|
|
@@ -0,0 +1,23590 @@
|
|
|
+/*
|
|
|
+ Nuklear - 1.40.0 - public domain
|
|
|
+ no warrenty implied; use at your own risk.
|
|
|
+ authored from 2015-2017 by Micha Mettke
|
|
|
+
|
|
|
+ABOUT:
|
|
|
+ This is a minimal state graphical user interface single header toolkit
|
|
|
+ written in ANSI C and licensed under public domain.
|
|
|
+ It was designed as a simple embeddable user interface for application and does
|
|
|
+ not have any dependencies, a default renderbackend or OS window and input handling
|
|
|
+ but instead provides a very modular library approach by using simple input state
|
|
|
+ for input and draw commands describing primitive shapes as output.
|
|
|
+ So instead of providing a layered library that tries to abstract over a number
|
|
|
+ of platform and render backends it only focuses on the actual UI.
|
|
|
+
|
|
|
+VALUES:
|
|
|
+ - Graphical user interface toolkit
|
|
|
+ - Single header library
|
|
|
+ - Written in C89 (a.k.a. ANSI C or ISO C90)
|
|
|
+ - Small codebase (~17kLOC)
|
|
|
+ - Focus on portability, efficiency and simplicity
|
|
|
+ - No dependencies (not even the standard library if not wanted)
|
|
|
+ - Fully skinnable and customizable
|
|
|
+ - Low memory footprint with total memory control if needed or wanted
|
|
|
+ - UTF-8 support
|
|
|
+ - No global or hidden state
|
|
|
+ - Customizable library modules (you can compile and use only what you need)
|
|
|
+ - Optional font baker and vertex buffer output
|
|
|
+
|
|
|
+USAGE:
|
|
|
+ This library is self contained in one single header file and can be used either
|
|
|
+ in header only mode or in implementation mode. The header only mode is used
|
|
|
+ by default when included and allows including this header in other headers
|
|
|
+ and does not contain the actual implementation.
|
|
|
+
|
|
|
+ The implementation mode requires to define the preprocessor macro
|
|
|
+ NK_IMPLEMENTATION in *one* .c/.cpp file before #includeing this file, e.g.:
|
|
|
+
|
|
|
+ #define NK_IMPLEMENTATION
|
|
|
+ #include "nuklear.h"
|
|
|
+
|
|
|
+ Also optionally define the symbols listed in the section "OPTIONAL DEFINES"
|
|
|
+ below in header and implementation mode if you want to use additional functionality
|
|
|
+ or need more control over the library.
|
|
|
+ IMPORTANT: Every time you include "nuklear.h" you have to define the same flags.
|
|
|
+ This is very important not doing it either leads to compiler errors
|
|
|
+ or even worse stack corruptions.
|
|
|
+
|
|
|
+FEATURES:
|
|
|
+ - Absolutely no platform dependend code
|
|
|
+ - Memory management control ranging from/to
|
|
|
+ - Ease of use by allocating everything from standard library
|
|
|
+ - Control every byte of memory inside the library
|
|
|
+ - Font handling control ranging from/to
|
|
|
+ - Use your own font implementation for everything
|
|
|
+ - Use this libraries internal font baking and handling API
|
|
|
+ - Drawing output control ranging from/to
|
|
|
+ - Simple shapes for more high level APIs which already have drawing capabilities
|
|
|
+ - Hardware accessible anti-aliased vertex buffer output
|
|
|
+ - Customizable colors and properties ranging from/to
|
|
|
+ - Simple changes to color by filling a simple color table
|
|
|
+ - Complete control with ability to use skinning to decorate widgets
|
|
|
+ - Bendable UI library with widget ranging from/to
|
|
|
+ - Basic widgets like buttons, checkboxes, slider, ...
|
|
|
+ - Advanced widget like abstract comboboxes, contextual menus,...
|
|
|
+ - Compile time configuration to only compile what you need
|
|
|
+ - Subset which can be used if you do not want to link or use the standard library
|
|
|
+ - Can be easily modified to only update on user input instead of frame updates
|
|
|
+
|
|
|
+OPTIONAL DEFINES:
|
|
|
+ NK_PRIVATE
|
|
|
+ If defined declares all functions as static, so they can only be accessed
|
|
|
+ inside the file that contains the implementation
|
|
|
+
|
|
|
+ NK_INCLUDE_FIXED_TYPES
|
|
|
+ If defined it will include header <stdint.h> for fixed sized types
|
|
|
+ otherwise nuklear tries to select the correct type. If that fails it will
|
|
|
+ throw a compiler error and you have to select the correct types yourself.
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+ if defined it will include header <stdlib.h> and provide additional functions
|
|
|
+ to use this library without caring for memory allocation control and therefore
|
|
|
+ ease memory management.
|
|
|
+ <!> Adds the standard library with malloc and free so don't define if you
|
|
|
+ don't want to link to the standard library <!>
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_STANDARD_IO
|
|
|
+ if defined it will include header <stdio.h> and provide
|
|
|
+ additional functions depending on file loading.
|
|
|
+ <!> Adds the standard library with fopen, fclose,... so don't define this
|
|
|
+ if you don't want to link to the standard library <!>
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_STANDARD_VARARGS
|
|
|
+ if defined it will include header <stdarg.h> and provide
|
|
|
+ additional functions depending on variable arguments
|
|
|
+ <!> Adds the standard library with va_list and so don't define this if
|
|
|
+ you don't want to link to the standard library<!>
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ Defining this adds a vertex draw command list backend to this
|
|
|
+ library, which allows you to convert queue commands into vertex draw commands.
|
|
|
+ This is mainly if you need a hardware accessible format for OpenGL, DirectX,
|
|
|
+ Vulkan, Metal,...
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_FONT_BAKING
|
|
|
+ Defining this adds `stb_truetype` and `stb_rect_pack` implementation
|
|
|
+ to this library and provides font baking and rendering.
|
|
|
+ If you already have font handling or do not want to use this font handler
|
|
|
+ you don't have to define it.
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_DEFAULT_FONT
|
|
|
+ Defining this adds the default font: ProggyClean.ttf into this library
|
|
|
+ which can be loaded into a font atlas and allows using this library without
|
|
|
+ having a truetype font
|
|
|
+ <!> Enabling this adds ~12kb to global stack memory <!>
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ Defining this adds a userdata pointer into each command. Can be useful for
|
|
|
+ example if you want to provide custom shaders depending on the used widget.
|
|
|
+ Can be combined with the style structures.
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_BUTTON_TRIGGER_ON_RELEASE
|
|
|
+ Different platforms require button clicks occuring either on buttons being
|
|
|
+ pressed (up to down) or released (down to up).
|
|
|
+ By default this library will react on buttons being pressed, but if you
|
|
|
+ define this it will only trigger if a button is released.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_ZERO_COMMAND_MEMORY
|
|
|
+ Defining this will zero out memory for each drawing command added to a
|
|
|
+ drawing queue (inside nk_command_buffer_push). Zeroing command memory
|
|
|
+ is very useful for fast checking (using memcmp) if command buffers are
|
|
|
+ equal and avoid drawing frames when nothing on screen has changed since
|
|
|
+ previous frame.
|
|
|
+
|
|
|
+ NK_ASSERT
|
|
|
+ If you don't define this, nuklear will use <assert.h> with assert().
|
|
|
+ <!> Adds the standard library so define to nothing of not wanted <!>
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_BUFFER_DEFAULT_INITIAL_SIZE
|
|
|
+ Initial buffer size allocated by all buffers while using the default allocator
|
|
|
+ functions included by defining NK_INCLUDE_DEFAULT_ALLOCATOR. If you don't
|
|
|
+ want to allocate the default 4k memory then redefine it.
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_MAX_NUMBER_BUFFER
|
|
|
+ Maximum buffer size for the conversion buffer between float and string
|
|
|
+ Under normal circumstances this should be more than sufficient.
|
|
|
+ <!> If used needs to be defined for implementation and header <!>
|
|
|
+
|
|
|
+ NK_INPUT_MAX
|
|
|
+ Defines the max number of bytes which can be added as text input in one frame.
|
|
|
+ Under normal circumstances this should be more than sufficient.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_MEMSET
|
|
|
+ You can define this to 'memset' or your own memset implementation
|
|
|
+ replacement. If not nuklear will use its own version.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_MEMCPY
|
|
|
+ You can define this to 'memcpy' or your own memcpy implementation
|
|
|
+ replacement. If not nuklear will use its own version.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_SQRT
|
|
|
+ You can define this to 'sqrt' or your own sqrt implementation
|
|
|
+ replacement. If not nuklear will use its own slow and not highly
|
|
|
+ accurate version.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_SIN
|
|
|
+ You can define this to 'sinf' or your own sine implementation
|
|
|
+ replacement. If not nuklear will use its own approximation implementation.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_COS
|
|
|
+ You can define this to 'cosf' or your own cosine implementation
|
|
|
+ replacement. If not nuklear will use its own approximation implementation.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_STRTOD
|
|
|
+ You can define this to `strtod` or your own string to double conversion
|
|
|
+ implementation replacement. If not defined nuklear will use its own
|
|
|
+ imprecise and possibly unsafe version (does not handle nan or infinity!).
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_DTOA
|
|
|
+ You can define this to `dtoa` or your own double to string conversion
|
|
|
+ implementation replacement. If not defined nuklear will use its own
|
|
|
+ imprecise and possibly unsafe version (does not handle nan or infinity!).
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_VSNPRINTF
|
|
|
+ If you define `NK_INCLUDE_STANDARD_VARARGS` as well as `NK_INCLUDE_STANDARD_IO`
|
|
|
+ and want to be safe define this to `vsnprintf` on compilers supporting
|
|
|
+ later versions of C or C++. By default nuklear will check for your stdlib version
|
|
|
+ in C as well as compiler version in C++. if `vsnprintf` is available
|
|
|
+ it will define it to `vsnprintf` directly. If not defined and if you have
|
|
|
+ older versions of C or C++ it will be defined to `vsprintf` which is unsafe.
|
|
|
+ <!> If used it is only required to be defined for the implementation part <!>
|
|
|
+
|
|
|
+ NK_BYTE
|
|
|
+ NK_INT16
|
|
|
+ NK_UINT16
|
|
|
+ NK_INT32
|
|
|
+ NK_UINT32
|
|
|
+ NK_SIZE_TYPE
|
|
|
+ NK_POINTER_TYPE
|
|
|
+ If you compile without NK_USE_FIXED_TYPE then a number of standard types
|
|
|
+ will be selected and compile time validated. If they are incorrect you can
|
|
|
+ define the correct types by overloading these type defines.
|
|
|
+
|
|
|
+CREDITS:
|
|
|
+ Developed by Micha Mettke and every direct or indirect contributor.
|
|
|
+
|
|
|
+ Embeds stb_texedit, stb_truetype and stb_rectpack by Sean Barret (public domain)
|
|
|
+ Embeds ProggyClean.ttf font by Tristan Grimmer (MIT license).
|
|
|
+
|
|
|
+ Big thank you to Omar Cornut (ocornut@github) for his imgui library and
|
|
|
+ giving me the inspiration for this library, Casey Muratori for handmade hero
|
|
|
+ and his original immediate mode graphical user interface idea and Sean
|
|
|
+ Barret for his amazing single header libraries which restored my faith
|
|
|
+ in libraries and brought me to create some of my own.
|
|
|
+
|
|
|
+LICENSE:
|
|
|
+ This software is dual-licensed to the public domain and under the following
|
|
|
+ license: you are granted a perpetual, irrevocable license to copy, modify,
|
|
|
+ publish and distribute this file as you see fit.
|
|
|
+*/
|
|
|
+#ifndef NK_NUKLEAR_H_
|
|
|
+#define NK_NUKLEAR_H_
|
|
|
+
|
|
|
+#ifdef __cplusplus
|
|
|
+extern "C" {
|
|
|
+#endif
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * CONSTANTS
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#define NK_UNDEFINED (-1.0f)
|
|
|
+#define NK_UTF_INVALID 0xFFFD /* internal invalid utf8 rune */
|
|
|
+#define NK_UTF_SIZE 4 /* describes the number of bytes a glyph consists of*/
|
|
|
+#ifndef NK_INPUT_MAX
|
|
|
+#define NK_INPUT_MAX 16
|
|
|
+#endif
|
|
|
+#ifndef NK_MAX_NUMBER_BUFFER
|
|
|
+#define NK_MAX_NUMBER_BUFFER 64
|
|
|
+#endif
|
|
|
+#ifndef NK_SCROLLBAR_HIDING_TIMEOUT
|
|
|
+#define NK_SCROLLBAR_HIDING_TIMEOUT 4.0f
|
|
|
+#endif
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * HELPER
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#ifndef NK_API
|
|
|
+ #ifdef NK_PRIVATE
|
|
|
+ #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199409L))
|
|
|
+ #define NK_API static inline
|
|
|
+ #elif defined(__cplusplus)
|
|
|
+ #define NK_API static inline
|
|
|
+ #else
|
|
|
+ #define NK_API static
|
|
|
+ #endif
|
|
|
+ #else
|
|
|
+ #define NK_API extern
|
|
|
+ #endif
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_INTERN static
|
|
|
+#define NK_STORAGE static
|
|
|
+#define NK_GLOBAL static
|
|
|
+
|
|
|
+#define NK_FLAG(x) (1 << (x))
|
|
|
+#define NK_STRINGIFY(x) #x
|
|
|
+#define NK_MACRO_STRINGIFY(x) NK_STRINGIFY(x)
|
|
|
+#define NK_STRING_JOIN_IMMEDIATE(arg1, arg2) arg1 ## arg2
|
|
|
+#define NK_STRING_JOIN_DELAY(arg1, arg2) NK_STRING_JOIN_IMMEDIATE(arg1, arg2)
|
|
|
+#define NK_STRING_JOIN(arg1, arg2) NK_STRING_JOIN_DELAY(arg1, arg2)
|
|
|
+
|
|
|
+#ifdef _MSC_VER
|
|
|
+#define NK_UNIQUE_NAME(name) NK_STRING_JOIN(name,__COUNTER__)
|
|
|
+#else
|
|
|
+#define NK_UNIQUE_NAME(name) NK_STRING_JOIN(name,__LINE__)
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_STATIC_ASSERT
|
|
|
+#define NK_STATIC_ASSERT(exp) typedef char NK_UNIQUE_NAME(_dummy_array)[(exp)?1:-1]
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_FILE_LINE
|
|
|
+#ifdef _MSC_VER
|
|
|
+#define NK_FILE_LINE __FILE__ ":" NK_MACRO_STRINGIFY(__COUNTER__)
|
|
|
+#else
|
|
|
+#define NK_FILE_LINE __FILE__ ":" NK_MACRO_STRINGIFY(__LINE__)
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_MIN(a,b) ((a) < (b) ? (a) : (b))
|
|
|
+#define NK_MAX(a,b) ((a) < (b) ? (b) : (a))
|
|
|
+#define NK_CLAMP(i,v,x) (NK_MAX(NK_MIN(v,x), i))
|
|
|
+/*
|
|
|
+ * ===============================================================
|
|
|
+ *
|
|
|
+ * BASIC
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#ifdef NK_INCLUDE_FIXED_TYPES
|
|
|
+ #include <stdint.h>
|
|
|
+ #define NK_INT8 int8_t
|
|
|
+ #define NK_UINT8 uint8_t
|
|
|
+ #define NK_INT16 int16_t
|
|
|
+ #define NK_UINT16 uint16_t
|
|
|
+ #define NK_INT32 int32_t
|
|
|
+ #define NK_UINT32 uint32_t
|
|
|
+ #define NK_SIZE_TYPE uintptr_t
|
|
|
+ #define NK_POINTER_TYPE uintptr_t
|
|
|
+#else
|
|
|
+ #ifndef NK_INT8
|
|
|
+ #define NK_INT8 char
|
|
|
+ #endif
|
|
|
+ #ifndef NK_UINT8
|
|
|
+ #define NK_UINT8 unsigned char
|
|
|
+ #endif
|
|
|
+ #ifndef NK_INT16
|
|
|
+ #define NK_INT16 signed short
|
|
|
+ #endif
|
|
|
+ #ifndef NK_UINT16
|
|
|
+ #define NK_UINT16 unsigned short
|
|
|
+ #endif
|
|
|
+ #ifndef NK_INT32
|
|
|
+ #if defined(_MSC_VER)
|
|
|
+ #define NK_INT32 __int32
|
|
|
+ #else
|
|
|
+ #define NK_INT32 signed int
|
|
|
+ #endif
|
|
|
+ #endif
|
|
|
+ #ifndef NK_UINT32
|
|
|
+ #if defined(_MSC_VER)
|
|
|
+ #define NK_UINT32 unsigned __int32
|
|
|
+ #else
|
|
|
+ #define NK_UINT32 unsigned int
|
|
|
+ #endif
|
|
|
+ #endif
|
|
|
+ #ifndef NK_SIZE_TYPE
|
|
|
+ #if defined(_WIN64) && defined(_MSC_VER)
|
|
|
+ #define NK_SIZE_TYPE unsigned __int64
|
|
|
+ #elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
|
|
|
+ #define NK_SIZE_TYPE unsigned __int32
|
|
|
+ #elif defined(__GNUC__) || defined(__clang__)
|
|
|
+ #if defined(__x86_64__) || defined(__ppc64__)
|
|
|
+ #define NK_SIZE_TYPE unsigned long
|
|
|
+ #else
|
|
|
+ #define NK_SIZE_TYPE unsigned int
|
|
|
+ #endif
|
|
|
+ #else
|
|
|
+ #define NK_SIZE_TYPE unsigned long
|
|
|
+ #endif
|
|
|
+ #endif
|
|
|
+ #ifndef NK_POINTER_TYPE
|
|
|
+ #if defined(_WIN64) && defined(_MSC_VER)
|
|
|
+ #define NK_POINTER_TYPE unsigned __int64
|
|
|
+ #elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
|
|
|
+ #define NK_POINTER_TYPE unsigned __int32
|
|
|
+ #elif defined(__GNUC__) || defined(__clang__)
|
|
|
+ #if defined(__x86_64__) || defined(__ppc64__)
|
|
|
+ #define NK_POINTER_TYPE unsigned long
|
|
|
+ #else
|
|
|
+ #define NK_POINTER_TYPE unsigned int
|
|
|
+ #endif
|
|
|
+ #else
|
|
|
+ #define NK_POINTER_TYPE unsigned long
|
|
|
+ #endif
|
|
|
+ #endif
|
|
|
+#endif
|
|
|
+
|
|
|
+typedef NK_INT8 nk_char;
|
|
|
+typedef NK_UINT8 nk_uchar;
|
|
|
+typedef NK_UINT8 nk_byte;
|
|
|
+typedef NK_INT16 nk_short;
|
|
|
+typedef NK_UINT16 nk_ushort;
|
|
|
+typedef NK_INT32 nk_int;
|
|
|
+typedef NK_UINT32 nk_uint;
|
|
|
+typedef NK_SIZE_TYPE nk_size;
|
|
|
+typedef NK_POINTER_TYPE nk_ptr;
|
|
|
+
|
|
|
+typedef nk_uint nk_hash;
|
|
|
+typedef nk_uint nk_flags;
|
|
|
+typedef nk_uint nk_rune;
|
|
|
+
|
|
|
+/* Make sure correct type size:
|
|
|
+ * This will fire with a negative subscript error if the type sizes
|
|
|
+ * are set incorrectly by the compiler, and compile out if not */
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_short) == 2);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_ushort) == 2);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_uint) == 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_int) == 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_byte) == 1);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_flags) >= 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_rune) >= 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*));
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_ptr) >= sizeof(void*));
|
|
|
+
|
|
|
+/* ============================================================================
|
|
|
+ *
|
|
|
+ * API
|
|
|
+ *
|
|
|
+ * =========================================================================== */
|
|
|
+struct nk_buffer;
|
|
|
+struct nk_allocator;
|
|
|
+struct nk_command_buffer;
|
|
|
+struct nk_draw_command;
|
|
|
+struct nk_convert_config;
|
|
|
+struct nk_style_item;
|
|
|
+struct nk_text_edit;
|
|
|
+struct nk_draw_list;
|
|
|
+struct nk_user_font;
|
|
|
+struct nk_panel;
|
|
|
+struct nk_context;
|
|
|
+struct nk_draw_vertex_layout_element;
|
|
|
+struct nk_style_button;
|
|
|
+struct nk_style_toggle;
|
|
|
+struct nk_style_selectable;
|
|
|
+struct nk_style_slide;
|
|
|
+struct nk_style_progress;
|
|
|
+struct nk_style_scrollbar;
|
|
|
+struct nk_style_edit;
|
|
|
+struct nk_style_property;
|
|
|
+struct nk_style_chart;
|
|
|
+struct nk_style_combo;
|
|
|
+struct nk_style_tab;
|
|
|
+struct nk_style_window_header;
|
|
|
+struct nk_style_window;
|
|
|
+
|
|
|
+enum {nk_false, nk_true};
|
|
|
+struct nk_color {nk_byte r,g,b,a;};
|
|
|
+struct nk_colorf {float r,g,b,a;};
|
|
|
+struct nk_vec2 {float x,y;};
|
|
|
+struct nk_vec2i {short x, y;};
|
|
|
+struct nk_rect {float x,y,w,h;};
|
|
|
+struct nk_recti {short x,y,w,h;};
|
|
|
+typedef char nk_glyph[NK_UTF_SIZE];
|
|
|
+typedef union {void *ptr; int id;} nk_handle;
|
|
|
+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;};
|
|
|
+
|
|
|
+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};
|
|
|
+enum nk_orientation {NK_VERTICAL, NK_HORIZONTAL};
|
|
|
+enum nk_collapse_states {NK_MINIMIZED = nk_false, NK_MAXIMIZED = nk_true};
|
|
|
+enum nk_show_states {NK_HIDDEN = nk_false, NK_SHOWN = nk_true};
|
|
|
+enum nk_chart_type {NK_CHART_LINES, NK_CHART_COLUMN, NK_CHART_MAX};
|
|
|
+enum nk_chart_event {NK_CHART_HOVERING = 0x01, NK_CHART_CLICKED = 0x02};
|
|
|
+enum nk_color_format {NK_RGB, NK_RGBA};
|
|
|
+enum nk_popup_type {NK_POPUP_STATIC, NK_POPUP_DYNAMIC};
|
|
|
+enum nk_layout_format {NK_DYNAMIC, NK_STATIC};
|
|
|
+enum nk_tree_type {NK_TREE_NODE, NK_TREE_TAB};
|
|
|
+
|
|
|
+typedef void*(*nk_plugin_alloc)(nk_handle, void *old, nk_size);
|
|
|
+typedef void (*nk_plugin_free)(nk_handle, void *old);
|
|
|
+typedef int(*nk_plugin_filter)(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+typedef void(*nk_plugin_paste)(nk_handle, struct nk_text_edit*);
|
|
|
+typedef void(*nk_plugin_copy)(nk_handle, const char*, int len);
|
|
|
+
|
|
|
+struct nk_allocator {
|
|
|
+ nk_handle userdata;
|
|
|
+ nk_plugin_alloc alloc;
|
|
|
+ nk_plugin_free free;
|
|
|
+};
|
|
|
+enum nk_symbol_type {
|
|
|
+ NK_SYMBOL_NONE,
|
|
|
+ NK_SYMBOL_X,
|
|
|
+ NK_SYMBOL_UNDERSCORE,
|
|
|
+ NK_SYMBOL_CIRCLE_SOLID,
|
|
|
+ NK_SYMBOL_CIRCLE_OUTLINE,
|
|
|
+ NK_SYMBOL_RECT_SOLID,
|
|
|
+ NK_SYMBOL_RECT_OUTLINE,
|
|
|
+ NK_SYMBOL_TRIANGLE_UP,
|
|
|
+ NK_SYMBOL_TRIANGLE_DOWN,
|
|
|
+ NK_SYMBOL_TRIANGLE_LEFT,
|
|
|
+ NK_SYMBOL_TRIANGLE_RIGHT,
|
|
|
+ NK_SYMBOL_PLUS,
|
|
|
+ NK_SYMBOL_MINUS,
|
|
|
+ NK_SYMBOL_MAX
|
|
|
+};
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * CONTEXT
|
|
|
+ *
|
|
|
+ * =============================================================================*/
|
|
|
+/* Contexts are the main entry point and the majestro of nuklear and contain all required state.
|
|
|
+ * They are used for window, memory, input, style, stack, commands and time management and need
|
|
|
+ * to be passed into all nuklear GUI specific functions.
|
|
|
+ *
|
|
|
+ * Usage
|
|
|
+ * -------------------
|
|
|
+ * To use a context it first has to be initialized which can be achieved by calling
|
|
|
+ * one of either `nk_init_default`, `nk_init_fixed`, `nk_init`, `nk_init_custom`.
|
|
|
+ * Each takes in a font handle and a specific way of handling memory. Memory control
|
|
|
+ * hereby ranges from standard library to just specifing a fixed sized block of memory
|
|
|
+ * which nuklear has to manage itself from.
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * nk_init_xxx(&ctx, ...);
|
|
|
+ * while (1) {
|
|
|
+ * [...]
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * Reference
|
|
|
+ * -------------------
|
|
|
+ * nk_init_default - Initializes context with standard library memory alloction (malloc,free)
|
|
|
+ * nk_init_fixed - Initializes context from single fixed size memory block
|
|
|
+ * nk_init - Initializes context with memory allocator callbacks for alloc and free
|
|
|
+ * nk_init_custom - Initializes context from two buffers. One for draw commands the other for window/panel/table allocations
|
|
|
+ * nk_clear - Called at the end of the frame to reset and prepare the context for the next frame
|
|
|
+ * nk_free - Shutdown and free all memory allocated inside the context
|
|
|
+ * nk_set_user_data - Utility function to pass user data to draw command
|
|
|
+ */
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+/* nk_init_default - Initializes a `nk_context` struct with a default standard library allocator.
|
|
|
+ * Should be used if you don't want to be bothered with memory management in nuklear.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an either stack or heap allocated `nk_context` struct
|
|
|
+ * @font must point to a previously initialized font handle for more info look at font documentation
|
|
|
+ * Return values:
|
|
|
+ * true(1) on success
|
|
|
+ * false(0) on failure */
|
|
|
+NK_API int nk_init_default(struct nk_context*, const struct nk_user_font*);
|
|
|
+#endif
|
|
|
+/* nk_init_fixed - Initializes a `nk_context` struct from a single fixed size memory block
|
|
|
+ * Should be used if you want complete control over nuklears memory management.
|
|
|
+ * Especially recommended for system with little memory or systems with virtual memory.
|
|
|
+ * For the later case you can just allocate for example 16MB of virtual memory
|
|
|
+ * and only the required amount of memory will actually be commited.
|
|
|
+ * IMPORTANT: make sure the passed memory block is aligned correctly for `nk_draw_commands`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an either stack or heap allocated `nk_context` struct
|
|
|
+ * @memory must point to a previously allocated memory block
|
|
|
+ * @size must contain the total size of @memory
|
|
|
+ * @font must point to a previously initialized font handle for more info look at font documentation
|
|
|
+ * Return values:
|
|
|
+ * true(1) on success
|
|
|
+ * false(0) on failure */
|
|
|
+NK_API int nk_init_fixed(struct nk_context*, void *memory, nk_size size, const struct nk_user_font*);
|
|
|
+/* nk_init - Initializes a `nk_context` struct with memory allocation callbacks for nuklear to allocate
|
|
|
+ * memory from. Used internally for `nk_init_default` and provides a kitchen sink allocation
|
|
|
+ * interface to nuklear. Can be useful for cases like monitoring memory consumption.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an either stack or heap allocated `nk_context` struct
|
|
|
+ * @alloc must point to a previously allocated memory allocator
|
|
|
+ * @font must point to a previously initialized font handle for more info look at font documentation
|
|
|
+ * Return values:
|
|
|
+ * true(1) on success
|
|
|
+ * false(0) on failure */
|
|
|
+NK_API int nk_init(struct nk_context*, struct nk_allocator*, const struct nk_user_font*);
|
|
|
+/* nk_init_custom - Initializes a `nk_context` struct from two different either fixed or growing
|
|
|
+ * buffers. The first buffer is for allocating draw commands while the second buffer is
|
|
|
+ * used for allocating windows, panels and state tables.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an either stack or heap allocated `nk_context` struct
|
|
|
+ * @cmds must point to a previously initialized memory buffer either fixed or dynamic to store draw commands into
|
|
|
+ * @pool must point to a previously initialized memory buffer either fixed or dynamic to store windows, panels and tables
|
|
|
+ * @font must point to a previously initialized font handle for more info look at font documentation
|
|
|
+ * Return values:
|
|
|
+ * true(1) on success
|
|
|
+ * false(0) on failure */
|
|
|
+NK_API int nk_init_custom(struct nk_context*, struct nk_buffer *cmds, struct nk_buffer *pool, const struct nk_user_font*);
|
|
|
+/* nk_clear - Resets the context state at the end of the frame. This includes mostly
|
|
|
+ * garbage collector tasks like removing windows or table not called and therefore
|
|
|
+ * used anymore.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to a previously initialized `nk_context` struct */
|
|
|
+NK_API void nk_clear(struct nk_context*);
|
|
|
+/* nk_free - Frees all memory allocated by nuklear. Not needed if context was
|
|
|
+ * initialized with `nk_init_fixed`.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to a previously initialized `nk_context` struct */
|
|
|
+NK_API void nk_free(struct nk_context*);
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+/* nk_set_user_data - Sets the currently passed userdata passed down into each draw command.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to a previously initialized `nk_context` struct
|
|
|
+ * @data handle with either pointer or index to be passed into every draw commands */
|
|
|
+NK_API void nk_set_user_data(struct nk_context*, nk_handle handle);
|
|
|
+#endif
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * INPUT
|
|
|
+ *
|
|
|
+ * =============================================================================*/
|
|
|
+/* The input API is responsible for holding the current input state composed of
|
|
|
+ * mouse, key and text input states.
|
|
|
+ * It is worth noting that no direct os or window handling is done in nuklear.
|
|
|
+ * Instead all input state has to be provided by platform specific code. This in one hand
|
|
|
+ * expects more work from the user and complicates usage but on the other hand
|
|
|
+ * provides simple abstraction over a big number of platforms, libraries and other
|
|
|
+ * already provided functionality.
|
|
|
+ *
|
|
|
+ * Usage
|
|
|
+ * -------------------
|
|
|
+ * Input state needs to be provided to nuklear by first calling `nk_input_begin`
|
|
|
+ * which resets internal state like delta mouse position and button transistions.
|
|
|
+ * After `nk_input_begin` all current input state needs to be provided. This includes
|
|
|
+ * mouse motion, button and key pressed and released, text input and scrolling.
|
|
|
+ * Both event- or state-based input handling are supported by this API
|
|
|
+ * and should work without problems. Finally after all input state has been
|
|
|
+ * mirrored `nk_input_end` needs to be called to finish input process.
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * nk_init_xxx(&ctx, ...);
|
|
|
+ * while (1) {
|
|
|
+ * Event evt;
|
|
|
+ * nk_input_begin(&ctx);
|
|
|
+ * while (GetEvent(&evt)) {
|
|
|
+ * if (evt.type == MOUSE_MOVE)
|
|
|
+ * nk_input_motion(&ctx, evt.motion.x, evt.motion.y);
|
|
|
+ * else if (evt.type == ...) {
|
|
|
+ * ...
|
|
|
+ * }
|
|
|
+ * }
|
|
|
+ * nk_input_end(&ctx);
|
|
|
+ * [...]
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * Reference
|
|
|
+ * -------------------
|
|
|
+ * nk_input_begin - Begins the input mirroring process. Needs to be called before all other `nk_input_xxx` calls
|
|
|
+ * nk_input_motion - Mirrors mouse cursor position
|
|
|
+ * nk_input_key - Mirrors key state with either pressed or released
|
|
|
+ * nk_input_button - Mirrors mouse button state with either pressed or released
|
|
|
+ * nk_input_scroll - Mirrors mouse scroll values
|
|
|
+ * nk_input_char - Adds a single ASCII text character into an internal text buffer
|
|
|
+ * nk_input_glyph - Adds a single multi-byte UTF-8 character into an internal text buffer
|
|
|
+ * nk_input_unicode - Adds a single unicode rune into an internal text buffer
|
|
|
+ * nk_input_end - Ends the input mirroring process by calculating state changes. Don't call any `nk_input_xxx` function referenced above after this call
|
|
|
+ */
|
|
|
+enum nk_keys {
|
|
|
+ NK_KEY_NONE,
|
|
|
+ NK_KEY_SHIFT,
|
|
|
+ NK_KEY_CTRL,
|
|
|
+ NK_KEY_DEL,
|
|
|
+ NK_KEY_ENTER,
|
|
|
+ NK_KEY_TAB,
|
|
|
+ NK_KEY_BACKSPACE,
|
|
|
+ NK_KEY_COPY,
|
|
|
+ NK_KEY_CUT,
|
|
|
+ NK_KEY_PASTE,
|
|
|
+ NK_KEY_UP,
|
|
|
+ NK_KEY_DOWN,
|
|
|
+ NK_KEY_LEFT,
|
|
|
+ NK_KEY_RIGHT,
|
|
|
+ /* Shortcuts: text field */
|
|
|
+ NK_KEY_TEXT_INSERT_MODE,
|
|
|
+ NK_KEY_TEXT_REPLACE_MODE,
|
|
|
+ NK_KEY_TEXT_RESET_MODE,
|
|
|
+ NK_KEY_TEXT_LINE_START,
|
|
|
+ NK_KEY_TEXT_LINE_END,
|
|
|
+ NK_KEY_TEXT_START,
|
|
|
+ NK_KEY_TEXT_END,
|
|
|
+ NK_KEY_TEXT_UNDO,
|
|
|
+ NK_KEY_TEXT_REDO,
|
|
|
+ NK_KEY_TEXT_SELECT_ALL,
|
|
|
+ NK_KEY_TEXT_WORD_LEFT,
|
|
|
+ NK_KEY_TEXT_WORD_RIGHT,
|
|
|
+ /* Shortcuts: scrollbar */
|
|
|
+ NK_KEY_SCROLL_START,
|
|
|
+ NK_KEY_SCROLL_END,
|
|
|
+ NK_KEY_SCROLL_DOWN,
|
|
|
+ NK_KEY_SCROLL_UP,
|
|
|
+ NK_KEY_MAX
|
|
|
+};
|
|
|
+enum nk_buttons {
|
|
|
+ NK_BUTTON_LEFT,
|
|
|
+ NK_BUTTON_MIDDLE,
|
|
|
+ NK_BUTTON_RIGHT,
|
|
|
+ NK_BUTTON_DOUBLE,
|
|
|
+ NK_BUTTON_MAX
|
|
|
+};
|
|
|
+/* nk_input_begin - Begins the input mirroring process by resetting text, scroll
|
|
|
+ * mouse previous mouse position and movement as well as key state transistions,
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct */
|
|
|
+NK_API void nk_input_begin(struct nk_context*);
|
|
|
+/* nk_input_motion - Mirros current mouse position to nuklear
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @x must constain an integer describing the current mouse cursor x-position
|
|
|
+ * @y must constain an integer describing the current mouse cursor y-position */
|
|
|
+NK_API void nk_input_motion(struct nk_context*, int x, int y);
|
|
|
+/* nk_input_key - Mirros state of a specific key to nuklear
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @key must be any value specified in enum `nk_keys` that needs to be mirrored
|
|
|
+ * @down must be 0 for key is up and 1 for key is down */
|
|
|
+NK_API void nk_input_key(struct nk_context*, enum nk_keys, int down);
|
|
|
+/* nk_input_button - Mirros the state of a specific mouse button to nuklear
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @nk_buttons must be any value specified in enum `nk_buttons` that needs to be mirrored
|
|
|
+ * @x must constain an integer describing mouse cursor x-position on click up/down
|
|
|
+ * @y must constain an integer describing mouse cursor y-position on click up/down
|
|
|
+ * @down must be 0 for key is up and 1 for key is down */
|
|
|
+NK_API void nk_input_button(struct nk_context*, enum nk_buttons, int x, int y, int down);
|
|
|
+/* nk_input_char - Copies a single ASCII character into an internal text buffer
|
|
|
+ * This is basically a helper function to quickly push ASCII characters into
|
|
|
+ * nuklear. Note that you can only push up to NK_INPUT_MAX bytes into
|
|
|
+ * struct `nk_input` between `nk_input_begin` and `nk_input_end`.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @c must be a single ASCII character preferable one that can be printed */
|
|
|
+NK_API void nk_input_scroll(struct nk_context*, struct nk_vec2 val);
|
|
|
+/* nk_input_char - Copies a single ASCII character into an internal text buffer
|
|
|
+ * This is basically a helper function to quickly push ASCII characters into
|
|
|
+ * nuklear. Note that you can only push up to NK_INPUT_MAX bytes into
|
|
|
+ * struct `nk_input` between `nk_input_begin` and `nk_input_end`.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @c must be a single ASCII character preferable one that can be printed */
|
|
|
+NK_API void nk_input_char(struct nk_context*, char);
|
|
|
+/* nk_input_unicode - Converts a encoded unicode rune into UTF-8 and copies the result
|
|
|
+ * into an internal text buffer.
|
|
|
+ * Note that you can only push up to NK_INPUT_MAX bytes into
|
|
|
+ * struct `nk_input` between `nk_input_begin` and `nk_input_end`.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @glyph UTF-32 uncode codepoint */
|
|
|
+NK_API void nk_input_glyph(struct nk_context*, const nk_glyph);
|
|
|
+/* nk_input_unicode - Converts a unicode rune into UTF-8 and copies the result
|
|
|
+ * into an internal text buffer.
|
|
|
+ * Note that you can only push up to NK_INPUT_MAX bytes into
|
|
|
+ * struct `nk_input` between `nk_input_begin` and `nk_input_end`.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @glyph UTF-32 uncode codepoint */
|
|
|
+NK_API void nk_input_unicode(struct nk_context*, nk_rune);
|
|
|
+/* nk_input_end - End the input mirroring process by resetting mouse grabbing
|
|
|
+ * state to ensure the mouse cursor is not grabbed indefinitely.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct */
|
|
|
+NK_API void nk_input_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * DRAWING
|
|
|
+ *
|
|
|
+ * =============================================================================*/
|
|
|
+/* This library was designed to be render backend agnostic so it does
|
|
|
+ * not draw anything to screen directly. Instead all drawn shapes, widgets
|
|
|
+ * are made of, are buffered into memory and make up a command queue.
|
|
|
+ * Each frame therefore fills the command buffer with draw commands
|
|
|
+ * that then need to be executed by the user and his own render backend.
|
|
|
+ * After that the command buffer needs to be cleared and a new frame can be
|
|
|
+ * started. It is probably important to note that the command buffer is the main
|
|
|
+ * drawing API and the optional vertex buffer API only takes this format and
|
|
|
+ * converts it into a hardware accessible format.
|
|
|
+ *
|
|
|
+ * Usage
|
|
|
+ * -------------------
|
|
|
+ * To draw all draw commands accumulated over a frame you need your own render
|
|
|
+ * backend able to draw a number of 2D primitives. This includes at least
|
|
|
+ * filled and stroked rectangles, circles, text, lines, triangles and scissors.
|
|
|
+ * As soon as this criterion is met you can iterate over each draw command
|
|
|
+ * and execute each draw command in a interpreter like fashion:
|
|
|
+ *
|
|
|
+ * const struct nk_command *cmd = 0;
|
|
|
+ * nk_foreach(cmd, &ctx) {
|
|
|
+ * switch (cmd->type) {
|
|
|
+ * case NK_COMMAND_LINE:
|
|
|
+ * your_draw_line_function(...)
|
|
|
+ * break;
|
|
|
+ * case NK_COMMAND_RECT
|
|
|
+ * your_draw_rect_function(...)
|
|
|
+ * break;
|
|
|
+ * case ...:
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ *
|
|
|
+ * In program flow context draw commands need to be executed after input has been
|
|
|
+ * gathered and the complete UI with windows and their contained widgets have
|
|
|
+ * been executed and before calling `nk_clear` which frees all previously
|
|
|
+ * allocated draw commands.
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * nk_init_xxx(&ctx, ...);
|
|
|
+ * while (1) {
|
|
|
+ * Event evt;
|
|
|
+ * nk_input_begin(&ctx);
|
|
|
+ * while (GetEvent(&evt)) {
|
|
|
+ * if (evt.type == MOUSE_MOVE)
|
|
|
+ * nk_input_motion(&ctx, evt.motion.x, evt.motion.y);
|
|
|
+ * else if (evt.type == [...]) {
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * }
|
|
|
+ * nk_input_end(&ctx);
|
|
|
+ *
|
|
|
+ * [...]
|
|
|
+ *
|
|
|
+ * const struct nk_command *cmd = 0;
|
|
|
+ * nk_foreach(cmd, &ctx) {
|
|
|
+ * switch (cmd->type) {
|
|
|
+ * case NK_COMMAND_LINE:
|
|
|
+ * your_draw_line_function(...)
|
|
|
+ * break;
|
|
|
+ * case NK_COMMAND_RECT
|
|
|
+ * your_draw_rect_function(...)
|
|
|
+ * break;
|
|
|
+ * case ...:
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * You probably noticed that you have to draw all of the UI each frame which is
|
|
|
+ * quite wasteful. While the actual UI updating loop is quite fast rendering
|
|
|
+ * without actually needing it is not. So there are multiple things you could do.
|
|
|
+ *
|
|
|
+ * First is only update on input. This of course is only an option if your
|
|
|
+ * application only depends on the UI and does not require any outside calculations.
|
|
|
+ * If you actually only update on input make sure to update the UI two times each
|
|
|
+ * frame and call `nk_clear` directly after the first pass and only draw in
|
|
|
+ * the second pass. In addition it is recommended to also add additional timers
|
|
|
+ * to make sure the UI is not drawn more than a fixed number of frames per second.
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * nk_init_xxx(&ctx, ...);
|
|
|
+ * while (1) {
|
|
|
+ * [...wait for input ]
|
|
|
+ *
|
|
|
+ * [...do two UI passes ...]
|
|
|
+ * do_ui(...)
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * do_ui(...)
|
|
|
+ *
|
|
|
+ * const struct nk_command *cmd = 0;
|
|
|
+ * nk_foreach(cmd, &ctx) {
|
|
|
+ * switch (cmd->type) {
|
|
|
+ * case NK_COMMAND_LINE:
|
|
|
+ * your_draw_line_function(...)
|
|
|
+ * break;
|
|
|
+ * case NK_COMMAND_RECT
|
|
|
+ * your_draw_rect_function(...)
|
|
|
+ * break;
|
|
|
+ * case ...:
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * The second probably more applicable trick is to only draw if anything changed.
|
|
|
+ * It is not really useful for applications with continous draw loop but
|
|
|
+ * quite useful for desktop applications. To actually get nuklear to only
|
|
|
+ * draw on changes you first have to define `NK_ZERO_COMMAND_MEMORY` and
|
|
|
+ * allocate a memory buffer that will store each unique drawing output.
|
|
|
+ * After each frame you compare the draw command memory inside the library
|
|
|
+ * with your allocated buffer by memcmp. If memcmp detects differences
|
|
|
+ * you have to copy the command buffer into the allocated buffer
|
|
|
+ * and then draw like usual (this example uses fixed memory but you could
|
|
|
+ * use dynamically allocated memory).
|
|
|
+ *
|
|
|
+ * [... other defines ...]
|
|
|
+ * #define NK_ZERO_COMMAND_MEMORY
|
|
|
+ * #include "nuklear.h"
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * void *last = calloc(1,64*1024);
|
|
|
+ * void *buf = calloc(1,64*1024);
|
|
|
+ * nk_init_fixed(&ctx, buf, 64*1024);
|
|
|
+ * while (1) {
|
|
|
+ * [...input...]
|
|
|
+ * [...ui...]
|
|
|
+ *
|
|
|
+ * void *cmds = nk_buffer_memory(&ctx.memory);
|
|
|
+ * if (memcmp(cmds, last, ctx.memory.allocated)) {
|
|
|
+ * memcpy(last,cmds,ctx.memory.allocated);
|
|
|
+ * const struct nk_command *cmd = 0;
|
|
|
+ * nk_foreach(cmd, &ctx) {
|
|
|
+ * switch (cmd->type) {
|
|
|
+ * case NK_COMMAND_LINE:
|
|
|
+ * your_draw_line_function(...)
|
|
|
+ * break;
|
|
|
+ * case NK_COMMAND_RECT
|
|
|
+ * your_draw_rect_function(...)
|
|
|
+ * break;
|
|
|
+ * case ...:
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * }
|
|
|
+ * }
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * Finally while using draw commands makes sense for higher abstracted platforms like
|
|
|
+ * X11 and Win32 or drawing libraries it is often desirable to use graphics
|
|
|
+ * hardware directly. Therefore it is possible to just define
|
|
|
+ * `NK_INCLUDE_VERTEX_BUFFER_OUTPUT` which includes optional vertex output.
|
|
|
+ * To access the vertex output you first have to convert all draw commands into
|
|
|
+ * vertexes by calling `nk_convert` which takes in your prefered vertex format.
|
|
|
+ * After successfully converting all draw commands just iterate over and execute all
|
|
|
+ * vertex draw commands:
|
|
|
+ *
|
|
|
+ * struct nk_convert_config cfg = {};
|
|
|
+ * static const struct nk_draw_vertex_layout_element vertex_layout[] = {
|
|
|
+ * {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct your_vertex, pos)},
|
|
|
+ * {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct your_vertex, uv)},
|
|
|
+ * {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct your_vertex, col)},
|
|
|
+ * {NK_VERTEX_LAYOUT_END}
|
|
|
+ * };
|
|
|
+ * cfg.shape_AA = NK_ANTI_ALIASING_ON;
|
|
|
+ * cfg.line_AA = NK_ANTI_ALIASING_ON;
|
|
|
+ * cfg.vertex_layout = vertex_layout;
|
|
|
+ * cfg.vertex_size = sizeof(struct your_vertex);
|
|
|
+ * cfg.vertex_alignment = NK_ALIGNOF(struct your_vertex);
|
|
|
+ * cfg.circle_segment_count = 22;
|
|
|
+ * cfg.curve_segment_count = 22;
|
|
|
+ * cfg.arc_segment_count = 22;
|
|
|
+ * cfg.global_alpha = 1.0f;
|
|
|
+ * cfg.null = dev->null;
|
|
|
+ *
|
|
|
+ * struct nk_buffer cmds, verts, idx;
|
|
|
+ * nk_buffer_init_default(&cmds);
|
|
|
+ * nk_buffer_init_default(&verts);
|
|
|
+ * nk_buffer_init_default(&idx);
|
|
|
+ * nk_convert(&ctx, &cmds, &verts, &idx, &cfg);
|
|
|
+ * nk_draw_foreach(cmd, &ctx, &cmds) {
|
|
|
+ * if (!cmd->elem_count) continue;
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * nk_buffer_free(&cms);
|
|
|
+ * nk_buffer_free(&verts);
|
|
|
+ * nk_buffer_free(&idx);
|
|
|
+ *
|
|
|
+ * Reference
|
|
|
+ * -------------------
|
|
|
+ * nk__begin - Returns the first draw command in the context draw command list to be drawn
|
|
|
+ * nk__next - Increments the draw command iterator to the next command inside the context draw command list
|
|
|
+ * nk_foreach - Iteratates over each draw command inside the context draw command list
|
|
|
+ *
|
|
|
+ * nk_convert - Converts from the abstract draw commands list into a hardware accessable vertex format
|
|
|
+ * nk__draw_begin - Returns the first vertex command in the context vertex draw list to be executed
|
|
|
+ * nk__draw_next - Increments the vertex command iterator to the next command inside the context vertex command list
|
|
|
+ * nk__draw_end - Returns the end of the vertex draw list
|
|
|
+ * nk_draw_foreach - Iterates over each vertex draw command inside the vertex draw list
|
|
|
+ */
|
|
|
+enum nk_anti_aliasing {NK_ANTI_ALIASING_OFF, NK_ANTI_ALIASING_ON};
|
|
|
+enum nk_convert_result {
|
|
|
+ NK_CONVERT_SUCCESS = 0,
|
|
|
+ NK_CONVERT_INVALID_PARAM = 1,
|
|
|
+ NK_CONVERT_COMMAND_BUFFER_FULL = NK_FLAG(1),
|
|
|
+ NK_CONVERT_VERTEX_BUFFER_FULL = NK_FLAG(2),
|
|
|
+ NK_CONVERT_ELEMENT_BUFFER_FULL = NK_FLAG(3)
|
|
|
+};
|
|
|
+struct nk_draw_null_texture {
|
|
|
+ nk_handle texture; /* texture handle to a texture with a white pixel */
|
|
|
+ struct nk_vec2 uv; /* coordinates to a white pixel in the texture */
|
|
|
+};
|
|
|
+struct nk_convert_config {
|
|
|
+ float global_alpha; /* global alpha value */
|
|
|
+ enum nk_anti_aliasing line_AA; /* line anti-aliasing flag can be turned off if you are tight on memory */
|
|
|
+ enum nk_anti_aliasing shape_AA; /* shape anti-aliasing flag can be turned off if you are tight on memory */
|
|
|
+ unsigned circle_segment_count; /* number of segments used for circles: default to 22 */
|
|
|
+ unsigned arc_segment_count; /* number of segments used for arcs: default to 22 */
|
|
|
+ unsigned curve_segment_count; /* number of segments used for curves: default to 22 */
|
|
|
+ struct nk_draw_null_texture null; /* handle to texture with a white pixel for shape drawing */
|
|
|
+ const struct nk_draw_vertex_layout_element *vertex_layout; /* describes the vertex output format and packing */
|
|
|
+ nk_size vertex_size; /* sizeof one vertex for vertex packing */
|
|
|
+ nk_size vertex_alignment; /* vertex alignment: Can be optained by NK_ALIGNOF */
|
|
|
+};
|
|
|
+/* nk__begin - Returns a draw command list iterator to iterate all draw
|
|
|
+ * commands accumulated over one frame.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * Return values:
|
|
|
+ * draw command pointer pointing to the first command inside the draw command list */
|
|
|
+NK_API const struct nk_command* nk__begin(struct nk_context*);
|
|
|
+/* nk__next - Returns a draw command list iterator to iterate all draw
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * @cmd must point to an previously a draw command either returned by `nk__begin` or `nk__next`
|
|
|
+ * Return values:
|
|
|
+ * draw command pointer pointing to the next command inside the draw command list */
|
|
|
+NK_API const struct nk_command* nk__next(struct nk_context*, const struct nk_command*);
|
|
|
+/* nk_foreach - Iterates over each draw command inside the context draw command list
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * @cmd pointer initialized to NULL */
|
|
|
+#define nk_foreach(c, ctx) for((c) = nk__begin(ctx); (c) != 0; (c) = nk__next(ctx,c))
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+/* nk_convert - converts all internal draw command into vertex draw commands and fills
|
|
|
+ * three buffers with vertexes, vertex draw commands and vertex indicies. The vertex format
|
|
|
+ * as well as some other configuration values have to be configurated by filling out a
|
|
|
+ * `nk_convert_config` struct.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * @cmds must point to a previously initialized buffer to hold converted vertex draw commands
|
|
|
+ * @vertices must point to a previously initialized buffer to hold all produced verticies
|
|
|
+ * @elements must point to a previously initialized buffer to hold all procudes vertex indicies
|
|
|
+ * @config must point to a filled out `nk_config` struct to configure the conversion process
|
|
|
+ * Returns:
|
|
|
+ * returns NK_CONVERT_SUCCESS on success and a enum nk_convert_result error values if not */
|
|
|
+NK_API nk_flags nk_convert(struct nk_context*, struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements, const struct nk_convert_config*);
|
|
|
+/* nk__draw_begin - Returns a draw vertex command buffer iterator to iterate each the vertex draw command buffer
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * @buf must point to an previously by `nk_convert` filled out vertex draw command buffer
|
|
|
+ * Return values:
|
|
|
+ * vertex draw command pointer pointing to the first command inside the vertex draw command buffer */
|
|
|
+NK_API const struct nk_draw_command* nk__draw_begin(const struct nk_context*, const struct nk_buffer*);
|
|
|
+/* nk__draw_end - Returns the vertex draw command at the end of the vertex draw command buffer
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * @buf must point to an previously by `nk_convert` filled out vertex draw command buffer
|
|
|
+ * Return values:
|
|
|
+ * vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer */
|
|
|
+NK_API const struct nk_draw_command* nk__draw_end(const struct nk_context*, const struct nk_buffer*);
|
|
|
+/* nk__draw_next - Increments the the vertex draw command buffer iterator
|
|
|
+ * Parameters:
|
|
|
+ * @cmd must point to an previously either by `nk__draw_begin` or `nk__draw_next` returned vertex draw command
|
|
|
+ * @buf must point to an previously by `nk_convert` filled out vertex draw command buffer
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame
|
|
|
+ * Return values:
|
|
|
+ * vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer */
|
|
|
+NK_API const struct nk_draw_command* nk__draw_next(const struct nk_draw_command*, const struct nk_buffer*, const struct nk_context*);
|
|
|
+/* nk_draw_foreach - Iterates over each vertex draw command inside a vertex draw command buffer
|
|
|
+ * Parameters:
|
|
|
+ * @cmd nk_draw_command pointer set to NULL
|
|
|
+ * @buf must point to an previously by `nk_convert` filled out vertex draw command buffer
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct at the end of a frame */
|
|
|
+#define nk_draw_foreach(cmd,ctx, b) for((cmd)=nk__draw_begin(ctx, b); (cmd)!=0; (cmd)=nk__draw_next(cmd, b, ctx))
|
|
|
+#endif
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * WINDOW
|
|
|
+ *
|
|
|
+ * =============================================================================
|
|
|
+ * Windows are the main persistent state used inside nuklear and are life time
|
|
|
+ * controlled by simply "retouching" (i.e. calling) each window each frame.
|
|
|
+ * All widgets inside nuklear can only be added inside function pair `nk_begin_xxx`
|
|
|
+ * and `nk_end`. Calling any widgets outside these two functions will result in an
|
|
|
+ * assert in debug or no state change in release mode.
|
|
|
+ *
|
|
|
+ * Each window holds frame persistent state like position, size, flags, state tables,
|
|
|
+ * and some garbage collected internal persistent widget state. Each window
|
|
|
+ * is linked into a window stack list which determines the drawing and overlapping
|
|
|
+ * order. The topmost window thereby is the currently active window.
|
|
|
+ *
|
|
|
+ * To change window position inside the stack occurs either automatically by
|
|
|
+ * user input by being clicked on or programatically by calling `nk_window_focus`.
|
|
|
+ * Windows by default are visible unless explicitly being defined with flag
|
|
|
+ * `NK_WINDOW_HIDDEN`, the user clicked the close button on windows with flag
|
|
|
+ * `NK_WINDOW_CLOSABLE` or if a window was explicitly hidden by calling
|
|
|
+ * `nk_window_show`. To explicitly close and destroy a window call `nk_window_close`.
|
|
|
+ *
|
|
|
+ * Usage
|
|
|
+ * -------------------
|
|
|
+ * To create and keep a window you have to call one of the two `nk_begin_xxx`
|
|
|
+ * functions to start window declarations and `nk_end` at the end. Furthermore it
|
|
|
+ * is recommended to check the return value of `nk_begin_xxx` and only process
|
|
|
+ * widgets inside the window if the value is not 0. Either way you have to call
|
|
|
+ * `nk_end` at the end of window declarations. Furthmore do not attempt to
|
|
|
+ * nest `nk_begin_xxx` calls which will hopefully result in an assert or if not
|
|
|
+ * in a segmation fault.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * [... widgets ...]
|
|
|
+ * }
|
|
|
+ * nk_end(ctx);
|
|
|
+ *
|
|
|
+ * In the grand concept window and widget declarations need to occur after input
|
|
|
+ * handling and before drawing to screen. Not doing so can result in higher
|
|
|
+ * latency or at worst invalid behavior. Furthermore make sure that `nk_clear`
|
|
|
+ * is called at the end of the frame. While nuklears default platform backends
|
|
|
+ * already call `nk_clear` for you if you write your own backend not calling
|
|
|
+ * `nk_clear` can cause asserts or even worse undefined behavior.
|
|
|
+ *
|
|
|
+ * struct nk_context ctx;
|
|
|
+ * nk_init_xxx(&ctx, ...);
|
|
|
+ * while (1) {
|
|
|
+ * Event evt;
|
|
|
+ * nk_input_begin(&ctx);
|
|
|
+ * while (GetEvent(&evt)) {
|
|
|
+ * if (evt.type == MOUSE_MOVE)
|
|
|
+ * nk_input_motion(&ctx, evt.motion.x, evt.motion.y);
|
|
|
+ * else if (evt.type == [...]) {
|
|
|
+ * nk_input_xxx(...);
|
|
|
+ * }
|
|
|
+ * }
|
|
|
+ * nk_input_end(&ctx);
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * nk_end(ctx);
|
|
|
+ *
|
|
|
+ * const struct nk_command *cmd = 0;
|
|
|
+ * nk_foreach(cmd, &ctx) {
|
|
|
+ * case NK_COMMAND_LINE:
|
|
|
+ * your_draw_line_function(...)
|
|
|
+ * break;
|
|
|
+ * case NK_COMMAND_RECT
|
|
|
+ * your_draw_rect_function(...)
|
|
|
+ * break;
|
|
|
+ * case ...:
|
|
|
+ * [...]
|
|
|
+ * }
|
|
|
+ * nk_clear(&ctx);
|
|
|
+ * }
|
|
|
+ * nk_free(&ctx);
|
|
|
+ *
|
|
|
+ * Reference
|
|
|
+ * -------------------
|
|
|
+ * nk_begin - starts a new window; needs to be called every frame for every window (unless hidden) or otherwise the window gets removed
|
|
|
+ * nk_begin_titled - extended window start with seperated title and identifier to allow multiple windows with same name but not title
|
|
|
+ * nk_end - needs to be called at the end of the window building process to process scaling, scrollbars and general cleanup
|
|
|
+ *
|
|
|
+ * nk_window_find - finds and returns the window with give name
|
|
|
+ * nk_window_get_bounds - returns a rectangle with screen position and size of the currently processed window.
|
|
|
+ * nk_window_get_position - returns the position of the currently processed window
|
|
|
+ * nk_window_get_size - returns the size with width and height of the currently processed window
|
|
|
+ * nk_window_get_width - returns the width of the currently processed window
|
|
|
+ * nk_window_get_height - returns the height of the currently processed window
|
|
|
+ * nk_window_get_panel - returns the underlying panel which contains all processing state of the currnet window
|
|
|
+ * nk_window_get_content_region - returns the position and size of the currently visible and non-clipped space inside the currently processed window
|
|
|
+ * nk_window_get_content_region_min - returns the upper rectangle position of the currently visible and non-clipped space inside the currently processed window
|
|
|
+ * nk_window_get_content_region_max - returns the upper rectangle position of the currently visible and non-clipped space inside the currently processed window
|
|
|
+ * nk_window_get_content_region_size - returns the size of the currently visible and non-clipped space inside the currently processed window
|
|
|
+ * nk_window_get_canvas - returns the draw command buffer. Can be used to draw custom widgets
|
|
|
+ *
|
|
|
+ * nk_window_has_focus - returns if the currently processed window is currently active
|
|
|
+ * nk_window_is_collapsed - returns if the window with given name is currently minimized/collapsed
|
|
|
+ * nk_window_is_closed - returns if the currently processed window was closed
|
|
|
+ * nk_window_is_hidden - returns if the currently processed window was hidden
|
|
|
+ * nk_window_is_active - same as nk_window_has_focus for some reason
|
|
|
+ * nk_window_is_hovered - returns if the currently processed window is currently being hovered by mouse
|
|
|
+ * nk_window_is_any_hovered - return if any wndow currently hovered
|
|
|
+ * nk_item_is_any_active - returns if any window or widgets is currently hovered or active
|
|
|
+ *
|
|
|
+ * nk_window_set_bounds - updates position and size of the currently processed window
|
|
|
+ * nk_window_set_position - updates position of the currently process window
|
|
|
+ * nk_window_set_size - updates the size of the currently processed window
|
|
|
+ * nk_window_set_focus - set the currently processed window as active window
|
|
|
+ *
|
|
|
+ * nk_window_close - closes the window with given window name which deletes the window at the end of the frame
|
|
|
+ * nk_window_collapse - collapses the window with given window name
|
|
|
+ * nk_window_collapse_if - collapses the window with given window name if the given condition was met
|
|
|
+ * nk_window_show - hides a visible or reshows a hidden window
|
|
|
+ * nk_window_show_if - hides/shows a window depending on condition
|
|
|
+ */
|
|
|
+enum nk_panel_flags {
|
|
|
+ NK_WINDOW_BORDER = NK_FLAG(0), /* Draws a border around the window to visually separate window from the background */
|
|
|
+ NK_WINDOW_MOVABLE = NK_FLAG(1), /* The movable flag indicates that a window can be moved by user input or by dragging the window header */
|
|
|
+ NK_WINDOW_SCALABLE = NK_FLAG(2), /* The scalable flag indicates that a window can be scaled by user input by dragging a scaler icon at the button of the window */
|
|
|
+ NK_WINDOW_CLOSABLE = NK_FLAG(3), /* adds a closable icon into the header */
|
|
|
+ NK_WINDOW_MINIMIZABLE = NK_FLAG(4), /* adds a minimize icon into the header */
|
|
|
+ NK_WINDOW_NO_SCROLLBAR = NK_FLAG(5), /* Removes the scrollbar from the window */
|
|
|
+ NK_WINDOW_TITLE = NK_FLAG(6), /* Forces a header at the top at the window showing the title */
|
|
|
+ NK_WINDOW_SCROLL_AUTO_HIDE = NK_FLAG(7), /* Automatically hides the window scrollbar if no user interaction: also requires delta time in `nk_context` to be set each frame */
|
|
|
+ NK_WINDOW_BACKGROUND = NK_FLAG(8), /* Always keep window in the background */
|
|
|
+ NK_WINDOW_SCALE_LEFT = NK_FLAG(9), /* Puts window scaler in the left-ottom corner instead right-bottom*/
|
|
|
+ NK_WINDOW_NO_INPUT = NK_FLAG(10) /* Prevents window of scaling, moving or getting focus */
|
|
|
+};
|
|
|
+/* nk_begin - starts a new window; needs to be called every frame for every window (unless hidden) or otherwise the window gets removed
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @title window title and identifier. Needs to be persitent over frames to identify the window
|
|
|
+ * @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 `enum nk_panel_flags` with a number of different window behaviors
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if the window can be filled up with widgets from this point until `nk_end or 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_begin_titled - extended window start with seperated title and identifier to allow multiple windows with same name but not title
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name window identifier. Needs to be persitent over frames to identify the window
|
|
|
+ * @title window title displayed inside header if flag `NK_WINDOW_TITLE` or either `NK_WINDOW_CLOSABLE` or `NK_WINDOW_MINIMIZED` was set
|
|
|
+ * @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 `enum nk_panel_flags` with a number of different window behaviors
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if the window can be filled up with widgets from this point until `nk_end or 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_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
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct */
|
|
|
+NK_API void nk_end(struct nk_context *ctx);
|
|
|
+/* nk_window_find - finds and returns the window with give name
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name window identifier
|
|
|
+ * Return values:
|
|
|
+ * returns a `nk_window` struct pointing to the idified window or 0 if no window with given name was found */
|
|
|
+NK_API struct nk_window *nk_window_find(struct nk_context *ctx, const char *name);
|
|
|
+/* nk_window_get_bounds - returns a rectangle with screen position and size of the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns a `nk_rect` struct with window upper left position and size */
|
|
|
+NK_API struct nk_rect nk_window_get_bounds(const struct nk_context *ctx);
|
|
|
+/* nk_window_get_position - returns the position of the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns a `nk_vec2` struct with window upper left position */
|
|
|
+NK_API struct nk_vec2 nk_window_get_position(const struct nk_context *ctx);
|
|
|
+/* nk_window_get_size - returns the size with width and height of the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns a `nk_vec2` struct with window size */
|
|
|
+NK_API struct nk_vec2 nk_window_get_size(const struct nk_context*);
|
|
|
+/* nk_window_get_width - returns the width of the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns the window width */
|
|
|
+NK_API float nk_window_get_width(const struct nk_context*);
|
|
|
+/* nk_window_get_height - returns the height of the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns the window height */
|
|
|
+NK_API float nk_window_get_height(const struct nk_context*);
|
|
|
+/* nk_window_get_panel - returns the underlying panel which contains all processing state of the currnet window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns a pointer to window internal `nk_panel` state. DO NOT keep this pointer around it is only valid until `nk_end` */
|
|
|
+NK_API struct nk_panel* nk_window_get_panel(struct nk_context*);
|
|
|
+/* nk_window_get_content_region - returns the position and size of the currently visible and non-clipped space inside the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns `nk_rect` struct with screen position and size (no scrollbar offset) of the visible space inside the current window */
|
|
|
+NK_API struct nk_rect nk_window_get_content_region(struct nk_context*);
|
|
|
+/* nk_window_get_content_region_min - returns the upper left position of the currently visible and non-clipped space inside the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns `nk_vec2` struct with upper left screen position (no scrollbar offset) of the visible space inside the current window */
|
|
|
+NK_API struct nk_vec2 nk_window_get_content_region_min(struct nk_context*);
|
|
|
+/* nk_window_get_content_region_max - returns the lower right screen position of the currently visible and non-clipped space inside the currently processed window.
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns `nk_vec2` struct with lower right screen position (no scrollbar offset) of the visible space inside the current window */
|
|
|
+NK_API struct nk_vec2 nk_window_get_content_region_max(struct nk_context*);
|
|
|
+/* nk_window_get_content_region_size - returns the size of the currently visible and non-clipped space inside the currently processed window
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns `nk_vec2` struct with size the visible space inside the current window */
|
|
|
+NK_API struct nk_vec2 nk_window_get_content_region_size(struct nk_context*);
|
|
|
+/* nk_window_get_canvas - returns the draw command buffer. Can be used to draw custom widgets
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns a pointer to window internal `nk_command_buffer` struct used as drawing canvas. Can be used to do custom drawing */
|
|
|
+NK_API struct nk_command_buffer* nk_window_get_canvas(struct nk_context*);
|
|
|
+/* nk_window_has_focus - returns if the currently processed window is currently active
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns 0 if current window is not active or 1 if it is */
|
|
|
+NK_API int nk_window_has_focus(const struct nk_context*);
|
|
|
+/* nk_window_is_collapsed - returns if the window with given name is currently minimized/collapsed
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of window you want to check is collapsed
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if current window is minimized and 0 if window not found or is not minimized */
|
|
|
+NK_API int nk_window_is_collapsed(struct nk_context *ctx, const char *name);
|
|
|
+/* nk_window_is_closed - returns if the window with given name was closed by calling `nk_close`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of window you want to check is closed
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if current window was closed or 0 window not found or not closed */
|
|
|
+NK_API int nk_window_is_closed(struct nk_context*, const char*);
|
|
|
+/* nk_window_is_hidden - returns if the window with given name is hidden
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of window you want to check is hidden
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if current window is hidden or 0 window not found or visible */
|
|
|
+NK_API int nk_window_is_hidden(struct nk_context*, const char*);
|
|
|
+/* nk_window_is_active - same as nk_window_has_focus for some reason
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of window you want to check is hidden
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if current window is active or 0 window not found or not active */
|
|
|
+NK_API int nk_window_is_active(struct nk_context*, const char*);
|
|
|
+/* nk_window_is_hovered - return if the current window is being hovered
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if current window is hovered or 0 otherwise */
|
|
|
+NK_API int nk_window_is_hovered(struct nk_context*);
|
|
|
+/* nk_window_is_any_hovered - returns if the any window is being hovered
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if any window is hovered or 0 otherwise */
|
|
|
+NK_API int nk_window_is_any_hovered(struct nk_context*);
|
|
|
+/* nk_item_is_any_active - returns if the any window is being hovered or any widget is currently active.
|
|
|
+ * Can be used to decide if input should be processed by UI or your specific input handling.
|
|
|
+ * Example could be UI and 3D camera to move inside a 3D space.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * Return values:
|
|
|
+ * returns 1 if any window is hovered or any item is active or 0 otherwise */
|
|
|
+NK_API int nk_item_is_any_active(struct nk_context*);
|
|
|
+/* nk_window_set_bounds - updates position and size of the currently processed window
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @bounds points to a `nk_rect` struct with the new position and size of currently active window */
|
|
|
+NK_API void nk_window_set_bounds(struct nk_context*, struct nk_rect bounds);
|
|
|
+/* nk_window_set_position - updates position of the currently processed window
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @pos points to a `nk_vec2` struct with the new position of currently active window */
|
|
|
+NK_API void nk_window_set_position(struct nk_context*, struct nk_vec2 pos);
|
|
|
+/* nk_window_set_size - updates size of the currently processed window
|
|
|
+ * IMPORTANT: only call this function between calls `nk_begin_xxx` and `nk_end`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @bounds points to a `nk_vec2` struct with the new size of currently active window */
|
|
|
+NK_API void nk_window_set_size(struct nk_context*, struct nk_vec2);
|
|
|
+/* nk_window_set_focus - sets the window with given name as active
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be set active */
|
|
|
+NK_API void nk_window_set_focus(struct nk_context*, const char *name);
|
|
|
+/* nk_window_close - closed a window and marks it for being freed at the end of the frame
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be closed */
|
|
|
+NK_API void nk_window_close(struct nk_context *ctx, const char *name);
|
|
|
+/* nk_window_collapse - updates collapse state of a window with given name
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be either collapse or maximize */
|
|
|
+NK_API void nk_window_collapse(struct nk_context*, const char *name, enum nk_collapse_states state);
|
|
|
+/* nk_window_collapse - updates collapse state of a window with given name if given condition is met
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be either collapse or maximize
|
|
|
+ * @state the window should be put into
|
|
|
+ * @condition that has to be true to actually commit the collsage state change */
|
|
|
+NK_API void nk_window_collapse_if(struct nk_context*, const char *name, enum nk_collapse_states, int cond);
|
|
|
+/* nk_window_show - updates visibility state of a window with given name
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be either collapse or maximize
|
|
|
+ * @state with either visible or hidden to modify the window with */
|
|
|
+NK_API void nk_window_show(struct nk_context*, const char *name, enum nk_show_states);
|
|
|
+/* nk_window_show_if - updates visibility state of a window with given name if a given condition is met
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @name of the window to be either collapse or maximize
|
|
|
+ * @state with either visible or hidden to modify the window with
|
|
|
+ * @condition that has to be true to actually commit the visible state change */
|
|
|
+NK_API void nk_window_show_if(struct nk_context*, const char *name, enum nk_show_states, int cond);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * LAYOUT
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+/* Layouting in general describes placing widget inside a window with position and size.
|
|
|
+ * While in this particular implementation there are five different APIs for layouting
|
|
|
+ * each with different trade offs between control and ease of use.
|
|
|
+ *
|
|
|
+ * All layouting methodes in this library are based around the concept of a row.
|
|
|
+ * A row has a height the window content grows by and a number of columns and each
|
|
|
+ * layouting method specifies how each widget is placed inside the row.
|
|
|
+ * After a row has been allocated by calling a layouting functions and then
|
|
|
+ * filled with widgets will advance an internal pointer over the allocated row.
|
|
|
+ *
|
|
|
+ * To acually define a layout you just call the appropriate layouting function
|
|
|
+ * and each subsequnetial widget call will place the widget as specified. Important
|
|
|
+ * here is that if you define more widgets then columns defined inside the layout
|
|
|
+ * functions it will allocate the next row without you having to make another layouting
|
|
|
+ * call.
|
|
|
+ *
|
|
|
+ * Biggest limitation with using all these APIs outside the `nk_layout_space_xxx` API
|
|
|
+ * is that you have to define the row height for each. However the row height
|
|
|
+ * often depends on the height of the font.
|
|
|
+ *
|
|
|
+ * To fix that internally nuklear uses a minimum row height that is set to the
|
|
|
+ * height plus padding of currently active font and overwrites the row height
|
|
|
+ * value if zero.
|
|
|
+ *
|
|
|
+ * If you manually want to change the minimum row height then
|
|
|
+ * use nk_layout_set_min_row_height, and use nk_layout_reset_min_row_height to
|
|
|
+ * reset it back to be derived from font height.
|
|
|
+ *
|
|
|
+ * Also if you change the font in nuklear it will automatically change the minimum
|
|
|
+ * row height for you and. This means if you change the font but still want
|
|
|
+ * a minimum row height smaller than the font you have to repush your value.
|
|
|
+ *
|
|
|
+ * For actually more advanced UI I would even recommend using the `nk_layout_space_xxx`
|
|
|
+ * layouting method in combination with a cassowary constraint solver (there are
|
|
|
+ * some versions on github with permissive license model) to take over all control over widget
|
|
|
+ * layouting yourself. However for quick and dirty layouting using all the other layouting
|
|
|
+ * functions should be fine.
|
|
|
+ *
|
|
|
+ * Usage
|
|
|
+ * -------------------
|
|
|
+ * 1.) nk_layout_row_dynamic
|
|
|
+ * The easiest layouting function is `nk_layout_row_dynamic`. It provides each
|
|
|
+ * widgets with same horizontal space inside the row and dynamically grows
|
|
|
+ * if the owning window grows in width. So the number of columns dictates
|
|
|
+ * the size of each widget dynamically by formula:
|
|
|
+ *
|
|
|
+ * widget_width = (window_width - padding - spacing) * (1/colum_count)
|
|
|
+ *
|
|
|
+ * Just like all other layouting APIs if you define more widget than columns this
|
|
|
+ * library will allocate a new row and keep all layouting parameters previously
|
|
|
+ * defined.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // first row with height: 30 composed of two widgets
|
|
|
+ * nk_layout_row_dynamic(&ctx, 30, 2);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // second row with same parameter as defined above
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // third row uses 0 for height which will use auto layouting
|
|
|
+ * nk_layout_row_dynamic(&ctx, 0, 2);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * 2.) nk_layout_row_static
|
|
|
+ * Another easy layouting function is `nk_layout_row_static`. It provides each
|
|
|
+ * widget with same horizontal pixel width inside the row and does not grow
|
|
|
+ * if the owning window scales smaller or bigger.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // first row with height: 30 composed of two widgets with width: 80
|
|
|
+ * nk_layout_row_static(&ctx, 30, 80, 2);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // second row with same parameter as defined above
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // third row uses 0 for height which will use auto layouting
|
|
|
+ * nk_layout_row_static(&ctx, 0, 80, 2);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * 3.) nk_layout_row_xxx
|
|
|
+ * A little bit more advanced layouting API are functions `nk_layout_row_begin`,
|
|
|
+ * `nk_layout_row_push` and `nk_layout_row_end`. They allow to directly
|
|
|
+ * specify each column pixel or window ratio in a row. It supports either
|
|
|
+ * directly setting per column pixel width or widget window ratio but not
|
|
|
+ * both. Furthermore it is a immediate mode API so each value is directly
|
|
|
+ * pushed before calling a widget. Therefore the layout is not automatically
|
|
|
+ * repeating like the last two layouting functions.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // first row with height: 25 composed of two widgets with width 60 and 40
|
|
|
+ * nk_layout_row_begin(ctx, NK_STATIC, 25, 2);
|
|
|
+ * nk_layout_row_push(ctx, 60);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_push(ctx, 40);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_end(ctx);
|
|
|
+ *
|
|
|
+ * // second row with height: 25 composed of two widgets with window ratio 0.25 and 0.75
|
|
|
+ * nk_layout_row_begin(ctx, NK_DYNAMIC, 25, 2);
|
|
|
+ * nk_layout_row_push(ctx, 0.25f);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_push(ctx, 0.75f);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_end(ctx);
|
|
|
+ *
|
|
|
+ * // third row with auto generated height: composed of two widgets with window ratio 0.25 and 0.75
|
|
|
+ * nk_layout_row_begin(ctx, NK_DYNAMIC, 0, 2);
|
|
|
+ * nk_layout_row_push(ctx, 0.25f);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_push(ctx, 0.75f);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_row_end(ctx);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * 4.) nk_layout_row
|
|
|
+ * The array counterpart to API nk_layout_row_xxx is the single nk_layout_row
|
|
|
+ * functions. Instead of pushing either pixel or window ratio for every widget
|
|
|
+ * it allows to define it by array. The trade of for less control is that
|
|
|
+ * `nk_layout_row` is automatically repeating. Otherwise the behavior is the
|
|
|
+ * same.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // two rows with height: 30 composed of two widgets with width 60 and 40
|
|
|
+ * const float size[] = {60,40};
|
|
|
+ * nk_layout_row(ctx, NK_STATIC, 30, 2, ratio);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // two rows with height: 30 composed of two widgets with window ratio 0.25 and 0.75
|
|
|
+ * const float ratio[] = {0.25, 0.75};
|
|
|
+ * nk_layout_row(ctx, NK_DYNAMIC, 30, 2, ratio);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ *
|
|
|
+ * // two rows with auto generated height composed of two widgets with window ratio 0.25 and 0.75
|
|
|
+ * const float ratio[] = {0.25, 0.75};
|
|
|
+ * nk_layout_row(ctx, NK_DYNAMIC, 30, 2, ratio);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * 5.) nk_layout_row_template_xxx
|
|
|
+ * The most complex and second most flexible API is a simplified flexbox version without
|
|
|
+ * line wrapping and weights for dynamic widgets. It is an immediate mode API but
|
|
|
+ * unlike `nk_layout_row_xxx` it has auto repeat behavior and needs to be called
|
|
|
+ * before calling the templated widgets.
|
|
|
+ * The row template layout has three different per widget size specifier. The first
|
|
|
+ * one is the static widget size specifier with fixed widget pixel width. They do
|
|
|
+ * not grow if the row grows and will always stay the same. The second size
|
|
|
+ * specifier is nk_layout_row_template_push_variable which defines a
|
|
|
+ * minumum widget size but it also can grow if more space is available not taken
|
|
|
+ * by other widgets. Finally there are dynamic widgets which are completly flexible
|
|
|
+ * and unlike variable widgets can even shrink to zero if not enough space
|
|
|
+ * is provided.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // two rows with height: 30 composed of three widgets
|
|
|
+ * nk_layout_row_template_begin(ctx, 30);
|
|
|
+ * nk_layout_row_template_push_dynamic(ctx);
|
|
|
+ * nk_layout_row_template_push_variable(ctx, 80);
|
|
|
+ * nk_layout_row_template_push_static(ctx, 80);
|
|
|
+ * nk_layout_row_template_end(ctx);
|
|
|
+ *
|
|
|
+ * nk_widget(...); // dynamic widget can go to zero if not enough space
|
|
|
+ * nk_widget(...); // variable widget with min 80 pixel but can grow bigger if enough space
|
|
|
+ * nk_widget(...); // static widget with fixed 80 pixel width
|
|
|
+ *
|
|
|
+ * // second row same layout
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_widget(...);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * 6.) nk_layout_space_xxx
|
|
|
+ * Finally the most flexible API directly allows you to place widgets inside the
|
|
|
+ * window. The space layout API is an immediate mode API which does not support
|
|
|
+ * row auto repeat and directly sets position and size of a widget. Position
|
|
|
+ * and size hereby can be either specified as ratio of alloated space or
|
|
|
+ * allocated space local position and pixel size. Since this API is quite
|
|
|
+ * powerfull there are a number of utility functions to get the available space
|
|
|
+ * and convert between local allocated space and screen space.
|
|
|
+ *
|
|
|
+ * if (nk_begin_xxx(...) {
|
|
|
+ * // static row with height: 500 (you can set column count to INT_MAX if you don't want to be bothered)
|
|
|
+ * nk_layout_space_begin(ctx, NK_STATIC, 500, INT_MAX);
|
|
|
+ * nk_layout_space_push(ctx, nk_rect(0,0,150,200));
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_space_push(ctx, nk_rect(200,200,100,200));
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_space_end(ctx);
|
|
|
+ *
|
|
|
+ * // dynamic row with height: 500 (you can set column count to INT_MAX if you don't want to be bothered)
|
|
|
+ * nk_layout_space_begin(ctx, NK_DYNAMIC, 500, INT_MAX);
|
|
|
+ * nk_layout_space_push(ctx, nk_rect(0.5,0.5,0.1,0.1));
|
|
|
+ * nk_widget(...);
|
|
|
+ * nk_layout_space_push(ctx, nk_rect(0.7,0.6,0.1,0.1));
|
|
|
+ * nk_widget(...);
|
|
|
+ * }
|
|
|
+ * nk_end(...);
|
|
|
+ *
|
|
|
+ * Reference
|
|
|
+ * -------------------
|
|
|
+ * nk_layout_set_min_row_height - set the currently used minimum row height to a specified value
|
|
|
+ * nk_layout_reset_min_row_height - resets the currently used minimum row height to font height
|
|
|
+ *
|
|
|
+ * nk_layout_widget_bounds - calculates current width a static layout row can fit inside a window
|
|
|
+ * nk_layout_ratio_from_pixel - utility functions to calculate window ratio from pixel size
|
|
|
+ *
|
|
|
+ * nk_layout_row_dynamic - current layout is divided into n same sized gowing columns
|
|
|
+ * nk_layout_row_static - current layout is divided into n same fixed sized columns
|
|
|
+ * nk_layout_row_begin - starts a new row with given height and number of columns
|
|
|
+ * nk_layout_row_push - pushes another column with given size or window ratio
|
|
|
+ * nk_layout_row_end - finished previously started row
|
|
|
+ * nk_layout_row - specifies row columns in array as either window ratio or size
|
|
|
+ *
|
|
|
+ * nk_layout_row_template_begin - begins the row template declaration
|
|
|
+ * nk_layout_row_template_push_dynamic - adds a dynamic column that dynamically grows and can go to zero if not enough space
|
|
|
+ * nk_layout_row_template_push_variable - adds a variable column that dynamically grows but does not shrink below specified pixel width
|
|
|
+ * nk_layout_row_template_push_static - adds a static column that does not grow and will always have the same size
|
|
|
+ * nk_layout_row_template_end - marks the end of the row template
|
|
|
+ *
|
|
|
+ * nk_layout_space_begin - begins a new layouting space that allows to specify each widgets position and size
|
|
|
+ * nk_layout_space_push - pushes position and size of the next widget in own coordiante space either as pixel or ratio
|
|
|
+ * nk_layout_space_end - marks the end of the layouting space
|
|
|
+ *
|
|
|
+ * nk_layout_space_bounds - callable after nk_layout_space_begin and returns total space allocated
|
|
|
+ * nk_layout_space_to_screen - convertes vector from nk_layout_space coordiant space into screen space
|
|
|
+ * nk_layout_space_to_local - convertes vector from screem space into nk_layout_space coordinates
|
|
|
+ * nk_layout_space_rect_to_screen - convertes rectangle from nk_layout_space coordiant space into screen space
|
|
|
+ * nk_layout_space_rect_to_local - convertes rectangle from screem space into nk_layout_space coordinates
|
|
|
+ */
|
|
|
+/* nk_layout_set_min_row_height - sets the currently used minimum row height.
|
|
|
+ * IMPORTANT: The passed height needs to include both your prefered row height
|
|
|
+ * as well as padding. No internal padding is added.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_begin_xxx`
|
|
|
+ * @height new minimum row height to be used for auto generating the row height */
|
|
|
+NK_API void nk_layout_set_min_row_height(struct nk_context*, float height);
|
|
|
+/* nk_layout_reset_min_row_height - Reset the currently used minimum row height
|
|
|
+ * back to font height + text padding + additional padding (style_window.min_row_height_padding)
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_begin_xxx` */
|
|
|
+NK_API void nk_layout_reset_min_row_height(struct nk_context*);
|
|
|
+/* nk_layout_widget_bounds - returns the width of the next row allocate by one of the layouting functions
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` */
|
|
|
+NK_API struct nk_rect nk_layout_widget_bounds(struct nk_context*);
|
|
|
+/* nk_layout_ratio_from_pixel - utility functions to calculate window ratio from pixel size
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context`
|
|
|
+ * @pixel_width to convert to window ratio */
|
|
|
+NK_API float nk_layout_ratio_from_pixel(struct nk_context*, float pixel_width);
|
|
|
+/* nk_layout_row_dynamic - Sets current row layout to share horizontal space
|
|
|
+ * between @cols number of widgets evenly. Once called all subsequent widget
|
|
|
+ * calls greater than @cols will allocate a new row with same layout.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_begin_xxx`
|
|
|
+ * @row_height holds height of each widget in row or zero for auto layouting
|
|
|
+ * @cols number of widget inside row */
|
|
|
+NK_API void nk_layout_row_dynamic(struct nk_context *ctx, float height, int cols);
|
|
|
+/* nk_layout_row_static - Sets current row layout to fill @cols number of widgets
|
|
|
+ * in row with same @item_width horizontal size. Once called all subsequent widget
|
|
|
+ * calls greater than @cols will allocate a new row with same layout.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_begin_xxx`
|
|
|
+ * @height holds row height to allocate from panel for widget height
|
|
|
+ * @item_width holds width of each widget in row
|
|
|
+ * @cols number of widget inside row */
|
|
|
+NK_API void nk_layout_row_static(struct nk_context *ctx, float height, int item_width, int cols);
|
|
|
+/* nk_layout_row_begin - Starts a new dynamic or fixed row with given height and columns.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_begin_xxx`
|
|
|
+ * @fmt either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
|
|
|
+ * @row_height holds height of each widget in row or zero for auto layouting
|
|
|
+ * @cols number of widget inside row */
|
|
|
+NK_API void nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt, float row_height, int cols);
|
|
|
+/* nk_layout_row_push - Specifies either window ratio or width of a single column
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_begin`
|
|
|
+ * @value either a window ratio or fixed width depending on @fmt in previous `nk_layout_row_begin` call */
|
|
|
+NK_API void nk_layout_row_push(struct nk_context*, float value);
|
|
|
+/* nk_layout_row_end - finished previously started row
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_begin` */
|
|
|
+NK_API void nk_layout_row_end(struct nk_context*);
|
|
|
+/* nk_layout_row - specifies row columns in array as either window ratio or size
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context`
|
|
|
+ * @fmt either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
|
|
|
+ * @row_height holds height of each widget in row or zero for auto layouting
|
|
|
+ * @cols number of widget inside row */
|
|
|
+NK_API void nk_layout_row(struct nk_context*, enum nk_layout_format, float height, int cols, const float *ratio);
|
|
|
+/* nk_layout_row_template_begin - Begins the row template declaration
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @row_height holds height of each widget in row or zero for auto layouting */
|
|
|
+NK_API void nk_layout_row_template_begin(struct nk_context*, float row_height);
|
|
|
+/* nk_layout_row_template_push_dynamic - adds a dynamic column that dynamically grows and can go to zero if not enough space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_template_begin` */
|
|
|
+NK_API void nk_layout_row_template_push_dynamic(struct nk_context*);
|
|
|
+/* nk_layout_row_template_push_variable - adds a variable column that dynamically grows but does not shrink below specified pixel width
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_template_begin`
|
|
|
+ * @min_width holds the minimum pixel width the next column must be */
|
|
|
+NK_API void nk_layout_row_template_push_variable(struct nk_context*, float min_width);
|
|
|
+/* nk_layout_row_template_push_static - adds a static column that does not grow and will always have the same size
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_template_begin`
|
|
|
+ * @width holds the absolulte pixel width value the next column must be */
|
|
|
+NK_API void nk_layout_row_template_push_static(struct nk_context*, float width);
|
|
|
+/* nk_layout_row_template_end - marks the end of the row template
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_row_template_begin` */
|
|
|
+NK_API void nk_layout_row_template_end(struct nk_context*);
|
|
|
+/* nk_layout_space_begin - begins a new layouting space that allows to specify each widgets position and size.
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct
|
|
|
+ * @fmt either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
|
|
|
+ * @row_height holds height of each widget in row or zero for auto layouting
|
|
|
+ * @widget_count number of widgets inside row */
|
|
|
+NK_API void nk_layout_space_begin(struct nk_context*, enum nk_layout_format, float height, int widget_count);
|
|
|
+/* nk_layout_space_push - pushes position and size of the next widget in own coordiante space either as pixel or ratio
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin`
|
|
|
+ * @bounds position and size in laoyut space local coordinates */
|
|
|
+NK_API void nk_layout_space_push(struct nk_context*, struct nk_rect);
|
|
|
+/* nk_layout_space_end - marks the end of the layout space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` */
|
|
|
+NK_API void nk_layout_space_end(struct nk_context*);
|
|
|
+/* nk_layout_space_bounds - returns total space allocated for `nk_layout_space`
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin` */
|
|
|
+NK_API struct nk_rect nk_layout_space_bounds(struct nk_context*);
|
|
|
+/* nk_layout_space_to_screen - convertes vector from nk_layout_space coordiant space into screen space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin`
|
|
|
+ * @vec position to convert from layout space into screen coordinate space */
|
|
|
+NK_API struct nk_vec2 nk_layout_space_to_screen(struct nk_context*, struct nk_vec2);
|
|
|
+/* nk_layout_space_to_screen - convertes vector from layout space into screen space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin`
|
|
|
+ * @vec position to convert from screen space into layout coordinate space */
|
|
|
+NK_API struct nk_vec2 nk_layout_space_to_local(struct nk_context*, struct nk_vec2);
|
|
|
+/* nk_layout_space_rect_to_screen - convertes rectangle from screen space into layout space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin`
|
|
|
+ * @bounds rectangle to convert from layout space into screen space */
|
|
|
+NK_API struct nk_rect nk_layout_space_rect_to_screen(struct nk_context*, struct nk_rect);
|
|
|
+/* nk_layout_space_rect_to_local - convertes rectangle from layout space into screen space
|
|
|
+ * Parameters:
|
|
|
+ * @ctx must point to an previously initialized `nk_context` struct after call `nk_layout_space_begin`
|
|
|
+ * @bounds rectangle to convert from screen space into layout space */
|
|
|
+NK_API struct nk_rect nk_layout_space_rect_to_local(struct nk_context*, struct nk_rect);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * GROUP
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_group_begin(struct nk_context*, const char *title, nk_flags);
|
|
|
+NK_API int nk_group_scrolled_offset_begin(struct nk_context*, nk_uint *x_offset, nk_uint *y_offset, const char*, nk_flags);
|
|
|
+NK_API int nk_group_scrolled_begin(struct nk_context*, struct nk_scroll*, const char *title, nk_flags);
|
|
|
+NK_API void nk_group_scrolled_end(struct nk_context*);
|
|
|
+NK_API void nk_group_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * LIST VIEW
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+struct nk_list_view {
|
|
|
+/* public: */
|
|
|
+ int begin, end, count;
|
|
|
+/* private: */
|
|
|
+ int total_height;
|
|
|
+ struct nk_context *ctx;
|
|
|
+ nk_uint *scroll_pointer;
|
|
|
+ nk_uint scroll_value;
|
|
|
+};
|
|
|
+NK_API int nk_list_view_begin(struct nk_context*, struct nk_list_view *out, const char *id, nk_flags, int row_height, int row_count);
|
|
|
+NK_API void nk_list_view_end(struct nk_list_view*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * TREE
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+#define nk_tree_push(ctx, type, title, state) nk_tree_push_hashed(ctx, type, title, state, NK_FILE_LINE,nk_strlen(NK_FILE_LINE),__LINE__)
|
|
|
+#define nk_tree_push_id(ctx, type, title, state, id) nk_tree_push_hashed(ctx, type, title, state, NK_FILE_LINE,nk_strlen(NK_FILE_LINE),id)
|
|
|
+NK_API int nk_tree_push_hashed(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed);
|
|
|
+#define nk_tree_image_push(ctx, type, img, title, state) nk_tree_image_push_hashed(ctx, type, img, title, state, NK_FILE_LINE,nk_strlen(NK_FILE_LINE),__LINE__)
|
|
|
+#define nk_tree_image_push_id(ctx, type, img, title, state, id) nk_tree_image_push_hashed(ctx, type, img, title, state, NK_FILE_LINE,nk_strlen(NK_FILE_LINE),id)
|
|
|
+NK_API int nk_tree_image_push_hashed(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states initial_state, const char *hash, int len,int seed);
|
|
|
+NK_API void nk_tree_pop(struct nk_context*);
|
|
|
+NK_API int nk_tree_state_push(struct nk_context*, enum nk_tree_type, const char *title, enum nk_collapse_states *state);
|
|
|
+NK_API int nk_tree_state_image_push(struct nk_context*, enum nk_tree_type, struct nk_image, const char *title, enum nk_collapse_states *state);
|
|
|
+NK_API void nk_tree_state_pop(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * WIDGET
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+enum nk_widget_layout_states {
|
|
|
+ NK_WIDGET_INVALID, /* The widget cannot be seen and is completely out of view */
|
|
|
+ NK_WIDGET_VALID, /* The widget is completely inside the window and can be updated and drawn */
|
|
|
+ NK_WIDGET_ROM /* The widget is partially visible and cannot be updated */
|
|
|
+};
|
|
|
+enum nk_widget_states {
|
|
|
+ NK_WIDGET_STATE_MODIFIED = NK_FLAG(1),
|
|
|
+ NK_WIDGET_STATE_INACTIVE = NK_FLAG(2), /* widget is neither active nor hovered */
|
|
|
+ NK_WIDGET_STATE_ENTERED = NK_FLAG(3), /* widget has been hovered on the current frame */
|
|
|
+ NK_WIDGET_STATE_HOVER = NK_FLAG(4), /* widget is being hovered */
|
|
|
+ NK_WIDGET_STATE_ACTIVED = NK_FLAG(5),/* widget is currently activated */
|
|
|
+ NK_WIDGET_STATE_LEFT = NK_FLAG(6), /* widget is from this frame on not hovered anymore */
|
|
|
+ NK_WIDGET_STATE_HOVERED = NK_WIDGET_STATE_HOVER|NK_WIDGET_STATE_MODIFIED, /* widget is being hovered */
|
|
|
+ NK_WIDGET_STATE_ACTIVE = NK_WIDGET_STATE_ACTIVED|NK_WIDGET_STATE_MODIFIED /* widget is currently activated */
|
|
|
+};
|
|
|
+NK_API enum nk_widget_layout_states nk_widget(struct nk_rect*, const struct nk_context*);
|
|
|
+NK_API enum nk_widget_layout_states nk_widget_fitting(struct nk_rect*, struct nk_context*, struct nk_vec2);
|
|
|
+NK_API struct nk_rect nk_widget_bounds(struct nk_context*);
|
|
|
+NK_API struct nk_vec2 nk_widget_position(struct nk_context*);
|
|
|
+NK_API struct nk_vec2 nk_widget_size(struct nk_context*);
|
|
|
+NK_API float nk_widget_width(struct nk_context*);
|
|
|
+NK_API float nk_widget_height(struct nk_context*);
|
|
|
+NK_API int nk_widget_is_hovered(struct nk_context*);
|
|
|
+NK_API int nk_widget_is_mouse_clicked(struct nk_context*, enum nk_buttons);
|
|
|
+NK_API int nk_widget_has_mouse_click_down(struct nk_context*, enum nk_buttons, int down);
|
|
|
+NK_API void nk_spacing(struct nk_context*, int cols);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * TEXT
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+enum nk_text_align {
|
|
|
+ NK_TEXT_ALIGN_LEFT = 0x01,
|
|
|
+ NK_TEXT_ALIGN_CENTERED = 0x02,
|
|
|
+ NK_TEXT_ALIGN_RIGHT = 0x04,
|
|
|
+ NK_TEXT_ALIGN_TOP = 0x08,
|
|
|
+ NK_TEXT_ALIGN_MIDDLE = 0x10,
|
|
|
+ NK_TEXT_ALIGN_BOTTOM = 0x20
|
|
|
+};
|
|
|
+enum nk_text_alignment {
|
|
|
+ NK_TEXT_LEFT = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_LEFT,
|
|
|
+ NK_TEXT_CENTERED = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_CENTERED,
|
|
|
+ NK_TEXT_RIGHT = NK_TEXT_ALIGN_MIDDLE|NK_TEXT_ALIGN_RIGHT
|
|
|
+};
|
|
|
+NK_API void nk_text(struct nk_context*, const char*, int, nk_flags);
|
|
|
+NK_API void nk_text_colored(struct nk_context*, const char*, int, nk_flags, struct nk_color);
|
|
|
+NK_API void nk_text_wrap(struct nk_context*, const char*, int);
|
|
|
+NK_API void nk_text_wrap_colored(struct nk_context*, const char*, int, struct nk_color);
|
|
|
+NK_API void nk_label(struct nk_context*, const char*, nk_flags align);
|
|
|
+NK_API void nk_label_colored(struct nk_context*, const char*, nk_flags align, struct nk_color);
|
|
|
+NK_API void nk_label_wrap(struct nk_context*, const char*);
|
|
|
+NK_API void nk_label_colored_wrap(struct nk_context*, const char*, struct nk_color);
|
|
|
+NK_API void nk_image(struct nk_context*, struct nk_image);
|
|
|
+#ifdef NK_INCLUDE_STANDARD_VARARGS
|
|
|
+NK_API void nk_labelf(struct nk_context*, nk_flags, const char*, ...);
|
|
|
+NK_API void nk_labelf_colored(struct nk_context*, nk_flags align, struct nk_color, const char*,...);
|
|
|
+NK_API void nk_labelf_wrap(struct nk_context*, const char*,...);
|
|
|
+NK_API void nk_labelf_colored_wrap(struct nk_context*, struct nk_color, const char*,...);
|
|
|
+NK_API void nk_value_bool(struct nk_context*, const char *prefix, int);
|
|
|
+NK_API void nk_value_int(struct nk_context*, const char *prefix, int);
|
|
|
+NK_API void nk_value_uint(struct nk_context*, const char *prefix, unsigned int);
|
|
|
+NK_API void nk_value_float(struct nk_context*, const char *prefix, float);
|
|
|
+NK_API void nk_value_color_byte(struct nk_context*, const char *prefix, struct nk_color);
|
|
|
+NK_API void nk_value_color_float(struct nk_context*, const char *prefix, struct nk_color);
|
|
|
+NK_API void nk_value_color_hex(struct nk_context*, const char *prefix, struct nk_color);
|
|
|
+#endif
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * BUTTON
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_button_text(struct nk_context*, const char *title, int len);
|
|
|
+NK_API int nk_button_label(struct nk_context*, const char *title);
|
|
|
+NK_API int nk_button_color(struct nk_context*, struct nk_color);
|
|
|
+NK_API int nk_button_symbol(struct nk_context*, enum nk_symbol_type);
|
|
|
+NK_API int nk_button_image(struct nk_context*, struct nk_image img);
|
|
|
+NK_API int nk_button_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags text_alignment);
|
|
|
+NK_API int nk_button_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment);
|
|
|
+NK_API int nk_button_image_label(struct nk_context*, struct nk_image img, const char*, nk_flags text_alignment);
|
|
|
+NK_API int nk_button_image_text(struct nk_context*, struct nk_image img, const char*, int, nk_flags alignment);
|
|
|
+NK_API int nk_button_text_styled(struct nk_context*, const struct nk_style_button*, const char *title, int len);
|
|
|
+NK_API int nk_button_label_styled(struct nk_context*, const struct nk_style_button*, const char *title);
|
|
|
+NK_API int nk_button_symbol_styled(struct nk_context*, const struct nk_style_button*, enum nk_symbol_type);
|
|
|
+NK_API int nk_button_image_styled(struct nk_context*, const struct nk_style_button*, struct nk_image img);
|
|
|
+NK_API int nk_button_symbol_text_styled(struct nk_context*,const struct nk_style_button*, enum nk_symbol_type, const char*, int, nk_flags alignment);
|
|
|
+NK_API int nk_button_symbol_label_styled(struct nk_context *ctx, const struct nk_style_button *style, enum nk_symbol_type symbol, const char *title, nk_flags align);
|
|
|
+NK_API int nk_button_image_label_styled(struct nk_context*,const struct nk_style_button*, struct nk_image img, const char*, nk_flags text_alignment);
|
|
|
+NK_API int nk_button_image_text_styled(struct nk_context*,const struct nk_style_button*, struct nk_image img, const char*, int, nk_flags alignment);
|
|
|
+NK_API void nk_button_set_behavior(struct nk_context*, enum nk_button_behavior);
|
|
|
+NK_API int nk_button_push_behavior(struct nk_context*, enum nk_button_behavior);
|
|
|
+NK_API int nk_button_pop_behavior(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * CHECKBOX
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_check_label(struct nk_context*, const char*, int active);
|
|
|
+NK_API int nk_check_text(struct nk_context*, const char*, int,int active);
|
|
|
+NK_API unsigned nk_check_flags_label(struct nk_context*, const char*, unsigned int flags, unsigned int value);
|
|
|
+NK_API unsigned nk_check_flags_text(struct nk_context*, const char*, int, unsigned int flags, unsigned int value);
|
|
|
+NK_API int nk_checkbox_label(struct nk_context*, const char*, int *active);
|
|
|
+NK_API int nk_checkbox_text(struct nk_context*, const char*, int, int *active);
|
|
|
+NK_API int nk_checkbox_flags_label(struct nk_context*, const char*, unsigned int *flags, unsigned int value);
|
|
|
+NK_API int nk_checkbox_flags_text(struct nk_context*, const char*, int, unsigned int *flags, unsigned int value);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * RADIO BUTTON
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_radio_label(struct nk_context*, const char*, int *active);
|
|
|
+NK_API int nk_radio_text(struct nk_context*, const char*, int, int *active);
|
|
|
+NK_API int nk_option_label(struct nk_context*, const char*, int active);
|
|
|
+NK_API int nk_option_text(struct nk_context*, const char*, int, int active);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * SELECTABLE
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_selectable_label(struct nk_context*, const char*, nk_flags align, int *value);
|
|
|
+NK_API int nk_selectable_text(struct nk_context*, const char*, int, nk_flags align, int *value);
|
|
|
+NK_API int nk_selectable_image_label(struct nk_context*,struct nk_image, const char*, nk_flags align, int *value);
|
|
|
+NK_API int nk_selectable_image_text(struct nk_context*,struct nk_image, const char*, int, nk_flags align, int *value);
|
|
|
+NK_API int nk_select_label(struct nk_context*, const char*, nk_flags align, int value);
|
|
|
+NK_API int nk_select_text(struct nk_context*, const char*, int, nk_flags align, int value);
|
|
|
+NK_API int nk_select_image_label(struct nk_context*, struct nk_image,const char*, nk_flags align, int value);
|
|
|
+NK_API int nk_select_image_text(struct nk_context*, struct nk_image,const char*, int, nk_flags align, int value);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * SLIDER
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API float nk_slide_float(struct nk_context*, float min, float val, float max, float step);
|
|
|
+NK_API int nk_slide_int(struct nk_context*, int min, int val, int max, int step);
|
|
|
+NK_API int nk_slider_float(struct nk_context*, float min, float *val, float max, float step);
|
|
|
+NK_API int nk_slider_int(struct nk_context*, int min, int *val, int max, int step);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * PROGRESSBAR
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_progress(struct nk_context*, nk_size *cur, nk_size max, int modifyable);
|
|
|
+NK_API nk_size nk_prog(struct nk_context*, nk_size cur, nk_size max, int modifyable);
|
|
|
+
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * COLOR PICKER
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API struct nk_color nk_color_picker(struct nk_context*, struct nk_color, enum nk_color_format);
|
|
|
+NK_API int nk_color_pick(struct nk_context*, struct nk_color*, enum nk_color_format);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * PROPERTIES
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API void nk_property_int(struct nk_context*, const char *name, int min, int *val, int max, int step, float inc_per_pixel);
|
|
|
+NK_API void nk_property_float(struct nk_context*, const char *name, float min, float *val, float max, float step, float inc_per_pixel);
|
|
|
+NK_API void nk_property_double(struct nk_context*, const char *name, double min, double *val, double max, double step, float inc_per_pixel);
|
|
|
+NK_API int nk_propertyi(struct nk_context*, const char *name, int min, int val, int max, int step, float inc_per_pixel);
|
|
|
+NK_API float nk_propertyf(struct nk_context*, const char *name, float min, float val, float max, float step, float inc_per_pixel);
|
|
|
+NK_API double nk_propertyd(struct nk_context*, const char *name, double min, double val, double max, double step, float inc_per_pixel);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * TEXT EDIT
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+enum nk_edit_flags {
|
|
|
+ NK_EDIT_DEFAULT = 0,
|
|
|
+ NK_EDIT_READ_ONLY = NK_FLAG(0),
|
|
|
+ NK_EDIT_AUTO_SELECT = NK_FLAG(1),
|
|
|
+ NK_EDIT_SIG_ENTER = NK_FLAG(2),
|
|
|
+ NK_EDIT_ALLOW_TAB = NK_FLAG(3),
|
|
|
+ NK_EDIT_NO_CURSOR = NK_FLAG(4),
|
|
|
+ NK_EDIT_SELECTABLE = NK_FLAG(5),
|
|
|
+ NK_EDIT_CLIPBOARD = NK_FLAG(6),
|
|
|
+ NK_EDIT_CTRL_ENTER_NEWLINE = NK_FLAG(7),
|
|
|
+ NK_EDIT_NO_HORIZONTAL_SCROLL = NK_FLAG(8),
|
|
|
+ NK_EDIT_ALWAYS_INSERT_MODE = NK_FLAG(9),
|
|
|
+ NK_EDIT_MULTILINE = NK_FLAG(10),
|
|
|
+ NK_EDIT_GOTO_END_ON_ACTIVATE = NK_FLAG(11)
|
|
|
+};
|
|
|
+enum nk_edit_types {
|
|
|
+ NK_EDIT_SIMPLE = NK_EDIT_ALWAYS_INSERT_MODE,
|
|
|
+ NK_EDIT_FIELD = NK_EDIT_SIMPLE|NK_EDIT_SELECTABLE|NK_EDIT_CLIPBOARD,
|
|
|
+ NK_EDIT_BOX = NK_EDIT_ALWAYS_INSERT_MODE| NK_EDIT_SELECTABLE| NK_EDIT_MULTILINE|NK_EDIT_ALLOW_TAB|NK_EDIT_CLIPBOARD,
|
|
|
+ NK_EDIT_EDITOR = NK_EDIT_SELECTABLE|NK_EDIT_MULTILINE|NK_EDIT_ALLOW_TAB| NK_EDIT_CLIPBOARD
|
|
|
+};
|
|
|
+enum nk_edit_events {
|
|
|
+ NK_EDIT_ACTIVE = NK_FLAG(0), /* edit widget is currently being modified */
|
|
|
+ NK_EDIT_INACTIVE = NK_FLAG(1), /* edit widget is not active and is not being modified */
|
|
|
+ NK_EDIT_ACTIVATED = NK_FLAG(2), /* edit widget went from state inactive to state active */
|
|
|
+ NK_EDIT_DEACTIVATED = NK_FLAG(3), /* edit widget went from state active to state inactive */
|
|
|
+ NK_EDIT_COMMITED = NK_FLAG(4) /* edit widget has received an enter and lost focus */
|
|
|
+};
|
|
|
+NK_API nk_flags nk_edit_string(struct nk_context*, nk_flags, char *buffer, int *len, int max, nk_plugin_filter);
|
|
|
+NK_API nk_flags nk_edit_string_zero_terminated(struct nk_context*, nk_flags, char *buffer, int max, nk_plugin_filter);
|
|
|
+NK_API nk_flags nk_edit_buffer(struct nk_context*, nk_flags, struct nk_text_edit*, nk_plugin_filter);
|
|
|
+NK_API void nk_edit_focus(struct nk_context*, nk_flags flags);
|
|
|
+NK_API void nk_edit_unfocus(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * CHART
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_chart_begin(struct nk_context*, enum nk_chart_type, int num, float min, float max);
|
|
|
+NK_API int nk_chart_begin_colored(struct nk_context*, enum nk_chart_type, struct nk_color, struct nk_color active, int num, float min, float max);
|
|
|
+NK_API void nk_chart_add_slot(struct nk_context *ctx, const enum nk_chart_type, int count, float min_value, float max_value);
|
|
|
+NK_API void nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type, struct nk_color, struct nk_color active, int count, float min_value, float max_value);
|
|
|
+NK_API nk_flags nk_chart_push(struct nk_context*, float);
|
|
|
+NK_API nk_flags nk_chart_push_slot(struct nk_context*, float, int);
|
|
|
+NK_API void nk_chart_end(struct nk_context*);
|
|
|
+NK_API void nk_plot(struct nk_context*, enum nk_chart_type, const float *values, int count, int offset);
|
|
|
+NK_API void nk_plot_function(struct nk_context*, enum nk_chart_type, void *userdata, float(*value_getter)(void* user, int index), int count, int offset);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * POPUP
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_popup_begin(struct nk_context*, enum nk_popup_type, const char*, nk_flags, struct nk_rect bounds);
|
|
|
+NK_API void nk_popup_close(struct nk_context*);
|
|
|
+NK_API void nk_popup_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * COMBOBOX
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_combo(struct nk_context*, const char **items, int count, int selected, int item_height, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_separator(struct nk_context*, const char *items_separated_by_separator, int separator, int selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_string(struct nk_context*, const char *items_separated_by_zeros, int selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void *userdata, int selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+NK_API void nk_combobox(struct nk_context*, const char **items, int count, int *selected, int item_height, struct nk_vec2 size);
|
|
|
+NK_API void nk_combobox_string(struct nk_context*, const char *items_separated_by_zeros, int *selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+NK_API void nk_combobox_separator(struct nk_context*, const char *items_separated_by_separator, int separator,int *selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+NK_API void nk_combobox_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void*, int *selected, int count, int item_height, struct nk_vec2 size);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * ABSTRACT COMBOBOX
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_combo_begin_text(struct nk_context*, const char *selected, int, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_label(struct nk_context*, const char *selected, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_color(struct nk_context*, struct nk_color color, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_symbol(struct nk_context*, enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_symbol_label(struct nk_context*, const char *selected, enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_symbol_text(struct nk_context*, const char *selected, int, enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_image(struct nk_context*, struct nk_image img, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_image_label(struct nk_context*, const char *selected, struct nk_image, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_begin_image_text(struct nk_context*, const char *selected, int, struct nk_image, struct nk_vec2 size);
|
|
|
+NK_API int nk_combo_item_label(struct nk_context*, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_combo_item_text(struct nk_context*, const char*,int, nk_flags alignment);
|
|
|
+NK_API int nk_combo_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_combo_item_image_text(struct nk_context*, struct nk_image, const char*, int,nk_flags alignment);
|
|
|
+NK_API int nk_combo_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_combo_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment);
|
|
|
+NK_API void nk_combo_close(struct nk_context*);
|
|
|
+NK_API void nk_combo_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * CONTEXTUAL
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_contextual_begin(struct nk_context*, nk_flags, struct nk_vec2, struct nk_rect trigger_bounds);
|
|
|
+NK_API int nk_contextual_item_text(struct nk_context*, const char*, int,nk_flags align);
|
|
|
+NK_API int nk_contextual_item_label(struct nk_context*, const char*, nk_flags align);
|
|
|
+NK_API int nk_contextual_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_contextual_item_image_text(struct nk_context*, struct nk_image, const char*, int len, nk_flags alignment);
|
|
|
+NK_API int nk_contextual_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_contextual_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment);
|
|
|
+NK_API void nk_contextual_close(struct nk_context*);
|
|
|
+NK_API void nk_contextual_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * TOOLTIP
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API void nk_tooltip(struct nk_context*, const char*);
|
|
|
+NK_API int nk_tooltip_begin(struct nk_context*, float width);
|
|
|
+NK_API void nk_tooltip_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * MENU
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API void nk_menubar_begin(struct nk_context*);
|
|
|
+NK_API void nk_menubar_end(struct nk_context*);
|
|
|
+NK_API int nk_menu_begin_text(struct nk_context*, const char* title, int title_len, nk_flags align, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_label(struct nk_context*, const char*, nk_flags align, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_image(struct nk_context*, const char*, struct nk_image, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_image_text(struct nk_context*, const char*, int,nk_flags align,struct nk_image, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_image_label(struct nk_context*, const char*, nk_flags align,struct nk_image, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_symbol(struct nk_context*, const char*, enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_symbol_text(struct nk_context*, const char*, int,nk_flags align,enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_begin_symbol_label(struct nk_context*, const char*, nk_flags align,enum nk_symbol_type, struct nk_vec2 size);
|
|
|
+NK_API int nk_menu_item_text(struct nk_context*, const char*, int,nk_flags align);
|
|
|
+NK_API int nk_menu_item_label(struct nk_context*, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_menu_item_image_label(struct nk_context*, struct nk_image, const char*, nk_flags alignment);
|
|
|
+NK_API int nk_menu_item_image_text(struct nk_context*, struct nk_image, const char*, int len, nk_flags alignment);
|
|
|
+NK_API int nk_menu_item_symbol_text(struct nk_context*, enum nk_symbol_type, const char*, int, nk_flags alignment);
|
|
|
+NK_API int nk_menu_item_symbol_label(struct nk_context*, enum nk_symbol_type, const char*, nk_flags alignment);
|
|
|
+NK_API void nk_menu_close(struct nk_context*);
|
|
|
+NK_API void nk_menu_end(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * STYLE
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+enum nk_style_colors {
|
|
|
+ NK_COLOR_TEXT,
|
|
|
+ NK_COLOR_WINDOW,
|
|
|
+ NK_COLOR_HEADER,
|
|
|
+ NK_COLOR_BORDER,
|
|
|
+ NK_COLOR_BUTTON,
|
|
|
+ NK_COLOR_BUTTON_HOVER,
|
|
|
+ NK_COLOR_BUTTON_ACTIVE,
|
|
|
+ NK_COLOR_TOGGLE,
|
|
|
+ NK_COLOR_TOGGLE_HOVER,
|
|
|
+ NK_COLOR_TOGGLE_CURSOR,
|
|
|
+ NK_COLOR_SELECT,
|
|
|
+ NK_COLOR_SELECT_ACTIVE,
|
|
|
+ NK_COLOR_SLIDER,
|
|
|
+ NK_COLOR_SLIDER_CURSOR,
|
|
|
+ NK_COLOR_SLIDER_CURSOR_HOVER,
|
|
|
+ NK_COLOR_SLIDER_CURSOR_ACTIVE,
|
|
|
+ NK_COLOR_PROPERTY,
|
|
|
+ NK_COLOR_EDIT,
|
|
|
+ NK_COLOR_EDIT_CURSOR,
|
|
|
+ NK_COLOR_COMBO,
|
|
|
+ NK_COLOR_CHART,
|
|
|
+ NK_COLOR_CHART_COLOR,
|
|
|
+ NK_COLOR_CHART_COLOR_HIGHLIGHT,
|
|
|
+ NK_COLOR_SCROLLBAR,
|
|
|
+ NK_COLOR_SCROLLBAR_CURSOR,
|
|
|
+ NK_COLOR_SCROLLBAR_CURSOR_HOVER,
|
|
|
+ NK_COLOR_SCROLLBAR_CURSOR_ACTIVE,
|
|
|
+ NK_COLOR_TAB_HEADER,
|
|
|
+ NK_COLOR_COUNT
|
|
|
+};
|
|
|
+enum nk_style_cursor {
|
|
|
+ NK_CURSOR_ARROW,
|
|
|
+ NK_CURSOR_TEXT,
|
|
|
+ NK_CURSOR_MOVE,
|
|
|
+ NK_CURSOR_RESIZE_VERTICAL,
|
|
|
+ NK_CURSOR_RESIZE_HORIZONTAL,
|
|
|
+ NK_CURSOR_RESIZE_TOP_LEFT_DOWN_RIGHT,
|
|
|
+ NK_CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT,
|
|
|
+ NK_CURSOR_COUNT
|
|
|
+};
|
|
|
+NK_API void nk_style_default(struct nk_context*);
|
|
|
+NK_API void nk_style_from_table(struct nk_context*, const struct nk_color*);
|
|
|
+NK_API void nk_style_load_cursor(struct nk_context*, enum nk_style_cursor, const struct nk_cursor*);
|
|
|
+NK_API void nk_style_load_all_cursors(struct nk_context*, struct nk_cursor*);
|
|
|
+NK_API const char* nk_style_get_color_by_name(enum nk_style_colors);
|
|
|
+NK_API void nk_style_set_font(struct nk_context*, const struct nk_user_font*);
|
|
|
+NK_API int nk_style_set_cursor(struct nk_context*, enum nk_style_cursor);
|
|
|
+NK_API void nk_style_show_cursor(struct nk_context*);
|
|
|
+NK_API void nk_style_hide_cursor(struct nk_context*);
|
|
|
+
|
|
|
+NK_API int nk_style_push_font(struct nk_context*, const struct nk_user_font*);
|
|
|
+NK_API int nk_style_push_float(struct nk_context*, float*, float);
|
|
|
+NK_API int nk_style_push_vec2(struct nk_context*, struct nk_vec2*, struct nk_vec2);
|
|
|
+NK_API int nk_style_push_style_item(struct nk_context*, struct nk_style_item*, struct nk_style_item);
|
|
|
+NK_API int nk_style_push_flags(struct nk_context*, nk_flags*, nk_flags);
|
|
|
+NK_API int nk_style_push_color(struct nk_context*, struct nk_color*, struct nk_color);
|
|
|
+
|
|
|
+NK_API int nk_style_pop_font(struct nk_context*);
|
|
|
+NK_API int nk_style_pop_float(struct nk_context*);
|
|
|
+NK_API int nk_style_pop_vec2(struct nk_context*);
|
|
|
+NK_API int nk_style_pop_style_item(struct nk_context*);
|
|
|
+NK_API int nk_style_pop_flags(struct nk_context*);
|
|
|
+NK_API int nk_style_pop_color(struct nk_context*);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * COLOR
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API struct nk_color nk_rgb(int r, int g, int b);
|
|
|
+NK_API struct nk_color nk_rgb_iv(const int *rgb);
|
|
|
+NK_API struct nk_color nk_rgb_bv(const nk_byte* rgb);
|
|
|
+NK_API struct nk_color nk_rgb_f(float r, float g, float b);
|
|
|
+NK_API struct nk_color nk_rgb_fv(const float *rgb);
|
|
|
+NK_API struct nk_color nk_rgb_hex(const char *rgb);
|
|
|
+
|
|
|
+NK_API struct nk_color nk_rgba(int r, int g, int b, int a);
|
|
|
+NK_API struct nk_color nk_rgba_u32(nk_uint);
|
|
|
+NK_API struct nk_color nk_rgba_iv(const int *rgba);
|
|
|
+NK_API struct nk_color nk_rgba_bv(const nk_byte *rgba);
|
|
|
+NK_API struct nk_color nk_rgba_f(float r, float g, float b, float a);
|
|
|
+NK_API struct nk_color nk_rgba_fv(const float *rgba);
|
|
|
+NK_API struct nk_color nk_rgba_hex(const char *rgb);
|
|
|
+
|
|
|
+NK_API struct nk_color nk_hsv(int h, int s, int v);
|
|
|
+NK_API struct nk_color nk_hsv_iv(const int *hsv);
|
|
|
+NK_API struct nk_color nk_hsv_bv(const nk_byte *hsv);
|
|
|
+NK_API struct nk_color nk_hsv_f(float h, float s, float v);
|
|
|
+NK_API struct nk_color nk_hsv_fv(const float *hsv);
|
|
|
+
|
|
|
+NK_API struct nk_color nk_hsva(int h, int s, int v, int a);
|
|
|
+NK_API struct nk_color nk_hsva_iv(const int *hsva);
|
|
|
+NK_API struct nk_color nk_hsva_bv(const nk_byte *hsva);
|
|
|
+NK_API struct nk_color nk_hsva_f(float h, float s, float v, float a);
|
|
|
+NK_API struct nk_color nk_hsva_fv(const float *hsva);
|
|
|
+
|
|
|
+/* color (conversion nuklear --> user) */
|
|
|
+NK_API void nk_color_f(float *r, float *g, float *b, float *a, struct nk_color);
|
|
|
+NK_API void nk_color_fv(float *rgba_out, struct nk_color);
|
|
|
+NK_API void nk_color_d(double *r, double *g, double *b, double *a, struct nk_color);
|
|
|
+NK_API void nk_color_dv(double *rgba_out, struct nk_color);
|
|
|
+
|
|
|
+NK_API nk_uint nk_color_u32(struct nk_color);
|
|
|
+NK_API void nk_color_hex_rgba(char *output, struct nk_color);
|
|
|
+NK_API void nk_color_hex_rgb(char *output, struct nk_color);
|
|
|
+
|
|
|
+NK_API void nk_color_hsv_i(int *out_h, int *out_s, int *out_v, struct nk_color);
|
|
|
+NK_API void nk_color_hsv_b(nk_byte *out_h, nk_byte *out_s, nk_byte *out_v, struct nk_color);
|
|
|
+NK_API void nk_color_hsv_iv(int *hsv_out, struct nk_color);
|
|
|
+NK_API void nk_color_hsv_bv(nk_byte *hsv_out, struct nk_color);
|
|
|
+NK_API void nk_color_hsv_f(float *out_h, float *out_s, float *out_v, struct nk_color);
|
|
|
+NK_API void nk_color_hsv_fv(float *hsv_out, struct nk_color);
|
|
|
+
|
|
|
+NK_API void nk_color_hsva_i(int *h, int *s, int *v, int *a, struct nk_color);
|
|
|
+NK_API void nk_color_hsva_b(nk_byte *h, nk_byte *s, nk_byte *v, nk_byte *a, struct nk_color);
|
|
|
+NK_API void nk_color_hsva_iv(int *hsva_out, struct nk_color);
|
|
|
+NK_API void nk_color_hsva_bv(nk_byte *hsva_out, struct nk_color);
|
|
|
+NK_API void nk_color_hsva_f(float *out_h, float *out_s, float *out_v, float *out_a, struct nk_color);
|
|
|
+NK_API void nk_color_hsva_fv(float *hsva_out, struct nk_color);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * IMAGE
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API nk_handle nk_handle_ptr(void*);
|
|
|
+NK_API nk_handle nk_handle_id(int);
|
|
|
+NK_API struct nk_image nk_image_handle(nk_handle);
|
|
|
+NK_API struct nk_image nk_image_ptr(void*);
|
|
|
+NK_API struct nk_image nk_image_id(int);
|
|
|
+NK_API int nk_image_is_subimage(const struct nk_image* img);
|
|
|
+NK_API struct nk_image nk_subimage_ptr(void*, unsigned short w, unsigned short h, struct nk_rect sub_region);
|
|
|
+NK_API struct nk_image nk_subimage_id(int, unsigned short w, unsigned short h, struct nk_rect sub_region);
|
|
|
+NK_API struct nk_image nk_subimage_handle(nk_handle, unsigned short w, unsigned short h, struct nk_rect sub_region);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * MATH
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API nk_hash nk_murmur_hash(const void *key, int len, nk_hash seed);
|
|
|
+NK_API void nk_triangle_from_direction(struct nk_vec2 *result, struct nk_rect r, float pad_x, float pad_y, enum nk_heading);
|
|
|
+
|
|
|
+NK_API struct nk_vec2 nk_vec2(float x, float y);
|
|
|
+NK_API struct nk_vec2 nk_vec2i(int x, int y);
|
|
|
+NK_API struct nk_vec2 nk_vec2v(const float *xy);
|
|
|
+NK_API struct nk_vec2 nk_vec2iv(const int *xy);
|
|
|
+
|
|
|
+NK_API struct nk_rect nk_get_null_rect(void);
|
|
|
+NK_API struct nk_rect nk_rect(float x, float y, float w, float h);
|
|
|
+NK_API struct nk_rect nk_recti(int x, int y, int w, int h);
|
|
|
+NK_API struct nk_rect nk_recta(struct nk_vec2 pos, struct nk_vec2 size);
|
|
|
+NK_API struct nk_rect nk_rectv(const float *xywh);
|
|
|
+NK_API struct nk_rect nk_rectiv(const int *xywh);
|
|
|
+NK_API struct nk_vec2 nk_rect_pos(struct nk_rect);
|
|
|
+NK_API struct nk_vec2 nk_rect_size(struct nk_rect);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * STRING
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_strlen(const char *str);
|
|
|
+NK_API int nk_stricmp(const char *s1, const char *s2);
|
|
|
+NK_API int nk_stricmpn(const char *s1, const char *s2, int n);
|
|
|
+NK_API int nk_strtoi(const char *str, const char **endptr);
|
|
|
+NK_API float nk_strtof(const char *str, const char **endptr);
|
|
|
+NK_API double nk_strtod(const char *str, const char **endptr);
|
|
|
+NK_API int nk_strfilter(const char *text, const char *regexp);
|
|
|
+NK_API int nk_strmatch_fuzzy_string(char const *str, char const *pattern, int *out_score);
|
|
|
+NK_API int nk_strmatch_fuzzy_text(const char *txt, int txt_len, const char *pattern, int *out_score);
|
|
|
+/* =============================================================================
|
|
|
+ *
|
|
|
+ * UTF-8
|
|
|
+ *
|
|
|
+ * ============================================================================= */
|
|
|
+NK_API int nk_utf_decode(const char*, nk_rune*, int);
|
|
|
+NK_API int nk_utf_encode(nk_rune, char*, int);
|
|
|
+NK_API int nk_utf_len(const char*, int byte_len);
|
|
|
+NK_API const char* nk_utf_at(const char *buffer, int length, int index, nk_rune *unicode, int *len);
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * FONT
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+/* Font handling in this library was designed to be quite customizable and lets
|
|
|
+ you decide what you want to use and what you want to provide. There are three
|
|
|
+ different ways to use the font atlas. The first two will use your font
|
|
|
+ handling scheme and only requires essential data to run nuklear. The next
|
|
|
+ slightly more advanced features is font handling with vertex buffer output.
|
|
|
+ Finally the most complex API wise is using nuklears font baking API.
|
|
|
+
|
|
|
+ 1.) Using your own implementation without vertex buffer output
|
|
|
+ --------------------------------------------------------------
|
|
|
+ So first up the easiest way to do font handling is by just providing a
|
|
|
+ `nk_user_font` struct which only requires the height in pixel of the used
|
|
|
+ font and a callback to calculate the width of a string. This way of handling
|
|
|
+ fonts is best fitted for using the normal draw shape command API where you
|
|
|
+ do all the text drawing yourself and the library does not require any kind
|
|
|
+ of deeper knowledge about which font handling mechanism you use.
|
|
|
+ IMPORTANT: the `nk_user_font` pointer provided to nuklear has to persist
|
|
|
+ over the complete life time! I know this sucks but it is currently the only
|
|
|
+ way to switch between fonts.
|
|
|
+
|
|
|
+ float your_text_width_calculation(nk_handle handle, float height, const char *text, int len)
|
|
|
+ {
|
|
|
+ your_font_type *type = handle.ptr;
|
|
|
+ float text_width = ...;
|
|
|
+ return text_width;
|
|
|
+ }
|
|
|
+
|
|
|
+ struct nk_user_font font;
|
|
|
+ font.userdata.ptr = &your_font_class_or_struct;
|
|
|
+ font.height = your_font_height;
|
|
|
+ font.width = your_text_width_calculation;
|
|
|
+
|
|
|
+ struct nk_context ctx;
|
|
|
+ nk_init_default(&ctx, &font);
|
|
|
+
|
|
|
+ 2.) Using your own implementation with vertex buffer output
|
|
|
+ --------------------------------------------------------------
|
|
|
+ While the first approach works fine if you don't want to use the optional
|
|
|
+ vertex buffer output it is not enough if you do. To get font handling working
|
|
|
+ for these cases you have to provide two additional parameters inside the
|
|
|
+ `nk_user_font`. First a texture atlas handle used to draw text as subimages
|
|
|
+ of a bigger font atlas texture and a callback to query a character's glyph
|
|
|
+ information (offset, size, ...). So it is still possible to provide your own
|
|
|
+ font and use the vertex buffer output.
|
|
|
+
|
|
|
+ float your_text_width_calculation(nk_handle handle, float height, const char *text, int len)
|
|
|
+ {
|
|
|
+ your_font_type *type = handle.ptr;
|
|
|
+ float text_width = ...;
|
|
|
+ return text_width;
|
|
|
+ }
|
|
|
+ void query_your_font_glyph(nk_handle handle, float font_height, struct nk_user_font_glyph *glyph, nk_rune codepoint, nk_rune next_codepoint)
|
|
|
+ {
|
|
|
+ your_font_type *type = handle.ptr;
|
|
|
+ glyph.width = ...;
|
|
|
+ glyph.height = ...;
|
|
|
+ glyph.xadvance = ...;
|
|
|
+ glyph.uv[0].x = ...;
|
|
|
+ glyph.uv[0].y = ...;
|
|
|
+ glyph.uv[1].x = ...;
|
|
|
+ glyph.uv[1].y = ...;
|
|
|
+ glyph.offset.x = ...;
|
|
|
+ glyph.offset.y = ...;
|
|
|
+ }
|
|
|
+
|
|
|
+ struct nk_user_font font;
|
|
|
+ font.userdata.ptr = &your_font_class_or_struct;
|
|
|
+ font.height = your_font_height;
|
|
|
+ font.width = your_text_width_calculation;
|
|
|
+ font.query = query_your_font_glyph;
|
|
|
+ font.texture.id = your_font_texture;
|
|
|
+
|
|
|
+ struct nk_context ctx;
|
|
|
+ nk_init_default(&ctx, &font);
|
|
|
+
|
|
|
+ 3.) Nuklear font baker
|
|
|
+ ------------------------------------
|
|
|
+ The final approach if you do not have a font handling functionality or don't
|
|
|
+ want to use it in this library is by using the optional font baker.
|
|
|
+ The font baker API's can be used to create a font plus font atlas texture
|
|
|
+ and can be used with or without the vertex buffer output.
|
|
|
+
|
|
|
+ It still uses the `nk_user_font` struct and the two different approaches
|
|
|
+ previously stated still work. The font baker is not located inside
|
|
|
+ `nk_context` like all other systems since it can be understood as more of
|
|
|
+ an extension to nuklear and does not really depend on any `nk_context` state.
|
|
|
+
|
|
|
+ Font baker need to be initialized first by one of the nk_font_atlas_init_xxx
|
|
|
+ functions. If you don't care about memory just call the default version
|
|
|
+ `nk_font_atlas_init_default` which will allocate all memory from the standard library.
|
|
|
+ If you want to control memory allocation but you don't care if the allocated
|
|
|
+ memory is temporary and therefore can be freed directly after the baking process
|
|
|
+ is over or permanent you can call `nk_font_atlas_init`.
|
|
|
+
|
|
|
+ After successfull intializing the font baker you can add Truetype(.ttf) fonts from
|
|
|
+ different sources like memory or from file by calling one of the `nk_font_atlas_add_xxx`.
|
|
|
+ functions. Adding font will permanently store each font, font config and ttf memory block(!)
|
|
|
+ inside the font atlas and allows to reuse the font atlas. If you don't want to reuse
|
|
|
+ the font baker by for example adding additional fonts you can call
|
|
|
+ `nk_font_atlas_cleanup` after the baking process is over (after calling nk_font_atlas_end).
|
|
|
+
|
|
|
+ As soon as you added all fonts you wanted you can now start the baking process
|
|
|
+ for every selected glyphes to image by calling `nk_font_atlas_bake`.
|
|
|
+ The baking process returns image memory, width and height which can be used to
|
|
|
+ either create your own image object or upload it to any graphics library.
|
|
|
+ No matter which case you finally have to call `nk_font_atlas_end` which
|
|
|
+ will free all temporary memory including the font atlas image so make sure
|
|
|
+ you created our texture beforehand. `nk_font_atlas_end` requires a handle
|
|
|
+ to your font texture or object and optionally fills a `struct nk_draw_null_texture`
|
|
|
+ which can be used for the optional vertex output. If you don't want it just
|
|
|
+ set the argument to `NULL`.
|
|
|
+
|
|
|
+ At this point you are done and if you don't want to reuse the font atlas you
|
|
|
+ can call `nk_font_atlas_cleanup` to free all truetype blobs and configuration
|
|
|
+ memory. Finally if you don't use the font atlas and any of it's fonts anymore
|
|
|
+ you need to call `nk_font_atlas_clear` to free all memory still being used.
|
|
|
+
|
|
|
+ struct nk_font_atlas atlas;
|
|
|
+ nk_font_atlas_init_default(&atlas);
|
|
|
+ nk_font_atlas_begin(&atlas);
|
|
|
+ nk_font *font = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font.ttf", 13, 0);
|
|
|
+ nk_font *font2 = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font2.ttf", 16, 0);
|
|
|
+ const void* img = nk_font_atlas_bake(&atlas, &img_width, &img_height, NK_FONT_ATLAS_RGBA32);
|
|
|
+ nk_font_atlas_end(&atlas, nk_handle_id(texture), 0);
|
|
|
+
|
|
|
+ struct nk_context ctx;
|
|
|
+ nk_init_default(&ctx, &font->handle);
|
|
|
+ while (1) {
|
|
|
+
|
|
|
+ }
|
|
|
+ nk_font_atlas_clear(&atlas);
|
|
|
+
|
|
|
+ The font baker API is probably the most complex API inside this library and
|
|
|
+ I would suggest reading some of my examples `example/` to get a grip on how
|
|
|
+ to use the font atlas. There are a number of details I left out. For example
|
|
|
+ how to merge fonts, configure a font with `nk_font_config` to use other languages,
|
|
|
+ use another texture coodinate format and a lot more:
|
|
|
+
|
|
|
+ struct nk_font_config cfg = nk_font_config(font_pixel_height);
|
|
|
+ cfg.merge_mode = nk_false or nk_true;
|
|
|
+ cfg.range = nk_font_korean_glyph_ranges();
|
|
|
+ cfg.coord_type = NK_COORD_PIXEL;
|
|
|
+ nk_font *font = nk_font_atlas_add_from_file(&atlas, "Path/To/Your/TTF_Font.ttf", 13, &cfg);
|
|
|
+
|
|
|
+*/
|
|
|
+struct nk_user_font_glyph;
|
|
|
+typedef float(*nk_text_width_f)(nk_handle, float h, const char*, int len);
|
|
|
+typedef void(*nk_query_font_glyph_f)(nk_handle handle, float font_height,
|
|
|
+ struct nk_user_font_glyph *glyph,
|
|
|
+ nk_rune codepoint, nk_rune next_codepoint);
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+struct nk_user_font_glyph {
|
|
|
+ struct nk_vec2 uv[2];
|
|
|
+ /* texture coordinates */
|
|
|
+ struct nk_vec2 offset;
|
|
|
+ /* offset between top left and glyph */
|
|
|
+ float width, height;
|
|
|
+ /* size of the glyph */
|
|
|
+ float xadvance;
|
|
|
+ /* offset to the next glyph */
|
|
|
+};
|
|
|
+#endif
|
|
|
+
|
|
|
+struct nk_user_font {
|
|
|
+ nk_handle userdata;
|
|
|
+ /* user provided font handle */
|
|
|
+ float height;
|
|
|
+ /* max height of the font */
|
|
|
+ nk_text_width_f width;
|
|
|
+ /* font string width in pixel callback */
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ nk_query_font_glyph_f query;
|
|
|
+ /* font glyph callback to query drawing info */
|
|
|
+ nk_handle texture;
|
|
|
+ /* texture handle to the used font atlas or texture */
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_FONT_BAKING
|
|
|
+enum nk_font_coord_type {
|
|
|
+ NK_COORD_UV, /* texture coordinates inside font glyphs are clamped between 0-1 */
|
|
|
+ NK_COORD_PIXEL /* texture coordinates inside font glyphs are in absolute pixel */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_baked_font {
|
|
|
+ float height;
|
|
|
+ /* height of the font */
|
|
|
+ float ascent, descent;
|
|
|
+ /* font glyphs ascent and descent */
|
|
|
+ nk_rune glyph_offset;
|
|
|
+ /* glyph array offset inside the font glyph baking output array */
|
|
|
+ nk_rune glyph_count;
|
|
|
+ /* number of glyphs of this font inside the glyph baking array output */
|
|
|
+ const nk_rune *ranges;
|
|
|
+ /* font codepoint ranges as pairs of (from/to) and 0 as last element */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_font_config {
|
|
|
+ struct nk_font_config *next;
|
|
|
+ /* NOTE: only used internally */
|
|
|
+ void *ttf_blob;
|
|
|
+ /* pointer to loaded TTF file memory block.
|
|
|
+ * NOTE: not needed for nk_font_atlas_add_from_memory and nk_font_atlas_add_from_file. */
|
|
|
+ nk_size ttf_size;
|
|
|
+ /* size of the loaded TTF file memory block
|
|
|
+ * NOTE: not needed for nk_font_atlas_add_from_memory and nk_font_atlas_add_from_file. */
|
|
|
+
|
|
|
+ unsigned char ttf_data_owned_by_atlas;
|
|
|
+ /* used inside font atlas: default to: 0*/
|
|
|
+ unsigned char merge_mode;
|
|
|
+ /* merges this font into the last font */
|
|
|
+ unsigned char pixel_snap;
|
|
|
+ /* align every character to pixel boundary (if true set oversample (1,1)) */
|
|
|
+ unsigned char oversample_v, oversample_h;
|
|
|
+ /* rasterize at hight quality for sub-pixel position */
|
|
|
+ unsigned char padding[3];
|
|
|
+
|
|
|
+ float size;
|
|
|
+ /* baked pixel height of the font */
|
|
|
+ enum nk_font_coord_type coord_type;
|
|
|
+ /* texture coordinate format with either pixel or UV coordinates */
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+ /* extra pixel spacing between glyphs */
|
|
|
+ const nk_rune *range;
|
|
|
+ /* list of unicode ranges (2 values per range, zero terminated) */
|
|
|
+ struct nk_baked_font *font;
|
|
|
+ /* font to setup in the baking process: NOTE: not needed for font atlas */
|
|
|
+ nk_rune fallback_glyph;
|
|
|
+ /* fallback glyph to use if a given rune is not found */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_font_glyph {
|
|
|
+ nk_rune codepoint;
|
|
|
+ float xadvance;
|
|
|
+ float x0, y0, x1, y1, w, h;
|
|
|
+ float u0, v0, u1, v1;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_font {
|
|
|
+ struct nk_font *next;
|
|
|
+ struct nk_user_font handle;
|
|
|
+ struct nk_baked_font info;
|
|
|
+ float scale;
|
|
|
+ struct nk_font_glyph *glyphs;
|
|
|
+ const struct nk_font_glyph *fallback;
|
|
|
+ nk_rune fallback_codepoint;
|
|
|
+ nk_handle texture;
|
|
|
+ struct nk_font_config *config;
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_font_atlas_format {
|
|
|
+ NK_FONT_ATLAS_ALPHA8,
|
|
|
+ NK_FONT_ATLAS_RGBA32
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_font_atlas {
|
|
|
+ void *pixel;
|
|
|
+ int tex_width;
|
|
|
+ int tex_height;
|
|
|
+
|
|
|
+ struct nk_allocator permanent;
|
|
|
+ struct nk_allocator temporary;
|
|
|
+
|
|
|
+ struct nk_recti custom;
|
|
|
+ struct nk_cursor cursors[NK_CURSOR_COUNT];
|
|
|
+
|
|
|
+ int glyph_count;
|
|
|
+ struct nk_font_glyph *glyphs;
|
|
|
+ struct nk_font *default_font;
|
|
|
+ struct nk_font *fonts;
|
|
|
+ struct nk_font_config *config;
|
|
|
+ int font_num;
|
|
|
+};
|
|
|
+
|
|
|
+/* some language glyph codepoint ranges */
|
|
|
+NK_API const nk_rune *nk_font_default_glyph_ranges(void);
|
|
|
+NK_API const nk_rune *nk_font_chinese_glyph_ranges(void);
|
|
|
+NK_API const nk_rune *nk_font_cyrillic_glyph_ranges(void);
|
|
|
+NK_API const nk_rune *nk_font_korean_glyph_ranges(void);
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void nk_font_atlas_init_default(struct nk_font_atlas*);
|
|
|
+#endif
|
|
|
+NK_API void nk_font_atlas_init(struct nk_font_atlas*, struct nk_allocator*);
|
|
|
+NK_API void nk_font_atlas_init_custom(struct nk_font_atlas*, struct nk_allocator *persistent, struct nk_allocator *transient);
|
|
|
+NK_API void nk_font_atlas_begin(struct nk_font_atlas*);
|
|
|
+NK_API struct nk_font_config nk_font_config(float pixel_height);
|
|
|
+NK_API struct nk_font *nk_font_atlas_add(struct nk_font_atlas*, const struct nk_font_config*);
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_FONT
|
|
|
+NK_API struct nk_font* nk_font_atlas_add_default(struct nk_font_atlas*, float height, const struct nk_font_config*);
|
|
|
+#endif
|
|
|
+NK_API struct nk_font* nk_font_atlas_add_from_memory(struct nk_font_atlas *atlas, void *memory, nk_size size, float height, const struct nk_font_config *config);
|
|
|
+#ifdef NK_INCLUDE_STANDARD_IO
|
|
|
+NK_API struct nk_font* nk_font_atlas_add_from_file(struct nk_font_atlas *atlas, const char *file_path, float height, const struct nk_font_config*);
|
|
|
+#endif
|
|
|
+NK_API struct nk_font *nk_font_atlas_add_compressed(struct nk_font_atlas*, void *memory, nk_size size, float height, const struct nk_font_config*);
|
|
|
+NK_API struct nk_font* nk_font_atlas_add_compressed_base85(struct nk_font_atlas*, const char *data, float height, const struct nk_font_config *config);
|
|
|
+NK_API const void* nk_font_atlas_bake(struct nk_font_atlas*, int *width, int *height, enum nk_font_atlas_format);
|
|
|
+NK_API void nk_font_atlas_end(struct nk_font_atlas*, nk_handle tex, struct nk_draw_null_texture*);
|
|
|
+NK_API const struct nk_font_glyph* nk_font_find_glyph(struct nk_font*, nk_rune unicode);
|
|
|
+NK_API void nk_font_atlas_cleanup(struct nk_font_atlas *atlas);
|
|
|
+NK_API void nk_font_atlas_clear(struct nk_font_atlas*);
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * MEMORY BUFFER
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+/* A basic (double)-buffer with linear allocation and resetting as only
|
|
|
+ freeing policy. The buffer's main purpose is to control all memory management
|
|
|
+ inside the GUI toolkit and still leave memory control as much as possible in
|
|
|
+ the hand of the user while also making sure the library is easy to use if
|
|
|
+ not as much control is needed.
|
|
|
+ In general all memory inside this library can be provided from the user in
|
|
|
+ three different ways.
|
|
|
+
|
|
|
+ The first way and the one providing most control is by just passing a fixed
|
|
|
+ size memory block. In this case all control lies in the hand of the user
|
|
|
+ since he can exactly control where the memory comes from and how much memory
|
|
|
+ the library should consume. Of course using the fixed size API removes the
|
|
|
+ ability to automatically resize a buffer if not enough memory is provided so
|
|
|
+ you have to take over the resizing. While being a fixed sized buffer sounds
|
|
|
+ quite limiting, it is very effective in this library since the actual memory
|
|
|
+ consumption is quite stable and has a fixed upper bound for a lot of cases.
|
|
|
+
|
|
|
+ If you don't want to think about how much memory the library should allocate
|
|
|
+ at all time or have a very dynamic UI with unpredictable memory consumption
|
|
|
+ habits but still want control over memory allocation you can use the dynamic
|
|
|
+ allocator based API. The allocator consists of two callbacks for allocating
|
|
|
+ and freeing memory and optional userdata so you can plugin your own allocator.
|
|
|
+
|
|
|
+ The final and easiest way can be used by defining
|
|
|
+ NK_INCLUDE_DEFAULT_ALLOCATOR which uses the standard library memory
|
|
|
+ allocation functions malloc and free and takes over complete control over
|
|
|
+ memory in this library.
|
|
|
+*/
|
|
|
+struct nk_memory_status {
|
|
|
+ void *memory;
|
|
|
+ unsigned int type;
|
|
|
+ nk_size size;
|
|
|
+ nk_size allocated;
|
|
|
+ nk_size needed;
|
|
|
+ nk_size calls;
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_allocation_type {
|
|
|
+ NK_BUFFER_FIXED,
|
|
|
+ NK_BUFFER_DYNAMIC
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_buffer_allocation_type {
|
|
|
+ NK_BUFFER_FRONT,
|
|
|
+ NK_BUFFER_BACK,
|
|
|
+ NK_BUFFER_MAX
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_buffer_marker {
|
|
|
+ int active;
|
|
|
+ nk_size offset;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_memory {void *ptr;nk_size size;};
|
|
|
+struct nk_buffer {
|
|
|
+ struct nk_buffer_marker marker[NK_BUFFER_MAX];
|
|
|
+ /* buffer marker to free a buffer to a certain offset */
|
|
|
+ struct nk_allocator pool;
|
|
|
+ /* allocator callback for dynamic buffers */
|
|
|
+ enum nk_allocation_type type;
|
|
|
+ /* memory management type */
|
|
|
+ struct nk_memory memory;
|
|
|
+ /* memory and size of the current memory block */
|
|
|
+ float grow_factor;
|
|
|
+ /* growing factor for dynamic memory management */
|
|
|
+ nk_size allocated;
|
|
|
+ /* total amount of memory allocated */
|
|
|
+ nk_size needed;
|
|
|
+ /* totally consumed memory given that enough memory is present */
|
|
|
+ nk_size calls;
|
|
|
+ /* number of allocation calls */
|
|
|
+ nk_size size;
|
|
|
+ /* current size of the buffer */
|
|
|
+};
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void nk_buffer_init_default(struct nk_buffer*);
|
|
|
+#endif
|
|
|
+NK_API void nk_buffer_init(struct nk_buffer*, const struct nk_allocator*, nk_size size);
|
|
|
+NK_API void nk_buffer_init_fixed(struct nk_buffer*, void *memory, nk_size size);
|
|
|
+NK_API void nk_buffer_info(struct nk_memory_status*, struct nk_buffer*);
|
|
|
+NK_API void nk_buffer_push(struct nk_buffer*, enum nk_buffer_allocation_type type, const void *memory, nk_size size, nk_size align);
|
|
|
+NK_API void nk_buffer_mark(struct nk_buffer*, enum nk_buffer_allocation_type type);
|
|
|
+NK_API void nk_buffer_reset(struct nk_buffer*, enum nk_buffer_allocation_type type);
|
|
|
+NK_API void nk_buffer_clear(struct nk_buffer*);
|
|
|
+NK_API void nk_buffer_free(struct nk_buffer*);
|
|
|
+NK_API void *nk_buffer_memory(struct nk_buffer*);
|
|
|
+NK_API const void *nk_buffer_memory_const(const struct nk_buffer*);
|
|
|
+NK_API nk_size nk_buffer_total(struct nk_buffer*);
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * STRING
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+/* Basic string buffer which is only used in context with the text editor
|
|
|
+ * to manage and manipulate dynamic or fixed size string content. This is _NOT_
|
|
|
+ * the default string handling method. The only instance you should have any contact
|
|
|
+ * with this API is if you interact with an `nk_text_edit` object inside one of the
|
|
|
+ * copy and paste functions and even there only for more advanced cases. */
|
|
|
+struct nk_str {
|
|
|
+ struct nk_buffer buffer;
|
|
|
+ int len; /* in codepoints/runes/glyphs */
|
|
|
+};
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void nk_str_init_default(struct nk_str*);
|
|
|
+#endif
|
|
|
+NK_API void nk_str_init(struct nk_str*, const struct nk_allocator*, nk_size size);
|
|
|
+NK_API void nk_str_init_fixed(struct nk_str*, void *memory, nk_size size);
|
|
|
+NK_API void nk_str_clear(struct nk_str*);
|
|
|
+NK_API void nk_str_free(struct nk_str*);
|
|
|
+
|
|
|
+NK_API int nk_str_append_text_char(struct nk_str*, const char*, int);
|
|
|
+NK_API int nk_str_append_str_char(struct nk_str*, const char*);
|
|
|
+NK_API int nk_str_append_text_utf8(struct nk_str*, const char*, int);
|
|
|
+NK_API int nk_str_append_str_utf8(struct nk_str*, const char*);
|
|
|
+NK_API int nk_str_append_text_runes(struct nk_str*, const nk_rune*, int);
|
|
|
+NK_API int nk_str_append_str_runes(struct nk_str*, const nk_rune*);
|
|
|
+
|
|
|
+NK_API int nk_str_insert_at_char(struct nk_str*, int pos, const char*, int);
|
|
|
+NK_API int nk_str_insert_at_rune(struct nk_str*, int pos, const char*, int);
|
|
|
+
|
|
|
+NK_API int nk_str_insert_text_char(struct nk_str*, int pos, const char*, int);
|
|
|
+NK_API int nk_str_insert_str_char(struct nk_str*, int pos, const char*);
|
|
|
+NK_API int nk_str_insert_text_utf8(struct nk_str*, int pos, const char*, int);
|
|
|
+NK_API int nk_str_insert_str_utf8(struct nk_str*, int pos, const char*);
|
|
|
+NK_API int nk_str_insert_text_runes(struct nk_str*, int pos, const nk_rune*, int);
|
|
|
+NK_API int nk_str_insert_str_runes(struct nk_str*, int pos, const nk_rune*);
|
|
|
+
|
|
|
+NK_API void nk_str_remove_chars(struct nk_str*, int len);
|
|
|
+NK_API void nk_str_remove_runes(struct nk_str *str, int len);
|
|
|
+NK_API void nk_str_delete_chars(struct nk_str*, int pos, int len);
|
|
|
+NK_API void nk_str_delete_runes(struct nk_str*, int pos, int len);
|
|
|
+
|
|
|
+NK_API char *nk_str_at_char(struct nk_str*, int pos);
|
|
|
+NK_API char *nk_str_at_rune(struct nk_str*, int pos, nk_rune *unicode, int *len);
|
|
|
+NK_API nk_rune nk_str_rune_at(const struct nk_str*, int pos);
|
|
|
+NK_API const char *nk_str_at_char_const(const struct nk_str*, int pos);
|
|
|
+NK_API const char *nk_str_at_const(const struct nk_str*, int pos, nk_rune *unicode, int *len);
|
|
|
+
|
|
|
+NK_API char *nk_str_get(struct nk_str*);
|
|
|
+NK_API const char *nk_str_get_const(const struct nk_str*);
|
|
|
+NK_API int nk_str_len(struct nk_str*);
|
|
|
+NK_API int nk_str_len_char(struct nk_str*);
|
|
|
+
|
|
|
+/*===============================================================
|
|
|
+ *
|
|
|
+ * TEXT EDITOR
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+/* Editing text in this library is handled by either `nk_edit_string` or
|
|
|
+ * `nk_edit_buffer`. But like almost everything in this library there are multiple
|
|
|
+ * ways of doing it and a balance between control and ease of use with memory
|
|
|
+ * as well as functionality controlled by flags.
|
|
|
+ *
|
|
|
+ * This library generally allows three different levels of memory control:
|
|
|
+ * First of is the most basic way of just providing a simple char array with
|
|
|
+ * string length. This method is probably the easiest way of handling simple
|
|
|
+ * user text input. Main upside is complete control over memory while the biggest
|
|
|
+ * downside in comparsion with the other two approaches is missing undo/redo.
|
|
|
+ *
|
|
|
+ * For UIs that require undo/redo the second way was created. It is based on
|
|
|
+ * a fixed size nk_text_edit struct, which has an internal undo/redo stack.
|
|
|
+ * This is mainly useful if you want something more like a text editor but don't want
|
|
|
+ * to have a dynamically growing buffer.
|
|
|
+ *
|
|
|
+ * The final way is using a dynamically growing nk_text_edit struct, which
|
|
|
+ * has both a default version if you don't care where memory comes from and an
|
|
|
+ * allocator version if you do. While the text editor is quite powerful for its
|
|
|
+ * complexity I would not recommend editing gigabytes of data with it.
|
|
|
+ * It is rather designed for uses cases which make sense for a GUI library not for
|
|
|
+ * an full blown text editor.
|
|
|
+ */
|
|
|
+#ifndef NK_TEXTEDIT_UNDOSTATECOUNT
|
|
|
+#define NK_TEXTEDIT_UNDOSTATECOUNT 99
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_TEXTEDIT_UNDOCHARCOUNT
|
|
|
+#define NK_TEXTEDIT_UNDOCHARCOUNT 999
|
|
|
+#endif
|
|
|
+
|
|
|
+struct nk_text_edit;
|
|
|
+struct nk_clipboard {
|
|
|
+ nk_handle userdata;
|
|
|
+ nk_plugin_paste paste;
|
|
|
+ nk_plugin_copy copy;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_text_undo_record {
|
|
|
+ int where;
|
|
|
+ short insert_length;
|
|
|
+ short delete_length;
|
|
|
+ short char_storage;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_text_undo_state {
|
|
|
+ struct nk_text_undo_record undo_rec[NK_TEXTEDIT_UNDOSTATECOUNT];
|
|
|
+ nk_rune undo_char[NK_TEXTEDIT_UNDOCHARCOUNT];
|
|
|
+ short undo_point;
|
|
|
+ short redo_point;
|
|
|
+ short undo_char_point;
|
|
|
+ short redo_char_point;
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_text_edit_type {
|
|
|
+ NK_TEXT_EDIT_SINGLE_LINE,
|
|
|
+ NK_TEXT_EDIT_MULTI_LINE
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_text_edit_mode {
|
|
|
+ NK_TEXT_EDIT_MODE_VIEW,
|
|
|
+ NK_TEXT_EDIT_MODE_INSERT,
|
|
|
+ NK_TEXT_EDIT_MODE_REPLACE
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_text_edit {
|
|
|
+ struct nk_clipboard clip;
|
|
|
+ struct nk_str string;
|
|
|
+ nk_plugin_filter filter;
|
|
|
+ struct nk_vec2 scrollbar;
|
|
|
+
|
|
|
+ int cursor;
|
|
|
+ int select_start;
|
|
|
+ int select_end;
|
|
|
+ unsigned char mode;
|
|
|
+ unsigned char cursor_at_end_of_line;
|
|
|
+ unsigned char initialized;
|
|
|
+ unsigned char has_preferred_x;
|
|
|
+ unsigned char single_line;
|
|
|
+ unsigned char active;
|
|
|
+ unsigned char padding1;
|
|
|
+ float preferred_x;
|
|
|
+ struct nk_text_undo_state undo;
|
|
|
+};
|
|
|
+
|
|
|
+/* filter function */
|
|
|
+NK_API int nk_filter_default(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_ascii(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_float(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_decimal(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_hex(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_oct(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+NK_API int nk_filter_binary(const struct nk_text_edit*, nk_rune unicode);
|
|
|
+
|
|
|
+/* text editor */
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void nk_textedit_init_default(struct nk_text_edit*);
|
|
|
+#endif
|
|
|
+NK_API void nk_textedit_init(struct nk_text_edit*, struct nk_allocator*, nk_size size);
|
|
|
+NK_API void nk_textedit_init_fixed(struct nk_text_edit*, void *memory, nk_size size);
|
|
|
+NK_API void nk_textedit_free(struct nk_text_edit*);
|
|
|
+NK_API void nk_textedit_text(struct nk_text_edit*, const char*, int total_len);
|
|
|
+NK_API void nk_textedit_delete(struct nk_text_edit*, int where, int len);
|
|
|
+NK_API void nk_textedit_delete_selection(struct nk_text_edit*);
|
|
|
+NK_API void nk_textedit_select_all(struct nk_text_edit*);
|
|
|
+NK_API int nk_textedit_cut(struct nk_text_edit*);
|
|
|
+NK_API int nk_textedit_paste(struct nk_text_edit*, char const*, int len);
|
|
|
+NK_API void nk_textedit_undo(struct nk_text_edit*);
|
|
|
+NK_API void nk_textedit_redo(struct nk_text_edit*);
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * DRAWING
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+/* This library was designed to be render backend agnostic so it does
|
|
|
+ not draw anything to screen. Instead all drawn shapes, widgets
|
|
|
+ are made of, are buffered into memory and make up a command queue.
|
|
|
+ Each frame therefore fills the command buffer with draw commands
|
|
|
+ that then need to be executed by the user and his own render backend.
|
|
|
+ After that the command buffer needs to be cleared and a new frame can be
|
|
|
+ started. It is probably important to note that the command buffer is the main
|
|
|
+ drawing API and the optional vertex buffer API only takes this format and
|
|
|
+ converts it into a hardware accessible format.
|
|
|
+
|
|
|
+ To use the command queue to draw your own widgets you can access the
|
|
|
+ command buffer of each window by calling `nk_window_get_canvas` after
|
|
|
+ previously having called `nk_begin`:
|
|
|
+
|
|
|
+ void draw_red_rectangle_widget(struct nk_context *ctx)
|
|
|
+ {
|
|
|
+ struct nk_command_buffer *canvas;
|
|
|
+ struct nk_input *input = &ctx->input;
|
|
|
+ canvas = nk_window_get_canvas(ctx);
|
|
|
+
|
|
|
+ struct nk_rect space;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ state = nk_widget(&space, ctx);
|
|
|
+ if (!state) return;
|
|
|
+
|
|
|
+ if (state != NK_WIDGET_ROM)
|
|
|
+ update_your_widget_by_user_input(...);
|
|
|
+ nk_fill_rect(canvas, space, 0, nk_rgb(255,0,0));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nk_begin(...)) {
|
|
|
+ nk_layout_row_dynamic(ctx, 25, 1);
|
|
|
+ draw_red_rectangle_widget(ctx);
|
|
|
+ }
|
|
|
+ nk_end(..)
|
|
|
+
|
|
|
+ Important to know if you want to create your own widgets is the `nk_widget`
|
|
|
+ call. It allocates space on the panel reserved for this widget to be used,
|
|
|
+ but also returns the state of the widget space. If your widget is not seen and does
|
|
|
+ not have to be updated it is '0' and you can just return. If it only has
|
|
|
+ to be drawn the state will be `NK_WIDGET_ROM` otherwise you can do both
|
|
|
+ update and draw your widget. The reason for seperating is to only draw and
|
|
|
+ update what is actually neccessary which is crucial for performance.
|
|
|
+*/
|
|
|
+enum nk_command_type {
|
|
|
+ NK_COMMAND_NOP,
|
|
|
+ NK_COMMAND_SCISSOR,
|
|
|
+ NK_COMMAND_LINE,
|
|
|
+ NK_COMMAND_CURVE,
|
|
|
+ NK_COMMAND_RECT,
|
|
|
+ NK_COMMAND_RECT_FILLED,
|
|
|
+ NK_COMMAND_RECT_MULTI_COLOR,
|
|
|
+ NK_COMMAND_CIRCLE,
|
|
|
+ NK_COMMAND_CIRCLE_FILLED,
|
|
|
+ NK_COMMAND_ARC,
|
|
|
+ NK_COMMAND_ARC_FILLED,
|
|
|
+ NK_COMMAND_TRIANGLE,
|
|
|
+ NK_COMMAND_TRIANGLE_FILLED,
|
|
|
+ NK_COMMAND_POLYGON,
|
|
|
+ NK_COMMAND_POLYGON_FILLED,
|
|
|
+ NK_COMMAND_POLYLINE,
|
|
|
+ NK_COMMAND_TEXT,
|
|
|
+ NK_COMMAND_IMAGE,
|
|
|
+ NK_COMMAND_CUSTOM
|
|
|
+};
|
|
|
+
|
|
|
+/* command base and header of every command inside the buffer */
|
|
|
+struct nk_command {
|
|
|
+ enum nk_command_type type;
|
|
|
+ nk_size next;
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_handle userdata;
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_scissor {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_line {
|
|
|
+ struct nk_command header;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ struct nk_vec2i begin;
|
|
|
+ struct nk_vec2i 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];
|
|
|
+ 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;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_rect_filled {
|
|
|
+ struct nk_command header;
|
|
|
+ unsigned short rounding;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_rect_multi_color {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ struct nk_color left;
|
|
|
+ struct nk_color top;
|
|
|
+ struct nk_color bottom;
|
|
|
+ struct nk_color right;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_triangle {
|
|
|
+ struct nk_command header;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ struct nk_vec2i a;
|
|
|
+ struct nk_vec2i b;
|
|
|
+ struct nk_vec2i 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;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_circle {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ unsigned short w, h;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_circle_filled {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_arc {
|
|
|
+ struct nk_command header;
|
|
|
+ short cx, cy;
|
|
|
+ unsigned short r;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ float a[2];
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_arc_filled {
|
|
|
+ struct nk_command header;
|
|
|
+ short cx, cy;
|
|
|
+ unsigned short r;
|
|
|
+ float a[2];
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_polygon {
|
|
|
+ struct nk_command header;
|
|
|
+ struct nk_color color;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ unsigned short point_count;
|
|
|
+ struct nk_vec2i points[1];
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_polygon_filled {
|
|
|
+ struct nk_command header;
|
|
|
+ struct nk_color color;
|
|
|
+ unsigned short point_count;
|
|
|
+ struct nk_vec2i points[1];
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_polyline {
|
|
|
+ struct nk_command header;
|
|
|
+ struct nk_color color;
|
|
|
+ unsigned short line_thickness;
|
|
|
+ unsigned short point_count;
|
|
|
+ struct nk_vec2i points[1];
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_image {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ struct nk_image img;
|
|
|
+ struct nk_color col;
|
|
|
+};
|
|
|
+
|
|
|
+typedef void (*nk_command_custom_callback)(void *canvas, short x,short y,
|
|
|
+ unsigned short w, unsigned short h, nk_handle callback_data);
|
|
|
+struct nk_command_custom {
|
|
|
+ struct nk_command header;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ nk_handle callback_data;
|
|
|
+ nk_command_custom_callback callback;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_text {
|
|
|
+ struct nk_command header;
|
|
|
+ const struct nk_user_font *font;
|
|
|
+ struct nk_color background;
|
|
|
+ struct nk_color foreground;
|
|
|
+ short x, y;
|
|
|
+ unsigned short w, h;
|
|
|
+ float height;
|
|
|
+ int length;
|
|
|
+ char string[1];
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_command_clipping {
|
|
|
+ NK_CLIPPING_OFF = nk_false,
|
|
|
+ NK_CLIPPING_ON = nk_true
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_command_buffer {
|
|
|
+ struct nk_buffer *base;
|
|
|
+ struct nk_rect clip;
|
|
|
+ int use_clipping;
|
|
|
+ nk_handle userdata;
|
|
|
+ nk_size begin, end, last;
|
|
|
+};
|
|
|
+
|
|
|
+/* shape outlines */
|
|
|
+NK_API void nk_stroke_line(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(struct nk_command_buffer*, float, float, float, float, float, float, float, float, float line_thickness, struct nk_color);
|
|
|
+NK_API void nk_stroke_rect(struct nk_command_buffer*, struct nk_rect, float rounding, float line_thickness, struct nk_color);
|
|
|
+NK_API void nk_stroke_circle(struct nk_command_buffer*, struct nk_rect, float line_thickness, struct nk_color);
|
|
|
+NK_API void nk_stroke_arc(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(struct nk_command_buffer*, float, float, float, float, float, float, float line_thichness, struct nk_color);
|
|
|
+NK_API void nk_stroke_polyline(struct nk_command_buffer*, float *points, int point_count, float line_thickness, struct nk_color col);
|
|
|
+NK_API void nk_stroke_polygon(struct nk_command_buffer*, float*, int point_count, float line_thickness, struct nk_color);
|
|
|
+
|
|
|
+/* filled shades */
|
|
|
+NK_API void nk_fill_rect(struct nk_command_buffer*, struct nk_rect, float rounding, struct nk_color);
|
|
|
+NK_API void nk_fill_rect_multi_color(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(struct nk_command_buffer*, struct nk_rect, struct nk_color);
|
|
|
+NK_API void nk_fill_arc(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(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(struct nk_command_buffer*, float*, int point_count, struct nk_color);
|
|
|
+
|
|
|
+/* misc */
|
|
|
+NK_API void nk_draw_image(struct nk_command_buffer*, struct nk_rect, const struct nk_image*, struct nk_color);
|
|
|
+NK_API void nk_draw_text(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(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);
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * INPUT
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+struct nk_mouse_button {
|
|
|
+ int down;
|
|
|
+ unsigned int clicked;
|
|
|
+ struct nk_vec2 clicked_pos;
|
|
|
+};
|
|
|
+struct nk_mouse {
|
|
|
+ struct nk_mouse_button buttons[NK_BUTTON_MAX];
|
|
|
+ struct nk_vec2 pos;
|
|
|
+ struct nk_vec2 prev;
|
|
|
+ struct nk_vec2 delta;
|
|
|
+ struct nk_vec2 scroll_delta;
|
|
|
+ unsigned char grab;
|
|
|
+ unsigned char grabbed;
|
|
|
+ unsigned char ungrab;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_key {
|
|
|
+ int down;
|
|
|
+ unsigned int clicked;
|
|
|
+};
|
|
|
+struct nk_keyboard {
|
|
|
+ struct nk_key keys[NK_KEY_MAX];
|
|
|
+ char text[NK_INPUT_MAX];
|
|
|
+ int text_len;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_input {
|
|
|
+ struct nk_keyboard keyboard;
|
|
|
+ struct nk_mouse mouse;
|
|
|
+};
|
|
|
+
|
|
|
+NK_API int nk_input_has_mouse_click(const struct nk_input*, enum nk_buttons);
|
|
|
+NK_API int nk_input_has_mouse_click_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect);
|
|
|
+NK_API int nk_input_has_mouse_click_down_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect, int down);
|
|
|
+NK_API int nk_input_is_mouse_click_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect);
|
|
|
+NK_API int nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id, struct nk_rect b, int down);
|
|
|
+NK_API int nk_input_any_mouse_click_in_rect(const struct nk_input*, struct nk_rect);
|
|
|
+NK_API int nk_input_is_mouse_prev_hovering_rect(const struct nk_input*, struct nk_rect);
|
|
|
+NK_API int nk_input_is_mouse_hovering_rect(const struct nk_input*, struct nk_rect);
|
|
|
+NK_API int nk_input_mouse_clicked(const struct nk_input*, enum nk_buttons, struct nk_rect);
|
|
|
+NK_API int nk_input_is_mouse_down(const struct nk_input*, enum nk_buttons);
|
|
|
+NK_API int nk_input_is_mouse_pressed(const struct nk_input*, enum nk_buttons);
|
|
|
+NK_API int nk_input_is_mouse_released(const struct nk_input*, enum nk_buttons);
|
|
|
+NK_API int nk_input_is_key_pressed(const struct nk_input*, enum nk_keys);
|
|
|
+NK_API int nk_input_is_key_released(const struct nk_input*, enum nk_keys);
|
|
|
+NK_API int nk_input_is_key_down(const struct nk_input*, enum nk_keys);
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * DRAW LIST
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+/* The optional vertex buffer draw list provides a 2D drawing context
|
|
|
+ with antialiasing functionality which takes basic filled or outlined shapes
|
|
|
+ or a path and outputs vertexes, elements and draw commands.
|
|
|
+ The actual draw list API is not required to be used directly while using this
|
|
|
+ library since converting the default library draw command output is done by
|
|
|
+ just calling `nk_convert` but I decided to still make this library accessible
|
|
|
+ since it can be useful.
|
|
|
+
|
|
|
+ The draw list is based on a path buffering and polygon and polyline
|
|
|
+ rendering API which allows a lot of ways to draw 2D content to screen.
|
|
|
+ In fact it is probably more powerful than needed but allows even more crazy
|
|
|
+ things than this library provides by default.
|
|
|
+*/
|
|
|
+typedef nk_ushort nk_draw_index;
|
|
|
+enum nk_draw_list_stroke {
|
|
|
+ NK_STROKE_OPEN = nk_false,
|
|
|
+ /* build up path has no connection back to the beginning */
|
|
|
+ NK_STROKE_CLOSED = nk_true
|
|
|
+ /* build up path has a connection back to the beginning */
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_draw_vertex_layout_attribute {
|
|
|
+ NK_VERTEX_POSITION,
|
|
|
+ NK_VERTEX_COLOR,
|
|
|
+ NK_VERTEX_TEXCOORD,
|
|
|
+ NK_VERTEX_ATTRIBUTE_COUNT
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_draw_vertex_layout_format {
|
|
|
+ NK_FORMAT_SCHAR,
|
|
|
+ NK_FORMAT_SSHORT,
|
|
|
+ NK_FORMAT_SINT,
|
|
|
+ NK_FORMAT_UCHAR,
|
|
|
+ NK_FORMAT_USHORT,
|
|
|
+ NK_FORMAT_UINT,
|
|
|
+ NK_FORMAT_FLOAT,
|
|
|
+ NK_FORMAT_DOUBLE,
|
|
|
+
|
|
|
+NK_FORMAT_COLOR_BEGIN,
|
|
|
+ NK_FORMAT_R8G8B8 = NK_FORMAT_COLOR_BEGIN,
|
|
|
+ NK_FORMAT_R16G15B16,
|
|
|
+ NK_FORMAT_R32G32B32,
|
|
|
+
|
|
|
+ NK_FORMAT_R8G8B8A8,
|
|
|
+ NK_FORMAT_B8G8R8A8,
|
|
|
+ NK_FORMAT_R16G15B16A16,
|
|
|
+ NK_FORMAT_R32G32B32A32,
|
|
|
+ NK_FORMAT_R32G32B32A32_FLOAT,
|
|
|
+ NK_FORMAT_R32G32B32A32_DOUBLE,
|
|
|
+
|
|
|
+ NK_FORMAT_RGB32,
|
|
|
+ NK_FORMAT_RGBA32,
|
|
|
+NK_FORMAT_COLOR_END = NK_FORMAT_RGBA32,
|
|
|
+ NK_FORMAT_COUNT
|
|
|
+};
|
|
|
+
|
|
|
+#define NK_VERTEX_LAYOUT_END NK_VERTEX_ATTRIBUTE_COUNT,NK_FORMAT_COUNT,0
|
|
|
+struct nk_draw_vertex_layout_element {
|
|
|
+ enum nk_draw_vertex_layout_attribute attribute;
|
|
|
+ enum nk_draw_vertex_layout_format format;
|
|
|
+ nk_size offset;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_draw_command {
|
|
|
+ unsigned int elem_count;
|
|
|
+ /* number of elements in the current draw batch */
|
|
|
+ struct nk_rect clip_rect;
|
|
|
+ /* current screen clipping rectangle */
|
|
|
+ nk_handle texture;
|
|
|
+ /* current texture to set */
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_handle userdata;
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_draw_list {
|
|
|
+ struct nk_rect clip_rect;
|
|
|
+ struct nk_vec2 circle_vtx[12];
|
|
|
+ struct nk_convert_config config;
|
|
|
+
|
|
|
+ struct nk_buffer *buffer;
|
|
|
+ struct nk_buffer *vertices;
|
|
|
+ struct nk_buffer *elements;
|
|
|
+
|
|
|
+ unsigned int element_count;
|
|
|
+ unsigned int vertex_count;
|
|
|
+ unsigned int cmd_count;
|
|
|
+ nk_size cmd_offset;
|
|
|
+
|
|
|
+ unsigned int path_count;
|
|
|
+ unsigned int path_offset;
|
|
|
+
|
|
|
+ enum nk_anti_aliasing line_AA;
|
|
|
+ enum nk_anti_aliasing shape_AA;
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_handle userdata;
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+/* draw list */
|
|
|
+NK_API void nk_draw_list_init(struct nk_draw_list*);
|
|
|
+NK_API void nk_draw_list_setup(struct nk_draw_list*, const struct nk_convert_config*, struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements, enum nk_anti_aliasing line_aa,enum nk_anti_aliasing shape_aa);
|
|
|
+NK_API void nk_draw_list_clear(struct nk_draw_list*);
|
|
|
+
|
|
|
+/* drawing */
|
|
|
+#define nk_draw_list_foreach(cmd, can, b) for((cmd)=nk__draw_list_begin(can, b); (cmd)!=0; (cmd)=nk__draw_list_next(cmd, b, can))
|
|
|
+NK_API const struct nk_draw_command* nk__draw_list_begin(const struct nk_draw_list*, const struct nk_buffer*);
|
|
|
+NK_API const struct nk_draw_command* nk__draw_list_next(const struct nk_draw_command*, const struct nk_buffer*, const struct nk_draw_list*);
|
|
|
+NK_API const struct nk_draw_command* nk__draw_list_end(const struct nk_draw_list*, const struct nk_buffer*);
|
|
|
+NK_API void nk_draw_list_clear(struct nk_draw_list *list);
|
|
|
+
|
|
|
+/* path */
|
|
|
+NK_API void nk_draw_list_path_clear(struct nk_draw_list*);
|
|
|
+NK_API void nk_draw_list_path_line_to(struct nk_draw_list*, struct nk_vec2 pos);
|
|
|
+NK_API void nk_draw_list_path_arc_to_fast(struct nk_draw_list*, struct nk_vec2 center, float radius, int a_min, int a_max);
|
|
|
+NK_API void nk_draw_list_path_arc_to(struct nk_draw_list*, struct nk_vec2 center, float radius, float a_min, float a_max, unsigned int segments);
|
|
|
+NK_API void nk_draw_list_path_rect_to(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, float rounding);
|
|
|
+NK_API void nk_draw_list_path_curve_to(struct nk_draw_list*, struct nk_vec2 p2, struct nk_vec2 p3, struct nk_vec2 p4, unsigned int num_segments);
|
|
|
+NK_API void nk_draw_list_path_fill(struct nk_draw_list*, struct nk_color);
|
|
|
+NK_API void nk_draw_list_path_stroke(struct nk_draw_list*, struct nk_color, enum nk_draw_list_stroke closed, float thickness);
|
|
|
+
|
|
|
+/* stroke */
|
|
|
+NK_API void nk_draw_list_stroke_line(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_color, float thickness);
|
|
|
+NK_API void nk_draw_list_stroke_rect(struct nk_draw_list*, struct nk_rect rect, struct nk_color, float rounding, float thickness);
|
|
|
+NK_API void nk_draw_list_stroke_triangle(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_vec2 c, struct nk_color, float thickness);
|
|
|
+NK_API void nk_draw_list_stroke_circle(struct nk_draw_list*, struct nk_vec2 center, float radius, struct nk_color, unsigned int segs, float thickness);
|
|
|
+NK_API void nk_draw_list_stroke_curve(struct nk_draw_list*, struct nk_vec2 p0, struct nk_vec2 cp0, struct nk_vec2 cp1, struct nk_vec2 p1, struct nk_color, unsigned int segments, float thickness);
|
|
|
+NK_API void nk_draw_list_stroke_poly_line(struct nk_draw_list*, const struct nk_vec2 *pnts, const unsigned int cnt, struct nk_color, enum nk_draw_list_stroke, float thickness, enum nk_anti_aliasing);
|
|
|
+
|
|
|
+/* fill */
|
|
|
+NK_API void nk_draw_list_fill_rect(struct nk_draw_list*, struct nk_rect rect, struct nk_color, float rounding);
|
|
|
+NK_API void nk_draw_list_fill_rect_multi_color(struct nk_draw_list*, struct nk_rect rect, struct nk_color left, struct nk_color top, struct nk_color right, struct nk_color bottom);
|
|
|
+NK_API void nk_draw_list_fill_triangle(struct nk_draw_list*, struct nk_vec2 a, struct nk_vec2 b, struct nk_vec2 c, struct nk_color);
|
|
|
+NK_API void nk_draw_list_fill_circle(struct nk_draw_list*, struct nk_vec2 center, float radius, struct nk_color col, unsigned int segs);
|
|
|
+NK_API void nk_draw_list_fill_poly_convex(struct nk_draw_list*, const struct nk_vec2 *points, const unsigned int count, struct nk_color, enum nk_anti_aliasing);
|
|
|
+
|
|
|
+/* misc */
|
|
|
+NK_API void nk_draw_list_add_image(struct nk_draw_list*, struct nk_image texture, struct nk_rect rect, struct nk_color);
|
|
|
+NK_API void nk_draw_list_add_text(struct nk_draw_list*, const struct nk_user_font*, struct nk_rect, const char *text, int len, float font_height, struct nk_color);
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+NK_API void nk_draw_list_push_userdata(struct nk_draw_list*, nk_handle userdata);
|
|
|
+#endif
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * GUI
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+enum nk_style_item_type {
|
|
|
+ NK_STYLE_ITEM_COLOR,
|
|
|
+ NK_STYLE_ITEM_IMAGE
|
|
|
+};
|
|
|
+
|
|
|
+union nk_style_item_data {
|
|
|
+ struct nk_image image;
|
|
|
+ struct nk_color color;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_item {
|
|
|
+ enum nk_style_item_type type;
|
|
|
+ union nk_style_item_data data;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_text {
|
|
|
+ struct nk_color color;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_button {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* text */
|
|
|
+ struct nk_color text_background;
|
|
|
+ struct nk_color text_normal;
|
|
|
+ struct nk_color text_hover;
|
|
|
+ struct nk_color text_active;
|
|
|
+ nk_flags text_alignment;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 image_padding;
|
|
|
+ struct nk_vec2 touch_padding;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle userdata);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle userdata);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_toggle {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ struct nk_style_item cursor_normal;
|
|
|
+ struct nk_style_item cursor_hover;
|
|
|
+
|
|
|
+ /* text */
|
|
|
+ struct nk_color text_normal;
|
|
|
+ struct nk_color text_hover;
|
|
|
+ struct nk_color text_active;
|
|
|
+ struct nk_color text_background;
|
|
|
+ nk_flags text_alignment;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 touch_padding;
|
|
|
+ float spacing;
|
|
|
+ float border;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_selectable {
|
|
|
+ /* background (inactive) */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item pressed;
|
|
|
+
|
|
|
+ /* background (active) */
|
|
|
+ struct nk_style_item normal_active;
|
|
|
+ struct nk_style_item hover_active;
|
|
|
+ struct nk_style_item pressed_active;
|
|
|
+
|
|
|
+ /* text color (inactive) */
|
|
|
+ struct nk_color text_normal;
|
|
|
+ struct nk_color text_hover;
|
|
|
+ struct nk_color text_pressed;
|
|
|
+
|
|
|
+ /* text color (active) */
|
|
|
+ struct nk_color text_normal_active;
|
|
|
+ struct nk_color text_hover_active;
|
|
|
+ struct nk_color text_pressed_active;
|
|
|
+ struct nk_color text_background;
|
|
|
+ nk_flags text_alignment;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 touch_padding;
|
|
|
+ struct nk_vec2 image_padding;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_slider {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* background bar */
|
|
|
+ struct nk_color bar_normal;
|
|
|
+ struct nk_color bar_hover;
|
|
|
+ struct nk_color bar_active;
|
|
|
+ struct nk_color bar_filled;
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ struct nk_style_item cursor_normal;
|
|
|
+ struct nk_style_item cursor_hover;
|
|
|
+ struct nk_style_item cursor_active;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ float bar_height;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+ struct nk_vec2 cursor_size;
|
|
|
+
|
|
|
+ /* optional buttons */
|
|
|
+ int show_buttons;
|
|
|
+ struct nk_style_button inc_button;
|
|
|
+ struct nk_style_button dec_button;
|
|
|
+ enum nk_symbol_type inc_symbol;
|
|
|
+ enum nk_symbol_type dec_symbol;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_progress {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ struct nk_style_item cursor_normal;
|
|
|
+ struct nk_style_item cursor_hover;
|
|
|
+ struct nk_style_item cursor_active;
|
|
|
+ struct nk_color cursor_border_color;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float rounding;
|
|
|
+ float border;
|
|
|
+ float cursor_border;
|
|
|
+ float cursor_rounding;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_scrollbar {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ struct nk_style_item cursor_normal;
|
|
|
+ struct nk_style_item cursor_hover;
|
|
|
+ struct nk_style_item cursor_active;
|
|
|
+ struct nk_color cursor_border_color;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ float border_cursor;
|
|
|
+ float rounding_cursor;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ /* optional buttons */
|
|
|
+ int show_buttons;
|
|
|
+ struct nk_style_button inc_button;
|
|
|
+ struct nk_style_button dec_button;
|
|
|
+ enum nk_symbol_type inc_symbol;
|
|
|
+ enum nk_symbol_type dec_symbol;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_edit {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+ struct nk_style_scrollbar scrollbar;
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ struct nk_color cursor_normal;
|
|
|
+ struct nk_color cursor_hover;
|
|
|
+ struct nk_color cursor_text_normal;
|
|
|
+ struct nk_color cursor_text_hover;
|
|
|
+
|
|
|
+ /* text (unselected) */
|
|
|
+ struct nk_color text_normal;
|
|
|
+ struct nk_color text_hover;
|
|
|
+ struct nk_color text_active;
|
|
|
+
|
|
|
+ /* text (selected) */
|
|
|
+ struct nk_color selected_normal;
|
|
|
+ struct nk_color selected_hover;
|
|
|
+ struct nk_color selected_text_normal;
|
|
|
+ struct nk_color selected_text_hover;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ float cursor_size;
|
|
|
+ struct nk_vec2 scrollbar_size;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ float row_padding;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_property {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* text */
|
|
|
+ struct nk_color label_normal;
|
|
|
+ struct nk_color label_hover;
|
|
|
+ struct nk_color label_active;
|
|
|
+
|
|
|
+ /* symbols */
|
|
|
+ enum nk_symbol_type sym_left;
|
|
|
+ enum nk_symbol_type sym_right;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ struct nk_style_edit edit;
|
|
|
+ struct nk_style_button inc_button;
|
|
|
+ struct nk_style_button dec_button;
|
|
|
+
|
|
|
+ /* optional user callbacks */
|
|
|
+ nk_handle userdata;
|
|
|
+ void(*draw_begin)(struct nk_command_buffer*, nk_handle);
|
|
|
+ void(*draw_end)(struct nk_command_buffer*, nk_handle);
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_chart {
|
|
|
+ /* colors */
|
|
|
+ struct nk_style_item background;
|
|
|
+ struct nk_color border_color;
|
|
|
+ struct nk_color selected_color;
|
|
|
+ struct nk_color color;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_combo {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+ struct nk_color border_color;
|
|
|
+
|
|
|
+ /* label */
|
|
|
+ struct nk_color label_normal;
|
|
|
+ struct nk_color label_hover;
|
|
|
+ struct nk_color label_active;
|
|
|
+
|
|
|
+ /* symbol */
|
|
|
+ struct nk_color symbol_normal;
|
|
|
+ struct nk_color symbol_hover;
|
|
|
+ struct nk_color symbol_active;
|
|
|
+
|
|
|
+ /* button */
|
|
|
+ struct nk_style_button button;
|
|
|
+ enum nk_symbol_type sym_normal;
|
|
|
+ enum nk_symbol_type sym_hover;
|
|
|
+ enum nk_symbol_type sym_active;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 content_padding;
|
|
|
+ struct nk_vec2 button_padding;
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_tab {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item background;
|
|
|
+ struct nk_color border_color;
|
|
|
+ struct nk_color text;
|
|
|
+
|
|
|
+ /* button */
|
|
|
+ struct nk_style_button tab_maximize_button;
|
|
|
+ struct nk_style_button tab_minimize_button;
|
|
|
+ struct nk_style_button node_maximize_button;
|
|
|
+ struct nk_style_button node_minimize_button;
|
|
|
+ enum nk_symbol_type sym_minimize;
|
|
|
+ enum nk_symbol_type sym_maximize;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ float border;
|
|
|
+ float rounding;
|
|
|
+ float indent;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_style_header_align {
|
|
|
+ NK_HEADER_LEFT,
|
|
|
+ NK_HEADER_RIGHT
|
|
|
+};
|
|
|
+struct nk_style_window_header {
|
|
|
+ /* background */
|
|
|
+ struct nk_style_item normal;
|
|
|
+ struct nk_style_item hover;
|
|
|
+ struct nk_style_item active;
|
|
|
+
|
|
|
+ /* button */
|
|
|
+ struct nk_style_button close_button;
|
|
|
+ struct nk_style_button minimize_button;
|
|
|
+ enum nk_symbol_type close_symbol;
|
|
|
+ enum nk_symbol_type minimize_symbol;
|
|
|
+ enum nk_symbol_type maximize_symbol;
|
|
|
+
|
|
|
+ /* title */
|
|
|
+ struct nk_color label_normal;
|
|
|
+ struct nk_color label_hover;
|
|
|
+ struct nk_color label_active;
|
|
|
+
|
|
|
+ /* properties */
|
|
|
+ enum nk_style_header_align align;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 label_padding;
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style_window {
|
|
|
+ struct nk_style_window_header header;
|
|
|
+ struct nk_style_item fixed_background;
|
|
|
+ struct nk_color background;
|
|
|
+
|
|
|
+ struct nk_color border_color;
|
|
|
+ struct nk_color popup_border_color;
|
|
|
+ struct nk_color combo_border_color;
|
|
|
+ struct nk_color contextual_border_color;
|
|
|
+ struct nk_color menu_border_color;
|
|
|
+ struct nk_color group_border_color;
|
|
|
+ struct nk_color tooltip_border_color;
|
|
|
+ struct nk_style_item scaler;
|
|
|
+
|
|
|
+ float border;
|
|
|
+ float combo_border;
|
|
|
+ float contextual_border;
|
|
|
+ float menu_border;
|
|
|
+ float group_border;
|
|
|
+ float tooltip_border;
|
|
|
+ float popup_border;
|
|
|
+ float min_row_height_padding;
|
|
|
+
|
|
|
+ float rounding;
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+ struct nk_vec2 scrollbar_size;
|
|
|
+ struct nk_vec2 min_size;
|
|
|
+
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_vec2 group_padding;
|
|
|
+ struct nk_vec2 popup_padding;
|
|
|
+ struct nk_vec2 combo_padding;
|
|
|
+ struct nk_vec2 contextual_padding;
|
|
|
+ struct nk_vec2 menu_padding;
|
|
|
+ struct nk_vec2 tooltip_padding;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_style {
|
|
|
+ const struct nk_user_font *font;
|
|
|
+ const struct nk_cursor *cursors[NK_CURSOR_COUNT];
|
|
|
+ const struct nk_cursor *cursor_active;
|
|
|
+ struct nk_cursor *cursor_last;
|
|
|
+ int cursor_visible;
|
|
|
+
|
|
|
+ struct nk_style_text text;
|
|
|
+ struct nk_style_button button;
|
|
|
+ struct nk_style_button contextual_button;
|
|
|
+ struct nk_style_button menu_button;
|
|
|
+ struct nk_style_toggle option;
|
|
|
+ struct nk_style_toggle checkbox;
|
|
|
+ struct nk_style_selectable selectable;
|
|
|
+ struct nk_style_slider slider;
|
|
|
+ struct nk_style_progress progress;
|
|
|
+ struct nk_style_property property;
|
|
|
+ struct nk_style_edit edit;
|
|
|
+ struct nk_style_chart chart;
|
|
|
+ struct nk_style_scrollbar scrollh;
|
|
|
+ struct nk_style_scrollbar scrollv;
|
|
|
+ struct nk_style_tab tab;
|
|
|
+ struct nk_style_combo combo;
|
|
|
+ struct nk_style_window window;
|
|
|
+};
|
|
|
+
|
|
|
+NK_API struct nk_style_item nk_style_item_image(struct nk_image img);
|
|
|
+NK_API struct nk_style_item nk_style_item_color(struct nk_color);
|
|
|
+NK_API struct nk_style_item nk_style_item_hide(void);
|
|
|
+
|
|
|
+/*==============================================================
|
|
|
+ * PANEL
|
|
|
+ * =============================================================*/
|
|
|
+#ifndef NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS
|
|
|
+#define NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS 16
|
|
|
+#endif
|
|
|
+#ifndef NK_CHART_MAX_SLOT
|
|
|
+#define NK_CHART_MAX_SLOT 4
|
|
|
+#endif
|
|
|
+
|
|
|
+enum nk_panel_type {
|
|
|
+ NK_PANEL_WINDOW = NK_FLAG(0),
|
|
|
+ NK_PANEL_GROUP = NK_FLAG(1),
|
|
|
+ NK_PANEL_POPUP = NK_FLAG(2),
|
|
|
+ NK_PANEL_CONTEXTUAL = NK_FLAG(4),
|
|
|
+ NK_PANEL_COMBO = NK_FLAG(5),
|
|
|
+ NK_PANEL_MENU = NK_FLAG(6),
|
|
|
+ NK_PANEL_TOOLTIP = NK_FLAG(7)
|
|
|
+};
|
|
|
+enum nk_panel_set {
|
|
|
+ NK_PANEL_SET_NONBLOCK = NK_PANEL_CONTEXTUAL|NK_PANEL_COMBO|NK_PANEL_MENU|NK_PANEL_TOOLTIP,
|
|
|
+ NK_PANEL_SET_POPUP = NK_PANEL_SET_NONBLOCK|NK_PANEL_POPUP,
|
|
|
+ NK_PANEL_SET_SUB = NK_PANEL_SET_POPUP|NK_PANEL_GROUP
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_chart_slot {
|
|
|
+ enum nk_chart_type type;
|
|
|
+ struct nk_color color;
|
|
|
+ struct nk_color highlight;
|
|
|
+ float min, max, range;
|
|
|
+ int count;
|
|
|
+ struct nk_vec2 last;
|
|
|
+ int index;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_chart {
|
|
|
+ int slot;
|
|
|
+ float x, y, w, h;
|
|
|
+ struct nk_chart_slot slots[NK_CHART_MAX_SLOT];
|
|
|
+};
|
|
|
+
|
|
|
+enum nk_panel_row_layout_type {
|
|
|
+ NK_LAYOUT_DYNAMIC_FIXED = 0,
|
|
|
+ NK_LAYOUT_DYNAMIC_ROW,
|
|
|
+ NK_LAYOUT_DYNAMIC_FREE,
|
|
|
+ NK_LAYOUT_DYNAMIC,
|
|
|
+ NK_LAYOUT_STATIC_FIXED,
|
|
|
+ NK_LAYOUT_STATIC_ROW,
|
|
|
+ NK_LAYOUT_STATIC_FREE,
|
|
|
+ NK_LAYOUT_STATIC,
|
|
|
+ NK_LAYOUT_TEMPLATE,
|
|
|
+ NK_LAYOUT_COUNT
|
|
|
+};
|
|
|
+struct nk_row_layout {
|
|
|
+ enum nk_panel_row_layout_type type;
|
|
|
+ int index;
|
|
|
+ float height;
|
|
|
+ float min_height;
|
|
|
+ int columns;
|
|
|
+ const float *ratio;
|
|
|
+ float item_width;
|
|
|
+ float item_height;
|
|
|
+ float item_offset;
|
|
|
+ float filled;
|
|
|
+ struct nk_rect item;
|
|
|
+ int tree_depth;
|
|
|
+ float templates[NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS];
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_popup_buffer {
|
|
|
+ nk_size begin;
|
|
|
+ nk_size parent;
|
|
|
+ nk_size last;
|
|
|
+ nk_size end;
|
|
|
+ int active;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_menu_state {
|
|
|
+ float x, y, w, h;
|
|
|
+ struct nk_scroll offset;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_panel {
|
|
|
+ enum nk_panel_type type;
|
|
|
+ nk_flags flags;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ nk_uint *offset_x;
|
|
|
+ nk_uint *offset_y;
|
|
|
+ float at_x, at_y, max_x;
|
|
|
+ float footer_height;
|
|
|
+ float header_height;
|
|
|
+ float border;
|
|
|
+ unsigned int has_scrolling;
|
|
|
+ struct nk_rect clip;
|
|
|
+ struct nk_menu_state menu;
|
|
|
+ struct nk_row_layout row;
|
|
|
+ struct nk_chart chart;
|
|
|
+ struct nk_command_buffer *buffer;
|
|
|
+ struct nk_panel *parent;
|
|
|
+};
|
|
|
+
|
|
|
+/*==============================================================
|
|
|
+ * WINDOW
|
|
|
+ * =============================================================*/
|
|
|
+#ifndef NK_WINDOW_MAX_NAME
|
|
|
+#define NK_WINDOW_MAX_NAME 64
|
|
|
+#endif
|
|
|
+
|
|
|
+struct nk_table;
|
|
|
+enum nk_window_flags {
|
|
|
+ NK_WINDOW_PRIVATE = NK_FLAG(11),
|
|
|
+ NK_WINDOW_DYNAMIC = NK_WINDOW_PRIVATE,
|
|
|
+ /* special window type growing up in height while being filled to a certain maximum height */
|
|
|
+ NK_WINDOW_ROM = NK_FLAG(12),
|
|
|
+ /* sets window widgets into a read only mode and does not allow input changes */
|
|
|
+ NK_WINDOW_NOT_INTERACTIVE = NK_WINDOW_ROM|NK_WINDOW_NO_INPUT,
|
|
|
+ /* prevents all interaction caused by input to either window or widgets inside */
|
|
|
+ NK_WINDOW_HIDDEN = NK_FLAG(13),
|
|
|
+ /* Hides window and stops any window interaction and drawing */
|
|
|
+ NK_WINDOW_CLOSED = NK_FLAG(14),
|
|
|
+ /* Directly closes and frees the window at the end of the frame */
|
|
|
+ NK_WINDOW_MINIMIZED = NK_FLAG(15),
|
|
|
+ /* marks the window as minimized */
|
|
|
+ NK_WINDOW_REMOVE_ROM = NK_FLAG(16)
|
|
|
+ /* Removes read only mode at the end of the window */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_popup_state {
|
|
|
+ struct nk_window *win;
|
|
|
+ enum nk_panel_type type;
|
|
|
+ struct nk_popup_buffer buf;
|
|
|
+ nk_hash name;
|
|
|
+ int active;
|
|
|
+ unsigned combo_count;
|
|
|
+ unsigned con_count, con_old;
|
|
|
+ unsigned active_con;
|
|
|
+ struct nk_rect header;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_edit_state {
|
|
|
+ nk_hash name;
|
|
|
+ unsigned int seq;
|
|
|
+ unsigned int old;
|
|
|
+ int active, prev;
|
|
|
+ int cursor;
|
|
|
+ int sel_start;
|
|
|
+ int sel_end;
|
|
|
+ struct nk_scroll scrollbar;
|
|
|
+ unsigned char mode;
|
|
|
+ unsigned char single_line;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_property_state {
|
|
|
+ int active, prev;
|
|
|
+ char buffer[NK_MAX_NUMBER_BUFFER];
|
|
|
+ int length;
|
|
|
+ int cursor;
|
|
|
+ int select_start;
|
|
|
+ int select_end;
|
|
|
+ nk_hash name;
|
|
|
+ unsigned int seq;
|
|
|
+ unsigned int old;
|
|
|
+ int state;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_window {
|
|
|
+ unsigned int seq;
|
|
|
+ nk_hash name;
|
|
|
+ char name_string[NK_WINDOW_MAX_NAME];
|
|
|
+ nk_flags flags;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_scroll scrollbar;
|
|
|
+ struct nk_command_buffer buffer;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ float scrollbar_hiding_timer;
|
|
|
+
|
|
|
+ /* persistent widget state */
|
|
|
+ struct nk_property_state property;
|
|
|
+ struct nk_popup_state popup;
|
|
|
+ struct nk_edit_state edit;
|
|
|
+ unsigned int scrolled;
|
|
|
+
|
|
|
+ struct nk_table *tables;
|
|
|
+ unsigned int table_count;
|
|
|
+
|
|
|
+ /* window list hooks */
|
|
|
+ struct nk_window *next;
|
|
|
+ struct nk_window *prev;
|
|
|
+ struct nk_window *parent;
|
|
|
+};
|
|
|
+
|
|
|
+/*==============================================================
|
|
|
+ * STACK
|
|
|
+ * =============================================================*/
|
|
|
+/* The style modifier stack can be used to temporarily change a
|
|
|
+ * property inside `nk_style`. For example if you want a special
|
|
|
+ * red button you can temporarily push the old button color onto a stack
|
|
|
+ * draw the button with a red color and then you just pop the old color
|
|
|
+ * back from the stack:
|
|
|
+ *
|
|
|
+ * nk_style_push_style_item(ctx, &ctx->style.button.normal, nk_style_item_color(nk_rgb(255,0,0)));
|
|
|
+ * nk_style_push_style_item(ctx, &ctx->style.button.hover, nk_style_item_color(nk_rgb(255,0,0)));
|
|
|
+ * nk_style_push_style_item(ctx, &ctx->style.button.active, nk_style_item_color(nk_rgb(255,0,0)));
|
|
|
+ * nk_style_push_vec2(ctx, &cx->style.button.padding, nk_vec2(2,2));
|
|
|
+ *
|
|
|
+ * nk_button(...);
|
|
|
+ *
|
|
|
+ * nk_style_pop_style_item(ctx);
|
|
|
+ * nk_style_pop_style_item(ctx);
|
|
|
+ * nk_style_pop_style_item(ctx);
|
|
|
+ * nk_style_pop_vec2(ctx);
|
|
|
+ *
|
|
|
+ * Nuklear has a stack for style_items, float properties, vector properties,
|
|
|
+ * flags, colors, fonts and for button_behavior. Each has it's own fixed size stack
|
|
|
+ * which can be changed at compile time.
|
|
|
+ */
|
|
|
+#ifndef NK_BUTTON_BEHAVIOR_STACK_SIZE
|
|
|
+#define NK_BUTTON_BEHAVIOR_STACK_SIZE 8
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_FONT_STACK_SIZE
|
|
|
+#define NK_FONT_STACK_SIZE 8
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_STYLE_ITEM_STACK_SIZE
|
|
|
+#define NK_STYLE_ITEM_STACK_SIZE 16
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_FLOAT_STACK_SIZE
|
|
|
+#define NK_FLOAT_STACK_SIZE 32
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_VECTOR_STACK_SIZE
|
|
|
+#define NK_VECTOR_STACK_SIZE 16
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_FLAGS_STACK_SIZE
|
|
|
+#define NK_FLAGS_STACK_SIZE 32
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_COLOR_STACK_SIZE
|
|
|
+#define NK_COLOR_STACK_SIZE 32
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_CONFIGURATION_STACK_TYPE(prefix, name, type)\
|
|
|
+ struct nk_config_stack_##name##_element {\
|
|
|
+ prefix##_##type *address;\
|
|
|
+ prefix##_##type old_value;\
|
|
|
+ }
|
|
|
+#define NK_CONFIG_STACK(type,size)\
|
|
|
+ struct nk_config_stack_##type {\
|
|
|
+ int head;\
|
|
|
+ struct nk_config_stack_##type##_element elements[size];\
|
|
|
+ }
|
|
|
+
|
|
|
+#define nk_float float
|
|
|
+NK_CONFIGURATION_STACK_TYPE(struct nk, style_item, style_item);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(nk ,float, float);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(struct nk, vec2, vec2);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(nk ,flags, flags);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(struct nk, color, color);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(const struct nk, user_font, user_font*);
|
|
|
+NK_CONFIGURATION_STACK_TYPE(enum nk, button_behavior, button_behavior);
|
|
|
+
|
|
|
+NK_CONFIG_STACK(style_item, NK_STYLE_ITEM_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(float, NK_FLOAT_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(vec2, NK_VECTOR_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(flags, NK_FLAGS_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(color, NK_COLOR_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(user_font, NK_FONT_STACK_SIZE);
|
|
|
+NK_CONFIG_STACK(button_behavior, NK_BUTTON_BEHAVIOR_STACK_SIZE);
|
|
|
+
|
|
|
+struct nk_configuration_stacks {
|
|
|
+ struct nk_config_stack_style_item style_items;
|
|
|
+ struct nk_config_stack_float floats;
|
|
|
+ struct nk_config_stack_vec2 vectors;
|
|
|
+ struct nk_config_stack_flags flags;
|
|
|
+ struct nk_config_stack_color colors;
|
|
|
+ struct nk_config_stack_user_font fonts;
|
|
|
+ struct nk_config_stack_button_behavior button_behaviors;
|
|
|
+};
|
|
|
+
|
|
|
+/*==============================================================
|
|
|
+ * CONTEXT
|
|
|
+ * =============================================================*/
|
|
|
+#define NK_VALUE_PAGE_CAPACITY \
|
|
|
+ (((NK_MAX(sizeof(struct nk_window),sizeof(struct nk_panel)) / sizeof(nk_uint))) / 2)
|
|
|
+
|
|
|
+struct nk_table {
|
|
|
+ unsigned int seq;
|
|
|
+ unsigned int size;
|
|
|
+ nk_hash keys[NK_VALUE_PAGE_CAPACITY];
|
|
|
+ nk_uint values[NK_VALUE_PAGE_CAPACITY];
|
|
|
+ struct nk_table *next, *prev;
|
|
|
+};
|
|
|
+
|
|
|
+union nk_page_data {
|
|
|
+ struct nk_table tbl;
|
|
|
+ struct nk_panel pan;
|
|
|
+ struct nk_window win;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_page_element {
|
|
|
+ union nk_page_data data;
|
|
|
+ struct nk_page_element *next;
|
|
|
+ struct nk_page_element *prev;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_page {
|
|
|
+ unsigned int size;
|
|
|
+ struct nk_page *next;
|
|
|
+ struct nk_page_element win[1];
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_pool {
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ enum nk_allocation_type type;
|
|
|
+ unsigned int page_count;
|
|
|
+ struct nk_page *pages;
|
|
|
+ struct nk_page_element *freelist;
|
|
|
+ unsigned capacity;
|
|
|
+ nk_size size;
|
|
|
+ nk_size cap;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_context {
|
|
|
+/* public: can be accessed freely */
|
|
|
+ struct nk_input input;
|
|
|
+ struct nk_style style;
|
|
|
+ struct nk_buffer memory;
|
|
|
+ struct nk_clipboard clip;
|
|
|
+ nk_flags last_widget_state;
|
|
|
+ enum nk_button_behavior button_behavior;
|
|
|
+ struct nk_configuration_stacks stacks;
|
|
|
+ float delta_time_seconds;
|
|
|
+
|
|
|
+/* private:
|
|
|
+ should only be accessed if you
|
|
|
+ know what you are doing */
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ struct nk_draw_list draw_list;
|
|
|
+#endif
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_handle userdata;
|
|
|
+#endif
|
|
|
+ /* text editor objects are quite big because of an internal
|
|
|
+ * undo/redo stack. Therefore it does not make sense to have one for
|
|
|
+ * each window for temporary use cases, so I only provide *one* instance
|
|
|
+ * for all windows. This works because the content is cleared anyway */
|
|
|
+ struct nk_text_edit text_edit;
|
|
|
+ /* draw buffer used for overlay drawing operation like cursor */
|
|
|
+ struct nk_command_buffer overlay;
|
|
|
+
|
|
|
+ /* windows */
|
|
|
+ int build;
|
|
|
+ int use_pool;
|
|
|
+ struct nk_pool pool;
|
|
|
+ struct nk_window *begin;
|
|
|
+ struct nk_window *end;
|
|
|
+ struct nk_window *active;
|
|
|
+ struct nk_window *current;
|
|
|
+ struct nk_page_element *freelist;
|
|
|
+ unsigned int count;
|
|
|
+ unsigned int seq;
|
|
|
+};
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ * MATH
|
|
|
+ * =============================================================== */
|
|
|
+#define NK_PI 3.141592654f
|
|
|
+#define NK_UTF_INVALID 0xFFFD
|
|
|
+#define NK_MAX_FLOAT_PRECISION 2
|
|
|
+
|
|
|
+#define NK_UNUSED(x) ((void)(x))
|
|
|
+#define NK_SATURATE(x) (NK_MAX(0, NK_MIN(1.0f, x)))
|
|
|
+#define NK_LEN(a) (sizeof(a)/sizeof(a)[0])
|
|
|
+#define NK_ABS(a) (((a) < 0) ? -(a) : (a))
|
|
|
+#define NK_BETWEEN(x, a, b) ((a) <= (x) && (x) < (b))
|
|
|
+#define NK_INBOX(px, py, x, y, w, h)\
|
|
|
+ (NK_BETWEEN(px,x,x+w) && NK_BETWEEN(py,y,y+h))
|
|
|
+#define NK_INTERSECT(x0, y0, w0, h0, x1, y1, w1, h1) \
|
|
|
+ (!(((x1 > (x0 + w0)) || ((x1 + w1) < x0) || (y1 > (y0 + h0)) || (y1 + h1) < y0)))
|
|
|
+#define NK_CONTAINS(x, y, w, h, bx, by, bw, bh)\
|
|
|
+ (NK_INBOX(x,y, bx, by, bw, bh) && NK_INBOX(x+w,y+h, bx, by, bw, bh))
|
|
|
+
|
|
|
+#define nk_vec2_sub(a, b) nk_vec2((a).x - (b).x, (a).y - (b).y)
|
|
|
+#define nk_vec2_add(a, b) nk_vec2((a).x + (b).x, (a).y + (b).y)
|
|
|
+#define nk_vec2_len_sqr(a) ((a).x*(a).x+(a).y*(a).y)
|
|
|
+#define nk_vec2_muls(a, t) nk_vec2((a).x * (t), (a).y * (t))
|
|
|
+
|
|
|
+#define nk_ptr_add(t, p, i) ((t*)((void*)((nk_byte*)(p) + (i))))
|
|
|
+#define nk_ptr_add_const(t, p, i) ((const t*)((const void*)((const nk_byte*)(p) + (i))))
|
|
|
+#define nk_zero_struct(s) nk_zero(&s, sizeof(s))
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ * ALIGNMENT
|
|
|
+ * =============================================================== */
|
|
|
+/* Pointer to Integer type conversion for pointer alignment */
|
|
|
+#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC*/
|
|
|
+# define NK_UINT_TO_PTR(x) ((void*)(__PTRDIFF_TYPE__)(x))
|
|
|
+# define NK_PTR_TO_UINT(x) ((nk_size)(__PTRDIFF_TYPE__)(x))
|
|
|
+#elif !defined(__GNUC__) /* works for compilers other than LLVM */
|
|
|
+# define NK_UINT_TO_PTR(x) ((void*)&((char*)0)[x])
|
|
|
+# define NK_PTR_TO_UINT(x) ((nk_size)(((char*)x)-(char*)0))
|
|
|
+#elif defined(NK_USE_FIXED_TYPES) /* used if we have <stdint.h> */
|
|
|
+# define NK_UINT_TO_PTR(x) ((void*)(uintptr_t)(x))
|
|
|
+# define NK_PTR_TO_UINT(x) ((uintptr_t)(x))
|
|
|
+#else /* generates warning but works */
|
|
|
+# define NK_UINT_TO_PTR(x) ((void*)(x))
|
|
|
+# define NK_PTR_TO_UINT(x) ((nk_size)(x))
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_ALIGN_PTR(x, mask)\
|
|
|
+ (NK_UINT_TO_PTR((NK_PTR_TO_UINT((nk_byte*)(x) + (mask-1)) & ~(mask-1))))
|
|
|
+#define NK_ALIGN_PTR_BACK(x, mask)\
|
|
|
+ (NK_UINT_TO_PTR((NK_PTR_TO_UINT((nk_byte*)(x)) & ~(mask-1))))
|
|
|
+
|
|
|
+#define NK_OFFSETOF(st,m) ((nk_ptr)&(((st*)0)->m))
|
|
|
+#define NK_CONTAINER_OF(ptr,type,member)\
|
|
|
+ (type*)((void*)((char*)(1 ? (ptr): &((type*)0)->member) - NK_OFFSETOF(type, member)))
|
|
|
+
|
|
|
+#ifdef __cplusplus
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef __cplusplus
|
|
|
+template<typename T> struct nk_alignof;
|
|
|
+template<typename T, int size_diff> struct nk_helper{enum {value = size_diff};};
|
|
|
+template<typename T> struct nk_helper<T,0>{enum {value = nk_alignof<T>::value};};
|
|
|
+template<typename T> struct nk_alignof{struct Big {T x; char c;}; enum {
|
|
|
+ diff = sizeof(Big) - sizeof(T), value = nk_helper<Big, diff>::value};};
|
|
|
+#define NK_ALIGNOF(t) (nk_alignof<t>::value)
|
|
|
+#elif defined(_MSC_VER)
|
|
|
+#define NK_ALIGNOF(t) (__alignof(t))
|
|
|
+#else
|
|
|
+#define NK_ALIGNOF(t) ((char*)(&((struct {char c; t _h;}*)0)->_h) - (char*)0)
|
|
|
+#endif
|
|
|
+
|
|
|
+#endif /* NK_H_ */
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * IMPLEMENTATION
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#ifdef NK_IMPLEMENTATION
|
|
|
+
|
|
|
+#ifndef NK_POOL_DEFAULT_CAPACITY
|
|
|
+#define NK_POOL_DEFAULT_CAPACITY 16
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_DEFAULT_COMMAND_BUFFER_SIZE
|
|
|
+#define NK_DEFAULT_COMMAND_BUFFER_SIZE (4*1024)
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_BUFFER_DEFAULT_INITIAL_SIZE
|
|
|
+#define NK_BUFFER_DEFAULT_INITIAL_SIZE (4*1024)
|
|
|
+#endif
|
|
|
+
|
|
|
+/* standard library headers */
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+#include <stdlib.h> /* malloc, free */
|
|
|
+#endif
|
|
|
+#ifdef NK_INCLUDE_STANDARD_IO
|
|
|
+#include <stdio.h> /* fopen, fclose,... */
|
|
|
+#endif
|
|
|
+#ifdef NK_INCLUDE_STANDARD_VARARGS
|
|
|
+#include <stdarg.h> /* valist, va_start, va_end, ... */
|
|
|
+#endif
|
|
|
+#ifndef NK_ASSERT
|
|
|
+#include <assert.h>
|
|
|
+#define NK_ASSERT(expr) assert(expr)
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef NK_MEMSET
|
|
|
+#define NK_MEMSET nk_memset
|
|
|
+#endif
|
|
|
+#ifndef NK_MEMCPY
|
|
|
+#define NK_MEMCPY nk_memcopy
|
|
|
+#endif
|
|
|
+#ifndef NK_SQRT
|
|
|
+#define NK_SQRT nk_sqrt
|
|
|
+#endif
|
|
|
+#ifndef NK_SIN
|
|
|
+#define NK_SIN nk_sin
|
|
|
+#endif
|
|
|
+#ifndef NK_COS
|
|
|
+#define NK_COS nk_cos
|
|
|
+#endif
|
|
|
+#ifndef NK_STRTOD
|
|
|
+#define NK_STRTOD nk_strtod
|
|
|
+#endif
|
|
|
+#ifndef NK_DTOA
|
|
|
+#define NK_DTOA nk_dtoa
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_DEFAULT (-1)
|
|
|
+
|
|
|
+#ifndef NK_VSNPRINTF
|
|
|
+/* If your compiler does support `vsnprintf` I would highly recommend
|
|
|
+ * defining this to vsnprintf instead since `vsprintf` is basically
|
|
|
+ * unbelievable unsafe and should *NEVER* be used. But I have to support
|
|
|
+ * it since C89 only provides this unsafe version. */
|
|
|
+ #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||\
|
|
|
+ (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
|
|
|
+ (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)) ||\
|
|
|
+ (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500)) ||\
|
|
|
+ defined(_ISOC99_SOURCE) || defined(_BSD_SOURCE)
|
|
|
+ #define NK_VSNPRINTF(s,n,f,a) vsnprintf(s,n,f,a)
|
|
|
+ #else
|
|
|
+ #define NK_VSNPRINTF(s,n,f,a) vsprintf(s,f,a)
|
|
|
+ #endif
|
|
|
+#endif
|
|
|
+
|
|
|
+#define NK_SCHAR_MIN (-127)
|
|
|
+#define NK_SCHAR_MAX 127
|
|
|
+#define NK_UCHAR_MIN 0
|
|
|
+#define NK_UCHAR_MAX 256
|
|
|
+#define NK_SSHORT_MIN (-32767)
|
|
|
+#define NK_SSHORT_MAX 32767
|
|
|
+#define NK_USHORT_MIN 0
|
|
|
+#define NK_USHORT_MAX 65535
|
|
|
+#define NK_SINT_MIN (-2147483647)
|
|
|
+#define NK_SINT_MAX 2147483647
|
|
|
+#define NK_UINT_MIN 0
|
|
|
+#define NK_UINT_MAX 4294967295u
|
|
|
+
|
|
|
+/* Make sure correct type size:
|
|
|
+ * This will fire with a negative subscript error if the type sizes
|
|
|
+ * are set incorrectly by the compiler, and compile out if not */
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*));
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_ptr) == sizeof(void*));
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_flags) >= 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_rune) >= 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_ushort) == 2);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_short) == 2);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_uint) == 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_int) == 4);
|
|
|
+NK_STATIC_ASSERT(sizeof(nk_byte) == 1);
|
|
|
+
|
|
|
+NK_GLOBAL const struct nk_rect nk_null_rect = {-8192.0f, -8192.0f, 16384, 16384};
|
|
|
+#define NK_FLOAT_PRECISION 0.00000000000001
|
|
|
+
|
|
|
+NK_GLOBAL const struct nk_color nk_red = {255,0,0,255};
|
|
|
+NK_GLOBAL const struct nk_color nk_green = {0,255,0,255};
|
|
|
+NK_GLOBAL const struct nk_color nk_blue = {0,0,255,255};
|
|
|
+NK_GLOBAL const struct nk_color nk_white = {255,255,255,255};
|
|
|
+NK_GLOBAL const struct nk_color nk_black = {0,0,0,255};
|
|
|
+NK_GLOBAL const struct nk_color nk_yellow = {255,255,0,255};
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * MATH
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+/* Since nuklear is supposed to work on all systems providing floating point
|
|
|
+ math without any dependencies I also had to implement my own math functions
|
|
|
+ for sqrt, sin and cos. Since the actual highly accurate implementations for
|
|
|
+ the standard library functions are quite complex and I do not need high
|
|
|
+ precision for my use cases I use approximations.
|
|
|
+
|
|
|
+ Sqrt
|
|
|
+ ----
|
|
|
+ For square root nuklear uses the famous fast inverse square root:
|
|
|
+ https://en.wikipedia.org/wiki/Fast_inverse_square_root with
|
|
|
+ slightly tweaked magic constant. While on todays hardware it is
|
|
|
+ probably not faster it is still fast and accurate enough for
|
|
|
+ nuklear's use cases. IMPORTANT: this requires float format IEEE 754
|
|
|
+
|
|
|
+ Sine/Cosine
|
|
|
+ -----------
|
|
|
+ All constants inside both function are generated Remez's minimax
|
|
|
+ approximations for value range 0...2*PI. The reason why I decided to
|
|
|
+ approximate exactly that range is that nuklear only needs sine and
|
|
|
+ cosine to generate circles which only requires that exact range.
|
|
|
+ In addition I used Remez instead of Taylor for additional precision:
|
|
|
+ www.lolengine.net/blog/2011/12/21/better-function-approximatations.
|
|
|
+
|
|
|
+ The tool I used to generate constants for both sine and cosine
|
|
|
+ (it can actually approximate a lot more functions) can be
|
|
|
+ found here: www.lolengine.net/wiki/oss/lolremez
|
|
|
+*/
|
|
|
+NK_INTERN float
|
|
|
+nk_inv_sqrt(float number)
|
|
|
+{
|
|
|
+ float x2;
|
|
|
+ const float threehalfs = 1.5f;
|
|
|
+ union {nk_uint i; float f;} conv = {0};
|
|
|
+ conv.f = number;
|
|
|
+ x2 = number * 0.5f;
|
|
|
+ conv.i = 0x5f375A84 - (conv.i >> 1);
|
|
|
+ conv.f = conv.f * (threehalfs - (x2 * conv.f * conv.f));
|
|
|
+ return conv.f;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_sqrt(float x)
|
|
|
+{
|
|
|
+ return x * nk_inv_sqrt(x);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_sin(float x)
|
|
|
+{
|
|
|
+ NK_STORAGE const float a0 = +1.91059300966915117e-31f;
|
|
|
+ NK_STORAGE const float a1 = +1.00086760103908896f;
|
|
|
+ NK_STORAGE const float a2 = -1.21276126894734565e-2f;
|
|
|
+ NK_STORAGE const float a3 = -1.38078780785773762e-1f;
|
|
|
+ NK_STORAGE const float a4 = -2.67353392911981221e-2f;
|
|
|
+ NK_STORAGE const float a5 = +2.08026600266304389e-2f;
|
|
|
+ NK_STORAGE const float a6 = -3.03996055049204407e-3f;
|
|
|
+ NK_STORAGE const float a7 = +1.38235642404333740e-4f;
|
|
|
+ return a0 + x*(a1 + x*(a2 + x*(a3 + x*(a4 + x*(a5 + x*(a6 + x*a7))))));
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_cos(float x)
|
|
|
+{
|
|
|
+ NK_STORAGE const float a0 = +1.00238601909309722f;
|
|
|
+ NK_STORAGE const float a1 = -3.81919947353040024e-2f;
|
|
|
+ NK_STORAGE const float a2 = -3.94382342128062756e-1f;
|
|
|
+ NK_STORAGE const float a3 = -1.18134036025221444e-1f;
|
|
|
+ NK_STORAGE const float a4 = +1.07123798512170878e-1f;
|
|
|
+ NK_STORAGE const float a5 = -1.86637164165180873e-2f;
|
|
|
+ NK_STORAGE const float a6 = +9.90140908664079833e-4f;
|
|
|
+ NK_STORAGE const float a7 = -5.23022132118824778e-14f;
|
|
|
+ return a0 + x*(a1 + x*(a2 + x*(a3 + x*(a4 + x*(a5 + x*(a6 + x*a7))))));
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_uint
|
|
|
+nk_round_up_pow2(nk_uint v)
|
|
|
+{
|
|
|
+ v--;
|
|
|
+ v |= v >> 1;
|
|
|
+ v |= v >> 2;
|
|
|
+ v |= v >> 4;
|
|
|
+ v |= v >> 8;
|
|
|
+ v |= v >> 16;
|
|
|
+ v++;
|
|
|
+ return v;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_get_null_rect(void)
|
|
|
+{
|
|
|
+ return nk_null_rect;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_rect(float x, float y, float w, float h)
|
|
|
+{
|
|
|
+ struct nk_rect r;
|
|
|
+ r.x = x; r.y = y;
|
|
|
+ r.w = w; r.h = h;
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_recti(int x, int y, int w, int h)
|
|
|
+{
|
|
|
+ struct nk_rect r;
|
|
|
+ r.x = (float)x;
|
|
|
+ r.y = (float)y;
|
|
|
+ r.w = (float)w;
|
|
|
+ r.h = (float)h;
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_recta(struct nk_vec2 pos, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ return nk_rect(pos.x, pos.y, size.x, size.y);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_rectv(const float *r)
|
|
|
+{
|
|
|
+ return nk_rect(r[0], r[1], r[2], r[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_rectiv(const int *r)
|
|
|
+{
|
|
|
+ return nk_recti(r[0], r[1], r[2], r[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_rect_pos(struct nk_rect r)
|
|
|
+{
|
|
|
+ struct nk_vec2 ret;
|
|
|
+ ret.x = r.x; ret.y = r.y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_rect_size(struct nk_rect r)
|
|
|
+{
|
|
|
+ struct nk_vec2 ret;
|
|
|
+ ret.x = r.w; ret.y = r.h;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_rect
|
|
|
+nk_shrink_rect(struct nk_rect r, float amount)
|
|
|
+{
|
|
|
+ struct nk_rect res;
|
|
|
+ r.w = NK_MAX(r.w, 2 * amount);
|
|
|
+ r.h = NK_MAX(r.h, 2 * amount);
|
|
|
+ res.x = r.x + amount;
|
|
|
+ res.y = r.y + amount;
|
|
|
+ res.w = r.w - 2 * amount;
|
|
|
+ res.h = r.h - 2 * amount;
|
|
|
+ return res;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_rect
|
|
|
+nk_pad_rect(struct nk_rect r, struct nk_vec2 pad)
|
|
|
+{
|
|
|
+ r.w = NK_MAX(r.w, 2 * pad.x);
|
|
|
+ r.h = NK_MAX(r.h, 2 * pad.y);
|
|
|
+ r.x += pad.x; r.y += pad.y;
|
|
|
+ r.w -= 2 * pad.x;
|
|
|
+ r.h -= 2 * pad.y;
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_vec2(float x, float y)
|
|
|
+{
|
|
|
+ struct nk_vec2 ret;
|
|
|
+ ret.x = x; ret.y = y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_vec2i(int x, int y)
|
|
|
+{
|
|
|
+ struct nk_vec2 ret;
|
|
|
+ ret.x = (float)x;
|
|
|
+ ret.y = (float)y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_vec2v(const float *v)
|
|
|
+{
|
|
|
+ return nk_vec2(v[0], v[1]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_vec2iv(const int *v)
|
|
|
+{
|
|
|
+ return nk_vec2i(v[0], v[1]);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * UTIL
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+NK_INTERN int nk_str_match_here(const char *regexp, const char *text);
|
|
|
+NK_INTERN int nk_str_match_star(int c, const char *regexp, const char *text);
|
|
|
+NK_INTERN int nk_is_lower(int c) {return (c >= 'a' && c <= 'z') || (c >= 0xE0 && c <= 0xFF);}
|
|
|
+NK_INTERN int nk_is_upper(int c){return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c <= 0xDF);}
|
|
|
+NK_INTERN int nk_to_upper(int c) {return (c >= 'a' && c <= 'z') ? (c - ('a' - 'A')) : c;}
|
|
|
+NK_INTERN int nk_to_lower(int c) {return (c >= 'A' && c <= 'Z') ? (c - ('a' + 'A')) : c;}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_memcopy(void *dst0, const void *src0, nk_size length)
|
|
|
+{
|
|
|
+ nk_ptr t;
|
|
|
+ char *dst = (char*)dst0;
|
|
|
+ const char *src = (const char*)src0;
|
|
|
+ if (length == 0 || dst == src)
|
|
|
+ goto done;
|
|
|
+
|
|
|
+ #define nk_word int
|
|
|
+ #define nk_wsize sizeof(nk_word)
|
|
|
+ #define nk_wmask (nk_wsize-1)
|
|
|
+ #define NK_TLOOP(s) if (t) NK_TLOOP1(s)
|
|
|
+ #define NK_TLOOP1(s) do { s; } while (--t)
|
|
|
+
|
|
|
+ if (dst < src) {
|
|
|
+ t = (nk_ptr)src; /* only need low bits */
|
|
|
+ if ((t | (nk_ptr)dst) & nk_wmask) {
|
|
|
+ if ((t ^ (nk_ptr)dst) & nk_wmask || length < nk_wsize)
|
|
|
+ t = length;
|
|
|
+ else
|
|
|
+ t = nk_wsize - (t & nk_wmask);
|
|
|
+ length -= t;
|
|
|
+ NK_TLOOP1(*dst++ = *src++);
|
|
|
+ }
|
|
|
+ t = length / nk_wsize;
|
|
|
+ NK_TLOOP(*(nk_word*)(void*)dst = *(const nk_word*)(const void*)src;
|
|
|
+ src += nk_wsize; dst += nk_wsize);
|
|
|
+ t = length & nk_wmask;
|
|
|
+ NK_TLOOP(*dst++ = *src++);
|
|
|
+ } else {
|
|
|
+ src += length;
|
|
|
+ dst += length;
|
|
|
+ t = (nk_ptr)src;
|
|
|
+ if ((t | (nk_ptr)dst) & nk_wmask) {
|
|
|
+ if ((t ^ (nk_ptr)dst) & nk_wmask || length <= nk_wsize)
|
|
|
+ t = length;
|
|
|
+ else
|
|
|
+ t &= nk_wmask;
|
|
|
+ length -= t;
|
|
|
+ NK_TLOOP1(*--dst = *--src);
|
|
|
+ }
|
|
|
+ t = length / nk_wsize;
|
|
|
+ NK_TLOOP(src -= nk_wsize; dst -= nk_wsize;
|
|
|
+ *(nk_word*)(void*)dst = *(const nk_word*)(const void*)src);
|
|
|
+ t = length & nk_wmask;
|
|
|
+ NK_TLOOP(*--dst = *--src);
|
|
|
+ }
|
|
|
+ #undef nk_word
|
|
|
+ #undef nk_wsize
|
|
|
+ #undef nk_wmask
|
|
|
+ #undef NK_TLOOP
|
|
|
+ #undef NK_TLOOP1
|
|
|
+done:
|
|
|
+ return (dst0);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_memset(void *ptr, int c0, nk_size size)
|
|
|
+{
|
|
|
+ #define nk_word unsigned
|
|
|
+ #define nk_wsize sizeof(nk_word)
|
|
|
+ #define nk_wmask (nk_wsize - 1)
|
|
|
+ nk_byte *dst = (nk_byte*)ptr;
|
|
|
+ unsigned c = 0;
|
|
|
+ nk_size t = 0;
|
|
|
+
|
|
|
+ if ((c = (nk_byte)c0) != 0) {
|
|
|
+ c = (c << 8) | c; /* at least 16-bits */
|
|
|
+ if (sizeof(unsigned int) > 2)
|
|
|
+ c = (c << 16) | c; /* at least 32-bits*/
|
|
|
+ }
|
|
|
+
|
|
|
+ /* too small of a word count */
|
|
|
+ dst = (nk_byte*)ptr;
|
|
|
+ if (size < 3 * nk_wsize) {
|
|
|
+ while (size--) *dst++ = (nk_byte)c0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* align destination */
|
|
|
+ if ((t = NK_PTR_TO_UINT(dst) & nk_wmask) != 0) {
|
|
|
+ t = nk_wsize -t;
|
|
|
+ size -= t;
|
|
|
+ do {
|
|
|
+ *dst++ = (nk_byte)c0;
|
|
|
+ } while (--t != 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill word */
|
|
|
+ t = size / nk_wsize;
|
|
|
+ do {
|
|
|
+ *(nk_word*)((void*)dst) = c;
|
|
|
+ dst += nk_wsize;
|
|
|
+ } while (--t != 0);
|
|
|
+
|
|
|
+ /* fill trailing bytes */
|
|
|
+ t = (size & nk_wmask);
|
|
|
+ if (t != 0) {
|
|
|
+ do {
|
|
|
+ *dst++ = (nk_byte)c0;
|
|
|
+ } while (--t != 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ #undef nk_word
|
|
|
+ #undef nk_wsize
|
|
|
+ #undef nk_wmask
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_zero(void *ptr, nk_size size)
|
|
|
+{
|
|
|
+ NK_ASSERT(ptr);
|
|
|
+ NK_MEMSET(ptr, 0, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_strlen(const char *str)
|
|
|
+{
|
|
|
+ int siz = 0;
|
|
|
+ NK_ASSERT(str);
|
|
|
+ while (str && *str++ != '\0') siz++;
|
|
|
+ return siz;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_strtoi(const char *str, const char **endptr)
|
|
|
+{
|
|
|
+ int neg = 1;
|
|
|
+ const char *p = str;
|
|
|
+ int value = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str) return 0;
|
|
|
+
|
|
|
+ /* skip whitespace */
|
|
|
+ while (*p == ' ') p++;
|
|
|
+ if (*p == '-') {
|
|
|
+ neg = -1;
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ while (*p && *p >= '0' && *p <= '9') {
|
|
|
+ value = value * 10 + (int) (*p - '0');
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ if (endptr)
|
|
|
+ *endptr = p;
|
|
|
+ return neg*value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API double
|
|
|
+nk_strtod(const char *str, const char **endptr)
|
|
|
+{
|
|
|
+ double m;
|
|
|
+ double neg = 1.0;
|
|
|
+ const char *p = str;
|
|
|
+ double value = 0;
|
|
|
+ double number = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str) return 0;
|
|
|
+
|
|
|
+ /* skip whitespace */
|
|
|
+ while (*p == ' ') p++;
|
|
|
+ if (*p == '-') {
|
|
|
+ neg = -1.0;
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+
|
|
|
+ while (*p && *p != '.' && *p != 'e') {
|
|
|
+ value = value * 10.0 + (double) (*p - '0');
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (*p == '.') {
|
|
|
+ p++;
|
|
|
+ for(m = 0.1; *p && *p != 'e'; p++ ) {
|
|
|
+ value = value + (double) (*p - '0') * m;
|
|
|
+ m *= 0.1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (*p == 'e') {
|
|
|
+ int i, pow, div;
|
|
|
+ p++;
|
|
|
+ if (*p == '-') {
|
|
|
+ div = nk_true;
|
|
|
+ p++;
|
|
|
+ } else if (*p == '+') {
|
|
|
+ div = nk_false;
|
|
|
+ p++;
|
|
|
+ } else div = nk_false;
|
|
|
+
|
|
|
+ for (pow = 0; *p; p++)
|
|
|
+ pow = pow * 10 + (int) (*p - '0');
|
|
|
+
|
|
|
+ for (m = 1.0, i = 0; i < pow; i++)
|
|
|
+ m *= 10.0;
|
|
|
+
|
|
|
+ if (div)
|
|
|
+ value /= m;
|
|
|
+ else value *= m;
|
|
|
+ }
|
|
|
+ number = value * neg;
|
|
|
+ if (endptr)
|
|
|
+ *endptr = p;
|
|
|
+ return number;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_strtof(const char *str, const char **endptr)
|
|
|
+{
|
|
|
+ float float_value;
|
|
|
+ double double_value;
|
|
|
+ double_value = NK_STRTOD(str, endptr);
|
|
|
+ float_value = (float)double_value;
|
|
|
+ return float_value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_stricmp(const char *s1, const char *s2)
|
|
|
+{
|
|
|
+ nk_int c1,c2,d;
|
|
|
+ do {
|
|
|
+ c1 = *s1++;
|
|
|
+ c2 = *s2++;
|
|
|
+ d = c1 - c2;
|
|
|
+ while (d) {
|
|
|
+ if (c1 <= 'Z' && c1 >= 'A') {
|
|
|
+ d += ('a' - 'A');
|
|
|
+ if (!d) break;
|
|
|
+ }
|
|
|
+ if (c2 <= 'Z' && c2 >= 'A') {
|
|
|
+ d -= ('a' - 'A');
|
|
|
+ if (!d) break;
|
|
|
+ }
|
|
|
+ return ((d >= 0) << 1) - 1;
|
|
|
+ }
|
|
|
+ } while (c1);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_stricmpn(const char *s1, const char *s2, int n)
|
|
|
+{
|
|
|
+ int c1,c2,d;
|
|
|
+ NK_ASSERT(n >= 0);
|
|
|
+ do {
|
|
|
+ c1 = *s1++;
|
|
|
+ c2 = *s2++;
|
|
|
+ if (!n--) return 0;
|
|
|
+
|
|
|
+ d = c1 - c2;
|
|
|
+ while (d) {
|
|
|
+ if (c1 <= 'Z' && c1 >= 'A') {
|
|
|
+ d += ('a' - 'A');
|
|
|
+ if (!d) break;
|
|
|
+ }
|
|
|
+ if (c2 <= 'Z' && c2 >= 'A') {
|
|
|
+ d -= ('a' - 'A');
|
|
|
+ if (!d) break;
|
|
|
+ }
|
|
|
+ return ((d >= 0) << 1) - 1;
|
|
|
+ }
|
|
|
+ } while (c1);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_str_match_here(const char *regexp, const char *text)
|
|
|
+{
|
|
|
+ if (regexp[0] == '\0')
|
|
|
+ return 1;
|
|
|
+ if (regexp[1] == '*')
|
|
|
+ return nk_str_match_star(regexp[0], regexp+2, text);
|
|
|
+ if (regexp[0] == '$' && regexp[1] == '\0')
|
|
|
+ return *text == '\0';
|
|
|
+ if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
|
|
|
+ return nk_str_match_here(regexp+1, text+1);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_str_match_star(int c, const char *regexp, const char *text)
|
|
|
+{
|
|
|
+ do {/* a '* matches zero or more instances */
|
|
|
+ if (nk_str_match_here(regexp, text))
|
|
|
+ return 1;
|
|
|
+ } while (*text != '\0' && (*text++ == c || c == '.'));
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_strfilter(const char *text, const char *regexp)
|
|
|
+{
|
|
|
+ /*
|
|
|
+ c matches any literal character c
|
|
|
+ . matches any single character
|
|
|
+ ^ matches the beginning of the input string
|
|
|
+ $ matches the end of the input string
|
|
|
+ * matches zero or more occurrences of the previous character*/
|
|
|
+ if (regexp[0] == '^')
|
|
|
+ return nk_str_match_here(regexp+1, text);
|
|
|
+ do { /* must look even if string is empty */
|
|
|
+ if (nk_str_match_here(regexp, text))
|
|
|
+ return 1;
|
|
|
+ } while (*text++ != '\0');
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_strmatch_fuzzy_text(const char *str, int str_len,
|
|
|
+ const char *pattern, int *out_score)
|
|
|
+{
|
|
|
+ /* Returns true if each character in pattern is found sequentially within str
|
|
|
+ * if found then outScore is also set. Score value has no intrinsic meaning.
|
|
|
+ * Range varies with pattern. Can only compare scores with same search pattern. */
|
|
|
+
|
|
|
+ /* ------- scores --------- */
|
|
|
+ /* bonus for adjacent matches */
|
|
|
+ #define NK_ADJACENCY_BONUS 5
|
|
|
+ /* bonus if match occurs after a separator */
|
|
|
+ #define NK_SEPARATOR_BONUS 10
|
|
|
+ /* bonus if match is uppercase and prev is lower */
|
|
|
+ #define NK_CAMEL_BONUS 10
|
|
|
+ /* penalty applied for every letter in str before the first match */
|
|
|
+ #define NK_LEADING_LETTER_PENALTY (-3)
|
|
|
+ /* maximum penalty for leading letters */
|
|
|
+ #define NK_MAX_LEADING_LETTER_PENALTY (-9)
|
|
|
+ /* penalty for every letter that doesn't matter */
|
|
|
+ #define NK_UNMATCHED_LETTER_PENALTY (-1)
|
|
|
+
|
|
|
+ /* loop variables */
|
|
|
+ int score = 0;
|
|
|
+ char const * pattern_iter = pattern;
|
|
|
+ int str_iter = 0;
|
|
|
+ int prev_matched = nk_false;
|
|
|
+ int prev_lower = nk_false;
|
|
|
+ /* true so if first letter match gets separator bonus*/
|
|
|
+ int prev_separator = nk_true;
|
|
|
+
|
|
|
+ /* use "best" matched letter if multiple string letters match the pattern */
|
|
|
+ char const * best_letter = 0;
|
|
|
+ int best_letter_score = 0;
|
|
|
+
|
|
|
+ /* loop over strings */
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(pattern);
|
|
|
+ if (!str || !str_len || !pattern) return 0;
|
|
|
+ while (str_iter < str_len)
|
|
|
+ {
|
|
|
+ const char pattern_letter = *pattern_iter;
|
|
|
+ const char str_letter = str[str_iter];
|
|
|
+
|
|
|
+ int next_match = *pattern_iter != '\0' &&
|
|
|
+ nk_to_lower(pattern_letter) == nk_to_lower(str_letter);
|
|
|
+ int rematch = best_letter && nk_to_upper(*best_letter) == nk_to_upper(str_letter);
|
|
|
+
|
|
|
+ int advanced = next_match && best_letter;
|
|
|
+ int pattern_repeat = best_letter && *pattern_iter != '\0';
|
|
|
+ pattern_repeat = pattern_repeat &&
|
|
|
+ nk_to_lower(*best_letter) == nk_to_lower(pattern_letter);
|
|
|
+
|
|
|
+ if (advanced || pattern_repeat) {
|
|
|
+ score += best_letter_score;
|
|
|
+ best_letter = 0;
|
|
|
+ best_letter_score = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (next_match || rematch)
|
|
|
+ {
|
|
|
+ int new_score = 0;
|
|
|
+ /* Apply penalty for each letter before the first pattern match */
|
|
|
+ if (pattern_iter == pattern) {
|
|
|
+ int count = (int)(&str[str_iter] - str);
|
|
|
+ int penalty = NK_LEADING_LETTER_PENALTY * count;
|
|
|
+ if (penalty < NK_MAX_LEADING_LETTER_PENALTY)
|
|
|
+ penalty = NK_MAX_LEADING_LETTER_PENALTY;
|
|
|
+
|
|
|
+ score += penalty;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* apply bonus for consecutive bonuses */
|
|
|
+ if (prev_matched)
|
|
|
+ new_score += NK_ADJACENCY_BONUS;
|
|
|
+
|
|
|
+ /* apply bonus for matches after a separator */
|
|
|
+ if (prev_separator)
|
|
|
+ new_score += NK_SEPARATOR_BONUS;
|
|
|
+
|
|
|
+ /* apply bonus across camel case boundaries */
|
|
|
+ if (prev_lower && nk_is_upper(str_letter))
|
|
|
+ new_score += NK_CAMEL_BONUS;
|
|
|
+
|
|
|
+ /* update pattern iter IFF the next pattern letter was matched */
|
|
|
+ if (next_match)
|
|
|
+ ++pattern_iter;
|
|
|
+
|
|
|
+ /* update best letter in str which may be for a "next" letter or a rematch */
|
|
|
+ if (new_score >= best_letter_score) {
|
|
|
+ /* apply penalty for now skipped letter */
|
|
|
+ if (best_letter != 0)
|
|
|
+ score += NK_UNMATCHED_LETTER_PENALTY;
|
|
|
+
|
|
|
+ best_letter = &str[str_iter];
|
|
|
+ best_letter_score = new_score;
|
|
|
+ }
|
|
|
+ prev_matched = nk_true;
|
|
|
+ } else {
|
|
|
+ score += NK_UNMATCHED_LETTER_PENALTY;
|
|
|
+ prev_matched = nk_false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* separators should be more easily defined */
|
|
|
+ prev_lower = nk_is_lower(str_letter) != 0;
|
|
|
+ prev_separator = str_letter == '_' || str_letter == ' ';
|
|
|
+
|
|
|
+ ++str_iter;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* apply score for last match */
|
|
|
+ if (best_letter)
|
|
|
+ score += best_letter_score;
|
|
|
+
|
|
|
+ /* did not match full pattern */
|
|
|
+ if (*pattern_iter != '\0')
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ if (out_score)
|
|
|
+ *out_score = score;
|
|
|
+ return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_strmatch_fuzzy_string(char const *str, char const *pattern, int *out_score)
|
|
|
+{return nk_strmatch_fuzzy_text(str, nk_strlen(str), pattern, out_score);}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_string_float_limit(char *string, int prec)
|
|
|
+{
|
|
|
+ int dot = 0;
|
|
|
+ char *c = string;
|
|
|
+ while (*c) {
|
|
|
+ if (*c == '.') {
|
|
|
+ dot = 1;
|
|
|
+ c++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (dot == (prec+1)) {
|
|
|
+ *c = 0;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (dot > 0) dot++;
|
|
|
+ c++;
|
|
|
+ }
|
|
|
+ return (int)(c - string);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN double
|
|
|
+nk_pow(double x, int n)
|
|
|
+{
|
|
|
+ /* check the sign of n */
|
|
|
+ double r = 1;
|
|
|
+ int plus = n >= 0;
|
|
|
+ n = (plus) ? n : -n;
|
|
|
+ while (n > 0) {
|
|
|
+ if ((n & 1) == 1)
|
|
|
+ r *= x;
|
|
|
+ n /= 2;
|
|
|
+ x *= x;
|
|
|
+ }
|
|
|
+ return plus ? r : 1.0 / r;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_ifloord(double x)
|
|
|
+{
|
|
|
+ x = (double)((int)x - ((x < 0.0) ? 1 : 0));
|
|
|
+ return (int)x;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_ifloorf(float x)
|
|
|
+{
|
|
|
+ x = (float)((int)x - ((x < 0.0f) ? 1 : 0));
|
|
|
+ return (int)x;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_iceilf(float x)
|
|
|
+{
|
|
|
+ if (x >= 0) {
|
|
|
+ int i = (int)x;
|
|
|
+ return i;
|
|
|
+ } else {
|
|
|
+ int t = (int)x;
|
|
|
+ float r = x - (float)t;
|
|
|
+ return (r > 0.0f) ? t+1: t;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_log10(double n)
|
|
|
+{
|
|
|
+ int neg;
|
|
|
+ int ret;
|
|
|
+ int exp = 0;
|
|
|
+
|
|
|
+ neg = (n < 0) ? 1 : 0;
|
|
|
+ ret = (neg) ? (int)-n : (int)n;
|
|
|
+ while ((ret / 10) > 0) {
|
|
|
+ ret /= 10;
|
|
|
+ exp++;
|
|
|
+ }
|
|
|
+ if (neg) exp = -exp;
|
|
|
+ return exp;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_strrev_ascii(char *s)
|
|
|
+{
|
|
|
+ int len = nk_strlen(s);
|
|
|
+ int end = len / 2;
|
|
|
+ int i = 0;
|
|
|
+ char t;
|
|
|
+ for (; i < end; ++i) {
|
|
|
+ t = s[i];
|
|
|
+ s[i] = s[len - 1 - i];
|
|
|
+ s[len -1 - i] = t;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN char*
|
|
|
+nk_itoa(char *s, long n)
|
|
|
+{
|
|
|
+ long i = 0;
|
|
|
+ if (n == 0) {
|
|
|
+ s[i++] = '0';
|
|
|
+ s[i] = 0;
|
|
|
+ return s;
|
|
|
+ }
|
|
|
+ if (n < 0) {
|
|
|
+ s[i++] = '-';
|
|
|
+ n = -n;
|
|
|
+ }
|
|
|
+ while (n > 0) {
|
|
|
+ s[i++] = (char)('0' + (n % 10));
|
|
|
+ n /= 10;
|
|
|
+ }
|
|
|
+ s[i] = 0;
|
|
|
+ if (s[0] == '-')
|
|
|
+ ++s;
|
|
|
+
|
|
|
+ nk_strrev_ascii(s);
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN char*
|
|
|
+nk_dtoa(char *s, double n)
|
|
|
+{
|
|
|
+ int useExp = 0;
|
|
|
+ int digit = 0, m = 0, m1 = 0;
|
|
|
+ char *c = s;
|
|
|
+ int neg = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s) return 0;
|
|
|
+
|
|
|
+ if (n == 0.0) {
|
|
|
+ s[0] = '0'; s[1] = '\0';
|
|
|
+ return s;
|
|
|
+ }
|
|
|
+
|
|
|
+ neg = (n < 0);
|
|
|
+ if (neg) n = -n;
|
|
|
+
|
|
|
+ /* calculate magnitude */
|
|
|
+ m = nk_log10(n);
|
|
|
+ useExp = (m >= 14 || (neg && m >= 9) || m <= -9);
|
|
|
+ if (neg) *(c++) = '-';
|
|
|
+
|
|
|
+ /* set up for scientific notation */
|
|
|
+ if (useExp) {
|
|
|
+ if (m < 0)
|
|
|
+ m -= 1;
|
|
|
+ n = n / (double)nk_pow(10.0, m);
|
|
|
+ m1 = m;
|
|
|
+ m = 0;
|
|
|
+ }
|
|
|
+ if (m < 1.0) {
|
|
|
+ m = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* convert the number */
|
|
|
+ while (n > NK_FLOAT_PRECISION || m >= 0) {
|
|
|
+ double weight = nk_pow(10.0, m);
|
|
|
+ if (weight > 0) {
|
|
|
+ double t = (double)n / weight;
|
|
|
+ digit = nk_ifloord(t);
|
|
|
+ n -= ((double)digit * weight);
|
|
|
+ *(c++) = (char)('0' + (char)digit);
|
|
|
+ }
|
|
|
+ if (m == 0 && n > 0)
|
|
|
+ *(c++) = '.';
|
|
|
+ m--;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (useExp) {
|
|
|
+ /* convert the exponent */
|
|
|
+ int i, j;
|
|
|
+ *(c++) = 'e';
|
|
|
+ if (m1 > 0) {
|
|
|
+ *(c++) = '+';
|
|
|
+ } else {
|
|
|
+ *(c++) = '-';
|
|
|
+ m1 = -m1;
|
|
|
+ }
|
|
|
+ m = 0;
|
|
|
+ while (m1 > 0) {
|
|
|
+ *(c++) = (char)('0' + (char)(m1 % 10));
|
|
|
+ m1 /= 10;
|
|
|
+ m++;
|
|
|
+ }
|
|
|
+ c -= m;
|
|
|
+ for (i = 0, j = m-1; i<j; i++, j--) {
|
|
|
+ /* swap without temporary */
|
|
|
+ c[i] ^= c[j];
|
|
|
+ c[j] ^= c[i];
|
|
|
+ c[i] ^= c[j];
|
|
|
+ }
|
|
|
+ c += m;
|
|
|
+ }
|
|
|
+ *(c) = '\0';
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_STANDARD_VARARGS
|
|
|
+#ifndef NK_INCLUDE_STANDARD_IO
|
|
|
+static int
|
|
|
+nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
|
|
|
+{
|
|
|
+ enum nk_arg_type {
|
|
|
+ NK_ARG_TYPE_CHAR,
|
|
|
+ NK_ARG_TYPE_SHORT,
|
|
|
+ NK_ARG_TYPE_DEFAULT,
|
|
|
+ NK_ARG_TYPE_LONG
|
|
|
+ };
|
|
|
+ enum nk_arg_flags {
|
|
|
+ NK_ARG_FLAG_LEFT = 0x01,
|
|
|
+ NK_ARG_FLAG_PLUS = 0x02,
|
|
|
+ NK_ARG_FLAG_SPACE = 0x04,
|
|
|
+ NK_ARG_FLAG_NUM = 0x10,
|
|
|
+ NK_ARG_FLAG_ZERO = 0x20
|
|
|
+ };
|
|
|
+
|
|
|
+ char number_buffer[NK_MAX_NUMBER_BUFFER];
|
|
|
+ enum nk_arg_type arg_type = NK_ARG_TYPE_DEFAULT;
|
|
|
+ int precision = NK_DEFAULT;
|
|
|
+ int width = NK_DEFAULT;
|
|
|
+ nk_flags flag = 0;
|
|
|
+
|
|
|
+ int len = 0;
|
|
|
+ int result = -1;
|
|
|
+ const char *iter = fmt;
|
|
|
+
|
|
|
+ NK_ASSERT(buf);
|
|
|
+ NK_ASSERT(buf_size);
|
|
|
+ if (!buf || !buf_size || !fmt) return 0;
|
|
|
+ for (iter = fmt; *iter && len < buf_size; iter++) {
|
|
|
+ /* copy all non-format characters */
|
|
|
+ while (*iter && (*iter != '%') && (len < buf_size))
|
|
|
+ buf[len++] = *iter++;
|
|
|
+ if (!(*iter) || len >= buf_size) break;
|
|
|
+ iter++;
|
|
|
+
|
|
|
+ /* flag arguments */
|
|
|
+ while (*iter) {
|
|
|
+ if (*iter == '-') flag |= NK_ARG_FLAG_LEFT;
|
|
|
+ else if (*iter == '+') flag |= NK_ARG_FLAG_PLUS;
|
|
|
+ else if (*iter == ' ') flag |= NK_ARG_FLAG_SPACE;
|
|
|
+ else if (*iter == '#') flag |= NK_ARG_FLAG_NUM;
|
|
|
+ else if (*iter == '0') flag |= NK_ARG_FLAG_ZERO;
|
|
|
+ else break;
|
|
|
+ iter++;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* width argument */
|
|
|
+ width = NK_DEFAULT;
|
|
|
+ if (*iter >= '1' && *iter <= '9') {
|
|
|
+ const char *end;
|
|
|
+ width = nk_strtoi(iter, &end);
|
|
|
+ if (end == iter)
|
|
|
+ width = -1;
|
|
|
+ else iter = end;
|
|
|
+ } else if (*iter == '*') {
|
|
|
+ width = va_arg(args, int);
|
|
|
+ iter++;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* precision argument */
|
|
|
+ precision = NK_DEFAULT;
|
|
|
+ if (*iter == '.') {
|
|
|
+ iter++;
|
|
|
+ if (*iter == '*') {
|
|
|
+ precision = va_arg(args, int);
|
|
|
+ iter++;
|
|
|
+ } else {
|
|
|
+ const char *end;
|
|
|
+ precision = nk_strtoi(iter, &end);
|
|
|
+ if (end == iter)
|
|
|
+ precision = -1;
|
|
|
+ else iter = end;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* length modifier */
|
|
|
+ if (*iter == 'h') {
|
|
|
+ if (*(iter+1) == 'h') {
|
|
|
+ arg_type = NK_ARG_TYPE_CHAR;
|
|
|
+ iter++;
|
|
|
+ } else arg_type = NK_ARG_TYPE_SHORT;
|
|
|
+ iter++;
|
|
|
+ } else if (*iter == 'l') {
|
|
|
+ arg_type = NK_ARG_TYPE_LONG;
|
|
|
+ iter++;
|
|
|
+ } else arg_type = NK_ARG_TYPE_DEFAULT;
|
|
|
+
|
|
|
+ /* specifier */
|
|
|
+ if (*iter == '%') {
|
|
|
+ NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
|
|
|
+ NK_ASSERT(precision == NK_DEFAULT);
|
|
|
+ NK_ASSERT(width == NK_DEFAULT);
|
|
|
+ if (len < buf_size)
|
|
|
+ buf[len++] = '%';
|
|
|
+ } else if (*iter == 's') {
|
|
|
+ /* string */
|
|
|
+ const char *str = va_arg(args, const char*);
|
|
|
+ NK_ASSERT(str != buf && "buffer and argument are not allowed to overlap!");
|
|
|
+ NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
|
|
|
+ NK_ASSERT(precision == NK_DEFAULT);
|
|
|
+ NK_ASSERT(width == NK_DEFAULT);
|
|
|
+ if (str == buf) return -1;
|
|
|
+ while (str && *str && len < buf_size)
|
|
|
+ buf[len++] = *str++;
|
|
|
+ } else if (*iter == 'n') {
|
|
|
+ /* current length callback */
|
|
|
+ signed int *n = va_arg(args, int*);
|
|
|
+ NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
|
|
|
+ NK_ASSERT(precision == NK_DEFAULT);
|
|
|
+ NK_ASSERT(width == NK_DEFAULT);
|
|
|
+ if (n) *n = len;
|
|
|
+ } else if (*iter == 'c' || *iter == 'i' || *iter == 'd') {
|
|
|
+ /* signed integer */
|
|
|
+ long value = 0;
|
|
|
+ const char *num_iter;
|
|
|
+ int num_len, num_print, padding;
|
|
|
+ int cur_precision = NK_MAX(precision, 1);
|
|
|
+ int cur_width = NK_MAX(width, 0);
|
|
|
+
|
|
|
+ /* retrieve correct value type */
|
|
|
+ if (arg_type == NK_ARG_TYPE_CHAR)
|
|
|
+ value = (signed char)va_arg(args, int);
|
|
|
+ else if (arg_type == NK_ARG_TYPE_SHORT)
|
|
|
+ value = (signed short)va_arg(args, int);
|
|
|
+ else if (arg_type == NK_ARG_TYPE_LONG)
|
|
|
+ value = va_arg(args, signed long);
|
|
|
+ else if (*iter == 'c')
|
|
|
+ value = (unsigned char)va_arg(args, int);
|
|
|
+ else value = va_arg(args, signed int);
|
|
|
+
|
|
|
+ /* convert number to string */
|
|
|
+ nk_itoa(number_buffer, value);
|
|
|
+ num_len = nk_strlen(number_buffer);
|
|
|
+ padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0);
|
|
|
+ if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE))
|
|
|
+ padding = NK_MAX(padding-1, 0);
|
|
|
+
|
|
|
+ /* fill left padding up to a total of `width` characters */
|
|
|
+ if (!(flag & NK_ARG_FLAG_LEFT)) {
|
|
|
+ while (padding-- > 0 && (len < buf_size)) {
|
|
|
+ if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT))
|
|
|
+ buf[len++] = '0';
|
|
|
+ else buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* copy string value representation into buffer */
|
|
|
+ if ((flag & NK_ARG_FLAG_PLUS) && value >= 0 && len < buf_size)
|
|
|
+ buf[len++] = '+';
|
|
|
+ else if ((flag & NK_ARG_FLAG_SPACE) && value >= 0 && len < buf_size)
|
|
|
+ buf[len++] = ' ';
|
|
|
+
|
|
|
+ /* fill up to precision number of digits with '0' */
|
|
|
+ num_print = NK_MAX(cur_precision, num_len);
|
|
|
+ while (precision && (num_print > num_len) && (len < buf_size)) {
|
|
|
+ buf[len++] = '0';
|
|
|
+ num_print--;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* copy string value representation into buffer */
|
|
|
+ num_iter = number_buffer;
|
|
|
+ while (precision && *num_iter && len < buf_size)
|
|
|
+ buf[len++] = *num_iter++;
|
|
|
+
|
|
|
+ /* fill right padding up to width characters */
|
|
|
+ if (flag & NK_ARG_FLAG_LEFT) {
|
|
|
+ while ((padding-- > 0) && (len < buf_size))
|
|
|
+ buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ } else if (*iter == 'o' || *iter == 'x' || *iter == 'X' || *iter == 'u') {
|
|
|
+ /* unsigned integer */
|
|
|
+ unsigned long value = 0;
|
|
|
+ int num_len = 0, num_print, padding = 0;
|
|
|
+ int cur_precision = NK_MAX(precision, 1);
|
|
|
+ int cur_width = NK_MAX(width, 0);
|
|
|
+ unsigned int base = (*iter == 'o') ? 8: (*iter == 'u')? 10: 16;
|
|
|
+
|
|
|
+ /* print oct/hex/dec value */
|
|
|
+ const char *upper_output_format = "0123456789ABCDEF";
|
|
|
+ const char *lower_output_format = "0123456789abcdef";
|
|
|
+ const char *output_format = (*iter == 'x') ?
|
|
|
+ lower_output_format: upper_output_format;
|
|
|
+
|
|
|
+ /* retrieve correct value type */
|
|
|
+ if (arg_type == NK_ARG_TYPE_CHAR)
|
|
|
+ value = (unsigned char)va_arg(args, int);
|
|
|
+ else if (arg_type == NK_ARG_TYPE_SHORT)
|
|
|
+ value = (unsigned short)va_arg(args, int);
|
|
|
+ else if (arg_type == NK_ARG_TYPE_LONG)
|
|
|
+ value = va_arg(args, unsigned long);
|
|
|
+ else value = va_arg(args, unsigned int);
|
|
|
+
|
|
|
+ do {
|
|
|
+ /* convert decimal number into hex/oct number */
|
|
|
+ int digit = output_format[value % base];
|
|
|
+ if (num_len < NK_MAX_NUMBER_BUFFER)
|
|
|
+ number_buffer[num_len++] = (char)digit;
|
|
|
+ value /= base;
|
|
|
+ } while (value > 0);
|
|
|
+
|
|
|
+ num_print = NK_MAX(cur_precision, num_len);
|
|
|
+ padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0);
|
|
|
+ if (flag & NK_ARG_FLAG_NUM)
|
|
|
+ padding = NK_MAX(padding-1, 0);
|
|
|
+
|
|
|
+ /* fill left padding up to a total of `width` characters */
|
|
|
+ if (!(flag & NK_ARG_FLAG_LEFT)) {
|
|
|
+ while ((padding-- > 0) && (len < buf_size)) {
|
|
|
+ if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT))
|
|
|
+ buf[len++] = '0';
|
|
|
+ else buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill up to precision number of digits */
|
|
|
+ if (num_print && (flag & NK_ARG_FLAG_NUM)) {
|
|
|
+ if ((*iter == 'o') && (len < buf_size)) {
|
|
|
+ buf[len++] = '0';
|
|
|
+ } else if ((*iter == 'x') && ((len+1) < buf_size)) {
|
|
|
+ buf[len++] = '0';
|
|
|
+ buf[len++] = 'x';
|
|
|
+ } else if ((*iter == 'X') && ((len+1) < buf_size)) {
|
|
|
+ buf[len++] = '0';
|
|
|
+ buf[len++] = 'X';
|
|
|
+ }
|
|
|
+ }
|
|
|
+ while (precision && (num_print > num_len) && (len < buf_size)) {
|
|
|
+ buf[len++] = '0';
|
|
|
+ num_print--;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* reverse number direction */
|
|
|
+ while (num_len > 0) {
|
|
|
+ if (precision && (len < buf_size))
|
|
|
+ buf[len++] = number_buffer[num_len-1];
|
|
|
+ num_len--;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill right padding up to width characters */
|
|
|
+ if (flag & NK_ARG_FLAG_LEFT) {
|
|
|
+ while ((padding-- > 0) && (len < buf_size))
|
|
|
+ buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ } else if (*iter == 'f') {
|
|
|
+ /* floating point */
|
|
|
+ const char *num_iter;
|
|
|
+ int cur_precision = (precision < 0) ? 6: precision;
|
|
|
+ int prefix, cur_width = NK_MAX(width, 0);
|
|
|
+ double value = va_arg(args, double);
|
|
|
+ int num_len = 0, frac_len = 0, dot = 0;
|
|
|
+ int padding = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
|
|
|
+ NK_DTOA(number_buffer, value);
|
|
|
+ num_len = nk_strlen(number_buffer);
|
|
|
+
|
|
|
+ /* calculate padding */
|
|
|
+ num_iter = number_buffer;
|
|
|
+ while (*num_iter && *num_iter != '.')
|
|
|
+ num_iter++;
|
|
|
+
|
|
|
+ prefix = (*num_iter == '.')?(int)(num_iter - number_buffer)+1:0;
|
|
|
+ padding = NK_MAX(cur_width - (prefix + NK_MIN(cur_precision, num_len - prefix)) , 0);
|
|
|
+ if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE))
|
|
|
+ padding = NK_MAX(padding-1, 0);
|
|
|
+
|
|
|
+ /* fill left padding up to a total of `width` characters */
|
|
|
+ if (!(flag & NK_ARG_FLAG_LEFT)) {
|
|
|
+ while (padding-- > 0 && (len < buf_size)) {
|
|
|
+ if (flag & NK_ARG_FLAG_ZERO)
|
|
|
+ buf[len++] = '0';
|
|
|
+ else buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* copy string value representation into buffer */
|
|
|
+ num_iter = number_buffer;
|
|
|
+ if ((flag & NK_ARG_FLAG_PLUS) && (value >= 0) && (len < buf_size))
|
|
|
+ buf[len++] = '+';
|
|
|
+ else if ((flag & NK_ARG_FLAG_SPACE) && (value >= 0) && (len < buf_size))
|
|
|
+ buf[len++] = ' ';
|
|
|
+ while (*num_iter) {
|
|
|
+ if (dot) frac_len++;
|
|
|
+ if (len < buf_size)
|
|
|
+ buf[len++] = *num_iter;
|
|
|
+ if (*num_iter == '.') dot = 1;
|
|
|
+ if (frac_len >= cur_precision) break;
|
|
|
+ num_iter++;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill number up to precision */
|
|
|
+ while (frac_len < cur_precision) {
|
|
|
+ if (!dot && len < buf_size) {
|
|
|
+ buf[len++] = '.';
|
|
|
+ dot = 1;
|
|
|
+ }
|
|
|
+ if (len < buf_size)
|
|
|
+ buf[len++] = '0';
|
|
|
+ frac_len++;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill right padding up to width characters */
|
|
|
+ if (flag & NK_ARG_FLAG_LEFT) {
|
|
|
+ while ((padding-- > 0) && (len < buf_size))
|
|
|
+ buf[len++] = ' ';
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* Specifier not supported: g,G,e,E,p,z */
|
|
|
+ NK_ASSERT(0 && "specifier is not supported!");
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ buf[(len >= buf_size)?(buf_size-1):len] = 0;
|
|
|
+ result = (len >= buf_size)?-1:len;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_strfmt(char *buf, int buf_size, const char *fmt, va_list args)
|
|
|
+{
|
|
|
+ int result = -1;
|
|
|
+ NK_ASSERT(buf);
|
|
|
+ NK_ASSERT(buf_size);
|
|
|
+ if (!buf || !buf_size || !fmt) return 0;
|
|
|
+#ifdef NK_INCLUDE_STANDARD_IO
|
|
|
+ result = NK_VSNPRINTF(buf, (nk_size)buf_size, fmt, args);
|
|
|
+ result = (result >= buf_size) ? -1: result;
|
|
|
+ buf[buf_size-1] = 0;
|
|
|
+#else
|
|
|
+ result = nk_vsnprintf(buf, buf_size, fmt, args);
|
|
|
+#endif
|
|
|
+ return result;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API nk_hash
|
|
|
+nk_murmur_hash(const void * key, int len, nk_hash seed)
|
|
|
+{
|
|
|
+ /* 32-Bit MurmurHash3: https://code.google.com/p/smhasher/wiki/MurmurHash3*/
|
|
|
+ #define NK_ROTL(x,r) ((x) << (r) | ((x) >> (32 - r)))
|
|
|
+ union {const nk_uint *i; const nk_byte *b;} conv = {0};
|
|
|
+ const nk_byte *data = (const nk_byte*)key;
|
|
|
+ const int nblocks = len/4;
|
|
|
+ nk_uint h1 = seed;
|
|
|
+ const nk_uint c1 = 0xcc9e2d51;
|
|
|
+ const nk_uint c2 = 0x1b873593;
|
|
|
+ const nk_byte *tail;
|
|
|
+ const nk_uint *blocks;
|
|
|
+ nk_uint k1;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* body */
|
|
|
+ if (!key) return 0;
|
|
|
+ conv.b = (data + nblocks*4);
|
|
|
+ blocks = (const nk_uint*)conv.i;
|
|
|
+ for (i = -nblocks; i; ++i) {
|
|
|
+ k1 = blocks[i];
|
|
|
+ k1 *= c1;
|
|
|
+ k1 = NK_ROTL(k1,15);
|
|
|
+ k1 *= c2;
|
|
|
+
|
|
|
+ h1 ^= k1;
|
|
|
+ h1 = NK_ROTL(h1,13);
|
|
|
+ h1 = h1*5+0xe6546b64;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* tail */
|
|
|
+ tail = (const nk_byte*)(data + nblocks*4);
|
|
|
+ k1 = 0;
|
|
|
+ switch (len & 3) {
|
|
|
+ case 3: k1 ^= (nk_uint)(tail[2] << 16);
|
|
|
+ case 2: k1 ^= (nk_uint)(tail[1] << 8u);
|
|
|
+ case 1: k1 ^= tail[0];
|
|
|
+ k1 *= c1;
|
|
|
+ k1 = NK_ROTL(k1,15);
|
|
|
+ k1 *= c2;
|
|
|
+ h1 ^= k1;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* finalization */
|
|
|
+ h1 ^= (nk_uint)len;
|
|
|
+ /* fmix32 */
|
|
|
+ h1 ^= h1 >> 16;
|
|
|
+ h1 *= 0x85ebca6b;
|
|
|
+ h1 ^= h1 >> 13;
|
|
|
+ h1 *= 0xc2b2ae35;
|
|
|
+ h1 ^= h1 >> 16;
|
|
|
+
|
|
|
+ #undef NK_ROTL
|
|
|
+ return h1;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_STANDARD_IO
|
|
|
+NK_INTERN char*
|
|
|
+nk_file_load(const char* path, nk_size* siz, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ char *buf;
|
|
|
+ FILE *fd;
|
|
|
+ long ret;
|
|
|
+
|
|
|
+ NK_ASSERT(path);
|
|
|
+ NK_ASSERT(siz);
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+ if (!path || !siz || !alloc)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ fd = fopen(path, "rb");
|
|
|
+ if (!fd) return 0;
|
|
|
+ fseek(fd, 0, SEEK_END);
|
|
|
+ ret = ftell(fd);
|
|
|
+ if (ret < 0) {
|
|
|
+ fclose(fd);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ *siz = (nk_size)ret;
|
|
|
+ fseek(fd, 0, SEEK_SET);
|
|
|
+ buf = (char*)alloc->alloc(alloc->userdata,0, *siz);
|
|
|
+ NK_ASSERT(buf);
|
|
|
+ if (!buf) {
|
|
|
+ fclose(fd);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ *siz = (nk_size)fread(buf, *siz, 1, fd);
|
|
|
+ fclose(fd);
|
|
|
+ return buf;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * COLOR
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+NK_INTERN int
|
|
|
+nk_parse_hex(const char *p, int length)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int len = 0;
|
|
|
+ while (len < length) {
|
|
|
+ i <<= 4;
|
|
|
+ if (p[len] >= 'a' && p[len] <= 'f')
|
|
|
+ i += ((p[len] - 'a') + 10);
|
|
|
+ else if (p[len] >= 'A' && p[len] <= 'F')
|
|
|
+ i += ((p[len] - 'A') + 10);
|
|
|
+ else i += (p[len] - '0');
|
|
|
+ len++;
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba(int r, int g, int b, int a)
|
|
|
+{
|
|
|
+ struct nk_color ret;
|
|
|
+ ret.r = (nk_byte)NK_CLAMP(0, r, 255);
|
|
|
+ ret.g = (nk_byte)NK_CLAMP(0, g, 255);
|
|
|
+ ret.b = (nk_byte)NK_CLAMP(0, b, 255);
|
|
|
+ ret.a = (nk_byte)NK_CLAMP(0, a, 255);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb_hex(const char *rgb)
|
|
|
+{
|
|
|
+ struct nk_color col;
|
|
|
+ const char *c = rgb;
|
|
|
+ if (*c == '#') c++;
|
|
|
+ col.r = (nk_byte)nk_parse_hex(c, 2);
|
|
|
+ col.g = (nk_byte)nk_parse_hex(c+2, 2);
|
|
|
+ col.b = (nk_byte)nk_parse_hex(c+4, 2);
|
|
|
+ col.a = 255;
|
|
|
+ return col;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_hex(const char *rgb)
|
|
|
+{
|
|
|
+ struct nk_color col;
|
|
|
+ const char *c = rgb;
|
|
|
+ if (*c == '#') c++;
|
|
|
+ col.r = (nk_byte)nk_parse_hex(c, 2);
|
|
|
+ col.g = (nk_byte)nk_parse_hex(c+2, 2);
|
|
|
+ col.b = (nk_byte)nk_parse_hex(c+4, 2);
|
|
|
+ col.a = (nk_byte)nk_parse_hex(c+6, 2);
|
|
|
+ return col;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hex_rgba(char *output, struct nk_color col)
|
|
|
+{
|
|
|
+ #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i))
|
|
|
+ output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4);
|
|
|
+ output[1] = (char)NK_TO_HEX((col.r & 0x0F));
|
|
|
+ output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4);
|
|
|
+ output[3] = (char)NK_TO_HEX((col.g & 0x0F));
|
|
|
+ output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4);
|
|
|
+ output[5] = (char)NK_TO_HEX((col.b & 0x0F));
|
|
|
+ output[6] = (char)NK_TO_HEX((col.a & 0xF0) >> 4);
|
|
|
+ output[7] = (char)NK_TO_HEX((col.a & 0x0F));
|
|
|
+ output[8] = '\0';
|
|
|
+ #undef NK_TO_HEX
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hex_rgb(char *output, struct nk_color col)
|
|
|
+{
|
|
|
+ #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i))
|
|
|
+ output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4);
|
|
|
+ output[1] = (char)NK_TO_HEX((col.r & 0x0F));
|
|
|
+ output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4);
|
|
|
+ output[3] = (char)NK_TO_HEX((col.g & 0x0F));
|
|
|
+ output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4);
|
|
|
+ output[5] = (char)NK_TO_HEX((col.b & 0x0F));
|
|
|
+ output[6] = '\0';
|
|
|
+ #undef NK_TO_HEX
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_iv(const int *c)
|
|
|
+{
|
|
|
+ return nk_rgba(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_bv(const nk_byte *c)
|
|
|
+{
|
|
|
+ return nk_rgba(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb(int r, int g, int b)
|
|
|
+{
|
|
|
+ struct nk_color ret;
|
|
|
+ ret.r = (nk_byte)NK_CLAMP(0, r, 255);
|
|
|
+ ret.g = (nk_byte)NK_CLAMP(0, g, 255);
|
|
|
+ ret.b = (nk_byte)NK_CLAMP(0, b, 255);
|
|
|
+ ret.a = (nk_byte)255;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb_iv(const int *c)
|
|
|
+{
|
|
|
+ return nk_rgb(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb_bv(const nk_byte* c)
|
|
|
+{
|
|
|
+ return nk_rgb(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_u32(nk_uint in)
|
|
|
+{
|
|
|
+ struct nk_color ret;
|
|
|
+ ret.r = (in & 0xFF);
|
|
|
+ ret.g = ((in >> 8) & 0xFF);
|
|
|
+ ret.b = ((in >> 16) & 0xFF);
|
|
|
+ ret.a = (nk_byte)((in >> 24) & 0xFF);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_f(float r, float g, float b, float a)
|
|
|
+{
|
|
|
+ struct nk_color ret;
|
|
|
+ ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
|
|
|
+ ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
|
|
|
+ ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
|
|
|
+ ret.a = (nk_byte)(NK_SATURATE(a) * 255.0f);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgba_fv(const float *c)
|
|
|
+{
|
|
|
+ return nk_rgba_f(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb_f(float r, float g, float b)
|
|
|
+{
|
|
|
+ struct nk_color ret;
|
|
|
+ ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
|
|
|
+ ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
|
|
|
+ ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
|
|
|
+ ret.a = 255;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_rgb_fv(const float *c)
|
|
|
+{
|
|
|
+ return nk_rgb_f(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsv(int h, int s, int v)
|
|
|
+{
|
|
|
+ return nk_hsva(h, s, v, 255);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsv_iv(const int *c)
|
|
|
+{
|
|
|
+ return nk_hsv(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsv_bv(const nk_byte *c)
|
|
|
+{
|
|
|
+ return nk_hsv(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsv_f(float h, float s, float v)
|
|
|
+{
|
|
|
+ return nk_hsva_f(h, s, v, 1.0f);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsv_fv(const float *c)
|
|
|
+{
|
|
|
+ return nk_hsv_f(c[0], c[1], c[2]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsva(int h, int s, int v, int a)
|
|
|
+{
|
|
|
+ float hf = ((float)NK_CLAMP(0, h, 255)) / 255.0f;
|
|
|
+ float sf = ((float)NK_CLAMP(0, s, 255)) / 255.0f;
|
|
|
+ float vf = ((float)NK_CLAMP(0, v, 255)) / 255.0f;
|
|
|
+ float af = ((float)NK_CLAMP(0, a, 255)) / 255.0f;
|
|
|
+ return nk_hsva_f(hf, sf, vf, af);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsva_iv(const int *c)
|
|
|
+{
|
|
|
+ return nk_hsva(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsva_bv(const nk_byte *c)
|
|
|
+{
|
|
|
+ return nk_hsva(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsva_f(float h, float s, float v, float a)
|
|
|
+{
|
|
|
+ struct nk_colorf out = {0,0,0,0};
|
|
|
+ float p, q, t, f;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (s <= 0.0f) {
|
|
|
+ out.r = v; out.g = v; out.b = v;
|
|
|
+ return nk_rgb_f(out.r, out.g, out.b);
|
|
|
+ }
|
|
|
+
|
|
|
+ h = h / (60.0f/360.0f);
|
|
|
+ i = (int)h;
|
|
|
+ f = h - (float)i;
|
|
|
+ p = v * (1.0f - s);
|
|
|
+ q = v * (1.0f - (s * f));
|
|
|
+ t = v * (1.0f - s * (1.0f - f));
|
|
|
+
|
|
|
+ switch (i) {
|
|
|
+ case 0: default: out.r = v; out.g = t; out.b = p; break;
|
|
|
+ case 1: out.r = q; out.g = v; out.b = p; break;
|
|
|
+ case 2: out.r = p; out.g = v; out.b = t; break;
|
|
|
+ case 3: out.r = p; out.g = q; out.b = v; break;
|
|
|
+ case 4: out.r = t; out.g = p; out.b = v; break;
|
|
|
+ case 5: out.r = v; out.g = p; out.b = q; break;
|
|
|
+ }
|
|
|
+ return nk_rgba_f(out.r, out.g, out.b, a);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_hsva_fv(const float *c)
|
|
|
+{
|
|
|
+ return nk_hsva_f(c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_uint
|
|
|
+nk_color_u32(struct nk_color in)
|
|
|
+{
|
|
|
+ nk_uint out = (nk_uint)in.r;
|
|
|
+ out |= ((nk_uint)in.g << 8);
|
|
|
+ out |= ((nk_uint)in.b << 16);
|
|
|
+ out |= ((nk_uint)in.a << 24);
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_f(float *r, float *g, float *b, float *a, struct nk_color in)
|
|
|
+{
|
|
|
+ NK_STORAGE const float s = 1.0f/255.0f;
|
|
|
+ *r = (float)in.r * s;
|
|
|
+ *g = (float)in.g * s;
|
|
|
+ *b = (float)in.b * s;
|
|
|
+ *a = (float)in.a * s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_fv(float *c, struct nk_color in)
|
|
|
+{
|
|
|
+ nk_color_f(&c[0], &c[1], &c[2], &c[3], in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_d(double *r, double *g, double *b, double *a, struct nk_color in)
|
|
|
+{
|
|
|
+ NK_STORAGE const double s = 1.0/255.0;
|
|
|
+ *r = (double)in.r * s;
|
|
|
+ *g = (double)in.g * s;
|
|
|
+ *b = (double)in.b * s;
|
|
|
+ *a = (double)in.a * s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_dv(double *c, struct nk_color in)
|
|
|
+{
|
|
|
+ nk_color_d(&c[0], &c[1], &c[2], &c[3], in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_f(float *out_h, float *out_s, float *out_v, struct nk_color in)
|
|
|
+{
|
|
|
+ float a;
|
|
|
+ nk_color_hsva_f(out_h, out_s, out_v, &a, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_fv(float *out, struct nk_color in)
|
|
|
+{
|
|
|
+ float a;
|
|
|
+ nk_color_hsva_f(&out[0], &out[1], &out[2], &a, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_f(float *out_h, float *out_s,
|
|
|
+ float *out_v, float *out_a, struct nk_color in)
|
|
|
+{
|
|
|
+ float chroma;
|
|
|
+ float K = 0.0f;
|
|
|
+ float r,g,b,a;
|
|
|
+
|
|
|
+ nk_color_f(&r,&g,&b,&a, in);
|
|
|
+ if (g < b) {
|
|
|
+ const float t = g; g = b; b = t;
|
|
|
+ K = -1.f;
|
|
|
+ }
|
|
|
+ if (r < g) {
|
|
|
+ const float t = r; r = g; g = t;
|
|
|
+ K = -2.f/6.0f - K;
|
|
|
+ }
|
|
|
+ chroma = r - ((g < b) ? g: b);
|
|
|
+ *out_h = NK_ABS(K + (g - b)/(6.0f * chroma + 1e-20f));
|
|
|
+ *out_s = chroma / (r + 1e-20f);
|
|
|
+ *out_v = r;
|
|
|
+ *out_a = (float)in.a / 255.0f;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_fv(float *out, struct nk_color in)
|
|
|
+{
|
|
|
+ nk_color_hsva_f(&out[0], &out[1], &out[2], &out[3], in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_i(int *out_h, int *out_s, int *out_v,
|
|
|
+ int *out_a, struct nk_color in)
|
|
|
+{
|
|
|
+ float h,s,v,a;
|
|
|
+ nk_color_hsva_f(&h, &s, &v, &a, in);
|
|
|
+ *out_h = (nk_byte)(h * 255.0f);
|
|
|
+ *out_s = (nk_byte)(s * 255.0f);
|
|
|
+ *out_v = (nk_byte)(v * 255.0f);
|
|
|
+ *out_a = (nk_byte)(a * 255.0f);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_iv(int *out, struct nk_color in)
|
|
|
+{
|
|
|
+ nk_color_hsva_i(&out[0], &out[1], &out[2], &out[3], in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_bv(nk_byte *out, struct nk_color in)
|
|
|
+{
|
|
|
+ int tmp[4];
|
|
|
+ nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
|
|
|
+ out[0] = (nk_byte)tmp[0];
|
|
|
+ out[1] = (nk_byte)tmp[1];
|
|
|
+ out[2] = (nk_byte)tmp[2];
|
|
|
+ out[3] = (nk_byte)tmp[3];
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsva_b(nk_byte *h, nk_byte *s, nk_byte *v, nk_byte *a, struct nk_color in)
|
|
|
+{
|
|
|
+ int tmp[4];
|
|
|
+ nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
|
|
|
+ *h = (nk_byte)tmp[0];
|
|
|
+ *s = (nk_byte)tmp[1];
|
|
|
+ *v = (nk_byte)tmp[2];
|
|
|
+ *a = (nk_byte)tmp[3];
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_i(int *out_h, int *out_s, int *out_v, struct nk_color in)
|
|
|
+{
|
|
|
+ int a;
|
|
|
+ nk_color_hsva_i(out_h, out_s, out_v, &a, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_b(nk_byte *out_h, nk_byte *out_s, nk_byte *out_v, struct nk_color in)
|
|
|
+{
|
|
|
+ int tmp[4];
|
|
|
+ nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
|
|
|
+ *out_h = (nk_byte)tmp[0];
|
|
|
+ *out_s = (nk_byte)tmp[1];
|
|
|
+ *out_v = (nk_byte)tmp[2];
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_iv(int *out, struct nk_color in)
|
|
|
+{
|
|
|
+ nk_color_hsv_i(&out[0], &out[1], &out[2], in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_color_hsv_bv(nk_byte *out, struct nk_color in)
|
|
|
+{
|
|
|
+ int tmp[4];
|
|
|
+ nk_color_hsv_i(&tmp[0], &tmp[1], &tmp[2], in);
|
|
|
+ out[0] = (nk_byte)tmp[0];
|
|
|
+ out[1] = (nk_byte)tmp[1];
|
|
|
+ out[2] = (nk_byte)tmp[2];
|
|
|
+}
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * IMAGE
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+NK_API nk_handle
|
|
|
+nk_handle_ptr(void *ptr)
|
|
|
+{
|
|
|
+ nk_handle handle = {0};
|
|
|
+ handle.ptr = ptr;
|
|
|
+ return handle;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_handle
|
|
|
+nk_handle_id(int id)
|
|
|
+{
|
|
|
+ nk_handle handle;
|
|
|
+ nk_zero_struct(handle);
|
|
|
+ handle.id = id;
|
|
|
+ return handle;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_subimage_ptr(void *ptr, unsigned short w, unsigned short h, struct nk_rect r)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ s.handle.ptr = ptr;
|
|
|
+ s.w = w; s.h = h;
|
|
|
+ s.region[0] = (unsigned short)r.x;
|
|
|
+ s.region[1] = (unsigned short)r.y;
|
|
|
+ s.region[2] = (unsigned short)r.w;
|
|
|
+ s.region[3] = (unsigned short)r.h;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_subimage_id(int id, unsigned short w, unsigned short h, struct nk_rect r)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ s.handle.id = id;
|
|
|
+ s.w = w; s.h = h;
|
|
|
+ s.region[0] = (unsigned short)r.x;
|
|
|
+ s.region[1] = (unsigned short)r.y;
|
|
|
+ s.region[2] = (unsigned short)r.w;
|
|
|
+ s.region[3] = (unsigned short)r.h;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_subimage_handle(nk_handle handle, unsigned short w, unsigned short h,
|
|
|
+ struct nk_rect r)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ s.handle = handle;
|
|
|
+ s.w = w; s.h = h;
|
|
|
+ s.region[0] = (unsigned short)r.x;
|
|
|
+ s.region[1] = (unsigned short)r.y;
|
|
|
+ s.region[2] = (unsigned short)r.w;
|
|
|
+ s.region[3] = (unsigned short)r.h;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_image_handle(nk_handle handle)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ s.handle = handle;
|
|
|
+ s.w = 0; s.h = 0;
|
|
|
+ s.region[0] = 0;
|
|
|
+ s.region[1] = 0;
|
|
|
+ s.region[2] = 0;
|
|
|
+ s.region[3] = 0;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_image_ptr(void *ptr)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ NK_ASSERT(ptr);
|
|
|
+ s.handle.ptr = ptr;
|
|
|
+ s.w = 0; s.h = 0;
|
|
|
+ s.region[0] = 0;
|
|
|
+ s.region[1] = 0;
|
|
|
+ s.region[2] = 0;
|
|
|
+ s.region[3] = 0;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_image
|
|
|
+nk_image_id(int id)
|
|
|
+{
|
|
|
+ struct nk_image s;
|
|
|
+ nk_zero(&s, sizeof(s));
|
|
|
+ s.handle.id = id;
|
|
|
+ s.w = 0; s.h = 0;
|
|
|
+ s.region[0] = 0;
|
|
|
+ s.region[1] = 0;
|
|
|
+ s.region[2] = 0;
|
|
|
+ s.region[3] = 0;
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_image_is_subimage(const struct nk_image* img)
|
|
|
+{
|
|
|
+ NK_ASSERT(img);
|
|
|
+ return !(img->w == 0 && img->h == 0);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_unify(struct nk_rect *clip, const struct nk_rect *a, float x0, float y0,
|
|
|
+ float x1, float y1)
|
|
|
+{
|
|
|
+ NK_ASSERT(a);
|
|
|
+ NK_ASSERT(clip);
|
|
|
+ clip->x = NK_MAX(a->x, x0);
|
|
|
+ clip->y = NK_MAX(a->y, y0);
|
|
|
+ clip->w = NK_MIN(a->x + a->w, x1) - clip->x;
|
|
|
+ clip->h = NK_MIN(a->y + a->h, y1) - clip->y;
|
|
|
+ clip->w = NK_MAX(0, clip->w);
|
|
|
+ clip->h = NK_MAX(0, clip->h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_triangle_from_direction(struct nk_vec2 *result, struct nk_rect r,
|
|
|
+ float pad_x, float pad_y, enum nk_heading direction)
|
|
|
+{
|
|
|
+ float w_half, h_half;
|
|
|
+ NK_ASSERT(result);
|
|
|
+
|
|
|
+ r.w = NK_MAX(2 * pad_x, r.w);
|
|
|
+ r.h = NK_MAX(2 * pad_y, r.h);
|
|
|
+ r.w = r.w - 2 * pad_x;
|
|
|
+ r.h = r.h - 2 * pad_y;
|
|
|
+
|
|
|
+ r.x = r.x + pad_x;
|
|
|
+ r.y = r.y + pad_y;
|
|
|
+
|
|
|
+ w_half = r.w / 2.0f;
|
|
|
+ h_half = r.h / 2.0f;
|
|
|
+
|
|
|
+ if (direction == NK_UP) {
|
|
|
+ result[0] = nk_vec2(r.x + w_half, r.y);
|
|
|
+ result[1] = nk_vec2(r.x + r.w, r.y + r.h);
|
|
|
+ result[2] = nk_vec2(r.x, r.y + r.h);
|
|
|
+ } else if (direction == NK_RIGHT) {
|
|
|
+ result[0] = nk_vec2(r.x, r.y);
|
|
|
+ result[1] = nk_vec2(r.x + r.w, r.y + h_half);
|
|
|
+ result[2] = nk_vec2(r.x, r.y + r.h);
|
|
|
+ } else if (direction == NK_DOWN) {
|
|
|
+ result[0] = nk_vec2(r.x, r.y);
|
|
|
+ result[1] = nk_vec2(r.x + r.w, r.y);
|
|
|
+ result[2] = nk_vec2(r.x + w_half, r.y + r.h);
|
|
|
+ } else {
|
|
|
+ result[0] = nk_vec2(r.x, r.y + h_half);
|
|
|
+ result[1] = nk_vec2(r.x + r.w, r.y);
|
|
|
+ result[2] = nk_vec2(r.x + r.w, r.y + r.h);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_text_clamp(const struct nk_user_font *font, const char *text,
|
|
|
+ int text_len, float space, int *glyphs, float *text_width,
|
|
|
+ nk_rune *sep_list, int sep_count)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ float last_width = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ float width = 0;
|
|
|
+ int len = 0;
|
|
|
+ int g = 0;
|
|
|
+ float s;
|
|
|
+
|
|
|
+ int sep_len = 0;
|
|
|
+ int sep_g = 0;
|
|
|
+ float sep_width = 0;
|
|
|
+ sep_count = NK_MAX(sep_count,0);
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(text, &unicode, text_len);
|
|
|
+ while (glyph_len && (width < space) && (len < text_len)) {
|
|
|
+ len += glyph_len;
|
|
|
+ s = font->width(font->userdata, font->height, text, len);
|
|
|
+ for (i = 0; i < sep_count; ++i) {
|
|
|
+ if (unicode != sep_list[i]) continue;
|
|
|
+ sep_width = last_width = width;
|
|
|
+ sep_g = g+1;
|
|
|
+ sep_len = len;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (i == sep_count){
|
|
|
+ last_width = sep_width = width;
|
|
|
+ sep_g = g+1;
|
|
|
+ }
|
|
|
+ width = s;
|
|
|
+ glyph_len = nk_utf_decode(&text[len], &unicode, text_len - len);
|
|
|
+ g++;
|
|
|
+ }
|
|
|
+ if (len >= text_len) {
|
|
|
+ *glyphs = g;
|
|
|
+ *text_width = last_width;
|
|
|
+ return len;
|
|
|
+ } else {
|
|
|
+ *glyphs = sep_g;
|
|
|
+ *text_width = sep_width;
|
|
|
+ return (!sep_len) ? len: sep_len;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+enum {NK_DO_NOT_STOP_ON_NEW_LINE, NK_STOP_ON_NEW_LINE};
|
|
|
+NK_INTERN struct nk_vec2
|
|
|
+nk_text_calculate_text_bounds(const struct nk_user_font *font,
|
|
|
+ const char *begin, int byte_len, float row_height, const char **remaining,
|
|
|
+ struct nk_vec2 *out_offset, int *glyphs, int op)
|
|
|
+{
|
|
|
+ float line_height = row_height;
|
|
|
+ struct nk_vec2 text_size = nk_vec2(0,0);
|
|
|
+ float line_width = 0.0f;
|
|
|
+
|
|
|
+ float glyph_width;
|
|
|
+ int glyph_len = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ int text_len = 0;
|
|
|
+ if (!begin || byte_len <= 0 || !font)
|
|
|
+ return nk_vec2(0,row_height);
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(begin, &unicode, byte_len);
|
|
|
+ if (!glyph_len) return text_size;
|
|
|
+ glyph_width = font->width(font->userdata, font->height, begin, glyph_len);
|
|
|
+
|
|
|
+ *glyphs = 0;
|
|
|
+ while ((text_len < byte_len) && glyph_len) {
|
|
|
+ if (unicode == '\n') {
|
|
|
+ text_size.x = NK_MAX(text_size.x, line_width);
|
|
|
+ text_size.y += line_height;
|
|
|
+ line_width = 0;
|
|
|
+ *glyphs+=1;
|
|
|
+ if (op == NK_STOP_ON_NEW_LINE)
|
|
|
+ break;
|
|
|
+
|
|
|
+ text_len++;
|
|
|
+ glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (unicode == '\r') {
|
|
|
+ text_len++;
|
|
|
+ *glyphs+=1;
|
|
|
+ glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ *glyphs = *glyphs + 1;
|
|
|
+ text_len += glyph_len;
|
|
|
+ line_width += (float)glyph_width;
|
|
|
+ glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len);
|
|
|
+ glyph_width = font->width(font->userdata, font->height, begin+text_len, glyph_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (text_size.x < line_width)
|
|
|
+ text_size.x = line_width;
|
|
|
+ if (out_offset)
|
|
|
+ *out_offset = nk_vec2(line_width, text_size.y + line_height);
|
|
|
+ if (line_width > 0 || text_size.y == 0.0f)
|
|
|
+ text_size.y += line_height;
|
|
|
+ if (remaining)
|
|
|
+ *remaining = begin+text_len;
|
|
|
+ return text_size;
|
|
|
+}
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * UTF-8
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_GLOBAL const nk_byte nk_utfbyte[NK_UTF_SIZE+1] = {0x80, 0, 0xC0, 0xE0, 0xF0};
|
|
|
+NK_GLOBAL const nk_byte nk_utfmask[NK_UTF_SIZE+1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
|
|
|
+NK_GLOBAL const nk_uint nk_utfmin[NK_UTF_SIZE+1] = {0, 0, 0x80, 0x800, 0x10000};
|
|
|
+NK_GLOBAL const nk_uint nk_utfmax[NK_UTF_SIZE+1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_utf_validate(nk_rune *u, int i)
|
|
|
+{
|
|
|
+ NK_ASSERT(u);
|
|
|
+ if (!u) return 0;
|
|
|
+ if (!NK_BETWEEN(*u, nk_utfmin[i], nk_utfmax[i]) ||
|
|
|
+ NK_BETWEEN(*u, 0xD800, 0xDFFF))
|
|
|
+ *u = NK_UTF_INVALID;
|
|
|
+ for (i = 1; *u > nk_utfmax[i]; ++i);
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_rune
|
|
|
+nk_utf_decode_byte(char c, int *i)
|
|
|
+{
|
|
|
+ NK_ASSERT(i);
|
|
|
+ if (!i) return 0;
|
|
|
+ for(*i = 0; *i < (int)NK_LEN(nk_utfmask); ++(*i)) {
|
|
|
+ if (((nk_byte)c & nk_utfmask[*i]) == nk_utfbyte[*i])
|
|
|
+ return (nk_byte)(c & ~nk_utfmask[*i]);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_utf_decode(const char *c, nk_rune *u, int clen)
|
|
|
+{
|
|
|
+ int i, j, len, type=0;
|
|
|
+ nk_rune udecoded;
|
|
|
+
|
|
|
+ NK_ASSERT(c);
|
|
|
+ NK_ASSERT(u);
|
|
|
+
|
|
|
+ if (!c || !u) return 0;
|
|
|
+ if (!clen) return 0;
|
|
|
+ *u = NK_UTF_INVALID;
|
|
|
+
|
|
|
+ udecoded = nk_utf_decode_byte(c[0], &len);
|
|
|
+ if (!NK_BETWEEN(len, 1, NK_UTF_SIZE))
|
|
|
+ return 1;
|
|
|
+
|
|
|
+ for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
|
|
|
+ udecoded = (udecoded << 6) | nk_utf_decode_byte(c[i], &type);
|
|
|
+ if (type != 0)
|
|
|
+ return j;
|
|
|
+ }
|
|
|
+ if (j < len)
|
|
|
+ return 0;
|
|
|
+ *u = udecoded;
|
|
|
+ nk_utf_validate(u, len);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN char
|
|
|
+nk_utf_encode_byte(nk_rune u, int i)
|
|
|
+{
|
|
|
+ return (char)((nk_utfbyte[i]) | ((nk_byte)u & ~nk_utfmask[i]));
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_utf_encode(nk_rune u, char *c, int clen)
|
|
|
+{
|
|
|
+ int len, i;
|
|
|
+ len = nk_utf_validate(&u, 0);
|
|
|
+ if (clen < len || !len || len > NK_UTF_SIZE)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ for (i = len - 1; i != 0; --i) {
|
|
|
+ c[i] = nk_utf_encode_byte(u, 0);
|
|
|
+ u >>= 6;
|
|
|
+ }
|
|
|
+ c[0] = nk_utf_encode_byte(u, len);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_utf_len(const char *str, int len)
|
|
|
+{
|
|
|
+ const char *text;
|
|
|
+ int glyphs = 0;
|
|
|
+ int text_len;
|
|
|
+ int glyph_len;
|
|
|
+ int src_len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str || !len) return 0;
|
|
|
+
|
|
|
+ text = str;
|
|
|
+ text_len = len;
|
|
|
+ glyph_len = nk_utf_decode(text, &unicode, text_len);
|
|
|
+ while (glyph_len && src_len < len) {
|
|
|
+ glyphs++;
|
|
|
+ src_len = src_len + glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + src_len, &unicode, text_len - src_len);
|
|
|
+ }
|
|
|
+ return glyphs;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const char*
|
|
|
+nk_utf_at(const char *buffer, int length, int index,
|
|
|
+ nk_rune *unicode, int *len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int src_len = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ const char *text;
|
|
|
+ int text_len;
|
|
|
+
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ NK_ASSERT(unicode);
|
|
|
+ NK_ASSERT(len);
|
|
|
+
|
|
|
+ if (!buffer || !unicode || !len) return 0;
|
|
|
+ if (index < 0) {
|
|
|
+ *unicode = NK_UTF_INVALID;
|
|
|
+ *len = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ text = buffer;
|
|
|
+ text_len = length;
|
|
|
+ glyph_len = nk_utf_decode(text, unicode, text_len);
|
|
|
+ while (glyph_len) {
|
|
|
+ if (i == index) {
|
|
|
+ *len = glyph_len;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ src_len = src_len + glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len);
|
|
|
+ }
|
|
|
+ if (i != index) return 0;
|
|
|
+ return buffer + src_len;
|
|
|
+}
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * BUFFER
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_INTERN void* nk_malloc(nk_handle unused, void *old,nk_size size)
|
|
|
+{NK_UNUSED(unused); NK_UNUSED(old); return malloc(size);}
|
|
|
+NK_INTERN void nk_mfree(nk_handle unused, void *ptr)
|
|
|
+{NK_UNUSED(unused); free(ptr);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_init_default(struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ alloc.userdata.ptr = 0;
|
|
|
+ alloc.alloc = nk_malloc;
|
|
|
+ alloc.free = nk_mfree;
|
|
|
+ nk_buffer_init(buffer, &alloc, NK_BUFFER_DEFAULT_INITIAL_SIZE);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_init(struct nk_buffer *b, const struct nk_allocator *a,
|
|
|
+ nk_size initial_size)
|
|
|
+{
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(a);
|
|
|
+ NK_ASSERT(initial_size);
|
|
|
+ if (!b || !a || !initial_size) return;
|
|
|
+
|
|
|
+ nk_zero(b, sizeof(*b));
|
|
|
+ b->type = NK_BUFFER_DYNAMIC;
|
|
|
+ b->memory.ptr = a->alloc(a->userdata,0, initial_size);
|
|
|
+ b->memory.size = initial_size;
|
|
|
+ b->size = initial_size;
|
|
|
+ b->grow_factor = 2.0f;
|
|
|
+ b->pool = *a;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_init_fixed(struct nk_buffer *b, void *m, nk_size size)
|
|
|
+{
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(m);
|
|
|
+ NK_ASSERT(size);
|
|
|
+ if (!b || !m || !size) return;
|
|
|
+
|
|
|
+ nk_zero(b, sizeof(*b));
|
|
|
+ b->type = NK_BUFFER_FIXED;
|
|
|
+ b->memory.ptr = m;
|
|
|
+ b->memory.size = size;
|
|
|
+ b->size = size;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_buffer_align(void *unaligned, nk_size align, nk_size *alignment,
|
|
|
+ enum nk_buffer_allocation_type type)
|
|
|
+{
|
|
|
+ void *memory = 0;
|
|
|
+ switch (type) {
|
|
|
+ default:
|
|
|
+ case NK_BUFFER_MAX:
|
|
|
+ case NK_BUFFER_FRONT:
|
|
|
+ if (align) {
|
|
|
+ memory = NK_ALIGN_PTR(unaligned, align);
|
|
|
+ *alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned);
|
|
|
+ } else {
|
|
|
+ memory = unaligned;
|
|
|
+ *alignment = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case NK_BUFFER_BACK:
|
|
|
+ if (align) {
|
|
|
+ memory = NK_ALIGN_PTR_BACK(unaligned, align);
|
|
|
+ *alignment = (nk_size)((nk_byte*)unaligned - (nk_byte*)memory);
|
|
|
+ } else {
|
|
|
+ memory = unaligned;
|
|
|
+ *alignment = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return memory;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_buffer_realloc(struct nk_buffer *b, nk_size capacity, nk_size *size)
|
|
|
+{
|
|
|
+ void *temp;
|
|
|
+ nk_size buffer_size;
|
|
|
+
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(size);
|
|
|
+ if (!b || !size || !b->pool.alloc || !b->pool.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ buffer_size = b->memory.size;
|
|
|
+ temp = b->pool.alloc(b->pool.userdata, b->memory.ptr, capacity);
|
|
|
+ NK_ASSERT(temp);
|
|
|
+ if (!temp) return 0;
|
|
|
+
|
|
|
+ *size = capacity;
|
|
|
+ if (temp != b->memory.ptr) {
|
|
|
+ NK_MEMCPY(temp, b->memory.ptr, buffer_size);
|
|
|
+ b->pool.free(b->pool.userdata, b->memory.ptr);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (b->size == buffer_size) {
|
|
|
+ /* no back buffer so just set correct size */
|
|
|
+ b->size = capacity;
|
|
|
+ return temp;
|
|
|
+ } else {
|
|
|
+ /* copy back buffer to the end of the new buffer */
|
|
|
+ void *dst, *src;
|
|
|
+ nk_size back_size;
|
|
|
+ back_size = buffer_size - b->size;
|
|
|
+ dst = nk_ptr_add(void, temp, capacity - back_size);
|
|
|
+ src = nk_ptr_add(void, temp, b->size);
|
|
|
+ NK_MEMCPY(dst, src, back_size);
|
|
|
+ b->size = capacity - back_size;
|
|
|
+ }
|
|
|
+ return temp;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_buffer_alloc(struct nk_buffer *b, enum nk_buffer_allocation_type type,
|
|
|
+ nk_size size, nk_size align)
|
|
|
+{
|
|
|
+ int full;
|
|
|
+ nk_size alignment;
|
|
|
+ void *unaligned;
|
|
|
+ void *memory;
|
|
|
+
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(size);
|
|
|
+ if (!b || !size) return 0;
|
|
|
+ b->needed += size;
|
|
|
+
|
|
|
+ /* calculate total size with needed alignment + size */
|
|
|
+ if (type == NK_BUFFER_FRONT)
|
|
|
+ unaligned = nk_ptr_add(void, b->memory.ptr, b->allocated);
|
|
|
+ else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size);
|
|
|
+ memory = nk_buffer_align(unaligned, align, &alignment, type);
|
|
|
+
|
|
|
+ /* check if buffer has enough memory*/
|
|
|
+ if (type == NK_BUFFER_FRONT)
|
|
|
+ full = ((b->allocated + size + alignment) > b->size);
|
|
|
+ else full = ((b->size - NK_MIN(b->size,(size + alignment))) <= b->allocated);
|
|
|
+
|
|
|
+ if (full) {
|
|
|
+ nk_size capacity;
|
|
|
+ if (b->type != NK_BUFFER_DYNAMIC)
|
|
|
+ return 0;
|
|
|
+ NK_ASSERT(b->pool.alloc && b->pool.free);
|
|
|
+ if (b->type != NK_BUFFER_DYNAMIC || !b->pool.alloc || !b->pool.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* buffer is full so allocate bigger buffer if dynamic */
|
|
|
+ capacity = (nk_size)((float)b->memory.size * b->grow_factor);
|
|
|
+ capacity = NK_MAX(capacity, nk_round_up_pow2((nk_uint)(b->allocated + size)));
|
|
|
+ b->memory.ptr = nk_buffer_realloc(b, capacity, &b->memory.size);
|
|
|
+ if (!b->memory.ptr) return 0;
|
|
|
+
|
|
|
+ /* align newly allocated pointer */
|
|
|
+ if (type == NK_BUFFER_FRONT)
|
|
|
+ unaligned = nk_ptr_add(void, b->memory.ptr, b->allocated);
|
|
|
+ else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size);
|
|
|
+ memory = nk_buffer_align(unaligned, align, &alignment, type);
|
|
|
+ }
|
|
|
+ if (type == NK_BUFFER_FRONT)
|
|
|
+ b->allocated += size + alignment;
|
|
|
+ else b->size -= (size + alignment);
|
|
|
+ b->needed += alignment;
|
|
|
+ b->calls++;
|
|
|
+ return memory;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_push(struct nk_buffer *b, enum nk_buffer_allocation_type type,
|
|
|
+ const void *memory, nk_size size, nk_size align)
|
|
|
+{
|
|
|
+ void *mem = nk_buffer_alloc(b, type, size, align);
|
|
|
+ if (!mem) return;
|
|
|
+ NK_MEMCPY(mem, memory, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_mark(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return;
|
|
|
+ buffer->marker[type].active = nk_true;
|
|
|
+ if (type == NK_BUFFER_BACK)
|
|
|
+ buffer->marker[type].offset = buffer->size;
|
|
|
+ else buffer->marker[type].offset = buffer->allocated;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_reset(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return;
|
|
|
+ if (type == NK_BUFFER_BACK) {
|
|
|
+ /* reset back buffer either back to marker or empty */
|
|
|
+ buffer->needed -= (buffer->memory.size - buffer->marker[type].offset);
|
|
|
+ if (buffer->marker[type].active)
|
|
|
+ buffer->size = buffer->marker[type].offset;
|
|
|
+ else buffer->size = buffer->memory.size;
|
|
|
+ buffer->marker[type].active = nk_false;
|
|
|
+ } else {
|
|
|
+ /* reset front buffer either back to back marker or empty */
|
|
|
+ buffer->needed -= (buffer->allocated - buffer->marker[type].offset);
|
|
|
+ if (buffer->marker[type].active)
|
|
|
+ buffer->allocated = buffer->marker[type].offset;
|
|
|
+ else buffer->allocated = 0;
|
|
|
+ buffer->marker[type].active = nk_false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_clear(struct nk_buffer *b)
|
|
|
+{
|
|
|
+ NK_ASSERT(b);
|
|
|
+ if (!b) return;
|
|
|
+ b->allocated = 0;
|
|
|
+ b->size = b->memory.size;
|
|
|
+ b->calls = 0;
|
|
|
+ b->needed = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_free(struct nk_buffer *b)
|
|
|
+{
|
|
|
+ NK_ASSERT(b);
|
|
|
+ if (!b || !b->memory.ptr) return;
|
|
|
+ if (b->type == NK_BUFFER_FIXED) return;
|
|
|
+ if (!b->pool.free) return;
|
|
|
+ NK_ASSERT(b->pool.free);
|
|
|
+ b->pool.free(b->pool.userdata, b->memory.ptr);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_buffer_info(struct nk_memory_status *s, struct nk_buffer *b)
|
|
|
+{
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !b) return;
|
|
|
+ s->allocated = b->allocated;
|
|
|
+ s->size = b->memory.size;
|
|
|
+ s->needed = b->needed;
|
|
|
+ s->memory = b->memory.ptr;
|
|
|
+ s->calls = b->calls;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void*
|
|
|
+nk_buffer_memory(struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return 0;
|
|
|
+ return buffer->memory.ptr;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const void*
|
|
|
+nk_buffer_memory_const(const struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return 0;
|
|
|
+ return buffer->memory.ptr;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_size
|
|
|
+nk_buffer_total(struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return 0;
|
|
|
+ return buffer->memory.size;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * STRING
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void
|
|
|
+nk_str_init_default(struct nk_str *str)
|
|
|
+{
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ alloc.userdata.ptr = 0;
|
|
|
+ alloc.alloc = nk_malloc;
|
|
|
+ alloc.free = nk_mfree;
|
|
|
+ nk_buffer_init(&str->buffer, &alloc, 32);
|
|
|
+ str->len = 0;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_init(struct nk_str *str, const struct nk_allocator *alloc, nk_size size)
|
|
|
+{
|
|
|
+ nk_buffer_init(&str->buffer, alloc, size);
|
|
|
+ str->len = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_init_fixed(struct nk_str *str, void *memory, nk_size size)
|
|
|
+{
|
|
|
+ nk_buffer_init_fixed(&str->buffer, memory, size);
|
|
|
+ str->len = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_text_char(struct nk_str *s, const char *str, int len)
|
|
|
+{
|
|
|
+ char *mem;
|
|
|
+ NK_ASSERT(s);
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!s || !str || !len) return 0;
|
|
|
+ mem = (char*)nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
|
|
|
+ if (!mem) return 0;
|
|
|
+ NK_MEMCPY(mem, str, (nk_size)len * sizeof(char));
|
|
|
+ s->len += nk_utf_len(str, len);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_str_char(struct nk_str *s, const char *str)
|
|
|
+{
|
|
|
+ return nk_str_append_text_char(s, str, nk_strlen(str));
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_text_utf8(struct nk_str *str, const char *text, int len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+ if (!str || !text || !len) return 0;
|
|
|
+ for (i = 0; i < len; ++i)
|
|
|
+ byte_len += nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ nk_str_append_text_char(str, text, byte_len);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_str_utf8(struct nk_str *str, const char *text)
|
|
|
+{
|
|
|
+ int runes = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ int num_runes = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+ if (!str || !text) return 0;
|
|
|
+
|
|
|
+ glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ while (unicode != '\0' && glyph_len) {
|
|
|
+ glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ byte_len += glyph_len;
|
|
|
+ num_runes++;
|
|
|
+ }
|
|
|
+ nk_str_append_text_char(str, text, byte_len);
|
|
|
+ return runes;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_text_runes(struct nk_str *str, const nk_rune *text, int len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ nk_glyph glyph;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str || !text || !len) return 0;
|
|
|
+ for (i = 0; i < len; ++i) {
|
|
|
+ byte_len = nk_utf_encode(text[i], glyph, NK_UTF_SIZE);
|
|
|
+ if (!byte_len) break;
|
|
|
+ nk_str_append_text_char(str, glyph, byte_len);
|
|
|
+ }
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_append_str_runes(struct nk_str *str, const nk_rune *runes)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ nk_glyph glyph;
|
|
|
+ int byte_len;
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str || !runes) return 0;
|
|
|
+ while (runes[i] != '\0') {
|
|
|
+ byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
|
|
|
+ nk_str_append_text_char(str, glyph, byte_len);
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_at_char(struct nk_str *s, int pos, const char *str, int len)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ void *mem;
|
|
|
+ char *src;
|
|
|
+ char *dst;
|
|
|
+
|
|
|
+ int copylen;
|
|
|
+ NK_ASSERT(s);
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(len >= 0);
|
|
|
+ if (!s || !str || !len || (nk_size)pos > s->buffer.allocated) return 0;
|
|
|
+ if ((s->buffer.allocated + (nk_size)len >= s->buffer.memory.size) &&
|
|
|
+ (s->buffer.type == NK_BUFFER_FIXED)) return 0;
|
|
|
+
|
|
|
+ copylen = (int)s->buffer.allocated - pos;
|
|
|
+ if (!copylen) {
|
|
|
+ nk_str_append_text_char(s, str, len);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ mem = nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
|
|
|
+ if (!mem) return 0;
|
|
|
+
|
|
|
+ /* memmove */
|
|
|
+ NK_ASSERT(((int)pos + (int)len + ((int)copylen - 1)) >= 0);
|
|
|
+ NK_ASSERT(((int)pos + ((int)copylen - 1)) >= 0);
|
|
|
+ dst = nk_ptr_add(char, s->buffer.memory.ptr, pos + len + (copylen - 1));
|
|
|
+ src = nk_ptr_add(char, s->buffer.memory.ptr, pos + (copylen-1));
|
|
|
+ for (i = 0; i < copylen; ++i) *dst-- = *src--;
|
|
|
+ mem = nk_ptr_add(void, s->buffer.memory.ptr, pos);
|
|
|
+ NK_MEMCPY(mem, str, (nk_size)len * sizeof(char));
|
|
|
+ s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_at_rune(struct nk_str *str, int pos, const char *cstr, int len)
|
|
|
+{
|
|
|
+ int glyph_len;
|
|
|
+ nk_rune unicode;
|
|
|
+ const char *begin;
|
|
|
+ const char *buffer;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(cstr);
|
|
|
+ NK_ASSERT(len);
|
|
|
+ if (!str || !cstr || !len) return 0;
|
|
|
+ begin = nk_str_at_rune(str, pos, &unicode, &glyph_len);
|
|
|
+ if (!str->len)
|
|
|
+ return nk_str_append_text_char(str, cstr, len);
|
|
|
+ buffer = nk_str_get_const(str);
|
|
|
+ if (!begin) return 0;
|
|
|
+ return nk_str_insert_at_char(str, (int)(begin - buffer), cstr, len);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_text_char(struct nk_str *str, int pos, const char *text, int len)
|
|
|
+{
|
|
|
+ return nk_str_insert_text_utf8(str, pos, text, len);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_str_char(struct nk_str *str, int pos, const char *text)
|
|
|
+{
|
|
|
+ return nk_str_insert_text_utf8(str, pos, text, nk_strlen(text));
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ if (!str || !text || !len) return 0;
|
|
|
+ for (i = 0; i < len; ++i)
|
|
|
+ byte_len += nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ nk_str_insert_at_rune(str, pos, text, byte_len);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_str_utf8(struct nk_str *str, int pos, const char *text)
|
|
|
+{
|
|
|
+ int runes = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ int num_runes = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+ if (!str || !text) return 0;
|
|
|
+
|
|
|
+ glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ while (unicode != '\0' && glyph_len) {
|
|
|
+ glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
|
|
|
+ byte_len += glyph_len;
|
|
|
+ num_runes++;
|
|
|
+ }
|
|
|
+ nk_str_insert_at_rune(str, pos, text, byte_len);
|
|
|
+ return runes;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_text_runes(struct nk_str *str, int pos, const nk_rune *runes, int len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int byte_len = 0;
|
|
|
+ nk_glyph glyph;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str || !runes || !len) return 0;
|
|
|
+ for (i = 0; i < len; ++i) {
|
|
|
+ byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
|
|
|
+ if (!byte_len) break;
|
|
|
+ nk_str_insert_at_rune(str, pos+i, glyph, byte_len);
|
|
|
+ }
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_insert_str_runes(struct nk_str *str, int pos, const nk_rune *runes)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ nk_glyph glyph;
|
|
|
+ int byte_len;
|
|
|
+ NK_ASSERT(str);
|
|
|
+ if (!str || !runes) return 0;
|
|
|
+ while (runes[i] != '\0') {
|
|
|
+ byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
|
|
|
+ nk_str_insert_at_rune(str, pos+i, glyph, byte_len);
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_remove_chars(struct nk_str *s, int len)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ NK_ASSERT(len >= 0);
|
|
|
+ if (!s || len < 0 || (nk_size)len > s->buffer.allocated) return;
|
|
|
+ NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
|
|
|
+ s->buffer.allocated -= (nk_size)len;
|
|
|
+ s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_remove_runes(struct nk_str *str, int len)
|
|
|
+{
|
|
|
+ int index;
|
|
|
+ const char *begin;
|
|
|
+ const char *end;
|
|
|
+ nk_rune unicode;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(len >= 0);
|
|
|
+ if (!str || len < 0) return;
|
|
|
+ if (len >= str->len) {
|
|
|
+ str->len = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ index = str->len - len;
|
|
|
+ begin = nk_str_at_rune(str, index, &unicode, &len);
|
|
|
+ end = (const char*)str->buffer.memory.ptr + str->buffer.allocated;
|
|
|
+ nk_str_remove_chars(str, (int)(end-begin)+1);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_delete_chars(struct nk_str *s, int pos, int len)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !len || (nk_size)pos > s->buffer.allocated ||
|
|
|
+ (nk_size)(pos + len) > s->buffer.allocated) return;
|
|
|
+
|
|
|
+ if ((nk_size)(pos + len) < s->buffer.allocated) {
|
|
|
+ /* memmove */
|
|
|
+ char *dst = nk_ptr_add(char, s->buffer.memory.ptr, pos);
|
|
|
+ char *src = nk_ptr_add(char, s->buffer.memory.ptr, pos + len);
|
|
|
+ NK_MEMCPY(dst, src, s->buffer.allocated - (nk_size)(pos + len));
|
|
|
+ NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
|
|
|
+ s->buffer.allocated -= (nk_size)len;
|
|
|
+ } else nk_str_remove_chars(s, len);
|
|
|
+ s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_delete_runes(struct nk_str *s, int pos, int len)
|
|
|
+{
|
|
|
+ char *temp;
|
|
|
+ nk_rune unicode;
|
|
|
+ char *begin;
|
|
|
+ char *end;
|
|
|
+ int unused;
|
|
|
+
|
|
|
+ NK_ASSERT(s);
|
|
|
+ NK_ASSERT(s->len >= pos + len);
|
|
|
+ if (s->len < pos + len)
|
|
|
+ len = NK_CLAMP(0, (s->len - pos), s->len);
|
|
|
+ if (!len) return;
|
|
|
+
|
|
|
+ temp = (char *)s->buffer.memory.ptr;
|
|
|
+ begin = nk_str_at_rune(s, pos, &unicode, &unused);
|
|
|
+ if (!begin) return;
|
|
|
+ s->buffer.memory.ptr = begin;
|
|
|
+ end = nk_str_at_rune(s, len, &unicode, &unused);
|
|
|
+ s->buffer.memory.ptr = temp;
|
|
|
+ if (!end) return;
|
|
|
+ nk_str_delete_chars(s, (int)(begin - temp), (int)(end - begin));
|
|
|
+}
|
|
|
+
|
|
|
+NK_API char*
|
|
|
+nk_str_at_char(struct nk_str *s, int pos)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || pos > (int)s->buffer.allocated) return 0;
|
|
|
+ return nk_ptr_add(char, s->buffer.memory.ptr, pos);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API char*
|
|
|
+nk_str_at_rune(struct nk_str *str, int pos, nk_rune *unicode, int *len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int src_len = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ char *text;
|
|
|
+ int text_len;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(unicode);
|
|
|
+ NK_ASSERT(len);
|
|
|
+
|
|
|
+ if (!str || !unicode || !len) return 0;
|
|
|
+ if (pos < 0) {
|
|
|
+ *unicode = 0;
|
|
|
+ *len = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ text = (char*)str->buffer.memory.ptr;
|
|
|
+ text_len = (int)str->buffer.allocated;
|
|
|
+ glyph_len = nk_utf_decode(text, unicode, text_len);
|
|
|
+ while (glyph_len) {
|
|
|
+ if (i == pos) {
|
|
|
+ *len = glyph_len;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ src_len = src_len + glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len);
|
|
|
+ }
|
|
|
+ if (i != pos) return 0;
|
|
|
+ return text + src_len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const char*
|
|
|
+nk_str_at_char_const(const struct nk_str *s, int pos)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || pos > (int)s->buffer.allocated) return 0;
|
|
|
+ return nk_ptr_add(char, s->buffer.memory.ptr, pos);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const char*
|
|
|
+nk_str_at_const(const struct nk_str *str, int pos, nk_rune *unicode, int *len)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int src_len = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ char *text;
|
|
|
+ int text_len;
|
|
|
+
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(unicode);
|
|
|
+ NK_ASSERT(len);
|
|
|
+
|
|
|
+ if (!str || !unicode || !len) return 0;
|
|
|
+ if (pos < 0) {
|
|
|
+ *unicode = 0;
|
|
|
+ *len = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ text = (char*)str->buffer.memory.ptr;
|
|
|
+ text_len = (int)str->buffer.allocated;
|
|
|
+ glyph_len = nk_utf_decode(text, unicode, text_len);
|
|
|
+ while (glyph_len) {
|
|
|
+ if (i == pos) {
|
|
|
+ *len = glyph_len;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ src_len = src_len + glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len);
|
|
|
+ }
|
|
|
+ if (i != pos) return 0;
|
|
|
+ return text + src_len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_rune
|
|
|
+nk_str_rune_at(const struct nk_str *str, int pos)
|
|
|
+{
|
|
|
+ int len;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ nk_str_at_const(str, pos, &unicode, &len);
|
|
|
+ return unicode;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API char*
|
|
|
+nk_str_get(struct nk_str *s)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !s->len || !s->buffer.allocated) return 0;
|
|
|
+ return (char*)s->buffer.memory.ptr;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const char*
|
|
|
+nk_str_get_const(const struct nk_str *s)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !s->len || !s->buffer.allocated) return 0;
|
|
|
+ return (const char*)s->buffer.memory.ptr;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_len(struct nk_str *s)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !s->len || !s->buffer.allocated) return 0;
|
|
|
+ return s->len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_str_len_char(struct nk_str *s)
|
|
|
+{
|
|
|
+ NK_ASSERT(s);
|
|
|
+ if (!s || !s->len || !s->buffer.allocated) return 0;
|
|
|
+ return (int)s->buffer.allocated;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_clear(struct nk_str *str)
|
|
|
+{
|
|
|
+ NK_ASSERT(str);
|
|
|
+ nk_buffer_clear(&str->buffer);
|
|
|
+ str->len = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_str_free(struct nk_str *str)
|
|
|
+{
|
|
|
+ NK_ASSERT(str);
|
|
|
+ nk_buffer_free(&str->buffer);
|
|
|
+ str->len = 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * Command buffer
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+*/
|
|
|
+NK_INTERN void
|
|
|
+nk_command_buffer_init(struct nk_command_buffer *cmdbuf,
|
|
|
+ struct nk_buffer *buffer, enum nk_command_clipping clip)
|
|
|
+{
|
|
|
+ NK_ASSERT(cmdbuf);
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!cmdbuf || !buffer) return;
|
|
|
+ cmdbuf->base = buffer;
|
|
|
+ cmdbuf->use_clipping = clip;
|
|
|
+ cmdbuf->begin = buffer->allocated;
|
|
|
+ cmdbuf->end = buffer->allocated;
|
|
|
+ cmdbuf->last = buffer->allocated;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_command_buffer_reset(struct nk_command_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer) return;
|
|
|
+ buffer->begin = 0;
|
|
|
+ buffer->end = 0;
|
|
|
+ buffer->last = 0;
|
|
|
+ buffer->clip = nk_null_rect;
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ buffer->userdata.ptr = 0;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_command_buffer_push(struct nk_command_buffer* b,
|
|
|
+ enum nk_command_type t, nk_size size)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_command);
|
|
|
+ struct nk_command *cmd;
|
|
|
+ nk_size alignment;
|
|
|
+ void *unaligned;
|
|
|
+ void *memory;
|
|
|
+
|
|
|
+ NK_ASSERT(b);
|
|
|
+ NK_ASSERT(b->base);
|
|
|
+ if (!b) return 0;
|
|
|
+ cmd = (struct nk_command*)nk_buffer_alloc(b->base,NK_BUFFER_FRONT,size,align);
|
|
|
+ if (!cmd) return 0;
|
|
|
+
|
|
|
+ /* make sure the offset to the next command is aligned */
|
|
|
+ b->last = (nk_size)((nk_byte*)cmd - (nk_byte*)b->base->memory.ptr);
|
|
|
+ unaligned = (nk_byte*)cmd + size;
|
|
|
+ memory = NK_ALIGN_PTR(unaligned, align);
|
|
|
+ alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned);
|
|
|
+#ifdef NK_ZERO_COMMAND_MEMORY
|
|
|
+ NK_MEMSET(cmd, 0, size + alignment);
|
|
|
+#endif
|
|
|
+
|
|
|
+ cmd->type = t;
|
|
|
+ cmd->next = b->base->allocated + alignment;
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ cmd->userdata = b->userdata;
|
|
|
+#endif
|
|
|
+ b->end = cmd->next;
|
|
|
+ return cmd;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_push_scissor(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 = (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);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_line(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 = (unsigned short)line_thickness;
|
|
|
+ cmd->begin.x = (short)x0;
|
|
|
+ cmd->begin.y = (short)y0;
|
|
|
+ cmd->end.x = (short)x1;
|
|
|
+ cmd->end.y = (short)y1;
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_curve(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 = (unsigned short)line_thickness;
|
|
|
+ cmd->begin.x = (short)ax;
|
|
|
+ cmd->begin.y = (short)ay;
|
|
|
+ cmd->ctrl[0].x = (short)ctrl0x;
|
|
|
+ cmd->ctrl[0].y = (short)ctrl0y;
|
|
|
+ cmd->ctrl[1].x = (short)ctrl1x;
|
|
|
+ cmd->ctrl[1].y = (short)ctrl1y;
|
|
|
+ cmd->end.x = (short)bx;
|
|
|
+ cmd->end.y = (short)by;
|
|
|
+ cmd->color = col;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_rect(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 = (unsigned short)rounding;
|
|
|
+ cmd->line_thickness = (unsigned short)line_thickness;
|
|
|
+ cmd->x = (short)rect.x;
|
|
|
+ cmd->y = (short)rect.y;
|
|
|
+ cmd->w = (unsigned short)NK_MAX(0, rect.w);
|
|
|
+ cmd->h = (unsigned short)NK_MAX(0, rect.h);
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_rect(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 = (unsigned short)rounding;
|
|
|
+ cmd->x = (short)rect.x;
|
|
|
+ cmd->y = (short)rect.y;
|
|
|
+ cmd->w = (unsigned short)NK_MAX(0, rect.w);
|
|
|
+ cmd->h = (unsigned short)NK_MAX(0, rect.h);
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_rect_multi_color(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 = (short)rect.x;
|
|
|
+ cmd->y = (short)rect.y;
|
|
|
+ cmd->w = (unsigned short)NK_MAX(0, rect.w);
|
|
|
+ cmd->h = (unsigned short)NK_MAX(0, rect.h);
|
|
|
+ cmd->left = left;
|
|
|
+ cmd->top = top;
|
|
|
+ cmd->right = right;
|
|
|
+ cmd->bottom = bottom;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_circle(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 = (unsigned short)line_thickness;
|
|
|
+ cmd->x = (short)r.x;
|
|
|
+ cmd->y = (short)r.y;
|
|
|
+ cmd->w = (unsigned short)NK_MAX(r.w, 0);
|
|
|
+ cmd->h = (unsigned short)NK_MAX(r.h, 0);
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_circle(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 = (short)r.x;
|
|
|
+ cmd->y = (short)r.y;
|
|
|
+ cmd->w = (unsigned short)NK_MAX(r.w, 0);
|
|
|
+ cmd->h = (unsigned short)NK_MAX(r.h, 0);
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_arc(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 = (unsigned short)line_thickness;
|
|
|
+ cmd->cx = (short)cx;
|
|
|
+ cmd->cy = (short)cy;
|
|
|
+ cmd->r = (unsigned short)radius;
|
|
|
+ cmd->a[0] = a_min;
|
|
|
+ cmd->a[1] = a_max;
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_arc(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 = (short)cx;
|
|
|
+ cmd->cy = (short)cy;
|
|
|
+ cmd->r = (unsigned short)radius;
|
|
|
+ cmd->a[0] = a_min;
|
|
|
+ cmd->a[1] = a_max;
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_triangle(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 = (unsigned short)line_thickness;
|
|
|
+ cmd->a.x = (short)x0;
|
|
|
+ cmd->a.y = (short)y0;
|
|
|
+ cmd->b.x = (short)x1;
|
|
|
+ cmd->b.y = (short)y1;
|
|
|
+ cmd->c.x = (short)x2;
|
|
|
+ cmd->c.y = (short)y2;
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_triangle(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 = (short)x0;
|
|
|
+ cmd->a.y = (short)y0;
|
|
|
+ cmd->b.x = (short)x1;
|
|
|
+ cmd->b.y = (short)y1;
|
|
|
+ cmd->c.x = (short)x2;
|
|
|
+ cmd->c.y = (short)y2;
|
|
|
+ cmd->color = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_polygon(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(short) * 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 = (unsigned short)line_thickness;
|
|
|
+ cmd->point_count = (unsigned short)point_count;
|
|
|
+ for (i = 0; i < point_count; ++i) {
|
|
|
+ cmd->points[i].x = (short)points[i*2];
|
|
|
+ cmd->points[i].y = (short)points[i*2+1];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_fill_polygon(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(short) * 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 = (short)points[i*2+0];
|
|
|
+ cmd->points[i].y = (short)points[i*2+1];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_stroke_polyline(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(short) * 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 = (unsigned short)line_thickness;
|
|
|
+ for (i = 0; i < point_count; ++i) {
|
|
|
+ cmd->points[i].x = (short)points[i*2];
|
|
|
+ cmd->points[i].y = (short)points[i*2+1];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_image(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 = (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->img = *img;
|
|
|
+ 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)
|
|
|
+{
|
|
|
+ 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';
|
|
|
+}
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * DRAW LIST
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+NK_API void
|
|
|
+nk_draw_list_init(struct nk_draw_list *list)
|
|
|
+{
|
|
|
+ nk_size i = 0;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ nk_zero(list, sizeof(*list));
|
|
|
+ for (i = 0; i < NK_LEN(list->circle_vtx); ++i) {
|
|
|
+ const float a = ((float)i / (float)NK_LEN(list->circle_vtx)) * 2 * NK_PI;
|
|
|
+ list->circle_vtx[i].x = (float)NK_COS(a);
|
|
|
+ list->circle_vtx[i].y = (float)NK_SIN(a);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_setup(struct nk_draw_list *canvas, const struct nk_convert_config *config,
|
|
|
+ struct nk_buffer *cmds, struct nk_buffer *vertices, struct nk_buffer *elements,
|
|
|
+ enum nk_anti_aliasing line_aa, enum nk_anti_aliasing shape_aa)
|
|
|
+{
|
|
|
+ NK_ASSERT(canvas);
|
|
|
+ NK_ASSERT(config);
|
|
|
+ NK_ASSERT(cmds);
|
|
|
+ NK_ASSERT(vertices);
|
|
|
+ NK_ASSERT(elements);
|
|
|
+ if (!canvas || !config || !cmds || !vertices || !elements)
|
|
|
+ return;
|
|
|
+
|
|
|
+ canvas->buffer = cmds;
|
|
|
+ canvas->config = *config;
|
|
|
+ canvas->elements = elements;
|
|
|
+ canvas->vertices = vertices;
|
|
|
+ canvas->line_AA = line_aa;
|
|
|
+ canvas->shape_AA = shape_aa;
|
|
|
+ canvas->clip_rect = nk_null_rect;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_list_begin(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ nk_byte *memory;
|
|
|
+ nk_size offset;
|
|
|
+ const struct nk_draw_command *cmd;
|
|
|
+
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!buffer || !buffer->size || !canvas->cmd_count)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ memory = (nk_byte*)buffer->memory.ptr;
|
|
|
+ offset = buffer->memory.size - canvas->cmd_offset;
|
|
|
+ cmd = nk_ptr_add(const struct nk_draw_command, memory, offset);
|
|
|
+ return cmd;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_list_end(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
|
|
|
+{
|
|
|
+ nk_size size;
|
|
|
+ nk_size offset;
|
|
|
+ nk_byte *memory;
|
|
|
+ const struct nk_draw_command *end;
|
|
|
+
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ NK_ASSERT(canvas);
|
|
|
+ if (!buffer || !canvas)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ memory = (nk_byte*)buffer->memory.ptr;
|
|
|
+ size = buffer->memory.size;
|
|
|
+ offset = size - canvas->cmd_offset;
|
|
|
+ end = nk_ptr_add(const struct nk_draw_command, memory, offset);
|
|
|
+ end -= (canvas->cmd_count-1);
|
|
|
+ return end;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_list_next(const struct nk_draw_command *cmd,
|
|
|
+ const struct nk_buffer *buffer, const struct nk_draw_list *canvas)
|
|
|
+{
|
|
|
+ const struct nk_draw_command *end;
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ NK_ASSERT(canvas);
|
|
|
+ if (!cmd || !buffer || !canvas)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ end = nk__draw_list_end(canvas, buffer);
|
|
|
+ if (cmd <= end) return 0;
|
|
|
+ return (cmd-1);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_clear(struct nk_draw_list *list)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (list->buffer)
|
|
|
+ nk_buffer_clear(list->buffer);
|
|
|
+ if (list->vertices)
|
|
|
+ nk_buffer_clear(list->vertices);
|
|
|
+ if (list->elements)
|
|
|
+ nk_buffer_clear(list->elements);
|
|
|
+
|
|
|
+ list->element_count = 0;
|
|
|
+ list->vertex_count = 0;
|
|
|
+ list->cmd_offset = 0;
|
|
|
+ list->cmd_count = 0;
|
|
|
+ list->path_count = 0;
|
|
|
+ list->vertices = 0;
|
|
|
+ list->elements = 0;
|
|
|
+ list->clip_rect = nk_null_rect;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_vec2*
|
|
|
+nk_draw_list_alloc_path(struct nk_draw_list *list, int count)
|
|
|
+{
|
|
|
+ struct nk_vec2 *points;
|
|
|
+ NK_STORAGE const nk_size point_align = NK_ALIGNOF(struct nk_vec2);
|
|
|
+ NK_STORAGE const nk_size point_size = sizeof(struct nk_vec2);
|
|
|
+ points = (struct nk_vec2*)
|
|
|
+ nk_buffer_alloc(list->buffer, NK_BUFFER_FRONT,
|
|
|
+ point_size * (nk_size)count, point_align);
|
|
|
+
|
|
|
+ if (!points) return 0;
|
|
|
+ if (!list->path_offset) {
|
|
|
+ void *memory = nk_buffer_memory(list->buffer);
|
|
|
+ list->path_offset = (unsigned int)((nk_byte*)points - (nk_byte*)memory);
|
|
|
+ }
|
|
|
+ list->path_count += (unsigned int)count;
|
|
|
+ return points;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_vec2
|
|
|
+nk_draw_list_path_last(struct nk_draw_list *list)
|
|
|
+{
|
|
|
+ void *memory;
|
|
|
+ struct nk_vec2 *point;
|
|
|
+ NK_ASSERT(list->path_count);
|
|
|
+ memory = nk_buffer_memory(list->buffer);
|
|
|
+ point = nk_ptr_add(struct nk_vec2, memory, list->path_offset);
|
|
|
+ point += (list->path_count-1);
|
|
|
+ return *point;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_draw_command*
|
|
|
+nk_draw_list_push_command(struct nk_draw_list *list, struct nk_rect clip,
|
|
|
+ nk_handle texture)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_size cmd_align = NK_ALIGNOF(struct nk_draw_command);
|
|
|
+ NK_STORAGE const nk_size cmd_size = sizeof(struct nk_draw_command);
|
|
|
+ struct nk_draw_command *cmd;
|
|
|
+
|
|
|
+ NK_ASSERT(list);
|
|
|
+ cmd = (struct nk_draw_command*)
|
|
|
+ nk_buffer_alloc(list->buffer, NK_BUFFER_BACK, cmd_size, cmd_align);
|
|
|
+
|
|
|
+ if (!cmd) return 0;
|
|
|
+ if (!list->cmd_count) {
|
|
|
+ nk_byte *memory = (nk_byte*)nk_buffer_memory(list->buffer);
|
|
|
+ nk_size total = nk_buffer_total(list->buffer);
|
|
|
+ memory = nk_ptr_add(nk_byte, memory, total);
|
|
|
+ list->cmd_offset = (nk_size)(memory - (nk_byte*)cmd);
|
|
|
+ }
|
|
|
+
|
|
|
+ cmd->elem_count = 0;
|
|
|
+ cmd->clip_rect = clip;
|
|
|
+ cmd->texture = texture;
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ cmd->userdata = list->userdata;
|
|
|
+#endif
|
|
|
+
|
|
|
+ list->cmd_count++;
|
|
|
+ list->clip_rect = clip;
|
|
|
+ return cmd;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_draw_command*
|
|
|
+nk_draw_list_command_last(struct nk_draw_list *list)
|
|
|
+{
|
|
|
+ void *memory;
|
|
|
+ nk_size size;
|
|
|
+ struct nk_draw_command *cmd;
|
|
|
+ NK_ASSERT(list->cmd_count);
|
|
|
+
|
|
|
+ memory = nk_buffer_memory(list->buffer);
|
|
|
+ size = nk_buffer_total(list->buffer);
|
|
|
+ cmd = nk_ptr_add(struct nk_draw_command, memory, size - list->cmd_offset);
|
|
|
+ return (cmd - (list->cmd_count-1));
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_list_add_clip(struct nk_draw_list *list, struct nk_rect rect)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (!list->cmd_count) {
|
|
|
+ nk_draw_list_push_command(list, rect, list->config.null.texture);
|
|
|
+ } else {
|
|
|
+ struct nk_draw_command *prev = nk_draw_list_command_last(list);
|
|
|
+ if (prev->elem_count == 0)
|
|
|
+ prev->clip_rect = rect;
|
|
|
+ nk_draw_list_push_command(list, rect, prev->texture);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_list_push_image(struct nk_draw_list *list, nk_handle texture)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (!list->cmd_count) {
|
|
|
+ nk_draw_list_push_command(list, nk_null_rect, texture);
|
|
|
+ } else {
|
|
|
+ struct nk_draw_command *prev = nk_draw_list_command_last(list);
|
|
|
+ if (prev->elem_count == 0)
|
|
|
+ prev->texture = texture;
|
|
|
+ else if (prev->texture.id != texture.id)
|
|
|
+ nk_draw_list_push_command(list, prev->clip_rect, texture);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+NK_API void
|
|
|
+nk_draw_list_push_userdata(struct nk_draw_list *list, nk_handle userdata)
|
|
|
+{
|
|
|
+ list->userdata = userdata;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count)
|
|
|
+{
|
|
|
+ void *vtx;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return 0;
|
|
|
+ vtx = nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT,
|
|
|
+ list->config.vertex_size*count, list->config.vertex_alignment);
|
|
|
+ if (!vtx) return 0;
|
|
|
+ list->vertex_count += (unsigned int)count;
|
|
|
+ return vtx;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_draw_index*
|
|
|
+nk_draw_list_alloc_elements(struct nk_draw_list *list, nk_size count)
|
|
|
+{
|
|
|
+ nk_draw_index *ids;
|
|
|
+ struct nk_draw_command *cmd;
|
|
|
+ NK_STORAGE const nk_size elem_align = NK_ALIGNOF(nk_draw_index);
|
|
|
+ NK_STORAGE const nk_size elem_size = sizeof(nk_draw_index);
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return 0;
|
|
|
+
|
|
|
+ ids = (nk_draw_index*)
|
|
|
+ nk_buffer_alloc(list->elements, NK_BUFFER_FRONT, elem_size*count, elem_align);
|
|
|
+ if (!ids) return 0;
|
|
|
+ cmd = nk_draw_list_command_last(list);
|
|
|
+ list->element_count += (unsigned int)count;
|
|
|
+ cmd->elem_count += (unsigned int)count;
|
|
|
+ return ids;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_draw_vertex_layout_element_is_end_of_layout(
|
|
|
+ const struct nk_draw_vertex_layout_element *element)
|
|
|
+{
|
|
|
+ return (element->attribute == NK_VERTEX_ATTRIBUTE_COUNT ||
|
|
|
+ element->format == NK_FORMAT_COUNT);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_vertex_color(void *attribute, const float *values,
|
|
|
+ enum nk_draw_vertex_layout_format format)
|
|
|
+{
|
|
|
+ /* if this triggers you tried to provide a value format for a color */
|
|
|
+ NK_ASSERT(format >= NK_FORMAT_COLOR_BEGIN);
|
|
|
+ NK_ASSERT(format <= NK_FORMAT_COLOR_END);
|
|
|
+ if (format < NK_FORMAT_COLOR_BEGIN || format > NK_FORMAT_COLOR_END) return;
|
|
|
+
|
|
|
+ switch (format) {
|
|
|
+ default: NK_ASSERT(0 && "Invalid vertex layout color format"); break;
|
|
|
+ case NK_FORMAT_R8G8B8A8:
|
|
|
+ case NK_FORMAT_R8G8B8: {
|
|
|
+ struct nk_color col = nk_rgba_fv(values);
|
|
|
+ NK_MEMCPY(attribute, &col.r, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_B8G8R8A8: {
|
|
|
+ struct nk_color col = nk_rgba_fv(values);
|
|
|
+ struct nk_color bgra = nk_rgba(col.b, col.g, col.r, col.a);
|
|
|
+ NK_MEMCPY(attribute, &bgra, sizeof(bgra));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_R16G15B16: {
|
|
|
+ nk_ushort col[3];
|
|
|
+ col[0] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[0] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ col[1] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[1] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ col[2] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[2] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ NK_MEMCPY(attribute, col, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_R16G15B16A16: {
|
|
|
+ nk_ushort col[4];
|
|
|
+ col[0] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[0] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ col[1] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[1] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ col[2] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[2] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ col[3] = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[3] * NK_USHORT_MAX, NK_USHORT_MAX);
|
|
|
+ NK_MEMCPY(attribute, col, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_R32G32B32: {
|
|
|
+ nk_uint col[3];
|
|
|
+ col[0] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[0] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ col[1] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[1] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ col[2] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[2] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ NK_MEMCPY(attribute, col, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_R32G32B32A32: {
|
|
|
+ nk_uint col[4];
|
|
|
+ col[0] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[0] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ col[1] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[1] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ col[2] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[2] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ col[3] = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[3] * NK_UINT_MAX, NK_UINT_MAX);
|
|
|
+ NK_MEMCPY(attribute, col, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_R32G32B32A32_FLOAT:
|
|
|
+ NK_MEMCPY(attribute, values, sizeof(float)*4);
|
|
|
+ break;
|
|
|
+ case NK_FORMAT_R32G32B32A32_DOUBLE: {
|
|
|
+ double col[4];
|
|
|
+ col[0] = (double)NK_SATURATE(values[0]);
|
|
|
+ col[1] = (double)NK_SATURATE(values[1]);
|
|
|
+ col[2] = (double)NK_SATURATE(values[2]);
|
|
|
+ col[3] = (double)NK_SATURATE(values[3]);
|
|
|
+ NK_MEMCPY(attribute, col, sizeof(col));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_RGB32:
|
|
|
+ case NK_FORMAT_RGBA32: {
|
|
|
+ struct nk_color col = nk_rgba_fv(values);
|
|
|
+ nk_uint color = nk_color_u32(col);
|
|
|
+ NK_MEMCPY(attribute, &color, sizeof(color));
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_vertex_element(void *dst, const float *values, int value_count,
|
|
|
+ enum nk_draw_vertex_layout_format format)
|
|
|
+{
|
|
|
+ int value_index;
|
|
|
+ void *attribute = dst;
|
|
|
+ /* if this triggers you tried to provide a color format for a value */
|
|
|
+ NK_ASSERT(format < NK_FORMAT_COLOR_BEGIN);
|
|
|
+ if (format >= NK_FORMAT_COLOR_BEGIN && format <= NK_FORMAT_COLOR_END) return;
|
|
|
+ for (value_index = 0; value_index < value_count; ++value_index) {
|
|
|
+ switch (format) {
|
|
|
+ default: NK_ASSERT(0 && "invalid vertex layout format"); break;
|
|
|
+ case NK_FORMAT_SCHAR: {
|
|
|
+ char value = (char)NK_CLAMP(NK_SCHAR_MIN, values[value_index], NK_SCHAR_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(char));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_SSHORT: {
|
|
|
+ nk_short value = (nk_short)NK_CLAMP(NK_SSHORT_MIN, values[value_index], NK_SSHORT_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(value));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_SINT: {
|
|
|
+ nk_int value = (nk_int)NK_CLAMP(NK_SINT_MIN, values[value_index], NK_SINT_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(nk_int));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_UCHAR: {
|
|
|
+ unsigned char value = (unsigned char)NK_CLAMP(NK_UCHAR_MIN, values[value_index], NK_UCHAR_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(unsigned char));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_USHORT: {
|
|
|
+ nk_ushort value = (nk_ushort)NK_CLAMP(NK_USHORT_MIN, values[value_index], NK_USHORT_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(value));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_UINT: {
|
|
|
+ nk_uint value = (nk_uint)NK_CLAMP(NK_UINT_MIN, values[value_index], NK_UINT_MAX);
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(nk_uint));
|
|
|
+ } break;
|
|
|
+ case NK_FORMAT_FLOAT:
|
|
|
+ NK_MEMCPY(attribute, &values[value_index], sizeof(values[value_index]));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(float));
|
|
|
+ break;
|
|
|
+ case NK_FORMAT_DOUBLE: {
|
|
|
+ double value = (double)values[value_index];
|
|
|
+ NK_MEMCPY(attribute, &value, sizeof(value));
|
|
|
+ attribute = (void*)((char*)attribute + sizeof(double));
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void*
|
|
|
+nk_draw_vertex(void *dst, const struct nk_convert_config *config,
|
|
|
+ struct nk_vec2 pos, struct nk_vec2 uv, struct nk_colorf color)
|
|
|
+{
|
|
|
+ void *result = (void*)((char*)dst + config->vertex_size);
|
|
|
+ const struct nk_draw_vertex_layout_element *elem_iter = config->vertex_layout;
|
|
|
+ while (!nk_draw_vertex_layout_element_is_end_of_layout(elem_iter)) {
|
|
|
+ void *address = (void*)((char*)dst + elem_iter->offset);
|
|
|
+ switch (elem_iter->attribute) {
|
|
|
+ case NK_VERTEX_ATTRIBUTE_COUNT:
|
|
|
+ default: NK_ASSERT(0 && "wrong element attribute");
|
|
|
+ case NK_VERTEX_POSITION: nk_draw_vertex_element(address, &pos.x, 2, elem_iter->format); break;
|
|
|
+ case NK_VERTEX_TEXCOORD: nk_draw_vertex_element(address, &uv.x, 2, elem_iter->format); break;
|
|
|
+ case NK_VERTEX_COLOR: nk_draw_vertex_color(address, &color.r, elem_iter->format); break;
|
|
|
+ }
|
|
|
+ elem_iter++;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_poly_line(struct nk_draw_list *list, const struct nk_vec2 *points,
|
|
|
+ const unsigned int points_count, struct nk_color color, enum nk_draw_list_stroke closed,
|
|
|
+ float thickness, enum nk_anti_aliasing aliasing)
|
|
|
+{
|
|
|
+ nk_size count;
|
|
|
+ int thick_line;
|
|
|
+ struct nk_colorf col;
|
|
|
+ struct nk_colorf col_trans;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || points_count < 2) return;
|
|
|
+
|
|
|
+ color.a = (nk_byte)((float)color.a * list->config.global_alpha);
|
|
|
+ count = points_count;
|
|
|
+ if (!closed) count = points_count-1;
|
|
|
+ thick_line = thickness > 1.0f;
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_draw_list_push_userdata(list, list->userdata);
|
|
|
+#endif
|
|
|
+
|
|
|
+ color.a = (nk_byte)((float)color.a * list->config.global_alpha);
|
|
|
+ nk_color_fv(&col.r, color);
|
|
|
+ col_trans = col;
|
|
|
+ col_trans.a = 0;
|
|
|
+
|
|
|
+ if (aliasing == NK_ANTI_ALIASING_ON) {
|
|
|
+ /* ANTI-ALIASED STROKE */
|
|
|
+ const float AA_SIZE = 1.0f;
|
|
|
+ NK_STORAGE const nk_size pnt_align = NK_ALIGNOF(struct nk_vec2);
|
|
|
+ NK_STORAGE const nk_size pnt_size = sizeof(struct nk_vec2);
|
|
|
+
|
|
|
+ /* allocate vertices and elements */
|
|
|
+ nk_size i1 = 0;
|
|
|
+ nk_size vertex_offset;
|
|
|
+ nk_size index = list->vertex_count;
|
|
|
+
|
|
|
+ const nk_size idx_count = (thick_line) ? (count * 18) : (count * 12);
|
|
|
+ const nk_size vtx_count = (thick_line) ? (points_count * 4): (points_count *3);
|
|
|
+
|
|
|
+ void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
|
|
|
+ nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);
|
|
|
+
|
|
|
+ nk_size size;
|
|
|
+ struct nk_vec2 *normals, *temp;
|
|
|
+ if (!vtx || !ids) return;
|
|
|
+
|
|
|
+ /* temporary allocate normals + points */
|
|
|
+ vertex_offset = (nk_size)((nk_byte*)vtx - (nk_byte*)list->vertices->memory.ptr);
|
|
|
+ nk_buffer_mark(list->vertices, NK_BUFFER_FRONT);
|
|
|
+ size = pnt_size * ((thick_line) ? 5 : 3) * points_count;
|
|
|
+ normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align);
|
|
|
+ NK_ASSERT(normals);
|
|
|
+ if (!normals) return;
|
|
|
+ temp = normals + points_count;
|
|
|
+
|
|
|
+ /* make sure vertex pointer is still correct */
|
|
|
+ vtx = (void*)((nk_byte*)list->vertices->memory.ptr + vertex_offset);
|
|
|
+
|
|
|
+ /* calculate normals */
|
|
|
+ for (i1 = 0; i1 < count; ++i1) {
|
|
|
+ const nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1);
|
|
|
+ struct nk_vec2 diff = nk_vec2_sub(points[i2], points[i1]);
|
|
|
+ float len;
|
|
|
+
|
|
|
+ /* vec2 inverted length */
|
|
|
+ len = nk_vec2_len_sqr(diff);
|
|
|
+ if (len != 0.0f)
|
|
|
+ len = nk_inv_sqrt(len);
|
|
|
+ else len = 1.0f;
|
|
|
+
|
|
|
+ diff = nk_vec2_muls(diff, len);
|
|
|
+ normals[i1].x = diff.y;
|
|
|
+ normals[i1].y = -diff.x;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!closed)
|
|
|
+ normals[points_count-1] = normals[points_count-2];
|
|
|
+
|
|
|
+ if (!thick_line) {
|
|
|
+ nk_size idx1, i;
|
|
|
+ if (!closed) {
|
|
|
+ struct nk_vec2 d;
|
|
|
+ temp[0] = nk_vec2_add(points[0], nk_vec2_muls(normals[0], AA_SIZE));
|
|
|
+ temp[1] = nk_vec2_sub(points[0], nk_vec2_muls(normals[0], AA_SIZE));
|
|
|
+ d = nk_vec2_muls(normals[points_count-1], AA_SIZE);
|
|
|
+ temp[(points_count-1) * 2 + 0] = nk_vec2_add(points[points_count-1], d);
|
|
|
+ temp[(points_count-1) * 2 + 1] = nk_vec2_sub(points[points_count-1], d);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill elements */
|
|
|
+ idx1 = index;
|
|
|
+ for (i1 = 0; i1 < count; i1++) {
|
|
|
+ struct nk_vec2 dm;
|
|
|
+ float dmr2;
|
|
|
+ nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1);
|
|
|
+ nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 3);
|
|
|
+
|
|
|
+ /* average normals */
|
|
|
+ dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f);
|
|
|
+ dmr2 = dm.x * dm.x + dm.y* dm.y;
|
|
|
+ if (dmr2 > 0.000001f) {
|
|
|
+ float scale = 1.0f/dmr2;
|
|
|
+ scale = NK_MIN(100.0f, scale);
|
|
|
+ dm = nk_vec2_muls(dm, scale);
|
|
|
+ }
|
|
|
+
|
|
|
+ dm = nk_vec2_muls(dm, AA_SIZE);
|
|
|
+ temp[i2*2+0] = nk_vec2_add(points[i2], dm);
|
|
|
+ temp[i2*2+1] = nk_vec2_sub(points[i2], dm);
|
|
|
+
|
|
|
+ ids[0] = (nk_draw_index)(idx2 + 0); ids[1] = (nk_draw_index)(idx1+0);
|
|
|
+ ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2);
|
|
|
+ ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+0);
|
|
|
+ ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1);
|
|
|
+ ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0);
|
|
|
+ ids[10]= (nk_draw_index)(idx2 + 0); ids[11]= (nk_draw_index)(idx2+1);
|
|
|
+ ids += 12;
|
|
|
+ idx1 = idx2;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill vertices */
|
|
|
+ for (i = 0; i < points_count; ++i) {
|
|
|
+ const struct nk_vec2 uv = list->config.null.uv;
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, points[i], uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+0], uv, col_trans);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+1], uv, col_trans);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ nk_size idx1, i;
|
|
|
+ const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;
|
|
|
+ if (!closed) {
|
|
|
+ struct nk_vec2 d1 = nk_vec2_muls(normals[0], half_inner_thickness + AA_SIZE);
|
|
|
+ struct nk_vec2 d2 = nk_vec2_muls(normals[0], half_inner_thickness);
|
|
|
+
|
|
|
+ temp[0] = nk_vec2_add(points[0], d1);
|
|
|
+ temp[1] = nk_vec2_add(points[0], d2);
|
|
|
+ temp[2] = nk_vec2_sub(points[0], d2);
|
|
|
+ temp[3] = nk_vec2_sub(points[0], d1);
|
|
|
+
|
|
|
+ d1 = nk_vec2_muls(normals[points_count-1], half_inner_thickness + AA_SIZE);
|
|
|
+ d2 = nk_vec2_muls(normals[points_count-1], half_inner_thickness);
|
|
|
+
|
|
|
+ temp[(points_count-1)*4+0] = nk_vec2_add(points[points_count-1], d1);
|
|
|
+ temp[(points_count-1)*4+1] = nk_vec2_add(points[points_count-1], d2);
|
|
|
+ temp[(points_count-1)*4+2] = nk_vec2_sub(points[points_count-1], d2);
|
|
|
+ temp[(points_count-1)*4+3] = nk_vec2_sub(points[points_count-1], d1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* add all elements */
|
|
|
+ idx1 = index;
|
|
|
+ for (i1 = 0; i1 < count; ++i1) {
|
|
|
+ struct nk_vec2 dm_out, dm_in;
|
|
|
+ const nk_size i2 = ((i1+1) == points_count) ? 0: (i1 + 1);
|
|
|
+ nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 4);
|
|
|
+
|
|
|
+ /* average normals */
|
|
|
+ struct nk_vec2 dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f);
|
|
|
+ float dmr2 = dm.x * dm.x + dm.y* dm.y;
|
|
|
+ if (dmr2 > 0.000001f) {
|
|
|
+ float scale = 1.0f/dmr2;
|
|
|
+ scale = NK_MIN(100.0f, scale);
|
|
|
+ dm = nk_vec2_muls(dm, scale);
|
|
|
+ }
|
|
|
+
|
|
|
+ dm_out = nk_vec2_muls(dm, ((half_inner_thickness) + AA_SIZE));
|
|
|
+ dm_in = nk_vec2_muls(dm, half_inner_thickness);
|
|
|
+ temp[i2*4+0] = nk_vec2_add(points[i2], dm_out);
|
|
|
+ temp[i2*4+1] = nk_vec2_add(points[i2], dm_in);
|
|
|
+ temp[i2*4+2] = nk_vec2_sub(points[i2], dm_in);
|
|
|
+ temp[i2*4+3] = nk_vec2_sub(points[i2], dm_out);
|
|
|
+
|
|
|
+ /* add indexes */
|
|
|
+ ids[0] = (nk_draw_index)(idx2 + 1); ids[1] = (nk_draw_index)(idx1+1);
|
|
|
+ ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2);
|
|
|
+ ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+1);
|
|
|
+ ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1);
|
|
|
+ ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0);
|
|
|
+ ids[10]= (nk_draw_index)(idx2 + 0); ids[11] = (nk_draw_index)(idx2+1);
|
|
|
+ ids[12]= (nk_draw_index)(idx2 + 2); ids[13] = (nk_draw_index)(idx1+2);
|
|
|
+ ids[14]= (nk_draw_index)(idx1 + 3); ids[15] = (nk_draw_index)(idx1+3);
|
|
|
+ ids[16]= (nk_draw_index)(idx2 + 3); ids[17] = (nk_draw_index)(idx2+2);
|
|
|
+ ids += 18;
|
|
|
+ idx1 = idx2;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* add vertices */
|
|
|
+ for (i = 0; i < points_count; ++i) {
|
|
|
+ const struct nk_vec2 uv = list->config.null.uv;
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+0], uv, col_trans);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+1], uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+2], uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+3], uv, col_trans);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* free temporary normals + points */
|
|
|
+ nk_buffer_reset(list->vertices, NK_BUFFER_FRONT);
|
|
|
+ } else {
|
|
|
+ /* NON ANTI-ALIASED STROKE */
|
|
|
+ nk_size i1 = 0;
|
|
|
+ nk_size idx = list->vertex_count;
|
|
|
+ const nk_size idx_count = count * 6;
|
|
|
+ const nk_size vtx_count = count * 4;
|
|
|
+ void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
|
|
|
+ nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);
|
|
|
+ if (!vtx || !ids) return;
|
|
|
+
|
|
|
+ for (i1 = 0; i1 < count; ++i1) {
|
|
|
+ float dx, dy;
|
|
|
+ const struct nk_vec2 uv = list->config.null.uv;
|
|
|
+ const nk_size i2 = ((i1+1) == points_count) ? 0 : i1 + 1;
|
|
|
+ const struct nk_vec2 p1 = points[i1];
|
|
|
+ const struct nk_vec2 p2 = points[i2];
|
|
|
+ struct nk_vec2 diff = nk_vec2_sub(p2, p1);
|
|
|
+ float len;
|
|
|
+
|
|
|
+ /* vec2 inverted length */
|
|
|
+ len = nk_vec2_len_sqr(diff);
|
|
|
+ if (len != 0.0f)
|
|
|
+ len = nk_inv_sqrt(len);
|
|
|
+ else len = 1.0f;
|
|
|
+ diff = nk_vec2_muls(diff, len);
|
|
|
+
|
|
|
+ /* add vertices */
|
|
|
+ dx = diff.x * (thickness * 0.5f);
|
|
|
+ dy = diff.y * (thickness * 0.5f);
|
|
|
+
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x + dy, p1.y - dx), uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x + dy, p2.y - dx), uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x - dy, p2.y + dx), uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x - dy, p1.y + dx), uv, col);
|
|
|
+
|
|
|
+ ids[0] = (nk_draw_index)(idx+0); ids[1] = (nk_draw_index)(idx+1);
|
|
|
+ ids[2] = (nk_draw_index)(idx+2); ids[3] = (nk_draw_index)(idx+0);
|
|
|
+ ids[4] = (nk_draw_index)(idx+2); ids[5] = (nk_draw_index)(idx+3);
|
|
|
+
|
|
|
+ ids += 6;
|
|
|
+ idx += 4;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_fill_poly_convex(struct nk_draw_list *list,
|
|
|
+ const struct nk_vec2 *points, const unsigned int points_count,
|
|
|
+ struct nk_color color, enum nk_anti_aliasing aliasing)
|
|
|
+{
|
|
|
+ struct nk_colorf col;
|
|
|
+ struct nk_colorf col_trans;
|
|
|
+
|
|
|
+ NK_STORAGE const nk_size pnt_align = NK_ALIGNOF(struct nk_vec2);
|
|
|
+ NK_STORAGE const nk_size pnt_size = sizeof(struct nk_vec2);
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || points_count < 3) return;
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ nk_draw_list_push_userdata(list, list->userdata);
|
|
|
+#endif
|
|
|
+
|
|
|
+ color.a = (nk_byte)((float)color.a * list->config.global_alpha);
|
|
|
+ nk_color_fv(&col.r, color);
|
|
|
+ col_trans = col;
|
|
|
+ col_trans.a = 0;
|
|
|
+
|
|
|
+ if (aliasing == NK_ANTI_ALIASING_ON) {
|
|
|
+ nk_size i = 0;
|
|
|
+ nk_size i0 = 0;
|
|
|
+ nk_size i1 = 0;
|
|
|
+
|
|
|
+ const float AA_SIZE = 1.0f;
|
|
|
+ nk_size vertex_offset = 0;
|
|
|
+ nk_size index = list->vertex_count;
|
|
|
+
|
|
|
+ const nk_size idx_count = (points_count-2)*3 + points_count*6;
|
|
|
+ const nk_size vtx_count = (points_count*2);
|
|
|
+
|
|
|
+ void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
|
|
|
+ nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);
|
|
|
+
|
|
|
+ nk_size size = 0;
|
|
|
+ struct nk_vec2 *normals = 0;
|
|
|
+ unsigned int vtx_inner_idx = (unsigned int)(index + 0);
|
|
|
+ unsigned int vtx_outer_idx = (unsigned int)(index + 1);
|
|
|
+ if (!vtx || !ids) return;
|
|
|
+
|
|
|
+ /* temporary allocate normals */
|
|
|
+ vertex_offset = (nk_size)((nk_byte*)vtx - (nk_byte*)list->vertices->memory.ptr);
|
|
|
+ nk_buffer_mark(list->vertices, NK_BUFFER_FRONT);
|
|
|
+ size = pnt_size * points_count;
|
|
|
+ normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align);
|
|
|
+ NK_ASSERT(normals);
|
|
|
+ if (!normals) return;
|
|
|
+ vtx = (void*)((nk_byte*)list->vertices->memory.ptr + vertex_offset);
|
|
|
+
|
|
|
+ /* add elements */
|
|
|
+ for (i = 2; i < points_count; i++) {
|
|
|
+ ids[0] = (nk_draw_index)(vtx_inner_idx);
|
|
|
+ ids[1] = (nk_draw_index)(vtx_inner_idx + ((i-1) << 1));
|
|
|
+ ids[2] = (nk_draw_index)(vtx_inner_idx + (i << 1));
|
|
|
+ ids += 3;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* compute normals */
|
|
|
+ for (i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) {
|
|
|
+ struct nk_vec2 p0 = points[i0];
|
|
|
+ struct nk_vec2 p1 = points[i1];
|
|
|
+ struct nk_vec2 diff = nk_vec2_sub(p1, p0);
|
|
|
+
|
|
|
+ /* vec2 inverted length */
|
|
|
+ float len = nk_vec2_len_sqr(diff);
|
|
|
+ if (len != 0.0f)
|
|
|
+ len = nk_inv_sqrt(len);
|
|
|
+ else len = 1.0f;
|
|
|
+ diff = nk_vec2_muls(diff, len);
|
|
|
+
|
|
|
+ normals[i0].x = diff.y;
|
|
|
+ normals[i0].y = -diff.x;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* add vertices + indexes */
|
|
|
+ for (i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) {
|
|
|
+ const struct nk_vec2 uv = list->config.null.uv;
|
|
|
+ struct nk_vec2 n0 = normals[i0];
|
|
|
+ struct nk_vec2 n1 = normals[i1];
|
|
|
+ struct nk_vec2 dm = nk_vec2_muls(nk_vec2_add(n0, n1), 0.5f);
|
|
|
+ float dmr2 = dm.x*dm.x + dm.y*dm.y;
|
|
|
+ if (dmr2 > 0.000001f) {
|
|
|
+ float scale = 1.0f / dmr2;
|
|
|
+ scale = NK_MIN(scale, 100.0f);
|
|
|
+ dm = nk_vec2_muls(dm, scale);
|
|
|
+ }
|
|
|
+ dm = nk_vec2_muls(dm, AA_SIZE * 0.5f);
|
|
|
+
|
|
|
+ /* add vertices */
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2_sub(points[i1], dm), uv, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2_add(points[i1], dm), uv, col_trans);
|
|
|
+
|
|
|
+ /* add indexes */
|
|
|
+ ids[0] = (nk_draw_index)(vtx_inner_idx+(i1<<1));
|
|
|
+ ids[1] = (nk_draw_index)(vtx_inner_idx+(i0<<1));
|
|
|
+ ids[2] = (nk_draw_index)(vtx_outer_idx+(i0<<1));
|
|
|
+ ids[3] = (nk_draw_index)(vtx_outer_idx+(i0<<1));
|
|
|
+ ids[4] = (nk_draw_index)(vtx_outer_idx+(i1<<1));
|
|
|
+ ids[5] = (nk_draw_index)(vtx_inner_idx+(i1<<1));
|
|
|
+ ids += 6;
|
|
|
+ }
|
|
|
+ /* free temporary normals + points */
|
|
|
+ nk_buffer_reset(list->vertices, NK_BUFFER_FRONT);
|
|
|
+ } else {
|
|
|
+ nk_size i = 0;
|
|
|
+ nk_size index = list->vertex_count;
|
|
|
+ const nk_size idx_count = (points_count-2)*3;
|
|
|
+ const nk_size vtx_count = points_count;
|
|
|
+ void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
|
|
|
+ nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);
|
|
|
+
|
|
|
+ if (!vtx || !ids) return;
|
|
|
+ for (i = 0; i < vtx_count; ++i)
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, points[i], list->config.null.uv, col);
|
|
|
+ for (i = 2; i < points_count; ++i) {
|
|
|
+ ids[0] = (nk_draw_index)index;
|
|
|
+ ids[1] = (nk_draw_index)(index+ i - 1);
|
|
|
+ ids[2] = (nk_draw_index)(index+i);
|
|
|
+ ids += 3;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_clear(struct nk_draw_list *list)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ nk_buffer_reset(list->buffer, NK_BUFFER_FRONT);
|
|
|
+ list->path_count = 0;
|
|
|
+ list->path_offset = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_line_to(struct nk_draw_list *list, struct nk_vec2 pos)
|
|
|
+{
|
|
|
+ struct nk_vec2 *points = 0;
|
|
|
+ struct nk_draw_command *cmd = 0;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (!list->cmd_count)
|
|
|
+ nk_draw_list_add_clip(list, nk_null_rect);
|
|
|
+
|
|
|
+ cmd = nk_draw_list_command_last(list);
|
|
|
+ if (cmd && cmd->texture.ptr != list->config.null.texture.ptr)
|
|
|
+ nk_draw_list_push_image(list, list->config.null.texture);
|
|
|
+
|
|
|
+ points = nk_draw_list_alloc_path(list, 1);
|
|
|
+ if (!points) return;
|
|
|
+ points[0] = pos;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_arc_to_fast(struct nk_draw_list *list, struct nk_vec2 center,
|
|
|
+ float radius, int a_min, int a_max)
|
|
|
+{
|
|
|
+ int a = 0;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (a_min <= a_max) {
|
|
|
+ for (a = a_min; a <= a_max; a++) {
|
|
|
+ const struct nk_vec2 c = list->circle_vtx[(nk_size)a % NK_LEN(list->circle_vtx)];
|
|
|
+ const float x = center.x + c.x * radius;
|
|
|
+ const float y = center.y + c.y * radius;
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2(x, y));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_arc_to(struct nk_draw_list *list, struct nk_vec2 center,
|
|
|
+ float radius, float a_min, float a_max, unsigned int segments)
|
|
|
+{
|
|
|
+ unsigned int i = 0;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ if (radius == 0.0f) return;
|
|
|
+ for (i = 0; i <= segments; ++i) {
|
|
|
+ const float a = a_min + ((float)i / ((float)segments) * (a_max - a_min));
|
|
|
+ const float x = center.x + (float)NK_COS(a) * radius;
|
|
|
+ const float y = center.y + (float)NK_SIN(a) * radius;
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2(x, y));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_rect_to(struct nk_draw_list *list, struct nk_vec2 a,
|
|
|
+ struct nk_vec2 b, float rounding)
|
|
|
+{
|
|
|
+ float r;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ r = rounding;
|
|
|
+ r = NK_MIN(r, ((b.x-a.x) < 0) ? -(b.x-a.x): (b.x-a.x));
|
|
|
+ r = NK_MIN(r, ((b.y-a.y) < 0) ? -(b.y-a.y): (b.y-a.y));
|
|
|
+
|
|
|
+ if (r == 0.0f) {
|
|
|
+ nk_draw_list_path_line_to(list, a);
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2(b.x,a.y));
|
|
|
+ nk_draw_list_path_line_to(list, b);
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2(a.x,b.y));
|
|
|
+ } else {
|
|
|
+ nk_draw_list_path_arc_to_fast(list, nk_vec2(a.x + r, a.y + r), r, 6, 9);
|
|
|
+ nk_draw_list_path_arc_to_fast(list, nk_vec2(b.x - r, a.y + r), r, 9, 12);
|
|
|
+ nk_draw_list_path_arc_to_fast(list, nk_vec2(b.x - r, b.y - r), r, 0, 3);
|
|
|
+ nk_draw_list_path_arc_to_fast(list, nk_vec2(a.x + r, b.y - r), r, 3, 6);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_curve_to(struct nk_draw_list *list, struct nk_vec2 p2,
|
|
|
+ struct nk_vec2 p3, struct nk_vec2 p4, unsigned int num_segments)
|
|
|
+{
|
|
|
+ float t_step;
|
|
|
+ unsigned int i_step;
|
|
|
+ struct nk_vec2 p1;
|
|
|
+
|
|
|
+ NK_ASSERT(list);
|
|
|
+ NK_ASSERT(list->path_count);
|
|
|
+ if (!list || !list->path_count) return;
|
|
|
+ num_segments = NK_MAX(num_segments, 1);
|
|
|
+
|
|
|
+ p1 = nk_draw_list_path_last(list);
|
|
|
+ t_step = 1.0f/(float)num_segments;
|
|
|
+ for (i_step = 1; i_step <= num_segments; ++i_step) {
|
|
|
+ float t = t_step * (float)i_step;
|
|
|
+ float u = 1.0f - t;
|
|
|
+ float w1 = u*u*u;
|
|
|
+ float w2 = 3*u*u*t;
|
|
|
+ float w3 = 3*u*t*t;
|
|
|
+ float w4 = t * t *t;
|
|
|
+ float x = w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x;
|
|
|
+ float y = w1 * p1.y + w2 * p2.y + w3 * p3.y + w4 * p4.y;
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2(x,y));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_fill(struct nk_draw_list *list, struct nk_color color)
|
|
|
+{
|
|
|
+ struct nk_vec2 *points;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
|
|
|
+ nk_draw_list_fill_poly_convex(list, points, list->path_count, color, list->config.shape_AA);
|
|
|
+ nk_draw_list_path_clear(list);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_path_stroke(struct nk_draw_list *list, struct nk_color color,
|
|
|
+ enum nk_draw_list_stroke closed, float thickness)
|
|
|
+{
|
|
|
+ struct nk_vec2 *points;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
|
|
|
+ nk_draw_list_stroke_poly_line(list, points, list->path_count, color,
|
|
|
+ closed, thickness, list->config.line_AA);
|
|
|
+ nk_draw_list_path_clear(list);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_line(struct nk_draw_list *list, struct nk_vec2 a,
|
|
|
+ struct nk_vec2 b, struct nk_color col, float thickness)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ if (list->line_AA == NK_ANTI_ALIASING_ON) {
|
|
|
+ nk_draw_list_path_line_to(list, a);
|
|
|
+ nk_draw_list_path_line_to(list, b);
|
|
|
+ } else {
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2_sub(a,nk_vec2(0.5f,0.5f)));
|
|
|
+ nk_draw_list_path_line_to(list, nk_vec2_sub(b,nk_vec2(0.5f,0.5f)));
|
|
|
+ }
|
|
|
+ nk_draw_list_path_stroke(list, col, NK_STROKE_OPEN, thickness);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_fill_rect(struct nk_draw_list *list, struct nk_rect rect,
|
|
|
+ struct nk_color col, float rounding)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+
|
|
|
+ if (list->line_AA == NK_ANTI_ALIASING_ON) {
|
|
|
+ nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
|
|
|
+ } else {
|
|
|
+ nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
|
|
|
+ } nk_draw_list_path_fill(list, col);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_rect(struct nk_draw_list *list, struct nk_rect rect,
|
|
|
+ struct nk_color col, float rounding, float thickness)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ if (list->line_AA == NK_ANTI_ALIASING_ON) {
|
|
|
+ nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
|
|
|
+ } else {
|
|
|
+ nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
|
|
|
+ } nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_fill_rect_multi_color(struct nk_draw_list *list, struct nk_rect rect,
|
|
|
+ struct nk_color left, struct nk_color top, struct nk_color right,
|
|
|
+ struct nk_color bottom)
|
|
|
+{
|
|
|
+ void *vtx;
|
|
|
+ struct nk_colorf col_left, col_top;
|
|
|
+ struct nk_colorf col_right, col_bottom;
|
|
|
+ nk_draw_index *idx;
|
|
|
+ nk_draw_index index;
|
|
|
+
|
|
|
+ nk_color_fv(&col_left.r, left);
|
|
|
+ nk_color_fv(&col_right.r, right);
|
|
|
+ nk_color_fv(&col_top.r, top);
|
|
|
+ nk_color_fv(&col_bottom.r, bottom);
|
|
|
+
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+
|
|
|
+ nk_draw_list_push_image(list, list->config.null.texture);
|
|
|
+ index = (nk_draw_index)list->vertex_count;
|
|
|
+ vtx = nk_draw_list_alloc_vertices(list, 4);
|
|
|
+ idx = nk_draw_list_alloc_elements(list, 6);
|
|
|
+ if (!vtx || !idx) return;
|
|
|
+
|
|
|
+ idx[0] = (nk_draw_index)(index+0); idx[1] = (nk_draw_index)(index+1);
|
|
|
+ idx[2] = (nk_draw_index)(index+2); idx[3] = (nk_draw_index)(index+0);
|
|
|
+ idx[4] = (nk_draw_index)(index+2); idx[5] = (nk_draw_index)(index+3);
|
|
|
+
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x, rect.y), list->config.null.uv, col_left);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y), list->config.null.uv, col_top);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x + rect.w, rect.y + rect.h), list->config.null.uv, col_right);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(rect.x, rect.y + rect.h), list->config.null.uv, col_bottom);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_fill_triangle(struct nk_draw_list *list, struct nk_vec2 a,
|
|
|
+ struct nk_vec2 b, struct nk_vec2 c, struct nk_color col)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ nk_draw_list_path_line_to(list, a);
|
|
|
+ nk_draw_list_path_line_to(list, b);
|
|
|
+ nk_draw_list_path_line_to(list, c);
|
|
|
+ nk_draw_list_path_fill(list, col);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_triangle(struct nk_draw_list *list, struct nk_vec2 a,
|
|
|
+ struct nk_vec2 b, struct nk_vec2 c, struct nk_color col, float thickness)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ nk_draw_list_path_line_to(list, a);
|
|
|
+ nk_draw_list_path_line_to(list, b);
|
|
|
+ nk_draw_list_path_line_to(list, c);
|
|
|
+ nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_fill_circle(struct nk_draw_list *list, struct nk_vec2 center,
|
|
|
+ float radius, struct nk_color col, unsigned int segs)
|
|
|
+{
|
|
|
+ float a_max;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)segs;
|
|
|
+ nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs);
|
|
|
+ nk_draw_list_path_fill(list, col);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_circle(struct nk_draw_list *list, struct nk_vec2 center,
|
|
|
+ float radius, struct nk_color col, unsigned int segs, float thickness)
|
|
|
+{
|
|
|
+ float a_max;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)segs;
|
|
|
+ nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs);
|
|
|
+ nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_stroke_curve(struct nk_draw_list *list, struct nk_vec2 p0,
|
|
|
+ struct nk_vec2 cp0, struct nk_vec2 cp1, struct nk_vec2 p1,
|
|
|
+ struct nk_color col, unsigned int segments, float thickness)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !col.a) return;
|
|
|
+ nk_draw_list_path_line_to(list, p0);
|
|
|
+ nk_draw_list_path_curve_to(list, cp0, cp1, p1, segments);
|
|
|
+ nk_draw_list_path_stroke(list, col, NK_STROKE_OPEN, thickness);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_list_push_rect_uv(struct nk_draw_list *list, struct nk_vec2 a,
|
|
|
+ struct nk_vec2 c, struct nk_vec2 uva, struct nk_vec2 uvc,
|
|
|
+ struct nk_color color)
|
|
|
+{
|
|
|
+ void *vtx;
|
|
|
+ struct nk_vec2 uvb;
|
|
|
+ struct nk_vec2 uvd;
|
|
|
+ struct nk_vec2 b;
|
|
|
+ struct nk_vec2 d;
|
|
|
+
|
|
|
+ struct nk_colorf col;
|
|
|
+ nk_draw_index *idx;
|
|
|
+ nk_draw_index index;
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+
|
|
|
+ nk_color_fv(&col.r, color);
|
|
|
+ uvb = nk_vec2(uvc.x, uva.y);
|
|
|
+ uvd = nk_vec2(uva.x, uvc.y);
|
|
|
+ b = nk_vec2(c.x, a.y);
|
|
|
+ d = nk_vec2(a.x, c.y);
|
|
|
+
|
|
|
+ index = (nk_draw_index)list->vertex_count;
|
|
|
+ vtx = nk_draw_list_alloc_vertices(list, 4);
|
|
|
+ idx = nk_draw_list_alloc_elements(list, 6);
|
|
|
+ if (!vtx || !idx) return;
|
|
|
+
|
|
|
+ idx[0] = (nk_draw_index)(index+0); idx[1] = (nk_draw_index)(index+1);
|
|
|
+ idx[2] = (nk_draw_index)(index+2); idx[3] = (nk_draw_index)(index+0);
|
|
|
+ idx[4] = (nk_draw_index)(index+2); idx[5] = (nk_draw_index)(index+3);
|
|
|
+
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, a, uva, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, b, uvb, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, c, uvc, col);
|
|
|
+ vtx = nk_draw_vertex(vtx, &list->config, d, uvd, col);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_add_image(struct nk_draw_list *list, struct nk_image texture,
|
|
|
+ struct nk_rect rect, struct nk_color color)
|
|
|
+{
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list) return;
|
|
|
+ /* push new command with given texture */
|
|
|
+ nk_draw_list_push_image(list, texture.handle);
|
|
|
+ if (nk_image_is_subimage(&texture)) {
|
|
|
+ /* add region inside of the texture */
|
|
|
+ struct nk_vec2 uv[2];
|
|
|
+ uv[0].x = (float)texture.region[0]/(float)texture.w;
|
|
|
+ uv[0].y = (float)texture.region[1]/(float)texture.h;
|
|
|
+ uv[1].x = (float)(texture.region[0] + texture.region[2])/(float)texture.w;
|
|
|
+ uv[1].y = (float)(texture.region[1] + texture.region[3])/(float)texture.h;
|
|
|
+ nk_draw_list_push_rect_uv(list, nk_vec2(rect.x, rect.y),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h), uv[0], uv[1], color);
|
|
|
+ } else nk_draw_list_push_rect_uv(list, nk_vec2(rect.x, rect.y),
|
|
|
+ nk_vec2(rect.x + rect.w, rect.y + rect.h),
|
|
|
+ nk_vec2(0.0f, 0.0f), nk_vec2(1.0f, 1.0f),color);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_draw_list_add_text(struct nk_draw_list *list, const struct nk_user_font *font,
|
|
|
+ struct nk_rect rect, const char *text, int len, float font_height,
|
|
|
+ struct nk_color fg)
|
|
|
+{
|
|
|
+ float x = 0;
|
|
|
+ int text_len = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ nk_rune next = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ int next_glyph_len = 0;
|
|
|
+ struct nk_user_font_glyph g;
|
|
|
+
|
|
|
+ NK_ASSERT(list);
|
|
|
+ if (!list || !len || !text) return;
|
|
|
+ if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h,
|
|
|
+ list->clip_rect.x, list->clip_rect.y, list->clip_rect.w, list->clip_rect.h)) return;
|
|
|
+
|
|
|
+ nk_draw_list_push_image(list, font->texture);
|
|
|
+ x = rect.x;
|
|
|
+ glyph_len = nk_utf_decode(text, &unicode, len);
|
|
|
+ if (!glyph_len) return;
|
|
|
+
|
|
|
+ /* draw every glyph image */
|
|
|
+ fg.a = (nk_byte)((float)fg.a * list->config.global_alpha);
|
|
|
+ while (text_len < len && glyph_len) {
|
|
|
+ float gx, gy, gh, gw;
|
|
|
+ float char_width = 0;
|
|
|
+ if (unicode == NK_UTF_INVALID) break;
|
|
|
+
|
|
|
+ /* query currently drawn glyph information */
|
|
|
+ next_glyph_len = nk_utf_decode(text + text_len + glyph_len, &next, (int)len - text_len);
|
|
|
+ font->query(font->userdata, font_height, &g, unicode,
|
|
|
+ (next == NK_UTF_INVALID) ? '\0' : next);
|
|
|
+
|
|
|
+ /* calculate and draw glyph drawing rectangle and image */
|
|
|
+ gx = x + g.offset.x;
|
|
|
+ gy = rect.y + g.offset.y;
|
|
|
+ gw = g.width; gh = g.height;
|
|
|
+ char_width = g.xadvance;
|
|
|
+ nk_draw_list_push_rect_uv(list, nk_vec2(gx,gy), nk_vec2(gx + gw, gy+ gh),
|
|
|
+ g.uv[0], g.uv[1], fg);
|
|
|
+
|
|
|
+ /* offset next glyph */
|
|
|
+ text_len += glyph_len;
|
|
|
+ x += char_width;
|
|
|
+ glyph_len = next_glyph_len;
|
|
|
+ unicode = next;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_convert(struct nk_context *ctx, struct nk_buffer *cmds,
|
|
|
+ struct nk_buffer *vertices, struct nk_buffer *elements,
|
|
|
+ const struct nk_convert_config *config)
|
|
|
+{
|
|
|
+ nk_flags res = NK_CONVERT_SUCCESS;
|
|
|
+ const struct nk_command *cmd;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(cmds);
|
|
|
+ NK_ASSERT(vertices);
|
|
|
+ NK_ASSERT(elements);
|
|
|
+ NK_ASSERT(config);
|
|
|
+ NK_ASSERT(config->vertex_layout);
|
|
|
+ NK_ASSERT(config->vertex_size);
|
|
|
+ if (!ctx || !cmds || !vertices || !elements || !config || !config->vertex_layout)
|
|
|
+ return NK_CONVERT_INVALID_PARAM;
|
|
|
+
|
|
|
+ nk_draw_list_setup(&ctx->draw_list, config, cmds, vertices, elements,
|
|
|
+ config->line_AA, config->shape_AA);
|
|
|
+ nk_foreach(cmd, ctx)
|
|
|
+ {
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ ctx->draw_list.userdata = cmd->userdata;
|
|
|
+#endif
|
|
|
+ switch (cmd->type) {
|
|
|
+ case NK_COMMAND_NOP: break;
|
|
|
+ case NK_COMMAND_SCISSOR: {
|
|
|
+ const struct nk_command_scissor *s = (const struct nk_command_scissor*)cmd;
|
|
|
+ nk_draw_list_add_clip(&ctx->draw_list, nk_rect(s->x, s->y, s->w, s->h));
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_LINE: {
|
|
|
+ const struct nk_command_line *l = (const struct nk_command_line*)cmd;
|
|
|
+ nk_draw_list_stroke_line(&ctx->draw_list, nk_vec2(l->begin.x, l->begin.y),
|
|
|
+ nk_vec2(l->end.x, l->end.y), l->color, l->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_CURVE: {
|
|
|
+ const struct nk_command_curve *q = (const struct nk_command_curve*)cmd;
|
|
|
+ nk_draw_list_stroke_curve(&ctx->draw_list, nk_vec2(q->begin.x, q->begin.y),
|
|
|
+ nk_vec2(q->ctrl[0].x, q->ctrl[0].y), nk_vec2(q->ctrl[1].x,
|
|
|
+ q->ctrl[1].y), nk_vec2(q->end.x, q->end.y), q->color,
|
|
|
+ config->curve_segment_count, q->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_RECT: {
|
|
|
+ const struct nk_command_rect *r = (const struct nk_command_rect*)cmd;
|
|
|
+ nk_draw_list_stroke_rect(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h),
|
|
|
+ r->color, (float)r->rounding, r->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_RECT_FILLED: {
|
|
|
+ const struct nk_command_rect_filled *r = (const struct nk_command_rect_filled*)cmd;
|
|
|
+ nk_draw_list_fill_rect(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h),
|
|
|
+ r->color, (float)r->rounding);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_RECT_MULTI_COLOR: {
|
|
|
+ const struct nk_command_rect_multi_color *r = (const struct nk_command_rect_multi_color*)cmd;
|
|
|
+ nk_draw_list_fill_rect_multi_color(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h),
|
|
|
+ r->left, r->top, r->right, r->bottom);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_CIRCLE: {
|
|
|
+ const struct nk_command_circle *c = (const struct nk_command_circle*)cmd;
|
|
|
+ nk_draw_list_stroke_circle(&ctx->draw_list, nk_vec2((float)c->x + (float)c->w/2,
|
|
|
+ (float)c->y + (float)c->h/2), (float)c->w/2, c->color,
|
|
|
+ config->circle_segment_count, c->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_CIRCLE_FILLED: {
|
|
|
+ const struct nk_command_circle_filled *c = (const struct nk_command_circle_filled *)cmd;
|
|
|
+ nk_draw_list_fill_circle(&ctx->draw_list, nk_vec2((float)c->x + (float)c->w/2,
|
|
|
+ (float)c->y + (float)c->h/2), (float)c->w/2, c->color,
|
|
|
+ config->circle_segment_count);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_ARC: {
|
|
|
+ const struct nk_command_arc *c = (const struct nk_command_arc*)cmd;
|
|
|
+ nk_draw_list_path_line_to(&ctx->draw_list, nk_vec2(c->cx, c->cy));
|
|
|
+ nk_draw_list_path_arc_to(&ctx->draw_list, nk_vec2(c->cx, c->cy), c->r,
|
|
|
+ c->a[0], c->a[1], config->arc_segment_count);
|
|
|
+ nk_draw_list_path_stroke(&ctx->draw_list, c->color, NK_STROKE_CLOSED, c->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_ARC_FILLED: {
|
|
|
+ const struct nk_command_arc_filled *c = (const struct nk_command_arc_filled*)cmd;
|
|
|
+ nk_draw_list_path_line_to(&ctx->draw_list, nk_vec2(c->cx, c->cy));
|
|
|
+ nk_draw_list_path_arc_to(&ctx->draw_list, nk_vec2(c->cx, c->cy), c->r,
|
|
|
+ c->a[0], c->a[1], config->arc_segment_count);
|
|
|
+ nk_draw_list_path_fill(&ctx->draw_list, c->color);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_TRIANGLE: {
|
|
|
+ const struct nk_command_triangle *t = (const struct nk_command_triangle*)cmd;
|
|
|
+ nk_draw_list_stroke_triangle(&ctx->draw_list, nk_vec2(t->a.x, t->a.y),
|
|
|
+ nk_vec2(t->b.x, t->b.y), nk_vec2(t->c.x, t->c.y), t->color,
|
|
|
+ t->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_TRIANGLE_FILLED: {
|
|
|
+ const struct nk_command_triangle_filled *t = (const struct nk_command_triangle_filled*)cmd;
|
|
|
+ nk_draw_list_fill_triangle(&ctx->draw_list, nk_vec2(t->a.x, t->a.y),
|
|
|
+ nk_vec2(t->b.x, t->b.y), nk_vec2(t->c.x, t->c.y), t->color);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_POLYGON: {
|
|
|
+ int i;
|
|
|
+ const struct nk_command_polygon*p = (const struct nk_command_polygon*)cmd;
|
|
|
+ for (i = 0; i < p->point_count; ++i) {
|
|
|
+ struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
|
|
|
+ nk_draw_list_path_line_to(&ctx->draw_list, pnt);
|
|
|
+ }
|
|
|
+ nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_CLOSED, p->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_POLYGON_FILLED: {
|
|
|
+ int i;
|
|
|
+ const struct nk_command_polygon_filled *p = (const struct nk_command_polygon_filled*)cmd;
|
|
|
+ for (i = 0; i < p->point_count; ++i) {
|
|
|
+ struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
|
|
|
+ nk_draw_list_path_line_to(&ctx->draw_list, pnt);
|
|
|
+ }
|
|
|
+ nk_draw_list_path_fill(&ctx->draw_list, p->color);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_POLYLINE: {
|
|
|
+ int i;
|
|
|
+ const struct nk_command_polyline *p = (const struct nk_command_polyline*)cmd;
|
|
|
+ for (i = 0; i < p->point_count; ++i) {
|
|
|
+ struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
|
|
|
+ nk_draw_list_path_line_to(&ctx->draw_list, pnt);
|
|
|
+ }
|
|
|
+ nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_OPEN, p->line_thickness);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_TEXT: {
|
|
|
+ const struct nk_command_text *t = (const struct nk_command_text*)cmd;
|
|
|
+ nk_draw_list_add_text(&ctx->draw_list, t->font, nk_rect(t->x, t->y, t->w, t->h),
|
|
|
+ t->string, t->length, t->height, t->foreground);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_IMAGE: {
|
|
|
+ const struct nk_command_image *i = (const struct nk_command_image*)cmd;
|
|
|
+ nk_draw_list_add_image(&ctx->draw_list, i->img, nk_rect(i->x, i->y, i->w, i->h), i->col);
|
|
|
+ } break;
|
|
|
+ case NK_COMMAND_CUSTOM: {
|
|
|
+ const struct nk_command_custom *c = (const struct nk_command_custom*)cmd;
|
|
|
+ c->callback(&ctx->draw_list, c->x, c->y, c->w, c->h, c->callback_data);
|
|
|
+ } break;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ res |= (cmds->needed > cmds->allocated + (cmds->memory.size - cmds->size)) ? NK_CONVERT_COMMAND_BUFFER_FULL: 0;
|
|
|
+ res |= (vertices->needed > vertices->allocated) ? NK_CONVERT_VERTEX_BUFFER_FULL: 0;
|
|
|
+ res |= (elements->needed > elements->allocated) ? NK_CONVERT_ELEMENT_BUFFER_FULL: 0;
|
|
|
+ return res;
|
|
|
+}
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_begin(const struct nk_context *ctx,
|
|
|
+ const struct nk_buffer *buffer)
|
|
|
+{return nk__draw_list_begin(&ctx->draw_list, buffer);}
|
|
|
+
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_end(const struct nk_context *ctx, const struct nk_buffer *buffer)
|
|
|
+{return nk__draw_list_end(&ctx->draw_list, buffer);}
|
|
|
+
|
|
|
+NK_API const struct nk_draw_command*
|
|
|
+nk__draw_next(const struct nk_draw_command *cmd,
|
|
|
+ const struct nk_buffer *buffer, const struct nk_context *ctx)
|
|
|
+{return nk__draw_list_next(cmd, buffer, &ctx->draw_list);}
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * FONT HANDLING
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+#ifdef NK_INCLUDE_FONT_BAKING
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * RECT PACK
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+/* stb_rect_pack.h - v0.05 - public domain - rectangle packing */
|
|
|
+/* Sean Barrett 2014 */
|
|
|
+#define NK_RP__MAXVAL 0xffff
|
|
|
+typedef unsigned short nk_rp_coord;
|
|
|
+
|
|
|
+struct nk_rp_rect {
|
|
|
+ /* reserved for your use: */
|
|
|
+ int id;
|
|
|
+ /* input: */
|
|
|
+ nk_rp_coord w, h;
|
|
|
+ /* output: */
|
|
|
+ nk_rp_coord x, y;
|
|
|
+ int was_packed;
|
|
|
+ /* non-zero if valid packing */
|
|
|
+}; /* 16 bytes, nominally */
|
|
|
+
|
|
|
+struct nk_rp_node {
|
|
|
+ nk_rp_coord x,y;
|
|
|
+ struct nk_rp_node *next;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_rp_context {
|
|
|
+ int width;
|
|
|
+ int height;
|
|
|
+ int align;
|
|
|
+ int init_mode;
|
|
|
+ int heuristic;
|
|
|
+ int num_nodes;
|
|
|
+ struct nk_rp_node *active_head;
|
|
|
+ struct nk_rp_node *free_head;
|
|
|
+ struct nk_rp_node extra[2];
|
|
|
+ /* we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_rp__findresult {
|
|
|
+ int x,y;
|
|
|
+ struct nk_rp_node **prev_link;
|
|
|
+};
|
|
|
+
|
|
|
+enum NK_RP_HEURISTIC {
|
|
|
+ NK_RP_HEURISTIC_Skyline_default=0,
|
|
|
+ NK_RP_HEURISTIC_Skyline_BL_sortHeight = NK_RP_HEURISTIC_Skyline_default,
|
|
|
+ NK_RP_HEURISTIC_Skyline_BF_sortHeight
|
|
|
+};
|
|
|
+enum NK_RP_INIT_STATE{NK_RP__INIT_skyline = 1};
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_rp_setup_allow_out_of_mem(struct nk_rp_context *context, int allow_out_of_mem)
|
|
|
+{
|
|
|
+ if (allow_out_of_mem)
|
|
|
+ /* if it's ok to run out of memory, then don't bother aligning them; */
|
|
|
+ /* this gives better packing, but may fail due to OOM (even though */
|
|
|
+ /* the rectangles easily fit). @TODO a smarter approach would be to only */
|
|
|
+ /* quantize once we've hit OOM, then we could get rid of this parameter. */
|
|
|
+ context->align = 1;
|
|
|
+ else {
|
|
|
+ /* if it's not ok to run out of memory, then quantize the widths */
|
|
|
+ /* so that num_nodes is always enough nodes. */
|
|
|
+ /* */
|
|
|
+ /* I.e. num_nodes * align >= width */
|
|
|
+ /* align >= width / num_nodes */
|
|
|
+ /* align = ceil(width/num_nodes) */
|
|
|
+ context->align = (context->width + context->num_nodes-1) / context->num_nodes;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_rp_init_target(struct nk_rp_context *context, int width, int height,
|
|
|
+ struct nk_rp_node *nodes, int num_nodes)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+#ifndef STBRP_LARGE_RECTS
|
|
|
+ NK_ASSERT(width <= 0xffff && height <= 0xffff);
|
|
|
+#endif
|
|
|
+
|
|
|
+ for (i=0; i < num_nodes-1; ++i)
|
|
|
+ nodes[i].next = &nodes[i+1];
|
|
|
+ nodes[i].next = 0;
|
|
|
+ context->init_mode = NK_RP__INIT_skyline;
|
|
|
+ context->heuristic = NK_RP_HEURISTIC_Skyline_default;
|
|
|
+ context->free_head = &nodes[0];
|
|
|
+ context->active_head = &context->extra[0];
|
|
|
+ context->width = width;
|
|
|
+ context->height = height;
|
|
|
+ context->num_nodes = num_nodes;
|
|
|
+ nk_rp_setup_allow_out_of_mem(context, 0);
|
|
|
+
|
|
|
+ /* node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) */
|
|
|
+ context->extra[0].x = 0;
|
|
|
+ context->extra[0].y = 0;
|
|
|
+ context->extra[0].next = &context->extra[1];
|
|
|
+ context->extra[1].x = (nk_rp_coord) width;
|
|
|
+ context->extra[1].y = 65535;
|
|
|
+ context->extra[1].next = 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* find minimum y position if it starts at x1 */
|
|
|
+NK_INTERN int
|
|
|
+nk_rp__skyline_find_min_y(struct nk_rp_context *c, struct nk_rp_node *first,
|
|
|
+ int x0, int width, int *pwaste)
|
|
|
+{
|
|
|
+ struct nk_rp_node *node = first;
|
|
|
+ int x1 = x0 + width;
|
|
|
+ int min_y, visited_width, waste_area;
|
|
|
+ NK_ASSERT(first->x <= x0);
|
|
|
+ NK_UNUSED(c);
|
|
|
+
|
|
|
+ NK_ASSERT(node->next->x > x0);
|
|
|
+ /* we ended up handling this in the caller for efficiency */
|
|
|
+ NK_ASSERT(node->x <= x0);
|
|
|
+
|
|
|
+ min_y = 0;
|
|
|
+ waste_area = 0;
|
|
|
+ visited_width = 0;
|
|
|
+ while (node->x < x1)
|
|
|
+ {
|
|
|
+ if (node->y > min_y) {
|
|
|
+ /* raise min_y higher. */
|
|
|
+ /* we've accounted for all waste up to min_y, */
|
|
|
+ /* but we'll now add more waste for everything we've visited */
|
|
|
+ waste_area += visited_width * (node->y - min_y);
|
|
|
+ min_y = node->y;
|
|
|
+ /* the first time through, visited_width might be reduced */
|
|
|
+ if (node->x < x0)
|
|
|
+ visited_width += node->next->x - x0;
|
|
|
+ else
|
|
|
+ visited_width += node->next->x - node->x;
|
|
|
+ } else {
|
|
|
+ /* add waste area */
|
|
|
+ int under_width = node->next->x - node->x;
|
|
|
+ if (under_width + visited_width > width)
|
|
|
+ under_width = width - visited_width;
|
|
|
+ waste_area += under_width * (min_y - node->y);
|
|
|
+ visited_width += under_width;
|
|
|
+ }
|
|
|
+ node = node->next;
|
|
|
+ }
|
|
|
+ *pwaste = waste_area;
|
|
|
+ return min_y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_rp__findresult
|
|
|
+nk_rp__skyline_find_best_pos(struct nk_rp_context *c, int width, int height)
|
|
|
+{
|
|
|
+ int best_waste = (1<<30), best_x, best_y = (1 << 30);
|
|
|
+ struct nk_rp__findresult fr;
|
|
|
+ struct nk_rp_node **prev, *node, *tail, **best = 0;
|
|
|
+
|
|
|
+ /* align to multiple of c->align */
|
|
|
+ width = (width + c->align - 1);
|
|
|
+ width -= width % c->align;
|
|
|
+ NK_ASSERT(width % c->align == 0);
|
|
|
+
|
|
|
+ node = c->active_head;
|
|
|
+ prev = &c->active_head;
|
|
|
+ while (node->x + width <= c->width) {
|
|
|
+ int y,waste;
|
|
|
+ y = nk_rp__skyline_find_min_y(c, node, node->x, width, &waste);
|
|
|
+ /* actually just want to test BL */
|
|
|
+ if (c->heuristic == NK_RP_HEURISTIC_Skyline_BL_sortHeight) {
|
|
|
+ /* bottom left */
|
|
|
+ if (y < best_y) {
|
|
|
+ best_y = y;
|
|
|
+ best = prev;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* best-fit */
|
|
|
+ if (y + height <= c->height) {
|
|
|
+ /* can only use it if it first vertically */
|
|
|
+ if (y < best_y || (y == best_y && waste < best_waste)) {
|
|
|
+ best_y = y;
|
|
|
+ best_waste = waste;
|
|
|
+ best = prev;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ prev = &node->next;
|
|
|
+ node = node->next;
|
|
|
+ }
|
|
|
+ best_x = (best == 0) ? 0 : (*best)->x;
|
|
|
+
|
|
|
+ /* if doing best-fit (BF), we also have to try aligning right edge to each node position */
|
|
|
+ /* */
|
|
|
+ /* e.g, if fitting */
|
|
|
+ /* */
|
|
|
+ /* ____________________ */
|
|
|
+ /* |____________________| */
|
|
|
+ /* */
|
|
|
+ /* into */
|
|
|
+ /* */
|
|
|
+ /* | | */
|
|
|
+ /* | ____________| */
|
|
|
+ /* |____________| */
|
|
|
+ /* */
|
|
|
+ /* then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned */
|
|
|
+ /* */
|
|
|
+ /* This makes BF take about 2x the time */
|
|
|
+ if (c->heuristic == NK_RP_HEURISTIC_Skyline_BF_sortHeight)
|
|
|
+ {
|
|
|
+ tail = c->active_head;
|
|
|
+ node = c->active_head;
|
|
|
+ prev = &c->active_head;
|
|
|
+ /* find first node that's admissible */
|
|
|
+ while (tail->x < width)
|
|
|
+ tail = tail->next;
|
|
|
+ while (tail)
|
|
|
+ {
|
|
|
+ int xpos = tail->x - width;
|
|
|
+ int y,waste;
|
|
|
+ NK_ASSERT(xpos >= 0);
|
|
|
+ /* find the left position that matches this */
|
|
|
+ while (node->next->x <= xpos) {
|
|
|
+ prev = &node->next;
|
|
|
+ node = node->next;
|
|
|
+ }
|
|
|
+ NK_ASSERT(node->next->x > xpos && node->x <= xpos);
|
|
|
+ y = nk_rp__skyline_find_min_y(c, node, xpos, width, &waste);
|
|
|
+ if (y + height < c->height) {
|
|
|
+ if (y <= best_y) {
|
|
|
+ if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
|
|
|
+ best_x = xpos;
|
|
|
+ NK_ASSERT(y <= best_y);
|
|
|
+ best_y = y;
|
|
|
+ best_waste = waste;
|
|
|
+ best = prev;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ tail = tail->next;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ fr.prev_link = best;
|
|
|
+ fr.x = best_x;
|
|
|
+ fr.y = best_y;
|
|
|
+ return fr;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_rp__findresult
|
|
|
+nk_rp__skyline_pack_rectangle(struct nk_rp_context *context, int width, int height)
|
|
|
+{
|
|
|
+ /* find best position according to heuristic */
|
|
|
+ struct nk_rp__findresult res = nk_rp__skyline_find_best_pos(context, width, height);
|
|
|
+ struct nk_rp_node *node, *cur;
|
|
|
+
|
|
|
+ /* bail if: */
|
|
|
+ /* 1. it failed */
|
|
|
+ /* 2. the best node doesn't fit (we don't always check this) */
|
|
|
+ /* 3. we're out of memory */
|
|
|
+ if (res.prev_link == 0 || res.y + height > context->height || context->free_head == 0) {
|
|
|
+ res.prev_link = 0;
|
|
|
+ return res;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* on success, create new node */
|
|
|
+ node = context->free_head;
|
|
|
+ node->x = (nk_rp_coord) res.x;
|
|
|
+ node->y = (nk_rp_coord) (res.y + height);
|
|
|
+
|
|
|
+ context->free_head = node->next;
|
|
|
+
|
|
|
+ /* insert the new node into the right starting point, and */
|
|
|
+ /* let 'cur' point to the remaining nodes needing to be */
|
|
|
+ /* stitched back in */
|
|
|
+ cur = *res.prev_link;
|
|
|
+ if (cur->x < res.x) {
|
|
|
+ /* preserve the existing one, so start testing with the next one */
|
|
|
+ struct nk_rp_node *next = cur->next;
|
|
|
+ cur->next = node;
|
|
|
+ cur = next;
|
|
|
+ } else {
|
|
|
+ *res.prev_link = node;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* from here, traverse cur and free the nodes, until we get to one */
|
|
|
+ /* that shouldn't be freed */
|
|
|
+ while (cur->next && cur->next->x <= res.x + width) {
|
|
|
+ struct nk_rp_node *next = cur->next;
|
|
|
+ /* move the current node to the free list */
|
|
|
+ cur->next = context->free_head;
|
|
|
+ context->free_head = cur;
|
|
|
+ cur = next;
|
|
|
+ }
|
|
|
+ /* stitch the list back in */
|
|
|
+ node->next = cur;
|
|
|
+
|
|
|
+ if (cur->x < res.x + width)
|
|
|
+ cur->x = (nk_rp_coord) (res.x + width);
|
|
|
+ return res;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_rect_height_compare(const void *a, const void *b)
|
|
|
+{
|
|
|
+ const struct nk_rp_rect *p = (const struct nk_rp_rect *) a;
|
|
|
+ const struct nk_rp_rect *q = (const struct nk_rp_rect *) b;
|
|
|
+ if (p->h > q->h)
|
|
|
+ return -1;
|
|
|
+ if (p->h < q->h)
|
|
|
+ return 1;
|
|
|
+ return (p->w > q->w) ? -1 : (p->w < q->w);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_rect_original_order(const void *a, const void *b)
|
|
|
+{
|
|
|
+ const struct nk_rp_rect *p = (const struct nk_rp_rect *) a;
|
|
|
+ const struct nk_rp_rect *q = (const struct nk_rp_rect *) b;
|
|
|
+ return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_rp_qsort(struct nk_rp_rect *array, unsigned int len, int(*cmp)(const void*,const void*))
|
|
|
+{
|
|
|
+ /* iterative quick sort */
|
|
|
+ #define NK_MAX_SORT_STACK 64
|
|
|
+ unsigned right, left = 0, stack[NK_MAX_SORT_STACK], pos = 0;
|
|
|
+ unsigned seed = len/2 * 69069+1;
|
|
|
+ for (;;) {
|
|
|
+ for (; left+1 < len; len++) {
|
|
|
+ struct nk_rp_rect pivot, tmp;
|
|
|
+ if (pos == NK_MAX_SORT_STACK) len = stack[pos = 0];
|
|
|
+ pivot = array[left+seed%(len-left)];
|
|
|
+ seed = seed * 69069 + 1;
|
|
|
+ stack[pos++] = len;
|
|
|
+ for (right = left-1;;) {
|
|
|
+ while (cmp(&array[++right], &pivot) < 0);
|
|
|
+ while (cmp(&pivot, &array[--len]) < 0);
|
|
|
+ if (right >= len) break;
|
|
|
+ tmp = array[right];
|
|
|
+ array[right] = array[len];
|
|
|
+ array[len] = tmp;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (pos == 0) break;
|
|
|
+ left = len;
|
|
|
+ len = stack[--pos];
|
|
|
+ }
|
|
|
+ #undef NK_MAX_SORT_STACK
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_rp_pack_rects(struct nk_rp_context *context, struct nk_rp_rect *rects, int num_rects)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ /* we use the 'was_packed' field internally to allow sorting/unsorting */
|
|
|
+ for (i=0; i < num_rects; ++i) {
|
|
|
+ rects[i].was_packed = i;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* sort according to heuristic */
|
|
|
+ nk_rp_qsort(rects, (unsigned)num_rects, nk_rect_height_compare);
|
|
|
+
|
|
|
+ for (i=0; i < num_rects; ++i) {
|
|
|
+ struct nk_rp__findresult fr = nk_rp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
|
|
|
+ if (fr.prev_link) {
|
|
|
+ rects[i].x = (nk_rp_coord) fr.x;
|
|
|
+ rects[i].y = (nk_rp_coord) fr.y;
|
|
|
+ } else {
|
|
|
+ rects[i].x = rects[i].y = NK_RP__MAXVAL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* unsort */
|
|
|
+ nk_rp_qsort(rects, (unsigned)num_rects, nk_rect_original_order);
|
|
|
+
|
|
|
+ /* set was_packed flags */
|
|
|
+ for (i=0; i < num_rects; ++i)
|
|
|
+ rects[i].was_packed = !(rects[i].x == NK_RP__MAXVAL && rects[i].y == NK_RP__MAXVAL);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * TRUETYPE
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+/* stb_truetype.h - v1.07 - public domain */
|
|
|
+#define NK_TT_MAX_OVERSAMPLE 8
|
|
|
+#define NK_TT__OVER_MASK (NK_TT_MAX_OVERSAMPLE-1)
|
|
|
+
|
|
|
+struct nk_tt_bakedchar {
|
|
|
+ unsigned short x0,y0,x1,y1;
|
|
|
+ /* coordinates of bbox in bitmap */
|
|
|
+ float xoff,yoff,xadvance;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_aligned_quad{
|
|
|
+ float x0,y0,s0,t0; /* top-left */
|
|
|
+ float x1,y1,s1,t1; /* bottom-right */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_packedchar {
|
|
|
+ unsigned short x0,y0,x1,y1;
|
|
|
+ /* coordinates of bbox in bitmap */
|
|
|
+ float xoff,yoff,xadvance;
|
|
|
+ float xoff2,yoff2;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_pack_range {
|
|
|
+ float font_size;
|
|
|
+ int first_unicode_codepoint_in_range;
|
|
|
+ /* if non-zero, then the chars are continuous, and this is the first codepoint */
|
|
|
+ int *array_of_unicode_codepoints;
|
|
|
+ /* if non-zero, then this is an array of unicode codepoints */
|
|
|
+ int num_chars;
|
|
|
+ struct nk_tt_packedchar *chardata_for_range; /* output */
|
|
|
+ unsigned char h_oversample, v_oversample;
|
|
|
+ /* don't set these, they're used internally */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_pack_context {
|
|
|
+ void *pack_info;
|
|
|
+ int width;
|
|
|
+ int height;
|
|
|
+ int stride_in_bytes;
|
|
|
+ int padding;
|
|
|
+ unsigned int h_oversample, v_oversample;
|
|
|
+ unsigned char *pixels;
|
|
|
+ void *nodes;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_fontinfo {
|
|
|
+ const unsigned char* data; /* pointer to .ttf file */
|
|
|
+ int fontstart;/* offset of start of font */
|
|
|
+ int numGlyphs;/* number of glyphs, needed for range checking */
|
|
|
+ int loca,head,glyf,hhea,hmtx,kern; /* table locations as offset from start of .ttf */
|
|
|
+ int index_map; /* a cmap mapping for our chosen character encoding */
|
|
|
+ int indexToLocFormat; /* format needed to map from glyph index to glyph */
|
|
|
+};
|
|
|
+
|
|
|
+enum {
|
|
|
+ NK_TT_vmove=1,
|
|
|
+ NK_TT_vline,
|
|
|
+ NK_TT_vcurve
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt_vertex {
|
|
|
+ short x,y,cx,cy;
|
|
|
+ unsigned char type,padding;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt__bitmap{
|
|
|
+ int w,h,stride;
|
|
|
+ unsigned char *pixels;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt__hheap_chunk {
|
|
|
+ struct nk_tt__hheap_chunk *next;
|
|
|
+};
|
|
|
+struct nk_tt__hheap {
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ struct nk_tt__hheap_chunk *head;
|
|
|
+ void *first_free;
|
|
|
+ int num_remaining_in_head_chunk;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt__edge {
|
|
|
+ float x0,y0, x1,y1;
|
|
|
+ int invert;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_tt__active_edge {
|
|
|
+ struct nk_tt__active_edge *next;
|
|
|
+ float fx,fdx,fdy;
|
|
|
+ float direction;
|
|
|
+ float sy;
|
|
|
+ float ey;
|
|
|
+};
|
|
|
+struct nk_tt__point {float x,y;};
|
|
|
+
|
|
|
+#define NK_TT_MACSTYLE_DONTCARE 0
|
|
|
+#define NK_TT_MACSTYLE_BOLD 1
|
|
|
+#define NK_TT_MACSTYLE_ITALIC 2
|
|
|
+#define NK_TT_MACSTYLE_UNDERSCORE 4
|
|
|
+#define NK_TT_MACSTYLE_NONE 8
|
|
|
+/* <= not same as 0, this makes us check the bitfield is 0 */
|
|
|
+
|
|
|
+enum { /* platformID */
|
|
|
+ NK_TT_PLATFORM_ID_UNICODE =0,
|
|
|
+ NK_TT_PLATFORM_ID_MAC =1,
|
|
|
+ NK_TT_PLATFORM_ID_ISO =2,
|
|
|
+ NK_TT_PLATFORM_ID_MICROSOFT =3
|
|
|
+};
|
|
|
+
|
|
|
+enum { /* encodingID for NK_TT_PLATFORM_ID_UNICODE */
|
|
|
+ NK_TT_UNICODE_EID_UNICODE_1_0 =0,
|
|
|
+ NK_TT_UNICODE_EID_UNICODE_1_1 =1,
|
|
|
+ NK_TT_UNICODE_EID_ISO_10646 =2,
|
|
|
+ NK_TT_UNICODE_EID_UNICODE_2_0_BMP=3,
|
|
|
+ NK_TT_UNICODE_EID_UNICODE_2_0_FULL=4
|
|
|
+};
|
|
|
+
|
|
|
+enum { /* encodingID for NK_TT_PLATFORM_ID_MICROSOFT */
|
|
|
+ NK_TT_MS_EID_SYMBOL =0,
|
|
|
+ NK_TT_MS_EID_UNICODE_BMP =1,
|
|
|
+ NK_TT_MS_EID_SHIFTJIS =2,
|
|
|
+ NK_TT_MS_EID_UNICODE_FULL =10
|
|
|
+};
|
|
|
+
|
|
|
+enum { /* encodingID for NK_TT_PLATFORM_ID_MAC; same as Script Manager codes */
|
|
|
+ NK_TT_MAC_EID_ROMAN =0, NK_TT_MAC_EID_ARABIC =4,
|
|
|
+ NK_TT_MAC_EID_JAPANESE =1, NK_TT_MAC_EID_HEBREW =5,
|
|
|
+ NK_TT_MAC_EID_CHINESE_TRAD =2, NK_TT_MAC_EID_GREEK =6,
|
|
|
+ NK_TT_MAC_EID_KOREAN =3, NK_TT_MAC_EID_RUSSIAN =7
|
|
|
+};
|
|
|
+
|
|
|
+enum { /* languageID for NK_TT_PLATFORM_ID_MICROSOFT; same as LCID... */
|
|
|
+ /* problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs */
|
|
|
+ NK_TT_MS_LANG_ENGLISH =0x0409, NK_TT_MS_LANG_ITALIAN =0x0410,
|
|
|
+ NK_TT_MS_LANG_CHINESE =0x0804, NK_TT_MS_LANG_JAPANESE =0x0411,
|
|
|
+ NK_TT_MS_LANG_DUTCH =0x0413, NK_TT_MS_LANG_KOREAN =0x0412,
|
|
|
+ NK_TT_MS_LANG_FRENCH =0x040c, NK_TT_MS_LANG_RUSSIAN =0x0419,
|
|
|
+ NK_TT_MS_LANG_GERMAN =0x0407, NK_TT_MS_LANG_SPANISH =0x0409,
|
|
|
+ NK_TT_MS_LANG_HEBREW =0x040d, NK_TT_MS_LANG_SWEDISH =0x041D
|
|
|
+};
|
|
|
+
|
|
|
+enum { /* languageID for NK_TT_PLATFORM_ID_MAC */
|
|
|
+ NK_TT_MAC_LANG_ENGLISH =0 , NK_TT_MAC_LANG_JAPANESE =11,
|
|
|
+ NK_TT_MAC_LANG_ARABIC =12, NK_TT_MAC_LANG_KOREAN =23,
|
|
|
+ NK_TT_MAC_LANG_DUTCH =4 , NK_TT_MAC_LANG_RUSSIAN =32,
|
|
|
+ NK_TT_MAC_LANG_FRENCH =1 , NK_TT_MAC_LANG_SPANISH =6 ,
|
|
|
+ NK_TT_MAC_LANG_GERMAN =2 , NK_TT_MAC_LANG_SWEDISH =5 ,
|
|
|
+ NK_TT_MAC_LANG_HEBREW =10, NK_TT_MAC_LANG_CHINESE_SIMPLIFIED =33,
|
|
|
+ NK_TT_MAC_LANG_ITALIAN =3 , NK_TT_MAC_LANG_CHINESE_TRAD =19
|
|
|
+};
|
|
|
+
|
|
|
+#define nk_ttBYTE(p) (* (const nk_byte *) (p))
|
|
|
+#define nk_ttCHAR(p) (* (const char *) (p))
|
|
|
+
|
|
|
+#if defined(NK_BIGENDIAN) && !defined(NK_ALLOW_UNALIGNED_TRUETYPE)
|
|
|
+ #define nk_ttUSHORT(p) (* (nk_ushort *) (p))
|
|
|
+ #define nk_ttSHORT(p) (* (nk_short *) (p))
|
|
|
+ #define nk_ttULONG(p) (* (nk_uint *) (p))
|
|
|
+ #define nk_ttLONG(p) (* (nk_int *) (p))
|
|
|
+#else
|
|
|
+ static nk_ushort nk_ttUSHORT(const nk_byte *p) { return (nk_ushort)(p[0]*256 + p[1]); }
|
|
|
+ static nk_short nk_ttSHORT(const nk_byte *p) { return (nk_short)(p[0]*256 + p[1]); }
|
|
|
+ static nk_uint nk_ttULONG(const nk_byte *p) { return (nk_uint)((p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]); }
|
|
|
+#endif
|
|
|
+
|
|
|
+#define nk_tt_tag4(p,c0,c1,c2,c3)\
|
|
|
+ ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
|
|
|
+#define nk_tt_tag(p,str) nk_tt_tag4(p,str[0],str[1],str[2],str[3])
|
|
|
+
|
|
|
+NK_INTERN int nk_tt_GetGlyphShape(const struct nk_tt_fontinfo *info, struct nk_allocator *alloc,
|
|
|
+ int glyph_index, struct nk_tt_vertex **pvertices);
|
|
|
+
|
|
|
+NK_INTERN nk_uint
|
|
|
+nk_tt__find_table(const nk_byte *data, nk_uint fontstart, const char *tag)
|
|
|
+{
|
|
|
+ /* @OPTIMIZE: binary search */
|
|
|
+ nk_int num_tables = nk_ttUSHORT(data+fontstart+4);
|
|
|
+ nk_uint tabledir = fontstart + 12;
|
|
|
+ nk_int i;
|
|
|
+ for (i = 0; i < num_tables; ++i) {
|
|
|
+ nk_uint loc = tabledir + (nk_uint)(16*i);
|
|
|
+ if (nk_tt_tag(data+loc+0, tag))
|
|
|
+ return nk_ttULONG(data+loc+8);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_InitFont(struct nk_tt_fontinfo *info, const unsigned char *data2, int fontstart)
|
|
|
+{
|
|
|
+ nk_uint cmap, t;
|
|
|
+ nk_int i,numTables;
|
|
|
+ const nk_byte *data = (const nk_byte *) data2;
|
|
|
+
|
|
|
+ info->data = data;
|
|
|
+ info->fontstart = fontstart;
|
|
|
+
|
|
|
+ cmap = nk_tt__find_table(data, (nk_uint)fontstart, "cmap"); /* required */
|
|
|
+ info->loca = (int)nk_tt__find_table(data, (nk_uint)fontstart, "loca"); /* required */
|
|
|
+ info->head = (int)nk_tt__find_table(data, (nk_uint)fontstart, "head"); /* required */
|
|
|
+ info->glyf = (int)nk_tt__find_table(data, (nk_uint)fontstart, "glyf"); /* required */
|
|
|
+ info->hhea = (int)nk_tt__find_table(data, (nk_uint)fontstart, "hhea"); /* required */
|
|
|
+ info->hmtx = (int)nk_tt__find_table(data, (nk_uint)fontstart, "hmtx"); /* required */
|
|
|
+ info->kern = (int)nk_tt__find_table(data, (nk_uint)fontstart, "kern"); /* not required */
|
|
|
+ if (!cmap || !info->loca || !info->head || !info->glyf || !info->hhea || !info->hmtx)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ t = nk_tt__find_table(data, (nk_uint)fontstart, "maxp");
|
|
|
+ if (t) info->numGlyphs = nk_ttUSHORT(data+t+4);
|
|
|
+ else info->numGlyphs = 0xffff;
|
|
|
+
|
|
|
+ /* find a cmap encoding table we understand *now* to avoid searching */
|
|
|
+ /* later. (todo: could make this installable) */
|
|
|
+ /* the same regardless of glyph. */
|
|
|
+ numTables = nk_ttUSHORT(data + cmap + 2);
|
|
|
+ info->index_map = 0;
|
|
|
+ for (i=0; i < numTables; ++i)
|
|
|
+ {
|
|
|
+ nk_uint encoding_record = cmap + 4 + 8 * (nk_uint)i;
|
|
|
+ /* find an encoding we understand: */
|
|
|
+ switch(nk_ttUSHORT(data+encoding_record)) {
|
|
|
+ case NK_TT_PLATFORM_ID_MICROSOFT:
|
|
|
+ switch (nk_ttUSHORT(data+encoding_record+2)) {
|
|
|
+ case NK_TT_MS_EID_UNICODE_BMP:
|
|
|
+ case NK_TT_MS_EID_UNICODE_FULL:
|
|
|
+ /* MS/Unicode */
|
|
|
+ info->index_map = (int)(cmap + nk_ttULONG(data+encoding_record+4));
|
|
|
+ break;
|
|
|
+ default: break;
|
|
|
+ } break;
|
|
|
+ case NK_TT_PLATFORM_ID_UNICODE:
|
|
|
+ /* Mac/iOS has these */
|
|
|
+ /* all the encodingIDs are unicode, so we don't bother to check it */
|
|
|
+ info->index_map = (int)(cmap + nk_ttULONG(data+encoding_record+4));
|
|
|
+ break;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (info->index_map == 0)
|
|
|
+ return 0;
|
|
|
+ info->indexToLocFormat = nk_ttUSHORT(data+info->head + 50);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_FindGlyphIndex(const struct nk_tt_fontinfo *info, int unicode_codepoint)
|
|
|
+{
|
|
|
+ const nk_byte *data = info->data;
|
|
|
+ nk_uint index_map = (nk_uint)info->index_map;
|
|
|
+
|
|
|
+ nk_ushort format = nk_ttUSHORT(data + index_map + 0);
|
|
|
+ if (format == 0) { /* apple byte encoding */
|
|
|
+ nk_int bytes = nk_ttUSHORT(data + index_map + 2);
|
|
|
+ if (unicode_codepoint < bytes-6)
|
|
|
+ return nk_ttBYTE(data + index_map + 6 + unicode_codepoint);
|
|
|
+ return 0;
|
|
|
+ } else if (format == 6) {
|
|
|
+ nk_uint first = nk_ttUSHORT(data + index_map + 6);
|
|
|
+ nk_uint count = nk_ttUSHORT(data + index_map + 8);
|
|
|
+ if ((nk_uint) unicode_codepoint >= first && (nk_uint) unicode_codepoint < first+count)
|
|
|
+ return nk_ttUSHORT(data + index_map + 10 + (unicode_codepoint - (int)first)*2);
|
|
|
+ return 0;
|
|
|
+ } else if (format == 2) {
|
|
|
+ NK_ASSERT(0); /* @TODO: high-byte mapping for japanese/chinese/korean */
|
|
|
+ return 0;
|
|
|
+ } else if (format == 4) { /* standard mapping for windows fonts: binary search collection of ranges */
|
|
|
+ nk_ushort segcount = nk_ttUSHORT(data+index_map+6) >> 1;
|
|
|
+ nk_ushort searchRange = nk_ttUSHORT(data+index_map+8) >> 1;
|
|
|
+ nk_ushort entrySelector = nk_ttUSHORT(data+index_map+10);
|
|
|
+ nk_ushort rangeShift = nk_ttUSHORT(data+index_map+12) >> 1;
|
|
|
+
|
|
|
+ /* do a binary search of the segments */
|
|
|
+ nk_uint endCount = index_map + 14;
|
|
|
+ nk_uint search = endCount;
|
|
|
+
|
|
|
+ if (unicode_codepoint > 0xffff)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* they lie from endCount .. endCount + segCount */
|
|
|
+ /* but searchRange is the nearest power of two, so... */
|
|
|
+ if (unicode_codepoint >= nk_ttUSHORT(data + search + rangeShift*2))
|
|
|
+ search += (nk_uint)(rangeShift*2);
|
|
|
+
|
|
|
+ /* now decrement to bias correctly to find smallest */
|
|
|
+ search -= 2;
|
|
|
+ while (entrySelector) {
|
|
|
+ nk_ushort end;
|
|
|
+ searchRange >>= 1;
|
|
|
+ end = nk_ttUSHORT(data + search + searchRange*2);
|
|
|
+ if (unicode_codepoint > end)
|
|
|
+ search += (nk_uint)(searchRange*2);
|
|
|
+ --entrySelector;
|
|
|
+ }
|
|
|
+ search += 2;
|
|
|
+
|
|
|
+ {
|
|
|
+ nk_ushort offset, start;
|
|
|
+ nk_ushort item = (nk_ushort) ((search - endCount) >> 1);
|
|
|
+
|
|
|
+ NK_ASSERT(unicode_codepoint <= nk_ttUSHORT(data + endCount + 2*item));
|
|
|
+ start = nk_ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
|
|
|
+ if (unicode_codepoint < start)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ offset = nk_ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
|
|
|
+ if (offset == 0)
|
|
|
+ return (nk_ushort) (unicode_codepoint + nk_ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
|
|
|
+
|
|
|
+ return nk_ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
|
|
|
+ }
|
|
|
+ } else if (format == 12 || format == 13) {
|
|
|
+ nk_uint ngroups = nk_ttULONG(data+index_map+12);
|
|
|
+ nk_int low,high;
|
|
|
+ low = 0; high = (nk_int)ngroups;
|
|
|
+ /* Binary search the right group. */
|
|
|
+ while (low < high) {
|
|
|
+ nk_int mid = low + ((high-low) >> 1); /* rounds down, so low <= mid < high */
|
|
|
+ nk_uint start_char = nk_ttULONG(data+index_map+16+mid*12);
|
|
|
+ nk_uint end_char = nk_ttULONG(data+index_map+16+mid*12+4);
|
|
|
+ if ((nk_uint) unicode_codepoint < start_char)
|
|
|
+ high = mid;
|
|
|
+ else if ((nk_uint) unicode_codepoint > end_char)
|
|
|
+ low = mid+1;
|
|
|
+ else {
|
|
|
+ nk_uint start_glyph = nk_ttULONG(data+index_map+16+mid*12+8);
|
|
|
+ if (format == 12)
|
|
|
+ return (int)start_glyph + (int)unicode_codepoint - (int)start_char;
|
|
|
+ else /* format == 13 */
|
|
|
+ return (int)start_glyph;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0; /* not found */
|
|
|
+ }
|
|
|
+ /* @TODO */
|
|
|
+ NK_ASSERT(0);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_setvertex(struct nk_tt_vertex *v, nk_byte type, nk_int x, nk_int y, nk_int cx, nk_int cy)
|
|
|
+{
|
|
|
+ v->type = type;
|
|
|
+ v->x = (nk_short) x;
|
|
|
+ v->y = (nk_short) y;
|
|
|
+ v->cx = (nk_short) cx;
|
|
|
+ v->cy = (nk_short) cy;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt__GetGlyfOffset(const struct nk_tt_fontinfo *info, int glyph_index)
|
|
|
+{
|
|
|
+ int g1,g2;
|
|
|
+ if (glyph_index >= info->numGlyphs) return -1; /* glyph index out of range */
|
|
|
+ if (info->indexToLocFormat >= 2) return -1; /* unknown index->glyph map format */
|
|
|
+
|
|
|
+ if (info->indexToLocFormat == 0) {
|
|
|
+ g1 = info->glyf + nk_ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
|
|
|
+ g2 = info->glyf + nk_ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
|
|
|
+ } else {
|
|
|
+ g1 = info->glyf + (int)nk_ttULONG (info->data + info->loca + glyph_index * 4);
|
|
|
+ g2 = info->glyf + (int)nk_ttULONG (info->data + info->loca + glyph_index * 4 + 4);
|
|
|
+ }
|
|
|
+ return g1==g2 ? -1 : g1; /* if length is 0, return -1 */
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_GetGlyphBox(const struct nk_tt_fontinfo *info, int glyph_index,
|
|
|
+ int *x0, int *y0, int *x1, int *y1)
|
|
|
+{
|
|
|
+ int g = nk_tt__GetGlyfOffset(info, glyph_index);
|
|
|
+ if (g < 0) return 0;
|
|
|
+
|
|
|
+ if (x0) *x0 = nk_ttSHORT(info->data + g + 2);
|
|
|
+ if (y0) *y0 = nk_ttSHORT(info->data + g + 4);
|
|
|
+ if (x1) *x1 = nk_ttSHORT(info->data + g + 6);
|
|
|
+ if (y1) *y1 = nk_ttSHORT(info->data + g + 8);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+stbtt__close_shape(struct nk_tt_vertex *vertices, int num_vertices, int was_off,
|
|
|
+ int start_off, nk_int sx, nk_int sy, nk_int scx, nk_int scy, nk_int cx, nk_int cy)
|
|
|
+{
|
|
|
+ if (start_off) {
|
|
|
+ if (was_off)
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vcurve, sx,sy,scx,scy);
|
|
|
+ } else {
|
|
|
+ if (was_off)
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vcurve,sx,sy,cx,cy);
|
|
|
+ else
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vline,sx,sy,0,0);
|
|
|
+ }
|
|
|
+ return num_vertices;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_GetGlyphShape(const struct nk_tt_fontinfo *info, struct nk_allocator *alloc,
|
|
|
+ int glyph_index, struct nk_tt_vertex **pvertices)
|
|
|
+{
|
|
|
+ nk_short numberOfContours;
|
|
|
+ const nk_byte *endPtsOfContours;
|
|
|
+ const nk_byte *data = info->data;
|
|
|
+ struct nk_tt_vertex *vertices=0;
|
|
|
+ int num_vertices=0;
|
|
|
+ int g = nk_tt__GetGlyfOffset(info, glyph_index);
|
|
|
+ *pvertices = 0;
|
|
|
+
|
|
|
+ if (g < 0) return 0;
|
|
|
+ numberOfContours = nk_ttSHORT(data + g);
|
|
|
+ if (numberOfContours > 0) {
|
|
|
+ nk_byte flags=0,flagcount;
|
|
|
+ nk_int ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
|
|
|
+ nk_int x,y,cx,cy,sx,sy, scx,scy;
|
|
|
+ const nk_byte *points;
|
|
|
+ endPtsOfContours = (data + g + 10);
|
|
|
+ ins = nk_ttUSHORT(data + g + 10 + numberOfContours * 2);
|
|
|
+ points = data + g + 10 + numberOfContours * 2 + 2 + ins;
|
|
|
+
|
|
|
+ n = 1+nk_ttUSHORT(endPtsOfContours + numberOfContours*2-2);
|
|
|
+ m = n + 2*numberOfContours; /* a loose bound on how many vertices we might need */
|
|
|
+ vertices = (struct nk_tt_vertex *)alloc->alloc(alloc->userdata, 0, (nk_size)m * sizeof(vertices[0]));
|
|
|
+ if (vertices == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ next_move = 0;
|
|
|
+ flagcount=0;
|
|
|
+
|
|
|
+ /* in first pass, we load uninterpreted data into the allocated array */
|
|
|
+ /* above, shifted to the end of the array so we won't overwrite it when */
|
|
|
+ /* we create our final data starting from the front */
|
|
|
+ off = m - n; /* starting offset for uninterpreted data, regardless of how m ends up being calculated */
|
|
|
+
|
|
|
+ /* first load flags */
|
|
|
+ for (i=0; i < n; ++i) {
|
|
|
+ if (flagcount == 0) {
|
|
|
+ flags = *points++;
|
|
|
+ if (flags & 8)
|
|
|
+ flagcount = *points++;
|
|
|
+ } else --flagcount;
|
|
|
+ vertices[off+i].type = flags;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now load x coordinates */
|
|
|
+ x=0;
|
|
|
+ for (i=0; i < n; ++i) {
|
|
|
+ flags = vertices[off+i].type;
|
|
|
+ if (flags & 2) {
|
|
|
+ nk_short dx = *points++;
|
|
|
+ x += (flags & 16) ? dx : -dx; /* ??? */
|
|
|
+ } else {
|
|
|
+ if (!(flags & 16)) {
|
|
|
+ x = x + (nk_short) (points[0]*256 + points[1]);
|
|
|
+ points += 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ vertices[off+i].x = (nk_short) x;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now load y coordinates */
|
|
|
+ y=0;
|
|
|
+ for (i=0; i < n; ++i) {
|
|
|
+ flags = vertices[off+i].type;
|
|
|
+ if (flags & 4) {
|
|
|
+ nk_short dy = *points++;
|
|
|
+ y += (flags & 32) ? dy : -dy; /* ??? */
|
|
|
+ } else {
|
|
|
+ if (!(flags & 32)) {
|
|
|
+ y = y + (nk_short) (points[0]*256 + points[1]);
|
|
|
+ points += 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ vertices[off+i].y = (nk_short) y;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now convert them to our format */
|
|
|
+ num_vertices=0;
|
|
|
+ sx = sy = cx = cy = scx = scy = 0;
|
|
|
+ for (i=0; i < n; ++i)
|
|
|
+ {
|
|
|
+ flags = vertices[off+i].type;
|
|
|
+ x = (nk_short) vertices[off+i].x;
|
|
|
+ y = (nk_short) vertices[off+i].y;
|
|
|
+
|
|
|
+ if (next_move == i) {
|
|
|
+ if (i != 0)
|
|
|
+ num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
|
|
|
+
|
|
|
+ /* now start the new one */
|
|
|
+ start_off = !(flags & 1);
|
|
|
+ if (start_off) {
|
|
|
+ /* if we start off with an off-curve point, then when we need to find a point on the curve */
|
|
|
+ /* where we can start, and we need to save some state for when we wraparound. */
|
|
|
+ scx = x;
|
|
|
+ scy = y;
|
|
|
+ if (!(vertices[off+i+1].type & 1)) {
|
|
|
+ /* next point is also a curve point, so interpolate an on-point curve */
|
|
|
+ sx = (x + (nk_int) vertices[off+i+1].x) >> 1;
|
|
|
+ sy = (y + (nk_int) vertices[off+i+1].y) >> 1;
|
|
|
+ } else {
|
|
|
+ /* otherwise just use the next point as our start point */
|
|
|
+ sx = (nk_int) vertices[off+i+1].x;
|
|
|
+ sy = (nk_int) vertices[off+i+1].y;
|
|
|
+ ++i; /* we're using point i+1 as the starting point, so skip it */
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ sx = x;
|
|
|
+ sy = y;
|
|
|
+ }
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vmove,sx,sy,0,0);
|
|
|
+ was_off = 0;
|
|
|
+ next_move = 1 + nk_ttUSHORT(endPtsOfContours+j*2);
|
|
|
+ ++j;
|
|
|
+ } else {
|
|
|
+ if (!(flags & 1))
|
|
|
+ { /* if it's a curve */
|
|
|
+ if (was_off) /* two off-curve control points in a row means interpolate an on-curve midpoint */
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
|
|
|
+ cx = x;
|
|
|
+ cy = y;
|
|
|
+ was_off = 1;
|
|
|
+ } else {
|
|
|
+ if (was_off)
|
|
|
+ nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vcurve, x,y, cx, cy);
|
|
|
+ else nk_tt_setvertex(&vertices[num_vertices++], NK_TT_vline, x,y,0,0);
|
|
|
+ was_off = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
|
|
|
+ } else if (numberOfContours == -1) {
|
|
|
+ /* Compound shapes. */
|
|
|
+ int more = 1;
|
|
|
+ const nk_byte *comp = data + g + 10;
|
|
|
+ num_vertices = 0;
|
|
|
+ vertices = 0;
|
|
|
+
|
|
|
+ while (more)
|
|
|
+ {
|
|
|
+ nk_ushort flags, gidx;
|
|
|
+ int comp_num_verts = 0, i;
|
|
|
+ struct nk_tt_vertex *comp_verts = 0, *tmp = 0;
|
|
|
+ float mtx[6] = {1,0,0,1,0,0}, m, n;
|
|
|
+
|
|
|
+ flags = (nk_ushort)nk_ttSHORT(comp); comp+=2;
|
|
|
+ gidx = (nk_ushort)nk_ttSHORT(comp); comp+=2;
|
|
|
+
|
|
|
+ if (flags & 2) { /* XY values */
|
|
|
+ if (flags & 1) { /* shorts */
|
|
|
+ mtx[4] = nk_ttSHORT(comp); comp+=2;
|
|
|
+ mtx[5] = nk_ttSHORT(comp); comp+=2;
|
|
|
+ } else {
|
|
|
+ mtx[4] = nk_ttCHAR(comp); comp+=1;
|
|
|
+ mtx[5] = nk_ttCHAR(comp); comp+=1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* @TODO handle matching point */
|
|
|
+ NK_ASSERT(0);
|
|
|
+ }
|
|
|
+ if (flags & (1<<3)) { /* WE_HAVE_A_SCALE */
|
|
|
+ mtx[0] = mtx[3] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ mtx[1] = mtx[2] = 0;
|
|
|
+ } else if (flags & (1<<6)) { /* WE_HAVE_AN_X_AND_YSCALE */
|
|
|
+ mtx[0] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ mtx[1] = mtx[2] = 0;
|
|
|
+ mtx[3] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ } else if (flags & (1<<7)) { /* WE_HAVE_A_TWO_BY_TWO */
|
|
|
+ mtx[0] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ mtx[1] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ mtx[2] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ mtx[3] = nk_ttSHORT(comp)/16384.0f; comp+=2;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Find transformation scales. */
|
|
|
+ m = (float) NK_SQRT(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
|
|
|
+ n = (float) NK_SQRT(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
|
|
|
+
|
|
|
+ /* Get indexed glyph. */
|
|
|
+ comp_num_verts = nk_tt_GetGlyphShape(info, alloc, gidx, &comp_verts);
|
|
|
+ if (comp_num_verts > 0)
|
|
|
+ {
|
|
|
+ /* Transform vertices. */
|
|
|
+ for (i = 0; i < comp_num_verts; ++i) {
|
|
|
+ struct nk_tt_vertex* v = &comp_verts[i];
|
|
|
+ short x,y;
|
|
|
+ x=v->x; y=v->y;
|
|
|
+ v->x = (short)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
|
|
|
+ v->y = (short)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
|
|
|
+ x=v->cx; y=v->cy;
|
|
|
+ v->cx = (short)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
|
|
|
+ v->cy = (short)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
|
|
|
+ }
|
|
|
+ /* Append vertices. */
|
|
|
+ tmp = (struct nk_tt_vertex*)alloc->alloc(alloc->userdata, 0,
|
|
|
+ (nk_size)(num_vertices+comp_num_verts)*sizeof(struct nk_tt_vertex));
|
|
|
+ if (!tmp) {
|
|
|
+ if (vertices) alloc->free(alloc->userdata, vertices);
|
|
|
+ if (comp_verts) alloc->free(alloc->userdata, comp_verts);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (num_vertices > 0) NK_MEMCPY(tmp, vertices, (nk_size)num_vertices*sizeof(struct nk_tt_vertex));
|
|
|
+ NK_MEMCPY(tmp+num_vertices, comp_verts, (nk_size)comp_num_verts*sizeof(struct nk_tt_vertex));
|
|
|
+ if (vertices) alloc->free(alloc->userdata,vertices);
|
|
|
+ vertices = tmp;
|
|
|
+ alloc->free(alloc->userdata,comp_verts);
|
|
|
+ num_vertices += comp_num_verts;
|
|
|
+ }
|
|
|
+ /* More components ? */
|
|
|
+ more = flags & (1<<5);
|
|
|
+ }
|
|
|
+ } else if (numberOfContours < 0) {
|
|
|
+ /* @TODO other compound variations? */
|
|
|
+ NK_ASSERT(0);
|
|
|
+ } else {
|
|
|
+ /* numberOfCounters == 0, do nothing */
|
|
|
+ }
|
|
|
+ *pvertices = vertices;
|
|
|
+ return num_vertices;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_GetGlyphHMetrics(const struct nk_tt_fontinfo *info, int glyph_index,
|
|
|
+ int *advanceWidth, int *leftSideBearing)
|
|
|
+{
|
|
|
+ nk_ushort numOfLongHorMetrics = nk_ttUSHORT(info->data+info->hhea + 34);
|
|
|
+ if (glyph_index < numOfLongHorMetrics) {
|
|
|
+ if (advanceWidth)
|
|
|
+ *advanceWidth = nk_ttSHORT(info->data + info->hmtx + 4*glyph_index);
|
|
|
+ if (leftSideBearing)
|
|
|
+ *leftSideBearing = nk_ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
|
|
|
+ } else {
|
|
|
+ if (advanceWidth)
|
|
|
+ *advanceWidth = nk_ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
|
|
|
+ if (leftSideBearing)
|
|
|
+ *leftSideBearing = nk_ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_GetFontVMetrics(const struct nk_tt_fontinfo *info,
|
|
|
+ int *ascent, int *descent, int *lineGap)
|
|
|
+{
|
|
|
+ if (ascent ) *ascent = nk_ttSHORT(info->data+info->hhea + 4);
|
|
|
+ if (descent) *descent = nk_ttSHORT(info->data+info->hhea + 6);
|
|
|
+ if (lineGap) *lineGap = nk_ttSHORT(info->data+info->hhea + 8);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_tt_ScaleForPixelHeight(const struct nk_tt_fontinfo *info, float height)
|
|
|
+{
|
|
|
+ int fheight = nk_ttSHORT(info->data + info->hhea + 4) - nk_ttSHORT(info->data + info->hhea + 6);
|
|
|
+ return (float) height / (float)fheight;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_tt_ScaleForMappingEmToPixels(const struct nk_tt_fontinfo *info, float pixels)
|
|
|
+{
|
|
|
+ int unitsPerEm = nk_ttUSHORT(info->data + info->head + 18);
|
|
|
+ return pixels / (float)unitsPerEm;
|
|
|
+}
|
|
|
+
|
|
|
+/*-------------------------------------------------------------
|
|
|
+ * antialiasing software rasterizer
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_GetGlyphBitmapBoxSubpixel(const struct nk_tt_fontinfo *font,
|
|
|
+ int glyph, float scale_x, float scale_y,float shift_x, float shift_y,
|
|
|
+ int *ix0, int *iy0, int *ix1, int *iy1)
|
|
|
+{
|
|
|
+ int x0,y0,x1,y1;
|
|
|
+ if (!nk_tt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
|
|
|
+ /* e.g. space character */
|
|
|
+ if (ix0) *ix0 = 0;
|
|
|
+ if (iy0) *iy0 = 0;
|
|
|
+ if (ix1) *ix1 = 0;
|
|
|
+ if (iy1) *iy1 = 0;
|
|
|
+ } else {
|
|
|
+ /* move to integral bboxes (treating pixels as little squares, what pixels get touched)? */
|
|
|
+ if (ix0) *ix0 = nk_ifloorf((float)x0 * scale_x + shift_x);
|
|
|
+ if (iy0) *iy0 = nk_ifloorf((float)-y1 * scale_y + shift_y);
|
|
|
+ if (ix1) *ix1 = nk_iceilf ((float)x1 * scale_x + shift_x);
|
|
|
+ if (iy1) *iy1 = nk_iceilf ((float)-y0 * scale_y + shift_y);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_GetGlyphBitmapBox(const struct nk_tt_fontinfo *font, int glyph,
|
|
|
+ float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
|
|
|
+{
|
|
|
+ nk_tt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1);
|
|
|
+}
|
|
|
+
|
|
|
+/*-------------------------------------------------------------
|
|
|
+ * Rasterizer
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN void*
|
|
|
+nk_tt__hheap_alloc(struct nk_tt__hheap *hh, nk_size size)
|
|
|
+{
|
|
|
+ if (hh->first_free) {
|
|
|
+ void *p = hh->first_free;
|
|
|
+ hh->first_free = * (void **) p;
|
|
|
+ return p;
|
|
|
+ } else {
|
|
|
+ if (hh->num_remaining_in_head_chunk == 0) {
|
|
|
+ int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
|
|
|
+ struct nk_tt__hheap_chunk *c = (struct nk_tt__hheap_chunk *)
|
|
|
+ hh->alloc.alloc(hh->alloc.userdata, 0,
|
|
|
+ sizeof(struct nk_tt__hheap_chunk) + size * (nk_size)count);
|
|
|
+ if (c == 0) return 0;
|
|
|
+ c->next = hh->head;
|
|
|
+ hh->head = c;
|
|
|
+ hh->num_remaining_in_head_chunk = count;
|
|
|
+ }
|
|
|
+ --hh->num_remaining_in_head_chunk;
|
|
|
+ return (char *) (hh->head) + size * (nk_size)hh->num_remaining_in_head_chunk;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__hheap_free(struct nk_tt__hheap *hh, void *p)
|
|
|
+{
|
|
|
+ *(void **) p = hh->first_free;
|
|
|
+ hh->first_free = p;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__hheap_cleanup(struct nk_tt__hheap *hh)
|
|
|
+{
|
|
|
+ struct nk_tt__hheap_chunk *c = hh->head;
|
|
|
+ while (c) {
|
|
|
+ struct nk_tt__hheap_chunk *n = c->next;
|
|
|
+ hh->alloc.free(hh->alloc.userdata, c);
|
|
|
+ c = n;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_tt__active_edge*
|
|
|
+nk_tt__new_active(struct nk_tt__hheap *hh, struct nk_tt__edge *e,
|
|
|
+ int off_x, float start_point)
|
|
|
+{
|
|
|
+ struct nk_tt__active_edge *z = (struct nk_tt__active_edge *)
|
|
|
+ nk_tt__hheap_alloc(hh, sizeof(*z));
|
|
|
+ float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
|
|
|
+ /*STBTT_assert(e->y0 <= start_point); */
|
|
|
+ if (!z) return z;
|
|
|
+ z->fdx = dxdy;
|
|
|
+ z->fdy = (dxdy != 0) ? (1/dxdy): 0;
|
|
|
+ z->fx = e->x0 + dxdy * (start_point - e->y0);
|
|
|
+ z->fx -= (float)off_x;
|
|
|
+ z->direction = e->invert ? 1.0f : -1.0f;
|
|
|
+ z->sy = e->y0;
|
|
|
+ z->ey = e->y1;
|
|
|
+ z->next = 0;
|
|
|
+ return z;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__handle_clipped_edge(float *scanline, int x, struct nk_tt__active_edge *e,
|
|
|
+ float x0, float y0, float x1, float y1)
|
|
|
+{
|
|
|
+ if (y0 == y1) return;
|
|
|
+ NK_ASSERT(y0 < y1);
|
|
|
+ NK_ASSERT(e->sy <= e->ey);
|
|
|
+ if (y0 > e->ey) return;
|
|
|
+ if (y1 < e->sy) return;
|
|
|
+ if (y0 < e->sy) {
|
|
|
+ x0 += (x1-x0) * (e->sy - y0) / (y1-y0);
|
|
|
+ y0 = e->sy;
|
|
|
+ }
|
|
|
+ if (y1 > e->ey) {
|
|
|
+ x1 += (x1-x0) * (e->ey - y1) / (y1-y0);
|
|
|
+ y1 = e->ey;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (x0 == x) NK_ASSERT(x1 <= x+1);
|
|
|
+ else if (x0 == x+1) NK_ASSERT(x1 >= x);
|
|
|
+ else if (x0 <= x) NK_ASSERT(x1 <= x);
|
|
|
+ else if (x0 >= x+1) NK_ASSERT(x1 >= x+1);
|
|
|
+ else NK_ASSERT(x1 >= x && x1 <= x+1);
|
|
|
+
|
|
|
+ if (x0 <= x && x1 <= x)
|
|
|
+ scanline[x] += e->direction * (y1-y0);
|
|
|
+ else if (x0 >= x+1 && x1 >= x+1);
|
|
|
+ else {
|
|
|
+ NK_ASSERT(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1);
|
|
|
+ /* coverage = 1 - average x position */
|
|
|
+ scanline[x] += (float)e->direction * (float)(y1-y0) * (1.0f-((x0-(float)x)+(x1-(float)x))/2.0f);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__fill_active_edges_new(float *scanline, float *scanline_fill, int len,
|
|
|
+ struct nk_tt__active_edge *e, float y_top)
|
|
|
+{
|
|
|
+ float y_bottom = y_top+1;
|
|
|
+ while (e)
|
|
|
+ {
|
|
|
+ /* brute force every pixel */
|
|
|
+ /* compute intersection points with top & bottom */
|
|
|
+ NK_ASSERT(e->ey >= y_top);
|
|
|
+ if (e->fdx == 0) {
|
|
|
+ float x0 = e->fx;
|
|
|
+ if (x0 < len) {
|
|
|
+ if (x0 >= 0) {
|
|
|
+ nk_tt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom);
|
|
|
+ nk_tt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom);
|
|
|
+ } else {
|
|
|
+ nk_tt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ float x0 = e->fx;
|
|
|
+ float dx = e->fdx;
|
|
|
+ float xb = x0 + dx;
|
|
|
+ float x_top, x_bottom;
|
|
|
+ float y0,y1;
|
|
|
+ float dy = e->fdy;
|
|
|
+ NK_ASSERT(e->sy <= y_bottom && e->ey >= y_top);
|
|
|
+
|
|
|
+ /* compute endpoints of line segment clipped to this scanline (if the */
|
|
|
+ /* line segment starts on this scanline. x0 is the intersection of the */
|
|
|
+ /* line with y_top, but that may be off the line segment. */
|
|
|
+ if (e->sy > y_top) {
|
|
|
+ x_top = x0 + dx * (e->sy - y_top);
|
|
|
+ y0 = e->sy;
|
|
|
+ } else {
|
|
|
+ x_top = x0;
|
|
|
+ y0 = y_top;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (e->ey < y_bottom) {
|
|
|
+ x_bottom = x0 + dx * (e->ey - y_top);
|
|
|
+ y1 = e->ey;
|
|
|
+ } else {
|
|
|
+ x_bottom = xb;
|
|
|
+ y1 = y_bottom;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len)
|
|
|
+ {
|
|
|
+ /* from here on, we don't have to range check x values */
|
|
|
+ if ((int) x_top == (int) x_bottom) {
|
|
|
+ float height;
|
|
|
+ /* simple case, only spans one pixel */
|
|
|
+ int x = (int) x_top;
|
|
|
+ height = y1 - y0;
|
|
|
+ NK_ASSERT(x >= 0 && x < len);
|
|
|
+ scanline[x] += e->direction * (1.0f-(((float)x_top - (float)x) + ((float)x_bottom-(float)x))/2.0f) * (float)height;
|
|
|
+ scanline_fill[x] += e->direction * (float)height; /* everything right of this pixel is filled */
|
|
|
+ } else {
|
|
|
+ int x,x1,x2;
|
|
|
+ float y_crossing, step, sign, area;
|
|
|
+ /* covers 2+ pixels */
|
|
|
+ if (x_top > x_bottom)
|
|
|
+ {
|
|
|
+ /* flip scanline vertically; signed area is the same */
|
|
|
+ float t;
|
|
|
+ y0 = y_bottom - (y0 - y_top);
|
|
|
+ y1 = y_bottom - (y1 - y_top);
|
|
|
+ t = y0; y0 = y1; y1 = t;
|
|
|
+ t = x_bottom; x_bottom = x_top; x_top = t;
|
|
|
+ dx = -dx;
|
|
|
+ dy = -dy;
|
|
|
+ t = x0; x0 = xb; xb = t;
|
|
|
+ }
|
|
|
+
|
|
|
+ x1 = (int) x_top;
|
|
|
+ x2 = (int) x_bottom;
|
|
|
+ /* compute intersection with y axis at x1+1 */
|
|
|
+ y_crossing = ((float)x1+1 - (float)x0) * (float)dy + (float)y_top;
|
|
|
+
|
|
|
+ sign = e->direction;
|
|
|
+ /* area of the rectangle covered from y0..y_crossing */
|
|
|
+ area = sign * (y_crossing-y0);
|
|
|
+ /* area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing) */
|
|
|
+ scanline[x1] += area * (1.0f-((float)((float)x_top - (float)x1)+(float)(x1+1-x1))/2.0f);
|
|
|
+
|
|
|
+ step = sign * dy;
|
|
|
+ for (x = x1+1; x < x2; ++x) {
|
|
|
+ scanline[x] += area + step/2;
|
|
|
+ area += step;
|
|
|
+ }
|
|
|
+ y_crossing += (float)dy * (float)(x2 - (x1+1));
|
|
|
+
|
|
|
+ scanline[x2] += area + sign * (1.0f-((float)(x2-x2)+((float)x_bottom-(float)x2))/2.0f) * (y1-y_crossing);
|
|
|
+ scanline_fill[x2] += sign * (y1-y0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* if edge goes outside of box we're drawing, we require */
|
|
|
+ /* clipping logic. since this does not match the intended use */
|
|
|
+ /* of this library, we use a different, very slow brute */
|
|
|
+ /* force implementation */
|
|
|
+ int x;
|
|
|
+ for (x=0; x < len; ++x)
|
|
|
+ {
|
|
|
+ /* cases: */
|
|
|
+ /* */
|
|
|
+ /* there can be up to two intersections with the pixel. any intersection */
|
|
|
+ /* with left or right edges can be handled by splitting into two (or three) */
|
|
|
+ /* regions. intersections with top & bottom do not necessitate case-wise logic. */
|
|
|
+ /* */
|
|
|
+ /* the old way of doing this found the intersections with the left & right edges, */
|
|
|
+ /* then used some simple logic to produce up to three segments in sorted order */
|
|
|
+ /* from top-to-bottom. however, this had a problem: if an x edge was epsilon */
|
|
|
+ /* across the x border, then the corresponding y position might not be distinct */
|
|
|
+ /* from the other y segment, and it might ignored as an empty segment. to avoid */
|
|
|
+ /* that, we need to explicitly produce segments based on x positions. */
|
|
|
+
|
|
|
+ /* rename variables to clear pairs */
|
|
|
+ float ya = y_top;
|
|
|
+ float x1 = (float) (x);
|
|
|
+ float x2 = (float) (x+1);
|
|
|
+ float x3 = xb;
|
|
|
+ float y3 = y_bottom;
|
|
|
+ float yb,y2;
|
|
|
+
|
|
|
+ yb = ((float)x - x0) / dx + y_top;
|
|
|
+ y2 = ((float)x+1 - x0) / dx + y_top;
|
|
|
+
|
|
|
+ if (x0 < x1 && x3 > x2) { /* three segments descending down-right */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x1,yb);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x1,yb, x2,y2);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
|
|
|
+ } else if (x3 < x1 && x0 > x2) { /* three segments descending down-left */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x2,y2);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x2,y2, x1,yb);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x1,yb, x3,y3);
|
|
|
+ } else if (x0 < x1 && x3 > x1) { /* two segments across x, down-right */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x1,yb);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x1,yb, x3,y3);
|
|
|
+ } else if (x3 < x1 && x0 > x1) { /* two segments across x, down-left */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x1,yb);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x1,yb, x3,y3);
|
|
|
+ } else if (x0 < x2 && x3 > x2) { /* two segments across x+1, down-right */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x2,y2);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
|
|
|
+ } else if (x3 < x2 && x0 > x2) { /* two segments across x+1, down-left */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x2,y2);
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
|
|
|
+ } else { /* one segment */
|
|
|
+ nk_tt__handle_clipped_edge(scanline,x,e, x0,ya, x3,y3);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ e = e->next;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* directly AA rasterize edges w/o supersampling */
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__rasterize_sorted_edges(struct nk_tt__bitmap *result, struct nk_tt__edge *e,
|
|
|
+ int n, int vsubsample, int off_x, int off_y, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ struct nk_tt__hheap hh;
|
|
|
+ struct nk_tt__active_edge *active = 0;
|
|
|
+ int y,j=0, i;
|
|
|
+ float scanline_data[129], *scanline, *scanline2;
|
|
|
+
|
|
|
+ NK_UNUSED(vsubsample);
|
|
|
+ nk_zero_struct(hh);
|
|
|
+ hh.alloc = *alloc;
|
|
|
+
|
|
|
+ if (result->w > 64)
|
|
|
+ scanline = (float *) alloc->alloc(alloc->userdata,0, (nk_size)(result->w*2+1) * sizeof(float));
|
|
|
+ else scanline = scanline_data;
|
|
|
+
|
|
|
+ scanline2 = scanline + result->w;
|
|
|
+ y = off_y;
|
|
|
+ e[n].y0 = (float) (off_y + result->h) + 1;
|
|
|
+
|
|
|
+ while (j < result->h)
|
|
|
+ {
|
|
|
+ /* find center of pixel for this scanline */
|
|
|
+ float scan_y_top = (float)y + 0.0f;
|
|
|
+ float scan_y_bottom = (float)y + 1.0f;
|
|
|
+ struct nk_tt__active_edge **step = &active;
|
|
|
+
|
|
|
+ NK_MEMSET(scanline , 0, (nk_size)result->w*sizeof(scanline[0]));
|
|
|
+ NK_MEMSET(scanline2, 0, (nk_size)(result->w+1)*sizeof(scanline[0]));
|
|
|
+
|
|
|
+ /* update all active edges; */
|
|
|
+ /* remove all active edges that terminate before the top of this scanline */
|
|
|
+ while (*step) {
|
|
|
+ struct nk_tt__active_edge * z = *step;
|
|
|
+ if (z->ey <= scan_y_top) {
|
|
|
+ *step = z->next; /* delete from list */
|
|
|
+ NK_ASSERT(z->direction);
|
|
|
+ z->direction = 0;
|
|
|
+ nk_tt__hheap_free(&hh, z);
|
|
|
+ } else {
|
|
|
+ step = &((*step)->next); /* advance through list */
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* insert all edges that start before the bottom of this scanline */
|
|
|
+ while (e->y0 <= scan_y_bottom) {
|
|
|
+ if (e->y0 != e->y1) {
|
|
|
+ struct nk_tt__active_edge *z = nk_tt__new_active(&hh, e, off_x, scan_y_top);
|
|
|
+ if (z != 0) {
|
|
|
+ NK_ASSERT(z->ey >= scan_y_top);
|
|
|
+ /* insert at front */
|
|
|
+ z->next = active;
|
|
|
+ active = z;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ++e;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now process all active edges */
|
|
|
+ if (active)
|
|
|
+ nk_tt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top);
|
|
|
+
|
|
|
+ {
|
|
|
+ float sum = 0;
|
|
|
+ for (i=0; i < result->w; ++i) {
|
|
|
+ float k;
|
|
|
+ int m;
|
|
|
+ sum += scanline2[i];
|
|
|
+ k = scanline[i] + sum;
|
|
|
+ k = (float) NK_ABS(k) * 255.0f + 0.5f;
|
|
|
+ m = (int) k;
|
|
|
+ if (m > 255) m = 255;
|
|
|
+ result->pixels[j*result->stride + i] = (unsigned char) m;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* advance all the edges */
|
|
|
+ step = &active;
|
|
|
+ while (*step) {
|
|
|
+ struct nk_tt__active_edge *z = *step;
|
|
|
+ z->fx += z->fdx; /* advance to position for current scanline */
|
|
|
+ step = &((*step)->next); /* advance through list */
|
|
|
+ }
|
|
|
+ ++y;
|
|
|
+ ++j;
|
|
|
+ }
|
|
|
+ nk_tt__hheap_cleanup(&hh);
|
|
|
+ if (scanline != scanline_data)
|
|
|
+ alloc->free(alloc->userdata, scanline);
|
|
|
+}
|
|
|
+
|
|
|
+#define NK_TT__COMPARE(a,b) ((a)->y0 < (b)->y0)
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__sort_edges_ins_sort(struct nk_tt__edge *p, int n)
|
|
|
+{
|
|
|
+ int i,j;
|
|
|
+ for (i=1; i < n; ++i) {
|
|
|
+ struct nk_tt__edge t = p[i], *a = &t;
|
|
|
+ j = i;
|
|
|
+ while (j > 0) {
|
|
|
+ struct nk_tt__edge *b = &p[j-1];
|
|
|
+ int c = NK_TT__COMPARE(a,b);
|
|
|
+ if (!c) break;
|
|
|
+ p[j] = p[j-1];
|
|
|
+ --j;
|
|
|
+ }
|
|
|
+ if (i != j)
|
|
|
+ p[j] = t;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__sort_edges_quicksort(struct nk_tt__edge *p, int n)
|
|
|
+{
|
|
|
+ /* threshold for transitioning to insertion sort */
|
|
|
+ while (n > 12) {
|
|
|
+ struct nk_tt__edge t;
|
|
|
+ int c01,c12,c,m,i,j;
|
|
|
+
|
|
|
+ /* compute median of three */
|
|
|
+ m = n >> 1;
|
|
|
+ c01 = NK_TT__COMPARE(&p[0],&p[m]);
|
|
|
+ c12 = NK_TT__COMPARE(&p[m],&p[n-1]);
|
|
|
+
|
|
|
+ /* if 0 >= mid >= end, or 0 < mid < end, then use mid */
|
|
|
+ if (c01 != c12) {
|
|
|
+ /* otherwise, we'll need to swap something else to middle */
|
|
|
+ int z;
|
|
|
+ c = NK_TT__COMPARE(&p[0],&p[n-1]);
|
|
|
+ /* 0>mid && mid<n: 0>n => n; 0<n => 0 */
|
|
|
+ /* 0<mid && mid>n: 0>n => 0; 0<n => n */
|
|
|
+ z = (c == c12) ? 0 : n-1;
|
|
|
+ t = p[z];
|
|
|
+ p[z] = p[m];
|
|
|
+ p[m] = t;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now p[m] is the median-of-three */
|
|
|
+ /* swap it to the beginning so it won't move around */
|
|
|
+ t = p[0];
|
|
|
+ p[0] = p[m];
|
|
|
+ p[m] = t;
|
|
|
+
|
|
|
+ /* partition loop */
|
|
|
+ i=1;
|
|
|
+ j=n-1;
|
|
|
+ for(;;) {
|
|
|
+ /* handling of equality is crucial here */
|
|
|
+ /* for sentinels & efficiency with duplicates */
|
|
|
+ for (;;++i) {
|
|
|
+ if (!NK_TT__COMPARE(&p[i], &p[0])) break;
|
|
|
+ }
|
|
|
+ for (;;--j) {
|
|
|
+ if (!NK_TT__COMPARE(&p[0], &p[j])) break;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* make sure we haven't crossed */
|
|
|
+ if (i >= j) break;
|
|
|
+ t = p[i];
|
|
|
+ p[i] = p[j];
|
|
|
+ p[j] = t;
|
|
|
+
|
|
|
+ ++i;
|
|
|
+ --j;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /* recurse on smaller side, iterate on larger */
|
|
|
+ if (j < (n-i)) {
|
|
|
+ nk_tt__sort_edges_quicksort(p,j);
|
|
|
+ p = p+i;
|
|
|
+ n = n-i;
|
|
|
+ } else {
|
|
|
+ nk_tt__sort_edges_quicksort(p+i, n-i);
|
|
|
+ n = j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__sort_edges(struct nk_tt__edge *p, int n)
|
|
|
+{
|
|
|
+ nk_tt__sort_edges_quicksort(p, n);
|
|
|
+ nk_tt__sort_edges_ins_sort(p, n);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__rasterize(struct nk_tt__bitmap *result, struct nk_tt__point *pts,
|
|
|
+ int *wcount, int windings, float scale_x, float scale_y,
|
|
|
+ float shift_x, float shift_y, int off_x, int off_y, int invert,
|
|
|
+ struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ float y_scale_inv = invert ? -scale_y : scale_y;
|
|
|
+ struct nk_tt__edge *e;
|
|
|
+ int n,i,j,k,m;
|
|
|
+ int vsubsample = 1;
|
|
|
+ /* vsubsample should divide 255 evenly; otherwise we won't reach full opacity */
|
|
|
+
|
|
|
+ /* now we have to blow out the windings into explicit edge lists */
|
|
|
+ n = 0;
|
|
|
+ for (i=0; i < windings; ++i)
|
|
|
+ n += wcount[i];
|
|
|
+
|
|
|
+ e = (struct nk_tt__edge*)
|
|
|
+ alloc->alloc(alloc->userdata, 0,(sizeof(*e) * (nk_size)(n+1)));
|
|
|
+ if (e == 0) return;
|
|
|
+ n = 0;
|
|
|
+
|
|
|
+ m=0;
|
|
|
+ for (i=0; i < windings; ++i)
|
|
|
+ {
|
|
|
+ struct nk_tt__point *p = pts + m;
|
|
|
+ m += wcount[i];
|
|
|
+ j = wcount[i]-1;
|
|
|
+ for (k=0; k < wcount[i]; j=k++) {
|
|
|
+ int a=k,b=j;
|
|
|
+ /* skip the edge if horizontal */
|
|
|
+ if (p[j].y == p[k].y)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ /* add edge from j to k to the list */
|
|
|
+ e[n].invert = 0;
|
|
|
+ if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) {
|
|
|
+ e[n].invert = 1;
|
|
|
+ a=j,b=k;
|
|
|
+ }
|
|
|
+ e[n].x0 = p[a].x * scale_x + shift_x;
|
|
|
+ e[n].y0 = (p[a].y * y_scale_inv + shift_y) * (float)vsubsample;
|
|
|
+ e[n].x1 = p[b].x * scale_x + shift_x;
|
|
|
+ e[n].y1 = (p[b].y * y_scale_inv + shift_y) * (float)vsubsample;
|
|
|
+ ++n;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now sort the edges by their highest point (should snap to integer, and then by x) */
|
|
|
+ /*STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); */
|
|
|
+ nk_tt__sort_edges(e, n);
|
|
|
+ /* now, traverse the scanlines and find the intersections on each scanline, use xor winding rule */
|
|
|
+ nk_tt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, alloc);
|
|
|
+ alloc->free(alloc->userdata, e);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__add_point(struct nk_tt__point *points, int n, float x, float y)
|
|
|
+{
|
|
|
+ if (!points) return; /* during first pass, it's unallocated */
|
|
|
+ points[n].x = x;
|
|
|
+ points[n].y = y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt__tesselate_curve(struct nk_tt__point *points, int *num_points,
|
|
|
+ float x0, float y0, float x1, float y1, float x2, float y2,
|
|
|
+ float objspace_flatness_squared, int n)
|
|
|
+{
|
|
|
+ /* tesselate until threshold p is happy...
|
|
|
+ * @TODO warped to compensate for non-linear stretching */
|
|
|
+ /* midpoint */
|
|
|
+ float mx = (x0 + 2*x1 + x2)/4;
|
|
|
+ float my = (y0 + 2*y1 + y2)/4;
|
|
|
+ /* versus directly drawn line */
|
|
|
+ float dx = (x0+x2)/2 - mx;
|
|
|
+ float dy = (y0+y2)/2 - my;
|
|
|
+ if (n > 16) /* 65536 segments on one curve better be enough! */
|
|
|
+ return 1;
|
|
|
+
|
|
|
+ /* half-pixel error allowed... need to be smaller if AA */
|
|
|
+ if (dx*dx+dy*dy > objspace_flatness_squared) {
|
|
|
+ nk_tt__tesselate_curve(points, num_points, x0,y0,
|
|
|
+ (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
|
|
|
+ nk_tt__tesselate_curve(points, num_points, mx,my,
|
|
|
+ (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
|
|
|
+ } else {
|
|
|
+ nk_tt__add_point(points, *num_points,x2,y2);
|
|
|
+ *num_points = *num_points+1;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* returns number of contours */
|
|
|
+NK_INTERN struct nk_tt__point*
|
|
|
+nk_tt_FlattenCurves(struct nk_tt_vertex *vertices, int num_verts,
|
|
|
+ float objspace_flatness, int **contour_lengths, int *num_contours,
|
|
|
+ struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ struct nk_tt__point *points=0;
|
|
|
+ int num_points=0;
|
|
|
+ float objspace_flatness_squared = objspace_flatness * objspace_flatness;
|
|
|
+ int i;
|
|
|
+ int n=0;
|
|
|
+ int start=0;
|
|
|
+ int pass;
|
|
|
+
|
|
|
+ /* count how many "moves" there are to get the contour count */
|
|
|
+ for (i=0; i < num_verts; ++i)
|
|
|
+ if (vertices[i].type == NK_TT_vmove) ++n;
|
|
|
+
|
|
|
+ *num_contours = n;
|
|
|
+ if (n == 0) return 0;
|
|
|
+
|
|
|
+ *contour_lengths = (int *)
|
|
|
+ alloc->alloc(alloc->userdata,0, (sizeof(**contour_lengths) * (nk_size)n));
|
|
|
+ if (*contour_lengths == 0) {
|
|
|
+ *num_contours = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* make two passes through the points so we don't need to realloc */
|
|
|
+ for (pass=0; pass < 2; ++pass)
|
|
|
+ {
|
|
|
+ float x=0,y=0;
|
|
|
+ if (pass == 1) {
|
|
|
+ points = (struct nk_tt__point *)
|
|
|
+ alloc->alloc(alloc->userdata,0, (nk_size)num_points * sizeof(points[0]));
|
|
|
+ if (points == 0) goto error;
|
|
|
+ }
|
|
|
+ num_points = 0;
|
|
|
+ n= -1;
|
|
|
+
|
|
|
+ for (i=0; i < num_verts; ++i)
|
|
|
+ {
|
|
|
+ switch (vertices[i].type) {
|
|
|
+ case NK_TT_vmove:
|
|
|
+ /* start the next contour */
|
|
|
+ if (n >= 0)
|
|
|
+ (*contour_lengths)[n] = num_points - start;
|
|
|
+ ++n;
|
|
|
+ start = num_points;
|
|
|
+
|
|
|
+ x = vertices[i].x, y = vertices[i].y;
|
|
|
+ nk_tt__add_point(points, num_points++, x,y);
|
|
|
+ break;
|
|
|
+ case NK_TT_vline:
|
|
|
+ x = vertices[i].x, y = vertices[i].y;
|
|
|
+ nk_tt__add_point(points, num_points++, x, y);
|
|
|
+ break;
|
|
|
+ case NK_TT_vcurve:
|
|
|
+ nk_tt__tesselate_curve(points, &num_points, x,y,
|
|
|
+ vertices[i].cx, vertices[i].cy,
|
|
|
+ vertices[i].x, vertices[i].y,
|
|
|
+ objspace_flatness_squared, 0);
|
|
|
+ x = vertices[i].x, y = vertices[i].y;
|
|
|
+ break;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ (*contour_lengths)[n] = num_points - start;
|
|
|
+ }
|
|
|
+ return points;
|
|
|
+
|
|
|
+error:
|
|
|
+ alloc->free(alloc->userdata, points);
|
|
|
+ alloc->free(alloc->userdata, *contour_lengths);
|
|
|
+ *contour_lengths = 0;
|
|
|
+ *num_contours = 0;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_Rasterize(struct nk_tt__bitmap *result, float flatness_in_pixels,
|
|
|
+ struct nk_tt_vertex *vertices, int num_verts,
|
|
|
+ float scale_x, float scale_y, float shift_x, float shift_y,
|
|
|
+ int x_off, int y_off, int invert, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ float scale = scale_x > scale_y ? scale_y : scale_x;
|
|
|
+ int winding_count, *winding_lengths;
|
|
|
+ struct nk_tt__point *windings = nk_tt_FlattenCurves(vertices, num_verts,
|
|
|
+ flatness_in_pixels / scale, &winding_lengths, &winding_count, alloc);
|
|
|
+
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+ if (windings) {
|
|
|
+ nk_tt__rasterize(result, windings, winding_lengths, winding_count,
|
|
|
+ scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, alloc);
|
|
|
+ alloc->free(alloc->userdata, winding_lengths);
|
|
|
+ alloc->free(alloc->userdata, windings);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_MakeGlyphBitmapSubpixel(const struct nk_tt_fontinfo *info, unsigned char *output,
|
|
|
+ int out_w, int out_h, int out_stride, float scale_x, float scale_y,
|
|
|
+ float shift_x, float shift_y, int glyph, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ int ix0,iy0;
|
|
|
+ struct nk_tt_vertex *vertices;
|
|
|
+ int num_verts = nk_tt_GetGlyphShape(info, alloc, glyph, &vertices);
|
|
|
+ struct nk_tt__bitmap gbm;
|
|
|
+
|
|
|
+ nk_tt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x,
|
|
|
+ shift_y, &ix0,&iy0,0,0);
|
|
|
+ gbm.pixels = output;
|
|
|
+ gbm.w = out_w;
|
|
|
+ gbm.h = out_h;
|
|
|
+ gbm.stride = out_stride;
|
|
|
+
|
|
|
+ if (gbm.w && gbm.h)
|
|
|
+ nk_tt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y,
|
|
|
+ shift_x, shift_y, ix0,iy0, 1, alloc);
|
|
|
+ alloc->free(alloc->userdata, vertices);
|
|
|
+}
|
|
|
+
|
|
|
+/*-------------------------------------------------------------
|
|
|
+ * Bitmap baking
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_PackBegin(struct nk_tt_pack_context *spc, unsigned char *pixels,
|
|
|
+ int pw, int ph, int stride_in_bytes, int padding, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ int num_nodes = pw - padding;
|
|
|
+ struct nk_rp_context *context = (struct nk_rp_context *)
|
|
|
+ alloc->alloc(alloc->userdata,0, sizeof(*context));
|
|
|
+ struct nk_rp_node *nodes = (struct nk_rp_node*)
|
|
|
+ alloc->alloc(alloc->userdata,0, (sizeof(*nodes ) * (nk_size)num_nodes));
|
|
|
+
|
|
|
+ if (context == 0 || nodes == 0) {
|
|
|
+ if (context != 0) alloc->free(alloc->userdata, context);
|
|
|
+ if (nodes != 0) alloc->free(alloc->userdata, nodes);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ spc->width = pw;
|
|
|
+ spc->height = ph;
|
|
|
+ spc->pixels = pixels;
|
|
|
+ spc->pack_info = context;
|
|
|
+ spc->nodes = nodes;
|
|
|
+ spc->padding = padding;
|
|
|
+ spc->stride_in_bytes = (stride_in_bytes != 0) ? stride_in_bytes : pw;
|
|
|
+ spc->h_oversample = 1;
|
|
|
+ spc->v_oversample = 1;
|
|
|
+
|
|
|
+ nk_rp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);
|
|
|
+ if (pixels)
|
|
|
+ NK_MEMSET(pixels, 0, (nk_size)(pw*ph)); /* background of 0 around pixels */
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_PackEnd(struct nk_tt_pack_context *spc, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ alloc->free(alloc->userdata, spc->nodes);
|
|
|
+ alloc->free(alloc->userdata, spc->pack_info);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_PackSetOversampling(struct nk_tt_pack_context *spc,
|
|
|
+ unsigned int h_oversample, unsigned int v_oversample)
|
|
|
+{
|
|
|
+ NK_ASSERT(h_oversample <= NK_TT_MAX_OVERSAMPLE);
|
|
|
+ NK_ASSERT(v_oversample <= NK_TT_MAX_OVERSAMPLE);
|
|
|
+ if (h_oversample <= NK_TT_MAX_OVERSAMPLE)
|
|
|
+ spc->h_oversample = h_oversample;
|
|
|
+ if (v_oversample <= NK_TT_MAX_OVERSAMPLE)
|
|
|
+ spc->v_oversample = v_oversample;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes,
|
|
|
+ int kernel_width)
|
|
|
+{
|
|
|
+ unsigned char buffer[NK_TT_MAX_OVERSAMPLE];
|
|
|
+ int safe_w = w - kernel_width;
|
|
|
+ int j;
|
|
|
+
|
|
|
+ for (j=0; j < h; ++j)
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ unsigned int total;
|
|
|
+ NK_MEMSET(buffer, 0, (nk_size)kernel_width);
|
|
|
+
|
|
|
+ total = 0;
|
|
|
+
|
|
|
+ /* make kernel_width a constant in common cases so compiler can optimize out the divide */
|
|
|
+ switch (kernel_width) {
|
|
|
+ case 2:
|
|
|
+ for (i=0; i <= safe_w; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
|
|
|
+ pixels[i] = (unsigned char) (total / 2);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ for (i=0; i <= safe_w; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
|
|
|
+ pixels[i] = (unsigned char) (total / 3);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 4:
|
|
|
+ for (i=0; i <= safe_w; ++i) {
|
|
|
+ total += (unsigned int)pixels[i] - buffer[i & NK_TT__OVER_MASK];
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
|
|
|
+ pixels[i] = (unsigned char) (total / 4);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 5:
|
|
|
+ for (i=0; i <= safe_w; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
|
|
|
+ pixels[i] = (unsigned char) (total / 5);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ for (i=0; i <= safe_w; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
|
|
|
+ pixels[i] = (unsigned char) (total / (unsigned int)kernel_width);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (; i < w; ++i) {
|
|
|
+ NK_ASSERT(pixels[i] == 0);
|
|
|
+ total -= (unsigned int)(buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ pixels[i] = (unsigned char) (total / (unsigned int)kernel_width);
|
|
|
+ }
|
|
|
+ pixels += stride_in_bytes;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes,
|
|
|
+ int kernel_width)
|
|
|
+{
|
|
|
+ unsigned char buffer[NK_TT_MAX_OVERSAMPLE];
|
|
|
+ int safe_h = h - kernel_width;
|
|
|
+ int j;
|
|
|
+
|
|
|
+ for (j=0; j < w; ++j)
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ unsigned int total;
|
|
|
+ NK_MEMSET(buffer, 0, (nk_size)kernel_width);
|
|
|
+
|
|
|
+ total = 0;
|
|
|
+
|
|
|
+ /* make kernel_width a constant in common cases so compiler can optimize out the divide */
|
|
|
+ switch (kernel_width) {
|
|
|
+ case 2:
|
|
|
+ for (i=0; i <= safe_h; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / 2);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ for (i=0; i <= safe_h; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / 3);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 4:
|
|
|
+ for (i=0; i <= safe_h; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / 4);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 5:
|
|
|
+ for (i=0; i <= safe_h; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / 5);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ for (i=0; i <= safe_h; ++i) {
|
|
|
+ total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / (unsigned int)kernel_width);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (; i < h; ++i) {
|
|
|
+ NK_ASSERT(pixels[i*stride_in_bytes] == 0);
|
|
|
+ total -= (unsigned int)(buffer[i & NK_TT__OVER_MASK]);
|
|
|
+ pixels[i*stride_in_bytes] = (unsigned char) (total / (unsigned int)kernel_width);
|
|
|
+ }
|
|
|
+ pixels += 1;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_tt__oversample_shift(int oversample)
|
|
|
+{
|
|
|
+ if (!oversample)
|
|
|
+ return 0.0f;
|
|
|
+
|
|
|
+ /* The prefilter is a box filter of width "oversample", */
|
|
|
+ /* which shifts phase by (oversample - 1)/2 pixels in */
|
|
|
+ /* oversampled space. We want to shift in the opposite */
|
|
|
+ /* direction to counter this. */
|
|
|
+ return (float)-(oversample - 1) / (2.0f * (float)oversample);
|
|
|
+}
|
|
|
+
|
|
|
+/* rects array must be big enough to accommodate all characters in the given ranges */
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_PackFontRangesGatherRects(struct nk_tt_pack_context *spc,
|
|
|
+ struct nk_tt_fontinfo *info, struct nk_tt_pack_range *ranges,
|
|
|
+ int num_ranges, struct nk_rp_rect *rects)
|
|
|
+{
|
|
|
+ int i,j,k;
|
|
|
+ k = 0;
|
|
|
+
|
|
|
+ for (i=0; i < num_ranges; ++i) {
|
|
|
+ float fh = ranges[i].font_size;
|
|
|
+ float scale = (fh > 0) ? nk_tt_ScaleForPixelHeight(info, fh):
|
|
|
+ nk_tt_ScaleForMappingEmToPixels(info, -fh);
|
|
|
+ ranges[i].h_oversample = (unsigned char) spc->h_oversample;
|
|
|
+ ranges[i].v_oversample = (unsigned char) spc->v_oversample;
|
|
|
+ for (j=0; j < ranges[i].num_chars; ++j) {
|
|
|
+ int x0,y0,x1,y1;
|
|
|
+ int codepoint = ranges[i].first_unicode_codepoint_in_range ?
|
|
|
+ ranges[i].first_unicode_codepoint_in_range + j :
|
|
|
+ ranges[i].array_of_unicode_codepoints[j];
|
|
|
+
|
|
|
+ int glyph = nk_tt_FindGlyphIndex(info, codepoint);
|
|
|
+ nk_tt_GetGlyphBitmapBoxSubpixel(info,glyph, scale * (float)spc->h_oversample,
|
|
|
+ scale * (float)spc->v_oversample, 0,0, &x0,&y0,&x1,&y1);
|
|
|
+ rects[k].w = (nk_rp_coord) (x1-x0 + spc->padding + (int)spc->h_oversample-1);
|
|
|
+ rects[k].h = (nk_rp_coord) (y1-y0 + spc->padding + (int)spc->v_oversample-1);
|
|
|
+ ++k;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return k;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tt_PackFontRangesRenderIntoRects(struct nk_tt_pack_context *spc,
|
|
|
+ struct nk_tt_fontinfo *info, struct nk_tt_pack_range *ranges,
|
|
|
+ int num_ranges, struct nk_rp_rect *rects, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ int i,j,k, return_value = 1;
|
|
|
+ /* save current values */
|
|
|
+ int old_h_over = (int)spc->h_oversample;
|
|
|
+ int old_v_over = (int)spc->v_oversample;
|
|
|
+ /* rects array must be big enough to accommodate all characters in the given ranges */
|
|
|
+
|
|
|
+ k = 0;
|
|
|
+ for (i=0; i < num_ranges; ++i)
|
|
|
+ {
|
|
|
+ float fh = ranges[i].font_size;
|
|
|
+ float recip_h,recip_v,sub_x,sub_y;
|
|
|
+ float scale = fh > 0 ? nk_tt_ScaleForPixelHeight(info, fh):
|
|
|
+ nk_tt_ScaleForMappingEmToPixels(info, -fh);
|
|
|
+
|
|
|
+ spc->h_oversample = ranges[i].h_oversample;
|
|
|
+ spc->v_oversample = ranges[i].v_oversample;
|
|
|
+
|
|
|
+ recip_h = 1.0f / (float)spc->h_oversample;
|
|
|
+ recip_v = 1.0f / (float)spc->v_oversample;
|
|
|
+
|
|
|
+ sub_x = nk_tt__oversample_shift((int)spc->h_oversample);
|
|
|
+ sub_y = nk_tt__oversample_shift((int)spc->v_oversample);
|
|
|
+
|
|
|
+ for (j=0; j < ranges[i].num_chars; ++j)
|
|
|
+ {
|
|
|
+ struct nk_rp_rect *r = &rects[k];
|
|
|
+ if (r->was_packed)
|
|
|
+ {
|
|
|
+ struct nk_tt_packedchar *bc = &ranges[i].chardata_for_range[j];
|
|
|
+ int advance, lsb, x0,y0,x1,y1;
|
|
|
+ int codepoint = ranges[i].first_unicode_codepoint_in_range ?
|
|
|
+ ranges[i].first_unicode_codepoint_in_range + j :
|
|
|
+ ranges[i].array_of_unicode_codepoints[j];
|
|
|
+ int glyph = nk_tt_FindGlyphIndex(info, codepoint);
|
|
|
+ nk_rp_coord pad = (nk_rp_coord) spc->padding;
|
|
|
+
|
|
|
+ /* pad on left and top */
|
|
|
+ r->x = (nk_rp_coord)((int)r->x + (int)pad);
|
|
|
+ r->y = (nk_rp_coord)((int)r->y + (int)pad);
|
|
|
+ r->w = (nk_rp_coord)((int)r->w - (int)pad);
|
|
|
+ r->h = (nk_rp_coord)((int)r->h - (int)pad);
|
|
|
+
|
|
|
+ nk_tt_GetGlyphHMetrics(info, glyph, &advance, &lsb);
|
|
|
+ nk_tt_GetGlyphBitmapBox(info, glyph, scale * (float)spc->h_oversample,
|
|
|
+ (scale * (float)spc->v_oversample), &x0,&y0,&x1,&y1);
|
|
|
+ nk_tt_MakeGlyphBitmapSubpixel(info, spc->pixels + r->x + r->y*spc->stride_in_bytes,
|
|
|
+ (int)(r->w - spc->h_oversample+1), (int)(r->h - spc->v_oversample+1),
|
|
|
+ spc->stride_in_bytes, scale * (float)spc->h_oversample,
|
|
|
+ scale * (float)spc->v_oversample, 0,0, glyph, alloc);
|
|
|
+
|
|
|
+ if (spc->h_oversample > 1)
|
|
|
+ nk_tt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
|
|
|
+ r->w, r->h, spc->stride_in_bytes, (int)spc->h_oversample);
|
|
|
+
|
|
|
+ if (spc->v_oversample > 1)
|
|
|
+ nk_tt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
|
|
|
+ r->w, r->h, spc->stride_in_bytes, (int)spc->v_oversample);
|
|
|
+
|
|
|
+ bc->x0 = (nk_ushort) r->x;
|
|
|
+ bc->y0 = (nk_ushort) r->y;
|
|
|
+ bc->x1 = (nk_ushort) (r->x + r->w);
|
|
|
+ bc->y1 = (nk_ushort) (r->y + r->h);
|
|
|
+ bc->xadvance = scale * (float)advance;
|
|
|
+ bc->xoff = (float) x0 * recip_h + sub_x;
|
|
|
+ bc->yoff = (float) y0 * recip_v + sub_y;
|
|
|
+ bc->xoff2 = ((float)x0 + r->w) * recip_h + sub_x;
|
|
|
+ bc->yoff2 = ((float)y0 + r->h) * recip_v + sub_y;
|
|
|
+ } else {
|
|
|
+ return_value = 0; /* if any fail, report failure */
|
|
|
+ }
|
|
|
+ ++k;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* restore original values */
|
|
|
+ spc->h_oversample = (unsigned int)old_h_over;
|
|
|
+ spc->v_oversample = (unsigned int)old_v_over;
|
|
|
+ return return_value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_tt_GetPackedQuad(struct nk_tt_packedchar *chardata, int pw, int ph,
|
|
|
+ int char_index, float *xpos, float *ypos, struct nk_tt_aligned_quad *q,
|
|
|
+ int align_to_integer)
|
|
|
+{
|
|
|
+ float ipw = 1.0f / (float)pw, iph = 1.0f / (float)ph;
|
|
|
+ struct nk_tt_packedchar *b = (struct nk_tt_packedchar*)(chardata + char_index);
|
|
|
+ if (align_to_integer) {
|
|
|
+ int tx = nk_ifloorf((*xpos + b->xoff) + 0.5f);
|
|
|
+ int ty = nk_ifloorf((*ypos + b->yoff) + 0.5f);
|
|
|
+
|
|
|
+ float x = (float)tx;
|
|
|
+ float y = (float)ty;
|
|
|
+
|
|
|
+ q->x0 = x;
|
|
|
+ q->y0 = y;
|
|
|
+ q->x1 = x + b->xoff2 - b->xoff;
|
|
|
+ q->y1 = y + b->yoff2 - b->yoff;
|
|
|
+ } else {
|
|
|
+ q->x0 = *xpos + b->xoff;
|
|
|
+ q->y0 = *ypos + b->yoff;
|
|
|
+ q->x1 = *xpos + b->xoff2;
|
|
|
+ q->y1 = *ypos + b->yoff2;
|
|
|
+ }
|
|
|
+ q->s0 = b->x0 * ipw;
|
|
|
+ q->t0 = b->y0 * iph;
|
|
|
+ q->s1 = b->x1 * ipw;
|
|
|
+ q->t1 = b->y1 * iph;
|
|
|
+ *xpos += b->xadvance;
|
|
|
+}
|
|
|
+
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * FONT BAKING
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+struct nk_font_bake_data {
|
|
|
+ struct nk_tt_fontinfo info;
|
|
|
+ struct nk_rp_rect *rects;
|
|
|
+ struct nk_tt_pack_range *ranges;
|
|
|
+ nk_rune range_count;
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_font_baker {
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ struct nk_tt_pack_context spc;
|
|
|
+ struct nk_font_bake_data *build;
|
|
|
+ struct nk_tt_packedchar *packed_chars;
|
|
|
+ struct nk_rp_rect *rects;
|
|
|
+ struct nk_tt_pack_range *ranges;
|
|
|
+};
|
|
|
+
|
|
|
+NK_GLOBAL const nk_size nk_rect_align = NK_ALIGNOF(struct nk_rp_rect);
|
|
|
+NK_GLOBAL const nk_size nk_range_align = NK_ALIGNOF(struct nk_tt_pack_range);
|
|
|
+NK_GLOBAL const nk_size nk_char_align = NK_ALIGNOF(struct nk_tt_packedchar);
|
|
|
+NK_GLOBAL const nk_size nk_build_align = NK_ALIGNOF(struct nk_font_bake_data);
|
|
|
+NK_GLOBAL const nk_size nk_baker_align = NK_ALIGNOF(struct nk_font_baker);
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_range_count(const nk_rune *range)
|
|
|
+{
|
|
|
+ const nk_rune *iter = range;
|
|
|
+ NK_ASSERT(range);
|
|
|
+ if (!range) return 0;
|
|
|
+ while (*(iter++) != 0);
|
|
|
+ return (iter == range) ? 0 : (int)((iter - range)/2);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_range_glyph_count(const nk_rune *range, int count)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int total_glyphs = 0;
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ int diff;
|
|
|
+ nk_rune f = range[(i*2)+0];
|
|
|
+ nk_rune t = range[(i*2)+1];
|
|
|
+ NK_ASSERT(t >= f);
|
|
|
+ diff = (int)((t - f) + 1);
|
|
|
+ total_glyphs += diff;
|
|
|
+ }
|
|
|
+ return total_glyphs;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const nk_rune*
|
|
|
+nk_font_default_glyph_ranges(void)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_rune ranges[] = {0x0020, 0x00FF, 0};
|
|
|
+ return ranges;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const nk_rune*
|
|
|
+nk_font_chinese_glyph_ranges(void)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_rune ranges[] = {
|
|
|
+ 0x0020, 0x00FF,
|
|
|
+ 0x3000, 0x30FF,
|
|
|
+ 0x31F0, 0x31FF,
|
|
|
+ 0xFF00, 0xFFEF,
|
|
|
+ 0x4e00, 0x9FAF,
|
|
|
+ 0
|
|
|
+ };
|
|
|
+ return ranges;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const nk_rune*
|
|
|
+nk_font_cyrillic_glyph_ranges(void)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_rune ranges[] = {
|
|
|
+ 0x0020, 0x00FF,
|
|
|
+ 0x0400, 0x052F,
|
|
|
+ 0x2DE0, 0x2DFF,
|
|
|
+ 0xA640, 0xA69F,
|
|
|
+ 0
|
|
|
+ };
|
|
|
+ return ranges;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const nk_rune*
|
|
|
+nk_font_korean_glyph_ranges(void)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_rune ranges[] = {
|
|
|
+ 0x0020, 0x00FF,
|
|
|
+ 0x3131, 0x3163,
|
|
|
+ 0xAC00, 0xD79D,
|
|
|
+ 0
|
|
|
+ };
|
|
|
+ return ranges;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_font_baker_memory(nk_size *temp, int *glyph_count,
|
|
|
+ struct nk_font_config *config_list, int count)
|
|
|
+{
|
|
|
+ int range_count = 0;
|
|
|
+ int total_range_count = 0;
|
|
|
+ struct nk_font_config *iter;
|
|
|
+
|
|
|
+ NK_ASSERT(config_list);
|
|
|
+ NK_ASSERT(glyph_count);
|
|
|
+ if (!config_list) {
|
|
|
+ *temp = 0;
|
|
|
+ *glyph_count = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ *glyph_count = 0;
|
|
|
+ if (!config_list->range)
|
|
|
+ config_list->range = nk_font_default_glyph_ranges();
|
|
|
+ for (iter = config_list; iter; iter = iter->next) {
|
|
|
+ range_count = nk_range_count(iter->range);
|
|
|
+ total_range_count += range_count;
|
|
|
+ *glyph_count += nk_range_glyph_count(iter->range, range_count);
|
|
|
+ }
|
|
|
+
|
|
|
+ *temp = (nk_size)*glyph_count * sizeof(struct nk_rp_rect);
|
|
|
+ *temp += (nk_size)total_range_count * sizeof(struct nk_tt_pack_range);
|
|
|
+ *temp += (nk_size)*glyph_count * sizeof(struct nk_tt_packedchar);
|
|
|
+ *temp += (nk_size)count * sizeof(struct nk_font_bake_data);
|
|
|
+ *temp += sizeof(struct nk_font_baker);
|
|
|
+ *temp += nk_rect_align + nk_range_align + nk_char_align;
|
|
|
+ *temp += nk_build_align + nk_baker_align;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_font_baker*
|
|
|
+nk_font_baker(void *memory, int glyph_count, int count, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ struct nk_font_baker *baker;
|
|
|
+ if (!memory) return 0;
|
|
|
+ /* setup baker inside a memory block */
|
|
|
+ baker = (struct nk_font_baker*)NK_ALIGN_PTR(memory, nk_baker_align);
|
|
|
+ baker->build = (struct nk_font_bake_data*)NK_ALIGN_PTR((baker + 1), nk_build_align);
|
|
|
+ baker->packed_chars = (struct nk_tt_packedchar*)NK_ALIGN_PTR((baker->build + count), nk_char_align);
|
|
|
+ baker->rects = (struct nk_rp_rect*)NK_ALIGN_PTR((baker->packed_chars + glyph_count), nk_rect_align);
|
|
|
+ baker->ranges = (struct nk_tt_pack_range*)NK_ALIGN_PTR((baker->rects + glyph_count), nk_range_align);
|
|
|
+ baker->alloc = *alloc;
|
|
|
+ return baker;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_font_bake_pack(struct nk_font_baker *baker,
|
|
|
+ nk_size *image_memory, int *width, int *height, struct nk_recti *custom,
|
|
|
+ const struct nk_font_config *config_list, int count,
|
|
|
+ struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ NK_STORAGE const nk_size max_height = 1024 * 32;
|
|
|
+ const struct nk_font_config *config_iter;
|
|
|
+ int total_glyph_count = 0;
|
|
|
+ int total_range_count = 0;
|
|
|
+ int range_count = 0;
|
|
|
+ int i = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(image_memory);
|
|
|
+ NK_ASSERT(width);
|
|
|
+ NK_ASSERT(height);
|
|
|
+ NK_ASSERT(config_list);
|
|
|
+ NK_ASSERT(count);
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+
|
|
|
+ if (!image_memory || !width || !height || !config_list || !count) return nk_false;
|
|
|
+ for (config_iter = config_list; config_iter; config_iter = config_iter->next) {
|
|
|
+ range_count = nk_range_count(config_iter->range);
|
|
|
+ total_range_count += range_count;
|
|
|
+ total_glyph_count += nk_range_glyph_count(config_iter->range, range_count);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* setup font baker from temporary memory */
|
|
|
+ for (config_iter = config_list; config_iter; config_iter = config_iter->next) {
|
|
|
+ const struct nk_font_config *cfg = config_iter;
|
|
|
+ if (!nk_tt_InitFont(&baker->build[i++].info, (const unsigned char*)cfg->ttf_blob, 0))
|
|
|
+ return nk_false;
|
|
|
+ }
|
|
|
+
|
|
|
+ *height = 0;
|
|
|
+ *width = (total_glyph_count > 1000) ? 1024 : 512;
|
|
|
+ nk_tt_PackBegin(&baker->spc, 0, (int)*width, (int)max_height, 0, 1, alloc);
|
|
|
+ {
|
|
|
+ int input_i = 0;
|
|
|
+ int range_n = 0;
|
|
|
+ int rect_n = 0;
|
|
|
+ int char_n = 0;
|
|
|
+
|
|
|
+ if (custom) {
|
|
|
+ /* pack custom user data first so it will be in the upper left corner*/
|
|
|
+ struct nk_rp_rect custom_space;
|
|
|
+ nk_zero(&custom_space, sizeof(custom_space));
|
|
|
+ custom_space.w = (nk_rp_coord)((custom->w * 2) + 1);
|
|
|
+ custom_space.h = (nk_rp_coord)(custom->h + 1);
|
|
|
+
|
|
|
+ nk_tt_PackSetOversampling(&baker->spc, 1, 1);
|
|
|
+ nk_rp_pack_rects((struct nk_rp_context*)baker->spc.pack_info, &custom_space, 1);
|
|
|
+ *height = NK_MAX(*height, (int)(custom_space.y + custom_space.h));
|
|
|
+
|
|
|
+ custom->x = (short)custom_space.x;
|
|
|
+ custom->y = (short)custom_space.y;
|
|
|
+ custom->w = (short)custom_space.w;
|
|
|
+ custom->h = (short)custom_space.h;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* first font pass: pack all glyphs */
|
|
|
+ for (input_i = 0, config_iter = config_list; input_i < count && config_iter;
|
|
|
+ input_i++, config_iter = config_iter->next)
|
|
|
+ {
|
|
|
+ int n = 0;
|
|
|
+ int glyph_count;
|
|
|
+ const nk_rune *in_range;
|
|
|
+ const struct nk_font_config *cfg = config_iter;
|
|
|
+ struct nk_font_bake_data *tmp = &baker->build[input_i];
|
|
|
+
|
|
|
+ /* count glyphs + ranges in current font */
|
|
|
+ glyph_count = 0; range_count = 0;
|
|
|
+ for (in_range = cfg->range; in_range[0] && in_range[1]; in_range += 2) {
|
|
|
+ glyph_count += (int)(in_range[1] - in_range[0]) + 1;
|
|
|
+ range_count++;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* setup ranges */
|
|
|
+ tmp->ranges = baker->ranges + range_n;
|
|
|
+ tmp->range_count = (nk_rune)range_count;
|
|
|
+ range_n += range_count;
|
|
|
+ for (i = 0; i < range_count; ++i) {
|
|
|
+ in_range = &cfg->range[i * 2];
|
|
|
+ tmp->ranges[i].font_size = cfg->size;
|
|
|
+ tmp->ranges[i].first_unicode_codepoint_in_range = (int)in_range[0];
|
|
|
+ tmp->ranges[i].num_chars = (int)(in_range[1]- in_range[0]) + 1;
|
|
|
+ tmp->ranges[i].chardata_for_range = baker->packed_chars + char_n;
|
|
|
+ char_n += tmp->ranges[i].num_chars;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* pack */
|
|
|
+ tmp->rects = baker->rects + rect_n;
|
|
|
+ rect_n += glyph_count;
|
|
|
+ nk_tt_PackSetOversampling(&baker->spc, cfg->oversample_h, cfg->oversample_v);
|
|
|
+ n = nk_tt_PackFontRangesGatherRects(&baker->spc, &tmp->info,
|
|
|
+ tmp->ranges, (int)tmp->range_count, tmp->rects);
|
|
|
+ nk_rp_pack_rects((struct nk_rp_context*)baker->spc.pack_info, tmp->rects, (int)n);
|
|
|
+
|
|
|
+ /* texture height */
|
|
|
+ for (i = 0; i < n; ++i) {
|
|
|
+ if (tmp->rects[i].was_packed)
|
|
|
+ *height = NK_MAX(*height, tmp->rects[i].y + tmp->rects[i].h);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ NK_ASSERT(rect_n == total_glyph_count);
|
|
|
+ NK_ASSERT(char_n == total_glyph_count);
|
|
|
+ NK_ASSERT(range_n == total_range_count);
|
|
|
+ }
|
|
|
+ *height = (int)nk_round_up_pow2((nk_uint)*height);
|
|
|
+ *image_memory = (nk_size)(*width) * (nk_size)(*height);
|
|
|
+ return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_font_bake(struct nk_font_baker *baker, void *image_memory, int width, int height,
|
|
|
+ struct nk_font_glyph *glyphs, int glyphs_count,
|
|
|
+ const struct nk_font_config *config_list, int font_count)
|
|
|
+{
|
|
|
+ int input_i = 0;
|
|
|
+ nk_rune glyph_n = 0;
|
|
|
+ const struct nk_font_config *config_iter;
|
|
|
+
|
|
|
+ NK_ASSERT(image_memory);
|
|
|
+ NK_ASSERT(width);
|
|
|
+ NK_ASSERT(height);
|
|
|
+ NK_ASSERT(config_list);
|
|
|
+ NK_ASSERT(baker);
|
|
|
+ NK_ASSERT(font_count);
|
|
|
+ NK_ASSERT(glyphs_count);
|
|
|
+ if (!image_memory || !width || !height || !config_list ||
|
|
|
+ !font_count || !glyphs || !glyphs_count)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* second font pass: render glyphs */
|
|
|
+ nk_zero(image_memory, (nk_size)((nk_size)width * (nk_size)height));
|
|
|
+ baker->spc.pixels = (unsigned char*)image_memory;
|
|
|
+ baker->spc.height = (int)height;
|
|
|
+ for (input_i = 0, config_iter = config_list; input_i < font_count && config_iter;
|
|
|
+ ++input_i, config_iter = config_iter->next)
|
|
|
+ {
|
|
|
+ const struct nk_font_config *cfg = config_iter;
|
|
|
+ struct nk_font_bake_data *tmp = &baker->build[input_i];
|
|
|
+ nk_tt_PackSetOversampling(&baker->spc, cfg->oversample_h, cfg->oversample_v);
|
|
|
+ nk_tt_PackFontRangesRenderIntoRects(&baker->spc, &tmp->info, tmp->ranges,
|
|
|
+ (int)tmp->range_count, tmp->rects, &baker->alloc);
|
|
|
+ }
|
|
|
+ nk_tt_PackEnd(&baker->spc, &baker->alloc);
|
|
|
+
|
|
|
+ /* third pass: setup font and glyphs */
|
|
|
+ for (input_i = 0, config_iter = config_list; input_i < font_count && config_iter;
|
|
|
+ ++input_i, config_iter = config_iter->next)
|
|
|
+ {
|
|
|
+ nk_size i = 0;
|
|
|
+ int char_idx = 0;
|
|
|
+ nk_rune glyph_count = 0;
|
|
|
+ const struct nk_font_config *cfg = config_iter;
|
|
|
+ struct nk_font_bake_data *tmp = &baker->build[input_i];
|
|
|
+ struct nk_baked_font *dst_font = cfg->font;
|
|
|
+
|
|
|
+ float font_scale = nk_tt_ScaleForPixelHeight(&tmp->info, cfg->size);
|
|
|
+ int unscaled_ascent, unscaled_descent, unscaled_line_gap;
|
|
|
+ nk_tt_GetFontVMetrics(&tmp->info, &unscaled_ascent, &unscaled_descent,
|
|
|
+ &unscaled_line_gap);
|
|
|
+
|
|
|
+ /* fill baked font */
|
|
|
+ if (!cfg->merge_mode) {
|
|
|
+ dst_font->ranges = cfg->range;
|
|
|
+ dst_font->height = cfg->size;
|
|
|
+ dst_font->ascent = ((float)unscaled_ascent * font_scale);
|
|
|
+ dst_font->descent = ((float)unscaled_descent * font_scale);
|
|
|
+ dst_font->glyph_offset = glyph_n;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* fill own baked font glyph array */
|
|
|
+ for (i = 0; i < tmp->range_count; ++i)
|
|
|
+ {
|
|
|
+ struct nk_tt_pack_range *range = &tmp->ranges[i];
|
|
|
+ for (char_idx = 0; char_idx < range->num_chars; char_idx++)
|
|
|
+ {
|
|
|
+ nk_rune codepoint = 0;
|
|
|
+ float dummy_x = 0, dummy_y = 0;
|
|
|
+ struct nk_tt_aligned_quad q;
|
|
|
+ struct nk_font_glyph *glyph;
|
|
|
+
|
|
|
+ /* query glyph bounds from stb_truetype */
|
|
|
+ const struct nk_tt_packedchar *pc = &range->chardata_for_range[char_idx];
|
|
|
+ if (!pc->x0 && !pc->x1 && !pc->y0 && !pc->y1) continue;
|
|
|
+ codepoint = (nk_rune)(range->first_unicode_codepoint_in_range + char_idx);
|
|
|
+ nk_tt_GetPackedQuad(range->chardata_for_range, (int)width,
|
|
|
+ (int)height, char_idx, &dummy_x, &dummy_y, &q, 0);
|
|
|
+
|
|
|
+ /* fill own glyph type with data */
|
|
|
+ glyph = &glyphs[dst_font->glyph_offset + (unsigned int)glyph_count];
|
|
|
+ glyph->codepoint = codepoint;
|
|
|
+ glyph->x0 = q.x0; glyph->y0 = q.y0;
|
|
|
+ glyph->x1 = q.x1; glyph->y1 = q.y1;
|
|
|
+ glyph->y0 += (dst_font->ascent + 0.5f);
|
|
|
+ glyph->y1 += (dst_font->ascent + 0.5f);
|
|
|
+ glyph->w = glyph->x1 - glyph->x0 + 0.5f;
|
|
|
+ glyph->h = glyph->y1 - glyph->y0;
|
|
|
+
|
|
|
+ if (cfg->coord_type == NK_COORD_PIXEL) {
|
|
|
+ glyph->u0 = q.s0 * (float)width;
|
|
|
+ glyph->v0 = q.t0 * (float)height;
|
|
|
+ glyph->u1 = q.s1 * (float)width;
|
|
|
+ glyph->v1 = q.t1 * (float)height;
|
|
|
+ } else {
|
|
|
+ glyph->u0 = q.s0;
|
|
|
+ glyph->v0 = q.t0;
|
|
|
+ glyph->u1 = q.s1;
|
|
|
+ glyph->v1 = q.t1;
|
|
|
+ }
|
|
|
+ glyph->xadvance = (pc->xadvance + cfg->spacing.x);
|
|
|
+ if (cfg->pixel_snap)
|
|
|
+ glyph->xadvance = (float)(int)(glyph->xadvance + 0.5f);
|
|
|
+ glyph_count++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ dst_font->glyph_count = glyph_count;
|
|
|
+ glyph_n += dst_font->glyph_count;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_font_bake_custom_data(void *img_memory, int img_width, int img_height,
|
|
|
+ struct nk_recti img_dst, const char *texture_data_mask, int tex_width,
|
|
|
+ int tex_height, char white, char black)
|
|
|
+{
|
|
|
+ nk_byte *pixels;
|
|
|
+ int y = 0;
|
|
|
+ int x = 0;
|
|
|
+ int n = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(img_memory);
|
|
|
+ NK_ASSERT(img_width);
|
|
|
+ NK_ASSERT(img_height);
|
|
|
+ NK_ASSERT(texture_data_mask);
|
|
|
+ NK_UNUSED(tex_height);
|
|
|
+ if (!img_memory || !img_width || !img_height || !texture_data_mask)
|
|
|
+ return;
|
|
|
+
|
|
|
+ pixels = (nk_byte*)img_memory;
|
|
|
+ for (y = 0, n = 0; y < tex_height; ++y) {
|
|
|
+ for (x = 0; x < tex_width; ++x, ++n) {
|
|
|
+ const int off0 = ((img_dst.x + x) + (img_dst.y + y) * img_width);
|
|
|
+ const int off1 = off0 + 1 + tex_width;
|
|
|
+ pixels[off0] = (texture_data_mask[n] == white) ? 0xFF : 0x00;
|
|
|
+ pixels[off1] = (texture_data_mask[n] == black) ? 0xFF : 0x00;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_font_bake_convert(void *out_memory, int img_width, int img_height,
|
|
|
+ const void *in_memory)
|
|
|
+{
|
|
|
+ int n = 0;
|
|
|
+ nk_rune *dst;
|
|
|
+ const nk_byte *src;
|
|
|
+
|
|
|
+ NK_ASSERT(out_memory);
|
|
|
+ NK_ASSERT(in_memory);
|
|
|
+ NK_ASSERT(img_width);
|
|
|
+ NK_ASSERT(img_height);
|
|
|
+ if (!out_memory || !in_memory || !img_height || !img_width) return;
|
|
|
+
|
|
|
+ dst = (nk_rune*)out_memory;
|
|
|
+ src = (const nk_byte*)in_memory;
|
|
|
+ for (n = (int)(img_width * img_height); n > 0; n--)
|
|
|
+ *dst++ = ((nk_rune)(*src++) << 24) | 0x00FFFFFF;
|
|
|
+}
|
|
|
+
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * FONT
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN float
|
|
|
+nk_font_text_width(nk_handle handle, float height, const char *text, int len)
|
|
|
+{
|
|
|
+ nk_rune unicode;
|
|
|
+ int text_len = 0;
|
|
|
+ float text_width = 0;
|
|
|
+ int glyph_len = 0;
|
|
|
+ float scale = 0;
|
|
|
+
|
|
|
+ struct nk_font *font = (struct nk_font*)handle.ptr;
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(font->glyphs);
|
|
|
+ if (!font || !text || !len)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ scale = height/font->info.height;
|
|
|
+ glyph_len = text_len = nk_utf_decode(text, &unicode, (int)len);
|
|
|
+ if (!glyph_len) return 0;
|
|
|
+ while (text_len <= (int)len && glyph_len) {
|
|
|
+ const struct nk_font_glyph *g;
|
|
|
+ if (unicode == NK_UTF_INVALID) break;
|
|
|
+
|
|
|
+ /* query currently drawn glyph information */
|
|
|
+ g = nk_font_find_glyph(font, unicode);
|
|
|
+ text_width += g->xadvance * scale;
|
|
|
+
|
|
|
+ /* offset next glyph */
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, (int)len - text_len);
|
|
|
+ text_len += glyph_len;
|
|
|
+ }
|
|
|
+ return text_width;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+NK_INTERN void
|
|
|
+nk_font_query_font_glyph(nk_handle handle, float height,
|
|
|
+ struct nk_user_font_glyph *glyph, nk_rune codepoint, nk_rune next_codepoint)
|
|
|
+{
|
|
|
+ float scale;
|
|
|
+ const struct nk_font_glyph *g;
|
|
|
+ struct nk_font *font;
|
|
|
+
|
|
|
+ NK_ASSERT(glyph);
|
|
|
+ NK_UNUSED(next_codepoint);
|
|
|
+
|
|
|
+ font = (struct nk_font*)handle.ptr;
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(font->glyphs);
|
|
|
+ if (!font || !glyph)
|
|
|
+ return;
|
|
|
+
|
|
|
+ scale = height/font->info.height;
|
|
|
+ g = nk_font_find_glyph(font, codepoint);
|
|
|
+ glyph->width = (g->x1 - g->x0) * scale;
|
|
|
+ glyph->height = (g->y1 - g->y0) * scale;
|
|
|
+ glyph->offset = nk_vec2(g->x0 * scale, g->y0 * scale);
|
|
|
+ glyph->xadvance = (g->xadvance * scale);
|
|
|
+ glyph->uv[0] = nk_vec2(g->u0, g->v0);
|
|
|
+ glyph->uv[1] = nk_vec2(g->u1, g->v1);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API const struct nk_font_glyph*
|
|
|
+nk_font_find_glyph(struct nk_font *font, nk_rune unicode)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int count;
|
|
|
+ int total_glyphs = 0;
|
|
|
+ const struct nk_font_glyph *glyph = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(font->glyphs);
|
|
|
+ NK_ASSERT(font->info.ranges);
|
|
|
+ if (!font || !font->glyphs) return 0;
|
|
|
+
|
|
|
+ glyph = font->fallback;
|
|
|
+ count = nk_range_count(font->info.ranges);
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ nk_rune f = font->info.ranges[(i*2)+0];
|
|
|
+ nk_rune t = font->info.ranges[(i*2)+1];
|
|
|
+ int diff = (int)((t - f) + 1);
|
|
|
+ if (unicode >= f && unicode <= t)
|
|
|
+ return &font->glyphs[((nk_rune)total_glyphs + (unicode - f))];
|
|
|
+ total_glyphs += diff;
|
|
|
+ }
|
|
|
+ return glyph;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_font_init(struct nk_font *font, float pixel_height,
|
|
|
+ nk_rune fallback_codepoint, struct nk_font_glyph *glyphs,
|
|
|
+ const struct nk_baked_font *baked_font, nk_handle atlas)
|
|
|
+{
|
|
|
+ struct nk_baked_font baked;
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(glyphs);
|
|
|
+ NK_ASSERT(baked_font);
|
|
|
+ if (!font || !glyphs || !baked_font)
|
|
|
+ return;
|
|
|
+
|
|
|
+ baked = *baked_font;
|
|
|
+ font->fallback = 0;
|
|
|
+ font->info = baked;
|
|
|
+ font->scale = (float)pixel_height / (float)font->info.height;
|
|
|
+ font->glyphs = &glyphs[baked_font->glyph_offset];
|
|
|
+ font->texture = atlas;
|
|
|
+ font->fallback_codepoint = fallback_codepoint;
|
|
|
+ font->fallback = nk_font_find_glyph(font, fallback_codepoint);
|
|
|
+
|
|
|
+ font->handle.height = font->info.height * font->scale;
|
|
|
+ font->handle.width = nk_font_text_width;
|
|
|
+ font->handle.userdata.ptr = font;
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ font->handle.query = nk_font_query_font_glyph;
|
|
|
+ font->handle.texture = font->texture;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+/* ---------------------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * DEFAULT FONT
|
|
|
+ *
|
|
|
+ * ProggyClean.ttf
|
|
|
+ * Copyright (c) 2004, 2005 Tristan Grimmer
|
|
|
+ * MIT license (see License.txt in http://www.upperbounds.net/download/ProggyClean.ttf.zip)
|
|
|
+ * Download and more information at http://upperbounds.net
|
|
|
+ *-----------------------------------------------------------------------------*/
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_FONT
|
|
|
+
|
|
|
+ #ifdef __clang__
|
|
|
+#pragma clang diagnostic push
|
|
|
+
|
|
|
+#pragma clang diagnostic ignored "-Woverlength-strings"
|
|
|
+#elif defined(__GNUC__) || defined(__GNUG__)
|
|
|
+#pragma GCC diagnostic push
|
|
|
+#pragma GCC diagnostic ignored "-Woverlength-strings"
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_GLOBAL const char nk_proggy_clean_ttf_compressed_data_base85[11980+1] =
|
|
|
+ "7])#######hV0qs'/###[),##/l:$#Q6>##5[n42>c-TH`->>#/e>11NNV=Bv(*:.F?uu#(gRU.o0XGH`$vhLG1hxt9?W`#,5LsCp#-i>.r$<$6pD>Lb';9Crc6tgXmKVeU2cD4Eo3R/"
|
|
|
+ "2*>]b(MC;$jPfY.;h^`IWM9<Lh2TlS+f-s$o6Q<BWH`YiU.xfLq$N;$0iR/GX:U(jcW2p/W*q?-qmnUCI;jHSAiFWM.R*kU@C=GH?a9wp8f$e.-4^Qg1)Q-GL(lf(r/7GrRgwV%MS=C#"
|
|
|
+ "`8ND>Qo#t'X#(v#Y9w0#1D$CIf;W'#pWUPXOuxXuU(H9M(1<q-UE31#^-V'8IRUo7Qf./L>=Ke$$'5F%)]0^#[email protected]<r:QLtFsLcL6##lOj)#.Y5<-R&KgLwqJfLgN&;Q?gI^#DY2uL"
|
|
|
+ "i@^rMl9t=cWq6##weg>$FBjVQTSDgEKnIS7EM9>ZY9w0#L;>>#Mx&4Mvt//L[MkA#[email protected]'[0#7RL_&#w+F%HtG9M#XL`N&.,GM4Pg;-<nLENhvx>-VsM.M0rJfLH2eTM`*oJMHRC`N"
|
|
|
+ "kfimM2J,W-jXS:)r0wK#@Fge$U>`w'N7G#$#fB#$E^$#:9:hk+eOe--6x)F7*E%?76%^GMHePW-Z5l'&GiF#$956:rS?dA#fiK:)Yr+`�j@'DbG&#^$PG.Ll+DNa<XCMKEV*N)LN/N"
|
|
|
+ "*b=%Q6pia-Xg8I$<MR&,VdJe$<(7G;Ckl'&hF;;$<_=X(b.RS%%)###MPBuuE1V:v&cXm#(&cV]`k9OhLMbn%s$G2,B$BfD3X*sp5#l,$R#]x_X1xKX%b5U*[r5iMfUo9U`N99hG)"
|
|
|
+ "tm+/Us9pG)XPu`<0s-)WTt(gCRxIg(%6sfh=ktMKn3j)<6<b5Sk_/0(^]AaN#(p/L>&VZ>1i%h1S9u5o@YaaW$e+b<TWFn/Z:Oh(Cx2$lNEoN^e)#CFY@@I;BOQ*sRwZtZxRcU7uW6CX"
|
|
|
+ "ow0i(?$Q[cjOd[P4d)]>ROPOpxTO7Stwi1::iB1q)C_=dV26J;2,]7op$]uQr@_V7$q^%lQwtuHY]=DX,n3L#0PHDO4f9>dC@O>HBuKPpP*E,N+b3L#lpR/MrTEH.IAQk.a>D[.e;mc."
|
|
|
+ "x]Ip.PH^'/aqUO/$1WxLoW0[iLA<QT;5HKD+@qQ'NQ(3_PLhE48R.qAPSwQ0/WK?Z,[x?-J;jQTWA0X@KJ(_Y8N-:/M74:/-ZpKrUss?d#dZq]DAbkU*JqkL+nwX@@47`5>w=4h(9.`G"
|
|
|
+ "CRUxHPeR`5Mjol(dUWxZa(>STrPkrJiWx`5U7F#.g*jrohGg`cg:lSTvEY/EV_7H4Q9[Z%cnv;JQYZ5q.l7Zeas:HOIZOB?G<Nald$qs]@]L<J7bR*>gv:[7MI2k).'2($5FNP&EQ(,)"
|
|
|
+ "U]W]+fh18.vsai00);D3@4ku5P?DP8aJt+;qUM]=+b'8@;mViBKx0DE[-auGl8:PJ&Dj+M6OC]O^((##]`0i)drT;-7X`=-H3[igUnPG-NZlo.#k@h#=Ork$m>a>$-?Tm$UV(?#P6YY#"
|
|
|
+ "'/###xe7q.73rI3*pP/$1>s9)W,JrM7SN]'/4C#v$U`0#V.[0>xQsH$fEmPMgY2u7Kh(G%siIfLSoS+MK2eTM$=5,M8p`A.;_R%#u[K#$x4AG8.kK/HSB==-'Ie/QTtG?-.*^N-4B/ZM"
|
|
|
+ "_3YlQC7(p7q)&](`6_c)$/*JL(L-^(]$wIM`dPtOdGA,U3:w2M-0<q-]L_?^)1vw'.,MRsqVr.L;aN&#/EgJ)PBc[-f>+WomX2u7lqM2iEumMTcsF?-aT=Z-97UEnXglEn1K-bnEO`gu"
|
|
|
+ "Ft(c%=;Am_Qs@jLooI&NX;]0#j4#F14;gl8-GQpgwhrq8'=l_f-b49'UOqkLu7-##oDY2L(te+Mch&gLYtJ,MEtJfLh'x'M=$CS-ZZ%P]8bZ>#S?YY#%Q&q'3^Fw&?D)UDNrocM3A76/"
|
|
|
+ "/oL?#h7gl85[qW/NDOk%16ij;+:1a'iNIdb-ou8.P*w,v5#EI$TWS>Pot-R*H'-SEpA:g)f+O$%%`kA#G=8RMmG1&O`>to8bC]T&$,n.LoO>29sp3dt-52U%VM#q7'DHpg+#Z9%H[K<L"
|
|
|
+ "%a2E-grWVM3@2=-k22tL]4$##6We'8UJCKE[d_=%wI;'6X-GsLX4j^SgJ$##R*w,vP3wK#iiW&#*h^D&R?jp7+/u&#(AP##XU8c$fSYW-J95_-Dp[g9wcO&#M-h1OcJlc-*vpw0xUX&#"
|
|
|
+ "OQFKNX@QI'IoPp7nb,QU//MQ&ZDkKP)X<WSVL(68uVl&#c'[0#(s1X&xm$Y%B7*K:eDA323j998GXbA#pwMs-jgD$9QISB-A_(aN4xoFM^@C58D0+Q+q3n0#3U1InDjF682-SjMXJK)("
|
|
|
+ "h$hxua_K]ul92%'BOU&#BRRh-slg8KDlr:%L71Ka:.A;%YULjDPmL<LYs8i#XwJOYaKPKc1h:'9Ke,g)b),78=I39B;xiY$bgGw-&.Zi9InXDuYa%G*f2Bq7mn9^#p1vv%#(Wi-;/Z5h"
|
|
|
+ "o;#2:;%d	v68C5g?ntX0X)pT`;%pB3q7mgGN)3%(P8nTd5L7GeA-GL@+%J3u2:(Yf>et`e;)f#Km8&+DC$I46>#Kr]]u-[=99tts1.qb#q72g1WJO81q+eN'03'eM>&1XxY-caEnO"
|
|
|
+ "j%2n8)),?ILR5^.Ibn<-X-Mq7[a82Lq:F&#ce+S9wsCK*x`569E8ew'He]h:sI[2LM$[guka3ZRd6:t%IG:;$%YiJ:Nq=?eAw;/:nnDq0(CYcMpG)qLN4$##&J<j$UpK<Q4a1]MupW^-"
|
|
|
+ "sj_$%[HK%'F####QRZJ::Y3EGl4'@%FkiAOg#p[##O`gukTfBHagL<LHw%q&OV0##F=6/:chIm0@eCP8X]:kFI%hl8hgO@RcBhS-@Qb$%+m=hPDLg*%K8ln(wcf3/'DW-$.lR?n[nCH-"
|
|
|
+ "eXOONTJlh:.RYF%3'p6sq:UIMA945&^HFS87@$EP2iG<-lCO$%c`uKGD3rC$x0BL8aFn--`ke%#HMP'vh1/R&O_J9'um,.<tx[@%wsJk&bUT2`0uMv7gg#qp/ij.L56'hl;.s5CUrxjO"
|
|
|
+ "M7-##.l+Au'A&O:-T72L]P`&=;ctp'XScX*rU.>-XTt,%OVU4)S1+R-#dg0/Nn?Ku1^0f$B*P:Rowwm-`0PKjYDDM'3]d39VZHEl4,.j']Pk-M.h^&:0FACm$maq-&sgw0t7/6(^xtk%"
|
|
|
+ "LuH88Fj-ekm>GA#_>568x6(OFRl-IZp`&b,_P'$M<Jnq79VsJW/mWS*PUiq76;]/NM_>hLbxfc$mj`,O;&%W2m`Zh:/)Uetw:aJ%]K9h:TcF]u_-Sj9,VK3M.*'&0D[Ca]J9gp8,kAW]"
|
|
|
+ "%(?A%R$f<->Zts'^kn=-^@c4%-pY6qI%J%1IGxfLU9CP8cbPlXv);C=b),<2mOvP8up,UVf3839acAWAW-W?#ao/^#%KYo8fRULNd2.>%m]UK:n%r$'sw]J;5pAoO_#2mO3n,'=H5(et"
|
|
|
+ "Hg*`+RLgv>=4U8guD$I%D:W>-r5V*%j*W:Kvej.Lp$<M-SGZ':+Q_k+uvOSLiEo(<aD/K<CCc`'Lx>'?;++O'>()jLR-^u68PHm8ZFWe+ej8h:9r6L*0//c&iH&R8pRbA#Kjm%upV1g:"
|
|
|
+ "a_#Ur7FuA#(tRh#.Y5K+@?3<-8m0$PEn;J:rh6?I6uG<-`wMU'ircp0LaE_OtlMb&1#6T.#FDKu#1Lw%u%+GM+X'e?YLfjM[VO0MbuFp7;>Q&#WIo)0@F%q7c#4XAXN-U&VB<HFF*qL("
|
|
|
+ "$/V,;(kXZejWO`<[5?\?ewY(*9=%wDc;,u<'9t3W-(H1th3+G]ucQ]kLs7df($/*JL]@*t7Bu_G3_7mp7<[email protected];x3B0lqp7Hf,^Ze7-##@/c58Mo(3;knp0%)A7?-W+eI'o8)b<"
|
|
|
+ "nKnw'Ho8C=Y>pqB>0ie&jhZ[?iLR@@_AvA-iQC(=ksRZRVp7`.=+NpBC%rh&3]R:8XDmE5^V8O(x<<aG/1N$#FX$0V5Y6x'aErI3I$7x%E`v<-BY,)%-?Psf*l?%C3.mM(=/M0:JxG'?"
|
|
|
+ "7WhH%o'a<-80g0NBxoO(GH<dM]n.+%q@jH?f.UsJ2Ggs&4<-e47&Kl+f//9@`b+?.TeN_&B8Ss?v;^Trk;f#YvJkl&w$]>-+k?'(<S:68tq*WoDfZu';mM?8X[ma8W%*`-=;D.(nc7/;"
|
|
|
+ ")g:T1=^J$&BRV(-lTmNB6xqB[@0*o.erM*<SWF]u2=st-*(6v>^](H.aREZSi,#1:[IXaZFOm<-ui#qUq2$##Ri;u75OK#(RtaW-K-F`S+cF]uN`-KMQ%rP/Xri.LRcB##=YL3BgM/3M"
|
|
|
+ "D?@f&1'BW-)Ju<L25gl8uhVm1hL$##*8###'A3/LkKW+(^rWX?5W_8g)a(m&K8P>#bmmWCMkk&#TR`C,5d>g)F;t,4:@_l8G/5h4vUd%&%950:VXD'QdWoY-F$BtUwmfe$YqL'8(PWX("
|
|
|
+ "P?^@Po3$##`MSs?DWBZ/S>+4%>fX,VWv/w'KD`LP5IbH;rTV>n3cEK8U#bX]l-/V+^lj3;vlMb&[5YQ8#pekX9JP3XUC72L,,?+Ni&co7ApnO*5NK,((W-i:$,kp'UDAO(G0Sq7MVjJs"
|
|
|
+ "bIu)'Z,*[>br5fX^:FPAWr-m2KgL<LUN098kTF&#lvo58=/vjDo;.;)Ka*hLR#/k=rKbxuV`>Q_nN6'8uTGT5g)uLv:873UpTLgH+#FgpH'_o1780Ph8KmxQJ8#H72L4@768@Tm&Q"
|
|
|
+ "h4CB/5OvmA&,Q&QbUoi$a_%3M01H)4x7I^&KQVgtFnV+;[Pc>[m4k//,]1?#`VY[Jr*3&&slRfLiVZJ:]?=K3Sw=[$=uRB?3xk48@aeg<Z'<$#4H)6,>e0jT6'N#(q%.O=?2S]u*(m<-"
|
|
|
+ "V8J'(1)G][68hW$5'q[GC&5j`TE?m'esFGNRM)j,ffZ?-qx8;->g4t*:CIP/[Qap7/9'#(1sao7w-.qNUdkJ)tCF&#B^;[email protected]$m%#QvQS8U@)2Z+3K:AKM5i"
|
|
|
+ "sZ88+dKQ)W6>J%CL<KE>`.d*(B`-n8D9oK<Up]c$X$(,)M8Zt7/[rdkqTgl-0cuGMv'?>-XV1q['-5k'cAZ69e;D_?$ZPP&s^+7])$*$#@QYi9,5P	r+$%CE=68>K8r0=dSC%%(@p7"
|
|
|
+ ".m7jilQ02'0-VWAg<a/''3u.=4L$Y)6k/K:_[3=&jvL<L0C/2'v:^;-DIBW,B4E68:kZ;%?8(Q8BH=kO65BW?xSG&#@uU,DS*,?.+(o(#1vCS8#CHF>TlGW'b)Tq7VT9q^*^$$.:&N@@"
|
|
|
+ "$&)WHtPm*5_rO0&e%K&#-30j(E4#'Zb.o/(Tpm$>K'f@[PvFl,hfINTNU6u'0pao7%XUp9]5.>%h`8_=VYbxuel.NTSsJfLacFu3B'lQSu/m6-Oqem8T+oE--$0a/k]uj9EwsG>%veR*"
|
|
|
+ "hv^BFpQj:K'#SJ,sB-'#](j.Lg92rTw-*n%@/;39rrJF,l#qV%OrtBeC6/,;qB3ebNW[?,Hqj2L.1NP&GjUR=1D8QaS3Up&@*9wP?+lo7b?@%'k4`p0Z$22%K3+iCZj?XJN4Nm&+YF]u"
|
|
|
+ "@-W$U%VEQ/,,>>#)D<h#`)h0:<Q6909ua+&VU%n2:cG3FJ-%@Bj-DgLr`Hw&HAKjKjseK</xKT*)B,N9X3]krc12t'pgTV(Lv-tL[xg_%=M_q7a^x?7Ubd>#%8cY#YZ?=,`Wdxu/ae&#"
|
|
|
+ "w6)R89tI#6@s'(6Bf7a&?S=^ZI_kS&ai`&=tE72L_D,;^R)7[$s<Eh#c&)q.MXI%#v9ROa5FZO%sF7q7Nwb&#ptUJ:aqJe$Sl68%.D###EC><?-aF&#RNQv>o8lKN%5/$(vdfq7+ebA#"
|
|
|
+ "u1p]ovUKW&Y%q]'>$1@-[xfn$7ZTp7mM,G,Ko7a&Gu%G[RMxJs[0MM%wci.LFDK)(<c`Q8N)jEIF*+?P2a8g%)$q]o2aH8C&<SibC/q,(e:v;-b#6[$NtDZ84Je2KNvB#$P5?tQ3nt(0"
|
|
|
+ "d=j.LQf./Ll33+(;q3L-w=8dX$#WF&uIJ@-bfI>%:_i2B5CsR8&9Z&#=mPEnm0f`<&c)QL5uJ#%u%lJj+D-r;BoFDoS97h5g)E#o:&S4weDF,9^Hoe`h*L+_a*NrLW-1pG_&2UdB8"
|
|
|
+ "6e%B/:=>)N4xeW.*wft-;$'58-ESqr<b?UI(_%@[P46>#U`'6AQ]m&6/`Z>#S?YY#Vc;r7U2&326d=w&H####?TZ`*4?&.MK?LP8Vxg>$[QXc%QJv92.(Db*B)gb*BM9dM*hJMAo*c&#"
|
|
|
+ "b0v=Pjer]$gG&JXDf->'StvU7505l9$AFvgYRI^&<^b68?j#q9QX4SM'RO#&sL1IM.rJfLUAj221]d##DW=m83u5;'bYx,*Sl0hL(W;;$doB&O/TQ:(Z^xBdLjL<Lni;''X.`$#8+1GD"
|
|
|
+ ":k$YUWsbn8ogh6rxZ2Z9]%nd+>V#*8U_72Lh+2Q8Cj0i:6hp&$C/:p(HK>T8Y[gHQ4`4)'$Ab(Nof%V'8hL&#<NEdtg(n'=S1A(Q1/I&4([%dM`,Iu'1:_hL>SfD07&6D<fp8dHM7/g+"
|
|
|
+ "tlPN9J*rKaPct&?'uBCem^jn%9_K)<,C5K3s=5g&GmJb*[SYq7K;TRLGCsM-$$;S%:Y@r7AK0pprpL<Lrh,q7e/%KWK:50I^+m'vi`3?%Zp+<-d+$L-Sv:@.o19n$s0&39;kn;S%BSq*"
|
|
|
+ "$3WoJSCLweV[aZ'MQIjO<7;X-X;&+dMLvu#^UsGEC9WEc[X(wI7#2.(F0jV*eZf<-Qv3J-c+J5AlrB#$p(H68LvEA'q3n0#m,[`*8Ft)FcYgEud]CWfm68,(aLA$@EFTgLXoBq/UPlp7"
|
|
|
+ ":d[/;r_ix=:TF`S5H-b<LI&HY(K=h#)]Lk$K14lVfm:x$H<3^Ql<M`$OhapBnkup'D#L$Pb_`N*g]2e;X/Dtg,bsj&K#2[-:iYr'_wgH)NUIR8a1n#S?Yej'h8^58UbZd+^FKD*T@;6A"
|
|
|
+ "7aQC[K8d-(v6GI$x:T<&'Gp5Uf>@M.*J:;$-rv29'M]8qMv-tLp,'886iaC=Hb*YJoKJ,(j%K=H`K.v9HggqBIiZu'QvBT.#=)0ukruV&.)3=(^1`o*Pj4<-<aN((^7('#Z0wK#5GX@7"
|
|
|
+ "u][`*S^43933A4rl][`*O4CgLEl]v$1Q3AeF37dbXk,.)vj#x'd`;qgbQR%FW,2(?LO=s%Sc68%NP'##Aotl8x=BE#j1UD([3$M(]UI2LX3RpKN@;/#f'f/&_mt&F)XdF<9t4)Qa.*kT"
|
|
|
+ "LwQ'(TTB9.xH'>#MJ+gLq9-##@HuZPN0]u:h7.T..G:;$/Usj(T7`Q8tT72LnYl<-qx8;-HV7Q-&Xdx%1a,hC=0u+HlsV>nuIQL-5<N?)NBS)QN*_I,?&)2'IM%L3I)X((e/dl2&8'<M"
|
|
|
+ ":^#M*Q+[T.Xri.LYS3v%fF`68h;b-X[/En'CR.q7E)p'/kle2HM,u;^%OKC-N+Ll%F9CF<Nf'^#t2L,;27W:0O@6##U6W7:$rJfLWHj$#)woqBefIZ.PK<b*t7ed;p*_m;4ExK#h@&]>"
|
|
|
+ "_>@kXQtMacfD.m-VAb8;IReM3$wf0''hra*so568'Ip&vRs849'MRYSp%:t:h5qSgwpEr$B>Q,;s(C#$)`svQuF$##-D,##,g68@2[T;.XSdN9Qe)rpt._K-#5wF)sP'##p#C0c%-Gb%"
|
|
|
+ "hd+<-j'Ai*x&&HMkT]C'OSl##5RG[JXaHN;d'uA#x._U;.`PU@(Z3dt4r152@:v,'R.Sj'w#0<-;kPI)FfJ&#AYJ&#//)>-k=m=*XnK$>=)72L]0I%>.G690a:$##<,);?;72#?x9+d;"
|
|
|
+ "^V'9;jY@;)br#q^YQpx:X#Te$Z^'=-=bGhLf:D6&bNwZ9-ZD#n^9HhLMr5G;']d&6'wYmTFmL<LD)F^%[tC'8;+9E#C$g%#5Y>q9wI>P(9mI[>kC-ekLC/R&CH+s'B;K-M6$EB%is00:"
|
|
|
+ "+A4[7xks.LrNk0&E)wILYF@2L'0Nb$+pv<(2.768/FrY&h$^3i&@+G%JT'<-,v`3;_)I9M^AE]CN?Cl2AZg+%4iTpT3<n-&%H%b<FDj2M<hH=&Eh<2Len$b*aTX=-8QxN)k11IM1c^j%"
|
|
|
+ "9s<L<NFSo)B?+<-(GxsF,^-Eh@$4dXhN$+#rxK8'je'D7k`e;)2pYwPA'_p9&@^18ml1^[@g4t*[JOa*[=Qp7(qJ_oOL^('7fB&Hq-:sf,sNj8xq^>$U4O]GKx'm9)b@p7YsvK3w^YR-"
|
|
|
+ "CdQ*:Ir<($u&)#(&?L9Rg3H)4fiEp^iI9O8KnTj,]H?D*r7'M;PwZ9K0E^k&-cpI;.p/6_vwoFMV<->#%Xi.LxVnrU(4&8/P+:hLSKj$#U%]49t'I:rgMi'FL@a:0Y-uA[39',(vbma*"
|
|
|
+ "hU%<-SRF`Tt:542R_VV$p@[p8DV[A,?1839FWdF<TddF<9Ah-6&9tWoDlh]&1SpGMq>Ti1O*H&#(AL8[_P%.M>v^-))qOT*F5Cq0`Ye%+$B6i:7@0IX<N+T+0MlMBPQ*Vj>SsD<U4JHY"
|
|
|
+ "8kD2)2fU/M#$e.)T4,_=8hLim[&);?UkK'-x?'(:siIfL<$pFM`i<?%W(mGDHM%>iWP,##P`%/L<eXi:@Z9C.7o=@(pXdAO/NLQ8lPl+HPOQa8wD8=^GlPa8TKI1CjhsCTSLJM'/Wl>-"
|
|
|
+ "S(qw%sf/@%#B6;/U7K]uZbi^Oc^2n<bhPmUkMw>%t<)'mEVE''n`WnJra$^TKvX5B>;_aSEK',(hwa0:i4G?.Bci.(X[?b*($,=-n<.Q%`(X=?+@Am*Js0&=3bh8K]mL<LoNs'6,'85`"
|
|
|
+ "0?t/'_U59@]ddF<#LdF<eWdF<OuN/45rY<-L@&#+fm>69=Lb,OcZV/);TTm8VI;?%OtJ<(b4mq7M6:u?KRdF<gR@2L=FNU-<b[(9c/ML3m;Z[$oF3g)GAWqpARc=<ROu7cL5l;-[A]%/"
|
|
|
+ "+fsd;l#SafT/f*W]0=O'$(Tb<[)*@e775R-:Yob%g*>l*:xP?Yb.5)%w_I?7uk5JC+FS(m#i'k.'a0i)9<7b'fs'59hq$*5Uhv##pi^8+hIEBF`nvo`;'l0.^S1<-wUK2/Coh58KKhLj"
|
|
|
+ "M=SO*rfO`+qC`W-On.=AJ56>>i2@2LH6A:&5q`?9I3@@'04&p2/LVa*T-4<-i3;M9UvZd+N7>b*eIwg:CC)c<>nO&#<IGe;__.thjZl<%w(Wk2xmp4Q@I#I9,DF]u7-P=.-_:YJ]aS@V"
|
|
|
+ "?6*C()dOp7:WL,b&3Rg/.cmM9&r^>$(>.Z-I&J(Q0Hd5Q%7Co-b`-c<N(6r@ip+AurK<m86QIth*#v;-OBqi+L7wDE-Ir8K['m+DDSLwK&/.?-V%U_%3:qKNu$_b*B-kp7NaD'QdWQPK"
|
|
|
+ "Yq[@>P)hI;*_F]u`Rb[.j8_Q/<&>uu+VsH$sM9TA%?)(vmJ80),P7E>)tjD%2L=-t#fK[%`v=Q8<FfNkgg^oIbah*#8/Qt$F&:K*-(N/'+1vMB,u()-a.VUU*#[e%gAAO(S>WlA2);Sa"
|
|
|
+ ">gXm8YB`1d@K#n]76-a$U,mF<fX]idqd)<3,]J7JmW4`6]uks=4-72L(jEk+:bJ0M^q-8Dm_Z?0olP1C9Sa&H[d&c$ooQUj]Exd*3ZM@-WGW2%s',B-_M%>%Ul:#/'xoFM9QX-$.QN'>"
|
|
|
+ "[%$Z$uF6pA6Ki2O5:8w*vP1<-1`[G,)-m#>0`P&#eb#.3i)rtB61(o'$?X3B</R90;eZ]%Ncq;-Tl]#F>2Qft^ae_5tKL9MUe9b*sLEQ95C&`=G?@Mj=wh*'3E>=-<)Gt*Iw)'QG:`@I"
|
|
|
+ "wOf7&]1i'S01B+Ev/Nac#9S;=;YQpg_6U`*kVY39xK,[/6Aj7:'1Bm-_1EYfa1+o&o4hp7KN_Q(OlIo@S%;jVdn0'1<Vc52=u`3^o-n1'g4v58Hj&6_t7$##?M)c<$bgQ_'SY((-xkA#"
|
|
|
+ "Y(,p'H9rIVY-b,'%bCPF7.J<Up^,(dU1VY*5#WkTU>h19w,WQhLI)3S#f$2(eb,jr*b;3Vw]*7NH%$c4Vs,eD9>XW8?N]o+(*pgC%/72LV-u<Hp,3@e^9UB1J+ak9-TN/mhKPg+AJYd$"
|
|
|
+ "MlvAF_jCK*.O-^(63adMT->W%iewS8W6m2rtCpo'RS1R84=@paTKt)>=%&1[)*vp'u+x,VrwN;&]kuO9JDbg=pO$J*.jVe;u'm0dr9l,<*wMK*Oe=g8lV_KEBFkO'oU]^=[-792#ok,)"
|
|
|
+ "i]lR8qQ2oA8wcRCZ^7w/Njh;?.stX?Q1>S1q4Bn$)K1<-rGdO'$Wr.Lc.CG)$/*JL4tNR/,SVO3,aUw'DJN:)Ss;wGn9A32ijw%FL+Z0Fn.U9;reSq)bmI32U==5ALuG&#Vf1398/pVo"
|
|
|
+ "1*c-(aY168o<`JsSbk-,1N;$>0:OUas(3:8Z972LSfF8eb=c-;>SPw7.6hn3m`9^Xkn(r.qS[0;T%&Qc=+STRxX'q1BNk3&*eu2;&8q$&x>Q#Q7^Tf+6<(d%ZVmj2bDi%.3L2n+4W'$P"
|
|
|
+ "iDDG)g,r%+?,$@?uou5tSe2aN_AQU*<h`e-GI7)?OK2A.d7_c)?wQ5AS@DL3r#7fSkgl6-++D:'A,uq7SvlB$pcpH'q3n0#_%dY#xCpr-l<F0NR@-##FEV6NTF6##$l84N1w?AO>'IAO"
|
|
|
+ "URQ##V^Fv-XFbGM7Fl(N<3DhLGF%q.1rC$#:T__&Pi68%0xi_&[qFJ(77j_&JWoF.V735&T,[R*:xFR*K5>>#`bW-?4Ne_&6Ne_&6Ne_&n`kr-#GJcM6X;uM6X;uM(.a..^2TkL%oR(#"
|
|
|
+ ";u.T%fAr%4tJ8&><1=GHZ_+m9/#H1F^R#SC#*N=BA9(D?v[UiFY>>^8p,KKF.W]L29uLkLlu/+4T<XoIB&hx=T1PcDaB&;HH+-AFr?(m9HZV)FKS8JCw;SD=6[^/DZUL`EUDf]GGlG&>"
|
|
|
+ "w$)F./^n3+rlo+DB;5sIYGNk+i1t-69Jg--0pao7Sm#K)pdHW&;LuDNH@H>#/X-TI(;P>#,Gc>#0Su>#4`1?#8lC?#<xU?#@.i?#D:%@#HF7@#LRI@#P_[@#Tkn@#Xw*A#]-=A#a9OA#"
|
|
|
+ "d<F&#*;G##.GY##2Sl##6`($#:l:$#>xL$#B.`$#F:r$#JF.%#NR@%#R_R%#Vke%#Zww%#_-4^Rh%Sflr-k'MS.o?.5/sWel/wpEM0%3'/1)K^f1-d>G21&v(35>V`39V7A4=onx4"
|
|
|
+ "A1OY5EI0;6Ibgr6M$HS7Q<)58C5w,;WoA*#[%T*#`1g*#d=#+#hI5+#lUG+#pbY+#tnl+#x$),#&1;,#*=M,#.I`,#2Ur,#6b.-#;w[H#iQtA#m^0B#qjBB#uvTB##-hB#'9$C#+E6C#"
|
|
|
+ "/QHC#3^ZC#7jmC#;v)D#?,<D#C8ND#GDaD#KPsD#O]/E#g1A5#KA*1#gC17#MGd;#8(02#L-d3#rWM4#Hga1#,<w0#T.j<#O#'2#CYN1#qa^:#_4m3#o@/=#eG8=#t8J5#`+78#4uI-#"
|
|
|
+ "m3B2#SB[8#Q0@8#i[*9#iOn8#1Nm;#^sN9#qh<9#:=x-#P;K2#$%X9#bC+.#Rg;<#mN=.#MTF.#RZO.#2?)4#Y#(/#[)1/#b;L/#dAU/#0Sv;#lY$0#n`-0#sf60#(F24#wrH0#%/e0#"
|
|
|
+ "TmD<#%JSMFove:CTBEXI:<eh2g)B,3h2^G3i;#d3jD>)4kMYD4lVu`4m`:&5niUA5@(A5BA1]PBB:xlBCC=2CDLXMCEUtiCf&0g2'tN?PGT4CPGT4CPGT4CPGT4CPGT4CPGT4CPGT4CP"
|
|
|
+ "GT4CPGT4CPGT4CPGT4CPGT4CPGT4CP-qekC`.9kEg^+F$kwViFJTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5o,^<-28ZI'O?;xp"
|
|
|
+ "O?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xp;7q-#lLYI:xvD=#";
|
|
|
+#endif /* NK_INCLUDE_DEFAULT_FONT */
|
|
|
+
|
|
|
+#define NK_CURSOR_DATA_W 90
|
|
|
+#define NK_CURSOR_DATA_H 27
|
|
|
+NK_GLOBAL const char nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] =
|
|
|
+{
|
|
|
+ "..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX"
|
|
|
+ "..- -X.....X- X.X - X.X -X.....X - X.....X"
|
|
|
+ "--- -XXX.XXX- X...X - X...X -X....X - X....X"
|
|
|
+ "X - X.X - X.....X - X.....X -X...X - X...X"
|
|
|
+ "XX - X.X -X.......X- X.......X -X..X.X - X.X..X"
|
|
|
+ "X.X - X.X -XXXX.XXXX- XXXX.XXXX -X.X X.X - X.X X.X"
|
|
|
+ "X..X - X.X - X.X - X.X -XX X.X - X.X XX"
|
|
|
+ "X...X - X.X - X.X - XX X.X XX - X.X - X.X "
|
|
|
+ "X....X - X.X - X.X - X.X X.X X.X - X.X - X.X "
|
|
|
+ "X.....X - X.X - X.X - X..X X.X X..X - X.X - X.X "
|
|
|
+ "X......X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X XX-XX X.X "
|
|
|
+ "X.......X - X.X - X.X -X.....................X- X.X X.X-X.X X.X "
|
|
|
+ "X........X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X..X-X..X.X "
|
|
|
+ "X.........X -XXX.XXX- X.X - X..X X.X X..X - X...X-X...X "
|
|
|
+ "X..........X-X.....X- X.X - X.X X.X X.X - X....X-X....X "
|
|
|
+ "X......XXXXX-XXXXXXX- X.X - XX X.X XX - X.....X-X.....X "
|
|
|
+ "X...X..X --------- X.X - X.X - XXXXXXX-XXXXXXX "
|
|
|
+ "X..X X..X - -XXXX.XXXX- XXXX.XXXX ------------------------------------"
|
|
|
+ "X.X X..X - -X.......X- X.......X - XX XX - "
|
|
|
+ "XX X..X - - X.....X - X.....X - X.X X.X - "
|
|
|
+ " X..X - X...X - X...X - X..X X..X - "
|
|
|
+ " XX - X.X - X.X - X...XXXXXXXXXXXXX...X - "
|
|
|
+ "------------ - X - X -X.....................X- "
|
|
|
+ " ----------------------------------- X...XXXXXXXXXXXXX...X - "
|
|
|
+ " - X..X X..X - "
|
|
|
+ " - X.X X.X - "
|
|
|
+ " - XX XX - "
|
|
|
+};
|
|
|
+
|
|
|
+#ifdef __clang__
|
|
|
+#pragma clang diagnostic pop
|
|
|
+#elif defined(__GNUC__) || defined(__GNUG__)
|
|
|
+#pragma GCC diagnostic pop
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_INTERN unsigned int
|
|
|
+nk_decompress_length(unsigned char *input)
|
|
|
+{
|
|
|
+ return (unsigned int)((input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_GLOBAL unsigned char *nk__barrier;
|
|
|
+NK_GLOBAL unsigned char *nk__barrier2;
|
|
|
+NK_GLOBAL unsigned char *nk__barrier3;
|
|
|
+NK_GLOBAL unsigned char *nk__barrier4;
|
|
|
+NK_GLOBAL unsigned char *nk__dout;
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk__match(unsigned char *data, unsigned int length)
|
|
|
+{
|
|
|
+ /* INVERSE of memmove... write each byte before copying the next...*/
|
|
|
+ NK_ASSERT (nk__dout + length <= nk__barrier);
|
|
|
+ if (nk__dout + length > nk__barrier) { nk__dout += length; return; }
|
|
|
+ if (data < nk__barrier4) { nk__dout = nk__barrier+1; return; }
|
|
|
+ while (length--) *nk__dout++ = *data++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk__lit(unsigned char *data, unsigned int length)
|
|
|
+{
|
|
|
+ NK_ASSERT (nk__dout + length <= nk__barrier);
|
|
|
+ if (nk__dout + length > nk__barrier) { nk__dout += length; return; }
|
|
|
+ if (data < nk__barrier2) { nk__dout = nk__barrier+1; return; }
|
|
|
+ NK_MEMCPY(nk__dout, data, length);
|
|
|
+ nk__dout += length;
|
|
|
+}
|
|
|
+
|
|
|
+#define nk__in2(x) ((i[x] << 8) + i[(x)+1])
|
|
|
+#define nk__in3(x) ((i[x] << 16) + nk__in2((x)+1))
|
|
|
+#define nk__in4(x) ((i[x] << 24) + nk__in3((x)+1))
|
|
|
+
|
|
|
+NK_INTERN unsigned char*
|
|
|
+nk_decompress_token(unsigned char *i)
|
|
|
+{
|
|
|
+ if (*i >= 0x20) { /* use fewer if's for cases that expand small */
|
|
|
+ if (*i >= 0x80) nk__match(nk__dout-i[1]-1, (unsigned int)i[0] - 0x80 + 1), i += 2;
|
|
|
+ else if (*i >= 0x40) nk__match(nk__dout-(nk__in2(0) - 0x4000 + 1), (unsigned int)i[2]+1), i += 3;
|
|
|
+ else /* *i >= 0x20 */ nk__lit(i+1, (unsigned int)i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1);
|
|
|
+ } else { /* more ifs for cases that expand large, since overhead is amortized */
|
|
|
+ if (*i >= 0x18) nk__match(nk__dout-(unsigned int)(nk__in3(0) - 0x180000 + 1), (unsigned int)i[3]+1), i += 4;
|
|
|
+ else if (*i >= 0x10) nk__match(nk__dout-(unsigned int)(nk__in3(0) - 0x100000 + 1), (unsigned int)nk__in2(3)+1), i += 5;
|
|
|
+ else if (*i >= 0x08) nk__lit(i+2, (unsigned int)nk__in2(0) - 0x0800 + 1), i += 2 + (nk__in2(0) - 0x0800 + 1);
|
|
|
+ else if (*i == 0x07) nk__lit(i+3, (unsigned int)nk__in2(1) + 1), i += 3 + (nk__in2(1) + 1);
|
|
|
+ else if (*i == 0x06) nk__match(nk__dout-(unsigned int)(nk__in3(1)+1), i[4]+1u), i += 5;
|
|
|
+ else if (*i == 0x04) nk__match(nk__dout-(unsigned int)(nk__in3(1)+1), (unsigned int)nk__in2(4)+1u), i += 6;
|
|
|
+ }
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN unsigned int
|
|
|
+nk_adler32(unsigned int adler32, unsigned char *buffer, unsigned int buflen)
|
|
|
+{
|
|
|
+ const unsigned long ADLER_MOD = 65521;
|
|
|
+ unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
|
|
|
+ unsigned long blocklen, i;
|
|
|
+
|
|
|
+ blocklen = buflen % 5552;
|
|
|
+ while (buflen) {
|
|
|
+ for (i=0; i + 7 < blocklen; i += 8) {
|
|
|
+ s1 += buffer[0]; s2 += s1;
|
|
|
+ s1 += buffer[1]; s2 += s1;
|
|
|
+ s1 += buffer[2]; s2 += s1;
|
|
|
+ s1 += buffer[3]; s2 += s1;
|
|
|
+ s1 += buffer[4]; s2 += s1;
|
|
|
+ s1 += buffer[5]; s2 += s1;
|
|
|
+ s1 += buffer[6]; s2 += s1;
|
|
|
+ s1 += buffer[7]; s2 += s1;
|
|
|
+ buffer += 8;
|
|
|
+ }
|
|
|
+ for (; i < blocklen; ++i) {
|
|
|
+ s1 += *buffer++; s2 += s1;
|
|
|
+ }
|
|
|
+
|
|
|
+ s1 %= ADLER_MOD; s2 %= ADLER_MOD;
|
|
|
+ buflen -= (unsigned int)blocklen;
|
|
|
+ blocklen = 5552;
|
|
|
+ }
|
|
|
+ return (unsigned int)(s2 << 16) + (unsigned int)s1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN unsigned int
|
|
|
+nk_decompress(unsigned char *output, unsigned char *i, unsigned int length)
|
|
|
+{
|
|
|
+ unsigned int olen;
|
|
|
+ if (nk__in4(0) != 0x57bC0000) return 0;
|
|
|
+ if (nk__in4(4) != 0) return 0; /* error! stream is > 4GB */
|
|
|
+ olen = nk_decompress_length(i);
|
|
|
+ nk__barrier2 = i;
|
|
|
+ nk__barrier3 = i+length;
|
|
|
+ nk__barrier = output + olen;
|
|
|
+ nk__barrier4 = output;
|
|
|
+ i += 16;
|
|
|
+
|
|
|
+ nk__dout = output;
|
|
|
+ for (;;) {
|
|
|
+ unsigned char *old_i = i;
|
|
|
+ i = nk_decompress_token(i);
|
|
|
+ if (i == old_i) {
|
|
|
+ if (*i == 0x05 && i[1] == 0xfa) {
|
|
|
+ NK_ASSERT(nk__dout == output + olen);
|
|
|
+ if (nk__dout != output + olen) return 0;
|
|
|
+ if (nk_adler32(1, output, olen) != (unsigned int) nk__in4(2))
|
|
|
+ return 0;
|
|
|
+ return olen;
|
|
|
+ } else {
|
|
|
+ NK_ASSERT(0); /* NOTREACHED */
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ NK_ASSERT(nk__dout <= output + olen);
|
|
|
+ if (nk__dout > output + olen)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN unsigned int
|
|
|
+nk_decode_85_byte(char c)
|
|
|
+{ return (unsigned int)((c >= '\\') ? c-36 : c-35); }
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_decode_85(unsigned char* dst, const unsigned char* src)
|
|
|
+{
|
|
|
+ while (*src)
|
|
|
+ {
|
|
|
+ unsigned int tmp =
|
|
|
+ nk_decode_85_byte((char)src[0]) +
|
|
|
+ 85 * (nk_decode_85_byte((char)src[1]) +
|
|
|
+ 85 * (nk_decode_85_byte((char)src[2]) +
|
|
|
+ 85 * (nk_decode_85_byte((char)src[3]) +
|
|
|
+ 85 * nk_decode_85_byte((char)src[4]))));
|
|
|
+
|
|
|
+ /* we can't assume little-endianess. */
|
|
|
+ dst[0] = (unsigned char)((tmp >> 0) & 0xFF);
|
|
|
+ dst[1] = (unsigned char)((tmp >> 8) & 0xFF);
|
|
|
+ dst[2] = (unsigned char)((tmp >> 16) & 0xFF);
|
|
|
+ dst[3] = (unsigned char)((tmp >> 24) & 0xFF);
|
|
|
+
|
|
|
+ src += 5;
|
|
|
+ dst += 4;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * FONT ATLAS
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API struct nk_font_config
|
|
|
+nk_font_config(float pixel_height)
|
|
|
+{
|
|
|
+ struct nk_font_config cfg;
|
|
|
+ nk_zero_struct(cfg);
|
|
|
+ cfg.ttf_blob = 0;
|
|
|
+ cfg.ttf_size = 0;
|
|
|
+ cfg.ttf_data_owned_by_atlas = 0;
|
|
|
+ cfg.size = pixel_height;
|
|
|
+ cfg.oversample_h = 3;
|
|
|
+ cfg.oversample_v = 1;
|
|
|
+ cfg.pixel_snap = 0;
|
|
|
+ cfg.coord_type = NK_COORD_UV;
|
|
|
+ cfg.spacing = nk_vec2(0,0);
|
|
|
+ cfg.range = nk_font_default_glyph_ranges();
|
|
|
+ cfg.merge_mode = 0;
|
|
|
+ cfg.fallback_glyph = '?';
|
|
|
+ cfg.font = 0;
|
|
|
+ return cfg;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_init_default(struct nk_font_atlas *atlas)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ if (!atlas) return;
|
|
|
+ nk_zero_struct(*atlas);
|
|
|
+ atlas->temporary.userdata.ptr = 0;
|
|
|
+ atlas->temporary.alloc = nk_malloc;
|
|
|
+ atlas->temporary.free = nk_mfree;
|
|
|
+ atlas->permanent.userdata.ptr = 0;
|
|
|
+ atlas->permanent.alloc = nk_malloc;
|
|
|
+ atlas->permanent.free = nk_mfree;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_init(struct nk_font_atlas *atlas, struct nk_allocator *alloc)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+ if (!atlas || !alloc) return;
|
|
|
+ nk_zero_struct(*atlas);
|
|
|
+ atlas->permanent = *alloc;
|
|
|
+ atlas->temporary = *alloc;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_init_custom(struct nk_font_atlas *atlas,
|
|
|
+ struct nk_allocator *permanent, struct nk_allocator *temporary)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(permanent);
|
|
|
+ NK_ASSERT(temporary);
|
|
|
+ if (!atlas || !permanent || !temporary) return;
|
|
|
+ nk_zero_struct(*atlas);
|
|
|
+ atlas->permanent = *permanent;
|
|
|
+ atlas->temporary = *temporary;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_begin(struct nk_font_atlas *atlas)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc && atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc && atlas->permanent.free);
|
|
|
+ if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free ||
|
|
|
+ !atlas->temporary.alloc || !atlas->temporary.free) return;
|
|
|
+ if (atlas->glyphs) {
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs);
|
|
|
+ atlas->glyphs = 0;
|
|
|
+ }
|
|
|
+ if (atlas->pixel) {
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, atlas->pixel);
|
|
|
+ atlas->pixel = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add(struct nk_font_atlas *atlas, const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ struct nk_font *font = 0;
|
|
|
+ struct nk_font_config *cfg;
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+
|
|
|
+ NK_ASSERT(config);
|
|
|
+ NK_ASSERT(config->ttf_blob);
|
|
|
+ NK_ASSERT(config->ttf_size);
|
|
|
+ NK_ASSERT(config->size > 0.0f);
|
|
|
+
|
|
|
+ if (!atlas || !config || !config->ttf_blob || !config->ttf_size || config->size <= 0.0f||
|
|
|
+ !atlas->permanent.alloc || !atlas->permanent.free ||
|
|
|
+ !atlas->temporary.alloc || !atlas->temporary.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* allocate and insert font config into list */
|
|
|
+ cfg = (struct nk_font_config*)
|
|
|
+ atlas->permanent.alloc(atlas->permanent.userdata,0, sizeof(struct nk_font_config));
|
|
|
+ NK_MEMCPY(cfg, config, sizeof(*config));
|
|
|
+ if (!atlas->config) {
|
|
|
+ atlas->config = cfg;
|
|
|
+ cfg->next = 0;
|
|
|
+ } else {
|
|
|
+ cfg->next = atlas->config;
|
|
|
+ atlas->config = cfg;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* allocate new font */
|
|
|
+ if (!config->merge_mode) {
|
|
|
+ font = (struct nk_font*)
|
|
|
+ atlas->permanent.alloc(atlas->permanent.userdata,0, sizeof(struct nk_font));
|
|
|
+ NK_ASSERT(font);
|
|
|
+ if (!font) return 0;
|
|
|
+ font->config = cfg;
|
|
|
+ } else {
|
|
|
+ NK_ASSERT(atlas->font_num);
|
|
|
+ font = atlas->fonts;
|
|
|
+ font->config = cfg;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* insert font into list */
|
|
|
+ if (!config->merge_mode) {
|
|
|
+ if (!atlas->fonts) {
|
|
|
+ atlas->fonts = font;
|
|
|
+ font->next = 0;
|
|
|
+ } else {
|
|
|
+ font->next = atlas->fonts;
|
|
|
+ atlas->fonts = font;
|
|
|
+ }
|
|
|
+ cfg->font = &font->info;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* create own copy of .TTF font blob */
|
|
|
+ if (!config->ttf_data_owned_by_atlas) {
|
|
|
+ cfg->ttf_blob = atlas->permanent.alloc(atlas->permanent.userdata,0, cfg->ttf_size);
|
|
|
+ NK_ASSERT(cfg->ttf_blob);
|
|
|
+ if (!cfg->ttf_blob) {
|
|
|
+ atlas->font_num++;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ NK_MEMCPY(cfg->ttf_blob, config->ttf_blob, cfg->ttf_size);
|
|
|
+ cfg->ttf_data_owned_by_atlas = 1;
|
|
|
+ }
|
|
|
+ atlas->font_num++;
|
|
|
+ return font;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add_from_memory(struct nk_font_atlas *atlas, void *memory,
|
|
|
+ nk_size size, float height, const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ struct nk_font_config cfg;
|
|
|
+ NK_ASSERT(memory);
|
|
|
+ NK_ASSERT(size);
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+ if (!atlas || !atlas->temporary.alloc || !atlas->temporary.free || !memory || !size ||
|
|
|
+ !atlas->permanent.alloc || !atlas->permanent.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ cfg = (config) ? *config: nk_font_config(height);
|
|
|
+ cfg.ttf_blob = memory;
|
|
|
+ cfg.ttf_size = size;
|
|
|
+ cfg.size = height;
|
|
|
+ cfg.ttf_data_owned_by_atlas = 0;
|
|
|
+ return nk_font_atlas_add(atlas, &cfg);
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_STANDARD_IO
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add_from_file(struct nk_font_atlas *atlas, const char *file_path,
|
|
|
+ float height, const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ nk_size size;
|
|
|
+ char *memory;
|
|
|
+ struct nk_font_config cfg;
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+
|
|
|
+ if (!atlas || !file_path) return 0;
|
|
|
+ memory = nk_file_load(file_path, &size, &atlas->permanent);
|
|
|
+ if (!memory) return 0;
|
|
|
+
|
|
|
+ cfg = (config) ? *config: nk_font_config(height);
|
|
|
+ cfg.ttf_blob = memory;
|
|
|
+ cfg.ttf_size = size;
|
|
|
+ cfg.size = height;
|
|
|
+ cfg.ttf_data_owned_by_atlas = 1;
|
|
|
+ return nk_font_atlas_add(atlas, &cfg);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add_compressed(struct nk_font_atlas *atlas,
|
|
|
+ void *compressed_data, nk_size compressed_size, float height,
|
|
|
+ const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ unsigned int decompressed_size;
|
|
|
+ void *decompressed_data;
|
|
|
+ struct nk_font_config cfg;
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+
|
|
|
+ NK_ASSERT(compressed_data);
|
|
|
+ NK_ASSERT(compressed_size);
|
|
|
+ if (!atlas || !compressed_data || !atlas->temporary.alloc || !atlas->temporary.free ||
|
|
|
+ !atlas->permanent.alloc || !atlas->permanent.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ decompressed_size = nk_decompress_length((unsigned char*)compressed_data);
|
|
|
+ decompressed_data = atlas->permanent.alloc(atlas->permanent.userdata,0,decompressed_size);
|
|
|
+ NK_ASSERT(decompressed_data);
|
|
|
+ if (!decompressed_data) return 0;
|
|
|
+ nk_decompress((unsigned char*)decompressed_data, (unsigned char*)compressed_data,
|
|
|
+ (unsigned int)compressed_size);
|
|
|
+
|
|
|
+ cfg = (config) ? *config: nk_font_config(height);
|
|
|
+ cfg.ttf_blob = decompressed_data;
|
|
|
+ cfg.ttf_size = decompressed_size;
|
|
|
+ cfg.size = height;
|
|
|
+ cfg.ttf_data_owned_by_atlas = 1;
|
|
|
+ return nk_font_atlas_add(atlas, &cfg);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add_compressed_base85(struct nk_font_atlas *atlas,
|
|
|
+ const char *data_base85, float height, const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ int compressed_size;
|
|
|
+ void *compressed_data;
|
|
|
+ struct nk_font *font;
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+
|
|
|
+ NK_ASSERT(data_base85);
|
|
|
+ if (!atlas || !data_base85 || !atlas->temporary.alloc || !atlas->temporary.free ||
|
|
|
+ !atlas->permanent.alloc || !atlas->permanent.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ compressed_size = (((int)nk_strlen(data_base85) + 4) / 5) * 4;
|
|
|
+ compressed_data = atlas->temporary.alloc(atlas->temporary.userdata,0, (nk_size)compressed_size);
|
|
|
+ NK_ASSERT(compressed_data);
|
|
|
+ if (!compressed_data) return 0;
|
|
|
+ nk_decode_85((unsigned char*)compressed_data, (const unsigned char*)data_base85);
|
|
|
+ font = nk_font_atlas_add_compressed(atlas, compressed_data,
|
|
|
+ (nk_size)compressed_size, height, config);
|
|
|
+ atlas->temporary.free(atlas->temporary.userdata, compressed_data);
|
|
|
+ return font;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_FONT
|
|
|
+NK_API struct nk_font*
|
|
|
+nk_font_atlas_add_default(struct nk_font_atlas *atlas,
|
|
|
+ float pixel_height, const struct nk_font_config *config)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+ return nk_font_atlas_add_compressed_base85(atlas,
|
|
|
+ nk_proggy_clean_ttf_compressed_data_base85, pixel_height, config);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API const void*
|
|
|
+nk_font_atlas_bake(struct nk_font_atlas *atlas, int *width, int *height,
|
|
|
+ enum nk_font_atlas_format fmt)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ void *tmp = 0;
|
|
|
+ nk_size tmp_size, img_size;
|
|
|
+ struct nk_font *font_iter;
|
|
|
+ struct nk_font_baker *baker;
|
|
|
+
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+
|
|
|
+ NK_ASSERT(width);
|
|
|
+ NK_ASSERT(height);
|
|
|
+ if (!atlas || !width || !height ||
|
|
|
+ !atlas->temporary.alloc || !atlas->temporary.free ||
|
|
|
+ !atlas->permanent.alloc || !atlas->permanent.free)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_FONT
|
|
|
+ /* no font added so just use default font */
|
|
|
+ if (!atlas->font_num)
|
|
|
+ atlas->default_font = nk_font_atlas_add_default(atlas, 13.0f, 0);
|
|
|
+#endif
|
|
|
+ NK_ASSERT(atlas->font_num);
|
|
|
+ if (!atlas->font_num) return 0;
|
|
|
+
|
|
|
+ /* allocate temporary baker memory required for the baking process */
|
|
|
+ nk_font_baker_memory(&tmp_size, &atlas->glyph_count, atlas->config, atlas->font_num);
|
|
|
+ tmp = atlas->temporary.alloc(atlas->temporary.userdata,0, tmp_size);
|
|
|
+ NK_ASSERT(tmp);
|
|
|
+ if (!tmp) goto failed;
|
|
|
+
|
|
|
+ /* allocate glyph memory for all fonts */
|
|
|
+ baker = nk_font_baker(tmp, atlas->glyph_count, atlas->font_num, &atlas->temporary);
|
|
|
+ atlas->glyphs = (struct nk_font_glyph*)atlas->permanent.alloc(
|
|
|
+ atlas->permanent.userdata,0, sizeof(struct nk_font_glyph)*(nk_size)atlas->glyph_count);
|
|
|
+ NK_ASSERT(atlas->glyphs);
|
|
|
+ if (!atlas->glyphs)
|
|
|
+ goto failed;
|
|
|
+
|
|
|
+ /* pack all glyphs into a tight fit space */
|
|
|
+ atlas->custom.w = (NK_CURSOR_DATA_W*2)+1;
|
|
|
+ atlas->custom.h = NK_CURSOR_DATA_H + 1;
|
|
|
+ if (!nk_font_bake_pack(baker, &img_size, width, height, &atlas->custom,
|
|
|
+ atlas->config, atlas->font_num, &atlas->temporary))
|
|
|
+ goto failed;
|
|
|
+
|
|
|
+ /* allocate memory for the baked image font atlas */
|
|
|
+ atlas->pixel = atlas->temporary.alloc(atlas->temporary.userdata,0, img_size);
|
|
|
+ NK_ASSERT(atlas->pixel);
|
|
|
+ if (!atlas->pixel)
|
|
|
+ goto failed;
|
|
|
+
|
|
|
+ /* bake glyphs and custom white pixel into image */
|
|
|
+ nk_font_bake(baker, atlas->pixel, *width, *height,
|
|
|
+ atlas->glyphs, atlas->glyph_count, atlas->config, atlas->font_num);
|
|
|
+ nk_font_bake_custom_data(atlas->pixel, *width, *height, atlas->custom,
|
|
|
+ nk_custom_cursor_data, NK_CURSOR_DATA_W, NK_CURSOR_DATA_H, '.', 'X');
|
|
|
+
|
|
|
+ if (fmt == NK_FONT_ATLAS_RGBA32) {
|
|
|
+ /* convert alpha8 image into rgba32 image */
|
|
|
+ void *img_rgba = atlas->temporary.alloc(atlas->temporary.userdata,0,
|
|
|
+ (nk_size)(*width * *height * 4));
|
|
|
+ NK_ASSERT(img_rgba);
|
|
|
+ if (!img_rgba) goto failed;
|
|
|
+ nk_font_bake_convert(img_rgba, *width, *height, atlas->pixel);
|
|
|
+ atlas->temporary.free(atlas->temporary.userdata, atlas->pixel);
|
|
|
+ atlas->pixel = img_rgba;
|
|
|
+ }
|
|
|
+ atlas->tex_width = *width;
|
|
|
+ atlas->tex_height = *height;
|
|
|
+
|
|
|
+ /* initialize each font */
|
|
|
+ for (font_iter = atlas->fonts; font_iter; font_iter = font_iter->next) {
|
|
|
+ struct nk_font *font = font_iter;
|
|
|
+ struct nk_font_config *config = font->config;
|
|
|
+ nk_font_init(font, config->size, config->fallback_glyph, atlas->glyphs,
|
|
|
+ config->font, nk_handle_ptr(0));
|
|
|
+ }
|
|
|
+
|
|
|
+ /* initialize each cursor */
|
|
|
+ {NK_STORAGE const struct nk_vec2 nk_cursor_data[NK_CURSOR_COUNT][3] = {
|
|
|
+ /* Pos ----- Size ------- Offset --*/
|
|
|
+ {{ 0, 3}, {12,19}, { 0, 0}},
|
|
|
+ {{13, 0}, { 7,16}, { 4, 8}},
|
|
|
+ {{31, 0}, {23,23}, {11,11}},
|
|
|
+ {{21, 0}, { 9, 23}, { 5,11}},
|
|
|
+ {{55,18}, {23, 9}, {11, 5}},
|
|
|
+ {{73, 0}, {17,17}, { 9, 9}},
|
|
|
+ {{55, 0}, {17,17}, { 9, 9}}
|
|
|
+ };
|
|
|
+ for (i = 0; i < NK_CURSOR_COUNT; ++i) {
|
|
|
+ struct nk_cursor *cursor = &atlas->cursors[i];
|
|
|
+ cursor->img.w = (unsigned short)*width;
|
|
|
+ cursor->img.h = (unsigned short)*height;
|
|
|
+ cursor->img.region[0] = (unsigned short)(atlas->custom.x + nk_cursor_data[i][0].x);
|
|
|
+ cursor->img.region[1] = (unsigned short)(atlas->custom.y + nk_cursor_data[i][0].y);
|
|
|
+ cursor->img.region[2] = (unsigned short)nk_cursor_data[i][1].x;
|
|
|
+ cursor->img.region[3] = (unsigned short)nk_cursor_data[i][1].y;
|
|
|
+ cursor->size = nk_cursor_data[i][1];
|
|
|
+ cursor->offset = nk_cursor_data[i][2];
|
|
|
+ }}
|
|
|
+ /* free temporary memory */
|
|
|
+ atlas->temporary.free(atlas->temporary.userdata, tmp);
|
|
|
+ return atlas->pixel;
|
|
|
+
|
|
|
+failed:
|
|
|
+ /* error so cleanup all memory */
|
|
|
+ if (tmp) atlas->temporary.free(atlas->temporary.userdata, tmp);
|
|
|
+ if (atlas->glyphs) {
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs);
|
|
|
+ atlas->glyphs = 0;
|
|
|
+ }
|
|
|
+ if (atlas->pixel) {
|
|
|
+ atlas->temporary.free(atlas->temporary.userdata, atlas->pixel);
|
|
|
+ atlas->pixel = 0;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_end(struct nk_font_atlas *atlas, nk_handle texture,
|
|
|
+ struct nk_draw_null_texture *null)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ struct nk_font *font_iter;
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ if (!atlas) {
|
|
|
+ if (!null) return;
|
|
|
+ null->texture = texture;
|
|
|
+ null->uv = nk_vec2(0.5f,0.5f);
|
|
|
+ }
|
|
|
+ if (null) {
|
|
|
+ null->texture = texture;
|
|
|
+ null->uv.x = (atlas->custom.x + 0.5f)/(float)atlas->tex_width;
|
|
|
+ null->uv.y = (atlas->custom.y + 0.5f)/(float)atlas->tex_height;
|
|
|
+ }
|
|
|
+ for (font_iter = atlas->fonts; font_iter; font_iter = font_iter->next) {
|
|
|
+ font_iter->texture = texture;
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ font_iter->handle.texture = texture;
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ for (i = 0; i < NK_CURSOR_COUNT; ++i)
|
|
|
+ atlas->cursors[i].img.handle = texture;
|
|
|
+
|
|
|
+ atlas->temporary.free(atlas->temporary.userdata, atlas->pixel);
|
|
|
+ atlas->pixel = 0;
|
|
|
+ atlas->tex_width = 0;
|
|
|
+ atlas->tex_height = 0;
|
|
|
+ atlas->custom.x = 0;
|
|
|
+ atlas->custom.y = 0;
|
|
|
+ atlas->custom.w = 0;
|
|
|
+ atlas->custom.h = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_cleanup(struct nk_font_atlas *atlas)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+
|
|
|
+ if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free) return;
|
|
|
+ if (atlas->config) {
|
|
|
+ struct nk_font_config *iter, *next;
|
|
|
+ for (iter = atlas->config; iter; iter = next) {
|
|
|
+ next = iter->next;
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, iter->ttf_blob);
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, iter);
|
|
|
+ }
|
|
|
+ atlas->config = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_font_atlas_clear(struct nk_font_atlas *atlas)
|
|
|
+{
|
|
|
+ NK_ASSERT(atlas);
|
|
|
+ NK_ASSERT(atlas->temporary.alloc);
|
|
|
+ NK_ASSERT(atlas->temporary.free);
|
|
|
+ NK_ASSERT(atlas->permanent.alloc);
|
|
|
+ NK_ASSERT(atlas->permanent.free);
|
|
|
+ if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free) return;
|
|
|
+
|
|
|
+ nk_font_atlas_cleanup(atlas);
|
|
|
+ if (atlas->fonts) {
|
|
|
+ struct nk_font *iter, *next;
|
|
|
+ for (iter = atlas->fonts; iter; iter = next) {
|
|
|
+ next = iter->next;
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, iter);
|
|
|
+ }
|
|
|
+ atlas->fonts = 0;
|
|
|
+ }
|
|
|
+ if (atlas->glyphs)
|
|
|
+ atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs);
|
|
|
+ nk_zero_struct(*atlas);
|
|
|
+}
|
|
|
+#endif
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * INPUT
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_API void
|
|
|
+nk_input_begin(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ struct nk_input *in;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+ for (i = 0; i < NK_BUTTON_MAX; ++i)
|
|
|
+ in->mouse.buttons[i].clicked = 0;
|
|
|
+
|
|
|
+ in->keyboard.text_len = 0;
|
|
|
+ in->mouse.scroll_delta = nk_vec2(0,0);
|
|
|
+ in->mouse.prev.x = in->mouse.pos.x;
|
|
|
+ in->mouse.prev.y = in->mouse.pos.y;
|
|
|
+ in->mouse.delta.x = 0;
|
|
|
+ in->mouse.delta.y = 0;
|
|
|
+ for (i = 0; i < NK_KEY_MAX; i++)
|
|
|
+ in->keyboard.keys[i].clicked = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_input *in;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+ if (in->mouse.grab)
|
|
|
+ in->mouse.grab = 0;
|
|
|
+ if (in->mouse.ungrab) {
|
|
|
+ in->mouse.grabbed = 0;
|
|
|
+ in->mouse.ungrab = 0;
|
|
|
+ in->mouse.grab = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_motion(struct nk_context *ctx, int x, int y)
|
|
|
+{
|
|
|
+ struct nk_input *in;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+ in->mouse.pos.x = (float)x;
|
|
|
+ in->mouse.pos.y = (float)y;
|
|
|
+ in->mouse.delta.x = in->mouse.pos.x - in->mouse.prev.x;
|
|
|
+ in->mouse.delta.y = in->mouse.pos.y - in->mouse.prev.y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_key(struct nk_context *ctx, enum nk_keys key, int down)
|
|
|
+{
|
|
|
+ struct nk_input *in;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+ if (in->keyboard.keys[key].down != down)
|
|
|
+ in->keyboard.keys[key].clicked++;
|
|
|
+ in->keyboard.keys[key].down = down;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, int down)
|
|
|
+{
|
|
|
+ struct nk_mouse_button *btn;
|
|
|
+ struct nk_input *in;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+ if (in->mouse.buttons[id].down == down) return;
|
|
|
+
|
|
|
+ btn = &in->mouse.buttons[id];
|
|
|
+ btn->clicked_pos.x = (float)x;
|
|
|
+ btn->clicked_pos.y = (float)y;
|
|
|
+ btn->down = down;
|
|
|
+ btn->clicked++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_scroll(struct nk_context *ctx, struct nk_vec2 val)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ ctx->input.mouse.scroll_delta.x += val.x;
|
|
|
+ ctx->input.mouse.scroll_delta.y += val.y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_glyph(struct nk_context *ctx, const nk_glyph glyph)
|
|
|
+{
|
|
|
+ int len = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+ struct nk_input *in;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ in = &ctx->input;
|
|
|
+
|
|
|
+ len = nk_utf_decode(glyph, &unicode, NK_UTF_SIZE);
|
|
|
+ if (len && ((in->keyboard.text_len + len) < NK_INPUT_MAX)) {
|
|
|
+ nk_utf_encode(unicode, &in->keyboard.text[in->keyboard.text_len],
|
|
|
+ NK_INPUT_MAX - in->keyboard.text_len);
|
|
|
+ in->keyboard.text_len += len;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_char(struct nk_context *ctx, char c)
|
|
|
+{
|
|
|
+ nk_glyph glyph;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ glyph[0] = c;
|
|
|
+ nk_input_glyph(ctx, glyph);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_input_unicode(struct nk_context *ctx, nk_rune unicode)
|
|
|
+{
|
|
|
+ nk_glyph rune;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ nk_utf_encode(unicode, rune, NK_UTF_SIZE);
|
|
|
+ nk_input_glyph(ctx, rune);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_has_mouse_click(const struct nk_input *i, enum nk_buttons id)
|
|
|
+{
|
|
|
+ const struct nk_mouse_button *btn;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ btn = &i->mouse.buttons[id];
|
|
|
+ return (btn->clicked && btn->down == nk_false) ? nk_true : nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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;
|
|
|
+ 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;
|
|
|
+ return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
|
|
|
+ struct nk_rect b, int down)
|
|
|
+{
|
|
|
+ const struct nk_mouse_button *btn;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ btn = &i->mouse.buttons[id];
|
|
|
+ return nk_input_has_mouse_click_in_rect(i, id, b) && (btn->down == down);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_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;
|
|
|
+ btn = &i->mouse.buttons[id];
|
|
|
+ return (nk_input_has_mouse_click_down_in_rect(i, id, b, nk_false) &&
|
|
|
+ btn->clicked) ? nk_true : nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
|
|
|
+ struct nk_rect b, int down)
|
|
|
+{
|
|
|
+ const struct nk_mouse_button *btn;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ btn = &i->mouse.buttons[id];
|
|
|
+ return (nk_input_has_mouse_click_down_in_rect(i, id, b, down) &&
|
|
|
+ btn->clicked) ? nk_true : nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_any_mouse_click_in_rect(const struct nk_input *in, struct nk_rect b)
|
|
|
+{
|
|
|
+ int i, down = 0;
|
|
|
+ for (i = 0; i < NK_BUTTON_MAX; ++i)
|
|
|
+ down = down || nk_input_is_mouse_click_in_rect(in, (enum nk_buttons)i, b);
|
|
|
+ return down;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_mouse_hovering_rect(const struct nk_input *i, struct nk_rect rect)
|
|
|
+{
|
|
|
+ if (!i) return nk_false;
|
|
|
+ return NK_INBOX(i->mouse.pos.x, i->mouse.pos.y, rect.x, rect.y, rect.w, rect.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_mouse_prev_hovering_rect(const struct nk_input *i, struct nk_rect rect)
|
|
|
+{
|
|
|
+ if (!i) return nk_false;
|
|
|
+ return NK_INBOX(i->mouse.prev.x, i->mouse.prev.y, rect.x, rect.y, rect.w, rect.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_mouse_clicked(const struct nk_input *i, enum nk_buttons id, struct nk_rect rect)
|
|
|
+{
|
|
|
+ if (!i) return nk_false;
|
|
|
+ if (!nk_input_is_mouse_hovering_rect(i, rect)) return nk_false;
|
|
|
+ return nk_input_is_mouse_click_in_rect(i, id, rect);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_mouse_down(const struct nk_input *i, enum nk_buttons id)
|
|
|
+{
|
|
|
+ if (!i) return nk_false;
|
|
|
+ return i->mouse.buttons[id].down;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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)
|
|
|
+ return nk_true;
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+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);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key)
|
|
|
+{
|
|
|
+ const struct nk_key *k;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ k = &i->keyboard.keys[key];
|
|
|
+ if ((k->down && k->clicked) || (!k->down && k->clicked >= 2))
|
|
|
+ return nk_true;
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_key_released(const struct nk_input *i, enum nk_keys key)
|
|
|
+{
|
|
|
+ const struct nk_key *k;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ k = &i->keyboard.keys[key];
|
|
|
+ if ((!k->down && k->clicked) || (k->down && k->clicked >= 2))
|
|
|
+ return nk_true;
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_input_is_key_down(const struct nk_input *i, enum nk_keys key)
|
|
|
+{
|
|
|
+ const struct nk_key *k;
|
|
|
+ if (!i) return nk_false;
|
|
|
+ k = &i->keyboard.keys[key];
|
|
|
+ if (k->down) return nk_true;
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * ==============================================================
|
|
|
+ *
|
|
|
+ * TEXT EDITOR
|
|
|
+ *
|
|
|
+ * ===============================================================
|
|
|
+ */
|
|
|
+/* stb_textedit.h - v1.8 - public domain - Sean Barrett */
|
|
|
+struct nk_text_find {
|
|
|
+ float x,y; /* position of n'th character */
|
|
|
+ float height; /* height of line */
|
|
|
+ int first_char, length; /* first char of row, and length */
|
|
|
+ int prev_first; /*_ first char of previous row */
|
|
|
+};
|
|
|
+
|
|
|
+struct nk_text_edit_row {
|
|
|
+ float x0,x1;
|
|
|
+ /* starting x location, end x location (allows for align=right, etc) */
|
|
|
+ float baseline_y_delta;
|
|
|
+ /* position of baseline relative to previous row's baseline*/
|
|
|
+ float ymin,ymax;
|
|
|
+ /* height of row above and below baseline */
|
|
|
+ int num_chars;
|
|
|
+};
|
|
|
+
|
|
|
+/* forward declarations */
|
|
|
+NK_INTERN void nk_textedit_makeundo_delete(struct nk_text_edit*, int, int);
|
|
|
+NK_INTERN void nk_textedit_makeundo_insert(struct nk_text_edit*, int, int);
|
|
|
+NK_INTERN void nk_textedit_makeundo_replace(struct nk_text_edit*, int, int, int);
|
|
|
+#define NK_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_textedit_get_width(const struct nk_text_edit *edit, int line_start, int char_id,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ int len = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ const char *str = nk_str_at_const(&edit->string, line_start + char_id, &unicode, &len);
|
|
|
+ return font->width(font->userdata, font->height, str, len);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_layout_row(struct nk_text_edit_row *r, struct nk_text_edit *edit,
|
|
|
+ int line_start_id, float row_height, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ int l;
|
|
|
+ int glyphs = 0;
|
|
|
+ nk_rune unicode;
|
|
|
+ const char *remaining;
|
|
|
+ int len = nk_str_len_char(&edit->string);
|
|
|
+ const char *end = nk_str_get_const(&edit->string) + len;
|
|
|
+ const char *text = nk_str_at_const(&edit->string, line_start_id, &unicode, &l);
|
|
|
+ const struct nk_vec2 size = nk_text_calculate_text_bounds(font,
|
|
|
+ text, (int)(end - text), row_height, &remaining, 0, &glyphs, NK_STOP_ON_NEW_LINE);
|
|
|
+
|
|
|
+ r->x0 = 0.0f;
|
|
|
+ r->x1 = size.x;
|
|
|
+ r->baseline_y_delta = size.y;
|
|
|
+ r->ymin = 0.0f;
|
|
|
+ r->ymax = size.y;
|
|
|
+ r->num_chars = glyphs;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_textedit_locate_coord(struct nk_text_edit *edit, float x, float y,
|
|
|
+ const struct nk_user_font *font, float row_height)
|
|
|
+{
|
|
|
+ struct nk_text_edit_row r;
|
|
|
+ int n = edit->string.len;
|
|
|
+ float base_y = 0, prev_x;
|
|
|
+ int i=0, k;
|
|
|
+
|
|
|
+ r.x0 = r.x1 = 0;
|
|
|
+ r.ymin = r.ymax = 0;
|
|
|
+ r.num_chars = 0;
|
|
|
+
|
|
|
+ /* search rows to find one that straddles 'y' */
|
|
|
+ while (i < n) {
|
|
|
+ nk_textedit_layout_row(&r, edit, i, row_height, font);
|
|
|
+ if (r.num_chars <= 0)
|
|
|
+ return n;
|
|
|
+
|
|
|
+ if (i==0 && y < base_y + r.ymin)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (y < base_y + r.ymax)
|
|
|
+ break;
|
|
|
+
|
|
|
+ i += r.num_chars;
|
|
|
+ base_y += r.baseline_y_delta;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* below all text, return 'after' last character */
|
|
|
+ if (i >= n)
|
|
|
+ return n;
|
|
|
+
|
|
|
+ /* check if it's before the beginning of the line */
|
|
|
+ if (x < r.x0)
|
|
|
+ return i;
|
|
|
+
|
|
|
+ /* check if it's before the end of the line */
|
|
|
+ if (x < r.x1) {
|
|
|
+ /* search characters in row for one that straddles 'x' */
|
|
|
+ k = i;
|
|
|
+ prev_x = r.x0;
|
|
|
+ for (i=0; i < r.num_chars; ++i) {
|
|
|
+ float w = nk_textedit_get_width(edit, k, i, font);
|
|
|
+ if (x < prev_x+w) {
|
|
|
+ if (x < prev_x+w/2)
|
|
|
+ return k+i;
|
|
|
+ else return k+i+1;
|
|
|
+ }
|
|
|
+ prev_x += w;
|
|
|
+ }
|
|
|
+ /* shouldn't happen, but if it does, fall through to end-of-line case */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* if the last character is a newline, return that.
|
|
|
+ * otherwise return 'after' the last character */
|
|
|
+ if (nk_str_rune_at(&edit->string, i+r.num_chars-1) == '\n')
|
|
|
+ return i+r.num_chars-1;
|
|
|
+ else return i+r.num_chars;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_click(struct nk_text_edit *state, float x, float y,
|
|
|
+ const struct nk_user_font *font, float row_height)
|
|
|
+{
|
|
|
+ /* API click: on mouse down, move the cursor to the clicked location,
|
|
|
+ * and reset the selection */
|
|
|
+ state->cursor = nk_textedit_locate_coord(state, x, y, font, row_height);
|
|
|
+ state->select_start = state->cursor;
|
|
|
+ state->select_end = state->cursor;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_drag(struct nk_text_edit *state, float x, float y,
|
|
|
+ const struct nk_user_font *font, float row_height)
|
|
|
+{
|
|
|
+ /* API drag: on mouse drag, move the cursor and selection endpoint
|
|
|
+ * to the clicked location */
|
|
|
+ int p = nk_textedit_locate_coord(state, x, y, font, row_height);
|
|
|
+ if (state->select_start == state->select_end)
|
|
|
+ state->select_start = state->cursor;
|
|
|
+ state->cursor = state->select_end = p;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_find_charpos(struct nk_text_find *find, struct nk_text_edit *state,
|
|
|
+ int n, int single_line, const struct nk_user_font *font, float row_height)
|
|
|
+{
|
|
|
+ /* find the x/y location of a character, and remember info about the previous
|
|
|
+ * row in case we get a move-up event (for page up, we'll have to rescan) */
|
|
|
+ struct nk_text_edit_row r;
|
|
|
+ int prev_start = 0;
|
|
|
+ int z = state->string.len;
|
|
|
+ int i=0, first;
|
|
|
+
|
|
|
+ nk_zero_struct(r);
|
|
|
+ if (n == z) {
|
|
|
+ /* if it's at the end, then find the last line -- simpler than trying to
|
|
|
+ explicitly handle this case in the regular code */
|
|
|
+ nk_textedit_layout_row(&r, state, 0, row_height, font);
|
|
|
+ if (single_line) {
|
|
|
+ find->first_char = 0;
|
|
|
+ find->length = z;
|
|
|
+ } else {
|
|
|
+ while (i < z) {
|
|
|
+ prev_start = i;
|
|
|
+ i += r.num_chars;
|
|
|
+ nk_textedit_layout_row(&r, state, i, row_height, font);
|
|
|
+ }
|
|
|
+
|
|
|
+ find->first_char = i;
|
|
|
+ find->length = r.num_chars;
|
|
|
+ }
|
|
|
+ find->x = r.x1;
|
|
|
+ find->y = r.ymin;
|
|
|
+ find->height = r.ymax - r.ymin;
|
|
|
+ find->prev_first = prev_start;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* search rows to find the one that straddles character n */
|
|
|
+ find->y = 0;
|
|
|
+
|
|
|
+ for(;;) {
|
|
|
+ nk_textedit_layout_row(&r, state, i, row_height, font);
|
|
|
+ if (n < i + r.num_chars) break;
|
|
|
+ prev_start = i;
|
|
|
+ i += r.num_chars;
|
|
|
+ find->y += r.baseline_y_delta;
|
|
|
+ }
|
|
|
+
|
|
|
+ find->first_char = first = i;
|
|
|
+ find->length = r.num_chars;
|
|
|
+ find->height = r.ymax - r.ymin;
|
|
|
+ find->prev_first = prev_start;
|
|
|
+
|
|
|
+ /* now scan to find xpos */
|
|
|
+ find->x = r.x0;
|
|
|
+ for (i=0; first+i < n; ++i)
|
|
|
+ find->x += nk_textedit_get_width(state, first, i, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_clamp(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* make the selection/cursor state valid if client altered the string */
|
|
|
+ int n = state->string.len;
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state)) {
|
|
|
+ if (state->select_start > n) state->select_start = n;
|
|
|
+ if (state->select_end > n) state->select_end = n;
|
|
|
+ /* if clamping forced them to be equal, move the cursor to match */
|
|
|
+ if (state->select_start == state->select_end)
|
|
|
+ state->cursor = state->select_start;
|
|
|
+ }
|
|
|
+ if (state->cursor > n) state->cursor = n;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_delete(struct nk_text_edit *state, int where, int len)
|
|
|
+{
|
|
|
+ /* delete characters while updating undo */
|
|
|
+ nk_textedit_makeundo_delete(state, where, len);
|
|
|
+ nk_str_delete_runes(&state->string, where, len);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_delete_selection(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* delete the section */
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state)) {
|
|
|
+ if (state->select_start < state->select_end) {
|
|
|
+ nk_textedit_delete(state, state->select_start,
|
|
|
+ state->select_end - state->select_start);
|
|
|
+ state->select_end = state->cursor = state->select_start;
|
|
|
+ } else {
|
|
|
+ nk_textedit_delete(state, state->select_end,
|
|
|
+ state->select_start - state->select_end);
|
|
|
+ state->select_start = state->cursor = state->select_end;
|
|
|
+ }
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_sortselection(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* canonicalize the selection so start <= end */
|
|
|
+ if (state->select_end < state->select_start) {
|
|
|
+ int temp = state->select_end;
|
|
|
+ state->select_end = state->select_start;
|
|
|
+ state->select_start = temp;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_move_to_first(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* move cursor to first character of selection */
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state)) {
|
|
|
+ nk_textedit_sortselection(state);
|
|
|
+ state->cursor = state->select_start;
|
|
|
+ state->select_end = state->select_start;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_move_to_last(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* move cursor to last character of selection */
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state)) {
|
|
|
+ nk_textedit_sortselection(state);
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ state->cursor = state->select_end;
|
|
|
+ state->select_start = state->select_end;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_is_word_boundary( struct nk_text_edit *state, int idx)
|
|
|
+{
|
|
|
+ int len;
|
|
|
+ nk_rune c;
|
|
|
+ if (idx <= 0) return 1;
|
|
|
+ if (!nk_str_at_rune(&state->string, idx, &c, &len)) return 1;
|
|
|
+ return (c == ' ' || c == '\t' ||c == 0x3000 || c == ',' || c == ';' ||
|
|
|
+ c == '(' || c == ')' || c == '{' || c == '}' || c == '[' || c == ']' ||
|
|
|
+ c == '|');
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_textedit_move_to_word_previous(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ int c = state->cursor - 1;
|
|
|
+ while( c >= 0 && !nk_is_word_boundary(state, c))
|
|
|
+ --c;
|
|
|
+
|
|
|
+ if( c < 0 )
|
|
|
+ c = 0;
|
|
|
+
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_textedit_move_to_word_next(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ const int len = state->string.len;
|
|
|
+ int c = state->cursor+1;
|
|
|
+ while( c < len && !nk_is_word_boundary(state, c))
|
|
|
+ ++c;
|
|
|
+
|
|
|
+ if( c > len )
|
|
|
+ c = len;
|
|
|
+
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_prep_selection_at_cursor(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* update selection and cursor to match each other */
|
|
|
+ if (!NK_TEXT_HAS_SELECTION(state))
|
|
|
+ state->select_start = state->select_end = state->cursor;
|
|
|
+ else state->cursor = state->select_end;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_textedit_cut(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ /* API cut: delete selection */
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
|
|
|
+ return 0;
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state)) {
|
|
|
+ nk_textedit_delete_selection(state); /* implicitly clamps */
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_textedit_paste(struct nk_text_edit *state, char const *ctext, int len)
|
|
|
+{
|
|
|
+ /* API paste: replace existing selection with passed-in text */
|
|
|
+ int glyphs;
|
|
|
+ const char *text = (const char *) ctext;
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW) return 0;
|
|
|
+
|
|
|
+ /* if there's a selection, the paste should delete it */
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_delete_selection(state);
|
|
|
+
|
|
|
+ /* try to insert the characters */
|
|
|
+ glyphs = nk_utf_len(ctext, len);
|
|
|
+ if (nk_str_insert_text_char(&state->string, state->cursor, text, len)) {
|
|
|
+ nk_textedit_makeundo_insert(state, state->cursor, glyphs);
|
|
|
+ state->cursor += len;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ /* remove the undo since we didn't actually insert the characters */
|
|
|
+ if (state->undo.undo_point)
|
|
|
+ --state->undo.undo_point;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_text(struct nk_text_edit *state, const char *text, int total_len)
|
|
|
+{
|
|
|
+ nk_rune unicode;
|
|
|
+ int glyph_len;
|
|
|
+ int text_len = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ if (!text || !total_len || state->mode == NK_TEXT_EDIT_MODE_VIEW) return;
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(text, &unicode, total_len);
|
|
|
+ while ((text_len < total_len) && glyph_len)
|
|
|
+ {
|
|
|
+ /* don't insert a backward delete, just process the event */
|
|
|
+ if (unicode == 127) goto next;
|
|
|
+ /* can't add newline in single-line mode */
|
|
|
+ if (unicode == '\n' && state->single_line) goto next;
|
|
|
+ /* filter incoming text */
|
|
|
+ if (state->filter && !state->filter(state, unicode)) goto next;
|
|
|
+
|
|
|
+ if (!NK_TEXT_HAS_SELECTION(state) &&
|
|
|
+ state->cursor < state->string.len)
|
|
|
+ {
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_REPLACE) {
|
|
|
+ nk_textedit_makeundo_replace(state, state->cursor, 1, 1);
|
|
|
+ nk_str_delete_runes(&state->string, state->cursor, 1);
|
|
|
+ }
|
|
|
+ if (nk_str_insert_text_utf8(&state->string, state->cursor,
|
|
|
+ text+text_len, 1))
|
|
|
+ {
|
|
|
+ ++state->cursor;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ nk_textedit_delete_selection(state); /* implicitly clamps */
|
|
|
+ if (nk_str_insert_text_utf8(&state->string, state->cursor,
|
|
|
+ text+text_len, 1))
|
|
|
+ {
|
|
|
+ nk_textedit_makeundo_insert(state, state->cursor, 1);
|
|
|
+ ++state->cursor;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ next:
|
|
|
+ text_len += glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, total_len-text_len);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_key(struct nk_text_edit *state, enum nk_keys key, int shift_mod,
|
|
|
+ const struct nk_user_font *font, float row_height)
|
|
|
+{
|
|
|
+retry:
|
|
|
+ switch (key)
|
|
|
+ {
|
|
|
+ case NK_KEY_NONE:
|
|
|
+ case NK_KEY_CTRL:
|
|
|
+ case NK_KEY_ENTER:
|
|
|
+ case NK_KEY_SHIFT:
|
|
|
+ case NK_KEY_TAB:
|
|
|
+ case NK_KEY_COPY:
|
|
|
+ case NK_KEY_CUT:
|
|
|
+ case NK_KEY_PASTE:
|
|
|
+ case NK_KEY_MAX:
|
|
|
+ default: break;
|
|
|
+ case NK_KEY_TEXT_UNDO:
|
|
|
+ nk_textedit_undo(state);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_REDO:
|
|
|
+ nk_textedit_redo(state);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_SELECT_ALL:
|
|
|
+ nk_textedit_select_all(state);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_INSERT_MODE:
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
|
|
|
+ state->mode = NK_TEXT_EDIT_MODE_INSERT;
|
|
|
+ break;
|
|
|
+ case NK_KEY_TEXT_REPLACE_MODE:
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
|
|
|
+ state->mode = NK_TEXT_EDIT_MODE_REPLACE;
|
|
|
+ break;
|
|
|
+ case NK_KEY_TEXT_RESET_MODE:
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_INSERT ||
|
|
|
+ state->mode == NK_TEXT_EDIT_MODE_REPLACE)
|
|
|
+ state->mode = NK_TEXT_EDIT_MODE_VIEW;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_LEFT:
|
|
|
+ if (shift_mod) {
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ /* move selection left */
|
|
|
+ if (state->select_end > 0)
|
|
|
+ --state->select_end;
|
|
|
+ state->cursor = state->select_end;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } else {
|
|
|
+ /* if currently there's a selection,
|
|
|
+ * move cursor to start of selection */
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_first(state);
|
|
|
+ else if (state->cursor > 0)
|
|
|
+ --state->cursor;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_RIGHT:
|
|
|
+ if (shift_mod) {
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ /* move selection right */
|
|
|
+ ++state->select_end;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ state->cursor = state->select_end;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } else {
|
|
|
+ /* if currently there's a selection,
|
|
|
+ * move cursor to end of selection */
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_last(state);
|
|
|
+ else ++state->cursor;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_WORD_LEFT:
|
|
|
+ if (shift_mod) {
|
|
|
+ if( !NK_TEXT_HAS_SELECTION( state ) )
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ state->cursor = nk_textedit_move_to_word_previous(state);
|
|
|
+ state->select_end = state->cursor;
|
|
|
+ nk_textedit_clamp(state );
|
|
|
+ } else {
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_first(state);
|
|
|
+ else {
|
|
|
+ state->cursor = nk_textedit_move_to_word_previous(state);
|
|
|
+ nk_textedit_clamp(state );
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_WORD_RIGHT:
|
|
|
+ if (shift_mod) {
|
|
|
+ if( !NK_TEXT_HAS_SELECTION( state ) )
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ state->cursor = nk_textedit_move_to_word_next(state);
|
|
|
+ state->select_end = state->cursor;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ } else {
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_last(state);
|
|
|
+ else {
|
|
|
+ state->cursor = nk_textedit_move_to_word_next(state);
|
|
|
+ nk_textedit_clamp(state );
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_DOWN: {
|
|
|
+ struct nk_text_find find;
|
|
|
+ struct nk_text_edit_row row;
|
|
|
+ int i, sel = shift_mod;
|
|
|
+
|
|
|
+ if (state->single_line) {
|
|
|
+ /* on windows, up&down in single-line behave like left&right */
|
|
|
+ key = NK_KEY_RIGHT;
|
|
|
+ goto retry;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sel)
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ else if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_last(state);
|
|
|
+
|
|
|
+ /* compute current position of cursor point */
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_find_charpos(&find, state, state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+
|
|
|
+ /* now find character position down a row */
|
|
|
+ if (find.length)
|
|
|
+ {
|
|
|
+ float x;
|
|
|
+ float goal_x = state->has_preferred_x ? state->preferred_x : find.x;
|
|
|
+ int start = find.first_char + find.length;
|
|
|
+
|
|
|
+ state->cursor = start;
|
|
|
+ nk_textedit_layout_row(&row, state, state->cursor, row_height, font);
|
|
|
+ x = row.x0;
|
|
|
+
|
|
|
+ for (i=0; i < row.num_chars && x < row.x1; ++i) {
|
|
|
+ float dx = nk_textedit_get_width(state, start, i, font);
|
|
|
+ x += dx;
|
|
|
+ if (x > goal_x)
|
|
|
+ break;
|
|
|
+ ++state->cursor;
|
|
|
+ }
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+
|
|
|
+ state->has_preferred_x = 1;
|
|
|
+ state->preferred_x = goal_x;
|
|
|
+ if (sel)
|
|
|
+ state->select_end = state->cursor;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_UP: {
|
|
|
+ struct nk_text_find find;
|
|
|
+ struct nk_text_edit_row row;
|
|
|
+ int i, sel = shift_mod;
|
|
|
+
|
|
|
+ if (state->single_line) {
|
|
|
+ /* on windows, up&down become left&right */
|
|
|
+ key = NK_KEY_LEFT;
|
|
|
+ goto retry;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sel)
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ else if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_move_to_first(state);
|
|
|
+
|
|
|
+ /* compute current position of cursor point */
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_find_charpos(&find, state, state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+
|
|
|
+ /* can only go up if there's a previous row */
|
|
|
+ if (find.prev_first != find.first_char) {
|
|
|
+ /* now find character position up a row */
|
|
|
+ float x;
|
|
|
+ float goal_x = state->has_preferred_x ? state->preferred_x : find.x;
|
|
|
+
|
|
|
+ state->cursor = find.prev_first;
|
|
|
+ nk_textedit_layout_row(&row, state, state->cursor, row_height, font);
|
|
|
+ x = row.x0;
|
|
|
+
|
|
|
+ for (i=0; i < row.num_chars && x < row.x1; ++i) {
|
|
|
+ float dx = nk_textedit_get_width(state, find.prev_first, i, font);
|
|
|
+ x += dx;
|
|
|
+ if (x > goal_x)
|
|
|
+ break;
|
|
|
+ ++state->cursor;
|
|
|
+ }
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+
|
|
|
+ state->has_preferred_x = 1;
|
|
|
+ state->preferred_x = goal_x;
|
|
|
+ if (sel) state->select_end = state->cursor;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_DEL:
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
|
|
|
+ break;
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_delete_selection(state);
|
|
|
+ else {
|
|
|
+ int n = state->string.len;
|
|
|
+ if (state->cursor < n)
|
|
|
+ nk_textedit_delete(state, state->cursor, 1);
|
|
|
+ }
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_BACKSPACE:
|
|
|
+ if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
|
|
|
+ break;
|
|
|
+ if (NK_TEXT_HAS_SELECTION(state))
|
|
|
+ nk_textedit_delete_selection(state);
|
|
|
+ else {
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ if (state->cursor > 0) {
|
|
|
+ nk_textedit_delete(state, state->cursor-1, 1);
|
|
|
+ --state->cursor;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_START:
|
|
|
+ if (shift_mod) {
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ state->cursor = state->select_end = 0;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } else {
|
|
|
+ state->cursor = state->select_start = state->select_end = 0;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_END:
|
|
|
+ if (shift_mod) {
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ state->cursor = state->select_end = state->string.len;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } else {
|
|
|
+ state->cursor = state->string.len;
|
|
|
+ state->select_start = state->select_end = 0;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_LINE_START: {
|
|
|
+ if (shift_mod) {
|
|
|
+ struct nk_text_find find;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ if (state->string.len && state->cursor == state->string.len)
|
|
|
+ --state->cursor;
|
|
|
+ nk_textedit_find_charpos(&find, state,state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+ state->cursor = state->select_end = find.first_char;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ } else {
|
|
|
+ struct nk_text_find find;
|
|
|
+ if (state->string.len && state->cursor == state->string.len)
|
|
|
+ --state->cursor;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_move_to_first(state);
|
|
|
+ nk_textedit_find_charpos(&find, state, state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+ state->cursor = find.first_char;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case NK_KEY_TEXT_LINE_END: {
|
|
|
+ if (shift_mod) {
|
|
|
+ struct nk_text_find find;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_prep_selection_at_cursor(state);
|
|
|
+ nk_textedit_find_charpos(&find, state, state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ state->cursor = find.first_char + find.length;
|
|
|
+ if (find.length > 0 && nk_str_rune_at(&state->string, state->cursor-1) == '\n')
|
|
|
+ --state->cursor;
|
|
|
+ state->select_end = state->cursor;
|
|
|
+ } else {
|
|
|
+ struct nk_text_find find;
|
|
|
+ nk_textedit_clamp(state);
|
|
|
+ nk_textedit_move_to_first(state);
|
|
|
+ nk_textedit_find_charpos(&find, state, state->cursor, state->single_line,
|
|
|
+ font, row_height);
|
|
|
+
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ state->cursor = find.first_char + find.length;
|
|
|
+ if (find.length > 0 && nk_str_rune_at(&state->string, state->cursor-1) == '\n')
|
|
|
+ --state->cursor;
|
|
|
+ }} break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_flush_redo(struct nk_text_undo_state *state)
|
|
|
+{
|
|
|
+ state->redo_point = NK_TEXTEDIT_UNDOSTATECOUNT;
|
|
|
+ state->redo_char_point = NK_TEXTEDIT_UNDOCHARCOUNT;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_discard_undo(struct nk_text_undo_state *state)
|
|
|
+{
|
|
|
+ /* discard the oldest entry in the undo list */
|
|
|
+ if (state->undo_point > 0) {
|
|
|
+ /* if the 0th undo state has characters, clean those up */
|
|
|
+ if (state->undo_rec[0].char_storage >= 0) {
|
|
|
+ int n = state->undo_rec[0].insert_length, i;
|
|
|
+ /* delete n characters from all other records */
|
|
|
+ state->undo_char_point = (short)(state->undo_char_point - n);
|
|
|
+ NK_MEMCPY(state->undo_char, state->undo_char + n,
|
|
|
+ (nk_size)state->undo_char_point*sizeof(nk_rune));
|
|
|
+ for (i=0; i < state->undo_point; ++i) {
|
|
|
+ if (state->undo_rec[i].char_storage >= 0)
|
|
|
+ state->undo_rec[i].char_storage = (short)
|
|
|
+ (state->undo_rec[i].char_storage - n);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ --state->undo_point;
|
|
|
+ NK_MEMCPY(state->undo_rec, state->undo_rec+1,
|
|
|
+ (nk_size)((nk_size)state->undo_point * sizeof(state->undo_rec[0])));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_discard_redo(struct nk_text_undo_state *state)
|
|
|
+{
|
|
|
+/* discard the oldest entry in the redo list--it's bad if this
|
|
|
+ ever happens, but because undo & redo have to store the actual
|
|
|
+ characters in different cases, the redo character buffer can
|
|
|
+ fill up even though the undo buffer didn't */
|
|
|
+ nk_size num;
|
|
|
+ int k = NK_TEXTEDIT_UNDOSTATECOUNT-1;
|
|
|
+ if (state->redo_point <= k) {
|
|
|
+ /* if the k'th undo state has characters, clean those up */
|
|
|
+ if (state->undo_rec[k].char_storage >= 0) {
|
|
|
+ int n = state->undo_rec[k].insert_length, i;
|
|
|
+ /* delete n characters from all other records */
|
|
|
+ state->redo_char_point = (short)(state->redo_char_point + n);
|
|
|
+ num = (nk_size)(NK_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point);
|
|
|
+ NK_MEMCPY(state->undo_char + state->redo_char_point,
|
|
|
+ state->undo_char + state->redo_char_point-n, num * sizeof(char));
|
|
|
+ for (i = state->redo_point; i < k; ++i) {
|
|
|
+ if (state->undo_rec[i].char_storage >= 0) {
|
|
|
+ state->undo_rec[i].char_storage = (short)
|
|
|
+ (state->undo_rec[i].char_storage + n);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ++state->redo_point;
|
|
|
+ num = (nk_size)(NK_TEXTEDIT_UNDOSTATECOUNT - state->redo_point);
|
|
|
+ if (num) NK_MEMCPY(state->undo_rec + state->redo_point-1,
|
|
|
+ state->undo_rec + state->redo_point, num * sizeof(state->undo_rec[0]));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_text_undo_record*
|
|
|
+nk_textedit_create_undo_record(struct nk_text_undo_state *state, int numchars)
|
|
|
+{
|
|
|
+ /* any time we create a new undo record, we discard redo*/
|
|
|
+ nk_textedit_flush_redo(state);
|
|
|
+
|
|
|
+ /* if we have no free records, we have to make room,
|
|
|
+ * by sliding the existing records down */
|
|
|
+ if (state->undo_point == NK_TEXTEDIT_UNDOSTATECOUNT)
|
|
|
+ nk_textedit_discard_undo(state);
|
|
|
+
|
|
|
+ /* if the characters to store won't possibly fit in the buffer,
|
|
|
+ * we can't undo */
|
|
|
+ if (numchars > NK_TEXTEDIT_UNDOCHARCOUNT) {
|
|
|
+ state->undo_point = 0;
|
|
|
+ state->undo_char_point = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* if we don't have enough free characters in the buffer,
|
|
|
+ * we have to make room */
|
|
|
+ while (state->undo_char_point + numchars > NK_TEXTEDIT_UNDOCHARCOUNT)
|
|
|
+ nk_textedit_discard_undo(state);
|
|
|
+ return &state->undo_rec[state->undo_point++];
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_rune*
|
|
|
+nk_textedit_createundo(struct nk_text_undo_state *state, int pos,
|
|
|
+ int insert_len, int delete_len)
|
|
|
+{
|
|
|
+ struct nk_text_undo_record *r = nk_textedit_create_undo_record(state, insert_len);
|
|
|
+ if (r == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ r->where = pos;
|
|
|
+ r->insert_length = (short) insert_len;
|
|
|
+ r->delete_length = (short) delete_len;
|
|
|
+
|
|
|
+ if (insert_len == 0) {
|
|
|
+ r->char_storage = -1;
|
|
|
+ return 0;
|
|
|
+ } else {
|
|
|
+ r->char_storage = state->undo_char_point;
|
|
|
+ state->undo_char_point = (short)(state->undo_char_point + insert_len);
|
|
|
+ return &state->undo_char[r->char_storage];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_undo(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ struct nk_text_undo_state *s = &state->undo;
|
|
|
+ struct nk_text_undo_record u, *r;
|
|
|
+ if (s->undo_point == 0)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* we need to do two things: apply the undo record, and create a redo record */
|
|
|
+ u = s->undo_rec[s->undo_point-1];
|
|
|
+ r = &s->undo_rec[s->redo_point-1];
|
|
|
+ r->char_storage = -1;
|
|
|
+
|
|
|
+ r->insert_length = u.delete_length;
|
|
|
+ r->delete_length = u.insert_length;
|
|
|
+ r->where = u.where;
|
|
|
+
|
|
|
+ if (u.delete_length)
|
|
|
+ {
|
|
|
+ /* if the undo record says to delete characters, then the redo record will
|
|
|
+ need to re-insert the characters that get deleted, so we need to store
|
|
|
+ them.
|
|
|
+ there are three cases:
|
|
|
+ - there's enough room to store the characters
|
|
|
+ - characters stored for *redoing* don't leave room for redo
|
|
|
+ - characters stored for *undoing* don't leave room for redo
|
|
|
+ if the last is true, we have to bail */
|
|
|
+ if (s->undo_char_point + u.delete_length >= NK_TEXTEDIT_UNDOCHARCOUNT) {
|
|
|
+ /* the undo records take up too much character space; there's no space
|
|
|
+ * to store the redo characters */
|
|
|
+ r->insert_length = 0;
|
|
|
+ } else {
|
|
|
+ int i;
|
|
|
+ /* there's definitely room to store the characters eventually */
|
|
|
+ while (s->undo_char_point + u.delete_length > s->redo_char_point) {
|
|
|
+ /* there's currently not enough room, so discard a redo record */
|
|
|
+ nk_textedit_discard_redo(s);
|
|
|
+ /* should never happen: */
|
|
|
+ if (s->redo_point == NK_TEXTEDIT_UNDOSTATECOUNT)
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ r = &s->undo_rec[s->redo_point-1];
|
|
|
+ r->char_storage = (short)(s->redo_char_point - u.delete_length);
|
|
|
+ s->redo_char_point = (short)(s->redo_char_point - u.delete_length);
|
|
|
+
|
|
|
+ /* now save the characters */
|
|
|
+ for (i=0; i < u.delete_length; ++i)
|
|
|
+ s->undo_char[r->char_storage + i] =
|
|
|
+ nk_str_rune_at(&state->string, u.where + i);
|
|
|
+ }
|
|
|
+ /* now we can carry out the deletion */
|
|
|
+ nk_str_delete_runes(&state->string, u.where, u.delete_length);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* check type of recorded action: */
|
|
|
+ if (u.insert_length) {
|
|
|
+ /* easy case: was a deletion, so we need to insert n characters */
|
|
|
+ nk_str_insert_text_runes(&state->string, u.where,
|
|
|
+ &s->undo_char[u.char_storage], u.insert_length);
|
|
|
+ s->undo_char_point = (short)(s->undo_char_point - u.insert_length);
|
|
|
+ }
|
|
|
+ state->cursor = (short)(u.where + u.insert_length);
|
|
|
+
|
|
|
+ s->undo_point--;
|
|
|
+ s->redo_point--;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_redo(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ struct nk_text_undo_state *s = &state->undo;
|
|
|
+ struct nk_text_undo_record *u, r;
|
|
|
+ if (s->redo_point == NK_TEXTEDIT_UNDOSTATECOUNT)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* we need to do two things: apply the redo record, and create an undo record */
|
|
|
+ u = &s->undo_rec[s->undo_point];
|
|
|
+ r = s->undo_rec[s->redo_point];
|
|
|
+
|
|
|
+ /* we KNOW there must be room for the undo record, because the redo record
|
|
|
+ was derived from an undo record */
|
|
|
+ u->delete_length = r.insert_length;
|
|
|
+ u->insert_length = r.delete_length;
|
|
|
+ u->where = r.where;
|
|
|
+ u->char_storage = -1;
|
|
|
+
|
|
|
+ if (r.delete_length) {
|
|
|
+ /* the redo record requires us to delete characters, so the undo record
|
|
|
+ needs to store the characters */
|
|
|
+ if (s->undo_char_point + u->insert_length > s->redo_char_point) {
|
|
|
+ u->insert_length = 0;
|
|
|
+ u->delete_length = 0;
|
|
|
+ } else {
|
|
|
+ int i;
|
|
|
+ u->char_storage = s->undo_char_point;
|
|
|
+ s->undo_char_point = (short)(s->undo_char_point + u->insert_length);
|
|
|
+
|
|
|
+ /* now save the characters */
|
|
|
+ for (i=0; i < u->insert_length; ++i) {
|
|
|
+ s->undo_char[u->char_storage + i] =
|
|
|
+ nk_str_rune_at(&state->string, u->where + i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ nk_str_delete_runes(&state->string, r.where, r.delete_length);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (r.insert_length) {
|
|
|
+ /* easy case: need to insert n characters */
|
|
|
+ nk_str_insert_text_runes(&state->string, r.where,
|
|
|
+ &s->undo_char[r.char_storage], r.insert_length);
|
|
|
+ }
|
|
|
+ state->cursor = r.where + r.insert_length;
|
|
|
+
|
|
|
+ s->undo_point++;
|
|
|
+ s->redo_point++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_makeundo_insert(struct nk_text_edit *state, int where, int length)
|
|
|
+{
|
|
|
+ nk_textedit_createundo(&state->undo, where, 0, length);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_makeundo_delete(struct nk_text_edit *state, int where, int length)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ nk_rune *p = nk_textedit_createundo(&state->undo, where, length, 0);
|
|
|
+ if (p) {
|
|
|
+ for (i=0; i < length; ++i)
|
|
|
+ p[i] = nk_str_rune_at(&state->string, where+i);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_makeundo_replace(struct nk_text_edit *state, int where,
|
|
|
+ int old_length, int new_length)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ nk_rune *p = nk_textedit_createundo(&state->undo, where, old_length, new_length);
|
|
|
+ if (p) {
|
|
|
+ for (i=0; i < old_length; ++i)
|
|
|
+ p[i] = nk_str_rune_at(&state->string, where+i);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_textedit_clear_state(struct nk_text_edit *state, enum nk_text_edit_type type,
|
|
|
+ nk_plugin_filter filter)
|
|
|
+{
|
|
|
+ /* reset the state to default */
|
|
|
+ state->undo.undo_point = 0;
|
|
|
+ state->undo.undo_char_point = 0;
|
|
|
+ state->undo.redo_point = NK_TEXTEDIT_UNDOSTATECOUNT;
|
|
|
+ state->undo.redo_char_point = NK_TEXTEDIT_UNDOCHARCOUNT;
|
|
|
+ state->select_end = state->select_start = 0;
|
|
|
+ state->cursor = 0;
|
|
|
+ state->has_preferred_x = 0;
|
|
|
+ state->preferred_x = 0;
|
|
|
+ state->cursor_at_end_of_line = 0;
|
|
|
+ state->initialized = 1;
|
|
|
+ state->single_line = (unsigned char)(type == NK_TEXT_EDIT_SINGLE_LINE);
|
|
|
+ state->mode = NK_TEXT_EDIT_MODE_VIEW;
|
|
|
+ state->filter = filter;
|
|
|
+ state->scrollbar = nk_vec2(0,0);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size)
|
|
|
+{
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(memory);
|
|
|
+ if (!state || !memory || !size) return;
|
|
|
+ NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
|
|
|
+ nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
|
|
|
+ nk_str_init_fixed(&state->string, memory, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_init(struct nk_text_edit *state, struct nk_allocator *alloc, nk_size size)
|
|
|
+{
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+ if (!state || !alloc) return;
|
|
|
+ NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
|
|
|
+ nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
|
|
|
+ nk_str_init(&state->string, alloc, size);
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API void
|
|
|
+nk_textedit_init_default(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ NK_ASSERT(state);
|
|
|
+ if (!state) return;
|
|
|
+ NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
|
|
|
+ nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
|
|
|
+ nk_str_init_default(&state->string);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_select_all(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ NK_ASSERT(state);
|
|
|
+ state->select_start = 0;
|
|
|
+ state->select_end = state->string.len;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_textedit_free(struct nk_text_edit *state)
|
|
|
+{
|
|
|
+ NK_ASSERT(state);
|
|
|
+ if (!state) return;
|
|
|
+ nk_str_free(&state->string);
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * TEXT WIDGET
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+#define nk_widget_state_reset(s)\
|
|
|
+ if ((*(s)) & NK_WIDGET_STATE_MODIFIED)\
|
|
|
+ (*(s)) = NK_WIDGET_STATE_INACTIVE|NK_WIDGET_STATE_MODIFIED;\
|
|
|
+ else (*(s)) = NK_WIDGET_STATE_INACTIVE;
|
|
|
+
|
|
|
+struct nk_text {
|
|
|
+ struct nk_vec2 padding;
|
|
|
+ struct nk_color background;
|
|
|
+ struct nk_color text;
|
|
|
+};
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_widget_text(struct nk_command_buffer *o, struct nk_rect b,
|
|
|
+ const char *string, int len, const struct nk_text *t,
|
|
|
+ nk_flags a, const struct nk_user_font *f)
|
|
|
+{
|
|
|
+ struct nk_rect label;
|
|
|
+ float text_width;
|
|
|
+
|
|
|
+ NK_ASSERT(o);
|
|
|
+ NK_ASSERT(t);
|
|
|
+ if (!o || !t) return;
|
|
|
+
|
|
|
+ b.h = NK_MAX(b.h, 2 * t->padding.y);
|
|
|
+ label.x = 0; label.w = 0;
|
|
|
+ label.y = b.y + t->padding.y;
|
|
|
+ label.h = NK_MIN(f->height, b.h - 2 * t->padding.y);
|
|
|
+
|
|
|
+ text_width = f->width(f->userdata, f->height, (const char*)string, len);
|
|
|
+ text_width += (2.0f * t->padding.x);
|
|
|
+
|
|
|
+ /* align in x-axis */
|
|
|
+ if (a & NK_TEXT_ALIGN_LEFT) {
|
|
|
+ label.x = b.x + t->padding.x;
|
|
|
+ label.w = NK_MAX(0, b.w - 2 * t->padding.x);
|
|
|
+ } else if (a & NK_TEXT_ALIGN_CENTERED) {
|
|
|
+ label.w = NK_MAX(1, 2 * t->padding.x + (float)text_width);
|
|
|
+ label.x = (b.x + t->padding.x + ((b.w - 2 * t->padding.x) - label.w) / 2);
|
|
|
+ label.x = NK_MAX(b.x + t->padding.x, label.x);
|
|
|
+ label.w = NK_MIN(b.x + b.w, label.x + label.w);
|
|
|
+ if (label.w >= label.x) label.w -= label.x;
|
|
|
+ } else if (a & NK_TEXT_ALIGN_RIGHT) {
|
|
|
+ label.x = NK_MAX(b.x + t->padding.x, (b.x + b.w) - (2 * t->padding.x + (float)text_width));
|
|
|
+ label.w = (float)text_width + 2 * t->padding.x;
|
|
|
+ } else return;
|
|
|
+
|
|
|
+ /* align in y-axis */
|
|
|
+ if (a & NK_TEXT_ALIGN_MIDDLE) {
|
|
|
+ label.y = b.y + b.h/2.0f - (float)f->height/2.0f;
|
|
|
+ label.h = NK_MAX(b.h/2.0f, b.h - (b.h/2.0f + f->height/2.0f));
|
|
|
+ } else if (a & NK_TEXT_ALIGN_BOTTOM) {
|
|
|
+ label.y = b.y + b.h - f->height;
|
|
|
+ label.h = f->height;
|
|
|
+ }
|
|
|
+ nk_draw_text(o, label, (const char*)string,
|
|
|
+ len, f, t->background, t->text);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ float width;
|
|
|
+ int glyphs = 0;
|
|
|
+ int fitting = 0;
|
|
|
+ int done = 0;
|
|
|
+ struct nk_rect line;
|
|
|
+ struct nk_text text;
|
|
|
+ NK_INTERN nk_rune seperator[] = {' '};
|
|
|
+
|
|
|
+ NK_ASSERT(o);
|
|
|
+ NK_ASSERT(t);
|
|
|
+ if (!o || !t) return;
|
|
|
+
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ text.background = t->background;
|
|
|
+ text.text = t->text;
|
|
|
+
|
|
|
+ b.w = NK_MAX(b.w, 2 * t->padding.x);
|
|
|
+ b.h = NK_MAX(b.h, 2 * t->padding.y);
|
|
|
+ b.h = b.h - 2 * t->padding.y;
|
|
|
+
|
|
|
+ line.x = b.x + t->padding.x;
|
|
|
+ line.y = b.y + t->padding.y;
|
|
|
+ line.w = b.w - 2 * t->padding.x;
|
|
|
+ line.h = 2 * t->padding.y + f->height;
|
|
|
+
|
|
|
+ fitting = nk_text_clamp(f, string, len, line.w, &glyphs, &width, seperator,NK_LEN(seperator));
|
|
|
+ while (done < len) {
|
|
|
+ if (!fitting || line.y + line.h >= (b.y + b.h)) break;
|
|
|
+ nk_widget_text(o, line, &string[done], fitting, &text, NK_TEXT_LEFT, f);
|
|
|
+ done += fitting;
|
|
|
+ line.y += f->height + 2 * t->padding.y;
|
|
|
+ fitting = nk_text_clamp(f, &string[done], len - done, line.w, &glyphs, &width, seperator,NK_LEN(seperator));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * BUTTON
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_symbol(struct nk_command_buffer *out, enum nk_symbol_type type,
|
|
|
+ struct nk_rect content, struct nk_color background, struct nk_color foreground,
|
|
|
+ float border_width, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ switch (type) {
|
|
|
+ case NK_SYMBOL_X:
|
|
|
+ case NK_SYMBOL_UNDERSCORE:
|
|
|
+ case NK_SYMBOL_PLUS:
|
|
|
+ case NK_SYMBOL_MINUS: {
|
|
|
+ /* single character text symbol */
|
|
|
+ const char *X = (type == NK_SYMBOL_X) ? "x":
|
|
|
+ (type == NK_SYMBOL_UNDERSCORE) ? "_":
|
|
|
+ (type == NK_SYMBOL_PLUS) ? "+": "-";
|
|
|
+ struct nk_text text;
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ text.background = background;
|
|
|
+ text.text = foreground;
|
|
|
+ nk_widget_text(out, content, X, 1, &text, NK_TEXT_CENTERED, font);
|
|
|
+ } break;
|
|
|
+ case NK_SYMBOL_CIRCLE_SOLID:
|
|
|
+ case NK_SYMBOL_CIRCLE_OUTLINE:
|
|
|
+ case NK_SYMBOL_RECT_SOLID:
|
|
|
+ case NK_SYMBOL_RECT_OUTLINE: {
|
|
|
+ /* simple empty/filled shapes */
|
|
|
+ if (type == NK_SYMBOL_RECT_SOLID || type == NK_SYMBOL_RECT_OUTLINE) {
|
|
|
+ nk_fill_rect(out, content, 0, foreground);
|
|
|
+ if (type == NK_SYMBOL_RECT_OUTLINE)
|
|
|
+ nk_fill_rect(out, nk_shrink_rect(content, border_width), 0, background);
|
|
|
+ } else {
|
|
|
+ nk_fill_circle(out, content, foreground);
|
|
|
+ if (type == NK_SYMBOL_CIRCLE_OUTLINE)
|
|
|
+ nk_fill_circle(out, nk_shrink_rect(content, 1), background);
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+ case NK_SYMBOL_TRIANGLE_UP:
|
|
|
+ case NK_SYMBOL_TRIANGLE_DOWN:
|
|
|
+ case NK_SYMBOL_TRIANGLE_LEFT:
|
|
|
+ case NK_SYMBOL_TRIANGLE_RIGHT: {
|
|
|
+ enum nk_heading heading;
|
|
|
+ struct nk_vec2 points[3];
|
|
|
+ heading = (type == NK_SYMBOL_TRIANGLE_RIGHT) ? NK_RIGHT :
|
|
|
+ (type == NK_SYMBOL_TRIANGLE_LEFT) ? NK_LEFT:
|
|
|
+ (type == NK_SYMBOL_TRIANGLE_UP) ? NK_UP: NK_DOWN;
|
|
|
+ nk_triangle_from_direction(points, content, 0, 0, heading);
|
|
|
+ nk_fill_triangle(out, points[0].x, points[0].y, points[1].x, points[1].y,
|
|
|
+ points[2].x, points[2].y, foreground);
|
|
|
+ } break;
|
|
|
+ default:
|
|
|
+ case NK_SYMBOL_NONE:
|
|
|
+ case NK_SYMBOL_MAX: break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_button_behavior(nk_flags *state, struct nk_rect r,
|
|
|
+ const struct nk_input *i, enum nk_button_behavior behavior)
|
|
|
+{
|
|
|
+ int ret = 0;
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (!i) return 0;
|
|
|
+ if (nk_input_is_mouse_hovering_rect(i, r)) {
|
|
|
+ *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+ if (nk_input_is_mouse_down(i, NK_BUTTON_LEFT))
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ if (nk_input_has_mouse_click_in_rect(i, NK_BUTTON_LEFT, r)) {
|
|
|
+ ret = (behavior != NK_BUTTON_DEFAULT) ?
|
|
|
+ nk_input_is_mouse_down(i, NK_BUTTON_LEFT):
|
|
|
+#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
|
|
|
+ nk_input_is_mouse_released(i, NK_BUTTON_LEFT);
|
|
|
+#else
|
|
|
+ nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT);
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(i, r))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER)
|
|
|
+ background = &style->hover;
|
|
|
+ else if (state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ background = &style->active;
|
|
|
+ else background = &style->normal;
|
|
|
+
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
|
|
|
+ }
|
|
|
+ return background;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !style)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ /* calculate button content space */
|
|
|
+ content->x = r.x + style->padding.x + style->border + style->rounding;
|
|
|
+ content->y = r.y + style->padding.y + style->border + style->rounding;
|
|
|
+ content->w = r.w - (2 * style->padding.x + style->border + style->rounding*2);
|
|
|
+ content->h = r.h - (2 * style->padding.y + style->border + style->rounding*2);
|
|
|
+
|
|
|
+ /* execute button behavior */
|
|
|
+ bounds.x = r.x - style->touch_padding.x;
|
|
|
+ bounds.y = r.y - style->touch_padding.y;
|
|
|
+ bounds.w = r.w + 2 * style->touch_padding.x;
|
|
|
+ bounds.h = r.h + 2 * style->touch_padding.y;
|
|
|
+ return nk_button_behavior(state, bounds, in, behavior);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_text text;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ background = nk_draw_button(out, bounds, state, style);
|
|
|
+
|
|
|
+ /* select correct colors/images */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR)
|
|
|
+ text.background = background->data.color;
|
|
|
+ else text.background = style->text_background;
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER)
|
|
|
+ text.text = style->text_hover;
|
|
|
+ else if (state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ text.text = style->text_active;
|
|
|
+ else text.text = style->text_normal;
|
|
|
+
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ nk_widget_text(out, *content, txt, len, &text, text_alignment, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_rect content;
|
|
|
+ int ret = nk_false;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(string);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ if (!out || !style || !font || !string)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ ret = nk_do_button(state, out, bounds, style, in, behavior, &content);
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_button_text(out, &bounds, &content, *state, style, string, len, align, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_color sym, bg;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ /* select correct colors/images */
|
|
|
+ background = nk_draw_button(out, bounds, state, style);
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR)
|
|
|
+ bg = background->data.color;
|
|
|
+ else bg = style->text_background;
|
|
|
+
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->text_hover;
|
|
|
+ else if (state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ sym = style->text_active;
|
|
|
+ else sym = style->text_normal;
|
|
|
+ nk_draw_symbol(out, type, *content, bg, sym, 1, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+ struct nk_rect content;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !style || !font || !state)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ ret = nk_do_button(state, out, bounds, style, in, behavior, &content);
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_button_symbol(out, &bounds, &content, *state, style, symbol, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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_draw_button(out, bounds, state, style);
|
|
|
+ nk_draw_image(out, *content, img, nk_white);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+ struct nk_rect content;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !style || !state)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ ret = nk_do_button(state, out, bounds, style, in, b, &content);
|
|
|
+ content.x += style->image_padding.x;
|
|
|
+ content.y += style->image_padding.y;
|
|
|
+ content.w -= 2 * style->image_padding.x;
|
|
|
+ content.h -= 2 * style->image_padding.y;
|
|
|
+
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_button_image(out, &bounds, &content, *state, style, &img);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_color sym;
|
|
|
+ struct nk_text text;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ /* select correct background colors/images */
|
|
|
+ background = nk_draw_button(out, bounds, state, style);
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR)
|
|
|
+ text.background = background->data.color;
|
|
|
+ else text.background = style->text_background;
|
|
|
+
|
|
|
+ /* select correct text colors */
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ sym = style->text_hover;
|
|
|
+ text.text = style->text_hover;
|
|
|
+ } else if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ sym = style->text_active;
|
|
|
+ text.text = style->text_active;
|
|
|
+ } else {
|
|
|
+ sym = style->text_normal;
|
|
|
+ text.text = style->text_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ nk_draw_symbol(out, type, *symbol, style->text_background, sym, 0, font);
|
|
|
+ nk_widget_text(out, *label, str, len, &text, NK_TEXT_CENTERED, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+ struct nk_rect tri = {0,0,0,0};
|
|
|
+ struct nk_rect content;
|
|
|
+
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ if (!out || !style || !font)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ ret = nk_do_button(state, out, bounds, style, in, behavior, &content);
|
|
|
+ tri.y = content.y + (content.h/2) - font->height/2;
|
|
|
+ tri.w = font->height; tri.h = font->height;
|
|
|
+ if (align & NK_TEXT_ALIGN_LEFT) {
|
|
|
+ tri.x = (content.x + content.w) - (2 * style->padding.x + tri.w);
|
|
|
+ tri.x = NK_MAX(tri.x, 0);
|
|
|
+ } else tri.x = content.x + 2 * style->padding.x;
|
|
|
+
|
|
|
+ /* draw button */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_button_text_symbol(out, &bounds, &content, &tri,
|
|
|
+ *state, style, str, len, symbol, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_text text;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ background = nk_draw_button(out, bounds, state, style);
|
|
|
+
|
|
|
+ /* select correct colors */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR)
|
|
|
+ text.background = background->data.color;
|
|
|
+ else text.background = style->text_background;
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER)
|
|
|
+ text.text = style->text_hover;
|
|
|
+ else if (state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ text.text = style->text_active;
|
|
|
+ else text.text = style->text_normal;
|
|
|
+
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ nk_widget_text(out, *label, str, len, &text, NK_TEXT_CENTERED, font);
|
|
|
+ nk_draw_image(out, *image, img, nk_white);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+ struct nk_rect icon;
|
|
|
+ struct nk_rect content;
|
|
|
+
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !font || !style || !str)
|
|
|
+ return nk_false;
|
|
|
+
|
|
|
+ ret = nk_do_button(state, out, bounds, style, in, behavior, &content);
|
|
|
+ icon.y = bounds.y + style->padding.y;
|
|
|
+ icon.w = icon.h = bounds.h - 2 * style->padding.y;
|
|
|
+ if (align & NK_TEXT_ALIGN_LEFT) {
|
|
|
+ icon.x = (bounds.x + bounds.w) - (2 * style->padding.x + icon.w);
|
|
|
+ icon.x = NK_MAX(icon.x, 0);
|
|
|
+ } else icon.x = bounds.x + 2 * style->padding.x;
|
|
|
+
|
|
|
+ icon.x += style->image_padding.x;
|
|
|
+ icon.y += style->image_padding.y;
|
|
|
+ icon.w -= 2 * style->image_padding.x;
|
|
|
+ icon.h -= 2 * style->image_padding.y;
|
|
|
+
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_button_text_image(out, &bounds, &content, &icon, *state, style, str, len, font, &img);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * TOGGLE
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+enum nk_toggle_type {
|
|
|
+ NK_TOGGLE_CHECK,
|
|
|
+ NK_TOGGLE_OPTION
|
|
|
+};
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_toggle_behavior(const struct nk_input *in, struct nk_rect select,
|
|
|
+ nk_flags *state, int active)
|
|
|
+{
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (nk_button_behavior(state, select, in, NK_BUTTON_DEFAULT)) {
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ active = !active;
|
|
|
+ }
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, select))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, select))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+ return active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ const struct nk_style_item *cursor;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ /* select correct colors/images */
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ text.text = style->text_hover;
|
|
|
+ } else if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ text.text = style->text_active;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ cursor = &style->cursor_normal;
|
|
|
+ text.text = style->text_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw background and cursor */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ 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);
|
|
|
+ else nk_fill_rect(out, *cursors, 0, cursor->data.color);
|
|
|
+ }
|
|
|
+
|
|
|
+ text.padding.x = 0;
|
|
|
+ text.padding.y = 0;
|
|
|
+ text.background = style->text_background;
|
|
|
+ nk_widget_text(out, *label, string, len, &text, NK_TEXT_LEFT, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ const struct nk_style_item *cursor;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ /* select correct colors/images */
|
|
|
+ if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ text.text = style->text_hover;
|
|
|
+ } else if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ text.text = style->text_active;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ cursor = &style->cursor_normal;
|
|
|
+ text.text = style->text_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 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);
|
|
|
+ } 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ text.padding.x = 0;
|
|
|
+ text.padding.y = 0;
|
|
|
+ text.background = style->text_background;
|
|
|
+ nk_widget_text(out, *label, string, len, &text, NK_TEXT_LEFT, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int was_active;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_rect select;
|
|
|
+ struct nk_rect cursor;
|
|
|
+ struct nk_rect label;
|
|
|
+
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ if (!out || !style || !font || !active)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ r.w = NK_MAX(r.w, font->height + 2 * style->padding.x);
|
|
|
+ r.h = NK_MAX(r.h, font->height + 2 * style->padding.y);
|
|
|
+
|
|
|
+ /* add additional touch padding for touch screen devices */
|
|
|
+ bounds.x = r.x - style->touch_padding.x;
|
|
|
+ bounds.y = r.y - style->touch_padding.y;
|
|
|
+ bounds.w = r.w + 2 * style->touch_padding.x;
|
|
|
+ bounds.h = r.h + 2 * style->touch_padding.y;
|
|
|
+
|
|
|
+ /* calculate the selector space */
|
|
|
+ select.w = font->height;
|
|
|
+ select.h = select.w;
|
|
|
+ select.y = r.y + r.h/2.0f - select.h/2.0f;
|
|
|
+ select.x = r.x;
|
|
|
+
|
|
|
+ /* calculate the bounds of the cursor inside the selector */
|
|
|
+ cursor.x = select.x + style->padding.x + style->border;
|
|
|
+ cursor.y = select.y + style->padding.y + style->border;
|
|
|
+ cursor.w = select.w - (2 * style->padding.x + 2 * style->border);
|
|
|
+ cursor.h = select.h - (2 * style->padding.y + 2 * style->border);
|
|
|
+
|
|
|
+ /* label behind the selector */
|
|
|
+ label.x = select.x + select.w + style->spacing;
|
|
|
+ label.y = select.y;
|
|
|
+ label.w = NK_MAX(r.x + r.w, label.x) - label.x;
|
|
|
+ label.h = select.w;
|
|
|
+
|
|
|
+ /* update selector */
|
|
|
+ was_active = *active;
|
|
|
+ *active = nk_toggle_behavior(in, bounds, state, *active);
|
|
|
+
|
|
|
+ /* draw selector */
|
|
|
+ if (style->draw_begin)
|
|
|
+ style->draw_begin(out, style->userdata);
|
|
|
+ if (type == NK_TOGGLE_CHECK) {
|
|
|
+ nk_draw_checkbox(out, *state, style, *active, &label, &select, &cursor, str, len, font);
|
|
|
+ } else {
|
|
|
+ nk_draw_option(out, *state, style, *active, &label, &select, &cursor, str, len, font);
|
|
|
+ }
|
|
|
+ if (style->draw_end)
|
|
|
+ style->draw_end(out, style->userdata);
|
|
|
+ return (was_active != *active);
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * SELECTABLE
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN 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,
|
|
|
+ const char *string, int len, nk_flags align, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_text text;
|
|
|
+ text.padding = style->padding;
|
|
|
+
|
|
|
+ /* select correct colors/images */
|
|
|
+ if (!active) {
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->pressed;
|
|
|
+ text.text = style->text_pressed;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ text.text = style->text_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ text.text = style->text_normal;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->pressed_active;
|
|
|
+ text.text = style->text_pressed_active;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover_active;
|
|
|
+ text.text = style->text_hover_active;
|
|
|
+ } else {
|
|
|
+ background = &style->normal_active;
|
|
|
+ text.text = style->text_normal_active;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /* draw selectable background and text */
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ text.background = background->data.color;
|
|
|
+ }
|
|
|
+ if (img && icon) nk_draw_image(out, *icon, img, nk_white);
|
|
|
+ nk_widget_text(out, *bounds, string, len, &text, align, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int old_value;
|
|
|
+ struct nk_rect touch;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(len);
|
|
|
+ NK_ASSERT(value);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(font);
|
|
|
+
|
|
|
+ if (!state || !out || !str || !len || !value || !style || !font) return 0;
|
|
|
+ old_value = *value;
|
|
|
+
|
|
|
+ /* remove padding */
|
|
|
+ touch.x = bounds.x - style->touch_padding.x;
|
|
|
+ touch.y = bounds.y - style->touch_padding.y;
|
|
|
+ touch.w = bounds.w + style->touch_padding.x * 2;
|
|
|
+ touch.h = bounds.h + style->touch_padding.y * 2;
|
|
|
+
|
|
|
+ /* update button */
|
|
|
+ if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT))
|
|
|
+ *value = !(*value);
|
|
|
+
|
|
|
+ /* draw selectable */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_selectable(out, *state, style, *value, &bounds, 0,0, str, len, align, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return old_value != *value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int old_value;
|
|
|
+ struct nk_rect touch;
|
|
|
+ struct nk_rect icon;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(str);
|
|
|
+ NK_ASSERT(len);
|
|
|
+ NK_ASSERT(value);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(font);
|
|
|
+
|
|
|
+ if (!state || !out || !str || !len || !value || !style || !font) return 0;
|
|
|
+ old_value = *value;
|
|
|
+
|
|
|
+ /* toggle behavior */
|
|
|
+ touch.x = bounds.x - style->touch_padding.x;
|
|
|
+ touch.y = bounds.y - style->touch_padding.y;
|
|
|
+ touch.w = bounds.w + style->touch_padding.x * 2;
|
|
|
+ touch.h = bounds.h + style->touch_padding.y * 2;
|
|
|
+ if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT))
|
|
|
+ *value = !(*value);
|
|
|
+
|
|
|
+ icon.y = bounds.y + style->padding.y;
|
|
|
+ icon.w = icon.h = bounds.h - 2 * style->padding.y;
|
|
|
+ if (align & NK_TEXT_ALIGN_LEFT) {
|
|
|
+ icon.x = (bounds.x + bounds.w) - (2 * style->padding.x + icon.w);
|
|
|
+ icon.x = NK_MAX(icon.x, 0);
|
|
|
+ } else icon.x = bounds.x + 2 * style->padding.x;
|
|
|
+
|
|
|
+ icon.x += style->image_padding.x;
|
|
|
+ icon.y += style->image_padding.y;
|
|
|
+ icon.w -= 2 * style->image_padding.x;
|
|
|
+ icon.h -= 2 * style->image_padding.y;
|
|
|
+
|
|
|
+ /* draw selectable */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_selectable(out, *state, style, *value, &bounds, &icon, img, str, len, align, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return old_value != *value;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * SLIDER
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN float
|
|
|
+nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor,
|
|
|
+ struct nk_rect *visual_cursor, struct nk_input *in,
|
|
|
+ struct nk_rect bounds, float slider_min, float slider_max, float slider_value,
|
|
|
+ float slider_step, float slider_steps)
|
|
|
+{
|
|
|
+ int left_mouse_down;
|
|
|
+ int left_mouse_click_in_cursor;
|
|
|
+
|
|
|
+ /* check if visual cursor is being dragged */
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ left_mouse_click_in_cursor = in && nk_input_has_mouse_click_down_in_rect(in,
|
|
|
+ NK_BUTTON_LEFT, *visual_cursor, nk_true);
|
|
|
+
|
|
|
+ if (left_mouse_down && left_mouse_click_in_cursor)
|
|
|
+ {
|
|
|
+ float ratio = 0;
|
|
|
+ const float d = in->mouse.pos.x - (visual_cursor->x+visual_cursor->w*0.5f);
|
|
|
+ const float pxstep = bounds.w / slider_steps;
|
|
|
+
|
|
|
+ /* only update value if the next slider step is reached */
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ if (NK_ABS(d) >= pxstep) {
|
|
|
+ const float steps = (float)((int)(NK_ABS(d) / pxstep));
|
|
|
+ slider_value += (d > 0) ? (slider_step*steps) : -(slider_step*steps);
|
|
|
+ slider_value = NK_CLAMP(slider_min, slider_value, slider_max);
|
|
|
+ ratio = (slider_value - slider_min)/slider_step;
|
|
|
+ logical_cursor->x = bounds.x + (logical_cursor->w * ratio);
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = logical_cursor->x;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* slider widget state */
|
|
|
+ if (nk_input_is_mouse_hovering_rect(in, bounds))
|
|
|
+ *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER &&
|
|
|
+ !nk_input_is_mouse_prev_hovering_rect(in, bounds))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, bounds))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+ return slider_value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_slider(struct nk_command_buffer *out, nk_flags state,
|
|
|
+ const struct nk_style_slider *style, const struct nk_rect *bounds,
|
|
|
+ const struct nk_rect *visual_cursor, float min, float value, float max)
|
|
|
+{
|
|
|
+ struct nk_rect fill;
|
|
|
+ struct nk_rect bar;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ /* select correct slider images/colors */
|
|
|
+ struct nk_color bar_color;
|
|
|
+ const struct nk_style_item *cursor;
|
|
|
+
|
|
|
+ NK_UNUSED(min);
|
|
|
+ NK_UNUSED(max);
|
|
|
+ NK_UNUSED(value);
|
|
|
+
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ bar_color = style->bar_active;
|
|
|
+ cursor = &style->cursor_active;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ bar_color = style->bar_hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ bar_color = style->bar_normal;
|
|
|
+ cursor = &style->cursor_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* calculate slider background bar */
|
|
|
+ bar.x = bounds->x;
|
|
|
+ bar.y = (visual_cursor->y + visual_cursor->h/2) - bounds->h/12;
|
|
|
+ bar.w = bounds->w;
|
|
|
+ bar.h = bounds->h/6;
|
|
|
+
|
|
|
+ /* filled background bar style */
|
|
|
+ fill.w = (visual_cursor->x + (visual_cursor->w/2.0f)) - bar.x;
|
|
|
+ fill.x = bar.x;
|
|
|
+ fill.y = bar.y;
|
|
|
+ fill.h = bar.h;
|
|
|
+
|
|
|
+ /* draw background */
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw slider bar */
|
|
|
+ nk_fill_rect(out, bar, style->rounding, bar_color);
|
|
|
+ nk_fill_rect(out, fill, style->rounding, style->bar_filled);
|
|
|
+
|
|
|
+ /* draw cursor */
|
|
|
+ if (cursor->type == NK_STYLE_ITEM_IMAGE)
|
|
|
+ nk_draw_image(out, *visual_cursor, &cursor->data.image, nk_white);
|
|
|
+ else nk_fill_circle(out, *visual_cursor, cursor->data.color);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_do_slider(nk_flags *state,
|
|
|
+ struct nk_command_buffer *out, struct nk_rect bounds,
|
|
|
+ float min, float val, float max, float step,
|
|
|
+ const struct nk_style_slider *style, struct nk_input *in,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ float slider_range;
|
|
|
+ float slider_min;
|
|
|
+ float slider_max;
|
|
|
+ float slider_value;
|
|
|
+ float slider_steps;
|
|
|
+ float cursor_offset;
|
|
|
+
|
|
|
+ struct nk_rect visual_cursor;
|
|
|
+ struct nk_rect logical_cursor;
|
|
|
+
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !style)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* remove padding from slider bounds */
|
|
|
+ bounds.x = bounds.x + style->padding.x;
|
|
|
+ bounds.y = bounds.y + style->padding.y;
|
|
|
+ bounds.h = NK_MAX(bounds.h, 2*style->padding.y);
|
|
|
+ bounds.w = NK_MAX(bounds.w, 2*style->padding.x + style->cursor_size.x);
|
|
|
+ bounds.w -= 2 * style->padding.x;
|
|
|
+ bounds.h -= 2 * style->padding.y;
|
|
|
+
|
|
|
+ /* optional buttons */
|
|
|
+ if (style->show_buttons) {
|
|
|
+ nk_flags ws;
|
|
|
+ struct nk_rect button;
|
|
|
+ button.y = bounds.y;
|
|
|
+ button.w = bounds.h;
|
|
|
+ button.h = bounds.h;
|
|
|
+
|
|
|
+ /* decrement button */
|
|
|
+ button.x = bounds.x;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->dec_symbol, NK_BUTTON_DEFAULT,
|
|
|
+ &style->dec_button, in, font))
|
|
|
+ val -= step;
|
|
|
+
|
|
|
+ /* increment button */
|
|
|
+ button.x = (bounds.x + bounds.w) - button.w;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->inc_symbol, NK_BUTTON_DEFAULT,
|
|
|
+ &style->inc_button, in, font))
|
|
|
+ val += step;
|
|
|
+
|
|
|
+ bounds.x = bounds.x + button.w + style->spacing.x;
|
|
|
+ bounds.w = bounds.w - (2*button.w + 2*style->spacing.x);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* remove one cursor size to support visual cursor */
|
|
|
+ bounds.x += style->cursor_size.x*0.5f;
|
|
|
+ bounds.w -= style->cursor_size.x;
|
|
|
+
|
|
|
+ /* make sure the provided values are correct */
|
|
|
+ slider_max = NK_MAX(min, max);
|
|
|
+ slider_min = NK_MIN(min, max);
|
|
|
+ slider_value = NK_CLAMP(slider_min, val, slider_max);
|
|
|
+ slider_range = slider_max - slider_min;
|
|
|
+ slider_steps = slider_range / step;
|
|
|
+ cursor_offset = (slider_value - slider_min) / step;
|
|
|
+
|
|
|
+ /* calculate cursor
|
|
|
+ Basically you have two cursors. One for visual representation and interaction
|
|
|
+ and one for updating the actual cursor value. */
|
|
|
+ logical_cursor.h = bounds.h;
|
|
|
+ logical_cursor.w = bounds.w / slider_steps;
|
|
|
+ logical_cursor.x = bounds.x + (logical_cursor.w * cursor_offset);
|
|
|
+ logical_cursor.y = bounds.y;
|
|
|
+
|
|
|
+ visual_cursor.h = style->cursor_size.y;
|
|
|
+ visual_cursor.w = style->cursor_size.x;
|
|
|
+ visual_cursor.y = (bounds.y + bounds.h*0.5f) - visual_cursor.h*0.5f;
|
|
|
+ visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f;
|
|
|
+
|
|
|
+ slider_value = nk_slider_behavior(state, &logical_cursor, &visual_cursor,
|
|
|
+ in, bounds, slider_min, slider_max, slider_value, step, slider_steps);
|
|
|
+ visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f;
|
|
|
+
|
|
|
+ /* draw slider */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_slider(out, *state, style, &bounds, &visual_cursor, slider_min, slider_value, slider_max);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return slider_value;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * PROGRESSBAR
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN nk_size
|
|
|
+nk_progress_behavior(nk_flags *state, const struct nk_input *in,
|
|
|
+ struct nk_rect r, nk_size max, nk_size value, int modifiable)
|
|
|
+{
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (in && modifiable && nk_input_is_mouse_hovering_rect(in, r)) {
|
|
|
+ int left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ int left_mouse_click_in_cursor = nk_input_has_mouse_click_down_in_rect(in,
|
|
|
+ NK_BUTTON_LEFT, r, nk_true);
|
|
|
+
|
|
|
+ if (left_mouse_down && left_mouse_click_in_cursor) {
|
|
|
+ float ratio = NK_MAX(0, (float)(in->mouse.pos.x - r.x)) / (float)r.w;
|
|
|
+ value = (nk_size)NK_MAX(0,((float)max * ratio));
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ } else *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set progressbar widget state */
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, r))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, r))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+
|
|
|
+ if (!max) return value;
|
|
|
+ value = NK_MIN(value, max);
|
|
|
+ return value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_progress(struct nk_command_buffer *out, nk_flags state,
|
|
|
+ const struct nk_style_progress *style, const struct nk_rect *bounds,
|
|
|
+ const struct nk_rect *scursor, nk_size value, nk_size max)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ const struct nk_style_item *cursor;
|
|
|
+
|
|
|
+ NK_UNUSED(max);
|
|
|
+ NK_UNUSED(value);
|
|
|
+
|
|
|
+ /* select correct colors/images to draw */
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ cursor = &style->cursor_active;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER){
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ cursor = &style->cursor_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw background */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
|
|
|
+ } else nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+
|
|
|
+ /* draw cursor */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ nk_fill_rect(out, *scursor, style->rounding, cursor->data.color);
|
|
|
+ nk_stroke_rect(out, *scursor, style->rounding, style->border, style->border_color);
|
|
|
+ } else nk_draw_image(out, *scursor, &cursor->data.image, nk_white);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_size
|
|
|
+nk_do_progress(nk_flags *state,
|
|
|
+ struct nk_command_buffer *out, struct nk_rect bounds,
|
|
|
+ nk_size value, nk_size max, int modifiable,
|
|
|
+ const struct nk_style_progress *style, const struct nk_input *in)
|
|
|
+{
|
|
|
+ float prog_scale;
|
|
|
+ nk_size prog_value;
|
|
|
+ struct nk_rect cursor;
|
|
|
+
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ if (!out || !style) return 0;
|
|
|
+
|
|
|
+ /* calculate progressbar cursor */
|
|
|
+ cursor.w = NK_MAX(bounds.w, 2 * style->padding.x + 2 * style->border);
|
|
|
+ cursor.h = NK_MAX(bounds.h, 2 * style->padding.y + 2 * style->border);
|
|
|
+ cursor = nk_pad_rect(bounds, nk_vec2(style->padding.x + style->border, style->padding.y + style->border));
|
|
|
+ prog_scale = (float)value / (float)max;
|
|
|
+ cursor.w = (bounds.w - 2) * prog_scale;
|
|
|
+
|
|
|
+ /* update progressbar */
|
|
|
+ prog_value = NK_MIN(value, max);
|
|
|
+ prog_value = nk_progress_behavior(state, in, bounds, max, prog_value, modifiable);
|
|
|
+
|
|
|
+ /* draw progressbar */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_progress(out, *state, style, &bounds, &cursor, value, max);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return prog_value;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * SCROLLBAR
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN float
|
|
|
+nk_scrollbar_behavior(nk_flags *state, struct nk_input *in,
|
|
|
+ int has_scrolling, const struct nk_rect *scroll,
|
|
|
+ const struct nk_rect *cursor, const struct nk_rect *empty0,
|
|
|
+ const struct nk_rect *empty1, float scroll_offset,
|
|
|
+ float target, float scroll_step, enum nk_orientation o)
|
|
|
+{
|
|
|
+ nk_flags ws = 0;
|
|
|
+ int left_mouse_down;
|
|
|
+ int left_mouse_click_in_cursor;
|
|
|
+ float scroll_delta;
|
|
|
+
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (!in) return scroll_offset;
|
|
|
+
|
|
|
+ left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ left_mouse_click_in_cursor = nk_input_has_mouse_click_down_in_rect(in,
|
|
|
+ NK_BUTTON_LEFT, *cursor, nk_true);
|
|
|
+ if (nk_input_is_mouse_hovering_rect(in, *scroll))
|
|
|
+ *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+
|
|
|
+ scroll_delta = (o == NK_VERTICAL) ? in->mouse.scroll_delta.y: in->mouse.scroll_delta.x;
|
|
|
+ if (left_mouse_down && left_mouse_click_in_cursor) {
|
|
|
+ /* update cursor by mouse dragging */
|
|
|
+ float pixel, delta;
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ if (o == NK_VERTICAL) {
|
|
|
+ float cursor_y;
|
|
|
+ pixel = in->mouse.delta.y;
|
|
|
+ delta = (pixel / scroll->h) * target;
|
|
|
+ scroll_offset = NK_CLAMP(0, scroll_offset + delta, target - scroll->h);
|
|
|
+ cursor_y = scroll->y + ((scroll_offset/target) * scroll->h);
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y = cursor_y + cursor->h/2.0f;
|
|
|
+ } else {
|
|
|
+ float cursor_x;
|
|
|
+ pixel = in->mouse.delta.x;
|
|
|
+ delta = (pixel / scroll->w) * target;
|
|
|
+ scroll_offset = NK_CLAMP(0, scroll_offset + delta, target - scroll->w);
|
|
|
+ cursor_x = scroll->x + ((scroll_offset/target) * scroll->w);
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = cursor_x + cursor->w/2.0f;
|
|
|
+ }
|
|
|
+ } else if ((nk_input_is_key_pressed(in, NK_KEY_SCROLL_UP) && o == NK_VERTICAL && has_scrolling)||
|
|
|
+ nk_button_behavior(&ws, *empty0, in, NK_BUTTON_DEFAULT)) {
|
|
|
+ /* scroll page up by click on empty space or shortcut */
|
|
|
+ if (o == NK_VERTICAL)
|
|
|
+ scroll_offset = NK_MAX(0, scroll_offset - scroll->h);
|
|
|
+ else scroll_offset = NK_MAX(0, scroll_offset - scroll->w);
|
|
|
+ } else if ((nk_input_is_key_pressed(in, NK_KEY_SCROLL_DOWN) && o == NK_VERTICAL && has_scrolling) ||
|
|
|
+ nk_button_behavior(&ws, *empty1, in, NK_BUTTON_DEFAULT)) {
|
|
|
+ /* scroll page down by click on empty space or shortcut */
|
|
|
+ if (o == NK_VERTICAL)
|
|
|
+ scroll_offset = NK_MIN(scroll_offset + scroll->h, target - scroll->h);
|
|
|
+ else scroll_offset = NK_MIN(scroll_offset + scroll->w, target - scroll->w);
|
|
|
+ } else if (has_scrolling) {
|
|
|
+ if ((scroll_delta < 0 || (scroll_delta > 0))) {
|
|
|
+ /* update cursor by mouse scrolling */
|
|
|
+ scroll_offset = scroll_offset + scroll_step * (-scroll_delta);
|
|
|
+ if (o == NK_VERTICAL)
|
|
|
+ scroll_offset = NK_CLAMP(0, scroll_offset, target - scroll->h);
|
|
|
+ else scroll_offset = NK_CLAMP(0, scroll_offset, target - scroll->w);
|
|
|
+ } else if (nk_input_is_key_pressed(in, NK_KEY_SCROLL_START)) {
|
|
|
+ /* update cursor to the beginning */
|
|
|
+ if (o == NK_VERTICAL) scroll_offset = 0;
|
|
|
+ } else if (nk_input_is_key_pressed(in, NK_KEY_SCROLL_END)) {
|
|
|
+ /* update cursor to the end */
|
|
|
+ if (o == NK_VERTICAL) scroll_offset = target - scroll->h;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, *scroll))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, *scroll))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+ return scroll_offset;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_draw_scrollbar(struct nk_command_buffer *out, nk_flags state,
|
|
|
+ const struct nk_style_scrollbar *style, const struct nk_rect *bounds,
|
|
|
+ const struct nk_rect *scroll)
|
|
|
+{
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ const struct nk_style_item *cursor;
|
|
|
+
|
|
|
+ /* select correct colors/images to draw */
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ cursor = &style->cursor_active;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ cursor = &style->cursor_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ cursor = &style->cursor_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw background */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
|
|
|
+ } else {
|
|
|
+ nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw cursor */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ nk_fill_rect(out, *scroll, style->rounding_cursor, cursor->data.color);
|
|
|
+ nk_stroke_rect(out, *scroll, style->rounding_cursor, style->border_cursor, style->cursor_border_color);
|
|
|
+ } else nk_draw_image(out, *scroll, &cursor->data.image, nk_white);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_do_scrollbarv(nk_flags *state,
|
|
|
+ struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling,
|
|
|
+ float offset, float target, float step, float button_pixel_inc,
|
|
|
+ const struct nk_style_scrollbar *style, struct nk_input *in,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ struct nk_rect empty_north;
|
|
|
+ struct nk_rect empty_south;
|
|
|
+ struct nk_rect cursor;
|
|
|
+
|
|
|
+ float scroll_step;
|
|
|
+ float scroll_offset;
|
|
|
+ float scroll_off;
|
|
|
+ float scroll_ratio;
|
|
|
+
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(state);
|
|
|
+ if (!out || !style) return 0;
|
|
|
+
|
|
|
+ scroll.w = NK_MAX(scroll.w, 1);
|
|
|
+ scroll.h = NK_MAX(scroll.h, 0);
|
|
|
+ if (target <= scroll.h) return 0;
|
|
|
+
|
|
|
+ /* optional scrollbar buttons */
|
|
|
+ if (style->show_buttons) {
|
|
|
+ nk_flags ws;
|
|
|
+ float scroll_h;
|
|
|
+ struct nk_rect button;
|
|
|
+
|
|
|
+ button.x = scroll.x;
|
|
|
+ button.w = scroll.w;
|
|
|
+ button.h = scroll.w;
|
|
|
+
|
|
|
+ scroll_h = NK_MAX(scroll.h - 2 * button.h,0);
|
|
|
+ scroll_step = NK_MIN(step, button_pixel_inc);
|
|
|
+
|
|
|
+ /* decrement button */
|
|
|
+ button.y = scroll.y;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->dec_symbol,
|
|
|
+ NK_BUTTON_REPEATER, &style->dec_button, in, font))
|
|
|
+ offset = offset - scroll_step;
|
|
|
+
|
|
|
+ /* increment button */
|
|
|
+ button.y = scroll.y + scroll.h - button.h;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->inc_symbol,
|
|
|
+ NK_BUTTON_REPEATER, &style->inc_button, in, font))
|
|
|
+ offset = offset + scroll_step;
|
|
|
+
|
|
|
+ scroll.y = scroll.y + button.h;
|
|
|
+ scroll.h = scroll_h;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* calculate scrollbar constants */
|
|
|
+ scroll_step = NK_MIN(step, scroll.h);
|
|
|
+ scroll_offset = NK_CLAMP(0, offset, target - scroll.h);
|
|
|
+ scroll_ratio = scroll.h / target;
|
|
|
+ scroll_off = scroll_offset / target;
|
|
|
+
|
|
|
+ /* calculate scrollbar cursor bounds */
|
|
|
+ cursor.h = NK_MAX((scroll_ratio * scroll.h) - (2*style->border + 2*style->padding.y), 0);
|
|
|
+ cursor.y = scroll.y + (scroll_off * scroll.h) + style->border + style->padding.y;
|
|
|
+ cursor.w = scroll.w - (2 * style->border + 2 * style->padding.x);
|
|
|
+ cursor.x = scroll.x + style->border + style->padding.x;
|
|
|
+
|
|
|
+ /* calculate empty space around cursor */
|
|
|
+ empty_north.x = scroll.x;
|
|
|
+ empty_north.y = scroll.y;
|
|
|
+ empty_north.w = scroll.w;
|
|
|
+ empty_north.h = NK_MAX(cursor.y - scroll.y, 0);
|
|
|
+
|
|
|
+ empty_south.x = scroll.x;
|
|
|
+ empty_south.y = cursor.y + cursor.h;
|
|
|
+ empty_south.w = scroll.w;
|
|
|
+ empty_south.h = NK_MAX((scroll.y + scroll.h) - (cursor.y + cursor.h), 0);
|
|
|
+
|
|
|
+ /* update scrollbar */
|
|
|
+ scroll_offset = nk_scrollbar_behavior(state, in, has_scrolling, &scroll, &cursor,
|
|
|
+ &empty_north, &empty_south, scroll_offset, target, scroll_step, NK_VERTICAL);
|
|
|
+ scroll_off = scroll_offset / target;
|
|
|
+ cursor.y = scroll.y + (scroll_off * scroll.h) + style->border_cursor + style->padding.y;
|
|
|
+
|
|
|
+ /* draw scrollbar */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_scrollbar(out, *state, style, &scroll, &cursor);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return scroll_offset;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_do_scrollbarh(nk_flags *state,
|
|
|
+ struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling,
|
|
|
+ float offset, float target, float step, float button_pixel_inc,
|
|
|
+ const struct nk_style_scrollbar *style, struct nk_input *in,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ struct nk_rect cursor;
|
|
|
+ struct nk_rect empty_west;
|
|
|
+ struct nk_rect empty_east;
|
|
|
+
|
|
|
+ float scroll_step;
|
|
|
+ float scroll_offset;
|
|
|
+ float scroll_off;
|
|
|
+ float scroll_ratio;
|
|
|
+
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ if (!out || !style) return 0;
|
|
|
+
|
|
|
+ /* scrollbar background */
|
|
|
+ scroll.h = NK_MAX(scroll.h, 1);
|
|
|
+ scroll.w = NK_MAX(scroll.w, 2 * scroll.h);
|
|
|
+ if (target <= scroll.w) return 0;
|
|
|
+
|
|
|
+ /* optional scrollbar buttons */
|
|
|
+ if (style->show_buttons) {
|
|
|
+ nk_flags ws;
|
|
|
+ float scroll_w;
|
|
|
+ struct nk_rect button;
|
|
|
+ button.y = scroll.y;
|
|
|
+ button.w = scroll.h;
|
|
|
+ button.h = scroll.h;
|
|
|
+
|
|
|
+ scroll_w = scroll.w - 2 * button.w;
|
|
|
+ scroll_step = NK_MIN(step, button_pixel_inc);
|
|
|
+
|
|
|
+ /* decrement button */
|
|
|
+ button.x = scroll.x;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->dec_symbol,
|
|
|
+ NK_BUTTON_REPEATER, &style->dec_button, in, font))
|
|
|
+ offset = offset - scroll_step;
|
|
|
+
|
|
|
+ /* increment button */
|
|
|
+ button.x = scroll.x + scroll.w - button.w;
|
|
|
+ if (nk_do_button_symbol(&ws, out, button, style->inc_symbol,
|
|
|
+ NK_BUTTON_REPEATER, &style->inc_button, in, font))
|
|
|
+ offset = offset + scroll_step;
|
|
|
+
|
|
|
+ scroll.x = scroll.x + button.w;
|
|
|
+ scroll.w = scroll_w;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* calculate scrollbar constants */
|
|
|
+ scroll_step = NK_MIN(step, scroll.w);
|
|
|
+ scroll_offset = NK_CLAMP(0, offset, target - scroll.w);
|
|
|
+ scroll_ratio = scroll.w / target;
|
|
|
+ scroll_off = scroll_offset / target;
|
|
|
+
|
|
|
+ /* calculate cursor bounds */
|
|
|
+ cursor.w = (scroll_ratio * scroll.w) - (2*style->border + 2*style->padding.x);
|
|
|
+ cursor.x = scroll.x + (scroll_off * scroll.w) + style->border + style->padding.x;
|
|
|
+ cursor.h = scroll.h - (2 * style->border + 2 * style->padding.y);
|
|
|
+ cursor.y = scroll.y + style->border + style->padding.y;
|
|
|
+
|
|
|
+ /* calculate empty space around cursor */
|
|
|
+ empty_west.x = scroll.x;
|
|
|
+ empty_west.y = scroll.y;
|
|
|
+ empty_west.w = cursor.x - scroll.x;
|
|
|
+ empty_west.h = scroll.h;
|
|
|
+
|
|
|
+ empty_east.x = cursor.x + cursor.w;
|
|
|
+ empty_east.y = scroll.y;
|
|
|
+ empty_east.w = (scroll.x + scroll.w) - (cursor.x + cursor.w);
|
|
|
+ empty_east.h = scroll.h;
|
|
|
+
|
|
|
+ /* update scrollbar */
|
|
|
+ scroll_offset = nk_scrollbar_behavior(state, in, has_scrolling, &scroll, &cursor,
|
|
|
+ &empty_west, &empty_east, scroll_offset, target, scroll_step, NK_HORIZONTAL);
|
|
|
+ scroll_off = scroll_offset / target;
|
|
|
+ cursor.x = scroll.x + (scroll_off * scroll.w);
|
|
|
+
|
|
|
+ /* draw scrollbar */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_scrollbar(out, *state, style, &scroll, &cursor);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+ return scroll_offset;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * FILTER
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_API int nk_filter_default(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{(void)unicode;NK_UNUSED(box);return nk_true;}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_ascii(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if (unicode > 128) return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_float(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if ((unicode < '0' || unicode > '9') && unicode != '.' && unicode != '-')
|
|
|
+ return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_decimal(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if ((unicode < '0' || unicode > '9') && unicode != '-')
|
|
|
+ return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_hex(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if ((unicode < '0' || unicode > '9') &&
|
|
|
+ (unicode < 'a' || unicode > 'f') &&
|
|
|
+ (unicode < 'A' || unicode > 'F'))
|
|
|
+ return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_oct(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if (unicode < '0' || unicode > '7')
|
|
|
+ return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_filter_binary(const struct nk_text_edit *box, nk_rune unicode)
|
|
|
+{
|
|
|
+ NK_UNUSED(box);
|
|
|
+ if (unicode != '0' && unicode != '1')
|
|
|
+ return nk_false;
|
|
|
+ else return nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * EDIT
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN 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_ASSERT(out);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ if (!text || !byte_len || !out || !style) return;
|
|
|
+
|
|
|
+ {int glyph_len = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ int text_len = 0;
|
|
|
+ float line_width = 0;
|
|
|
+ float glyph_width;
|
|
|
+ const char *line = text;
|
|
|
+ float line_offset = 0;
|
|
|
+ int line_count = 0;
|
|
|
+
|
|
|
+ struct nk_text txt;
|
|
|
+ txt.padding = nk_vec2(0,0);
|
|
|
+ txt.background = background;
|
|
|
+ txt.text = foreground;
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(text+text_len, &unicode, byte_len-text_len);
|
|
|
+ if (!glyph_len) return;
|
|
|
+ while ((text_len < byte_len) && glyph_len)
|
|
|
+ {
|
|
|
+ if (unicode == '\n') {
|
|
|
+ /* new line sepeator so draw previous line */
|
|
|
+ struct nk_rect label;
|
|
|
+ label.y = pos_y + line_offset;
|
|
|
+ label.h = row_height;
|
|
|
+ label.w = line_width;
|
|
|
+ label.x = pos_x;
|
|
|
+ if (!line_count)
|
|
|
+ label.x += x_offset;
|
|
|
+
|
|
|
+ if (is_selected) /* selection needs to draw different background color */
|
|
|
+ nk_fill_rect(out, label, 0, background);
|
|
|
+ nk_widget_text(out, label, line, (int)((text + text_len) - line),
|
|
|
+ &txt, NK_TEXT_CENTERED, font);
|
|
|
+
|
|
|
+ text_len++;
|
|
|
+ line_count++;
|
|
|
+ line_width = 0;
|
|
|
+ line = text + text_len;
|
|
|
+ line_offset += row_height;
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, (int)(byte_len-text_len));
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (unicode == '\r') {
|
|
|
+ text_len++;
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, byte_len-text_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ glyph_width = font->width(font->userdata, font->height, text+text_len, glyph_len);
|
|
|
+ line_width += (float)glyph_width;
|
|
|
+ text_len += glyph_len;
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, byte_len-text_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (line_width > 0) {
|
|
|
+ /* draw last line */
|
|
|
+ struct nk_rect label;
|
|
|
+ label.y = pos_y + line_offset;
|
|
|
+ label.h = row_height;
|
|
|
+ label.w = line_width;
|
|
|
+ label.x = pos_x;
|
|
|
+ if (!line_count)
|
|
|
+ label.x += x_offset;
|
|
|
+
|
|
|
+ if (is_selected)
|
|
|
+ nk_fill_rect(out, label, 0, background);
|
|
|
+ nk_widget_text(out, label, line, (int)((text + text_len) - line),
|
|
|
+ &txt, NK_TEXT_LEFT, font);
|
|
|
+ }}
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_rect area;
|
|
|
+ nk_flags ret = 0;
|
|
|
+ float row_height;
|
|
|
+ char prev_state = 0;
|
|
|
+ char is_hovered = 0;
|
|
|
+ char select_all = 0;
|
|
|
+ char cursor_follow = 0;
|
|
|
+ struct nk_rect old_clip;
|
|
|
+ struct nk_rect clip;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ if (!state || !out || !style)
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ /* visible text area calculation */
|
|
|
+ area.x = bounds.x + style->padding.x + style->border;
|
|
|
+ area.y = bounds.y + style->padding.y + style->border;
|
|
|
+ area.w = bounds.w - (2.0f * style->padding.x + 2 * style->border);
|
|
|
+ area.h = bounds.h - (2.0f * style->padding.y + 2 * style->border);
|
|
|
+ if (flags & NK_EDIT_MULTILINE)
|
|
|
+ area.w = NK_MAX(0, area.w - style->scrollbar_size.x);
|
|
|
+ row_height = (flags & NK_EDIT_MULTILINE)? font->height + style->row_padding: area.h;
|
|
|
+
|
|
|
+ /* calculate clipping rectangle */
|
|
|
+ old_clip = out->clip;
|
|
|
+ nk_unify(&clip, &old_clip, area.x, area.y, area.x + area.w, area.y + area.h);
|
|
|
+
|
|
|
+ /* update edit state */
|
|
|
+ prev_state = (char)edit->active;
|
|
|
+ is_hovered = (char)nk_input_is_mouse_hovering_rect(in, bounds);
|
|
|
+ if (in && in->mouse.buttons[NK_BUTTON_LEFT].clicked && in->mouse.buttons[NK_BUTTON_LEFT].down) {
|
|
|
+ edit->active = NK_INBOX(in->mouse.pos.x, in->mouse.pos.y,
|
|
|
+ bounds.x, bounds.y, bounds.w, bounds.h);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* (de)activate text editor */
|
|
|
+ if (!prev_state && edit->active) {
|
|
|
+ const enum nk_text_edit_type type = (flags & NK_EDIT_MULTILINE) ?
|
|
|
+ NK_TEXT_EDIT_MULTI_LINE: NK_TEXT_EDIT_SINGLE_LINE;
|
|
|
+ nk_textedit_clear_state(edit, type, filter);
|
|
|
+ if (flags & NK_EDIT_ALWAYS_INSERT_MODE)
|
|
|
+ edit->mode = NK_TEXT_EDIT_MODE_INSERT;
|
|
|
+ if (flags & NK_EDIT_AUTO_SELECT)
|
|
|
+ select_all = nk_true;
|
|
|
+ if (flags & NK_EDIT_GOTO_END_ON_ACTIVATE) {
|
|
|
+ edit->cursor = edit->string.len;
|
|
|
+ in = 0;
|
|
|
+ }
|
|
|
+ } else if (!edit->active) edit->mode = NK_TEXT_EDIT_MODE_VIEW;
|
|
|
+ if (flags & NK_EDIT_READ_ONLY)
|
|
|
+ edit->mode = NK_TEXT_EDIT_MODE_VIEW;
|
|
|
+
|
|
|
+ ret = (edit->active) ? NK_EDIT_ACTIVE: NK_EDIT_INACTIVE;
|
|
|
+ if (prev_state != edit->active)
|
|
|
+ ret |= (edit->active) ? NK_EDIT_ACTIVATED: NK_EDIT_DEACTIVATED;
|
|
|
+
|
|
|
+ /* handle user input */
|
|
|
+ if (edit->active && in)
|
|
|
+ {
|
|
|
+ int shift_mod = in->keyboard.keys[NK_KEY_SHIFT].down;
|
|
|
+ const float mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x;
|
|
|
+ const float mouse_y = (in->mouse.pos.y - area.y) + edit->scrollbar.y;
|
|
|
+
|
|
|
+ /* mouse click handler */
|
|
|
+ is_hovered = (char)nk_input_is_mouse_hovering_rect(in, area);
|
|
|
+ if (select_all) {
|
|
|
+ nk_textedit_select_all(edit);
|
|
|
+ } else if (is_hovered && in->mouse.buttons[NK_BUTTON_LEFT].down &&
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked) {
|
|
|
+ nk_textedit_click(edit, mouse_x, mouse_y, font, row_height);
|
|
|
+ } else if (is_hovered && in->mouse.buttons[NK_BUTTON_LEFT].down &&
|
|
|
+ (in->mouse.delta.x != 0.0f || in->mouse.delta.y != 0.0f)) {
|
|
|
+ nk_textedit_drag(edit, mouse_x, mouse_y, font, row_height);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ } else if (is_hovered && in->mouse.buttons[NK_BUTTON_RIGHT].clicked &&
|
|
|
+ in->mouse.buttons[NK_BUTTON_RIGHT].down) {
|
|
|
+ nk_textedit_key(edit, NK_KEY_TEXT_WORD_LEFT, nk_false, font, row_height);
|
|
|
+ nk_textedit_key(edit, NK_KEY_TEXT_WORD_RIGHT, nk_true, font, row_height);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ }
|
|
|
+
|
|
|
+ {int i; /* keyboard input */
|
|
|
+ int old_mode = edit->mode;
|
|
|
+ for (i = 0; i < NK_KEY_MAX; ++i) {
|
|
|
+ if (i == NK_KEY_ENTER || i == NK_KEY_TAB) continue; /* special case */
|
|
|
+ if (nk_input_is_key_pressed(in, (enum nk_keys)i)) {
|
|
|
+ nk_textedit_key(edit, (enum nk_keys)i, shift_mod, font, row_height);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (old_mode != edit->mode) {
|
|
|
+ in->keyboard.text_len = 0;
|
|
|
+ }}
|
|
|
+
|
|
|
+ /* text input */
|
|
|
+ edit->filter = filter;
|
|
|
+ if (in->keyboard.text_len) {
|
|
|
+ nk_textedit_text(edit, in->keyboard.text, in->keyboard.text_len);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ in->keyboard.text_len = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* enter key handler */
|
|
|
+ if (nk_input_is_key_pressed(in, NK_KEY_ENTER)) {
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ if (flags & NK_EDIT_CTRL_ENTER_NEWLINE && shift_mod)
|
|
|
+ nk_textedit_text(edit, "\n", 1);
|
|
|
+ else if (flags & NK_EDIT_SIG_ENTER)
|
|
|
+ ret |= NK_EDIT_COMMITED;
|
|
|
+ else nk_textedit_text(edit, "\n", 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* cut & copy handler */
|
|
|
+ {int copy= nk_input_is_key_pressed(in, NK_KEY_COPY);
|
|
|
+ int cut = nk_input_is_key_pressed(in, NK_KEY_CUT);
|
|
|
+ if ((copy || cut) && (flags & NK_EDIT_CLIPBOARD))
|
|
|
+ {
|
|
|
+ int glyph_len;
|
|
|
+ nk_rune unicode;
|
|
|
+ const char *text;
|
|
|
+ int b = edit->select_start;
|
|
|
+ int e = edit->select_end;
|
|
|
+
|
|
|
+ int begin = NK_MIN(b, e);
|
|
|
+ int end = NK_MAX(b, e);
|
|
|
+ text = nk_str_at_const(&edit->string, begin, &unicode, &glyph_len);
|
|
|
+ if (edit->clip.copy)
|
|
|
+ edit->clip.copy(edit->clip.userdata, text, end - begin);
|
|
|
+ if (cut && !(flags & NK_EDIT_READ_ONLY)){
|
|
|
+ nk_textedit_cut(edit);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ }
|
|
|
+ }}
|
|
|
+
|
|
|
+ /* paste handler */
|
|
|
+ {int paste = nk_input_is_key_pressed(in, NK_KEY_PASTE);
|
|
|
+ if (paste && (flags & NK_EDIT_CLIPBOARD) && edit->clip.paste) {
|
|
|
+ edit->clip.paste(edit->clip.userdata, edit);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ }}
|
|
|
+
|
|
|
+ /* tab handler */
|
|
|
+ {int tab = nk_input_is_key_pressed(in, NK_KEY_TAB);
|
|
|
+ if (tab && (flags & NK_EDIT_ALLOW_TAB)) {
|
|
|
+ nk_textedit_text(edit, " ", 4);
|
|
|
+ cursor_follow = nk_true;
|
|
|
+ }}
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set widget state */
|
|
|
+ if (edit->active)
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ else nk_widget_state_reset(state);
|
|
|
+
|
|
|
+ if (is_hovered)
|
|
|
+ *state |= NK_WIDGET_STATE_HOVERED;
|
|
|
+
|
|
|
+ /* DRAW EDIT */
|
|
|
+ {const char *text = nk_str_get_const(&edit->string);
|
|
|
+ int len = nk_str_len_char(&edit->string);
|
|
|
+
|
|
|
+ {/* select background colors/images */
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ if (*state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ background = &style->active;
|
|
|
+ else if (*state & NK_WIDGET_STATE_HOVER)
|
|
|
+ background = &style->hover;
|
|
|
+ else background = &style->normal;
|
|
|
+
|
|
|
+ /* draw background frame */
|
|
|
+ if (background->type == NK_STYLE_ITEM_COLOR) {
|
|
|
+ nk_stroke_rect(out, bounds, style->rounding, style->border, style->border_color);
|
|
|
+ nk_fill_rect(out, bounds, style->rounding, background->data.color);
|
|
|
+ } else nk_draw_image(out, bounds, &background->data.image, nk_white);}
|
|
|
+
|
|
|
+ area.w = NK_MAX(0, area.w - style->cursor_size);
|
|
|
+ if (edit->active)
|
|
|
+ {
|
|
|
+ int total_lines = 1;
|
|
|
+ struct nk_vec2 text_size = nk_vec2(0,0);
|
|
|
+
|
|
|
+ /* text pointer positions */
|
|
|
+ const char *cursor_ptr = 0;
|
|
|
+ const char *select_begin_ptr = 0;
|
|
|
+ const char *select_end_ptr = 0;
|
|
|
+
|
|
|
+ /* 2D pixel positions */
|
|
|
+ struct nk_vec2 cursor_pos = nk_vec2(0,0);
|
|
|
+ struct nk_vec2 selection_offset_start = nk_vec2(0,0);
|
|
|
+ struct nk_vec2 selection_offset_end = nk_vec2(0,0);
|
|
|
+
|
|
|
+ int selection_begin = NK_MIN(edit->select_start, edit->select_end);
|
|
|
+ int selection_end = NK_MAX(edit->select_start, edit->select_end);
|
|
|
+
|
|
|
+ /* calculate total line count + total space + cursor/selection position */
|
|
|
+ float line_width = 0.0f;
|
|
|
+ if (text && len)
|
|
|
+ {
|
|
|
+ /* utf8 encoding */
|
|
|
+ float glyph_width;
|
|
|
+ int glyph_len = 0;
|
|
|
+ nk_rune unicode = 0;
|
|
|
+ int text_len = 0;
|
|
|
+ int glyphs = 0;
|
|
|
+ int row_begin = 0;
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(text, &unicode, len);
|
|
|
+ glyph_width = font->width(font->userdata, font->height, text, glyph_len);
|
|
|
+ line_width = 0;
|
|
|
+
|
|
|
+ /* iterate all lines */
|
|
|
+ while ((text_len < len) && glyph_len)
|
|
|
+ {
|
|
|
+ /* set cursor 2D position and line */
|
|
|
+ if (!cursor_ptr && glyphs == edit->cursor)
|
|
|
+ {
|
|
|
+ int glyph_offset;
|
|
|
+ struct nk_vec2 out_offset;
|
|
|
+ struct nk_vec2 row_size;
|
|
|
+ const char *remaining;
|
|
|
+
|
|
|
+ /* calculate 2d position */
|
|
|
+ cursor_pos.y = (float)(total_lines-1) * row_height;
|
|
|
+ row_size = nk_text_calculate_text_bounds(font, text+row_begin,
|
|
|
+ text_len-row_begin, row_height, &remaining,
|
|
|
+ &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE);
|
|
|
+ cursor_pos.x = row_size.x;
|
|
|
+ cursor_ptr = text + text_len;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set start selection 2D position and line */
|
|
|
+ if (!select_begin_ptr && edit->select_start != edit->select_end &&
|
|
|
+ glyphs == selection_begin)
|
|
|
+ {
|
|
|
+ int glyph_offset;
|
|
|
+ struct nk_vec2 out_offset;
|
|
|
+ struct nk_vec2 row_size;
|
|
|
+ const char *remaining;
|
|
|
+
|
|
|
+ /* calculate 2d position */
|
|
|
+ selection_offset_start.y = (float)(NK_MAX(total_lines-1,0)) * row_height;
|
|
|
+ row_size = nk_text_calculate_text_bounds(font, text+row_begin,
|
|
|
+ text_len-row_begin, row_height, &remaining,
|
|
|
+ &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE);
|
|
|
+ selection_offset_start.x = row_size.x;
|
|
|
+ select_begin_ptr = text + text_len;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set end selection 2D position and line */
|
|
|
+ if (!select_end_ptr && edit->select_start != edit->select_end &&
|
|
|
+ glyphs == selection_end)
|
|
|
+ {
|
|
|
+ int glyph_offset;
|
|
|
+ struct nk_vec2 out_offset;
|
|
|
+ struct nk_vec2 row_size;
|
|
|
+ const char *remaining;
|
|
|
+
|
|
|
+ /* calculate 2d position */
|
|
|
+ selection_offset_end.y = (float)(total_lines-1) * row_height;
|
|
|
+ row_size = nk_text_calculate_text_bounds(font, text+row_begin,
|
|
|
+ text_len-row_begin, row_height, &remaining,
|
|
|
+ &out_offset, &glyph_offset, NK_STOP_ON_NEW_LINE);
|
|
|
+ selection_offset_end.x = row_size.x;
|
|
|
+ select_end_ptr = text + text_len;
|
|
|
+ }
|
|
|
+ if (unicode == '\n') {
|
|
|
+ text_size.x = NK_MAX(text_size.x, line_width);
|
|
|
+ total_lines++;
|
|
|
+ line_width = 0;
|
|
|
+ text_len++;
|
|
|
+ glyphs++;
|
|
|
+ row_begin = text_len;
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len);
|
|
|
+ glyph_width = font->width(font->userdata, font->height, text+text_len, glyph_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ glyphs++;
|
|
|
+ text_len += glyph_len;
|
|
|
+ line_width += (float)glyph_width;
|
|
|
+
|
|
|
+ glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len);
|
|
|
+ glyph_width = font->width(font->userdata, font->height,
|
|
|
+ text+text_len, glyph_len);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ text_size.y = (float)total_lines * row_height;
|
|
|
+
|
|
|
+ /* handle case when cursor is at end of text buffer */
|
|
|
+ if (!cursor_ptr && edit->cursor == edit->string.len) {
|
|
|
+ cursor_pos.x = line_width;
|
|
|
+ cursor_pos.y = text_size.y - row_height;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ {
|
|
|
+ /* scrollbar */
|
|
|
+ if (cursor_follow)
|
|
|
+ {
|
|
|
+ /* update scrollbar to follow cursor */
|
|
|
+ if (!(flags & NK_EDIT_NO_HORIZONTAL_SCROLL)) {
|
|
|
+ /* horizontal scroll */
|
|
|
+ const float scroll_increment = area.w * 0.25f;
|
|
|
+ if (cursor_pos.x < edit->scrollbar.x)
|
|
|
+ edit->scrollbar.x = (float)(int)NK_MAX(0.0f, cursor_pos.x - scroll_increment);
|
|
|
+ if (cursor_pos.x >= edit->scrollbar.x + area.w)
|
|
|
+ edit->scrollbar.x = (float)(int)NK_MAX(0.0f, cursor_pos.x);
|
|
|
+ } else edit->scrollbar.x = 0;
|
|
|
+
|
|
|
+ if (flags & NK_EDIT_MULTILINE) {
|
|
|
+ /* vertical scroll */
|
|
|
+ if (cursor_pos.y < edit->scrollbar.y)
|
|
|
+ edit->scrollbar.y = NK_MAX(0.0f, cursor_pos.y - row_height);
|
|
|
+ if (cursor_pos.y >= edit->scrollbar.y + area.h)
|
|
|
+ edit->scrollbar.y = edit->scrollbar.y + row_height;
|
|
|
+ } else edit->scrollbar.y = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* scrollbar widget */
|
|
|
+ if (flags & NK_EDIT_MULTILINE)
|
|
|
+ {
|
|
|
+ nk_flags ws;
|
|
|
+ struct nk_rect scroll;
|
|
|
+ float scroll_target;
|
|
|
+ float scroll_offset;
|
|
|
+ float scroll_step;
|
|
|
+ float scroll_inc;
|
|
|
+
|
|
|
+ scroll = area;
|
|
|
+ scroll.x = (bounds.x + bounds.w - style->border) - style->scrollbar_size.x;
|
|
|
+ scroll.w = style->scrollbar_size.x;
|
|
|
+
|
|
|
+ scroll_offset = edit->scrollbar.y;
|
|
|
+ scroll_step = scroll.h * 0.10f;
|
|
|
+ scroll_inc = scroll.h * 0.01f;
|
|
|
+ scroll_target = text_size.y;
|
|
|
+ edit->scrollbar.y = nk_do_scrollbarv(&ws, out, scroll, 0,
|
|
|
+ scroll_offset, scroll_target, scroll_step, scroll_inc,
|
|
|
+ &style->scrollbar, in, font);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw text */
|
|
|
+ {struct nk_color background_color;
|
|
|
+ struct nk_color text_color;
|
|
|
+ struct nk_color sel_background_color;
|
|
|
+ struct nk_color sel_text_color;
|
|
|
+ struct nk_color cursor_color;
|
|
|
+ struct nk_color cursor_text_color;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ nk_push_scissor(out, clip);
|
|
|
+
|
|
|
+ /* select correct colors to draw */
|
|
|
+ if (*state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ text_color = style->text_active;
|
|
|
+ sel_text_color = style->selected_text_hover;
|
|
|
+ sel_background_color = style->selected_hover;
|
|
|
+ cursor_color = style->cursor_hover;
|
|
|
+ cursor_text_color = style->cursor_text_hover;
|
|
|
+ } else if (*state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ text_color = style->text_hover;
|
|
|
+ sel_text_color = style->selected_text_hover;
|
|
|
+ sel_background_color = style->selected_hover;
|
|
|
+ cursor_text_color = style->cursor_text_hover;
|
|
|
+ cursor_color = style->cursor_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ text_color = style->text_normal;
|
|
|
+ sel_text_color = style->selected_text_normal;
|
|
|
+ sel_background_color = style->selected_normal;
|
|
|
+ cursor_color = style->cursor_normal;
|
|
|
+ cursor_text_color = style->cursor_text_normal;
|
|
|
+ }
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE)
|
|
|
+ background_color = nk_rgba(0,0,0,0);
|
|
|
+ else background_color = background->data.color;
|
|
|
+
|
|
|
+
|
|
|
+ if (edit->select_start == edit->select_end) {
|
|
|
+ /* no selection so just draw the complete text */
|
|
|
+ const char *begin = nk_str_get_const(&edit->string);
|
|
|
+ int l = nk_str_len_char(&edit->string);
|
|
|
+ nk_edit_draw_text(out, style, area.x - edit->scrollbar.x,
|
|
|
+ area.y - edit->scrollbar.y, 0, begin, l, row_height, font,
|
|
|
+ background_color, text_color, nk_false);
|
|
|
+ } else {
|
|
|
+ /* edit has selection so draw 1-3 text chunks */
|
|
|
+ if (edit->select_start != edit->select_end && selection_begin > 0){
|
|
|
+ /* draw unselected text before selection */
|
|
|
+ const char *begin = nk_str_get_const(&edit->string);
|
|
|
+ NK_ASSERT(select_begin_ptr);
|
|
|
+ nk_edit_draw_text(out, style, area.x - edit->scrollbar.x,
|
|
|
+ area.y - edit->scrollbar.y, 0, begin, (int)(select_begin_ptr - begin),
|
|
|
+ row_height, font, background_color, text_color, nk_false);
|
|
|
+ }
|
|
|
+ if (edit->select_start != edit->select_end) {
|
|
|
+ /* draw selected text */
|
|
|
+ NK_ASSERT(select_begin_ptr);
|
|
|
+ if (!select_end_ptr) {
|
|
|
+ const char *begin = nk_str_get_const(&edit->string);
|
|
|
+ select_end_ptr = begin + nk_str_len_char(&edit->string);
|
|
|
+ }
|
|
|
+ nk_edit_draw_text(out, style,
|
|
|
+ area.x - edit->scrollbar.x,
|
|
|
+ area.y + selection_offset_start.y - edit->scrollbar.y,
|
|
|
+ selection_offset_start.x,
|
|
|
+ select_begin_ptr, (int)(select_end_ptr - select_begin_ptr),
|
|
|
+ row_height, font, sel_background_color, sel_text_color, nk_true);
|
|
|
+ }
|
|
|
+ if ((edit->select_start != edit->select_end &&
|
|
|
+ selection_end < edit->string.len))
|
|
|
+ {
|
|
|
+ /* draw unselected text after selected text */
|
|
|
+ const char *begin = select_end_ptr;
|
|
|
+ const char *end = nk_str_get_const(&edit->string) +
|
|
|
+ nk_str_len_char(&edit->string);
|
|
|
+ NK_ASSERT(select_end_ptr);
|
|
|
+ nk_edit_draw_text(out, style,
|
|
|
+ area.x - edit->scrollbar.x,
|
|
|
+ area.y + selection_offset_end.y - edit->scrollbar.y,
|
|
|
+ selection_offset_end.x,
|
|
|
+ begin, (int)(end - begin), row_height, font,
|
|
|
+ background_color, text_color, nk_true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* cursor */
|
|
|
+ if (edit->select_start == edit->select_end)
|
|
|
+ {
|
|
|
+ if (edit->cursor >= nk_str_len(&edit->string) ||
|
|
|
+ (cursor_ptr && *cursor_ptr == '\n')) {
|
|
|
+ /* draw cursor at end of line */
|
|
|
+ struct nk_rect cursor;
|
|
|
+ cursor.w = style->cursor_size;
|
|
|
+ cursor.h = font->height;
|
|
|
+ cursor.x = area.x + cursor_pos.x - edit->scrollbar.x;
|
|
|
+ cursor.y = area.y + cursor_pos.y + row_height/2.0f - cursor.h/2.0f;
|
|
|
+ cursor.y -= edit->scrollbar.y;
|
|
|
+ nk_fill_rect(out, cursor, 0, cursor_color);
|
|
|
+ } else {
|
|
|
+ /* draw cursor inside text */
|
|
|
+ int glyph_len;
|
|
|
+ struct nk_rect label;
|
|
|
+ struct nk_text txt;
|
|
|
+
|
|
|
+ nk_rune unicode;
|
|
|
+ NK_ASSERT(cursor_ptr);
|
|
|
+ glyph_len = nk_utf_decode(cursor_ptr, &unicode, 4);
|
|
|
+
|
|
|
+ label.x = area.x + cursor_pos.x - edit->scrollbar.x;
|
|
|
+ label.y = area.y + cursor_pos.y - edit->scrollbar.y;
|
|
|
+ label.w = font->width(font->userdata, font->height, cursor_ptr, glyph_len);
|
|
|
+ label.h = row_height;
|
|
|
+
|
|
|
+ txt.padding = nk_vec2(0,0);
|
|
|
+ txt.background = cursor_color;;
|
|
|
+ txt.text = cursor_text_color;
|
|
|
+ nk_fill_rect(out, label, 0, cursor_color);
|
|
|
+ nk_widget_text(out, label, cursor_ptr, glyph_len, &txt, NK_TEXT_LEFT, font);
|
|
|
+ }
|
|
|
+ }}
|
|
|
+ } else {
|
|
|
+ /* not active so just draw text */
|
|
|
+ int l = nk_str_len_char(&edit->string);
|
|
|
+ const char *begin = nk_str_get_const(&edit->string);
|
|
|
+
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_color background_color;
|
|
|
+ struct nk_color text_color;
|
|
|
+ nk_push_scissor(out, clip);
|
|
|
+ if (*state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ text_color = style->text_active;
|
|
|
+ } else if (*state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ text_color = style->text_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ text_color = style->text_normal;
|
|
|
+ }
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE)
|
|
|
+ background_color = nk_rgba(0,0,0,0);
|
|
|
+ else background_color = background->data.color;
|
|
|
+ nk_edit_draw_text(out, style, area.x - edit->scrollbar.x,
|
|
|
+ area.y - edit->scrollbar.y, 0, begin, l, row_height, font,
|
|
|
+ background_color, text_color, nk_false);
|
|
|
+ }
|
|
|
+ nk_push_scissor(out, old_clip);}
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * PROPERTY
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+enum nk_property_status {
|
|
|
+ NK_PROPERTY_DEFAULT,
|
|
|
+ NK_PROPERTY_EDIT,
|
|
|
+ NK_PROPERTY_DRAG
|
|
|
+};
|
|
|
+enum nk_property_filter {
|
|
|
+ NK_FILTER_INT,
|
|
|
+ NK_FILTER_FLOAT
|
|
|
+};
|
|
|
+enum nk_property_kind {
|
|
|
+ NK_PROPERTY_INT,
|
|
|
+ NK_PROPERTY_FLOAT,
|
|
|
+ NK_PROPERTY_DOUBLE
|
|
|
+};
|
|
|
+union nk_property {
|
|
|
+ int i;
|
|
|
+ float f;
|
|
|
+ double d;
|
|
|
+};
|
|
|
+struct nk_property_variant {
|
|
|
+ enum nk_property_kind kind;
|
|
|
+ union nk_property value;
|
|
|
+ union nk_property min_value;
|
|
|
+ union nk_property max_value;
|
|
|
+ union nk_property step;
|
|
|
+};
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ int left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ int left_mouse_click_in_cursor = in &&
|
|
|
+ nk_input_has_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, drag, nk_true);
|
|
|
+
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (nk_input_is_mouse_hovering_rect(in, drag))
|
|
|
+ *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+
|
|
|
+ if (left_mouse_down && left_mouse_click_in_cursor) {
|
|
|
+ float delta, pixels;
|
|
|
+ pixels = in->mouse.delta.x;
|
|
|
+ delta = pixels * inc_per_pixel;
|
|
|
+ switch (variant->kind) {
|
|
|
+ default: break;
|
|
|
+ case NK_PROPERTY_INT:
|
|
|
+ variant->value.i = variant->value.i + (int)delta;
|
|
|
+ variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i, variant->max_value.i);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_FLOAT:
|
|
|
+ variant->value.f = variant->value.f + (float)delta;
|
|
|
+ variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f, variant->max_value.f);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_DOUBLE:
|
|
|
+ variant->value.d = variant->value.d + (double)delta;
|
|
|
+ variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d, variant->max_value.d);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ }
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, drag))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, drag))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ if (in && *state == NK_PROPERTY_DEFAULT) {
|
|
|
+ if (nk_button_behavior(ws, edit, in, NK_BUTTON_DEFAULT))
|
|
|
+ *state = NK_PROPERTY_EDIT;
|
|
|
+ else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, label, nk_true))
|
|
|
+ *state = NK_PROPERTY_DRAG;
|
|
|
+ else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, empty, nk_true))
|
|
|
+ *state = NK_PROPERTY_DRAG;
|
|
|
+ }
|
|
|
+ if (*state == NK_PROPERTY_DRAG) {
|
|
|
+ nk_drag_behavior(ws, in, property, variant, inc_per_pixel);
|
|
|
+ if (!(*ws & NK_WIDGET_STATE_ACTIVED)) *state = NK_PROPERTY_DEFAULT;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_text text;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ /* select correct background and text color */
|
|
|
+ if (state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->active;
|
|
|
+ text.text = style->label_active;
|
|
|
+ } else if (state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->hover;
|
|
|
+ text.text = style->label_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->normal;
|
|
|
+ text.text = style->label_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw background */
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
|
|
+ nk_stroke_rect(out, *bounds, style->rounding, style->border, background->data.color);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw label */
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ nk_widget_text(out, *label, name, len, &text, NK_TEXT_CENTERED, font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ const nk_plugin_filter filters[] = {
|
|
|
+ nk_filter_decimal,
|
|
|
+ nk_filter_float
|
|
|
+ };
|
|
|
+ int active, old;
|
|
|
+ int num_len, name_len;
|
|
|
+ char string[NK_MAX_NUMBER_BUFFER];
|
|
|
+ float size;
|
|
|
+
|
|
|
+ char *dst = 0;
|
|
|
+ int *length;
|
|
|
+
|
|
|
+ struct nk_rect left;
|
|
|
+ struct nk_rect right;
|
|
|
+ struct nk_rect label;
|
|
|
+ struct nk_rect edit;
|
|
|
+ struct nk_rect empty;
|
|
|
+
|
|
|
+ /* left decrement button */
|
|
|
+ left.h = font->height/2;
|
|
|
+ left.w = left.h;
|
|
|
+ left.x = property.x + style->border + style->padding.x;
|
|
|
+ left.y = property.y + style->border + property.h/2.0f - left.h/2;
|
|
|
+
|
|
|
+ /* text label */
|
|
|
+ name_len = nk_strlen(name);
|
|
|
+ size = font->width(font->userdata, font->height, name, name_len);
|
|
|
+ label.x = left.x + left.w + style->padding.x;
|
|
|
+ label.w = (float)size + 2 * style->padding.x;
|
|
|
+ label.y = property.y + style->border + style->padding.y;
|
|
|
+ label.h = property.h - (2 * style->border + 2 * style->padding.y);
|
|
|
+
|
|
|
+ /* right increment button */
|
|
|
+ right.y = left.y;
|
|
|
+ right.w = left.w;
|
|
|
+ right.h = left.h;
|
|
|
+ right.x = property.x + property.w - (right.w + style->padding.x);
|
|
|
+
|
|
|
+ /* edit */
|
|
|
+ if (*state == NK_PROPERTY_EDIT) {
|
|
|
+ size = font->width(font->userdata, font->height, buffer, *len);
|
|
|
+ size += style->edit.cursor_size;
|
|
|
+ length = len;
|
|
|
+ dst = buffer;
|
|
|
+ } else {
|
|
|
+ switch (variant->kind) {
|
|
|
+ default: break;
|
|
|
+ case NK_PROPERTY_INT:
|
|
|
+ nk_itoa(string, variant->value.i);
|
|
|
+ num_len = nk_strlen(string);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_FLOAT:
|
|
|
+ nk_dtoa(string, (double)variant->value.f);
|
|
|
+ num_len = nk_string_float_limit(string, NK_MAX_FLOAT_PRECISION);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_DOUBLE:
|
|
|
+ nk_dtoa(string, variant->value.d);
|
|
|
+ num_len = nk_string_float_limit(string, NK_MAX_FLOAT_PRECISION);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ size = font->width(font->userdata, font->height, string, num_len);
|
|
|
+ dst = string;
|
|
|
+ length = &num_len;
|
|
|
+ }
|
|
|
+
|
|
|
+ edit.w = (float)size + 2 * style->padding.x;
|
|
|
+ edit.w = NK_MIN(edit.w, right.x - (label.x + label.w));
|
|
|
+ edit.x = right.x - (edit.w + style->padding.x);
|
|
|
+ edit.y = property.y + style->border;
|
|
|
+ edit.h = property.h - (2 * style->border);
|
|
|
+
|
|
|
+ /* empty left space activator */
|
|
|
+ empty.w = edit.x - (label.x + label.w);
|
|
|
+ empty.x = label.x + label.w;
|
|
|
+ empty.y = property.y;
|
|
|
+ empty.h = property.h;
|
|
|
+
|
|
|
+ /* update property */
|
|
|
+ old = (*state == NK_PROPERTY_EDIT);
|
|
|
+ nk_property_behavior(ws, in, property, label, edit, empty, state, variant, inc_per_pixel);
|
|
|
+
|
|
|
+ /* draw property */
|
|
|
+ if (style->draw_begin) style->draw_begin(out, style->userdata);
|
|
|
+ nk_draw_property(out, style, &property, &label, *ws, name, name_len, font);
|
|
|
+ if (style->draw_end) style->draw_end(out, style->userdata);
|
|
|
+
|
|
|
+ /* execute right button */
|
|
|
+ if (nk_do_button_symbol(ws, out, left, style->sym_left, behavior, &style->dec_button, in, font)) {
|
|
|
+ switch (variant->kind) {
|
|
|
+ default: break;
|
|
|
+ case NK_PROPERTY_INT:
|
|
|
+ variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i - variant->step.i, variant->max_value.i); break;
|
|
|
+ case NK_PROPERTY_FLOAT:
|
|
|
+ variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f - variant->step.f, variant->max_value.f); break;
|
|
|
+ case NK_PROPERTY_DOUBLE:
|
|
|
+ variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d - variant->step.d, variant->max_value.d); break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* execute left button */
|
|
|
+ if (nk_do_button_symbol(ws, out, right, style->sym_right, behavior, &style->inc_button, in, font)) {
|
|
|
+ switch (variant->kind) {
|
|
|
+ default: break;
|
|
|
+ case NK_PROPERTY_INT:
|
|
|
+ variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i + variant->step.i, variant->max_value.i); break;
|
|
|
+ case NK_PROPERTY_FLOAT:
|
|
|
+ variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f + variant->step.f, variant->max_value.f); break;
|
|
|
+ case NK_PROPERTY_DOUBLE:
|
|
|
+ variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d + variant->step.d, variant->max_value.d); break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (old != NK_PROPERTY_EDIT && (*state == NK_PROPERTY_EDIT)) {
|
|
|
+ /* property has been activated so setup buffer */
|
|
|
+ NK_MEMCPY(buffer, dst, (nk_size)*length);
|
|
|
+ *cursor = nk_utf_len(buffer, *length);
|
|
|
+ *len = *length;
|
|
|
+ length = len;
|
|
|
+ dst = buffer;
|
|
|
+ active = 0;
|
|
|
+ } else active = (*state == NK_PROPERTY_EDIT);
|
|
|
+
|
|
|
+ /* execute and run text edit field */
|
|
|
+ nk_textedit_clear_state(text_edit, NK_TEXT_EDIT_SINGLE_LINE, filters[filter]);
|
|
|
+ text_edit->active = (unsigned char)active;
|
|
|
+ text_edit->string.len = *length;
|
|
|
+ text_edit->cursor = NK_CLAMP(0, *cursor, *length);
|
|
|
+ text_edit->select_start = NK_CLAMP(0,*select_begin, *length);
|
|
|
+ text_edit->select_end = NK_CLAMP(0,*select_end, *length);
|
|
|
+ text_edit->string.buffer.allocated = (nk_size)*length;
|
|
|
+ text_edit->string.buffer.memory.size = NK_MAX_NUMBER_BUFFER;
|
|
|
+ text_edit->string.buffer.memory.ptr = dst;
|
|
|
+ text_edit->string.buffer.size = NK_MAX_NUMBER_BUFFER;
|
|
|
+ text_edit->mode = NK_TEXT_EDIT_MODE_INSERT;
|
|
|
+ nk_do_edit(ws, out, edit, NK_EDIT_FIELD|NK_EDIT_AUTO_SELECT,
|
|
|
+ filters[filter], text_edit, &style->edit, (*state == NK_PROPERTY_EDIT) ? in: 0, font);
|
|
|
+
|
|
|
+ *length = text_edit->string.len;
|
|
|
+ *cursor = text_edit->cursor;
|
|
|
+ *select_begin = text_edit->select_start;
|
|
|
+ *select_end = text_edit->select_end;
|
|
|
+ if (text_edit->active && nk_input_is_key_pressed(in, NK_KEY_ENTER))
|
|
|
+ text_edit->active = nk_false;
|
|
|
+
|
|
|
+ if (active && !text_edit->active) {
|
|
|
+ /* property is now not active so convert edit text to value*/
|
|
|
+ *state = NK_PROPERTY_DEFAULT;
|
|
|
+ buffer[*len] = '\0';
|
|
|
+ switch (variant->kind) {
|
|
|
+ default: break;
|
|
|
+ case NK_PROPERTY_INT:
|
|
|
+ variant->value.i = nk_strtoi(buffer, 0);
|
|
|
+ variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i, variant->max_value.i);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_FLOAT:
|
|
|
+ nk_string_float_limit(buffer, NK_MAX_FLOAT_PRECISION);
|
|
|
+ variant->value.f = nk_strtof(buffer, 0);
|
|
|
+ variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f, variant->max_value.f);
|
|
|
+ break;
|
|
|
+ case NK_PROPERTY_DOUBLE:
|
|
|
+ nk_string_float_limit(buffer, NK_MAX_FLOAT_PRECISION);
|
|
|
+ variant->value.d = nk_strtod(buffer, 0);
|
|
|
+ variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d, variant->max_value.d);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * COLOR PICKER
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN 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_color *color, const struct nk_input *in)
|
|
|
+{
|
|
|
+ float hsva[4];
|
|
|
+ int value_changed = 0;
|
|
|
+ int hsv_changed = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(matrix);
|
|
|
+ NK_ASSERT(hue_bar);
|
|
|
+ NK_ASSERT(color);
|
|
|
+
|
|
|
+ /* color matrix */
|
|
|
+ nk_color_hsva_fv(hsva, *color);
|
|
|
+ if (nk_button_behavior(state, *matrix, in, NK_BUTTON_REPEATER)) {
|
|
|
+ hsva[1] = NK_SATURATE((in->mouse.pos.x - matrix->x) / (matrix->w-1));
|
|
|
+ hsva[2] = 1.0f - NK_SATURATE((in->mouse.pos.y - matrix->y) / (matrix->h-1));
|
|
|
+ value_changed = hsv_changed = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* hue bar */
|
|
|
+ if (nk_button_behavior(state, *hue_bar, in, NK_BUTTON_REPEATER)) {
|
|
|
+ hsva[0] = NK_SATURATE((in->mouse.pos.y - hue_bar->y) / (hue_bar->h-1));
|
|
|
+ value_changed = hsv_changed = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* alpha bar */
|
|
|
+ if (alpha_bar) {
|
|
|
+ if (nk_button_behavior(state, *alpha_bar, in, NK_BUTTON_REPEATER)) {
|
|
|
+ hsva[3] = 1.0f - NK_SATURATE((in->mouse.pos.y - alpha_bar->y) / (alpha_bar->h-1));
|
|
|
+ value_changed = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ nk_widget_state_reset(state);
|
|
|
+ if (hsv_changed) {
|
|
|
+ *color = nk_hsva_fv(hsva);
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ }
|
|
|
+ if (value_changed) {
|
|
|
+ color->a = (nk_byte)(hsva[3] * 255.0f);
|
|
|
+ *state = NK_WIDGET_STATE_ACTIVE;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set color picker widget state */
|
|
|
+ if (nk_input_is_mouse_hovering_rect(in, *bounds))
|
|
|
+ *state = NK_WIDGET_STATE_HOVERED;
|
|
|
+ if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, *bounds))
|
|
|
+ *state |= NK_WIDGET_STATE_ENTERED;
|
|
|
+ else if (nk_input_is_mouse_prev_hovering_rect(in, *bounds))
|
|
|
+ *state |= NK_WIDGET_STATE_LEFT;
|
|
|
+ return value_changed;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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_color color)
|
|
|
+{
|
|
|
+ NK_STORAGE const struct nk_color black = {0,0,0,255};
|
|
|
+ NK_STORAGE const struct nk_color white = {255, 255, 255, 255};
|
|
|
+ NK_STORAGE const struct nk_color black_trans = {0,0,0,0};
|
|
|
+
|
|
|
+ const float crosshair_size = 7.0f;
|
|
|
+ struct nk_color temp;
|
|
|
+ float hsva[4];
|
|
|
+ float line_y;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ NK_ASSERT(o);
|
|
|
+ NK_ASSERT(matrix);
|
|
|
+ NK_ASSERT(hue_bar);
|
|
|
+
|
|
|
+ /* draw hue bar */
|
|
|
+ nk_color_hsv_fv(hsva, color);
|
|
|
+ for (i = 0; i < 6; ++i) {
|
|
|
+ NK_GLOBAL const struct nk_color hue_colors[] = {
|
|
|
+ {255, 0, 0, 255},
|
|
|
+ {255,255,0,255},
|
|
|
+ {0,255,0,255},
|
|
|
+ {0, 255,255,255},
|
|
|
+ {0,0,255,255},
|
|
|
+ {255, 0, 255, 255},
|
|
|
+ {255, 0, 0, 255}
|
|
|
+ };
|
|
|
+ nk_fill_rect_multi_color(o,
|
|
|
+ nk_rect(hue_bar->x, hue_bar->y + (float)i * (hue_bar->h/6.0f) + 0.5f,
|
|
|
+ hue_bar->w, (hue_bar->h/6.0f) + 0.5f), hue_colors[i], hue_colors[i],
|
|
|
+ hue_colors[i+1], hue_colors[i+1]);
|
|
|
+ }
|
|
|
+ line_y = (float)(int)(hue_bar->y + hsva[0] * matrix->h + 0.5f);
|
|
|
+ nk_stroke_line(o, hue_bar->x-1, line_y, hue_bar->x + hue_bar->w + 2,
|
|
|
+ line_y, 1, nk_rgb(255,255,255));
|
|
|
+
|
|
|
+ /* draw alpha bar */
|
|
|
+ if (alpha_bar) {
|
|
|
+ float alpha = NK_SATURATE((float)color.a/255.0f);
|
|
|
+ line_y = (float)(int)(alpha_bar->y + (1.0f - alpha) * matrix->h + 0.5f);
|
|
|
+
|
|
|
+ nk_fill_rect_multi_color(o, *alpha_bar, white, white, black, black);
|
|
|
+ nk_stroke_line(o, alpha_bar->x-1, line_y, alpha_bar->x + alpha_bar->w + 2,
|
|
|
+ line_y, 1, nk_rgb(255,255,255));
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw color matrix */
|
|
|
+ temp = nk_hsv_f(hsva[0], 1.0f, 1.0f);
|
|
|
+ nk_fill_rect_multi_color(o, *matrix, white, temp, temp, white);
|
|
|
+ nk_fill_rect_multi_color(o, *matrix, black_trans, black_trans, black, black);
|
|
|
+
|
|
|
+ /* draw cross-hair */
|
|
|
+ {struct nk_vec2 p; float S = hsva[1]; float V = hsva[2];
|
|
|
+ p.x = (float)(int)(matrix->x + S * matrix->w);
|
|
|
+ p.y = (float)(int)(matrix->y + (1.0f - V) * matrix->h);
|
|
|
+ nk_stroke_line(o, p.x - crosshair_size, p.y, p.x-2, p.y, 1.0f, white);
|
|
|
+ nk_stroke_line(o, p.x + crosshair_size + 1, p.y, p.x+3, p.y, 1.0f, white);
|
|
|
+ nk_stroke_line(o, p.x, p.y + crosshair_size + 1, p.x, p.y+3, 1.0f, white);
|
|
|
+ nk_stroke_line(o, p.x, p.y - crosshair_size, p.x, p.y-2, 1.0f, white);}
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_do_color_picker(nk_flags *state,
|
|
|
+ struct nk_command_buffer *out, struct nk_color *color,
|
|
|
+ enum nk_color_format fmt, struct nk_rect bounds,
|
|
|
+ struct nk_vec2 padding, const struct nk_input *in,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ int ret = 0;
|
|
|
+ struct nk_rect matrix;
|
|
|
+ struct nk_rect hue_bar;
|
|
|
+ struct nk_rect alpha_bar;
|
|
|
+ float bar_w;
|
|
|
+
|
|
|
+ NK_ASSERT(out);
|
|
|
+ NK_ASSERT(color);
|
|
|
+ NK_ASSERT(state);
|
|
|
+ NK_ASSERT(font);
|
|
|
+ if (!out || !color || !state || !font)
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ bar_w = font->height;
|
|
|
+ bounds.x += padding.x;
|
|
|
+ bounds.y += padding.x;
|
|
|
+ bounds.w -= 2 * padding.x;
|
|
|
+ bounds.h -= 2 * padding.y;
|
|
|
+
|
|
|
+ matrix.x = bounds.x;
|
|
|
+ matrix.y = bounds.y;
|
|
|
+ matrix.h = bounds.h;
|
|
|
+ matrix.w = bounds.w - (3 * padding.x + 2 * bar_w);
|
|
|
+
|
|
|
+ hue_bar.w = bar_w;
|
|
|
+ hue_bar.y = bounds.y;
|
|
|
+ hue_bar.h = matrix.h;
|
|
|
+ hue_bar.x = matrix.x + matrix.w + padding.x;
|
|
|
+
|
|
|
+ alpha_bar.x = hue_bar.x + hue_bar.w + padding.x;
|
|
|
+ alpha_bar.y = bounds.y;
|
|
|
+ alpha_bar.w = bar_w;
|
|
|
+ alpha_bar.h = matrix.h;
|
|
|
+
|
|
|
+ ret = nk_color_picker_behavior(state, &bounds, &matrix, &hue_bar,
|
|
|
+ (fmt == NK_RGBA) ? &alpha_bar:0, color, in);
|
|
|
+ nk_draw_color_picker(out, &matrix, &hue_bar, (fmt == NK_RGBA) ? &alpha_bar:0, *color);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+/* ==============================================================
|
|
|
+ *
|
|
|
+ * STYLE
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_API void nk_style_default(struct nk_context *ctx){nk_style_from_table(ctx, 0);}
|
|
|
+#define NK_COLOR_MAP(NK_COLOR)\
|
|
|
+ NK_COLOR(NK_COLOR_TEXT, 175,175,175,255) \
|
|
|
+ NK_COLOR(NK_COLOR_WINDOW, 45, 45, 45, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_HEADER, 40, 40, 40, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_BORDER, 65, 65, 65, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_BUTTON, 50, 50, 50, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_BUTTON_HOVER, 40, 40, 40, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_BUTTON_ACTIVE, 35, 35, 35, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_TOGGLE, 100,100,100,255) \
|
|
|
+ NK_COLOR(NK_COLOR_TOGGLE_HOVER, 120,120,120,255) \
|
|
|
+ NK_COLOR(NK_COLOR_TOGGLE_CURSOR, 45, 45, 45, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_SELECT, 45, 45, 45, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_SELECT_ACTIVE, 35, 35, 35,255) \
|
|
|
+ NK_COLOR(NK_COLOR_SLIDER, 38, 38, 38, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_SLIDER_CURSOR, 100,100,100,255) \
|
|
|
+ NK_COLOR(NK_COLOR_SLIDER_CURSOR_HOVER, 120,120,120,255) \
|
|
|
+ NK_COLOR(NK_COLOR_SLIDER_CURSOR_ACTIVE, 150,150,150,255) \
|
|
|
+ NK_COLOR(NK_COLOR_PROPERTY, 38, 38, 38, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_EDIT, 38, 38, 38, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_EDIT_CURSOR, 175,175,175,255) \
|
|
|
+ NK_COLOR(NK_COLOR_COMBO, 45, 45, 45, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_CHART, 120,120,120,255) \
|
|
|
+ NK_COLOR(NK_COLOR_CHART_COLOR, 45, 45, 45, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_CHART_COLOR_HIGHLIGHT,255, 0, 0, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_SCROLLBAR, 40, 40, 40, 255) \
|
|
|
+ NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR, 100,100,100,255) \
|
|
|
+ NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR_HOVER,120,120,120,255) \
|
|
|
+ NK_COLOR(NK_COLOR_SCROLLBAR_CURSOR_ACTIVE,150,150,150,255) \
|
|
|
+ NK_COLOR(NK_COLOR_TAB_HEADER, 40, 40, 40,255)
|
|
|
+
|
|
|
+NK_GLOBAL const struct nk_color
|
|
|
+nk_default_color_style[NK_COLOR_COUNT] = {
|
|
|
+#define NK_COLOR(a,b,c,d,e) {b,c,d,e},
|
|
|
+ NK_COLOR_MAP(NK_COLOR)
|
|
|
+#undef NK_COLOR
|
|
|
+};
|
|
|
+
|
|
|
+NK_GLOBAL const char *nk_color_names[NK_COLOR_COUNT] = {
|
|
|
+#define NK_COLOR(a,b,c,d,e) #a,
|
|
|
+ NK_COLOR_MAP(NK_COLOR)
|
|
|
+#undef NK_COLOR
|
|
|
+};
|
|
|
+
|
|
|
+NK_API const char *nk_style_get_color_by_name(enum nk_style_colors c)
|
|
|
+{return nk_color_names[c];}
|
|
|
+
|
|
|
+NK_API struct nk_style_item nk_style_item_image(struct nk_image img)
|
|
|
+{struct nk_style_item i; i.type = NK_STYLE_ITEM_IMAGE; i.data.image = img; return i;}
|
|
|
+
|
|
|
+NK_API struct nk_style_item nk_style_item_color(struct nk_color col)
|
|
|
+{struct nk_style_item i; i.type = NK_STYLE_ITEM_COLOR; i.data.color = col; return i;}
|
|
|
+
|
|
|
+NK_API struct nk_style_item nk_style_item_hide(void)
|
|
|
+{struct nk_style_item i; i.type = NK_STYLE_ITEM_COLOR; i.data.color = nk_rgba(0,0,0,0); return i;}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_from_table(struct nk_context *ctx, const struct nk_color *table)
|
|
|
+{
|
|
|
+ struct nk_style *style;
|
|
|
+ struct nk_style_text *text;
|
|
|
+ struct nk_style_button *button;
|
|
|
+ struct nk_style_toggle *toggle;
|
|
|
+ struct nk_style_selectable *select;
|
|
|
+ struct nk_style_slider *slider;
|
|
|
+ struct nk_style_progress *prog;
|
|
|
+ struct nk_style_scrollbar *scroll;
|
|
|
+ struct nk_style_edit *edit;
|
|
|
+ struct nk_style_property *property;
|
|
|
+ struct nk_style_combo *combo;
|
|
|
+ struct nk_style_chart *chart;
|
|
|
+ struct nk_style_tab *tab;
|
|
|
+ struct nk_style_window *win;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ style = &ctx->style;
|
|
|
+ table = (!table) ? nk_default_color_style: table;
|
|
|
+
|
|
|
+ /* default text */
|
|
|
+ text = &style->text;
|
|
|
+ text->color = table[NK_COLOR_TEXT];
|
|
|
+ text->padding = nk_vec2(0,0);
|
|
|
+
|
|
|
+ /* default button */
|
|
|
+ button = &style->button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_BUTTON]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_BUTTON_HOVER]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_BUTTON_ACTIVE]);
|
|
|
+ button->border_color = table[NK_COLOR_BORDER];
|
|
|
+ button->text_background = table[NK_COLOR_BUTTON];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->image_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f, 0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 1.0f;
|
|
|
+ button->rounding = 4.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* contextual button */
|
|
|
+ button = &style->contextual_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_BUTTON_HOVER]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_BUTTON_ACTIVE]);
|
|
|
+ button->border_color = table[NK_COLOR_WINDOW];
|
|
|
+ button->text_background = table[NK_COLOR_WINDOW];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* menu button */
|
|
|
+ button = &style->menu_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->border_color = table[NK_COLOR_WINDOW];
|
|
|
+ button->text_background = table[NK_COLOR_WINDOW];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 1.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* checkbox toggle */
|
|
|
+ toggle = &style->checkbox;
|
|
|
+ nk_zero_struct(*toggle);
|
|
|
+ toggle->normal = nk_style_item_color(table[NK_COLOR_TOGGLE]);
|
|
|
+ toggle->hover = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]);
|
|
|
+ toggle->active = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]);
|
|
|
+ toggle->cursor_normal = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]);
|
|
|
+ toggle->cursor_hover = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]);
|
|
|
+ toggle->userdata = nk_handle_ptr(0);
|
|
|
+ toggle->text_background = table[NK_COLOR_WINDOW];
|
|
|
+ toggle->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ toggle->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ toggle->text_active = table[NK_COLOR_TEXT];
|
|
|
+ toggle->padding = nk_vec2(2.0f, 2.0f);
|
|
|
+ toggle->touch_padding = nk_vec2(0,0);
|
|
|
+ toggle->border_color = nk_rgba(0,0,0,0);
|
|
|
+ toggle->border = 0.0f;
|
|
|
+ toggle->spacing = 4;
|
|
|
+
|
|
|
+ /* option toggle */
|
|
|
+ toggle = &style->option;
|
|
|
+ nk_zero_struct(*toggle);
|
|
|
+ toggle->normal = nk_style_item_color(table[NK_COLOR_TOGGLE]);
|
|
|
+ toggle->hover = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]);
|
|
|
+ toggle->active = nk_style_item_color(table[NK_COLOR_TOGGLE_HOVER]);
|
|
|
+ toggle->cursor_normal = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]);
|
|
|
+ toggle->cursor_hover = nk_style_item_color(table[NK_COLOR_TOGGLE_CURSOR]);
|
|
|
+ toggle->userdata = nk_handle_ptr(0);
|
|
|
+ toggle->text_background = table[NK_COLOR_WINDOW];
|
|
|
+ toggle->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ toggle->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ toggle->text_active = table[NK_COLOR_TEXT];
|
|
|
+ toggle->padding = nk_vec2(3.0f, 3.0f);
|
|
|
+ toggle->touch_padding = nk_vec2(0,0);
|
|
|
+ toggle->border_color = nk_rgba(0,0,0,0);
|
|
|
+ toggle->border = 0.0f;
|
|
|
+ toggle->spacing = 4;
|
|
|
+
|
|
|
+ /* selectable */
|
|
|
+ select = &style->selectable;
|
|
|
+ nk_zero_struct(*select);
|
|
|
+ select->normal = nk_style_item_color(table[NK_COLOR_SELECT]);
|
|
|
+ select->hover = nk_style_item_color(table[NK_COLOR_SELECT]);
|
|
|
+ select->pressed = nk_style_item_color(table[NK_COLOR_SELECT]);
|
|
|
+ select->normal_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]);
|
|
|
+ select->hover_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]);
|
|
|
+ select->pressed_active = nk_style_item_color(table[NK_COLOR_SELECT_ACTIVE]);
|
|
|
+ select->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ select->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ select->text_pressed = table[NK_COLOR_TEXT];
|
|
|
+ select->text_normal_active = table[NK_COLOR_TEXT];
|
|
|
+ select->text_hover_active = table[NK_COLOR_TEXT];
|
|
|
+ select->text_pressed_active = table[NK_COLOR_TEXT];
|
|
|
+ select->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ select->touch_padding = nk_vec2(0,0);
|
|
|
+ select->userdata = nk_handle_ptr(0);
|
|
|
+ select->rounding = 0.0f;
|
|
|
+ select->draw_begin = 0;
|
|
|
+ select->draw_end = 0;
|
|
|
+
|
|
|
+ /* slider */
|
|
|
+ slider = &style->slider;
|
|
|
+ nk_zero_struct(*slider);
|
|
|
+ slider->normal = nk_style_item_hide();
|
|
|
+ slider->hover = nk_style_item_hide();
|
|
|
+ slider->active = nk_style_item_hide();
|
|
|
+ slider->bar_normal = table[NK_COLOR_SLIDER];
|
|
|
+ slider->bar_hover = table[NK_COLOR_SLIDER];
|
|
|
+ slider->bar_active = table[NK_COLOR_SLIDER];
|
|
|
+ slider->bar_filled = table[NK_COLOR_SLIDER_CURSOR];
|
|
|
+ slider->cursor_normal = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR]);
|
|
|
+ slider->cursor_hover = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_HOVER]);
|
|
|
+ slider->cursor_active = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_ACTIVE]);
|
|
|
+ slider->inc_symbol = NK_SYMBOL_TRIANGLE_RIGHT;
|
|
|
+ slider->dec_symbol = NK_SYMBOL_TRIANGLE_LEFT;
|
|
|
+ slider->cursor_size = nk_vec2(16,16);
|
|
|
+ slider->padding = nk_vec2(2,2);
|
|
|
+ slider->spacing = nk_vec2(2,2);
|
|
|
+ slider->userdata = nk_handle_ptr(0);
|
|
|
+ slider->show_buttons = nk_false;
|
|
|
+ slider->bar_height = 8;
|
|
|
+ slider->rounding = 0;
|
|
|
+ slider->draw_begin = 0;
|
|
|
+ slider->draw_end = 0;
|
|
|
+
|
|
|
+ /* slider buttons */
|
|
|
+ button = &style->slider.inc_button;
|
|
|
+ button->normal = nk_style_item_color(nk_rgb(40,40,40));
|
|
|
+ button->hover = nk_style_item_color(nk_rgb(42,42,42));
|
|
|
+ button->active = nk_style_item_color(nk_rgb(44,44,44));
|
|
|
+ button->border_color = nk_rgb(65,65,65);
|
|
|
+ button->text_background = nk_rgb(40,40,40);
|
|
|
+ button->text_normal = nk_rgb(175,175,175);
|
|
|
+ button->text_hover = nk_rgb(175,175,175);
|
|
|
+ button->text_active = nk_rgb(175,175,175);
|
|
|
+ button->padding = nk_vec2(8.0f,8.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 1.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+ style->slider.dec_button = style->slider.inc_button;
|
|
|
+
|
|
|
+ /* progressbar */
|
|
|
+ prog = &style->progress;
|
|
|
+ nk_zero_struct(*prog);
|
|
|
+ prog->normal = nk_style_item_color(table[NK_COLOR_SLIDER]);
|
|
|
+ prog->hover = nk_style_item_color(table[NK_COLOR_SLIDER]);
|
|
|
+ prog->active = nk_style_item_color(table[NK_COLOR_SLIDER]);
|
|
|
+ prog->cursor_normal = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR]);
|
|
|
+ prog->cursor_hover = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_HOVER]);
|
|
|
+ prog->cursor_active = nk_style_item_color(table[NK_COLOR_SLIDER_CURSOR_ACTIVE]);
|
|
|
+ prog->border_color = nk_rgba(0,0,0,0);
|
|
|
+ prog->cursor_border_color = nk_rgba(0,0,0,0);
|
|
|
+ prog->userdata = nk_handle_ptr(0);
|
|
|
+ prog->padding = nk_vec2(4,4);
|
|
|
+ prog->rounding = 0;
|
|
|
+ prog->border = 0;
|
|
|
+ prog->cursor_rounding = 0;
|
|
|
+ prog->cursor_border = 0;
|
|
|
+ prog->draw_begin = 0;
|
|
|
+ prog->draw_end = 0;
|
|
|
+
|
|
|
+ /* scrollbars */
|
|
|
+ scroll = &style->scrollh;
|
|
|
+ nk_zero_struct(*scroll);
|
|
|
+ scroll->normal = nk_style_item_color(table[NK_COLOR_SCROLLBAR]);
|
|
|
+ scroll->hover = nk_style_item_color(table[NK_COLOR_SCROLLBAR]);
|
|
|
+ scroll->active = nk_style_item_color(table[NK_COLOR_SCROLLBAR]);
|
|
|
+ scroll->cursor_normal = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR]);
|
|
|
+ scroll->cursor_hover = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR_HOVER]);
|
|
|
+ scroll->cursor_active = nk_style_item_color(table[NK_COLOR_SCROLLBAR_CURSOR_ACTIVE]);
|
|
|
+ scroll->dec_symbol = NK_SYMBOL_CIRCLE_SOLID;
|
|
|
+ scroll->inc_symbol = NK_SYMBOL_CIRCLE_SOLID;
|
|
|
+ scroll->userdata = nk_handle_ptr(0);
|
|
|
+ scroll->border_color = table[NK_COLOR_SCROLLBAR];
|
|
|
+ scroll->cursor_border_color = table[NK_COLOR_SCROLLBAR];
|
|
|
+ scroll->padding = nk_vec2(0,0);
|
|
|
+ scroll->show_buttons = nk_false;
|
|
|
+ scroll->border = 0;
|
|
|
+ scroll->rounding = 0;
|
|
|
+ scroll->border_cursor = 0;
|
|
|
+ scroll->rounding_cursor = 0;
|
|
|
+ scroll->draw_begin = 0;
|
|
|
+ scroll->draw_end = 0;
|
|
|
+ style->scrollv = style->scrollh;
|
|
|
+
|
|
|
+ /* scrollbars buttons */
|
|
|
+ button = &style->scrollh.inc_button;
|
|
|
+ button->normal = nk_style_item_color(nk_rgb(40,40,40));
|
|
|
+ button->hover = nk_style_item_color(nk_rgb(42,42,42));
|
|
|
+ button->active = nk_style_item_color(nk_rgb(44,44,44));
|
|
|
+ button->border_color = nk_rgb(65,65,65);
|
|
|
+ button->text_background = nk_rgb(40,40,40);
|
|
|
+ button->text_normal = nk_rgb(175,175,175);
|
|
|
+ button->text_hover = nk_rgb(175,175,175);
|
|
|
+ button->text_active = nk_rgb(175,175,175);
|
|
|
+ button->padding = nk_vec2(4.0f,4.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 1.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+ style->scrollh.dec_button = style->scrollh.inc_button;
|
|
|
+ style->scrollv.inc_button = style->scrollh.inc_button;
|
|
|
+ style->scrollv.dec_button = style->scrollh.inc_button;
|
|
|
+
|
|
|
+ /* edit */
|
|
|
+ edit = &style->edit;
|
|
|
+ nk_zero_struct(*edit);
|
|
|
+ edit->normal = nk_style_item_color(table[NK_COLOR_EDIT]);
|
|
|
+ edit->hover = nk_style_item_color(table[NK_COLOR_EDIT]);
|
|
|
+ edit->active = nk_style_item_color(table[NK_COLOR_EDIT]);
|
|
|
+ edit->cursor_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->cursor_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->cursor_text_normal= table[NK_COLOR_EDIT];
|
|
|
+ edit->cursor_text_hover = table[NK_COLOR_EDIT];
|
|
|
+ edit->border_color = table[NK_COLOR_BORDER];
|
|
|
+ edit->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->text_active = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_text_normal = table[NK_COLOR_EDIT];
|
|
|
+ edit->selected_text_hover = table[NK_COLOR_EDIT];
|
|
|
+ edit->scrollbar_size = nk_vec2(10,10);
|
|
|
+ edit->scrollbar = style->scrollv;
|
|
|
+ edit->padding = nk_vec2(4,4);
|
|
|
+ edit->row_padding = 2;
|
|
|
+ edit->cursor_size = 4;
|
|
|
+ edit->border = 1;
|
|
|
+ edit->rounding = 0;
|
|
|
+
|
|
|
+ /* property */
|
|
|
+ property = &style->property;
|
|
|
+ nk_zero_struct(*property);
|
|
|
+ property->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ property->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ property->active = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ property->border_color = table[NK_COLOR_BORDER];
|
|
|
+ property->label_normal = table[NK_COLOR_TEXT];
|
|
|
+ property->label_hover = table[NK_COLOR_TEXT];
|
|
|
+ property->label_active = table[NK_COLOR_TEXT];
|
|
|
+ property->sym_left = NK_SYMBOL_TRIANGLE_LEFT;
|
|
|
+ property->sym_right = NK_SYMBOL_TRIANGLE_RIGHT;
|
|
|
+ property->userdata = nk_handle_ptr(0);
|
|
|
+ property->padding = nk_vec2(4,4);
|
|
|
+ property->border = 1;
|
|
|
+ property->rounding = 10;
|
|
|
+ property->draw_begin = 0;
|
|
|
+ property->draw_end = 0;
|
|
|
+
|
|
|
+ /* property buttons */
|
|
|
+ button = &style->property.dec_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_PROPERTY];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+ style->property.inc_button = style->property.dec_button;
|
|
|
+
|
|
|
+ /* property edit */
|
|
|
+ edit = &style->property.edit;
|
|
|
+ nk_zero_struct(*edit);
|
|
|
+ edit->normal = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ edit->hover = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ edit->active = nk_style_item_color(table[NK_COLOR_PROPERTY]);
|
|
|
+ edit->border_color = nk_rgba(0,0,0,0);
|
|
|
+ edit->cursor_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->cursor_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->cursor_text_normal= table[NK_COLOR_EDIT];
|
|
|
+ edit->cursor_text_hover = table[NK_COLOR_EDIT];
|
|
|
+ edit->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->text_active = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_normal = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_hover = table[NK_COLOR_TEXT];
|
|
|
+ edit->selected_text_normal = table[NK_COLOR_EDIT];
|
|
|
+ edit->selected_text_hover = table[NK_COLOR_EDIT];
|
|
|
+ edit->padding = nk_vec2(0,0);
|
|
|
+ edit->cursor_size = 8;
|
|
|
+ edit->border = 0;
|
|
|
+ edit->rounding = 0;
|
|
|
+
|
|
|
+ /* chart */
|
|
|
+ chart = &style->chart;
|
|
|
+ nk_zero_struct(*chart);
|
|
|
+ chart->background = nk_style_item_color(table[NK_COLOR_CHART]);
|
|
|
+ chart->border_color = table[NK_COLOR_BORDER];
|
|
|
+ chart->selected_color = table[NK_COLOR_CHART_COLOR_HIGHLIGHT];
|
|
|
+ chart->color = table[NK_COLOR_CHART_COLOR];
|
|
|
+ chart->padding = nk_vec2(4,4);
|
|
|
+ chart->border = 0;
|
|
|
+ chart->rounding = 0;
|
|
|
+
|
|
|
+ /* combo */
|
|
|
+ combo = &style->combo;
|
|
|
+ combo->normal = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ combo->hover = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ combo->active = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ combo->border_color = table[NK_COLOR_BORDER];
|
|
|
+ combo->label_normal = table[NK_COLOR_TEXT];
|
|
|
+ combo->label_hover = table[NK_COLOR_TEXT];
|
|
|
+ combo->label_active = table[NK_COLOR_TEXT];
|
|
|
+ combo->sym_normal = NK_SYMBOL_TRIANGLE_DOWN;
|
|
|
+ combo->sym_hover = NK_SYMBOL_TRIANGLE_DOWN;
|
|
|
+ combo->sym_active = NK_SYMBOL_TRIANGLE_DOWN;
|
|
|
+ combo->content_padding = nk_vec2(4,4);
|
|
|
+ combo->button_padding = nk_vec2(0,4);
|
|
|
+ combo->spacing = nk_vec2(4,0);
|
|
|
+ combo->border = 1;
|
|
|
+ combo->rounding = 0;
|
|
|
+
|
|
|
+ /* combo button */
|
|
|
+ button = &style->combo.button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_COMBO]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_COMBO];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* tab */
|
|
|
+ tab = &style->tab;
|
|
|
+ tab->background = nk_style_item_color(table[NK_COLOR_TAB_HEADER]);
|
|
|
+ tab->border_color = table[NK_COLOR_BORDER];
|
|
|
+ tab->text = table[NK_COLOR_TEXT];
|
|
|
+ tab->sym_minimize = NK_SYMBOL_TRIANGLE_RIGHT;
|
|
|
+ tab->sym_maximize = NK_SYMBOL_TRIANGLE_DOWN;
|
|
|
+ tab->padding = nk_vec2(4,4);
|
|
|
+ tab->spacing = nk_vec2(4,4);
|
|
|
+ tab->indent = 10.0f;
|
|
|
+ tab->border = 1;
|
|
|
+ tab->rounding = 0;
|
|
|
+
|
|
|
+ /* tab button */
|
|
|
+ button = &style->tab.tab_minimize_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_TAB_HEADER]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_TAB_HEADER]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_TAB_HEADER]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_TAB_HEADER];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+ style->tab.tab_maximize_button =*button;
|
|
|
+
|
|
|
+ /* node button */
|
|
|
+ button = &style->tab.node_minimize_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_TAB_HEADER];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(2.0f,2.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+ style->tab.node_maximize_button =*button;
|
|
|
+
|
|
|
+ /* window header */
|
|
|
+ win = &style->window;
|
|
|
+ win->header.align = NK_HEADER_RIGHT;
|
|
|
+ win->header.close_symbol = NK_SYMBOL_X;
|
|
|
+ win->header.minimize_symbol = NK_SYMBOL_MINUS;
|
|
|
+ win->header.maximize_symbol = NK_SYMBOL_PLUS;
|
|
|
+ win->header.normal = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ win->header.hover = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ win->header.active = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ win->header.label_normal = table[NK_COLOR_TEXT];
|
|
|
+ win->header.label_hover = table[NK_COLOR_TEXT];
|
|
|
+ win->header.label_active = table[NK_COLOR_TEXT];
|
|
|
+ win->header.label_padding = nk_vec2(4,4);
|
|
|
+ win->header.padding = nk_vec2(4,4);
|
|
|
+ win->header.spacing = nk_vec2(0,0);
|
|
|
+
|
|
|
+ /* window header close button */
|
|
|
+ button = &style->window.header.close_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_HEADER];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* window header minimize button */
|
|
|
+ button = &style->window.header.minimize_button;
|
|
|
+ nk_zero_struct(*button);
|
|
|
+ button->normal = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->hover = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->active = nk_style_item_color(table[NK_COLOR_HEADER]);
|
|
|
+ button->border_color = nk_rgba(0,0,0,0);
|
|
|
+ button->text_background = table[NK_COLOR_HEADER];
|
|
|
+ button->text_normal = table[NK_COLOR_TEXT];
|
|
|
+ button->text_hover = table[NK_COLOR_TEXT];
|
|
|
+ button->text_active = table[NK_COLOR_TEXT];
|
|
|
+ button->padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->touch_padding = nk_vec2(0.0f,0.0f);
|
|
|
+ button->userdata = nk_handle_ptr(0);
|
|
|
+ button->text_alignment = NK_TEXT_CENTERED;
|
|
|
+ button->border = 0.0f;
|
|
|
+ button->rounding = 0.0f;
|
|
|
+ button->draw_begin = 0;
|
|
|
+ button->draw_end = 0;
|
|
|
+
|
|
|
+ /* window */
|
|
|
+ win->background = table[NK_COLOR_WINDOW];
|
|
|
+ win->fixed_background = nk_style_item_color(table[NK_COLOR_WINDOW]);
|
|
|
+ win->border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->popup_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->combo_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->contextual_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->menu_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->group_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->tooltip_border_color = table[NK_COLOR_BORDER];
|
|
|
+ win->scaler = nk_style_item_color(table[NK_COLOR_TEXT]);
|
|
|
+
|
|
|
+ win->rounding = 0.0f;
|
|
|
+ win->spacing = nk_vec2(4,4);
|
|
|
+ win->scrollbar_size = nk_vec2(10,10);
|
|
|
+ win->min_size = nk_vec2(64,64);
|
|
|
+
|
|
|
+ win->combo_border = 1.0f;
|
|
|
+ win->contextual_border = 1.0f;
|
|
|
+ win->menu_border = 1.0f;
|
|
|
+ win->group_border = 1.0f;
|
|
|
+ win->tooltip_border = 1.0f;
|
|
|
+ win->popup_border = 1.0f;
|
|
|
+ win->border = 2.0f;
|
|
|
+ win->min_row_height_padding = 8;
|
|
|
+
|
|
|
+ win->padding = nk_vec2(4,4);
|
|
|
+ win->group_padding = nk_vec2(4,4);
|
|
|
+ win->popup_padding = nk_vec2(4,4);
|
|
|
+ win->combo_padding = nk_vec2(4,4);
|
|
|
+ win->contextual_padding = nk_vec2(4,4);
|
|
|
+ win->menu_padding = nk_vec2(4,4);
|
|
|
+ win->tooltip_padding = nk_vec2(4,4);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_set_font(struct nk_context *ctx, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ struct nk_style *style;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+
|
|
|
+ if (!ctx) return;
|
|
|
+ style = &ctx->style;
|
|
|
+ style->font = font;
|
|
|
+ ctx->stacks.fonts.head = 0;
|
|
|
+ if (ctx->current)
|
|
|
+ nk_layout_reset_min_row_height(ctx);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_style_push_font(struct nk_context *ctx, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ struct nk_config_stack_user_font *font_stack;
|
|
|
+ struct nk_config_stack_user_font_element *element;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ font_stack = &ctx->stacks.fonts;
|
|
|
+ NK_ASSERT(font_stack->head < (int)NK_LEN(font_stack->elements));
|
|
|
+ if (font_stack->head >= (int)NK_LEN(font_stack->elements))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ element = &font_stack->elements[font_stack->head++];
|
|
|
+ element->address = &ctx->style.font;
|
|
|
+ element->old_value = ctx->style.font;
|
|
|
+ ctx->style.font = font;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_style_pop_font(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_config_stack_user_font *font_stack;
|
|
|
+ struct nk_config_stack_user_font_element *element;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ font_stack = &ctx->stacks.fonts;
|
|
|
+ NK_ASSERT(font_stack->head > 0);
|
|
|
+ if (font_stack->head < 1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ element = &font_stack->elements[--font_stack->head];
|
|
|
+ *element->address = element->old_value;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+#define NK_STYLE_PUSH_IMPLEMENATION(prefix, type, stack) \
|
|
|
+nk_style_push_##type(struct nk_context *ctx, prefix##_##type *address, prefix##_##type value)\
|
|
|
+{\
|
|
|
+ struct nk_config_stack_##type * type_stack;\
|
|
|
+ struct nk_config_stack_##type##_element *element;\
|
|
|
+ NK_ASSERT(ctx);\
|
|
|
+ if (!ctx) return 0;\
|
|
|
+ type_stack = &ctx->stacks.stack;\
|
|
|
+ NK_ASSERT(type_stack->head < (int)NK_LEN(type_stack->elements));\
|
|
|
+ if (type_stack->head >= (int)NK_LEN(type_stack->elements))\
|
|
|
+ return 0;\
|
|
|
+ element = &type_stack->elements[type_stack->head++];\
|
|
|
+ element->address = address;\
|
|
|
+ element->old_value = *address;\
|
|
|
+ *address = value;\
|
|
|
+ return 1;\
|
|
|
+}
|
|
|
+
|
|
|
+#define NK_STYLE_POP_IMPLEMENATION(type, stack) \
|
|
|
+nk_style_pop_##type(struct nk_context *ctx)\
|
|
|
+{\
|
|
|
+ struct nk_config_stack_##type *type_stack;\
|
|
|
+ struct nk_config_stack_##type##_element *element;\
|
|
|
+ NK_ASSERT(ctx);\
|
|
|
+ if (!ctx) return 0;\
|
|
|
+ type_stack = &ctx->stacks.stack;\
|
|
|
+ NK_ASSERT(type_stack->head > 0);\
|
|
|
+ if (type_stack->head < 1)\
|
|
|
+ return 0;\
|
|
|
+ element = &type_stack->elements[--type_stack->head];\
|
|
|
+ *element->address = element->old_value;\
|
|
|
+ return 1;\
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int NK_STYLE_PUSH_IMPLEMENATION(struct nk, style_item, style_items)
|
|
|
+NK_API int NK_STYLE_PUSH_IMPLEMENATION(nk,float, floats)
|
|
|
+NK_API int NK_STYLE_PUSH_IMPLEMENATION(struct nk, vec2, vectors)
|
|
|
+NK_API int NK_STYLE_PUSH_IMPLEMENATION(nk,flags, flags)
|
|
|
+NK_API int NK_STYLE_PUSH_IMPLEMENATION(struct nk,color, colors)
|
|
|
+
|
|
|
+NK_API int NK_STYLE_POP_IMPLEMENATION(style_item, style_items)
|
|
|
+NK_API int NK_STYLE_POP_IMPLEMENATION(float,floats)
|
|
|
+NK_API int NK_STYLE_POP_IMPLEMENATION(vec2, vectors)
|
|
|
+NK_API int NK_STYLE_POP_IMPLEMENATION(flags,flags)
|
|
|
+NK_API int NK_STYLE_POP_IMPLEMENATION(color,colors)
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_style_set_cursor(struct nk_context *ctx, enum nk_style_cursor c)
|
|
|
+{
|
|
|
+ struct nk_style *style;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ style = &ctx->style;
|
|
|
+ if (style->cursors[c]) {
|
|
|
+ style->cursor_active = style->cursors[c];
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_show_cursor(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ ctx->style.cursor_visible = nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_hide_cursor(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ ctx->style.cursor_visible = nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_load_cursor(struct nk_context *ctx, enum nk_style_cursor cursor,
|
|
|
+ const struct nk_cursor *c)
|
|
|
+{
|
|
|
+ struct nk_style *style;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ style = &ctx->style;
|
|
|
+ style->cursors[cursor] = c;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_style_load_all_cursors(struct nk_context *ctx, struct nk_cursor *cursors)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ struct nk_style *style;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ style = &ctx->style;
|
|
|
+ for (i = 0; i < NK_CURSOR_COUNT; ++i)
|
|
|
+ style->cursors[i] = &cursors[i];
|
|
|
+ style->cursor_visible = nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * POOL
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN void
|
|
|
+nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc,
|
|
|
+ unsigned int capacity)
|
|
|
+{
|
|
|
+ nk_zero(pool, sizeof(*pool));
|
|
|
+ pool->alloc = *alloc;
|
|
|
+ pool->capacity = capacity;
|
|
|
+ pool->type = NK_BUFFER_DYNAMIC;
|
|
|
+ pool->pages = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_pool_free(struct nk_pool *pool)
|
|
|
+{
|
|
|
+ struct nk_page *iter = pool->pages;
|
|
|
+ if (!pool) return;
|
|
|
+ if (pool->type == NK_BUFFER_FIXED) return;
|
|
|
+ while (iter) {
|
|
|
+ struct nk_page *next = iter->next;
|
|
|
+ pool->alloc.free(pool->alloc.userdata, iter);
|
|
|
+ iter = next;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size)
|
|
|
+{
|
|
|
+ nk_zero(pool, sizeof(*pool));
|
|
|
+ NK_ASSERT(size >= sizeof(struct nk_page));
|
|
|
+ if (size < sizeof(struct nk_page)) return;
|
|
|
+ pool->capacity = (unsigned)(size - sizeof(struct nk_page)) / sizeof(struct nk_page_element);
|
|
|
+ pool->pages = (struct nk_page*)memory;
|
|
|
+ pool->type = NK_BUFFER_FIXED;
|
|
|
+ pool->size = size;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_page_element*
|
|
|
+nk_pool_alloc(struct nk_pool *pool)
|
|
|
+{
|
|
|
+ if (!pool->pages || pool->pages->size >= pool->capacity) {
|
|
|
+ /* allocate new page */
|
|
|
+ struct nk_page *page;
|
|
|
+ if (pool->type == NK_BUFFER_FIXED) {
|
|
|
+ if (!pool->pages) {
|
|
|
+ NK_ASSERT(pool->pages);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ NK_ASSERT(pool->pages->size < pool->capacity);
|
|
|
+ return 0;
|
|
|
+ } else {
|
|
|
+ nk_size size = sizeof(struct nk_page);
|
|
|
+ size += NK_POOL_DEFAULT_CAPACITY * sizeof(union nk_page_data);
|
|
|
+ page = (struct nk_page*)pool->alloc.alloc(pool->alloc.userdata,0, size);
|
|
|
+ page->next = pool->pages;
|
|
|
+ pool->pages = page;
|
|
|
+ page->size = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return &pool->pages->win[pool->pages->size++];
|
|
|
+}
|
|
|
+
|
|
|
+/* ===============================================================
|
|
|
+ *
|
|
|
+ * CONTEXT
|
|
|
+ *
|
|
|
+ * ===============================================================*/
|
|
|
+NK_INTERN void* nk_create_window(struct nk_context *ctx);
|
|
|
+NK_INTERN void nk_remove_window(struct nk_context*, struct nk_window*);
|
|
|
+NK_INTERN void nk_free_window(struct nk_context *ctx, struct nk_window *win);
|
|
|
+NK_INTERN void nk_free_table(struct nk_context *ctx, struct nk_table *tbl);
|
|
|
+NK_INTERN void nk_remove_table(struct nk_window *win, struct nk_table *tbl);
|
|
|
+NK_INTERN void* nk_create_panel(struct nk_context *ctx);
|
|
|
+NK_INTERN void nk_free_panel(struct nk_context*, struct nk_panel *pan);
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_setup(struct nk_context *ctx, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ nk_zero_struct(*ctx);
|
|
|
+ nk_style_default(ctx);
|
|
|
+ ctx->seq = 1;
|
|
|
+ if (font) ctx->style.font = font;
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ nk_draw_list_init(&ctx->draw_list);
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
|
|
|
+NK_API int
|
|
|
+nk_init_default(struct nk_context *ctx, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ struct nk_allocator alloc;
|
|
|
+ alloc.userdata.ptr = 0;
|
|
|
+ alloc.alloc = nk_malloc;
|
|
|
+ alloc.free = nk_mfree;
|
|
|
+ return nk_init(ctx, &alloc, font);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ NK_ASSERT(memory);
|
|
|
+ if (!memory) return 0;
|
|
|
+ nk_setup(ctx, font);
|
|
|
+ nk_buffer_init_fixed(&ctx->memory, memory, size);
|
|
|
+ ctx->use_pool = nk_false;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_init_custom(struct nk_context *ctx, struct nk_buffer *cmds,
|
|
|
+ struct nk_buffer *pool, const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ NK_ASSERT(cmds);
|
|
|
+ NK_ASSERT(pool);
|
|
|
+ if (!cmds || !pool) return 0;
|
|
|
+
|
|
|
+ nk_setup(ctx, font);
|
|
|
+ ctx->memory = *cmds;
|
|
|
+ if (pool->type == NK_BUFFER_FIXED) {
|
|
|
+ /* take memory from buffer and alloc fixed pool */
|
|
|
+ nk_pool_init_fixed(&ctx->pool, pool->memory.ptr, pool->memory.size);
|
|
|
+ } else {
|
|
|
+ /* create dynamic pool from buffer allocator */
|
|
|
+ struct nk_allocator *alloc = &pool->pool;
|
|
|
+ nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
|
|
|
+ }
|
|
|
+ ctx->use_pool = nk_true;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_init(struct nk_context *ctx, struct nk_allocator *alloc,
|
|
|
+ const struct nk_user_font *font)
|
|
|
+{
|
|
|
+ NK_ASSERT(alloc);
|
|
|
+ if (!alloc) return 0;
|
|
|
+ nk_setup(ctx, font);
|
|
|
+ nk_buffer_init(&ctx->memory, alloc, NK_DEFAULT_COMMAND_BUFFER_SIZE);
|
|
|
+ nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
|
|
|
+ ctx->use_pool = nk_true;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+NK_API void
|
|
|
+nk_set_user_data(struct nk_context *ctx, nk_handle handle)
|
|
|
+{
|
|
|
+ if (!ctx) return;
|
|
|
+ ctx->userdata = handle;
|
|
|
+ if (ctx->current)
|
|
|
+ ctx->current->buffer.userdata = handle;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_free(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ nk_buffer_free(&ctx->memory);
|
|
|
+ if (ctx->use_pool)
|
|
|
+ nk_pool_free(&ctx->pool);
|
|
|
+
|
|
|
+ nk_zero(&ctx->input, sizeof(ctx->input));
|
|
|
+ nk_zero(&ctx->style, sizeof(ctx->style));
|
|
|
+ nk_zero(&ctx->memory, sizeof(ctx->memory));
|
|
|
+
|
|
|
+ ctx->seq = 0;
|
|
|
+ ctx->build = 0;
|
|
|
+ ctx->begin = 0;
|
|
|
+ ctx->end = 0;
|
|
|
+ ctx->active = 0;
|
|
|
+ ctx->current = 0;
|
|
|
+ ctx->freelist = 0;
|
|
|
+ ctx->count = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_clear(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *iter;
|
|
|
+ struct nk_window *next;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+
|
|
|
+ if (!ctx) return;
|
|
|
+ if (ctx->use_pool)
|
|
|
+ nk_buffer_clear(&ctx->memory);
|
|
|
+ else nk_buffer_reset(&ctx->memory, NK_BUFFER_FRONT);
|
|
|
+
|
|
|
+ ctx->build = 0;
|
|
|
+ ctx->memory.calls = 0;
|
|
|
+ ctx->last_widget_state = 0;
|
|
|
+ ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_ARROW];
|
|
|
+ NK_MEMSET(&ctx->overlay, 0, sizeof(ctx->overlay));
|
|
|
+#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
|
|
+ nk_draw_list_clear(&ctx->draw_list);
|
|
|
+#endif
|
|
|
+
|
|
|
+ /* garbage collector */
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter) {
|
|
|
+ /* make sure minimized windows do not get removed */
|
|
|
+ if ((iter->flags & NK_WINDOW_MINIMIZED) &&
|
|
|
+ !(iter->flags & NK_WINDOW_CLOSED)) {
|
|
|
+ iter = iter->next;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ /* remove hotness from hidden or closed windows*/
|
|
|
+ if (((iter->flags & NK_WINDOW_HIDDEN) ||
|
|
|
+ (iter->flags & NK_WINDOW_CLOSED)) &&
|
|
|
+ iter == ctx->active)
|
|
|
+ ctx->active = iter->next;
|
|
|
+
|
|
|
+ /* free unused popup windows */
|
|
|
+ if (iter->popup.win && iter->popup.win->seq != ctx->seq) {
|
|
|
+ nk_free_window(ctx, iter->popup.win);
|
|
|
+ iter->popup.win = 0;
|
|
|
+ }
|
|
|
+ /* remove unused window state tables */
|
|
|
+ {struct nk_table *n, *it = iter->tables;
|
|
|
+ while (it) {
|
|
|
+ n = it->next;
|
|
|
+ if (it->seq != ctx->seq) {
|
|
|
+ nk_remove_table(iter, it);
|
|
|
+ nk_zero(it, sizeof(union nk_page_data));
|
|
|
+ nk_free_table(ctx, it);
|
|
|
+ if (it == iter->tables)
|
|
|
+ iter->tables = n;
|
|
|
+ }
|
|
|
+ it = n;
|
|
|
+ }}
|
|
|
+ /* window itself is not used anymore so free */
|
|
|
+ if (iter->seq != ctx->seq || iter->flags & NK_WINDOW_CLOSED) {
|
|
|
+ next = iter->next;
|
|
|
+ nk_remove_window(ctx, iter);
|
|
|
+ nk_free_window(ctx, iter);
|
|
|
+ iter = next;
|
|
|
+ } else iter = iter->next;
|
|
|
+ }
|
|
|
+ ctx->seq++;
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * BUFFERING
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+NK_INTERN void
|
|
|
+nk_start_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!ctx || !buffer) return;
|
|
|
+ buffer->begin = ctx->memory.allocated;
|
|
|
+ buffer->end = buffer->begin;
|
|
|
+ buffer->last = buffer->begin;
|
|
|
+ buffer->clip = nk_null_rect;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_start(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ nk_start_buffer(ctx, &win->buffer);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_start_popup(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ struct nk_popup_buffer *buf;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ if (!ctx || !win) return;
|
|
|
+
|
|
|
+ /* save buffer fill state for popup */
|
|
|
+ buf = &win->popup.buf;
|
|
|
+ buf->begin = win->buffer.end;
|
|
|
+ buf->end = win->buffer.end;
|
|
|
+ buf->parent = win->buffer.last;
|
|
|
+ buf->last = buf->begin;
|
|
|
+ buf->active = nk_true;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_finish_popup(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ struct nk_popup_buffer *buf;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ if (!ctx || !win) return;
|
|
|
+
|
|
|
+ buf = &win->popup.buf;
|
|
|
+ buf->last = win->buffer.last;
|
|
|
+ buf->end = win->buffer.end;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_finish_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(buffer);
|
|
|
+ if (!ctx || !buffer) return;
|
|
|
+ buffer->end = ctx->memory.allocated;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_finish(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ struct nk_popup_buffer *buf;
|
|
|
+ struct nk_command *parent_last;
|
|
|
+ void *memory;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ if (!ctx || !win) return;
|
|
|
+ nk_finish_buffer(ctx, &win->buffer);
|
|
|
+ if (!win->popup.buf.active) return;
|
|
|
+
|
|
|
+ buf = &win->popup.buf;
|
|
|
+ memory = ctx->memory.memory.ptr;
|
|
|
+ parent_last = nk_ptr_add(struct nk_command, memory, buf->parent);
|
|
|
+ parent_last->next = buf->end;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_build(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *iter = 0;
|
|
|
+ struct nk_command *cmd = 0;
|
|
|
+ nk_byte *buffer = 0;
|
|
|
+
|
|
|
+ /* draw cursor overlay */
|
|
|
+ if (!ctx->style.cursor_active)
|
|
|
+ ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_ARROW];
|
|
|
+ if (ctx->style.cursor_active && !ctx->input.mouse.grabbed && ctx->style.cursor_visible) {
|
|
|
+ struct nk_rect mouse_bounds;
|
|
|
+ const struct nk_cursor *cursor = ctx->style.cursor_active;
|
|
|
+ nk_command_buffer_init(&ctx->overlay, &ctx->memory, NK_CLIPPING_OFF);
|
|
|
+ nk_start_buffer(ctx, &ctx->overlay);
|
|
|
+
|
|
|
+ mouse_bounds.x = ctx->input.mouse.pos.x - cursor->offset.x;
|
|
|
+ mouse_bounds.y = ctx->input.mouse.pos.y - cursor->offset.y;
|
|
|
+ mouse_bounds.w = cursor->size.x;
|
|
|
+ mouse_bounds.h = cursor->size.y;
|
|
|
+
|
|
|
+ nk_draw_image(&ctx->overlay, mouse_bounds, &cursor->img, nk_white);
|
|
|
+ nk_finish_buffer(ctx, &ctx->overlay);
|
|
|
+ }
|
|
|
+ /* build one big draw command list out of all window buffers */
|
|
|
+ iter = ctx->begin;
|
|
|
+ buffer = (nk_byte*)ctx->memory.memory.ptr;
|
|
|
+ while (iter != 0) {
|
|
|
+ struct nk_window *next = iter->next;
|
|
|
+ if (iter->buffer.last == iter->buffer.begin || (iter->flags & NK_WINDOW_HIDDEN)||
|
|
|
+ iter->seq != ctx->seq)
|
|
|
+ goto cont;
|
|
|
+
|
|
|
+ cmd = nk_ptr_add(struct nk_command, buffer, iter->buffer.last);
|
|
|
+ while (next && ((next->buffer.last == next->buffer.begin) ||
|
|
|
+ (next->flags & NK_WINDOW_HIDDEN)))
|
|
|
+ next = next->next; /* skip empty command buffers */
|
|
|
+
|
|
|
+ if (next) cmd->next = next->buffer.begin;
|
|
|
+ cont: iter = next;
|
|
|
+ }
|
|
|
+ /* append all popup draw commands into lists */
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter != 0) {
|
|
|
+ struct nk_window *next = iter->next;
|
|
|
+ struct nk_popup_buffer *buf;
|
|
|
+ if (!iter->popup.buf.active)
|
|
|
+ goto skip;
|
|
|
+
|
|
|
+ buf = &iter->popup.buf;
|
|
|
+ cmd->next = buf->begin;
|
|
|
+ cmd = nk_ptr_add(struct nk_command, buffer, buf->last);
|
|
|
+ buf->active = nk_false;
|
|
|
+ skip: iter = next;
|
|
|
+ }
|
|
|
+ /* append overlay commands */
|
|
|
+ if (cmd) {
|
|
|
+ if (ctx->overlay.end != ctx->overlay.begin)
|
|
|
+ cmd->next = ctx->overlay.begin;
|
|
|
+ else cmd->next = ctx->memory.allocated;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const struct nk_command*
|
|
|
+nk__begin(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *iter;
|
|
|
+ nk_byte *buffer;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ if (!ctx->count) return 0;
|
|
|
+
|
|
|
+ buffer = (nk_byte*)ctx->memory.memory.ptr;
|
|
|
+ if (!ctx->build) {
|
|
|
+ nk_build(ctx);
|
|
|
+ ctx->build = nk_true;
|
|
|
+ }
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter && ((iter->buffer.begin == iter->buffer.end) || (iter->flags & NK_WINDOW_HIDDEN)))
|
|
|
+ iter = iter->next;
|
|
|
+ if (!iter) return 0;
|
|
|
+ return nk_ptr_add_const(struct nk_command, buffer, iter->buffer.begin);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API const struct nk_command*
|
|
|
+nk__next(struct nk_context *ctx, const struct nk_command *cmd)
|
|
|
+{
|
|
|
+ nk_byte *buffer;
|
|
|
+ const struct nk_command *next;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx || !cmd || !ctx->count) return 0;
|
|
|
+ if (cmd->next >= ctx->memory.allocated) return 0;
|
|
|
+ buffer = (nk_byte*)ctx->memory.memory.ptr;
|
|
|
+ next = nk_ptr_add_const(struct nk_command, buffer, cmd->next);
|
|
|
+ return next;
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * PANEL
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+static int
|
|
|
+nk_panel_has_header(nk_flags flags, const char *title)
|
|
|
+{
|
|
|
+ int active = 0;
|
|
|
+ active = (flags & (NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE));
|
|
|
+ active = active || (flags & NK_WINDOW_TITLE);
|
|
|
+ active = active && !(flags & NK_WINDOW_HIDDEN) && title;
|
|
|
+ return active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_vec2
|
|
|
+nk_panel_get_padding(const struct nk_style *style, enum nk_panel_type type)
|
|
|
+{
|
|
|
+ switch (type) {
|
|
|
+ default:
|
|
|
+ case NK_PANEL_WINDOW: return style->window.padding;
|
|
|
+ case NK_PANEL_GROUP: return style->window.group_padding;
|
|
|
+ case NK_PANEL_POPUP: return style->window.popup_padding;
|
|
|
+ case NK_PANEL_CONTEXTUAL: return style->window.contextual_padding;
|
|
|
+ case NK_PANEL_COMBO: return style->window.combo_padding;
|
|
|
+ case NK_PANEL_MENU: return style->window.menu_padding;
|
|
|
+ case NK_PANEL_TOOLTIP: return style->window.menu_padding;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_panel_get_border(const struct nk_style *style, nk_flags flags,
|
|
|
+ enum nk_panel_type type)
|
|
|
+{
|
|
|
+ if (flags & NK_WINDOW_BORDER) {
|
|
|
+ switch (type) {
|
|
|
+ default:
|
|
|
+ case NK_PANEL_WINDOW: return style->window.border;
|
|
|
+ case NK_PANEL_GROUP: return style->window.group_border;
|
|
|
+ case NK_PANEL_POPUP: return style->window.popup_border;
|
|
|
+ case NK_PANEL_CONTEXTUAL: return style->window.contextual_border;
|
|
|
+ case NK_PANEL_COMBO: return style->window.combo_border;
|
|
|
+ case NK_PANEL_MENU: return style->window.menu_border;
|
|
|
+ case NK_PANEL_TOOLTIP: return style->window.menu_border;
|
|
|
+ }} else return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_color
|
|
|
+nk_panel_get_border_color(const struct nk_style *style, enum nk_panel_type type)
|
|
|
+{
|
|
|
+ switch (type) {
|
|
|
+ default:
|
|
|
+ case NK_PANEL_WINDOW: return style->window.border_color;
|
|
|
+ case NK_PANEL_GROUP: return style->window.group_border_color;
|
|
|
+ case NK_PANEL_POPUP: return style->window.popup_border_color;
|
|
|
+ case NK_PANEL_CONTEXTUAL: return style->window.contextual_border_color;
|
|
|
+ case NK_PANEL_COMBO: return style->window.combo_border_color;
|
|
|
+ case NK_PANEL_MENU: return style->window.menu_border_color;
|
|
|
+ case NK_PANEL_TOOLTIP: return style->window.menu_border_color;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_panel_is_sub(enum nk_panel_type type)
|
|
|
+{
|
|
|
+ return (type & NK_PANEL_SET_SUB)?1:0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_panel_is_nonblock(enum nk_panel_type type)
|
|
|
+{
|
|
|
+ return (type & NK_PANEL_SET_NONBLOCK)?1:0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_panel_begin(struct nk_context *ctx, const char *title, enum nk_panel_type panel_type)
|
|
|
+{
|
|
|
+ struct nk_input *in;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ struct nk_command_buffer *out;
|
|
|
+ const struct nk_style *style;
|
|
|
+ const struct nk_user_font *font;
|
|
|
+
|
|
|
+ struct nk_vec2 scrollbar_size;
|
|
|
+ struct nk_vec2 panel_padding;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return 0;
|
|
|
+ nk_zero(ctx->current->layout, sizeof(*ctx->current->layout));
|
|
|
+ if ((ctx->current->flags & NK_WINDOW_HIDDEN) || (ctx->current->flags & NK_WINDOW_CLOSED)) {
|
|
|
+ nk_zero(ctx->current->layout, sizeof(struct nk_panel));
|
|
|
+ ctx->current->layout->type = panel_type;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ /* pull state into local stack */
|
|
|
+ style = &ctx->style;
|
|
|
+ font = style->font;
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ out = &win->buffer;
|
|
|
+ in = (win->flags & NK_WINDOW_NO_INPUT) ? 0: &ctx->input;
|
|
|
+#ifdef NK_INCLUDE_COMMAND_USERDATA
|
|
|
+ win->buffer.userdata = ctx->userdata;
|
|
|
+#endif
|
|
|
+ /* pull style configuration into local stack */
|
|
|
+ scrollbar_size = style->window.scrollbar_size;
|
|
|
+ panel_padding = nk_panel_get_padding(style, panel_type);
|
|
|
+
|
|
|
+ /* window movement */
|
|
|
+ if ((win->flags & NK_WINDOW_MOVABLE) && !(win->flags & NK_WINDOW_ROM)) {
|
|
|
+ int left_mouse_down;
|
|
|
+ int left_mouse_click_in_cursor;
|
|
|
+
|
|
|
+ /* calculate draggable window space */
|
|
|
+ struct nk_rect header;
|
|
|
+ header.x = win->bounds.x;
|
|
|
+ header.y = win->bounds.y;
|
|
|
+ header.w = win->bounds.w;
|
|
|
+ if (nk_panel_has_header(win->flags, title)) {
|
|
|
+ header.h = font->height + 2.0f * style->window.header.padding.y;
|
|
|
+ header.h += 2.0f * style->window.header.label_padding.y;
|
|
|
+ } else header.h = panel_padding.y;
|
|
|
+
|
|
|
+ /* window movement by dragging */
|
|
|
+ left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ left_mouse_click_in_cursor = nk_input_has_mouse_click_down_in_rect(in,
|
|
|
+ NK_BUTTON_LEFT, header, nk_true);
|
|
|
+ if (left_mouse_down && left_mouse_click_in_cursor) {
|
|
|
+ win->bounds.x = win->bounds.x + in->mouse.delta.x;
|
|
|
+ win->bounds.y = win->bounds.y + in->mouse.delta.y;
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x += in->mouse.delta.x;
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y += in->mouse.delta.y;
|
|
|
+ ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_MOVE];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* setup panel */
|
|
|
+ layout->type = panel_type;
|
|
|
+ layout->flags = win->flags;
|
|
|
+ layout->bounds = win->bounds;
|
|
|
+ layout->bounds.x += panel_padding.x;
|
|
|
+ layout->bounds.w -= 2*panel_padding.x;
|
|
|
+ if (win->flags & NK_WINDOW_BORDER) {
|
|
|
+ layout->border = nk_panel_get_border(style, win->flags, panel_type);
|
|
|
+ layout->bounds = nk_shrink_rect(layout->bounds, layout->border);
|
|
|
+ } else layout->border = 0;
|
|
|
+ layout->at_y = layout->bounds.y;
|
|
|
+ layout->at_x = layout->bounds.x;
|
|
|
+ layout->max_x = 0;
|
|
|
+ layout->header_height = 0;
|
|
|
+ layout->footer_height = 0;
|
|
|
+ nk_layout_reset_min_row_height(ctx);
|
|
|
+ layout->row.index = 0;
|
|
|
+ layout->row.columns = 0;
|
|
|
+ layout->row.ratio = 0;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.tree_depth = 0;
|
|
|
+ layout->row.height = panel_padding.y;
|
|
|
+ layout->has_scrolling = nk_true;
|
|
|
+ if (!(win->flags & NK_WINDOW_NO_SCROLLBAR))
|
|
|
+ layout->bounds.w -= scrollbar_size.x;
|
|
|
+ if (!nk_panel_is_nonblock(panel_type)) {
|
|
|
+ layout->footer_height = 0;
|
|
|
+ if (!(win->flags & NK_WINDOW_NO_SCROLLBAR) || win->flags & NK_WINDOW_SCALABLE)
|
|
|
+ layout->footer_height = scrollbar_size.y;
|
|
|
+ layout->bounds.h -= layout->footer_height;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* panel header */
|
|
|
+ if (nk_panel_has_header(win->flags, title))
|
|
|
+ {
|
|
|
+ struct nk_text text;
|
|
|
+ struct nk_rect header;
|
|
|
+ const struct nk_style_item *background = 0;
|
|
|
+
|
|
|
+ /* calculate header bounds */
|
|
|
+ header.x = win->bounds.x;
|
|
|
+ header.y = win->bounds.y;
|
|
|
+ header.w = win->bounds.w;
|
|
|
+ header.h = font->height + 2.0f * style->window.header.padding.y;
|
|
|
+ header.h += (2.0f * style->window.header.label_padding.y);
|
|
|
+
|
|
|
+ /* shrink panel by header */
|
|
|
+ layout->header_height = header.h;
|
|
|
+ layout->bounds.y += header.h;
|
|
|
+ layout->bounds.h -= header.h;
|
|
|
+ layout->at_y += header.h;
|
|
|
+
|
|
|
+ /* select correct header background and text color */
|
|
|
+ if (ctx->active == win) {
|
|
|
+ background = &style->window.header.active;
|
|
|
+ text.text = style->window.header.label_active;
|
|
|
+ } else if (nk_input_is_mouse_hovering_rect(&ctx->input, header)) {
|
|
|
+ background = &style->window.header.hover;
|
|
|
+ text.text = style->window.header.label_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->window.header.normal;
|
|
|
+ text.text = style->window.header.label_normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw header background */
|
|
|
+ header.h += 1.0f;
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(out, header, 0, background->data.color);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* window close button */
|
|
|
+ {struct nk_rect button;
|
|
|
+ button.y = header.y + style->window.header.padding.y;
|
|
|
+ button.h = header.h - 2 * style->window.header.padding.y;
|
|
|
+ button.w = button.h;
|
|
|
+ if (win->flags & NK_WINDOW_CLOSABLE) {
|
|
|
+ nk_flags ws = 0;
|
|
|
+ if (style->window.header.align == NK_HEADER_RIGHT) {
|
|
|
+ button.x = (header.w + header.x) - (button.w + style->window.header.padding.x);
|
|
|
+ header.w -= button.w + style->window.header.spacing.x + style->window.header.padding.x;
|
|
|
+ } else {
|
|
|
+ button.x = header.x + style->window.header.padding.x;
|
|
|
+ header.x += button.w + style->window.header.spacing.x + style->window.header.padding.x;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nk_do_button_symbol(&ws, &win->buffer, button,
|
|
|
+ style->window.header.close_symbol, NK_BUTTON_DEFAULT,
|
|
|
+ &style->window.header.close_button, in, style->font) && !(win->flags & NK_WINDOW_ROM))
|
|
|
+ {
|
|
|
+ layout->flags |= NK_WINDOW_HIDDEN;
|
|
|
+ layout->flags &= (nk_flags)~NK_WINDOW_MINIMIZED;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* window minimize button */
|
|
|
+ if (win->flags & NK_WINDOW_MINIMIZABLE) {
|
|
|
+ nk_flags ws = 0;
|
|
|
+ if (style->window.header.align == NK_HEADER_RIGHT) {
|
|
|
+ button.x = (header.w + header.x) - button.w;
|
|
|
+ if (!(win->flags & NK_WINDOW_CLOSABLE)) {
|
|
|
+ button.x -= style->window.header.padding.x;
|
|
|
+ header.w -= style->window.header.padding.x;
|
|
|
+ }
|
|
|
+ header.w -= button.w + style->window.header.spacing.x;
|
|
|
+ } else {
|
|
|
+ button.x = header.x;
|
|
|
+ header.x += button.w + style->window.header.spacing.x + style->window.header.padding.x;
|
|
|
+ }
|
|
|
+ if (nk_do_button_symbol(&ws, &win->buffer, button, (layout->flags & NK_WINDOW_MINIMIZED)?
|
|
|
+ style->window.header.maximize_symbol: style->window.header.minimize_symbol,
|
|
|
+ NK_BUTTON_DEFAULT, &style->window.header.minimize_button, in, style->font) && !(win->flags & NK_WINDOW_ROM))
|
|
|
+ layout->flags = (layout->flags & NK_WINDOW_MINIMIZED) ?
|
|
|
+ layout->flags & (nk_flags)~NK_WINDOW_MINIMIZED:
|
|
|
+ layout->flags | NK_WINDOW_MINIMIZED;
|
|
|
+ }}
|
|
|
+
|
|
|
+ {/* window header title */
|
|
|
+ int text_len = nk_strlen(title);
|
|
|
+ struct nk_rect label = {0,0,0,0};
|
|
|
+ float t = font->width(font->userdata, font->height, title, text_len);
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+
|
|
|
+ label.x = header.x + style->window.header.padding.x;
|
|
|
+ label.x += style->window.header.label_padding.x;
|
|
|
+ label.y = header.y + style->window.header.label_padding.y;
|
|
|
+ label.h = font->height + 2 * style->window.header.label_padding.y;
|
|
|
+ label.w = t + 2 * style->window.header.spacing.x;
|
|
|
+ label.w = NK_CLAMP(0, label.w, header.x + header.w - label.x);
|
|
|
+ nk_widget_text(out, label,(const char*)title, text_len, &text, NK_TEXT_LEFT, font);}
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw window background */
|
|
|
+ if (!(layout->flags & NK_WINDOW_MINIMIZED) && !(layout->flags & NK_WINDOW_DYNAMIC)) {
|
|
|
+ struct nk_rect body;
|
|
|
+ body.x = win->bounds.x;
|
|
|
+ body.w = win->bounds.w;
|
|
|
+ body.y = (win->bounds.y + layout->header_height);
|
|
|
+ body.h = (win->bounds.h - layout->header_height);
|
|
|
+ if (style->window.fixed_background.type == NK_STYLE_ITEM_IMAGE)
|
|
|
+ nk_draw_image(out, body, &style->window.fixed_background.data.image, nk_white);
|
|
|
+ else nk_fill_rect(out, body, 0, style->window.fixed_background.data.color);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set clipping rectangle */
|
|
|
+ {struct nk_rect clip;
|
|
|
+ layout->clip = layout->bounds;
|
|
|
+ nk_unify(&clip, &win->buffer.clip, layout->clip.x, layout->clip.y,
|
|
|
+ layout->clip.x + layout->clip.w, layout->clip.y + layout->clip.h);
|
|
|
+ nk_push_scissor(out, clip);
|
|
|
+ layout->clip = clip;}
|
|
|
+ return !(layout->flags & NK_WINDOW_HIDDEN) && !(layout->flags & NK_WINDOW_MINIMIZED);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_panel_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_input *in;
|
|
|
+ struct nk_window *window;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+ struct nk_command_buffer *out;
|
|
|
+
|
|
|
+ struct nk_vec2 scrollbar_size;
|
|
|
+ struct nk_vec2 panel_padding;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ window = ctx->current;
|
|
|
+ layout = window->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+ out = &window->buffer;
|
|
|
+ in = (layout->flags & NK_WINDOW_ROM || layout->flags & NK_WINDOW_NO_INPUT) ? 0 :&ctx->input;
|
|
|
+ if (!nk_panel_is_sub(layout->type))
|
|
|
+ nk_push_scissor(out, nk_null_rect);
|
|
|
+
|
|
|
+ /* cache configuration data */
|
|
|
+ scrollbar_size = style->window.scrollbar_size;
|
|
|
+ panel_padding = nk_panel_get_padding(style, layout->type);
|
|
|
+
|
|
|
+ /* update the current cursor Y-position to point over the last added widget */
|
|
|
+ layout->at_y += layout->row.height;
|
|
|
+
|
|
|
+ /* dynamic panels */
|
|
|
+ if (layout->flags & NK_WINDOW_DYNAMIC && !(layout->flags & NK_WINDOW_MINIMIZED))
|
|
|
+ {
|
|
|
+ /* update panel height to fit dynamic growth */
|
|
|
+ struct nk_rect empty_space;
|
|
|
+ if (layout->at_y < (layout->bounds.y + layout->bounds.h))
|
|
|
+ layout->bounds.h = layout->at_y - layout->bounds.y;
|
|
|
+
|
|
|
+ /* fill top empty space */
|
|
|
+ empty_space.x = window->bounds.x;
|
|
|
+ empty_space.y = layout->bounds.y;
|
|
|
+ empty_space.h = panel_padding.y;
|
|
|
+ empty_space.w = window->bounds.w;
|
|
|
+ nk_fill_rect(out, empty_space, 0, style->window.background);
|
|
|
+
|
|
|
+ /* fill left empty space */
|
|
|
+ empty_space.x = window->bounds.x;
|
|
|
+ empty_space.y = layout->bounds.y;
|
|
|
+ empty_space.w = panel_padding.x + layout->border;
|
|
|
+ empty_space.h = layout->bounds.h;
|
|
|
+ nk_fill_rect(out, empty_space, 0, style->window.background);
|
|
|
+
|
|
|
+ /* fill right empty space */
|
|
|
+ empty_space.x = layout->bounds.x + layout->bounds.w - layout->border;
|
|
|
+ empty_space.y = layout->bounds.y;
|
|
|
+ empty_space.w = panel_padding.x + layout->border;
|
|
|
+ empty_space.h = layout->bounds.h;
|
|
|
+ if (*layout->offset_y == 0 && !(layout->flags & NK_WINDOW_NO_SCROLLBAR))
|
|
|
+ empty_space.w += scrollbar_size.x;
|
|
|
+ nk_fill_rect(out, empty_space, 0, style->window.background);
|
|
|
+
|
|
|
+ /* fill bottom empty space */
|
|
|
+ if (*layout->offset_x != 0 && !(layout->flags & NK_WINDOW_NO_SCROLLBAR)) {
|
|
|
+ empty_space.x = window->bounds.x;
|
|
|
+ empty_space.y = layout->bounds.y + layout->bounds.h;
|
|
|
+ empty_space.w = window->bounds.w;
|
|
|
+ empty_space.h = scrollbar_size.y;
|
|
|
+ nk_fill_rect(out, empty_space, 0, style->window.background);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* scrollbars */
|
|
|
+ if (!(layout->flags & NK_WINDOW_NO_SCROLLBAR) &&
|
|
|
+ !(layout->flags & NK_WINDOW_MINIMIZED) &&
|
|
|
+ window->scrollbar_hiding_timer < NK_SCROLLBAR_HIDING_TIMEOUT)
|
|
|
+ {
|
|
|
+ struct nk_rect scroll;
|
|
|
+ int scroll_has_scrolling;
|
|
|
+ float scroll_target;
|
|
|
+ float scroll_offset;
|
|
|
+ float scroll_step;
|
|
|
+ float scroll_inc;
|
|
|
+
|
|
|
+ /* mouse wheel scrolling */
|
|
|
+ if (nk_panel_is_sub(layout->type))
|
|
|
+ {
|
|
|
+ /* sub-window mouse wheel scrolling */
|
|
|
+ struct nk_window *root_window = window;
|
|
|
+ struct nk_panel *root_panel = window->layout;
|
|
|
+ while (root_panel->parent)
|
|
|
+ root_panel = root_panel->parent;
|
|
|
+ while (root_window->parent)
|
|
|
+ root_window = root_window->parent;
|
|
|
+
|
|
|
+ /* only allow scrolling if parent window is active */
|
|
|
+ scroll_has_scrolling = 0;
|
|
|
+ if ((root_window == ctx->active) && layout->has_scrolling) {
|
|
|
+ /* and panel is being hovered and inside clip rect*/
|
|
|
+ if (nk_input_is_mouse_hovering_rect(in, layout->bounds) &&
|
|
|
+ NK_INTERSECT(layout->bounds.x, layout->bounds.y, layout->bounds.w, layout->bounds.h,
|
|
|
+ root_panel->clip.x, root_panel->clip.y, root_panel->clip.w, root_panel->clip.h))
|
|
|
+ {
|
|
|
+ /* deactivate all parent scrolling */
|
|
|
+ root_panel = window->layout;
|
|
|
+ while (root_panel->parent) {
|
|
|
+ root_panel->has_scrolling = nk_false;
|
|
|
+ root_panel = root_panel->parent;
|
|
|
+ }
|
|
|
+ root_panel->has_scrolling = nk_false;
|
|
|
+ scroll_has_scrolling = nk_true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (!nk_panel_is_sub(layout->type)) {
|
|
|
+ /* window mouse wheel scrolling */
|
|
|
+ scroll_has_scrolling = (window == ctx->active) && layout->has_scrolling;
|
|
|
+ if (in && (in->mouse.scroll_delta.y > 0 || in->mouse.scroll_delta.x > 0) && scroll_has_scrolling)
|
|
|
+ window->scrolled = nk_true;
|
|
|
+ else window->scrolled = nk_false;
|
|
|
+ } else scroll_has_scrolling = nk_false;
|
|
|
+
|
|
|
+ {
|
|
|
+ /* vertical scrollbar */
|
|
|
+ nk_flags state = 0;
|
|
|
+ scroll.x = layout->bounds.x + layout->bounds.w + panel_padding.x;
|
|
|
+ scroll.y = layout->bounds.y;
|
|
|
+ scroll.w = scrollbar_size.x;
|
|
|
+ scroll.h = layout->bounds.h;
|
|
|
+
|
|
|
+ scroll_offset = (float)*layout->offset_y;
|
|
|
+ scroll_step = scroll.h * 0.10f;
|
|
|
+ scroll_inc = scroll.h * 0.01f;
|
|
|
+ scroll_target = (float)(int)(layout->at_y - scroll.y);
|
|
|
+ scroll_offset = nk_do_scrollbarv(&state, out, scroll, scroll_has_scrolling,
|
|
|
+ scroll_offset, scroll_target, scroll_step, scroll_inc,
|
|
|
+ &ctx->style.scrollv, in, style->font);
|
|
|
+ *layout->offset_y = (nk_uint)scroll_offset;
|
|
|
+ if (in && scroll_has_scrolling)
|
|
|
+ in->mouse.scroll_delta.y = 0;
|
|
|
+ }
|
|
|
+ {
|
|
|
+ /* horizontal scrollbar */
|
|
|
+ nk_flags state = 0;
|
|
|
+ scroll.x = layout->bounds.x;
|
|
|
+ scroll.y = layout->bounds.y + layout->bounds.h;
|
|
|
+ scroll.w = layout->bounds.w;
|
|
|
+ scroll.h = scrollbar_size.y;
|
|
|
+
|
|
|
+ scroll_offset = (float)*layout->offset_x;
|
|
|
+ scroll_target = (float)(int)(layout->max_x - scroll.x);
|
|
|
+ scroll_step = layout->max_x * 0.05f;
|
|
|
+ scroll_inc = layout->max_x * 0.005f;
|
|
|
+ scroll_offset = nk_do_scrollbarh(&state, out, scroll, scroll_has_scrolling,
|
|
|
+ scroll_offset, scroll_target, scroll_step, scroll_inc,
|
|
|
+ &ctx->style.scrollh, in, style->font);
|
|
|
+ *layout->offset_x = (nk_uint)scroll_offset;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* hide scroll if no user input */
|
|
|
+ if (window->flags & NK_WINDOW_SCROLL_AUTO_HIDE) {
|
|
|
+ int has_input = ctx->input.mouse.delta.x != 0 || ctx->input.mouse.delta.y != 0 || ctx->input.mouse.scroll_delta.y != 0;
|
|
|
+ int is_window_hovered = nk_window_is_hovered(ctx);
|
|
|
+ int any_item_active = (ctx->last_widget_state & NK_WIDGET_STATE_MODIFIED);
|
|
|
+ if ((!has_input && is_window_hovered) || (!is_window_hovered && !any_item_active))
|
|
|
+ window->scrollbar_hiding_timer += ctx->delta_time_seconds;
|
|
|
+ else window->scrollbar_hiding_timer = 0;
|
|
|
+ } else window->scrollbar_hiding_timer = 0;
|
|
|
+
|
|
|
+ /* window border */
|
|
|
+ if (layout->flags & NK_WINDOW_BORDER)
|
|
|
+ {
|
|
|
+ struct nk_color border_color = nk_panel_get_border_color(style, layout->type);
|
|
|
+ const float padding_y = (layout->flags & NK_WINDOW_MINIMIZED) ?
|
|
|
+ style->window.border + window->bounds.y + layout->header_height:
|
|
|
+ (layout->flags & NK_WINDOW_DYNAMIC)?
|
|
|
+ layout->bounds.y + layout->bounds.h + layout->footer_height:
|
|
|
+ window->bounds.y + window->bounds.h;
|
|
|
+
|
|
|
+ /* draw border top */
|
|
|
+ nk_stroke_line(out,window->bounds.x,window->bounds.y,
|
|
|
+ window->bounds.x + window->bounds.w, window->bounds.y,
|
|
|
+ layout->border, border_color);
|
|
|
+
|
|
|
+ /* draw bottom border */
|
|
|
+ nk_stroke_line(out, window->bounds.x, padding_y,
|
|
|
+ window->bounds.x + window->bounds.w, padding_y, layout->border, border_color);
|
|
|
+
|
|
|
+ /* draw left border */
|
|
|
+ nk_stroke_line(out, window->bounds.x + layout->border*0.5f,
|
|
|
+ window->bounds.y, window->bounds.x + layout->border*0.5f,
|
|
|
+ padding_y, layout->border, border_color);
|
|
|
+
|
|
|
+ /* draw right border */
|
|
|
+ nk_stroke_line(out, window->bounds.x + window->bounds.w - layout->border*0.5f,
|
|
|
+ window->bounds.y, window->bounds.x + window->bounds.w - layout->border*0.5f,
|
|
|
+ padding_y, layout->border, border_color);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* scaler */
|
|
|
+ if ((layout->flags & NK_WINDOW_SCALABLE) && in && !(layout->flags & NK_WINDOW_MINIMIZED))
|
|
|
+ {
|
|
|
+ /* calculate scaler bounds */
|
|
|
+ struct nk_rect scaler;
|
|
|
+ scaler.w = scrollbar_size.x;
|
|
|
+ scaler.h = scrollbar_size.y;
|
|
|
+ scaler.y = layout->bounds.y + layout->bounds.h;
|
|
|
+ if (layout->flags & NK_WINDOW_SCALE_LEFT)
|
|
|
+ scaler.x = layout->bounds.x - panel_padding.x * 0.5f;
|
|
|
+ else scaler.x = layout->bounds.x + layout->bounds.w + panel_padding.x;
|
|
|
+ if (layout->flags & NK_WINDOW_NO_SCROLLBAR)
|
|
|
+ scaler.x -= scaler.w;
|
|
|
+
|
|
|
+ /* draw scaler */
|
|
|
+ {const struct nk_style_item *item = &style->window.scaler;
|
|
|
+ if (item->type == NK_STYLE_ITEM_IMAGE)
|
|
|
+ nk_draw_image(out, scaler, &item->data.image, nk_white);
|
|
|
+ else {
|
|
|
+ if (layout->flags & NK_WINDOW_SCALE_LEFT) {
|
|
|
+ nk_fill_triangle(out, scaler.x, scaler.y, scaler.x,
|
|
|
+ scaler.y + scaler.h, scaler.x + scaler.w,
|
|
|
+ scaler.y + scaler.h, item->data.color);
|
|
|
+ } else {
|
|
|
+ nk_fill_triangle(out, scaler.x + scaler.w, scaler.y, scaler.x + scaler.w,
|
|
|
+ scaler.y + scaler.h, scaler.x, scaler.y + scaler.h, item->data.color);
|
|
|
+ }
|
|
|
+ }}
|
|
|
+
|
|
|
+ /* do window scaling */
|
|
|
+ if (!(window->flags & NK_WINDOW_ROM)) {
|
|
|
+ struct nk_vec2 window_size = style->window.min_size;
|
|
|
+ int left_mouse_down = in->mouse.buttons[NK_BUTTON_LEFT].down;
|
|
|
+ int left_mouse_click_in_scaler = nk_input_has_mouse_click_down_in_rect(in,
|
|
|
+ NK_BUTTON_LEFT, scaler, nk_true);
|
|
|
+
|
|
|
+ if (left_mouse_down && left_mouse_click_in_scaler) {
|
|
|
+ float delta_x = in->mouse.delta.x;
|
|
|
+ if (layout->flags & NK_WINDOW_SCALE_LEFT) {
|
|
|
+ delta_x = -delta_x;
|
|
|
+ window->bounds.x += in->mouse.delta.x;
|
|
|
+ }
|
|
|
+ /* dragging in x-direction */
|
|
|
+ if (window->bounds.w + delta_x >= window_size.x) {
|
|
|
+ if ((delta_x < 0) || (delta_x > 0 && in->mouse.pos.x >= scaler.x)) {
|
|
|
+ window->bounds.w = window->bounds.w + delta_x;
|
|
|
+ scaler.x += in->mouse.delta.x;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* dragging in y-direction (only possible if static window) */
|
|
|
+ if (!(layout->flags & NK_WINDOW_DYNAMIC)) {
|
|
|
+ if (window_size.y < window->bounds.h + in->mouse.delta.y) {
|
|
|
+ if ((in->mouse.delta.y < 0) || (in->mouse.delta.y > 0 && in->mouse.pos.y >= scaler.y)) {
|
|
|
+ window->bounds.h = window->bounds.h + in->mouse.delta.y;
|
|
|
+ scaler.y += in->mouse.delta.y;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT];
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = scaler.x + scaler.w/2.0f;
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.y = scaler.y + scaler.h/2.0f;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!nk_panel_is_sub(layout->type)) {
|
|
|
+ /* window is hidden so clear command buffer */
|
|
|
+ if (layout->flags & NK_WINDOW_HIDDEN)
|
|
|
+ nk_command_buffer_reset(&window->buffer);
|
|
|
+ /* window is visible and not tab */
|
|
|
+ else nk_finish(ctx, window);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* NK_WINDOW_REMOVE_ROM flag was set so remove NK_WINDOW_ROM */
|
|
|
+ if (layout->flags & NK_WINDOW_REMOVE_ROM) {
|
|
|
+ layout->flags &= ~(nk_flags)NK_WINDOW_ROM;
|
|
|
+ layout->flags &= ~(nk_flags)NK_WINDOW_REMOVE_ROM;
|
|
|
+ }
|
|
|
+ window->flags = layout->flags;
|
|
|
+
|
|
|
+ /* property garbage collector */
|
|
|
+ if (window->property.active && window->property.old != window->property.seq &&
|
|
|
+ window->property.active == window->property.prev) {
|
|
|
+ nk_zero(&window->property, sizeof(window->property));
|
|
|
+ } else {
|
|
|
+ window->property.old = window->property.seq;
|
|
|
+ window->property.prev = window->property.active;
|
|
|
+ window->property.seq = 0;
|
|
|
+ }
|
|
|
+ /* edit garbage collector */
|
|
|
+ if (window->edit.active && window->edit.old != window->edit.seq &&
|
|
|
+ window->edit.active == window->edit.prev) {
|
|
|
+ nk_zero(&window->edit, sizeof(window->edit));
|
|
|
+ } else {
|
|
|
+ window->edit.old = window->edit.seq;
|
|
|
+ window->edit.prev = window->edit.active;
|
|
|
+ window->edit.seq = 0;
|
|
|
+ }
|
|
|
+ /* contextual garbage collector */
|
|
|
+ if (window->popup.active_con && window->popup.con_old != window->popup.con_count) {
|
|
|
+ window->popup.con_count = 0;
|
|
|
+ window->popup.con_old = 0;
|
|
|
+ window->popup.active_con = 0;
|
|
|
+ } else {
|
|
|
+ window->popup.con_old = window->popup.con_count;
|
|
|
+ window->popup.con_count = 0;
|
|
|
+ }
|
|
|
+ window->popup.combo_count = 0;
|
|
|
+ /* helper to make sure you have a 'nk_tree_push' for every 'nk_tree_pop' */
|
|
|
+ NK_ASSERT(!layout->row.tree_depth);
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * PAGE ELEMENT
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+NK_INTERN struct nk_page_element*
|
|
|
+nk_create_page_element(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_page_element *elem;
|
|
|
+ if (ctx->freelist) {
|
|
|
+ /* unlink page element from free list */
|
|
|
+ elem = ctx->freelist;
|
|
|
+ ctx->freelist = elem->next;
|
|
|
+ } else if (ctx->use_pool) {
|
|
|
+ /* allocate page element from memory pool */
|
|
|
+ elem = nk_pool_alloc(&ctx->pool);
|
|
|
+ NK_ASSERT(elem);
|
|
|
+ if (!elem) return 0;
|
|
|
+ } else {
|
|
|
+ /* allocate new page element from back of fixed size memory buffer */
|
|
|
+ NK_STORAGE const nk_size size = sizeof(struct nk_page_element);
|
|
|
+ NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_page_element);
|
|
|
+ elem = (struct nk_page_element*)nk_buffer_alloc(&ctx->memory, NK_BUFFER_BACK, size, align);
|
|
|
+ NK_ASSERT(elem);
|
|
|
+ if (!elem) return 0;
|
|
|
+ }
|
|
|
+ nk_zero_struct(*elem);
|
|
|
+ elem->next = 0;
|
|
|
+ elem->prev = 0;
|
|
|
+ return elem;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_link_page_element_into_freelist(struct nk_context *ctx,
|
|
|
+ struct nk_page_element *elem)
|
|
|
+{
|
|
|
+ /* link table into freelist */
|
|
|
+ if (!ctx->freelist) {
|
|
|
+ ctx->freelist = elem;
|
|
|
+ } else {
|
|
|
+ elem->next = ctx->freelist;
|
|
|
+ ctx->freelist = elem;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_free_page_element(struct nk_context *ctx, struct nk_page_element *elem)
|
|
|
+{
|
|
|
+ /* we have a pool so just add to free list */
|
|
|
+ if (ctx->use_pool) {
|
|
|
+ nk_link_page_element_into_freelist(ctx, elem);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ /* if possible remove last element from back of fixed memory buffer */
|
|
|
+ {void *elem_end = (void*)(elem + 1);
|
|
|
+ void *buffer_end = (nk_byte*)ctx->memory.memory.ptr + ctx->memory.size;
|
|
|
+ if (elem_end == buffer_end)
|
|
|
+ ctx->memory.size -= sizeof(struct nk_page_element);
|
|
|
+ else nk_link_page_element_into_freelist(ctx, elem);}
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * PANEL
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+NK_INTERN void*
|
|
|
+nk_create_panel(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_page_element *elem;
|
|
|
+ elem = nk_create_page_element(ctx);
|
|
|
+ if (!elem) return 0;
|
|
|
+ nk_zero_struct(*elem);
|
|
|
+ return &elem->data.pan;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_free_panel(struct nk_context *ctx, struct nk_panel *pan)
|
|
|
+{
|
|
|
+ union nk_page_data *pd = NK_CONTAINER_OF(pan, union nk_page_data, pan);
|
|
|
+ struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data);
|
|
|
+ nk_free_page_element(ctx, pe);
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * TABLES
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+NK_INTERN struct nk_table*
|
|
|
+nk_create_table(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_page_element *elem;
|
|
|
+ elem = nk_create_page_element(ctx);
|
|
|
+ if (!elem) return 0;
|
|
|
+ nk_zero_struct(*elem);
|
|
|
+ return &elem->data.tbl;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_free_table(struct nk_context *ctx, struct nk_table *tbl)
|
|
|
+{
|
|
|
+ union nk_page_data *pd = NK_CONTAINER_OF(tbl, union nk_page_data, tbl);
|
|
|
+ struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data);
|
|
|
+ nk_free_page_element(ctx, pe);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_push_table(struct nk_window *win, struct nk_table *tbl)
|
|
|
+{
|
|
|
+ if (!win->tables) {
|
|
|
+ win->tables = tbl;
|
|
|
+ tbl->next = 0;
|
|
|
+ tbl->prev = 0;
|
|
|
+ tbl->size = 0;
|
|
|
+ win->table_count = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ win->tables->prev = tbl;
|
|
|
+ tbl->next = win->tables;
|
|
|
+ tbl->prev = 0;
|
|
|
+ tbl->size = 0;
|
|
|
+ win->tables = tbl;
|
|
|
+ win->table_count++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_remove_table(struct nk_window *win, struct nk_table *tbl)
|
|
|
+{
|
|
|
+ if (win->tables == tbl)
|
|
|
+ win->tables = tbl->next;
|
|
|
+ if (tbl->next)
|
|
|
+ tbl->next->prev = tbl->prev;
|
|
|
+ if (tbl->prev)
|
|
|
+ tbl->prev->next = tbl->next;
|
|
|
+ tbl->next = 0;
|
|
|
+ tbl->prev = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_uint*
|
|
|
+nk_add_value(struct nk_context *ctx, struct nk_window *win,
|
|
|
+ nk_hash name, nk_uint value)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ if (!win || !ctx) return 0;
|
|
|
+ if (!win->tables || win->tables->size >= NK_VALUE_PAGE_CAPACITY) {
|
|
|
+ struct nk_table *tbl = nk_create_table(ctx);
|
|
|
+ NK_ASSERT(tbl);
|
|
|
+ if (!tbl) return 0;
|
|
|
+ nk_push_table(win, tbl);
|
|
|
+ }
|
|
|
+ win->tables->seq = win->seq;
|
|
|
+ win->tables->keys[win->tables->size] = name;
|
|
|
+ win->tables->values[win->tables->size] = value;
|
|
|
+ return &win->tables->values[win->tables->size++];
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_uint*
|
|
|
+nk_find_value(struct nk_window *win, nk_hash name)
|
|
|
+{
|
|
|
+ struct nk_table *iter = win->tables;
|
|
|
+ while (iter) {
|
|
|
+ unsigned int i = 0;
|
|
|
+ unsigned int size = iter->size;
|
|
|
+ for (i = 0; i < size; ++i) {
|
|
|
+ if (iter->keys[i] == name) {
|
|
|
+ iter->seq = win->seq;
|
|
|
+ return &iter->values[i];
|
|
|
+ }
|
|
|
+ } size = NK_VALUE_PAGE_CAPACITY;
|
|
|
+ iter = iter->next;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* ----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * WINDOW
|
|
|
+ *
|
|
|
+ * ---------------------------------------------------------------*/
|
|
|
+NK_INTERN void*
|
|
|
+nk_create_window(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_page_element *elem;
|
|
|
+ elem = nk_create_page_element(ctx);
|
|
|
+ if (!elem) return 0;
|
|
|
+ elem->data.win.seq = ctx->seq;
|
|
|
+ return &elem->data.win;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_free_window(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ /* unlink windows from list */
|
|
|
+ struct nk_table *it = win->tables;
|
|
|
+ if (win->popup.win) {
|
|
|
+ nk_free_window(ctx, win->popup.win);
|
|
|
+ win->popup.win = 0;
|
|
|
+ }
|
|
|
+ win->next = 0;
|
|
|
+ win->prev = 0;
|
|
|
+
|
|
|
+ while (it) {
|
|
|
+ /*free window state tables */
|
|
|
+ struct nk_table *n = it->next;
|
|
|
+ nk_remove_table(win, it);
|
|
|
+ nk_free_table(ctx, it);
|
|
|
+ if (it == win->tables)
|
|
|
+ win->tables = n;
|
|
|
+ it = n;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* link windows into freelist */
|
|
|
+ {union nk_page_data *pd = NK_CONTAINER_OF(win, union nk_page_data, win);
|
|
|
+ struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data);
|
|
|
+ nk_free_page_element(ctx, pe);}
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_window*
|
|
|
+nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name)
|
|
|
+{
|
|
|
+ struct nk_window *iter;
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter) {
|
|
|
+ NK_ASSERT(iter != iter->next);
|
|
|
+ if (iter->name == hash) {
|
|
|
+ int max_len = nk_strlen(iter->name_string);
|
|
|
+ if (!nk_stricmpn(iter->name_string, name, max_len))
|
|
|
+ return iter;
|
|
|
+ }
|
|
|
+ iter = iter->next;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+enum nk_window_insert_location {
|
|
|
+ NK_INSERT_BACK, /* inserts window into the back of list (front of screen) */
|
|
|
+ NK_INSERT_FRONT /* inserts window into the front of list (back of screen) */
|
|
|
+};
|
|
|
+NK_INTERN void
|
|
|
+nk_insert_window(struct nk_context *ctx, struct nk_window *win,
|
|
|
+ enum nk_window_insert_location loc)
|
|
|
+{
|
|
|
+ const struct nk_window *iter;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(win);
|
|
|
+ if (!win || !ctx) return;
|
|
|
+
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter) {
|
|
|
+ NK_ASSERT(iter != iter->next);
|
|
|
+ NK_ASSERT(iter != win);
|
|
|
+ if (iter == win) return;
|
|
|
+ iter = iter->next;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!ctx->begin) {
|
|
|
+ win->next = 0;
|
|
|
+ win->prev = 0;
|
|
|
+ ctx->begin = win;
|
|
|
+ ctx->end = win;
|
|
|
+ ctx->count = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (loc == NK_INSERT_BACK) {
|
|
|
+ struct nk_window *end;
|
|
|
+ end = ctx->end;
|
|
|
+ end->flags |= NK_WINDOW_ROM;
|
|
|
+ end->next = win;
|
|
|
+ win->prev = ctx->end;
|
|
|
+ win->next = 0;
|
|
|
+ ctx->end = win;
|
|
|
+ ctx->active = ctx->end;
|
|
|
+ ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
|
|
|
+ } else {
|
|
|
+ ctx->end->flags |= NK_WINDOW_ROM;
|
|
|
+ ctx->begin->prev = win;
|
|
|
+ win->next = ctx->begin;
|
|
|
+ win->prev = 0;
|
|
|
+ ctx->begin = win;
|
|
|
+ ctx->begin->flags &= ~(nk_flags)NK_WINDOW_ROM;
|
|
|
+ }
|
|
|
+ ctx->count++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_remove_window(struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ if (win == ctx->begin || win == ctx->end) {
|
|
|
+ if (win == ctx->begin) {
|
|
|
+ ctx->begin = win->next;
|
|
|
+ if (win->next)
|
|
|
+ win->next->prev = 0;
|
|
|
+ }
|
|
|
+ if (win == ctx->end) {
|
|
|
+ ctx->end = win->prev;
|
|
|
+ if (win->prev)
|
|
|
+ win->prev->next = 0;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (win->next)
|
|
|
+ win->next->prev = win->prev;
|
|
|
+ if (win->prev)
|
|
|
+ win->prev->next = win->next;
|
|
|
+ }
|
|
|
+ if (win == ctx->active || !ctx->active) {
|
|
|
+ ctx->active = ctx->end;
|
|
|
+ if (ctx->end)
|
|
|
+ ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
|
|
|
+ }
|
|
|
+ win->next = 0;
|
|
|
+ win->prev = 0;
|
|
|
+ ctx->count--;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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_begin_titled(struct nk_context *ctx, const char *name, const char *title,
|
|
|
+ struct nk_rect bounds, nk_flags flags)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ nk_hash title_hash;
|
|
|
+ int title_len;
|
|
|
+ int ret = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+ NK_ASSERT(title);
|
|
|
+ NK_ASSERT(ctx->style.font && ctx->style.font->width && "if this triggers you forgot to add a font");
|
|
|
+ NK_ASSERT(!ctx->current && "if this triggers you missed a `nk_end` call");
|
|
|
+ if (!ctx || ctx->current || !title || !name)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* find or create window */
|
|
|
+ style = &ctx->style;
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) {
|
|
|
+ /* create new window */
|
|
|
+ nk_size name_length = (nk_size)nk_strlen(name);
|
|
|
+ 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 = title_hash;
|
|
|
+ name_length = NK_MIN(name_length, NK_WINDOW_MAX_NAME-1);
|
|
|
+ NK_MEMCPY(win->name_string, name, name_length);
|
|
|
+ win->name_string[name_length] = 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;
|
|
|
+ }
|
|
|
+ if (win->flags & NK_WINDOW_HIDDEN) {
|
|
|
+ ctx->current = win;
|
|
|
+ win->layout = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* window overlapping */
|
|
|
+ if (!(win->flags & NK_WINDOW_HIDDEN) && !(win->flags & NK_WINDOW_NO_INPUT))
|
|
|
+ {
|
|
|
+ int inpanel, ishovered;
|
|
|
+ const 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 */
|
|
|
+ nk_start(ctx, win);
|
|
|
+ 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) || !(iter->flags & NK_WINDOW_BACKGROUND)))
|
|
|
+ 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->flags & NK_WINDOW_BACKGROUND)) {
|
|
|
+ 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 && 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;
|
|
|
+ ret = nk_panel_begin(ctx, title, NK_PANEL_WINDOW);
|
|
|
+ win->layout->offset_x = &win->scrollbar.x;
|
|
|
+ win->layout->offset_y = &win->scrollbar.y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_panel *layout;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current && "if this triggers you forgot to call `nk_begin`");
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return;
|
|
|
+
|
|
|
+ layout = ctx->current->layout;
|
|
|
+ if (!layout || (layout->type == NK_PANEL_WINDOW && (ctx->current->flags & NK_WINDOW_HIDDEN))) {
|
|
|
+ ctx->current = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ nk_panel_end(ctx);
|
|
|
+ nk_free_panel(ctx, ctx->current->layout);
|
|
|
+ ctx->current = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_window_get_bounds(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return nk_rect(0,0,0,0);
|
|
|
+ return ctx->current->bounds;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_window_get_position(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return nk_vec2(0,0);
|
|
|
+ return nk_vec2(ctx->current->bounds.x, ctx->current->bounds.y);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_window_get_size(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return nk_vec2(0,0);
|
|
|
+ return nk_vec2(ctx->current->bounds.w, ctx->current->bounds.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_window_get_width(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return ctx->current->bounds.w;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_window_get_height(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return ctx->current->bounds.h;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_window_get_content_region(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return nk_rect(0,0,0,0);
|
|
|
+ return ctx->current->layout->clip;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_window_get_content_region_min(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current) return nk_vec2(0,0);
|
|
|
+ return nk_vec2(ctx->current->layout->clip.x, ctx->current->layout->clip.y);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_window_get_content_region_max(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current) return nk_vec2(0,0);
|
|
|
+ return nk_vec2(ctx->current->layout->clip.x + ctx->current->layout->clip.w,
|
|
|
+ ctx->current->layout->clip.y + ctx->current->layout->clip.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_window_get_content_region_size(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current) return nk_vec2(0,0);
|
|
|
+ return nk_vec2(ctx->current->layout->clip.w, ctx->current->layout->clip.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_command_buffer*
|
|
|
+nk_window_get_canvas(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return &ctx->current->buffer;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_panel*
|
|
|
+nk_window_get_panel(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return ctx->current->layout;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_has_focus(const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return ctx->current == ctx->active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_hovered(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return 0;
|
|
|
+ return nk_input_is_mouse_hovering_rect(&ctx->input, ctx->current->bounds);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_any_hovered(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *iter;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ iter = ctx->begin;
|
|
|
+ while (iter) {
|
|
|
+ /* check if window is being hovered */
|
|
|
+ if (iter->flags & NK_WINDOW_MINIMIZED) {
|
|
|
+ struct nk_rect header = iter->bounds;
|
|
|
+ header.h = ctx->style.font->height + 2 * ctx->style.window.header.padding.y;
|
|
|
+ if (nk_input_is_mouse_hovering_rect(&ctx->input, header))
|
|
|
+ return 1;
|
|
|
+ } else if (nk_input_is_mouse_hovering_rect(&ctx->input, iter->bounds)) {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ /* check if window popup is being hovered */
|
|
|
+ if (iter->popup.active && iter->popup.win && nk_input_is_mouse_hovering_rect(&ctx->input, iter->popup.win->bounds))
|
|
|
+ return 1;
|
|
|
+ iter = iter->next;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_item_is_any_active(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ int any_hovered = nk_window_is_any_hovered(ctx);
|
|
|
+ int any_active = (ctx->last_widget_state & NK_WIDGET_STATE_MODIFIED);
|
|
|
+ return any_hovered || any_active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_collapsed(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return 0;
|
|
|
+ return win->flags & NK_WINDOW_MINIMIZED;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_closed(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 1;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return 1;
|
|
|
+ return (win->flags & NK_WINDOW_CLOSED);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_hidden(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 1;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return 1;
|
|
|
+ return (win->flags & NK_WINDOW_HIDDEN);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_window_is_active(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return 0;
|
|
|
+ return win == ctx->active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_window*
|
|
|
+nk_window_find(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ return nk_find_window(ctx, title_hash, name);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_close(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ win = nk_window_find(ctx, name);
|
|
|
+ if (!win) return;
|
|
|
+ NK_ASSERT(ctx->current != win && "You cannot close a currently active window");
|
|
|
+ if (ctx->current == win) return;
|
|
|
+ win->flags |= NK_WINDOW_HIDDEN;
|
|
|
+ win->flags |= NK_WINDOW_CLOSED;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_set_bounds(struct nk_context *ctx, struct nk_rect bounds)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx); NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+ ctx->current->bounds = bounds;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_set_position(struct nk_context *ctx, struct nk_vec2 pos)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx); NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+ ctx->current->bounds.x = pos.x;
|
|
|
+ ctx->current->bounds.y = pos.y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_set_size(struct nk_context *ctx, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx); NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+ ctx->current->bounds.w = size.x;
|
|
|
+ ctx->current->bounds.h = size.y;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_collapse(struct nk_context *ctx, const char *name,
|
|
|
+ enum nk_collapse_states c)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return;
|
|
|
+ if (c == NK_MINIMIZED)
|
|
|
+ win->flags |= NK_WINDOW_MINIMIZED;
|
|
|
+ else win->flags &= ~(nk_flags)NK_WINDOW_MINIMIZED;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_collapse_if(struct nk_context *ctx, const char *name,
|
|
|
+ enum nk_collapse_states c, int cond)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx || !cond) return;
|
|
|
+ nk_window_collapse(ctx, name, c);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_show(struct nk_context *ctx, const char *name, enum nk_show_states s)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (!win) return;
|
|
|
+ if (s == NK_HIDDEN) {
|
|
|
+ win->flags |= NK_WINDOW_HIDDEN;
|
|
|
+ } else win->flags &= ~(nk_flags)NK_WINDOW_HIDDEN;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_show_if(struct nk_context *ctx, const char *name,
|
|
|
+ enum nk_show_states s, int cond)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx || !cond) return;
|
|
|
+ nk_window_show(ctx, name, s);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_window_set_focus(struct nk_context *ctx, const char *name)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+
|
|
|
+ title_len = (int)nk_strlen(name);
|
|
|
+ title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
|
|
|
+ win = nk_find_window(ctx, title_hash, name);
|
|
|
+ if (win && ctx->end != win) {
|
|
|
+ nk_remove_window(ctx, win);
|
|
|
+ nk_insert_window(ctx, win, NK_INSERT_BACK);
|
|
|
+ }
|
|
|
+ ctx->active = win;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * MENUBAR
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_menubar_begin(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_panel *layout;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ layout = ctx->current->layout;
|
|
|
+ NK_ASSERT(layout->at_y == layout->bounds.y);
|
|
|
+ /* if this assert triggers you allocated space between nk_begin and nk_menubar_begin.
|
|
|
+ If you want a menubar the first nuklear function after `nk_begin` has to be a
|
|
|
+ `nk_menubar_begin` call. Inside the menubar you then have to allocate space for
|
|
|
+ widgets (also supports multiple rows).
|
|
|
+ Example:
|
|
|
+ if (nk_begin(...)) {
|
|
|
+ nk_menubar_begin(...);
|
|
|
+ nk_layout_xxxx(...);
|
|
|
+ nk_button(...);
|
|
|
+ nk_layout_xxxx(...);
|
|
|
+ nk_button(...);
|
|
|
+ nk_menubar_end(...);
|
|
|
+ }
|
|
|
+ nk_end(...);
|
|
|
+ */
|
|
|
+ if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED)
|
|
|
+ return;
|
|
|
+
|
|
|
+ layout->menu.x = layout->at_x;
|
|
|
+ layout->menu.y = layout->at_y + layout->row.height;
|
|
|
+ layout->menu.w = layout->bounds.w;
|
|
|
+ layout->menu.offset.x = *layout->offset_x;
|
|
|
+ layout->menu.offset.y = *layout->offset_y;
|
|
|
+ *layout->offset_y = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_menubar_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ struct nk_command_buffer *out;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ out = &win->buffer;
|
|
|
+ layout = win->layout;
|
|
|
+ if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED)
|
|
|
+ return;
|
|
|
+
|
|
|
+ layout->menu.h = layout->at_y - layout->menu.y;
|
|
|
+ layout->bounds.y += layout->menu.h + ctx->style.window.spacing.y + layout->row.height;
|
|
|
+ layout->bounds.h -= layout->menu.h + ctx->style.window.spacing.y + layout->row.height;
|
|
|
+
|
|
|
+ *layout->offset_x = layout->menu.offset.x;
|
|
|
+ *layout->offset_y = layout->menu.offset.y;
|
|
|
+ layout->at_y = layout->bounds.y - layout->row.height;
|
|
|
+
|
|
|
+ layout->clip.y = layout->bounds.y;
|
|
|
+ layout->clip.h = layout->bounds.h;
|
|
|
+ nk_push_scissor(out, layout->clip);
|
|
|
+}
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * LAYOUT
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_layout_set_min_row_height(struct nk_context *ctx, float height)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->row.min_height = height;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_reset_min_row_height(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->row.min_height = ctx->style.font->height;
|
|
|
+ layout->row.min_height += ctx->style.text.padding.y*2;
|
|
|
+ layout->row.min_height += ctx->style.window.min_row_height_padding*2;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN float
|
|
|
+nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type,
|
|
|
+ float total_space, int columns)
|
|
|
+{
|
|
|
+ float panel_padding;
|
|
|
+ float panel_spacing;
|
|
|
+ float panel_space;
|
|
|
+
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ spacing = style->window.spacing;
|
|
|
+ padding = nk_panel_get_padding(style, type);
|
|
|
+
|
|
|
+ /* calculate the usable panel space */
|
|
|
+ panel_padding = 2 * padding.x;
|
|
|
+ panel_spacing = (float)NK_MAX(columns - 1, 0) * spacing.x;
|
|
|
+ panel_space = total_space - panel_padding - panel_spacing;
|
|
|
+ return panel_space;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_panel_layout(const struct nk_context *ctx, struct nk_window *win,
|
|
|
+ float height, int cols)
|
|
|
+{
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+ struct nk_command_buffer *out;
|
|
|
+
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+ struct nk_color color;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* prefetch some configuration data */
|
|
|
+ layout = win->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+ out = &win->buffer;
|
|
|
+ color = style->window.background;
|
|
|
+ item_spacing = style->window.spacing;
|
|
|
+
|
|
|
+ /* if one of these triggers you forgot to add an `if` condition around either
|
|
|
+ a window, group, popup, combobox or contextual menu `begin` and `end` block.
|
|
|
+ Example:
|
|
|
+ if (nk_begin(...) {...} nk_end(...); or
|
|
|
+ if (nk_group_begin(...) { nk_group_end(...);} */
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_MINIMIZED));
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_HIDDEN));
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_CLOSED));
|
|
|
+
|
|
|
+ /* update the current row and set the current row layout */
|
|
|
+ layout->row.index = 0;
|
|
|
+ layout->at_y += layout->row.height;
|
|
|
+ layout->row.columns = cols;
|
|
|
+ if (height == 0.0f)
|
|
|
+ layout->row.height = NK_MAX(height, layout->row.min_height) + item_spacing.y;
|
|
|
+ else layout->row.height = height + item_spacing.y;
|
|
|
+
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ if (layout->flags & NK_WINDOW_DYNAMIC) {
|
|
|
+ /* draw background for dynamic panels */
|
|
|
+ struct nk_rect background;
|
|
|
+ background.x = win->bounds.x;
|
|
|
+ background.w = win->bounds.w;
|
|
|
+ background.y = layout->at_y - 1.0f;
|
|
|
+ background.h = layout->row.height + 1.0f;
|
|
|
+ nk_fill_rect(out, background, 0, color);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_row_layout(struct nk_context *ctx, enum nk_layout_format fmt,
|
|
|
+ float height, int cols, int width)
|
|
|
+{
|
|
|
+ /* update the current row and set the current row layout */
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ nk_panel_layout(ctx, win, height, cols);
|
|
|
+ if (fmt == NK_DYNAMIC)
|
|
|
+ win->layout->row.type = NK_LAYOUT_DYNAMIC_FIXED;
|
|
|
+ else win->layout->row.type = NK_LAYOUT_STATIC_FIXED;
|
|
|
+
|
|
|
+ win->layout->row.ratio = 0;
|
|
|
+ win->layout->row.filled = 0;
|
|
|
+ win->layout->row.item_offset = 0;
|
|
|
+ win->layout->row.item_width = (float)width;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_layout_ratio_from_pixel(struct nk_context *ctx, float pixel_width)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(pixel_width);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return 0;
|
|
|
+ win = ctx->current;
|
|
|
+ return NK_CLAMP(0.0f, pixel_width/win->bounds.x, 1.0f);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_dynamic(struct nk_context *ctx, float height, int cols)
|
|
|
+{
|
|
|
+ nk_row_layout(ctx, NK_DYNAMIC, height, cols, 0);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_static(struct nk_context *ctx, float height, int item_width, int cols)
|
|
|
+{
|
|
|
+ nk_row_layout(ctx, NK_STATIC, height, cols, item_width);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt,
|
|
|
+ float row_height, int cols)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ nk_panel_layout(ctx, win, row_height, cols);
|
|
|
+ if (fmt == NK_DYNAMIC)
|
|
|
+ layout->row.type = NK_LAYOUT_DYNAMIC_ROW;
|
|
|
+ else layout->row.type = NK_LAYOUT_STATIC_ROW;
|
|
|
+
|
|
|
+ layout->row.ratio = 0;
|
|
|
+ layout->row.filled = 0;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ layout->row.columns = cols;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_push(struct nk_context *ctx, float ratio_or_width)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
|
|
|
+ if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (layout->row.type == NK_LAYOUT_DYNAMIC_ROW) {
|
|
|
+ float ratio = ratio_or_width;
|
|
|
+ if ((ratio + layout->row.filled) > 1.0f) return;
|
|
|
+ if (ratio > 0.0f)
|
|
|
+ layout->row.item_width = NK_SATURATE(ratio);
|
|
|
+ else layout->row.item_width = 1.0f - layout->row.filled;
|
|
|
+ } else layout->row.item_width = ratio_or_width;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
|
|
|
+ if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
|
|
|
+ return;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row(struct nk_context *ctx, enum nk_layout_format fmt,
|
|
|
+ float height, int cols, const float *ratio)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ int n_undef = 0;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ nk_panel_layout(ctx, win, height, cols);
|
|
|
+ if (fmt == NK_DYNAMIC) {
|
|
|
+ /* calculate width of undefined widget ratios */
|
|
|
+ float r = 0;
|
|
|
+ layout->row.ratio = ratio;
|
|
|
+ for (i = 0; i < cols; ++i) {
|
|
|
+ if (ratio[i] < 0.0f)
|
|
|
+ n_undef++;
|
|
|
+ else r += ratio[i];
|
|
|
+ }
|
|
|
+ r = NK_SATURATE(1.0f - r);
|
|
|
+ layout->row.type = NK_LAYOUT_DYNAMIC;
|
|
|
+ layout->row.item_width = (r > 0 && n_undef > 0) ? (r / (float)n_undef):0;
|
|
|
+ } else {
|
|
|
+ layout->row.ratio = ratio;
|
|
|
+ layout->row.type = NK_LAYOUT_STATIC;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ }
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ layout->row.filled = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_template_begin(struct nk_context *ctx, float height)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ nk_panel_layout(ctx, win, height, 1);
|
|
|
+ layout->row.type = NK_LAYOUT_TEMPLATE;
|
|
|
+ layout->row.columns = 0;
|
|
|
+ layout->row.ratio = 0;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_height = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ layout->row.filled = 0;
|
|
|
+ layout->row.item.x = 0;
|
|
|
+ layout->row.item.y = 0;
|
|
|
+ layout->row.item.w = 0;
|
|
|
+ layout->row.item.h = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_template_push_dynamic(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
|
|
|
+ NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
|
|
|
+ if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
|
|
|
+ if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
|
|
|
+ layout->row.templates[layout->row.columns++] = -1.0f;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_template_push_variable(struct nk_context *ctx, float min_width)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
|
|
|
+ NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
|
|
|
+ if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
|
|
|
+ if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
|
|
|
+ layout->row.templates[layout->row.columns++] = -min_width;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_template_push_static(struct nk_context *ctx, float width)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
|
|
|
+ NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
|
|
|
+ if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
|
|
|
+ if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
|
|
|
+ layout->row.templates[layout->row.columns++] = width;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_row_template_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ int i = 0;
|
|
|
+ int variable_count = 0;
|
|
|
+ int min_variable_count = 0;
|
|
|
+ float min_fixed_width = 0.0f;
|
|
|
+ float total_fixed_width = 0.0f;
|
|
|
+ float max_variable_width = 0.0f;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
|
|
|
+ if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
|
|
|
+ for (i = 0; i < layout->row.columns; ++i) {
|
|
|
+ float width = layout->row.templates[i];
|
|
|
+ if (width >= 0.0f) {
|
|
|
+ total_fixed_width += width;
|
|
|
+ min_fixed_width += width;
|
|
|
+ } else if (width < -1.0f) {
|
|
|
+ width = -width;
|
|
|
+ total_fixed_width += width;
|
|
|
+ max_variable_width = NK_MAX(max_variable_width, width);
|
|
|
+ variable_count++;
|
|
|
+ } else {
|
|
|
+ min_variable_count++;
|
|
|
+ variable_count++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (variable_count) {
|
|
|
+ float space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type,
|
|
|
+ layout->bounds.w, layout->row.columns);
|
|
|
+ float var_width = (NK_MAX(space-min_fixed_width,0.0f)) / (float)variable_count;
|
|
|
+ int enough_space = var_width >= max_variable_width;
|
|
|
+ if (!enough_space)
|
|
|
+ var_width = (NK_MAX(space-total_fixed_width,0)) / (float)min_variable_count;
|
|
|
+ for (i = 0; i < layout->row.columns; ++i) {
|
|
|
+ float *width = &layout->row.templates[i];
|
|
|
+ *width = (*width >= 0.0f)? *width: (*width < -1.0f && !enough_space)? -(*width): var_width;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_space_begin(struct nk_context *ctx, enum nk_layout_format fmt,
|
|
|
+ float height, int widget_count)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ nk_panel_layout(ctx, win, height, widget_count);
|
|
|
+ if (fmt == NK_STATIC)
|
|
|
+ layout->row.type = NK_LAYOUT_STATIC_FREE;
|
|
|
+ else layout->row.type = NK_LAYOUT_DYNAMIC_FREE;
|
|
|
+
|
|
|
+ layout->row.ratio = 0;
|
|
|
+ layout->row.filled = 0;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_space_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->row.item_width = 0;
|
|
|
+ layout->row.item_height = 0;
|
|
|
+ layout->row.item_offset = 0;
|
|
|
+ nk_zero(&layout->row.item, sizeof(layout->row.item));
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_layout_space_push(struct nk_context *ctx, struct nk_rect rect)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->row.item = rect;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_layout_space_bounds(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect ret;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x = layout->clip.x;
|
|
|
+ ret.y = layout->clip.y;
|
|
|
+ ret.w = layout->clip.w;
|
|
|
+ ret.h = layout->row.height;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_layout_widget_bounds(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect ret;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x = layout->at_x;
|
|
|
+ ret.y = layout->at_y;
|
|
|
+ ret.w = layout->bounds.w - NK_MAX(layout->at_x - layout->bounds.x,0);
|
|
|
+ ret.h = layout->row.height;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_layout_space_to_screen(struct nk_context *ctx, struct nk_vec2 ret)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x += layout->at_x - (float)*layout->offset_x;
|
|
|
+ ret.y += layout->at_y - (float)*layout->offset_y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_layout_space_to_local(struct nk_context *ctx, struct nk_vec2 ret)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x += -layout->at_x + (float)*layout->offset_x;
|
|
|
+ ret.y += -layout->at_y + (float)*layout->offset_y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_layout_space_rect_to_screen(struct nk_context *ctx, struct nk_rect ret)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x += layout->at_x - (float)*layout->offset_x;
|
|
|
+ ret.y += layout->at_y - (float)*layout->offset_y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_layout_space_rect_to_local(struct nk_context *ctx, struct nk_rect ret)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ ret.x += -layout->at_x + (float)*layout->offset_x;
|
|
|
+ ret.y += -layout->at_y + (float)*layout->offset_y;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_panel_alloc_row(const struct nk_context *ctx, struct nk_window *win)
|
|
|
+{
|
|
|
+ struct nk_panel *layout = win->layout;
|
|
|
+ struct nk_vec2 spacing = ctx->style.window.spacing;
|
|
|
+ const float row_height = layout->row.height - spacing.y;
|
|
|
+ nk_panel_layout(ctx, win, row_height, layout->row.columns);
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
|
|
|
+ struct nk_window *win, int modify)
|
|
|
+{
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_vec2 spacing;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ float item_offset = 0;
|
|
|
+ float item_width = 0;
|
|
|
+ float item_spacing = 0;
|
|
|
+ float panel_space = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+ NK_ASSERT(bounds);
|
|
|
+
|
|
|
+ spacing = style->window.spacing;
|
|
|
+ padding = nk_panel_get_padding(style, layout->type);
|
|
|
+ panel_space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type,
|
|
|
+ layout->bounds.w, layout->row.columns);
|
|
|
+
|
|
|
+ /* calculate the width of one item inside the current layout space */
|
|
|
+ switch (layout->row.type) {
|
|
|
+ case NK_LAYOUT_DYNAMIC_FIXED: {
|
|
|
+ /* scaling fixed size widgets item width */
|
|
|
+ item_width = NK_MAX(1.0f,panel_space-1.0f) / (float)layout->row.columns;
|
|
|
+ item_offset = (float)layout->row.index * item_width;
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_DYNAMIC_ROW: {
|
|
|
+ /* scaling single ratio widget width */
|
|
|
+ item_width = layout->row.item_width * panel_space;
|
|
|
+ item_offset = layout->row.item_offset;
|
|
|
+ item_spacing = 0;
|
|
|
+
|
|
|
+ if (modify) {
|
|
|
+ layout->row.item_offset += item_width + spacing.x;
|
|
|
+ layout->row.filled += layout->row.item_width;
|
|
|
+ layout->row.index = 0;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_DYNAMIC_FREE: {
|
|
|
+ /* panel width depended free widget placing */
|
|
|
+ bounds->x = layout->at_x + (layout->bounds.w * layout->row.item.x);
|
|
|
+ bounds->x -= (float)*layout->offset_x;
|
|
|
+ bounds->y = layout->at_y + (layout->row.height * layout->row.item.y);
|
|
|
+ bounds->y -= (float)*layout->offset_y;
|
|
|
+ bounds->w = layout->bounds.w * layout->row.item.w;
|
|
|
+ bounds->h = layout->row.height * layout->row.item.h;
|
|
|
+ return;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_DYNAMIC: {
|
|
|
+ /* scaling arrays of panel width ratios for every widget */
|
|
|
+ float ratio;
|
|
|
+ NK_ASSERT(layout->row.ratio);
|
|
|
+ ratio = (layout->row.ratio[layout->row.index] < 0) ?
|
|
|
+ layout->row.item_width : layout->row.ratio[layout->row.index];
|
|
|
+
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ item_width = (ratio * panel_space);
|
|
|
+ item_offset = layout->row.item_offset;
|
|
|
+
|
|
|
+ if (modify) {
|
|
|
+ layout->row.item_offset += item_width;
|
|
|
+ layout->row.filled += ratio;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_STATIC_FIXED: {
|
|
|
+ /* non-scaling fixed widgets item width */
|
|
|
+ item_width = layout->row.item_width;
|
|
|
+ item_offset = (float)layout->row.index * item_width;
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_STATIC_ROW: {
|
|
|
+ /* scaling single ratio widget width */
|
|
|
+ item_width = layout->row.item_width;
|
|
|
+ item_offset = layout->row.item_offset;
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ if (modify) layout->row.item_offset += item_width;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_STATIC_FREE: {
|
|
|
+ /* free widget placing */
|
|
|
+ bounds->x = layout->at_x + layout->row.item.x;
|
|
|
+ bounds->w = layout->row.item.w;
|
|
|
+ if (((bounds->x + bounds->w) > layout->max_x) && modify)
|
|
|
+ layout->max_x = (bounds->x + bounds->w);
|
|
|
+ bounds->x -= (float)*layout->offset_x;
|
|
|
+ bounds->y = layout->at_y + layout->row.item.y;
|
|
|
+ bounds->y -= (float)*layout->offset_y;
|
|
|
+ bounds->h = layout->row.item.h;
|
|
|
+ return;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_STATIC: {
|
|
|
+ /* non-scaling array of panel pixel width for every widget */
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ item_width = layout->row.ratio[layout->row.index];
|
|
|
+ item_offset = layout->row.item_offset;
|
|
|
+ if (modify) layout->row.item_offset += item_width;
|
|
|
+ } break;
|
|
|
+ case NK_LAYOUT_TEMPLATE: {
|
|
|
+ /* stretchy row layout with combined dynamic/static widget width*/
|
|
|
+ NK_ASSERT(layout->row.index < layout->row.columns);
|
|
|
+ NK_ASSERT(layout->row.index < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
|
|
|
+ item_width = layout->row.templates[layout->row.index];
|
|
|
+ item_offset = layout->row.item_offset;
|
|
|
+ item_spacing = (float)layout->row.index * spacing.x;
|
|
|
+ if (modify) layout->row.item_offset += item_width;
|
|
|
+ } break;
|
|
|
+ default: NK_ASSERT(0); break;
|
|
|
+ };
|
|
|
+
|
|
|
+ /* set the bounds of the newly allocated widget */
|
|
|
+ bounds->w = item_width;
|
|
|
+ bounds->h = layout->row.height - spacing.y;
|
|
|
+ bounds->y = layout->at_y - (float)*layout->offset_y;
|
|
|
+ bounds->x = layout->at_x + item_offset + item_spacing + padding.x;
|
|
|
+ if (((bounds->x + bounds->w) > layout->max_x) && modify)
|
|
|
+ layout->max_x = bounds->x + bounds->w;
|
|
|
+ bounds->x -= (float)*layout->offset_x;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_panel_alloc_space(struct nk_rect *bounds, const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* check if the end of the row has been hit and begin new row if so */
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ if (layout->row.index >= layout->row.columns)
|
|
|
+ nk_panel_alloc_row(ctx, win);
|
|
|
+
|
|
|
+ /* calculate widget position and size */
|
|
|
+ nk_layout_widget_space(bounds, ctx, win, nk_true);
|
|
|
+ layout->row.index++;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN void
|
|
|
+nk_layout_peek(struct nk_rect *bounds, struct nk_context *ctx)
|
|
|
+{
|
|
|
+ float y;
|
|
|
+ int index;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ y = layout->at_y;
|
|
|
+ index = layout->row.index;
|
|
|
+ if (layout->row.index >= layout->row.columns) {
|
|
|
+ layout->at_y += layout->row.height;
|
|
|
+ layout->row.index = 0;
|
|
|
+ }
|
|
|
+ nk_layout_widget_space(bounds, ctx, win, nk_false);
|
|
|
+ layout->at_y = y;
|
|
|
+ layout->row.index = index;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ struct nk_image *img, const char *title, enum nk_collapse_states *state)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+ struct nk_command_buffer *out;
|
|
|
+ const struct nk_input *in;
|
|
|
+ const struct nk_style_button *button;
|
|
|
+ enum nk_symbol_type symbol;
|
|
|
+ float row_height;
|
|
|
+
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+ struct nk_rect header = {0,0,0,0};
|
|
|
+ struct nk_rect sym = {0,0,0,0};
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ nk_flags ws = 0;
|
|
|
+ enum nk_widget_layout_states widget_state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* cache some data */
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ out = &win->buffer;
|
|
|
+ style = &ctx->style;
|
|
|
+ item_spacing = style->window.spacing;
|
|
|
+
|
|
|
+ /* calculate header bounds and draw background */
|
|
|
+ row_height = style->font->height + 2 * style->tab.padding.y;
|
|
|
+ nk_layout_set_min_row_height(ctx, row_height);
|
|
|
+ nk_layout_row_dynamic(ctx, row_height, 1);
|
|
|
+ nk_layout_reset_min_row_height(ctx);
|
|
|
+
|
|
|
+ widget_state = nk_widget(&header, ctx);
|
|
|
+ if (type == NK_TREE_TAB) {
|
|
|
+ const struct nk_style_item *background = &style->tab.background;
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(out, header, &background->data.image, nk_white);
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(out, header, 0, style->tab.border_color);
|
|
|
+ nk_fill_rect(out, nk_shrink_rect(header, style->tab.border),
|
|
|
+ style->tab.rounding, background->data.color);
|
|
|
+ }
|
|
|
+ } else text.background = style->window.background;
|
|
|
+
|
|
|
+ /* update node state */
|
|
|
+ in = (!(layout->flags & NK_WINDOW_ROM)) ? &ctx->input: 0;
|
|
|
+ in = (in && widget_state == NK_WIDGET_VALID) ? &ctx->input : 0;
|
|
|
+ if (nk_button_behavior(&ws, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ *state = (*state == NK_MAXIMIZED) ? NK_MINIMIZED : NK_MAXIMIZED;
|
|
|
+
|
|
|
+ /* select correct button style */
|
|
|
+ if (*state == NK_MAXIMIZED) {
|
|
|
+ symbol = style->tab.sym_maximize;
|
|
|
+ if (type == NK_TREE_TAB)
|
|
|
+ button = &style->tab.tab_maximize_button;
|
|
|
+ else button = &style->tab.node_maximize_button;
|
|
|
+ } else {
|
|
|
+ symbol = style->tab.sym_minimize;
|
|
|
+ if (type == NK_TREE_TAB)
|
|
|
+ button = &style->tab.tab_minimize_button;
|
|
|
+ else button = &style->tab.node_minimize_button;
|
|
|
+ }
|
|
|
+
|
|
|
+ {/* draw triangle button */
|
|
|
+ sym.w = sym.h = style->font->height;
|
|
|
+ sym.y = header.y + style->tab.padding.y;
|
|
|
+ sym.x = header.x + style->tab.padding.x;
|
|
|
+ nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT,
|
|
|
+ button, 0, style->font);
|
|
|
+
|
|
|
+ if (img) {
|
|
|
+ /* draw optional image icon */
|
|
|
+ sym.x = sym.x + sym.w + 4 * item_spacing.x;
|
|
|
+ nk_draw_image(&win->buffer, sym, img, nk_white);
|
|
|
+ sym.w = style->font->height + style->tab.spacing.x;}
|
|
|
+ }
|
|
|
+
|
|
|
+ {/* draw label */
|
|
|
+ struct nk_rect label;
|
|
|
+ header.w = NK_MAX(header.w, sym.w + item_spacing.x);
|
|
|
+ label.x = sym.x + sym.w + item_spacing.x;
|
|
|
+ label.y = sym.y;
|
|
|
+ label.w = header.w - (sym.w + item_spacing.y + style->tab.indent);
|
|
|
+ label.h = style->font->height;
|
|
|
+ text.text = style->tab.text;
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ nk_widget_text(out, label, title, nk_strlen(title), &text,
|
|
|
+ NK_TEXT_LEFT, style->font);}
|
|
|
+
|
|
|
+ /* increase x-axis cursor widget position pointer */
|
|
|
+ if (*state == NK_MAXIMIZED) {
|
|
|
+ layout->at_x = header.x + (float)*layout->offset_x + style->tab.indent;
|
|
|
+ layout->bounds.w = NK_MAX(layout->bounds.w, style->tab.indent);
|
|
|
+ layout->bounds.w -= (style->tab.indent + style->window.padding.x);
|
|
|
+ layout->row.tree_depth++;
|
|
|
+ return nk_true;
|
|
|
+ } else return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_tree_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ struct nk_image *img, const char *title, enum nk_collapse_states initial_state,
|
|
|
+ const char *hash, int len, int line)
|
|
|
+{
|
|
|
+ struct nk_window *win = ctx->current;
|
|
|
+ int title_len = 0;
|
|
|
+ nk_hash tree_hash = 0;
|
|
|
+ nk_uint *state = 0;
|
|
|
+
|
|
|
+ /* retrieve tree state from internal widget state tables */
|
|
|
+ if (!hash) {
|
|
|
+ title_len = (int)nk_strlen(title);
|
|
|
+ tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line);
|
|
|
+ } else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line);
|
|
|
+ state = nk_find_value(win, tree_hash);
|
|
|
+ if (!state) {
|
|
|
+ state = nk_add_value(ctx, win, tree_hash, 0);
|
|
|
+ *state = initial_state;
|
|
|
+ }
|
|
|
+ return nk_tree_state_base(ctx, type, img, title, (enum nk_collapse_states*)state);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_tree_state_push(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ const char *title, enum nk_collapse_states *state)
|
|
|
+{return nk_tree_state_base(ctx, type, 0, title, state);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_tree_state_image_push(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ struct nk_image img, const char *title, enum nk_collapse_states *state)
|
|
|
+{return nk_tree_state_base(ctx, type, &img, title, state);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_tree_state_pop(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win = 0;
|
|
|
+ struct nk_panel *layout = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->at_x -= ctx->style.tab.indent + ctx->style.window.padding.x;
|
|
|
+ layout->bounds.w += ctx->style.tab.indent + ctx->style.window.padding.x;
|
|
|
+ NK_ASSERT(layout->row.tree_depth);
|
|
|
+ layout->row.tree_depth--;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_tree_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ const char *title, enum nk_collapse_states initial_state,
|
|
|
+ const char *hash, int len, int line)
|
|
|
+{return nk_tree_base(ctx, type, 0, title, initial_state, hash, len, line);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_tree_image_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
|
+ struct nk_image img, const char *title, enum nk_collapse_states initial_state,
|
|
|
+ const char *hash, int len,int seed)
|
|
|
+{return nk_tree_base(ctx, type, &img, title, initial_state, hash, len, seed);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_tree_pop(struct nk_context *ctx)
|
|
|
+{nk_tree_state_pop(ctx);}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * WIDGETS
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API struct nk_rect
|
|
|
+nk_widget_bounds(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return nk_rect(0,0,0,0);
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ return bounds;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_widget_position(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return nk_vec2(0,0);
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ return nk_vec2(bounds.x, bounds.y);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_vec2
|
|
|
+nk_widget_size(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return nk_vec2(0,0);
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ return nk_vec2(bounds.w, bounds.h);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_widget_width(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ return bounds.w;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_widget_height(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ return bounds.h;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_widget_is_hovered(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect c, v;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current || ctx->active != ctx->current)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ c = ctx->current->layout->clip;
|
|
|
+ c.x = (float)((int)c.x);
|
|
|
+ c.y = (float)((int)c.y);
|
|
|
+ c.w = (float)((int)c.w);
|
|
|
+ c.h = (float)((int)c.h);
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h);
|
|
|
+ if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h))
|
|
|
+ return 0;
|
|
|
+ return nk_input_is_mouse_hovering_rect(&ctx->input, bounds);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_widget_is_mouse_clicked(struct nk_context *ctx, enum nk_buttons btn)
|
|
|
+{
|
|
|
+ struct nk_rect c, v;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current || ctx->active != ctx->current)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ c = ctx->current->layout->clip;
|
|
|
+ c.x = (float)((int)c.x);
|
|
|
+ c.y = (float)((int)c.y);
|
|
|
+ c.w = (float)((int)c.w);
|
|
|
+ c.h = (float)((int)c.h);
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h);
|
|
|
+ if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h))
|
|
|
+ return 0;
|
|
|
+ return nk_input_mouse_clicked(&ctx->input, btn, bounds);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_widget_has_mouse_click_down(struct nk_context *ctx, enum nk_buttons btn, int down)
|
|
|
+{
|
|
|
+ struct nk_rect c, v;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current || ctx->active != ctx->current)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ c = ctx->current->layout->clip;
|
|
|
+ c.x = (float)((int)c.x);
|
|
|
+ c.y = (float)((int)c.y);
|
|
|
+ c.w = (float)((int)c.w);
|
|
|
+ c.h = (float)((int)c.h);
|
|
|
+
|
|
|
+ nk_layout_peek(&bounds, ctx);
|
|
|
+ nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h);
|
|
|
+ if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h))
|
|
|
+ return 0;
|
|
|
+ return nk_input_has_mouse_click_down_in_rect(&ctx->input, btn, bounds, down);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API enum nk_widget_layout_states
|
|
|
+nk_widget(struct nk_rect *bounds, const struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_rect c, v;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return NK_WIDGET_INVALID;
|
|
|
+
|
|
|
+ /* allocate space and check if the widget needs to be updated and drawn */
|
|
|
+ nk_panel_alloc_space(bounds, ctx);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ in = &ctx->input;
|
|
|
+ c = layout->clip;
|
|
|
+
|
|
|
+ /* if one of these triggers you forgot to add an `if` condition around either
|
|
|
+ a window, group, popup, combobox or contextual menu `begin` and `end` block.
|
|
|
+ Example:
|
|
|
+ if (nk_begin(...) {...} nk_end(...); or
|
|
|
+ if (nk_group_begin(...) { nk_group_end(...);} */
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_MINIMIZED));
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_HIDDEN));
|
|
|
+ NK_ASSERT(!(layout->flags & NK_WINDOW_CLOSED));
|
|
|
+
|
|
|
+ /* need to convert to int here to remove floating point errors */
|
|
|
+ bounds->x = (float)((int)bounds->x);
|
|
|
+ bounds->y = (float)((int)bounds->y);
|
|
|
+ bounds->w = (float)((int)bounds->w);
|
|
|
+ bounds->h = (float)((int)bounds->h);
|
|
|
+
|
|
|
+ c.x = (float)((int)c.x);
|
|
|
+ c.y = (float)((int)c.y);
|
|
|
+ c.w = (float)((int)c.w);
|
|
|
+ c.h = (float)((int)c.h);
|
|
|
+
|
|
|
+ nk_unify(&v, &c, bounds->x, bounds->y, bounds->x + bounds->w, bounds->y + bounds->h);
|
|
|
+ if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds->x, bounds->y, bounds->w, bounds->h))
|
|
|
+ return NK_WIDGET_INVALID;
|
|
|
+ if (!NK_INBOX(in->mouse.pos.x, in->mouse.pos.y, v.x, v.y, v.w, v.h))
|
|
|
+ return NK_WIDGET_ROM;
|
|
|
+ return NK_WIDGET_VALID;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API enum nk_widget_layout_states
|
|
|
+nk_widget_fitting(struct nk_rect *bounds, struct nk_context *ctx,
|
|
|
+ struct nk_vec2 item_padding)
|
|
|
+{
|
|
|
+ /* update the bounds to stand without padding */
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ struct nk_vec2 panel_padding;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return NK_WIDGET_INVALID;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+ state = nk_widget(bounds, ctx);
|
|
|
+
|
|
|
+ panel_padding = nk_panel_get_padding(style, layout->type);
|
|
|
+ if (layout->row.index == 1) {
|
|
|
+ bounds->w += panel_padding.x;
|
|
|
+ bounds->x -= panel_padding.x;
|
|
|
+ } else bounds->x -= item_padding.x;
|
|
|
+
|
|
|
+ if (layout->row.index == layout->row.columns)
|
|
|
+ bounds->w += panel_padding.x;
|
|
|
+ else bounds->w += item_padding.x;
|
|
|
+ return state;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * MISC
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_spacing(struct nk_context *ctx, int cols)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ struct nk_rect none;
|
|
|
+ int i, index, rows;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* spacing over row boundaries */
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ index = (layout->row.index + cols) % layout->row.columns;
|
|
|
+ rows = (layout->row.index + cols) / layout->row.columns;
|
|
|
+ if (rows) {
|
|
|
+ for (i = 0; i < rows; ++i)
|
|
|
+ nk_panel_alloc_row(ctx, win);
|
|
|
+ cols = index;
|
|
|
+ }
|
|
|
+ /* non table layout need to allocate space */
|
|
|
+ if (layout->row.type != NK_LAYOUT_DYNAMIC_FIXED &&
|
|
|
+ layout->row.type != NK_LAYOUT_STATIC_FIXED) {
|
|
|
+ for (i = 0; i < cols; ++i)
|
|
|
+ nk_panel_alloc_space(&none, ctx);
|
|
|
+ }
|
|
|
+ layout->row.index = index;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * TEXT
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_text_colored(struct nk_context *ctx, const char *str, int len,
|
|
|
+ nk_flags alignment, struct nk_color color)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_vec2 item_padding;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ nk_panel_alloc_space(&bounds, ctx);
|
|
|
+ item_padding = style->text.padding;
|
|
|
+
|
|
|
+ text.padding.x = item_padding.x;
|
|
|
+ text.padding.y = item_padding.y;
|
|
|
+ text.background = style->window.background;
|
|
|
+ text.text = color;
|
|
|
+ nk_widget_text(&win->buffer, bounds, str, len, &text, alignment, style->font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_text_wrap_colored(struct nk_context *ctx, const char *str,
|
|
|
+ int len, struct nk_color color)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_vec2 item_padding;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ nk_panel_alloc_space(&bounds, ctx);
|
|
|
+ item_padding = style->text.padding;
|
|
|
+
|
|
|
+ text.padding.x = item_padding.x;
|
|
|
+ text.padding.y = item_padding.y;
|
|
|
+ text.background = style->window.background;
|
|
|
+ text.text = color;
|
|
|
+ nk_widget_text_wrap(&win->buffer, bounds, str, len, &text, style->font);
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NK_INCLUDE_STANDARD_VARARGS
|
|
|
+NK_API void
|
|
|
+nk_labelf_colored(struct nk_context *ctx, nk_flags flags,
|
|
|
+ struct nk_color color, const char *fmt, ...)
|
|
|
+{
|
|
|
+ char buf[256];
|
|
|
+ va_list args;
|
|
|
+ va_start(args, fmt);
|
|
|
+ nk_strfmt(buf, NK_LEN(buf), fmt, args);
|
|
|
+ nk_label_colored(ctx, buf, flags, color);
|
|
|
+ va_end(args);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_labelf_colored_wrap(struct nk_context *ctx, struct nk_color color,
|
|
|
+ const char *fmt, ...)
|
|
|
+{
|
|
|
+ char buf[256];
|
|
|
+ va_list args;
|
|
|
+ va_start(args, fmt);
|
|
|
+ nk_strfmt(buf, NK_LEN(buf), fmt, args);
|
|
|
+ nk_label_colored_wrap(ctx, buf, color);
|
|
|
+ va_end(args);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_labelf(struct nk_context *ctx, nk_flags flags, const char *fmt, ...)
|
|
|
+{
|
|
|
+ char buf[256];
|
|
|
+ va_list args;
|
|
|
+ va_start(args, fmt);
|
|
|
+ nk_strfmt(buf, NK_LEN(buf), fmt, args);
|
|
|
+ nk_label(ctx, buf, flags);
|
|
|
+ va_end(args);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_labelf_wrap(struct nk_context *ctx, const char *fmt,...)
|
|
|
+{
|
|
|
+ char buf[256];
|
|
|
+ va_list args;
|
|
|
+ va_start(args, fmt);
|
|
|
+ nk_strfmt(buf, NK_LEN(buf), fmt, args);
|
|
|
+ nk_label_wrap(ctx, buf);
|
|
|
+ va_end(args);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_bool(struct nk_context *ctx, const char *prefix, int value)
|
|
|
+{nk_labelf(ctx, NK_TEXT_LEFT, "%s: %s", prefix, ((value) ? "true": "false"));}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_int(struct nk_context *ctx, const char *prefix, int value)
|
|
|
+{nk_labelf(ctx, NK_TEXT_LEFT, "%s: %d", prefix, value);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_uint(struct nk_context *ctx, const char *prefix, unsigned int value)
|
|
|
+{nk_labelf(ctx, NK_TEXT_LEFT, "%s: %u", prefix, value);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_float(struct nk_context *ctx, const char *prefix, float value)
|
|
|
+{
|
|
|
+ double double_value = (double)value;
|
|
|
+ nk_labelf(ctx, NK_TEXT_LEFT, "%s: %.3f", prefix, double_value);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_color_byte(struct nk_context *ctx, const char *p, struct nk_color c)
|
|
|
+{nk_labelf(ctx, NK_TEXT_LEFT, "%s: (%d, %d, %d, %d)", p, c.r, c.g, c.b, c.a);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_color_float(struct nk_context *ctx, const char *p, struct nk_color color)
|
|
|
+{
|
|
|
+ double c[4]; nk_color_dv(c, color);
|
|
|
+ nk_labelf(ctx, NK_TEXT_LEFT, "%s: (%.2f, %.2f, %.2f, %.2f)",
|
|
|
+ p, c[0], c[1], c[2], c[3]);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_value_color_hex(struct nk_context *ctx, const char *prefix, struct nk_color color)
|
|
|
+{
|
|
|
+ char hex[16];
|
|
|
+ nk_color_hex_rgba(hex, color);
|
|
|
+ nk_labelf(ctx, NK_TEXT_LEFT, "%s: %s", prefix, hex);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_text(struct nk_context *ctx, const char *str, int len, nk_flags alignment)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ nk_text_colored(ctx, str, len, alignment, ctx->style.text.color);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_text_wrap(struct nk_context *ctx, const char *str, int len)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ nk_text_wrap_colored(ctx, str, len, ctx->style.text.color);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_label(struct nk_context *ctx, const char *str, nk_flags alignment)
|
|
|
+{nk_text(ctx, str, nk_strlen(str), alignment);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_label_colored(struct nk_context *ctx, const char *str, nk_flags align,
|
|
|
+ struct nk_color color)
|
|
|
+{nk_text_colored(ctx, str, nk_strlen(str), align, color);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_label_wrap(struct nk_context *ctx, const char *str)
|
|
|
+{nk_text_wrap(ctx, str, nk_strlen(str));}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_label_colored_wrap(struct nk_context *ctx, const char *str, struct nk_color color)
|
|
|
+{nk_text_wrap_colored(ctx, str, nk_strlen(str), color);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_image(struct nk_context *ctx, struct nk_image img)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ if (!nk_widget(&bounds, ctx)) return;
|
|
|
+ nk_draw_image(&win->buffer, bounds, &img, nk_white);
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * BUTTON
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_button_set_behavior(struct nk_context *ctx, enum nk_button_behavior behavior)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return;
|
|
|
+ ctx->button_behavior = behavior;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_push_behavior(struct nk_context *ctx, enum nk_button_behavior behavior)
|
|
|
+{
|
|
|
+ struct nk_config_stack_button_behavior *button_stack;
|
|
|
+ struct nk_config_stack_button_behavior_element *element;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ button_stack = &ctx->stacks.button_behaviors;
|
|
|
+ NK_ASSERT(button_stack->head < (int)NK_LEN(button_stack->elements));
|
|
|
+ if (button_stack->head >= (int)NK_LEN(button_stack->elements))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ element = &button_stack->elements[button_stack->head++];
|
|
|
+ element->address = &ctx->button_behavior;
|
|
|
+ element->old_value = ctx->button_behavior;
|
|
|
+ ctx->button_behavior = behavior;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_pop_behavior(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_config_stack_button_behavior *button_stack;
|
|
|
+ struct nk_config_stack_button_behavior_element *element;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+
|
|
|
+ button_stack = &ctx->stacks.button_behaviors;
|
|
|
+ NK_ASSERT(button_stack->head > 0);
|
|
|
+ if (button_stack->head < 1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ element = &button_stack->elements[--button_stack->head];
|
|
|
+ *element->address = element->old_value;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_text_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, const char *title, int len)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(style);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!style || !ctx || !ctx->current || !ctx->current->layout) return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ title, len, style->text_alignment, ctx->button_behavior,
|
|
|
+ style, in, ctx->style.font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_text(struct nk_context *ctx, const char *title, int len)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ return nk_button_text_styled(ctx, &ctx->style.button, title, len);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_button_label_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, const char *title)
|
|
|
+{return nk_button_text_styled(ctx, style, title, nk_strlen(title));}
|
|
|
+
|
|
|
+NK_API int nk_button_label(struct nk_context *ctx, const char *title)
|
|
|
+{return nk_button_text(ctx, title, nk_strlen(title));}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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_style_button button;
|
|
|
+
|
|
|
+ int ret = 0;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_rect content;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+
|
|
|
+ button = ctx->style.button;
|
|
|
+ button.normal = nk_style_item_color(color);
|
|
|
+ button.hover = nk_style_item_color(color);
|
|
|
+ button.active = nk_style_item_color(color);
|
|
|
+ ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ &button, in, ctx->button_behavior, &content);
|
|
|
+ nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_symbol_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, enum nk_symbol_type symbol)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ symbol, ctx->button_behavior, style, in, ctx->style.font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_symbol(struct nk_context *ctx, enum nk_symbol_type symbol)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ return nk_button_symbol_styled(ctx, &ctx->style.button, symbol);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_image_styled(struct nk_context *ctx, const struct nk_style_button *style,
|
|
|
+ struct nk_image img)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_button_image(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ img, ctx->button_behavior, style, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_image(struct nk_context *ctx, struct nk_image img)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ return nk_button_image_styled(ctx, &ctx->style.button, img);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_symbol_text_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, enum nk_symbol_type symbol,
|
|
|
+ const char *text, int len, nk_flags align)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ symbol, text, len, align, ctx->button_behavior,
|
|
|
+ style, ctx->style.font, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbol,
|
|
|
+ const char* text, int len, nk_flags align)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx) return 0;
|
|
|
+ return nk_button_symbol_text_styled(ctx, &ctx->style.button, symbol, text, len, align);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_button_symbol_label(struct nk_context *ctx, enum nk_symbol_type symbol,
|
|
|
+ const char *label, nk_flags align)
|
|
|
+{return nk_button_symbol_text(ctx, symbol, label, nk_strlen(label), align);}
|
|
|
+
|
|
|
+NK_API int nk_button_symbol_label_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, enum nk_symbol_type symbol,
|
|
|
+ const char *title, nk_flags align)
|
|
|
+{return nk_button_symbol_text_styled(ctx, style, symbol, title, nk_strlen(title), align);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_image_text_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, struct nk_image img, const char *text,
|
|
|
+ int len, nk_flags align)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
|
|
|
+ bounds, img, text, len, align, ctx->button_behavior,
|
|
|
+ style, ctx->style.font, in);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_button_image_text(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *text, int len, nk_flags align)
|
|
|
+{return nk_button_image_text_styled(ctx, &ctx->style.button,img, text, len, align);}
|
|
|
+
|
|
|
+
|
|
|
+NK_API int nk_button_image_label(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *label, nk_flags align)
|
|
|
+{return nk_button_image_text(ctx, img, label, nk_strlen(label), align);}
|
|
|
+
|
|
|
+NK_API int nk_button_image_label_styled(struct nk_context *ctx,
|
|
|
+ const struct nk_style_button *style, struct nk_image img,
|
|
|
+ const char *label, nk_flags text_alignment)
|
|
|
+{return nk_button_image_text_styled(ctx, style, img, label, nk_strlen(label), text_alignment);}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * SELECTABLE
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_selectable_text(struct nk_context *ctx, const char *str, int len,
|
|
|
+ nk_flags align, int *value)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(value);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !value)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ str, len, align, value, &style->selectable, in, style->font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_selectable_image_text(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *str, int len, nk_flags align, int *value)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_input *in;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(value);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !value)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_selectable_image(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ str, len, align, value, &img, &style->selectable, in, style->font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_select_text(struct nk_context *ctx, const char *str, int len,
|
|
|
+ nk_flags align, int value)
|
|
|
+{nk_selectable_text(ctx, str, len, align, &value);return value;}
|
|
|
+
|
|
|
+NK_API int nk_selectable_label(struct nk_context *ctx, const char *str, nk_flags align, int *value)
|
|
|
+{return nk_selectable_text(ctx, str, nk_strlen(str), align, value);}
|
|
|
+
|
|
|
+NK_API int nk_selectable_image_label(struct nk_context *ctx,struct nk_image img,
|
|
|
+ const char *str, nk_flags align, int *value)
|
|
|
+{return nk_selectable_image_text(ctx, img, str, nk_strlen(str), align, value);}
|
|
|
+
|
|
|
+NK_API int nk_select_label(struct nk_context *ctx, const char *str, nk_flags align, int value)
|
|
|
+{nk_selectable_text(ctx, str, nk_strlen(str), align, &value);return value;}
|
|
|
+
|
|
|
+NK_API int nk_select_image_label(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *str, nk_flags align, int value)
|
|
|
+{nk_selectable_image_text(ctx, img, str, nk_strlen(str), align, &value);return value;}
|
|
|
+
|
|
|
+NK_API int nk_select_image_text(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *str, int len, nk_flags align, int value)
|
|
|
+{nk_selectable_image_text(ctx, img, str, len, align, &value);return value;}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * CHECKBOX
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+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;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return active;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return active;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &active,
|
|
|
+ text, len, NK_TOGGLE_CHECK, &style->checkbox, in, style->font);
|
|
|
+ return active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API unsigned int
|
|
|
+nk_check_flags_text(struct nk_context *ctx, const char *text, int len,
|
|
|
+ unsigned int flags, unsigned int value)
|
|
|
+{
|
|
|
+ int old_active;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ if (!ctx || !text) return flags;
|
|
|
+ old_active = (int)((flags & value) & value);
|
|
|
+ if (nk_check_text(ctx, text, len, old_active))
|
|
|
+ flags |= value;
|
|
|
+ else flags &= ~value;
|
|
|
+ return flags;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_checkbox_text(struct nk_context *ctx, const char *text, int len, int *active)
|
|
|
+{
|
|
|
+ int old_val;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ NK_ASSERT(active);
|
|
|
+ if (!ctx || !text || !active) return 0;
|
|
|
+ old_val = *active;
|
|
|
+ *active = nk_check_text(ctx, text, len, *active);
|
|
|
+ return old_val != *active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_checkbox_flags_text(struct nk_context *ctx, const char *text, int len,
|
|
|
+ unsigned int *flags, unsigned int value)
|
|
|
+{
|
|
|
+ int active;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ NK_ASSERT(flags);
|
|
|
+ if (!ctx || !text || !flags) return 0;
|
|
|
+
|
|
|
+ active = (int)((*flags & value) & value);
|
|
|
+ if (nk_checkbox_text(ctx, text, len, &active)) {
|
|
|
+ if (active) *flags |= value;
|
|
|
+ else *flags &= ~value;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_check_label(struct nk_context *ctx, const char *label, int active)
|
|
|
+{return nk_check_text(ctx, label, nk_strlen(label), active);}
|
|
|
+
|
|
|
+NK_API unsigned int nk_check_flags_label(struct nk_context *ctx, const char *label,
|
|
|
+ unsigned int flags, unsigned int value)
|
|
|
+{return nk_check_flags_text(ctx, label, nk_strlen(label), flags, value);}
|
|
|
+
|
|
|
+NK_API int nk_checkbox_label(struct nk_context *ctx, const char *label, int *active)
|
|
|
+{return nk_checkbox_text(ctx, label, nk_strlen(label), active);}
|
|
|
+
|
|
|
+NK_API int nk_checkbox_flags_label(struct nk_context *ctx, const char *label,
|
|
|
+ unsigned int *flags, unsigned int value)
|
|
|
+{return nk_checkbox_flags_text(ctx, label, nk_strlen(label), flags, value);}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * OPTION
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+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;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return is_active;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return state;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active,
|
|
|
+ text, len, NK_TOGGLE_OPTION, &style->option, in, style->font);
|
|
|
+ return is_active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_radio_text(struct nk_context *ctx, const char *text, int len, int *active)
|
|
|
+{
|
|
|
+ int old_value;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ NK_ASSERT(active);
|
|
|
+ if (!ctx || !text || !active) return 0;
|
|
|
+ old_value = *active;
|
|
|
+ *active = nk_option_text(ctx, text, len, old_value);
|
|
|
+ return old_value != *active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_option_label(struct nk_context *ctx, const char *label, int active)
|
|
|
+{return nk_option_text(ctx, label, nk_strlen(label), active);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_radio_label(struct nk_context *ctx, const char *label, int *active)
|
|
|
+{return nk_radio_text(ctx, label, nk_strlen(label), active);}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * SLIDER
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_slider_float(struct nk_context *ctx, float min_value, float *value, float max_value,
|
|
|
+ float value_step)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ struct nk_input *in;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ int ret = 0;
|
|
|
+ float old_value;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ NK_ASSERT(value);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !value)
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return ret;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+
|
|
|
+ old_value = *value;
|
|
|
+ *value = nk_do_slider(&ctx->last_widget_state, &win->buffer, bounds, min_value,
|
|
|
+ old_value, max_value, value_step, &style->slider, in, style->font);
|
|
|
+ return (old_value > *value || old_value < *value);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_slide_float(struct nk_context *ctx, float min, float val, float max, float step)
|
|
|
+{
|
|
|
+ nk_slider_float(ctx, min, &val, max, step); return val;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_slide_int(struct nk_context *ctx, int min, int val, int max, int step)
|
|
|
+{
|
|
|
+ float value = (float)val;
|
|
|
+ nk_slider_float(ctx, (float)min, &value, (float)max, (float)step);
|
|
|
+ return (int)value;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_slider_int(struct nk_context *ctx, int min, int *val, int max, int step)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+ float value = (float)*val;
|
|
|
+ ret = nk_slider_float(ctx, (float)min, &value, (float)max, (float)step);
|
|
|
+ *val = (int)value;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * PROGRESSBAR
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_progress(struct nk_context *ctx, nk_size *cur, nk_size max, int is_modifyable)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ nk_size old_value;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(cur);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !cur)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ old_value = *cur;
|
|
|
+ *cur = nk_do_progress(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ *cur, max, is_modifyable, &style->progress, in);
|
|
|
+ return (*cur != old_value);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_size nk_prog(struct nk_context *ctx, nk_size cur, nk_size max, int modifyable)
|
|
|
+{nk_progress(ctx, &cur, max, modifyable);return cur;}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * EDIT
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API void
|
|
|
+nk_edit_focus(struct nk_context *ctx, nk_flags flags)
|
|
|
+{
|
|
|
+ nk_hash hash;
|
|
|
+ struct nk_window *win;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ hash = win->edit.seq;
|
|
|
+ win->edit.active = nk_true;
|
|
|
+ win->edit.name = hash;
|
|
|
+ if (flags & NK_EDIT_ALWAYS_INSERT_MODE)
|
|
|
+ win->edit.mode = NK_TEXT_EDIT_MODE_INSERT;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_edit_unfocus(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ win->edit.active = nk_false;
|
|
|
+ win->edit.name = 0;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_edit_string(struct nk_context *ctx, nk_flags flags,
|
|
|
+ char *memory, int *len, int max, nk_plugin_filter filter)
|
|
|
+{
|
|
|
+ nk_hash hash;
|
|
|
+ nk_flags state;
|
|
|
+ struct nk_text_edit *edit;
|
|
|
+ struct nk_window *win;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(memory);
|
|
|
+ NK_ASSERT(len);
|
|
|
+ if (!ctx || !memory || !len)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ filter = (!filter) ? nk_filter_default: filter;
|
|
|
+ win = ctx->current;
|
|
|
+ hash = win->edit.seq;
|
|
|
+ edit = &ctx->text_edit;
|
|
|
+ nk_textedit_clear_state(&ctx->text_edit, (flags & NK_EDIT_MULTILINE)?
|
|
|
+ NK_TEXT_EDIT_MULTI_LINE: NK_TEXT_EDIT_SINGLE_LINE, filter);
|
|
|
+
|
|
|
+ if (win->edit.active && hash == win->edit.name) {
|
|
|
+ if (flags & NK_EDIT_NO_CURSOR)
|
|
|
+ edit->cursor = nk_utf_len(memory, *len);
|
|
|
+ else edit->cursor = win->edit.cursor;
|
|
|
+ if (!(flags & NK_EDIT_SELECTABLE)) {
|
|
|
+ edit->select_start = win->edit.cursor;
|
|
|
+ edit->select_end = win->edit.cursor;
|
|
|
+ } else {
|
|
|
+ edit->select_start = win->edit.sel_start;
|
|
|
+ edit->select_end = win->edit.sel_end;
|
|
|
+ }
|
|
|
+ edit->mode = win->edit.mode;
|
|
|
+ edit->scrollbar.x = (float)win->edit.scrollbar.x;
|
|
|
+ edit->scrollbar.y = (float)win->edit.scrollbar.y;
|
|
|
+ edit->active = nk_true;
|
|
|
+ } else edit->active = nk_false;
|
|
|
+
|
|
|
+ max = NK_MAX(1, max);
|
|
|
+ *len = NK_MIN(*len, max-1);
|
|
|
+ nk_str_init_fixed(&edit->string, memory, (nk_size)max);
|
|
|
+ edit->string.buffer.allocated = (nk_size)*len;
|
|
|
+ edit->string.len = nk_utf_len(memory, *len);
|
|
|
+ state = nk_edit_buffer(ctx, flags, edit, filter);
|
|
|
+ *len = (int)edit->string.buffer.allocated;
|
|
|
+
|
|
|
+ if (edit->active) {
|
|
|
+ win->edit.cursor = edit->cursor;
|
|
|
+ win->edit.sel_start = edit->select_start;
|
|
|
+ win->edit.sel_end = edit->select_end;
|
|
|
+ win->edit.mode = edit->mode;
|
|
|
+ win->edit.scrollbar.x = (nk_ushort)edit->scrollbar.x;
|
|
|
+ win->edit.scrollbar.y = (nk_ushort)edit->scrollbar.y;
|
|
|
+ }
|
|
|
+ return state;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_edit_buffer(struct nk_context *ctx, nk_flags flags,
|
|
|
+ struct nk_text_edit *edit, nk_plugin_filter filter)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ struct nk_input *in;
|
|
|
+
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ nk_flags ret_flags = 0;
|
|
|
+ unsigned char prev_state;
|
|
|
+ nk_hash hash;
|
|
|
+
|
|
|
+ /* make sure correct values */
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(edit);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return state;
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+
|
|
|
+ /* check if edit is currently hot item */
|
|
|
+ hash = win->edit.seq++;
|
|
|
+ if (win->edit.active && hash == win->edit.name) {
|
|
|
+ if (flags & NK_EDIT_NO_CURSOR)
|
|
|
+ edit->cursor = edit->string.len;
|
|
|
+ if (!(flags & NK_EDIT_SELECTABLE)) {
|
|
|
+ edit->select_start = edit->cursor;
|
|
|
+ edit->select_end = edit->cursor;
|
|
|
+ }
|
|
|
+ if (flags & NK_EDIT_CLIPBOARD)
|
|
|
+ edit->clip = ctx->clip;
|
|
|
+ }
|
|
|
+
|
|
|
+ filter = (!filter) ? nk_filter_default: filter;
|
|
|
+ prev_state = (unsigned char)edit->active;
|
|
|
+ in = (flags & NK_EDIT_READ_ONLY) ? 0: in;
|
|
|
+ ret_flags = nk_do_edit(&ctx->last_widget_state, &win->buffer, bounds, flags,
|
|
|
+ filter, edit, &style->edit, in, style->font);
|
|
|
+
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ ctx->style.cursor_active = ctx->style.cursors[NK_CURSOR_TEXT];
|
|
|
+ if (edit->active && prev_state != edit->active) {
|
|
|
+ /* current edit is now hot */
|
|
|
+ win->edit.active = nk_true;
|
|
|
+ win->edit.name = hash;
|
|
|
+ } else if (prev_state && !edit->active) {
|
|
|
+ /* current edit is now cold */
|
|
|
+ win->edit.active = nk_false;
|
|
|
+ }
|
|
|
+ return ret_flags;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_edit_string_zero_terminated(struct nk_context *ctx, nk_flags flags,
|
|
|
+ char *buffer, int max, nk_plugin_filter filter)
|
|
|
+{
|
|
|
+ nk_flags result;
|
|
|
+ int len = nk_strlen(buffer);
|
|
|
+ result = nk_edit_string(ctx, flags, buffer, &len, max, filter);
|
|
|
+ buffer[NK_MIN(NK_MAX(max-1,0), len)] = '\0';
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * PROPERTY
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN struct nk_property_variant
|
|
|
+nk_property_variant_int(int value, int min_value, int max_value, int step)
|
|
|
+{
|
|
|
+ struct nk_property_variant result;
|
|
|
+ result.kind = NK_PROPERTY_INT;
|
|
|
+ result.value.i = value;
|
|
|
+ result.min_value.i = min_value;
|
|
|
+ result.max_value.i = max_value;
|
|
|
+ result.step.i = step;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_property_variant
|
|
|
+nk_property_variant_float(float value, float min_value, float max_value, float step)
|
|
|
+{
|
|
|
+ struct nk_property_variant result;
|
|
|
+ result.kind = NK_PROPERTY_FLOAT;
|
|
|
+ result.value.f = value;
|
|
|
+ result.min_value.f = min_value;
|
|
|
+ result.max_value.f = max_value;
|
|
|
+ result.step.f = step;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN struct nk_property_variant
|
|
|
+nk_property_variant_double(double value, double min_value, double max_value,
|
|
|
+ double step)
|
|
|
+{
|
|
|
+ struct nk_property_variant result;
|
|
|
+ result.kind = NK_PROPERTY_DOUBLE;
|
|
|
+ result.value.d = value;
|
|
|
+ result.min_value.d = min_value;
|
|
|
+ result.max_value.d = max_value;
|
|
|
+ result.step.d = step;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN 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)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ struct nk_input *in;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+
|
|
|
+ int *state = 0;
|
|
|
+ nk_hash hash = 0;
|
|
|
+ char *buffer = 0;
|
|
|
+ int *len = 0;
|
|
|
+ int *cursor = 0;
|
|
|
+ int *select_begin = 0;
|
|
|
+ int *select_end = 0;
|
|
|
+ int old_state;
|
|
|
+
|
|
|
+ char dummy_buffer[NK_MAX_NUMBER_BUFFER];
|
|
|
+ int dummy_state = NK_PROPERTY_DEFAULT;
|
|
|
+ int dummy_length = 0;
|
|
|
+ int dummy_cursor = 0;
|
|
|
+ int dummy_select_begin = 0;
|
|
|
+ int dummy_select_end = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&bounds, ctx);
|
|
|
+ if (!s) return;
|
|
|
+
|
|
|
+ /* calculate hash from name */
|
|
|
+ if (name[0] == '#') {
|
|
|
+ hash = nk_murmur_hash(name, (int)nk_strlen(name), win->property.seq++);
|
|
|
+ name++; /* special number hash */
|
|
|
+ } else hash = nk_murmur_hash(name, (int)nk_strlen(name), 42);
|
|
|
+
|
|
|
+ /* check if property is currently hot item */
|
|
|
+ if (win->property.active && hash == win->property.name) {
|
|
|
+ buffer = win->property.buffer;
|
|
|
+ len = &win->property.length;
|
|
|
+ cursor = &win->property.cursor;
|
|
|
+ state = &win->property.state;
|
|
|
+ select_begin = &win->property.select_start;
|
|
|
+ select_end = &win->property.select_end;
|
|
|
+ } else {
|
|
|
+ buffer = dummy_buffer;
|
|
|
+ len = &dummy_length;
|
|
|
+ cursor = &dummy_cursor;
|
|
|
+ state = &dummy_state;
|
|
|
+ select_begin = &dummy_select_begin;
|
|
|
+ select_end = &dummy_select_end;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* execute property widget */
|
|
|
+ old_state = *state;
|
|
|
+ ctx->text_edit.clip = ctx->clip;
|
|
|
+ in = ((s == NK_WIDGET_ROM && !win->property.active) ||
|
|
|
+ layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ nk_do_property(&ctx->last_widget_state, &win->buffer, bounds, name,
|
|
|
+ variant, inc_per_pixel, buffer, len, state, cursor, select_begin,
|
|
|
+ select_end, &style->property, filter, in, style->font, &ctx->text_edit,
|
|
|
+ ctx->button_behavior);
|
|
|
+
|
|
|
+ if (in && *state != NK_PROPERTY_DEFAULT && !win->property.active) {
|
|
|
+ /* current property is now hot */
|
|
|
+ win->property.active = 1;
|
|
|
+ NK_MEMCPY(win->property.buffer, buffer, (nk_size)*len);
|
|
|
+ win->property.length = *len;
|
|
|
+ win->property.cursor = *cursor;
|
|
|
+ win->property.state = *state;
|
|
|
+ win->property.name = hash;
|
|
|
+ win->property.select_start = *select_begin;
|
|
|
+ win->property.select_end = *select_end;
|
|
|
+ if (*state == NK_PROPERTY_DRAG) {
|
|
|
+ ctx->input.mouse.grab = nk_true;
|
|
|
+ ctx->input.mouse.grabbed = nk_true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* check if previously active property is now inactive */
|
|
|
+ if (*state == NK_PROPERTY_DEFAULT && old_state != NK_PROPERTY_DEFAULT) {
|
|
|
+ if (old_state == NK_PROPERTY_DRAG) {
|
|
|
+ ctx->input.mouse.grab = nk_false;
|
|
|
+ ctx->input.mouse.grabbed = nk_false;
|
|
|
+ ctx->input.mouse.ungrab = nk_true;
|
|
|
+ }
|
|
|
+ win->property.select_start = 0;
|
|
|
+ win->property.select_end = 0;
|
|
|
+ win->property.active = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_property_int(struct nk_context *ctx, const char *name,
|
|
|
+ int min, int *val, int max, int step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+ NK_ASSERT(val);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name || !val) return;
|
|
|
+ variant = nk_property_variant_int(*val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
|
|
|
+ *val = variant.value.i;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_property_float(struct nk_context *ctx, const char *name,
|
|
|
+ float min, float *val, float max, float step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+ NK_ASSERT(val);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name || !val) return;
|
|
|
+ variant = nk_property_variant_float(*val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
|
|
|
+ *val = variant.value.f;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_property_double(struct nk_context *ctx, const char *name,
|
|
|
+ double min, double *val, double max, double step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+ NK_ASSERT(val);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name || !val) return;
|
|
|
+ variant = nk_property_variant_double(*val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
|
|
|
+ *val = variant.value.d;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_propertyi(struct nk_context *ctx, const char *name, int min, int val,
|
|
|
+ int max, int step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name) return val;
|
|
|
+ variant = nk_property_variant_int(val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
|
|
|
+ val = variant.value.i;
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API float
|
|
|
+nk_propertyf(struct nk_context *ctx, const char *name, float min,
|
|
|
+ float val, float max, float step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name) return val;
|
|
|
+ variant = nk_property_variant_float(val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
|
|
|
+ val = variant.value.f;
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API double
|
|
|
+nk_propertyd(struct nk_context *ctx, const char *name, double min,
|
|
|
+ double val, double max, double step, float inc_per_pixel)
|
|
|
+{
|
|
|
+ struct nk_property_variant variant;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(name);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !name) return val;
|
|
|
+ variant = nk_property_variant_double(val, min, max, step);
|
|
|
+ nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
|
|
|
+ val = variant.value.d;
|
|
|
+ return val;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * COLOR PICKER
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_color_pick(struct nk_context * ctx, struct nk_color *color,
|
|
|
+ enum nk_color_format fmt)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *config;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(color);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !color)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ config = &ctx->style;
|
|
|
+ layout = win->layout;
|
|
|
+ state = nk_widget(&bounds, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ return nk_do_color_picker(&ctx->last_widget_state, &win->buffer, color, fmt, bounds,
|
|
|
+ nk_vec2(0,0), in, config->font);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API struct nk_color
|
|
|
+nk_color_picker(struct nk_context *ctx, struct nk_color color,
|
|
|
+ enum nk_color_format fmt)
|
|
|
+{
|
|
|
+ nk_color_pick(ctx, &color, fmt);
|
|
|
+ return color;
|
|
|
+}
|
|
|
+
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * CHART
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_chart_begin_colored(struct nk_context *ctx, enum nk_chart_type type,
|
|
|
+ struct nk_color color, struct nk_color highlight,
|
|
|
+ int count, float min_value, float max_value)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_chart *chart;
|
|
|
+ const struct nk_style *config;
|
|
|
+ const struct nk_style_chart *style;
|
|
|
+
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_rect bounds = {0, 0, 0, 0};
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return 0;
|
|
|
+ if (!nk_widget(&bounds, ctx)) {
|
|
|
+ chart = &ctx->current->layout->chart;
|
|
|
+ nk_zero(chart, sizeof(*chart));
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ config = &ctx->style;
|
|
|
+ chart = &win->layout->chart;
|
|
|
+ style = &config->chart;
|
|
|
+
|
|
|
+ /* setup basic generic chart */
|
|
|
+ nk_zero(chart, sizeof(*chart));
|
|
|
+ chart->x = bounds.x + style->padding.x;
|
|
|
+ chart->y = bounds.y + style->padding.y;
|
|
|
+ chart->w = bounds.w - 2 * style->padding.x;
|
|
|
+ chart->h = bounds.h - 2 * style->padding.y;
|
|
|
+ chart->w = NK_MAX(chart->w, 2 * style->padding.x);
|
|
|
+ chart->h = NK_MAX(chart->h, 2 * style->padding.y);
|
|
|
+
|
|
|
+ /* add first slot into chart */
|
|
|
+ {struct nk_chart_slot *slot = &chart->slots[chart->slot++];
|
|
|
+ slot->type = type;
|
|
|
+ slot->count = count;
|
|
|
+ slot->color = color;
|
|
|
+ slot->highlight = highlight;
|
|
|
+ slot->min = NK_MIN(min_value, max_value);
|
|
|
+ slot->max = NK_MAX(min_value, max_value);
|
|
|
+ slot->range = slot->max - slot->min;}
|
|
|
+
|
|
|
+ /* draw chart background */
|
|
|
+ background = &style->background;
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(&win->buffer, bounds, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(&win->buffer, bounds, style->rounding, style->border_color);
|
|
|
+ nk_fill_rect(&win->buffer, nk_shrink_rect(bounds, style->border),
|
|
|
+ style->rounding, style->background.data.color);
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_chart_begin(struct nk_context *ctx, const enum nk_chart_type type,
|
|
|
+ int count, float min_value, float max_value)
|
|
|
+{return nk_chart_begin_colored(ctx, type, ctx->style.chart.color, ctx->style.chart.selected_color, count, min_value, max_value);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type type,
|
|
|
+ struct nk_color color, struct nk_color highlight,
|
|
|
+ int count, float min_value, float max_value)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ NK_ASSERT(ctx->current->layout->chart.slot < NK_CHART_MAX_SLOT);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return;
|
|
|
+ if (ctx->current->layout->chart.slot >= NK_CHART_MAX_SLOT) return;
|
|
|
+
|
|
|
+ /* add another slot into the graph */
|
|
|
+ {struct nk_chart *chart = &ctx->current->layout->chart;
|
|
|
+ struct nk_chart_slot *slot = &chart->slots[chart->slot++];
|
|
|
+ slot->type = type;
|
|
|
+ slot->count = count;
|
|
|
+ slot->color = color;
|
|
|
+ slot->highlight = highlight;
|
|
|
+ slot->min = NK_MIN(min_value, max_value);
|
|
|
+ slot->max = NK_MAX(min_value, max_value);
|
|
|
+ slot->range = slot->max - slot->min;}
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_chart_add_slot(struct nk_context *ctx, const enum nk_chart_type type,
|
|
|
+ int count, float min_value, float max_value)
|
|
|
+{nk_chart_add_slot_colored(ctx, type, ctx->style.chart.color, ctx->style.chart.selected_color, count, min_value, max_value);}
|
|
|
+
|
|
|
+NK_INTERN nk_flags
|
|
|
+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_command_buffer *out = &win->buffer;
|
|
|
+
|
|
|
+ nk_flags ret = 0;
|
|
|
+ struct nk_vec2 cur;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_color color;
|
|
|
+ float step;
|
|
|
+ float range;
|
|
|
+ float ratio;
|
|
|
+
|
|
|
+ NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT);
|
|
|
+ step = g->w / (float)g->slots[slot].count;
|
|
|
+ range = g->slots[slot].max - g->slots[slot].min;
|
|
|
+ ratio = (value - g->slots[slot].min) / range;
|
|
|
+
|
|
|
+ if (g->slots[slot].index == 0) {
|
|
|
+ /* first data point does not have a connection */
|
|
|
+ g->slots[slot].last.x = g->x;
|
|
|
+ g->slots[slot].last.y = (g->y + g->h) - ratio * (float)g->h;
|
|
|
+
|
|
|
+ bounds.x = g->slots[slot].last.x - 2;
|
|
|
+ bounds.y = g->slots[slot].last.y - 2;
|
|
|
+ bounds.w = bounds.h = 4;
|
|
|
+
|
|
|
+ color = g->slots[slot].color;
|
|
|
+ if (!(layout->flags & NK_WINDOW_ROM) &&
|
|
|
+ NK_INBOX(i->mouse.pos.x,i->mouse.pos.y, g->slots[slot].last.x-3, g->slots[slot].last.y-3, 6, 6)){
|
|
|
+ ret = nk_input_is_mouse_hovering_rect(i, bounds) ? NK_CHART_HOVERING : 0;
|
|
|
+ ret |= (i->mouse.buttons[NK_BUTTON_LEFT].down &&
|
|
|
+ i->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0;
|
|
|
+ color = g->slots[slot].highlight;
|
|
|
+ }
|
|
|
+ nk_fill_rect(out, bounds, 0, color);
|
|
|
+ g->slots[slot].index += 1;
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* draw a line between the last data point and the new one */
|
|
|
+ color = g->slots[slot].color;
|
|
|
+ cur.x = g->x + (float)(step * (float)g->slots[slot].index);
|
|
|
+ cur.y = (g->y + g->h) - (ratio * (float)g->h);
|
|
|
+ nk_stroke_line(out, g->slots[slot].last.x, g->slots[slot].last.y, cur.x, cur.y, 1.0f, color);
|
|
|
+
|
|
|
+ bounds.x = cur.x - 3;
|
|
|
+ bounds.y = cur.y - 3;
|
|
|
+ bounds.w = bounds.h = 6;
|
|
|
+
|
|
|
+ /* user selection of current data point */
|
|
|
+ if (!(layout->flags & NK_WINDOW_ROM)) {
|
|
|
+ if (nk_input_is_mouse_hovering_rect(i, bounds)) {
|
|
|
+ ret = NK_CHART_HOVERING;
|
|
|
+ ret |= (!i->mouse.buttons[NK_BUTTON_LEFT].down &&
|
|
|
+ i->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0;
|
|
|
+ color = g->slots[slot].highlight;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ nk_fill_rect(out, nk_rect(cur.x - 2, cur.y - 2, 4, 4), 0, color);
|
|
|
+
|
|
|
+ /* save current data point position */
|
|
|
+ g->slots[slot].last.x = cur.x;
|
|
|
+ g->slots[slot].last.y = cur.y;
|
|
|
+ g->slots[slot].index += 1;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN nk_flags
|
|
|
+nk_chart_push_column(const struct nk_context *ctx, struct nk_window *win,
|
|
|
+ struct nk_chart *chart, float value, int slot)
|
|
|
+{
|
|
|
+ struct nk_command_buffer *out = &win->buffer;
|
|
|
+ const struct nk_input *in = &ctx->input;
|
|
|
+ struct nk_panel *layout = win->layout;
|
|
|
+
|
|
|
+ float ratio;
|
|
|
+ nk_flags ret = 0;
|
|
|
+ struct nk_color color;
|
|
|
+ struct nk_rect item = {0,0,0,0};
|
|
|
+
|
|
|
+ NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT);
|
|
|
+ if (chart->slots[slot].index >= chart->slots[slot].count)
|
|
|
+ return nk_false;
|
|
|
+ if (chart->slots[slot].count) {
|
|
|
+ float padding = (float)(chart->slots[slot].count-1);
|
|
|
+ item.w = (chart->w - padding) / (float)(chart->slots[slot].count);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* calculate bounds of current bar chart entry */
|
|
|
+ color = chart->slots[slot].color;;
|
|
|
+ item.h = chart->h * NK_ABS((value/chart->slots[slot].range));
|
|
|
+ if (value >= 0) {
|
|
|
+ ratio = (value + NK_ABS(chart->slots[slot].min)) / NK_ABS(chart->slots[slot].range);
|
|
|
+ item.y = (chart->y + chart->h) - chart->h * ratio;
|
|
|
+ } else {
|
|
|
+ ratio = (value - chart->slots[slot].max) / chart->slots[slot].range;
|
|
|
+ item.y = chart->y + (chart->h * NK_ABS(ratio)) - item.h;
|
|
|
+ }
|
|
|
+ item.x = chart->x + ((float)chart->slots[slot].index * item.w);
|
|
|
+ item.x = item.x + ((float)chart->slots[slot].index);
|
|
|
+
|
|
|
+ /* user chart bar selection */
|
|
|
+ if (!(layout->flags & NK_WINDOW_ROM) &&
|
|
|
+ NK_INBOX(in->mouse.pos.x,in->mouse.pos.y,item.x,item.y,item.w,item.h)) {
|
|
|
+ ret = NK_CHART_HOVERING;
|
|
|
+ ret |= (!in->mouse.buttons[NK_BUTTON_LEFT].down &&
|
|
|
+ in->mouse.buttons[NK_BUTTON_LEFT].clicked) ? NK_CHART_CLICKED: 0;
|
|
|
+ color = chart->slots[slot].highlight;
|
|
|
+ }
|
|
|
+ nk_fill_rect(out, item, 0, color);
|
|
|
+ chart->slots[slot].index += 1;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_chart_push_slot(struct nk_context *ctx, float value, int slot)
|
|
|
+{
|
|
|
+ nk_flags flags;
|
|
|
+ struct nk_window *win;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(slot >= 0 && slot < NK_CHART_MAX_SLOT);
|
|
|
+ NK_ASSERT(slot < ctx->current->layout->chart.slot);
|
|
|
+ if (!ctx || !ctx->current || slot >= NK_CHART_MAX_SLOT) return nk_false;
|
|
|
+ if (slot >= ctx->current->layout->chart.slot) return nk_false;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ if (win->layout->chart.slot < slot) return nk_false;
|
|
|
+ switch (win->layout->chart.slots[slot].type) {
|
|
|
+ case NK_CHART_LINES:
|
|
|
+ flags = nk_chart_push_line(ctx, win, &win->layout->chart, value, slot); break;
|
|
|
+ case NK_CHART_COLUMN:
|
|
|
+ flags = nk_chart_push_column(ctx, win, &win->layout->chart, value, slot); break;
|
|
|
+ default:
|
|
|
+ case NK_CHART_MAX:
|
|
|
+ flags = 0;
|
|
|
+ }
|
|
|
+ return flags;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API nk_flags
|
|
|
+nk_chart_push(struct nk_context *ctx, float value)
|
|
|
+{return nk_chart_push_slot(ctx, value, 0);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_chart_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_chart *chart;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ chart = &win->layout->chart;
|
|
|
+ NK_MEMSET(chart, 0, sizeof(*chart));
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_plot(struct nk_context *ctx, enum nk_chart_type type, const float *values,
|
|
|
+ int count, int offset)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ float min_value;
|
|
|
+ float max_value;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(values);
|
|
|
+ if (!ctx || !values || !count) return;
|
|
|
+
|
|
|
+ min_value = values[offset];
|
|
|
+ max_value = values[offset];
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ min_value = NK_MIN(values[i + offset], min_value);
|
|
|
+ max_value = NK_MAX(values[i + offset], max_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nk_chart_begin(ctx, type, count, min_value, max_value)) {
|
|
|
+ for (i = 0; i < count; ++i)
|
|
|
+ nk_chart_push(ctx, values[i + offset]);
|
|
|
+ nk_chart_end(ctx);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_plot_function(struct nk_context *ctx, enum nk_chart_type type, void *userdata,
|
|
|
+ float(*value_getter)(void* user, int index), int count, int offset)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ float min_value;
|
|
|
+ float max_value;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(value_getter);
|
|
|
+ if (!ctx || !value_getter || !count) return;
|
|
|
+
|
|
|
+ max_value = min_value = value_getter(userdata, offset);
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ float value = value_getter(userdata, i + offset);
|
|
|
+ min_value = NK_MIN(value, min_value);
|
|
|
+ max_value = NK_MAX(value, max_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nk_chart_begin(ctx, type, count, min_value, max_value)) {
|
|
|
+ for (i = 0; i < count; ++i)
|
|
|
+ nk_chart_push(ctx, value_getter(userdata, i + offset));
|
|
|
+ nk_chart_end(ctx);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * GROUP
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_group_scrolled_offset_begin(struct nk_context *ctx,
|
|
|
+ nk_uint *x_offset, nk_uint *y_offset, const char *title, nk_flags flags)
|
|
|
+{
|
|
|
+ struct nk_rect bounds;
|
|
|
+ struct nk_window panel;
|
|
|
+ struct nk_window *win;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ nk_panel_alloc_space(&bounds, ctx);
|
|
|
+ {const struct nk_rect *c = &win->layout->clip;
|
|
|
+ if (!NK_INTERSECT(c->x, c->y, c->w, c->h, bounds.x, bounds.y, bounds.w, bounds.h) &&
|
|
|
+ !(flags & NK_WINDOW_MOVABLE)) {
|
|
|
+ return 0;
|
|
|
+ }}
|
|
|
+ if (win->flags & NK_WINDOW_ROM)
|
|
|
+ flags |= NK_WINDOW_ROM;
|
|
|
+
|
|
|
+ /* initialize a fake window to create the panel from */
|
|
|
+ nk_zero(&panel, sizeof(panel));
|
|
|
+ panel.bounds = bounds;
|
|
|
+ panel.flags = flags;
|
|
|
+ panel.scrollbar.x = *x_offset;
|
|
|
+ panel.scrollbar.y = *y_offset;
|
|
|
+ panel.buffer = win->buffer;
|
|
|
+ panel.layout = (struct nk_panel*)nk_create_panel(ctx);
|
|
|
+ ctx->current = &panel;
|
|
|
+ nk_panel_begin(ctx, (flags & NK_WINDOW_TITLE) ? title: 0, NK_PANEL_GROUP);
|
|
|
+
|
|
|
+ win->buffer = panel.buffer;
|
|
|
+ win->buffer.clip = panel.layout->clip;
|
|
|
+ panel.layout->offset_x = x_offset;
|
|
|
+ panel.layout->offset_y = y_offset;
|
|
|
+ panel.layout->parent = win->layout;
|
|
|
+ win->layout = panel.layout;
|
|
|
+
|
|
|
+ ctx->current = win;
|
|
|
+ if ((panel.layout->flags & NK_WINDOW_CLOSED) ||
|
|
|
+ (panel.layout->flags & NK_WINDOW_MINIMIZED))
|
|
|
+ {
|
|
|
+ nk_flags f = panel.layout->flags;
|
|
|
+ nk_group_scrolled_end(ctx);
|
|
|
+ if (f & NK_WINDOW_CLOSED)
|
|
|
+ return NK_WINDOW_CLOSED;
|
|
|
+ if (f & NK_WINDOW_MINIMIZED)
|
|
|
+ return NK_WINDOW_MINIMIZED;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_group_scrolled_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *parent;
|
|
|
+ struct nk_panel *g;
|
|
|
+
|
|
|
+ struct nk_rect clip;
|
|
|
+ struct nk_window pan;
|
|
|
+ struct nk_vec2 panel_padding;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* make sure nk_group_begin was called correctly */
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ win = ctx->current;
|
|
|
+ NK_ASSERT(win->layout);
|
|
|
+ g = win->layout;
|
|
|
+ NK_ASSERT(g->parent);
|
|
|
+ parent = g->parent;
|
|
|
+
|
|
|
+ /* dummy window */
|
|
|
+ nk_zero_struct(pan);
|
|
|
+ panel_padding = nk_panel_get_padding(&ctx->style, NK_PANEL_GROUP);
|
|
|
+ pan.bounds.y = g->bounds.y - (g->header_height + g->menu.h);
|
|
|
+ pan.bounds.x = g->bounds.x - panel_padding.x;
|
|
|
+ pan.bounds.w = g->bounds.w + 2 * panel_padding.x;
|
|
|
+ pan.bounds.h = g->bounds.h + g->header_height + g->menu.h;
|
|
|
+ if (g->flags & NK_WINDOW_BORDER) {
|
|
|
+ pan.bounds.x -= g->border;
|
|
|
+ pan.bounds.y -= g->border;
|
|
|
+ pan.bounds.w += 2*g->border;
|
|
|
+ pan.bounds.h += 2*g->border;
|
|
|
+ }
|
|
|
+ if (!(g->flags & NK_WINDOW_NO_SCROLLBAR)) {
|
|
|
+ pan.bounds.w += ctx->style.window.scrollbar_size.x;
|
|
|
+ pan.bounds.h += ctx->style.window.scrollbar_size.y;
|
|
|
+ }
|
|
|
+ pan.scrollbar.x = *g->offset_x;
|
|
|
+ pan.scrollbar.y = *g->offset_y;
|
|
|
+ pan.flags = g->flags;
|
|
|
+ pan.buffer = win->buffer;
|
|
|
+ pan.layout = g;
|
|
|
+ pan.parent = win;
|
|
|
+ ctx->current = &pan;
|
|
|
+
|
|
|
+ /* make sure group has correct clipping rectangle */
|
|
|
+ nk_unify(&clip, &parent->clip, pan.bounds.x, pan.bounds.y,
|
|
|
+ pan.bounds.x + pan.bounds.w, pan.bounds.y + pan.bounds.h + panel_padding.x);
|
|
|
+ nk_push_scissor(&pan.buffer, clip);
|
|
|
+ nk_end(ctx);
|
|
|
+
|
|
|
+ win->buffer = pan.buffer;
|
|
|
+ nk_push_scissor(&win->buffer, parent->clip);
|
|
|
+ ctx->current = win;
|
|
|
+ win->layout = parent;
|
|
|
+ g->bounds = pan.bounds;
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_group_scrolled_begin(struct nk_context *ctx,
|
|
|
+ struct nk_scroll *scroll, const char *title, nk_flags flags)
|
|
|
+{return nk_group_scrolled_offset_begin(ctx, &scroll->x, &scroll->y, title, flags);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_group_begin(struct nk_context *ctx, const char *title, nk_flags flags)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ struct nk_window *win;
|
|
|
+ nk_uint *x_offset;
|
|
|
+ nk_uint *y_offset;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(title);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !title)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* find persistent group scrollbar value */
|
|
|
+ win = ctx->current;
|
|
|
+ title_len = (int)nk_strlen(title);
|
|
|
+ title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_GROUP);
|
|
|
+ x_offset = nk_find_value(win, title_hash);
|
|
|
+ if (!x_offset) {
|
|
|
+ x_offset = nk_add_value(ctx, win, title_hash, 0);
|
|
|
+ y_offset = nk_add_value(ctx, win, title_hash+1, 0);
|
|
|
+
|
|
|
+ NK_ASSERT(x_offset);
|
|
|
+ NK_ASSERT(y_offset);
|
|
|
+ if (!x_offset || !y_offset) return 0;
|
|
|
+ *x_offset = *y_offset = 0;
|
|
|
+ } else y_offset = nk_find_value(win, title_hash+1);
|
|
|
+ return nk_group_scrolled_offset_begin(ctx, x_offset, y_offset, title, flags);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_group_end(struct nk_context *ctx)
|
|
|
+{nk_group_scrolled_end(ctx);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_list_view_begin(struct nk_context *ctx, struct nk_list_view *view,
|
|
|
+ const char *title, nk_flags flags, int row_height, int row_count)
|
|
|
+{
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ nk_uint *x_offset;
|
|
|
+ nk_uint *y_offset;
|
|
|
+
|
|
|
+ int result;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+ const struct nk_style *style;
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(view);
|
|
|
+ NK_ASSERT(title);
|
|
|
+ if (!ctx || !view || !title) return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ item_spacing = style->window.spacing;
|
|
|
+ row_height += NK_MAX(0, (int)item_spacing.y);
|
|
|
+
|
|
|
+ /* find persistent list view scrollbar offset */
|
|
|
+ title_len = (int)nk_strlen(title);
|
|
|
+ title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_GROUP);
|
|
|
+ x_offset = nk_find_value(win, title_hash);
|
|
|
+ if (!x_offset) {
|
|
|
+ x_offset = nk_add_value(ctx, win, title_hash, 0);
|
|
|
+ y_offset = nk_add_value(ctx, win, title_hash+1, 0);
|
|
|
+
|
|
|
+ NK_ASSERT(x_offset);
|
|
|
+ NK_ASSERT(y_offset);
|
|
|
+ if (!x_offset || !y_offset) return 0;
|
|
|
+ *x_offset = *y_offset = 0;
|
|
|
+ } else y_offset = nk_find_value(win, title_hash+1);
|
|
|
+ view->scroll_value = *y_offset;
|
|
|
+ view->scroll_pointer = y_offset;
|
|
|
+
|
|
|
+ *y_offset = 0;
|
|
|
+ result = nk_group_scrolled_offset_begin(ctx, x_offset, y_offset, title, flags);
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+
|
|
|
+ view->total_height = row_height * NK_MAX(row_count,1);
|
|
|
+ view->begin = (int)NK_MAX(((float)view->scroll_value / (float)row_height), 0.0f);
|
|
|
+ view->count = (int)NK_MAX(nk_iceilf((layout->clip.h)/(float)row_height), 0);
|
|
|
+ view->end = view->begin + view->count;
|
|
|
+ view->ctx = ctx;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_list_view_end(struct nk_list_view *view)
|
|
|
+{
|
|
|
+ struct nk_context *ctx;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *layout;
|
|
|
+
|
|
|
+ NK_ASSERT(view);
|
|
|
+ NK_ASSERT(view->ctx);
|
|
|
+ NK_ASSERT(view->scroll_pointer);
|
|
|
+ if (!view || !view->ctx) return;
|
|
|
+
|
|
|
+ ctx = view->ctx;
|
|
|
+ win = ctx->current;
|
|
|
+ layout = win->layout;
|
|
|
+ layout->at_y = layout->bounds.y + (float)view->total_height;
|
|
|
+ *view->scroll_pointer = *view->scroll_pointer + view->scroll_value;
|
|
|
+ nk_group_end(view->ctx);
|
|
|
+}
|
|
|
+
|
|
|
+/* --------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * POPUP
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_API int
|
|
|
+nk_popup_begin(struct nk_context *ctx, enum nk_popup_type type,
|
|
|
+ const char *title, nk_flags flags, struct nk_rect rect)
|
|
|
+{
|
|
|
+ struct nk_window *popup;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *panel;
|
|
|
+
|
|
|
+ int title_len;
|
|
|
+ nk_hash title_hash;
|
|
|
+ nk_size allocated;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(title);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ panel = win->layout;
|
|
|
+ NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP) && "popups are not allowed to have popups");
|
|
|
+ (void)panel;
|
|
|
+ title_len = (int)nk_strlen(title);
|
|
|
+ title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_POPUP);
|
|
|
+
|
|
|
+ popup = win->popup.win;
|
|
|
+ if (!popup) {
|
|
|
+ popup = (struct nk_window*)nk_create_window(ctx);
|
|
|
+ popup->parent = win;
|
|
|
+ win->popup.win = popup;
|
|
|
+ win->popup.active = 0;
|
|
|
+ win->popup.type = NK_PANEL_POPUP;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* make sure we have correct popup */
|
|
|
+ if (win->popup.name != title_hash) {
|
|
|
+ if (!win->popup.active) {
|
|
|
+ nk_zero(popup, sizeof(*popup));
|
|
|
+ win->popup.name = title_hash;
|
|
|
+ win->popup.active = 1;
|
|
|
+ win->popup.type = NK_PANEL_POPUP;
|
|
|
+ } else return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* popup position is local to window */
|
|
|
+ ctx->current = popup;
|
|
|
+ rect.x += win->layout->clip.x;
|
|
|
+ rect.y += win->layout->clip.y;
|
|
|
+
|
|
|
+ /* setup popup data */
|
|
|
+ popup->parent = win;
|
|
|
+ popup->bounds = rect;
|
|
|
+ popup->seq = ctx->seq;
|
|
|
+ popup->layout = (struct nk_panel*)nk_create_panel(ctx);
|
|
|
+ popup->flags = flags;
|
|
|
+ popup->flags |= NK_WINDOW_BORDER;
|
|
|
+ if (type == NK_POPUP_DYNAMIC)
|
|
|
+ popup->flags |= NK_WINDOW_DYNAMIC;
|
|
|
+
|
|
|
+ popup->buffer = win->buffer;
|
|
|
+ nk_start_popup(ctx, win);
|
|
|
+ allocated = ctx->memory.allocated;
|
|
|
+ nk_push_scissor(&popup->buffer, nk_null_rect);
|
|
|
+
|
|
|
+ if (nk_panel_begin(ctx, title, NK_PANEL_POPUP)) {
|
|
|
+ /* popup is running therefore invalidate parent panels */
|
|
|
+ struct nk_panel *root;
|
|
|
+ root = win->layout;
|
|
|
+ while (root) {
|
|
|
+ root->flags |= NK_WINDOW_ROM;
|
|
|
+ root->flags &= ~(nk_flags)NK_WINDOW_REMOVE_ROM;
|
|
|
+ root = root->parent;
|
|
|
+ }
|
|
|
+ win->popup.active = 1;
|
|
|
+ popup->layout->offset_x = &popup->scrollbar.x;
|
|
|
+ popup->layout->offset_y = &popup->scrollbar.y;
|
|
|
+ popup->layout->parent = win->layout;
|
|
|
+ return 1;
|
|
|
+ } else {
|
|
|
+ /* popup was closed/is invalid so cleanup */
|
|
|
+ struct nk_panel *root;
|
|
|
+ root = win->layout;
|
|
|
+ while (root) {
|
|
|
+ root->flags |= NK_WINDOW_REMOVE_ROM;
|
|
|
+ root = root->parent;
|
|
|
+ }
|
|
|
+ win->popup.buf.active = 0;
|
|
|
+ win->popup.active = 0;
|
|
|
+ ctx->memory.allocated = allocated;
|
|
|
+ ctx->current = win;
|
|
|
+ nk_free_panel(ctx, popup->layout);
|
|
|
+ popup->layout = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+NK_INTERN int
|
|
|
+nk_nonblock_begin(struct nk_context *ctx,
|
|
|
+ nk_flags flags, struct nk_rect body, struct nk_rect header,
|
|
|
+ enum nk_panel_type panel_type)
|
|
|
+{
|
|
|
+ struct nk_window *popup;
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_panel *panel;
|
|
|
+ int is_active = nk_true;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* popups cannot have popups */
|
|
|
+ win = ctx->current;
|
|
|
+ panel = win->layout;
|
|
|
+ NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP));
|
|
|
+ (void)panel;
|
|
|
+ popup = win->popup.win;
|
|
|
+ if (!popup) {
|
|
|
+ /* create window for nonblocking popup */
|
|
|
+ popup = (struct nk_window*)nk_create_window(ctx);
|
|
|
+ popup->parent = win;
|
|
|
+ win->popup.win = popup;
|
|
|
+ win->popup.type = panel_type;
|
|
|
+ nk_command_buffer_init(&popup->buffer, &ctx->memory, NK_CLIPPING_ON);
|
|
|
+ } else {
|
|
|
+ /* close the popup if user pressed outside or in the header */
|
|
|
+ int pressed, in_body, in_header;
|
|
|
+ pressed = nk_input_is_mouse_pressed(&ctx->input, NK_BUTTON_LEFT);
|
|
|
+ in_body = nk_input_is_mouse_hovering_rect(&ctx->input, body);
|
|
|
+ in_header = nk_input_is_mouse_hovering_rect(&ctx->input, header);
|
|
|
+ if (pressed && (!in_body || in_header))
|
|
|
+ is_active = nk_false;
|
|
|
+ }
|
|
|
+ win->popup.header = header;
|
|
|
+
|
|
|
+ if (!is_active) {
|
|
|
+ /* remove read only mode from all parent panels */
|
|
|
+ struct nk_panel *root = win->layout;
|
|
|
+ while (root) {
|
|
|
+ root->flags |= NK_WINDOW_REMOVE_ROM;
|
|
|
+ root = root->parent;
|
|
|
+ }
|
|
|
+ return is_active;
|
|
|
+ }
|
|
|
+
|
|
|
+ popup->bounds = body;
|
|
|
+ popup->parent = win;
|
|
|
+ popup->layout = (struct nk_panel*)nk_create_panel(ctx);
|
|
|
+ popup->flags = flags;
|
|
|
+ popup->flags |= NK_WINDOW_BORDER;
|
|
|
+ popup->flags |= NK_WINDOW_DYNAMIC;
|
|
|
+ popup->seq = ctx->seq;
|
|
|
+ win->popup.active = 1;
|
|
|
+ NK_ASSERT(popup->layout);
|
|
|
+
|
|
|
+ nk_start_popup(ctx, win);
|
|
|
+ popup->buffer = win->buffer;
|
|
|
+ nk_push_scissor(&popup->buffer, nk_null_rect);
|
|
|
+ ctx->current = popup;
|
|
|
+
|
|
|
+ nk_panel_begin(ctx, 0, panel_type);
|
|
|
+ win->buffer = popup->buffer;
|
|
|
+ popup->layout->parent = win->layout;
|
|
|
+ popup->layout->offset_x = &popup->scrollbar.x;
|
|
|
+ popup->layout->offset_y = &popup->scrollbar.y;
|
|
|
+
|
|
|
+ /* set read only mode to all parent panels */
|
|
|
+ {struct nk_panel *root;
|
|
|
+ root = win->layout;
|
|
|
+ while (root) {
|
|
|
+ root->flags |= NK_WINDOW_ROM;
|
|
|
+ root = root->parent;
|
|
|
+ }}
|
|
|
+ return is_active;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_popup_close(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *popup;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+
|
|
|
+ popup = ctx->current;
|
|
|
+ NK_ASSERT(popup->parent);
|
|
|
+ NK_ASSERT(popup->layout->type & NK_PANEL_SET_POPUP);
|
|
|
+ popup->flags |= NK_WINDOW_HIDDEN;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_popup_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_window *popup;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return;
|
|
|
+
|
|
|
+ popup = ctx->current;
|
|
|
+ if (!popup->parent) return;
|
|
|
+ win = popup->parent;
|
|
|
+ if (popup->flags & NK_WINDOW_HIDDEN) {
|
|
|
+ struct nk_panel *root;
|
|
|
+ root = win->layout;
|
|
|
+ while (root) {
|
|
|
+ root->flags |= NK_WINDOW_REMOVE_ROM;
|
|
|
+ root = root->parent;
|
|
|
+ }
|
|
|
+ win->popup.active = 0;
|
|
|
+ }
|
|
|
+ nk_push_scissor(&popup->buffer, nk_null_rect);
|
|
|
+ nk_end(ctx);
|
|
|
+
|
|
|
+ win->buffer = popup->buffer;
|
|
|
+ nk_finish_popup(ctx, win);
|
|
|
+ ctx->current = win;
|
|
|
+ nk_push_scissor(&win->buffer, win->layout->clip);
|
|
|
+}
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * TOOLTIP
|
|
|
+ *
|
|
|
+ * -------------------------------------------------------------- */
|
|
|
+NK_API int
|
|
|
+nk_tooltip_begin(struct nk_context *ctx, float width)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ const struct nk_input *in;
|
|
|
+ struct nk_rect bounds;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* make sure that no nonblocking popup is currently active */
|
|
|
+ win = ctx->current;
|
|
|
+ in = &ctx->input;
|
|
|
+ if (win->popup.win && (win->popup.type & NK_PANEL_SET_NONBLOCK))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ bounds.w = width;
|
|
|
+ bounds.h = nk_null_rect.h;
|
|
|
+ bounds.x = (in->mouse.pos.x + 1) - win->layout->clip.x;
|
|
|
+ bounds.y = (in->mouse.pos.y + 1) - win->layout->clip.y;
|
|
|
+
|
|
|
+ ret = nk_popup_begin(ctx, NK_POPUP_DYNAMIC,
|
|
|
+ "__##Tooltip##__", NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER, bounds);
|
|
|
+ if (ret) win->layout->flags &= ~(nk_flags)NK_WINDOW_ROM;
|
|
|
+ win->popup.type = NK_PANEL_TOOLTIP;
|
|
|
+ ctx->current->layout->type = NK_PANEL_TOOLTIP;
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_tooltip_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+ ctx->current->seq--;
|
|
|
+ nk_popup_close(ctx);
|
|
|
+ nk_popup_end(ctx);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_tooltip(struct nk_context *ctx, const char *text)
|
|
|
+{
|
|
|
+ const struct nk_style *style;
|
|
|
+ struct nk_vec2 padding;
|
|
|
+
|
|
|
+ int text_len;
|
|
|
+ float text_width;
|
|
|
+ float text_height;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ NK_ASSERT(text);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !text)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* fetch configuration data */
|
|
|
+ style = &ctx->style;
|
|
|
+ padding = style->window.padding;
|
|
|
+
|
|
|
+ /* calculate size of the text and tooltip */
|
|
|
+ text_len = nk_strlen(text);
|
|
|
+ text_width = style->font->width(style->font->userdata,
|
|
|
+ style->font->height, text, text_len);
|
|
|
+ text_width += (4 * padding.x);
|
|
|
+ text_height = (style->font->height + 2 * padding.y);
|
|
|
+
|
|
|
+ /* execute tooltip and fill with text */
|
|
|
+ if (nk_tooltip_begin(ctx, (float)text_width)) {
|
|
|
+ nk_layout_row_dynamic(ctx, (float)text_height, 1);
|
|
|
+ nk_text(ctx, text, text_len, NK_TEXT_LEFT);
|
|
|
+ nk_tooltip_end(ctx);
|
|
|
+ }
|
|
|
+}
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * CONTEXTUAL
|
|
|
+ *
|
|
|
+ * -------------------------------------------------------------- */
|
|
|
+NK_API int
|
|
|
+nk_contextual_begin(struct nk_context *ctx, nk_flags flags, struct nk_vec2 size,
|
|
|
+ struct nk_rect trigger_bounds)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_window *popup;
|
|
|
+ struct nk_rect body;
|
|
|
+
|
|
|
+ NK_STORAGE const struct nk_rect null_rect = {0,0,0,0};
|
|
|
+ int is_clicked = 0;
|
|
|
+ int is_active = 0;
|
|
|
+ int is_open = 0;
|
|
|
+ int ret = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ ++win->popup.con_count;
|
|
|
+
|
|
|
+ /* check if currently active contextual is active */
|
|
|
+ popup = win->popup.win;
|
|
|
+ is_open = (popup && win->popup.type == NK_PANEL_CONTEXTUAL);
|
|
|
+ is_clicked = nk_input_mouse_clicked(&ctx->input, NK_BUTTON_RIGHT, trigger_bounds);
|
|
|
+ if (win->popup.active_con && win->popup.con_count != win->popup.active_con)
|
|
|
+ return 0;
|
|
|
+ if ((is_clicked && is_open && !is_active) || (!is_open && !is_active && !is_clicked))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* calculate contextual position on click */
|
|
|
+ win->popup.active_con = win->popup.con_count;
|
|
|
+ if (is_clicked) {
|
|
|
+ body.x = ctx->input.mouse.pos.x;
|
|
|
+ body.y = ctx->input.mouse.pos.y;
|
|
|
+ } else {
|
|
|
+ body.x = popup->bounds.x;
|
|
|
+ body.y = popup->bounds.y;
|
|
|
+ }
|
|
|
+ body.w = size.x;
|
|
|
+ body.h = size.y;
|
|
|
+
|
|
|
+ /* start nonblocking contextual popup */
|
|
|
+ ret = nk_nonblock_begin(ctx, flags|NK_WINDOW_NO_SCROLLBAR, body,
|
|
|
+ null_rect, NK_PANEL_CONTEXTUAL);
|
|
|
+ if (ret) win->popup.type = NK_PANEL_CONTEXTUAL;
|
|
|
+ else {
|
|
|
+ win->popup.active_con = 0;
|
|
|
+ if (win->popup.win)
|
|
|
+ win->popup.win->flags = 0;
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding);
|
|
|
+ if (!state) return nk_false;
|
|
|
+
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ text, len, alignment, NK_BUTTON_DEFAULT, &style->contextual_button, in, style->font)) {
|
|
|
+ nk_contextual_close(ctx);
|
|
|
+ return nk_true;
|
|
|
+ }
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_contextual_item_label(struct nk_context *ctx, const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_text(ctx, label, nk_strlen(label), align);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding);
|
|
|
+ if (!state) return nk_false;
|
|
|
+
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ img, text, len, align, NK_BUTTON_DEFAULT, &style->contextual_button, style->font, in)){
|
|
|
+ nk_contextual_close(ctx);
|
|
|
+ return nk_true;
|
|
|
+ }
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_contextual_item_image_label(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_image_text(ctx, img, label, nk_strlen(label), align);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_contextual_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbol,
|
|
|
+ const char *text, int len, nk_flags align)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ const struct nk_input *in;
|
|
|
+ const struct nk_style *style;
|
|
|
+
|
|
|
+ struct nk_rect bounds;
|
|
|
+ enum nk_widget_layout_states state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding);
|
|
|
+ if (!state) return nk_false;
|
|
|
+
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
|
|
|
+ symbol, text, len, align, NK_BUTTON_DEFAULT, &style->contextual_button, style->font, in)) {
|
|
|
+ nk_contextual_close(ctx);
|
|
|
+ return nk_true;
|
|
|
+ }
|
|
|
+ return nk_false;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_contextual_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type symbol,
|
|
|
+ const char *text, nk_flags align)
|
|
|
+{return nk_contextual_item_symbol_text(ctx, symbol, text, nk_strlen(text), align);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_contextual_close(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout) return;
|
|
|
+ nk_popup_close(ctx);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_contextual_end(struct nk_context *ctx)
|
|
|
+{
|
|
|
+ struct nk_window *popup;
|
|
|
+ struct nk_panel *panel;
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !ctx->current) return;
|
|
|
+
|
|
|
+ popup = ctx->current;
|
|
|
+ panel = popup->layout;
|
|
|
+ NK_ASSERT(popup->parent);
|
|
|
+ NK_ASSERT(panel->type & NK_PANEL_SET_POPUP);
|
|
|
+ if (panel->flags & NK_WINDOW_DYNAMIC) {
|
|
|
+ /* Close behavior
|
|
|
+ This is a bit of a hack solution since we do not know before we end our popup
|
|
|
+ how big it will be. We therefore do not directly know when a
|
|
|
+ click outside the non-blocking popup must close it at that direct frame.
|
|
|
+ Instead it will be closed in the next frame.*/
|
|
|
+ struct nk_rect body = {0,0,0,0};
|
|
|
+ if (panel->at_y < (panel->bounds.y + panel->bounds.h)) {
|
|
|
+ struct nk_vec2 padding = nk_panel_get_padding(&ctx->style, panel->type);
|
|
|
+ body = panel->bounds;
|
|
|
+ body.y = (panel->at_y + panel->footer_height + panel->border + padding.y + panel->row.height);
|
|
|
+ body.h = (panel->bounds.y + panel->bounds.h) - body.y;
|
|
|
+ }
|
|
|
+ {int pressed = nk_input_is_mouse_pressed(&ctx->input, NK_BUTTON_LEFT);
|
|
|
+ int in_body = nk_input_is_mouse_hovering_rect(&ctx->input, body);
|
|
|
+ if (pressed && in_body)
|
|
|
+ popup->flags |= NK_WINDOW_HIDDEN;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (popup->flags & NK_WINDOW_HIDDEN)
|
|
|
+ popup->seq = 0;
|
|
|
+ nk_popup_end(ctx);
|
|
|
+ return;
|
|
|
+}
|
|
|
+/* -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * COMBO
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------*/
|
|
|
+NK_INTERN int
|
|
|
+nk_combo_begin(struct nk_context *ctx, struct nk_window *win,
|
|
|
+ struct nk_vec2 size, int is_clicked, struct nk_rect header)
|
|
|
+{
|
|
|
+ struct nk_window *popup;
|
|
|
+ int is_open = 0;
|
|
|
+ int is_active = 0;
|
|
|
+ struct nk_rect body;
|
|
|
+ nk_hash hash;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ popup = win->popup.win;
|
|
|
+ body.x = header.x;
|
|
|
+ body.w = size.x;
|
|
|
+ body.y = header.y + header.h-ctx->style.window.combo_border;
|
|
|
+ body.h = size.y;
|
|
|
+
|
|
|
+ hash = win->popup.combo_count++;
|
|
|
+ is_open = (popup) ? nk_true:nk_false;
|
|
|
+ is_active = (popup && (win->popup.name == hash) && win->popup.type == NK_PANEL_COMBO);
|
|
|
+ if ((is_clicked && is_open && !is_active) || (is_open && !is_active) ||
|
|
|
+ (!is_open && !is_active && !is_clicked)) return 0;
|
|
|
+ if (!nk_nonblock_begin(ctx, 0, body,
|
|
|
+ (is_clicked && is_open)?nk_rect(0,0,0,0):header, NK_PANEL_COMBO)) return 0;
|
|
|
+
|
|
|
+ win->popup.type = NK_PANEL_COMBO;
|
|
|
+ win->popup.name = hash;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+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_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ struct nk_rect header;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(selected);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout || !selected)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (s == NK_WIDGET_INVALID)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->combo.active;
|
|
|
+ text.text = style->combo.label_active;
|
|
|
+ } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->combo.hover;
|
|
|
+ text.text = style->combo.label_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->combo.normal;
|
|
|
+ text.text = style->combo.label_normal;
|
|
|
+ }
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ /* print currently selected text item */
|
|
|
+ struct nk_rect label;
|
|
|
+ struct nk_rect button;
|
|
|
+ struct nk_rect content;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.x;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+
|
|
|
+ /* draw selected label */
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ label.x = header.x + style->combo.content_padding.x;
|
|
|
+ label.y = header.y + style->combo.content_padding.y;
|
|
|
+ label.w = button.x - (style->combo.content_padding.x + style->combo.spacing.x) - label.x;;
|
|
|
+ label.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ nk_widget_text(&win->buffer, label, selected, len, &text,
|
|
|
+ NK_TEXT_LEFT, ctx->style.font);
|
|
|
+
|
|
|
+ /* draw open/close button */
|
|
|
+ nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_combo_begin_label(struct nk_context *ctx, const char *selected, struct nk_vec2 size)
|
|
|
+{return nk_combo_begin_text(ctx, selected, nk_strlen(selected), size);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (s == NK_WIDGET_INVALID)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ background = &style->combo.active;
|
|
|
+ else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ background = &style->combo.hover;
|
|
|
+ else background = &style->combo.normal;
|
|
|
+
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image,nk_white);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ struct nk_rect content;
|
|
|
+ struct nk_rect button;
|
|
|
+ struct nk_rect bounds;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.x;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+
|
|
|
+ /* draw color */
|
|
|
+ bounds.h = header.h - 4 * style->combo.content_padding.y;
|
|
|
+ bounds.y = header.y + 2 * style->combo.content_padding.y;
|
|
|
+ bounds.x = header.x + 2 * style->combo.content_padding.x;
|
|
|
+ bounds.w = (button.x - (style->combo.content_padding.x + style->combo.spacing.x)) - bounds.x;
|
|
|
+ nk_fill_rect(&win->buffer, bounds, 0, color);
|
|
|
+
|
|
|
+ /* draw open/close button */
|
|
|
+ nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_begin_symbol(struct nk_context *ctx, enum nk_symbol_type symbol, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_color sym_background;
|
|
|
+ struct nk_color symbol_color;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (s == NK_WIDGET_INVALID)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->combo.active;
|
|
|
+ symbol_color = style->combo.symbol_active;
|
|
|
+ } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->combo.hover;
|
|
|
+ symbol_color = style->combo.symbol_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->combo.normal;
|
|
|
+ symbol_color = style->combo.symbol_hover;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ sym_background = nk_rgba(0,0,0,0);
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ sym_background = background->data.color;
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ struct nk_rect bounds = {0,0,0,0};
|
|
|
+ struct nk_rect content;
|
|
|
+ struct nk_rect button;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.y;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+
|
|
|
+ /* draw symbol */
|
|
|
+ bounds.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ bounds.y = header.y + style->combo.content_padding.y;
|
|
|
+ bounds.x = header.x + style->combo.content_padding.x;
|
|
|
+ bounds.w = (button.x - style->combo.content_padding.y) - bounds.x;
|
|
|
+ nk_draw_symbol(&win->buffer, symbol, bounds, sym_background, symbol_color,
|
|
|
+ 1.0f, style->font);
|
|
|
+
|
|
|
+ /* draw open/close button */
|
|
|
+ nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_begin_symbol_text(struct nk_context *ctx, const char *selected, int len,
|
|
|
+ enum nk_symbol_type symbol, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_color symbol_color;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (!s) return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->combo.active;
|
|
|
+ symbol_color = style->combo.symbol_active;
|
|
|
+ text.text = style->combo.label_active;
|
|
|
+ } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->combo.hover;
|
|
|
+ symbol_color = style->combo.symbol_hover;
|
|
|
+ text.text = style->combo.label_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->combo.normal;
|
|
|
+ symbol_color = style->combo.symbol_normal;
|
|
|
+ text.text = style->combo.label_normal;
|
|
|
+ }
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ struct nk_rect content;
|
|
|
+ struct nk_rect button;
|
|
|
+ struct nk_rect label;
|
|
|
+ struct nk_rect image;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.x;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+ nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+
|
|
|
+ /* draw symbol */
|
|
|
+ image.x = header.x + style->combo.content_padding.x;
|
|
|
+ image.y = header.y + style->combo.content_padding.y;
|
|
|
+ image.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ image.w = image.h;
|
|
|
+ nk_draw_symbol(&win->buffer, symbol, image, text.background, symbol_color,
|
|
|
+ 1.0f, style->font);
|
|
|
+
|
|
|
+ /* draw label */
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ label.x = image.x + image.w + style->combo.spacing.x + style->combo.content_padding.x;
|
|
|
+ label.y = header.y + style->combo.content_padding.y;
|
|
|
+ label.w = (button.x - style->combo.content_padding.x) - label.x;
|
|
|
+ label.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ const struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (s == NK_WIDGET_INVALID)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED)
|
|
|
+ background = &style->combo.active;
|
|
|
+ else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ background = &style->combo.hover;
|
|
|
+ else background = &style->combo.normal;
|
|
|
+
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ struct nk_rect bounds = {0,0,0,0};
|
|
|
+ struct nk_rect content;
|
|
|
+ struct nk_rect button;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.y;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+
|
|
|
+ /* draw image */
|
|
|
+ bounds.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ bounds.y = header.y + style->combo.content_padding.y;
|
|
|
+ bounds.x = header.x + style->combo.content_padding.x;
|
|
|
+ bounds.w = (button.x - style->combo.content_padding.y) - bounds.x;
|
|
|
+ nk_draw_image(&win->buffer, bounds, &img, nk_white);
|
|
|
+
|
|
|
+ /* draw open/close button */
|
|
|
+ nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_begin_image_text(struct nk_context *ctx, const char *selected, int len,
|
|
|
+ struct nk_image img, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_style *style;
|
|
|
+ struct nk_input *in;
|
|
|
+
|
|
|
+ struct nk_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ enum nk_widget_layout_states s;
|
|
|
+ const struct nk_style_item *background;
|
|
|
+ struct nk_text text;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ style = &ctx->style;
|
|
|
+ s = nk_widget(&header, ctx);
|
|
|
+ if (!s) return 0;
|
|
|
+
|
|
|
+ in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
|
|
|
+ if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
|
|
|
+ is_clicked = nk_true;
|
|
|
+
|
|
|
+ /* draw combo box header background and border */
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_ACTIVED) {
|
|
|
+ background = &style->combo.active;
|
|
|
+ text.text = style->combo.label_active;
|
|
|
+ } else if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER) {
|
|
|
+ background = &style->combo.hover;
|
|
|
+ text.text = style->combo.label_hover;
|
|
|
+ } else {
|
|
|
+ background = &style->combo.normal;
|
|
|
+ text.text = style->combo.label_normal;
|
|
|
+ }
|
|
|
+ if (background->type == NK_STYLE_ITEM_IMAGE) {
|
|
|
+ text.background = nk_rgba(0,0,0,0);
|
|
|
+ nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
|
|
|
+ } else {
|
|
|
+ text.background = background->data.color;
|
|
|
+ nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
|
|
|
+ nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ struct nk_rect content;
|
|
|
+ struct nk_rect button;
|
|
|
+ struct nk_rect label;
|
|
|
+ struct nk_rect image;
|
|
|
+
|
|
|
+ enum nk_symbol_type sym;
|
|
|
+ if (ctx->last_widget_state & NK_WIDGET_STATE_HOVER)
|
|
|
+ sym = style->combo.sym_hover;
|
|
|
+ else if (is_clicked)
|
|
|
+ sym = style->combo.sym_active;
|
|
|
+ else sym = style->combo.sym_normal;
|
|
|
+
|
|
|
+ /* calculate button */
|
|
|
+ button.w = header.h - 2 * style->combo.button_padding.y;
|
|
|
+ button.x = (header.x + header.w - header.h) - style->combo.button_padding.x;
|
|
|
+ button.y = header.y + style->combo.button_padding.y;
|
|
|
+ button.h = button.w;
|
|
|
+
|
|
|
+ content.x = button.x + style->combo.button.padding.x;
|
|
|
+ content.y = button.y + style->combo.button.padding.y;
|
|
|
+ content.w = button.w - 2 * style->combo.button.padding.x;
|
|
|
+ content.h = button.h - 2 * style->combo.button.padding.y;
|
|
|
+ nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
|
|
|
+ &ctx->style.combo.button, sym, style->font);
|
|
|
+
|
|
|
+ /* draw image */
|
|
|
+ image.x = header.x + style->combo.content_padding.x;
|
|
|
+ image.y = header.y + style->combo.content_padding.y;
|
|
|
+ image.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ image.w = image.h;
|
|
|
+ nk_draw_image(&win->buffer, image, &img, nk_white);
|
|
|
+
|
|
|
+ /* draw label */
|
|
|
+ text.padding = nk_vec2(0,0);
|
|
|
+ label.x = image.x + image.w + style->combo.spacing.x + style->combo.content_padding.x;
|
|
|
+ label.y = header.y + style->combo.content_padding.y;
|
|
|
+ label.w = (button.x - style->combo.content_padding.x) - label.x;
|
|
|
+ label.h = header.h - 2 * style->combo.content_padding.y;
|
|
|
+ nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font);
|
|
|
+ }
|
|
|
+ return nk_combo_begin(ctx, win, size, is_clicked, header);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_combo_begin_symbol_label(struct nk_context *ctx,
|
|
|
+ const char *selected, enum nk_symbol_type type, struct nk_vec2 size)
|
|
|
+{return nk_combo_begin_symbol_text(ctx, selected, nk_strlen(selected), type, size);}
|
|
|
+
|
|
|
+NK_API int nk_combo_begin_image_label(struct nk_context *ctx,
|
|
|
+ const char *selected, struct nk_image img, struct nk_vec2 size)
|
|
|
+{return nk_combo_begin_image_text(ctx, selected, nk_strlen(selected), img, size);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_text(struct nk_context *ctx, const char *text, int len,nk_flags align)
|
|
|
+{return nk_contextual_item_text(ctx, text, len, align);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_label(struct nk_context *ctx, const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_label(ctx, label, align);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_image_text(struct nk_context *ctx, struct nk_image img, const char *text,
|
|
|
+ int len, nk_flags alignment)
|
|
|
+{return nk_contextual_item_image_text(ctx, img, text, len, alignment);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_image_label(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *text, nk_flags alignment)
|
|
|
+{return nk_contextual_item_image_label(ctx, img, text, alignment);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym,
|
|
|
+ const char *text, int len, nk_flags alignment)
|
|
|
+{return nk_contextual_item_symbol_text(ctx, sym, text, len, alignment);}
|
|
|
+
|
|
|
+NK_API int nk_combo_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym,
|
|
|
+ const char *label, nk_flags alignment)
|
|
|
+{return nk_contextual_item_symbol_label(ctx, sym, label, alignment);}
|
|
|
+
|
|
|
+NK_API void nk_combo_end(struct nk_context *ctx)
|
|
|
+{nk_contextual_end(ctx);}
|
|
|
+
|
|
|
+NK_API void nk_combo_close(struct nk_context *ctx)
|
|
|
+{nk_contextual_close(ctx);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo(struct nk_context *ctx, const char **items, int count,
|
|
|
+ int selected, int item_height, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ int i = 0;
|
|
|
+ int max_height;
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+ struct nk_vec2 window_padding;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(items);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ if (!ctx || !items ||!count)
|
|
|
+ return selected;
|
|
|
+
|
|
|
+ item_spacing = ctx->style.window.spacing;
|
|
|
+ window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type);
|
|
|
+ max_height = count * item_height + count * (int)item_spacing.y;
|
|
|
+ max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2;
|
|
|
+ size.y = NK_MIN(size.y, (float)max_height);
|
|
|
+ if (nk_combo_begin_label(ctx, items[selected], size)) {
|
|
|
+ nk_layout_row_dynamic(ctx, (float)item_height, 1);
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ if (nk_combo_item_label(ctx, items[i], NK_TEXT_LEFT))
|
|
|
+ selected = i;
|
|
|
+ }
|
|
|
+ nk_combo_end(ctx);
|
|
|
+ }
|
|
|
+ return selected;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_separator(struct nk_context *ctx, const char *items_separated_by_separator,
|
|
|
+ int separator, int selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ int max_height;
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+ struct nk_vec2 window_padding;
|
|
|
+ const char *current_item;
|
|
|
+ const char *iter;
|
|
|
+ int length = 0;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(items_separated_by_separator);
|
|
|
+ if (!ctx || !items_separated_by_separator)
|
|
|
+ return selected;
|
|
|
+
|
|
|
+ /* calculate popup window */
|
|
|
+ item_spacing = ctx->style.window.spacing;
|
|
|
+ window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type);
|
|
|
+ max_height = count * item_height + count * (int)item_spacing.y;
|
|
|
+ max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2;
|
|
|
+ size.y = NK_MIN(size.y, (float)max_height);
|
|
|
+
|
|
|
+ /* find selected item */
|
|
|
+ current_item = items_separated_by_separator;
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ iter = current_item;
|
|
|
+ while (*iter && *iter != separator) iter++;
|
|
|
+ length = (int)(iter - current_item);
|
|
|
+ if (i == selected) break;
|
|
|
+ current_item = iter + 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nk_combo_begin_text(ctx, current_item, length, size)) {
|
|
|
+ current_item = items_separated_by_separator;
|
|
|
+ nk_layout_row_dynamic(ctx, (float)item_height, 1);
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ iter = current_item;
|
|
|
+ while (*iter && *iter != separator) iter++;
|
|
|
+ length = (int)(iter - current_item);
|
|
|
+ if (nk_combo_item_text(ctx, current_item, length, NK_TEXT_LEFT))
|
|
|
+ selected = i;
|
|
|
+ current_item = current_item + length + 1;
|
|
|
+ }
|
|
|
+ nk_combo_end(ctx);
|
|
|
+ }
|
|
|
+ return selected;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_string(struct nk_context *ctx, const char *items_separated_by_zeros,
|
|
|
+ int selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{return nk_combo_separator(ctx, items_separated_by_zeros, '\0', selected, count, item_height, size);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_combo_callback(struct nk_context *ctx, void(*item_getter)(void*, int, const char**),
|
|
|
+ void *userdata, int selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ int max_height;
|
|
|
+ struct nk_vec2 item_spacing;
|
|
|
+ struct nk_vec2 window_padding;
|
|
|
+ const char *item;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(item_getter);
|
|
|
+ if (!ctx || !item_getter)
|
|
|
+ return selected;
|
|
|
+
|
|
|
+ /* calculate popup window */
|
|
|
+ item_spacing = ctx->style.window.spacing;
|
|
|
+ window_padding = nk_panel_get_padding(&ctx->style, ctx->current->layout->type);
|
|
|
+ max_height = count * item_height + count * (int)item_spacing.y;
|
|
|
+ max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2;
|
|
|
+ size.y = NK_MIN(size.y, (float)max_height);
|
|
|
+
|
|
|
+ item_getter(userdata, selected, &item);
|
|
|
+ if (nk_combo_begin_label(ctx, item, size)) {
|
|
|
+ nk_layout_row_dynamic(ctx, (float)item_height, 1);
|
|
|
+ for (i = 0; i < count; ++i) {
|
|
|
+ item_getter(userdata, i, &item);
|
|
|
+ if (nk_combo_item_label(ctx, item, NK_TEXT_LEFT))
|
|
|
+ selected = i;
|
|
|
+ }
|
|
|
+ nk_combo_end(ctx);
|
|
|
+ }
|
|
|
+ return selected;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API void nk_combobox(struct nk_context *ctx, const char **items, int count,
|
|
|
+ int *selected, int item_height, struct nk_vec2 size)
|
|
|
+{*selected = nk_combo(ctx, items, count, *selected, item_height, size);}
|
|
|
+
|
|
|
+NK_API void nk_combobox_string(struct nk_context *ctx, const char *items_separated_by_zeros,
|
|
|
+ int *selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{*selected = nk_combo_string(ctx, items_separated_by_zeros, *selected, count, item_height, size);}
|
|
|
+
|
|
|
+NK_API void nk_combobox_separator(struct nk_context *ctx, const char *items_separated_by_separator,
|
|
|
+ int separator,int *selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{*selected = nk_combo_separator(ctx, items_separated_by_separator, separator,
|
|
|
+ *selected, count, item_height, size);}
|
|
|
+
|
|
|
+NK_API void nk_combobox_callback(struct nk_context *ctx,
|
|
|
+ void(*item_getter)(void* data, int id, const char **out_text),
|
|
|
+ void *userdata, int *selected, int count, int item_height, struct nk_vec2 size)
|
|
|
+{*selected = nk_combo_callback(ctx, item_getter, userdata, *selected, count, item_height, size);}
|
|
|
+
|
|
|
+/*
|
|
|
+ * -------------------------------------------------------------
|
|
|
+ *
|
|
|
+ * MENU
|
|
|
+ *
|
|
|
+ * --------------------------------------------------------------
|
|
|
+ */
|
|
|
+NK_INTERN int
|
|
|
+nk_menu_begin(struct nk_context *ctx, struct nk_window *win,
|
|
|
+ const char *id, int is_clicked, struct nk_rect header, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ int is_open = 0;
|
|
|
+ int is_active = 0;
|
|
|
+ struct nk_rect body;
|
|
|
+ struct nk_window *popup;
|
|
|
+ nk_hash hash = nk_murmur_hash(id, (int)nk_strlen(id), NK_PANEL_MENU);
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ body.x = header.x;
|
|
|
+ body.w = size.x;
|
|
|
+ body.y = header.y + header.h;
|
|
|
+ body.h = size.y;
|
|
|
+
|
|
|
+ popup = win->popup.win;
|
|
|
+ is_open = popup ? nk_true : nk_false;
|
|
|
+ is_active = (popup && (win->popup.name == hash) && win->popup.type == NK_PANEL_MENU);
|
|
|
+ if ((is_clicked && is_open && !is_active) || (is_open && !is_active) ||
|
|
|
+ (!is_open && !is_active && !is_clicked)) return 0;
|
|
|
+ if (!nk_nonblock_begin(ctx, NK_WINDOW_NO_SCROLLBAR, body, header, NK_PANEL_MENU))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win->popup.type = NK_PANEL_MENU;
|
|
|
+ win->popup.name = hash;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ nk_flags state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ state = nk_widget(&header, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || win->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, header,
|
|
|
+ title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font))
|
|
|
+ is_clicked = nk_true;
|
|
|
+ return nk_menu_begin(ctx, win, title, is_clicked, header, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_menu_begin_label(struct nk_context *ctx,
|
|
|
+ const char *text, nk_flags align, struct nk_vec2 size)
|
|
|
+{return nk_menu_begin_text(ctx, text, nk_strlen(text), align, size);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_menu_begin_image(struct nk_context *ctx, const char *id, struct nk_image img,
|
|
|
+ struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_rect header;
|
|
|
+ const struct nk_input *in;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ nk_flags state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ state = nk_widget(&header, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_image(&ctx->last_widget_state, &win->buffer, header,
|
|
|
+ img, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in))
|
|
|
+ is_clicked = nk_true;
|
|
|
+ return nk_menu_begin(ctx, win, id, is_clicked, header, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+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_rect header;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ nk_flags state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ state = nk_widget(&header, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, header,
|
|
|
+ sym, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font))
|
|
|
+ is_clicked = nk_true;
|
|
|
+ return nk_menu_begin(ctx, win, id, is_clicked, header, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len,
|
|
|
+ nk_flags align, struct nk_image img, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_rect header;
|
|
|
+ const struct nk_input *in;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ nk_flags state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ state = nk_widget(&header, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
|
|
|
+ header, img, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button,
|
|
|
+ ctx->style.font, in))
|
|
|
+ is_clicked = nk_true;
|
|
|
+ return nk_menu_begin(ctx, win, title, is_clicked, header, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_menu_begin_image_label(struct nk_context *ctx,
|
|
|
+ const char *title, nk_flags align, struct nk_image img, struct nk_vec2 size)
|
|
|
+{return nk_menu_begin_image_text(ctx, title, nk_strlen(title), align, img, size);}
|
|
|
+
|
|
|
+NK_API int
|
|
|
+nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len,
|
|
|
+ nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size)
|
|
|
+{
|
|
|
+ struct nk_window *win;
|
|
|
+ struct nk_rect header;
|
|
|
+ const struct nk_input *in;
|
|
|
+ int is_clicked = nk_false;
|
|
|
+ nk_flags state;
|
|
|
+
|
|
|
+ NK_ASSERT(ctx);
|
|
|
+ NK_ASSERT(ctx->current);
|
|
|
+ NK_ASSERT(ctx->current->layout);
|
|
|
+ if (!ctx || !ctx->current || !ctx->current->layout)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ win = ctx->current;
|
|
|
+ state = nk_widget(&header, ctx);
|
|
|
+ if (!state) return 0;
|
|
|
+
|
|
|
+ in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
|
|
+ if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer,
|
|
|
+ header, sym, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button,
|
|
|
+ ctx->style.font, in)) is_clicked = nk_true;
|
|
|
+ return nk_menu_begin(ctx, win, title, is_clicked, header, size);
|
|
|
+}
|
|
|
+
|
|
|
+NK_API int nk_menu_begin_symbol_label(struct nk_context *ctx,
|
|
|
+ const char *title, nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size )
|
|
|
+{return nk_menu_begin_symbol_text(ctx, title, nk_strlen(title), align,sym,size);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_text(struct nk_context *ctx, const char *title, int len, nk_flags align)
|
|
|
+{return nk_contextual_item_text(ctx, title, len, align);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_label(struct nk_context *ctx, const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_label(ctx, label, align);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_image_label(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_image_label(ctx, img, label, align);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_image_text(struct nk_context *ctx, struct nk_image img,
|
|
|
+ const char *text, int len, nk_flags align)
|
|
|
+{return nk_contextual_item_image_text(ctx, img, text, len, align);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym,
|
|
|
+ const char *text, int len, nk_flags align)
|
|
|
+{return nk_contextual_item_symbol_text(ctx, sym, text, len, align);}
|
|
|
+
|
|
|
+NK_API int nk_menu_item_symbol_label(struct nk_context *ctx, enum nk_symbol_type sym,
|
|
|
+ const char *label, nk_flags align)
|
|
|
+{return nk_contextual_item_symbol_label(ctx, sym, label, align);}
|
|
|
+
|
|
|
+NK_API void nk_menu_close(struct nk_context *ctx)
|
|
|
+{nk_contextual_close(ctx);}
|
|
|
+
|
|
|
+NK_API void
|
|
|
+nk_menu_end(struct nk_context *ctx)
|
|
|
+{nk_contextual_end(ctx);}
|
|
|
+
|
|
|
+#endif
|
Ray San