Skip to content

Instantly share code, notes, and snippets.

@zacharycarter

zacharycarter/nuklear.nim

Created Mar 2, 2017
Star
Embed
What would you like to do?
Learn more about clone URLs
Download ZIP
Raw
nuklear.nim
#[
Nuklear - 1.33.0 - public domain
no warrenty implied; use at your own risk.
authored from 2015-2016 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 the `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.
]#
{.deadCodeElim: on.}
{.compile: "src/bind.c".}
import macros
macro find_size(a,b: untyped): untyped =
if sizeof(a) < sizeof(b):
sizeof(b)
else:
sizeof(a) div sizeof(uint32) div 2
type
style_slide* = object
const
nk_false* = 0
nk_true* = 1
type
handle* = pointer
color* = object
r*: char
g*: char
b*: char
a*: char
colorf* = object
r*: float32
g*: float32
b*: float32
a*: float32
vec2* = object
x*: float32
y*: float32
vec2i* = object
x*: int16
y*: int16
rect* = object
x*: float32
y*: float32
w*: float32
h*: float32
recti* = object
x*: int16
y*: int16
w*: int16
h*: int16
glyph* = array[4, char]
img* = object {.byCopy.}
handle*: handle
w*: uint16
h*: uint16
region*: array[4, uint16]
cursor* = object
img*: img
size*: vec2
offset*: vec2
scroll* = object
x*: uint32
y*: uint32
heading* {.size: sizeof(int32).} = enum
UP, RIGHT, DOWN, LEFT
type
user_font_glyph* = object
uv*: array[2, vec2] ## texture coordinates
offset*: vec2 ## offset between top left and glyph
width*: float32
height*: float32 ## size of the glyph
xadvance*: float32 ## offset to the next glyph
text_width_f* = proc (a2: handle; h: float32; a4: cstring; len: int32): float32 {.cdecl.}
query_font_glyph_f* = proc (handle: handle; font_height: float32;
glyph: ptr user_font_glyph; codepoint: uint32;
next_codepoint: uint32) {.cdecl.}
user_font* = object
userdata*: handle
height*: float32
width*: text_width_f
query* :query_font_glyph_f
texture*: handle
font_coord_type* {.size: sizeof(int32).} = enum
COORD_UV, COORD_PIXEL
memory_status* = object
memory*: pointer
typ*: uint32
size*: uint
allocated*: uint
needed*: uint
calls*: uint
allocation_type* {.size: sizeof(int32).} = enum
BUFFER_FIXED, BUFFER_DYNAMIC
type
buffer_allocation_type* {.size: sizeof(int32).} = enum
BUFFER_FRONT, BUFFER_BACK, BUFFER_MAX
type
anti_aliasing* {.size: sizeof(int32).} = enum
ANTI_ALIASING_OFF, ANTI_ALIASING_ON
##################################################################
#
# 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.
]#
type
plugin_alloc* = proc (a2: handle; old: pointer; a4: uint): pointer {.cdecl.}
plugin_free* = proc (a2: handle; old: pointer) {.cdecl.}
allocator* = object
userdata*: handle
alloc*: plugin_alloc
free*: plugin_free
buffer_marker* = object
active*: int32
offset*: uint
memory* = object
pointr*: pointer
size*: uint
buffer* = object
marker*: array[BUFFER_MAX, buffer_marker]
pool*: allocator
typ*: allocation_type
memory*: memory
grow_factor*: float32
allocated*: uint
needed*: uint
calls*: uint
size*: uint
proc buffer_init_default(a2: ptr buffer) {.importc: "nk_buffer_init_default".}
proc init*(b: var buffer) =
buffer_init_default(addr b)
proc buffer_init(a2: ptr buffer; a3: ptr allocator; size: uint) {.importc: "nk_buffer_init".}
proc init*(b: var buffer, a: var allocator, size: uint) =
buffer_init(addr b, addr a, size)
proc buffer_init_fixed(a2: ptr buffer; memory: pointer; size: uint) {.importc: "nk_buffer_init_fixed".}
proc init*(b: var buffer, memory: pointer, size:uint) =
buffer_init_fixed(addr b, memory, size)
proc buffer_info(a2: ptr memory_status; a3: ptr buffer) {.importc: "nk_buffer_info".}
proc info*(b: var buffer, ms: var memory_status) =
buffer_info(addr ms, addr b)
proc buffer_push(a2: ptr buffer; typ: buffer_allocation_type;
memory: pointer; size: uint; align: uint) {.importc: "nk_buffer_push".}
proc push*(b: var buffer, `type`: buffer_allocation_type, memory: pointer, size, align: uint) =
buffer_push(addr b, `type`, memory, size, align)
proc buffer_mark*(a2: ptr buffer; typ: buffer_allocation_type) {.importc: "nk_buffer_mark".}
proc mark*(b: var buffer, `type`: buffer_allocation_type) =
buffer_mark(addr b, `type`)
proc buffer_reset(a2: ptr buffer; typ: buffer_allocation_type) {.importc: "nk_buffer_reset".}
proc reset*(b: var buffer, `type`: buffer_allocation_type) =
buffer_reset(addr b, `type`)
proc buffer_clear(a2: ptr buffer) {.importc: "nk_buffer_clear".}
proc clear*(b: var buffer) =
buffer_clear(addr b)
proc buffer_free(a2: ptr buffer) {.importc: "nk_buffer_free".}
proc free*(b: var buffer) =
buffer_free(addr b)
proc buffer_memory(a2: ptr buffer): pointer {.importc: "nk_buffer_memory".}
proc bufferMemory*(b: var buffer): pointer =
buffer_memory(addr b)
proc buffer_memory_const(a2: ptr buffer): pointer {.importc: "nk_buffer_memory_const".}
proc bufferMemoryConst*(b: var buffer): pointer =
buffer_memory_const(addr b)
proc buffer_total*(a2: ptr buffer): uint {.importc: "nk_buffer_total".}
proc total*(b: var buffer): uint =
buffer_total(addr b)
##################################################################
#*
# 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. */
type
str* = object
buffer*: buffer
len*: int32
proc str_init(a2: ptr str; a3: ptr allocator; size: uint) {.importc: "nk_str_init".}
proc init*(s: var str, a: var allocator, size: uint) =
str_init(addr s, addr a, size)
proc str_init_fixed(a2: ptr str; memory: pointer; size: uint) {.importc: "nk_str_init_fixed".}
proc initFixed*(s: var str, memory: pointer, size: uint) =
str_init_fixed(addr s, memory, size)
proc str_clear(a2: ptr str) {.importc: "nk_str_clear".}
proc clear*(s: var str) =
str_clear(addr s)
proc str_free(a2: ptr str) {.importc: "nk_str_free".}
proc free*(s: var str) =
str_free(addr s)
proc str_append_text_char(a2: ptr str; a3: cstring; a4: int32): int32 {.importc: "nk_str_append_text_char".}
proc appendTextChar*(s: var str, t: string, c: int32): int32 =
str_append_text_char(addr s, t, c)
proc str_append_str_char(a2: ptr str; a3: cstring): int32 {.importc: "nk_str_append_str_char".}
proc appendStrChar*(s: var str, t: string): int32 =
str_append_str_char(addr s, t)
proc str_append_text_utf8(a2: ptr str; a3: cstring; a4: int32): int32 {.importc: "nk_str_append_text_utf8".}
proc appendTextUTF8*(s: var str, t: string, u: int32): int32 =
str_append_text_utf8(addr s, t, u)
proc str_append_str_utf8(a2: ptr str; a3: cstring): int32 {.importc: "nk_str_append_str_utf8".}
proc appendStrUTF8*(s: var str, t: string): int32 =
str_append_str_utf8(addr s, t)
proc str_append_text_runes(a2: ptr str; a3: ptr uint32; a4: int32): int32 {.importc: "nk_str_append_text_runes".}
proc appendTextRunes*(s: var str, u: var uint32, i: int32): int32 =
str_append_text_runes(addr s, addr u, i)
proc str_append_str_runes(a2: ptr str; a3: ptr uint32): int32 {.importc: "nk_str_append_str_runes".}
proc appendStrRunes*(s: var str, u: var uint32): int32 =
str_append_str_runes(addr s, addr u)
proc str_insert_at_char(a2: ptr str; pos: int32; a4: cstring; a5: int32): int32 {. importc: "nk_str_insert_at_char".}
proc insertAtChar*(s: var str, pos: int32, t: string, i: int32): int32 =
str_insert_at_char(addr s, pos, t, i)
proc str_insert_at_rune(a2: ptr str; pos: int32; a4: cstring; a5: int32): int32 {. importc: "nk_str_insert_at_rune".}
proc insertAtRune*(s: var str, pos: int32, t: string, i: int32): int32 =
str_insert_at_rune(addr s, pos, t, i)
proc str_insert_text_char(a2: ptr str; pos: int32; a4: cstring; a5: int32): int32 {. importc: "nk_str_insert_text_char".}
proc insertTextChar*(s: var str, pos: int32, t: string, i: int32): int32 =
str_insert_text_char(addr s, pos, t, i)
proc str_insert_str_char(a2: ptr str; pos: int32; a4: cstring): int32 {.importc: "nk_str_insert_str_char".}
proc insertStrChar*(s: var str, pos: int32, t: string): int32 =
str_insert_str_char(addr s, pos, t)
proc str_insert_text_utf8(a2: ptr str; pos: int32; a4: cstring; a5: int32): int32 {. importc: "nk_str_insert_text_utf8".}
proc insertTextUTF8*(s: var str, pos: int32, t: string, i: int32): int32 =
str_insert_text_utf8(addr s, pos, t, i)
proc str_insert_str_utf8(a2: ptr str; pos: int32; a4: cstring): int32 {.importc: "nk_str_insert_str_utf8".}
proc insertStrUTF8*(s: var str, pos: int32, t: string): int32 =
str_insert_str_utf8(addr s, pos, t)
proc str_insert_text_runes(a2: ptr str; pos: int32; a4: ptr uint32; a5: int32): int32 {. importc: "nk_str_insert_text_runes".}
proc insertTextRunes*(s: var str, pos: int32, u: var uint32, i: int32): int32 =
str_insert_text_runes(addr s, pos, addr u, i)
proc str_insert_str_runes(a2: ptr str; pos: int32; a4: ptr uint32): int32 {.importc: "nk_str_insert_str_runes".}
proc insertStrRunes*(s: var str, pos: int32, u: var uint32): int32 =
str_insert_str_runes(addr s, pos, addr u)
proc str_remove_chars(a2: ptr str; len: int32) {.importc: "nk_str_remove_chars".}
proc removeChars*(s: var str, len: int32) =
str_remove_chars(addr s, len)
proc str_remove_runes(str: ptr str; len: int32) {.importc: "nk_str_remove_runes".}
proc removeRunes*(s: var str, len: int32) =
str_remove_runes(addr s, len)
proc str_delete_chars(a2: ptr str; pos: int32; len: int32) {.importc: "nk_str_delete_chars".}
proc deleteChars*(s: var str, pos: int32, len: int32) =
str_delete_chars(addr s, pos, len)
proc str_delete_runes(a2: ptr str; pos: int32; len: int32) {.importc: "nk_str_delete_runes".}
proc deleteRunes*(s: var str, pos: int32, len: int32) =
str_delete_runes(addr s, pos, len)
proc str_at_char(a2: ptr str; pos: int32): cstring {.importc: "nk_str_at_char".}
proc atChar*(s: var str, pos: int32) : string =
$str_at_char(addr s, pos)
proc str_at_rune(a2: ptr str; pos: int32; unicode: ptr uint32; len: ptr int32): cstring {. importc: "nk_str_at_rune".}
proc atRune*(s: var str, pos: int32, unicode: var uint32, len: var int32) : string =
$str_at_rune(addr s, pos, addr unicode, addr len)
proc str_rune_at(a2: ptr str; pos: int32): uint32 {.importc: "nk_str_rune_at".}
proc runeAt*(s: var str, pos: int32): uint32 =
str_rune_at(addr s, pos)
proc str_at_char_const(a2: ptr str; pos: int32): cstring {.importc: "nk_str_at_char_const".}
proc atCharConst*(s: var str, pos: int32): string =
$str_at_char_const(addr s, pos)
proc str_at_const(a2: ptr str; pos: int32; unicode: ptr uint32; len: ptr int32): cstring {. importc: "nk_str_at_const".}
proc atConst*(s: var str, pos: int32, unicode: var uint32, len: var int32): string =
$str_at_const(addr s, pos, addr unicode, addr len)
proc str_get(a2: ptr str): cstring {.importc: "nk_str_get".}
proc get*(s: var str): string =
$str_get(addr s)
proc str_get_const(a2: ptr str): cstring {.importc: "nk_str_get_const".}
proc getConst*(s: var str): string =
$str_get_const(addr s)
proc str_len(a2: ptr str): int32 {.importc: "nk_str_len".}
proc len*(s: var str): int32 =
str_len(addr s)
proc str_len_char(a2: ptr str): int32 {.importc: "nk_str_len_char".}
proc lenChar*(s: var str): int32 =
str_len_char(addr s)
type
command_buffer* = object
base*: ptr buffer
clip*: rect
use_clipping*: int32
userdata*: handle
begin*: uint
e*: uint
last*: uint
type
panel_type* {.size: sizeof(int32).} = enum
PANEL_WINDOW = (1 shl (0)), PANEL_GROUP = (1 shl (1)),
PANEL_POPUP = (1 shl (2)), PANEL_CONTEXTUAL = (1 shl (4)),
PANEL_COMBO = (1 shl (5)), PANEL_MENU = (1 shl (6)),
PANEL_TOOLTIP = (1 shl (7))
type
chart_type* {.size: sizeof(int32).} = enum
charT_LINES, charT_COLUMN, charT_MAX
type
style_item_type* {.size: sizeof(int32).} = enum
STYLE_ITEM_COLOR, STYLE_ITEM_IMAGE
type
button_behavior* {.size: sizeof(int32).} = enum
BUTTON_DEFAULT, BUTTON_REPEATER
type
buttons* {.size: sizeof(int32).} = enum
BUTTON_LEFT, BUTTON_MIDDLE, BUTTON_RIGHT, BUTTON_MAX
type
keys* {.size: sizeof(int32).} = enum
KEY_NONE, KEY_SHIFT, KEY_CTRL, KEY_DEL, KEY_ENTER, KEY_TAB,
KEY_BACKSPACE, KEY_COPY, KEY_CUT, KEY_PASTE, KEY_UP, KEY_DOWN,
KEY_LEFT, KEY_RIGHT, KEY_TEXT_INSERT_MODE, KEY_TEXT_REPLACE_MODE,
KEY_TEXT_RESET_MODE, KEY_TEXT_LINE_START, KEY_TEXT_LINE_END,
KEY_TEXT_START, KEY_TEXT_END, KEY_TEXT_UNDO, KEY_TEXT_REDO,
KEY_TEXT_SELECT_ALL, KEY_TEXT_WORD_LEFT, KEY_TEXT_WORD_RIGHT,
KEY_SCROLL_START, KEY_SCROLL_END, KEY_SCROLL_DOWN, KEY_SCROLL_UP,
KEY_MAX
type
style_cursor* {.size: sizeof(int32).} = enum
CURSOR_ARROW, CURSOR_TEXT, CURSOR_MOVE, CURSOR_RESIZE_VERTICAL,
CURSOR_RESIZE_HORIZONTAL, CURSOR_RESIZE_TOP_LEFT_DOWN_RIGHT,
CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT, CURSOR_COUNT
type
draw_vertex_layout_attribute* {.size: sizeof(int32).} = enum
VERTEX_POSITION, VERTEX_COLOR, VERTEX_TEXCOORD,
VERTEX_ATTRIBUTE_COUNT
type
draw_vertex_layout_format* {.size: sizeof(int32).} = enum
FORMAT_SCHAR, FORMAT_SSHORT, FORMAT_SINT, FORMAT_UCHAR,
FORMAT_USHORT, FORMAT_UINT, FORMAT_FLOAT, FORMAT_DOUBLE,
FORMAT_COLOR_BEGIN, FORMAT_R16G15B16, FORMAT_R32G32B32,
FORMAT_R8G8B8A8, FORMAT_R16G15B16A16, FORMAT_R32G32B32A32,
FORMAT_R32G32B32A32_FLOAT, FORMAT_R32G32B32A32_DOUBLE, FORMAT_RGB32,
FORMAT_RGBA32, FORMAT_COUNT
type
draw_vertex_layout_element* = object
attribute*: draw_vertex_layout_attribute
format*: draw_vertex_layout_format
offset*: uint
draw_command* = object
elem_count*: uint32
clip_rect*: rect
texture*: handle
draw_list* = object
clip_rect*: rect
circle_vtx*: array[12, vec2]
config*: convert_config
buffer*: ptr buffer
vertices*: ptr buffer
elements*: ptr buffer
element_count*: uint32
vertex_count*: uint32
cmd_count*: uint32
cmd_offset*: uint
path_count*: uint32
path_offset*: uint32
draw_null_texture* = object
texture*: handle
uv*: vec2
convert_config* = object
global_alpha*: float32
line_AA*: anti_aliasing
shape_AA*: anti_aliasing
circle_segment_count*: uint32
arc_segment_count*: uint32
curve_segment_count*: uint32
null*: draw_null_texture
vertex_layout*: ptr draw_vertex_layout_element
vertex_size*: uint
vertex_alignment*: uint
list_view* = object
begin*: int32
e*: int32
count*: int32
total_height*: int32
ctx*: ptr context
scroll_pointer*: ptr uint32
scroll_value*: uint32
symbol_type* {.size: sizeof(int32).} = enum
SYMBOL_NONE, SYMBOL_X, SYMBOL_UNDERSCORE, SYMBOL_CIRCLE_SOLID,
SYMBOL_CIRCLE_OUTLINE, SYMBOL_RECT_SOLID, SYMBOL_RECT_OUTLINE,
SYMBOL_TRIANGLE_UP, SYMBOL_TRIANGLE_DOWN, SYMBOL_TRIANGLE_LEFT,
SYMBOL_TRIANGLE_RIGHT, SYMBOL_PLUS, SYMBOL_MINUS, SYMBOL_MAX
menu_state* = object
x*: float32
y*: float32
w*: float32
h*: float32
offset*: scroll
row_layout* = object
typ*: panel_row_layout_type
index*: int32
height*: float32
columns*: int32
ratio*: ptr float32
item_width*: float32
item_height*: float32
item_offset*: float32
filled*: float32
item*: rect
tree_depth*: int32
templates*: array[16, float32]
popup_buffer* = object
begin*: uint
parent*: uint
last*: uint
e*: uint
active*: int32
chart_slot* = object
typ*: chart_type
color*: color
highlight*: color
min*: float32
max*: float32
range*: float32
count*: int32
last*: vec2
index*: int32
chart* = object
slot*: int32
x*: float32
y*: float32
w*: float32
h*: float32
slots*: array[4, chart_slot]
panel_row_layout_type* {.size: sizeof(int32).} = enum
LAYOUT_DYNAMIC_FIXED = 0, LAYOUT_DYNAMIC_ROW, LAYOUT_DYNAMIC_FREE,
LAYOUT_DYNAMIC, LAYOUT_STATIC_FIXED, LAYOUT_STATIC_ROW,
LAYOUT_STATIC_FREE, LAYOUT_STATIC, LAYOUT_TEMPLATE, LAYOUT_COUNT
panel* = object
typ*: panel_type
flags*: uint32
bounds*: rect
offset_x*: ptr uint32
offset_y*: ptr uint32
at_x*: float32
at_y*: float32
max_x*: float32
footer_height*: float32
header_height*: float32
border*: float32
has_scrolling*: uint32
clip*: rect
menu*: menu_state
row*: row_layout
chart*: chart
popup_buffer*: popup_buffer
buffer*: ptr command_buffer
parent*: ptr panel
window* = object
s*: uint32
name*: uint32
name_string*: array[64, char]
flags*: uint32
bounds*: rect
scrollbar*: scroll
buffer*: command_buffer
layout*: ptr panel
scrollbar_hiding_timer*: float32
property*: property_state
popup*: popup_state
edit*: edit_state
scrolled*: uint32
tables*: ptr table
table_count*: uint16
table_size*: uint16
next*: ptr window
prev*: ptr window
parent*: ptr window
popup_state* = object
win*: ptr window
typ*: panel_type
name*: uint32
active*: int32
combo_count*: uint32
con_count*: uint32
con_old*: uint32
active_con*: uint32
header*: rect
edit_state* = object
name*: uint32
s*: uint32
old*: uint32
active*: int32
prev*: int32
cursor*: int32
sel_start*: int32
sel_end*: int32
scrollbar*: scroll
mode*: cuchar
single_line*: cuchar
property_state* = object
active*: int32
prev*: int32
buffer*: array[64, char]
length*: int32
cursor*: int32
name*: uint32
s*: uint32
old*: uint32
state*: int32
style_item_data* = object {.union.}
image*: img
color*: color
style_item* = object
typ*: style_item_type
data*: style_item_data
config_stack_style_item_element* = object
address*: ptr style_item
old_value*: style_item
config_stack_float_element* = object
address*: ptr float32
old_value*: float32
config_stack_vec2_element* = object
address*: ptr vec2
old_value*: vec2
config_stack_flags_element* = object
address*: ptr uint32
old_value*: uint32
config_stack_color_element* = object
address*: ptr color
old_value*: color
config_stack_user_font_element* = object
address*: ptr ptr user_font
old_value*: ptr user_font
config_stack_button_behavior_element* = object
address*: ptr button_behavior
old_value*: button_behavior
config_stack_style_item* = object
head*: int32
elements*: array[16, config_stack_style_item_element]
config_stack_float* = object
head*: int32
elements*: array[32, config_stack_float_element]
config_stack_vec2* = object
head*: int32
elements*: array[16, config_stack_vec2_element]
config_stack_flags* = object
head*: int32
elements*: array[32, config_stack_flags_element]
config_stack_color* = object
head*: int32
elements*: array[32, config_stack_color_element]
config_stack_user_font* = object
head*: int32
elements*: array[8, config_stack_user_font_element]
config_stack_button_behavior* = object
head*: int32
elements*: array[8, config_stack_button_behavior_element]
configuration_stacks* = object
style_items*: config_stack_style_item
floats*: config_stack_float
vectors*: config_stack_vec2
flags*: config_stack_flags
colors*: config_stack_color
fonts*: config_stack_user_font
button_behaviors*: config_stack_button_behavior
table* = object
s*: uint32
keys: array[find_size(window, panel), uint32]
values: array[find_size(window, panel), uint32]
next*: ptr table
prev*: ptr table
page_data* = object {.union.}
tbl*: table
pan*: panel
win*: window
page_element* = object
data*: page_data
next*: ptr page_element
prev*: ptr page_element
page* = object
size*: uint32
next*: ptr page
win*: array[1, page_element]
pool* = object
alloc*: allocator
typ*: allocation_type
page_count*: uint32
pages*: ptr page
freelist*: ptr page_element
capacity*: uint32
size*: uint
cap*: uint
mouse_button* = object
down*: int32
clicked*: uint32
clicked_pos*: vec2
mouse* = object
buttons*: array[BUTTON_MAX, mouse_button]
pos*: vec2
prev*: vec2
delta*: vec2
scroll_delta*: float32
grab*: cuchar
grabbed*: cuchar
ungrab*: cuchar
key* = object
down*: int32
clicked*: uint32
keyboard* = object
keys*: array[KEY_MAX, key]
text*: array[16, char]
text_len*: int32
input* = object
keyboard*: keyboard
mouse*: mouse
context* = object
input*: input
style*: style
memory*: buffer
clip*: clipboard
last_widget_state*: uint32
button_behavior*: button_behavior
stacks*: configuration_stacks
delta_time_seconds*: float32
draw_list*: draw_list
text_edit*: text_edit
overlay*: command_buffer
build*: int32
use_pool*: int32
pool*: pool
begin*: ptr window
e*: ptr window
active*: ptr window
current*: ptr window
freelist*: ptr page_element
count*: uint32
s*: uint32
plugin_paste* = proc (a2: handle; a3: ptr text_edit) {.cdecl.}
plugin_copy* = proc (a2: handle; a3: cstring; len: int32) {.cdecl.}
clipboard* = object
userdata*: handle
paste*: plugin_paste
copy*: plugin_copy
text_edit* = object
clip*: clipboard
str*: str
filter*: plugin_filter
scrollbar*: vec2
cursor*: int32
select_start*: int32
select_end*: int32
mode*: cuchar
cursor_at_end_of_line*: cuchar
initialized*: cuchar
has_preferred_x*: cuchar
single_line*: cuchar
active*: cuchar
padding1*: cuchar
preferred_x*: float32
undo*: text_undo_state
plugin_filter = proc (a2: ptr text_edit; unicode: uint32): int32 {.cdecl.}
InputFilter* = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.}
text_undo_record* = object
where*: int32
insert_length*: int16
delete_length*: int16
char_storage*: int16
text_undo_state* = object
undo_rec*: array[99, text_undo_record]
undo_char*: array[999, uint32]
undo_point*: int16
redo_point*: int16
undo_char_point*: int16
redo_char_point*: int16
text_edit_type* {.size: sizeof(int32).} = enum
TEXT_EDIT_SINGLE_LINE, TEXT_EDIT_MULTI_LINE
style_text* = object
color*: color
padding*: vec2
style_button* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
text_background*: color
text_normal*: color
text_hover*: color
text_active*: color
text_alignment*: uint32
border*: float32
rounding*: float32
padding*: vec2
image_padding*: vec2
touch_padding*: vec2
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; userdata: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; userdata: handle) {.cdecl.}
style_toggle* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
cursor_normal*: style_item
cursor_hover*: style_item
text_normal*: color
text_hover*: color
text_active*: color
text_background*: color
text_alignment*: uint32
padding*: vec2
touch_padding*: vec2
spacing*: float32
border*: float32
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_selectable* = object
normal*: style_item
hover*: style_item
pressed*: style_item
normal_active*: style_item
hover_active*: style_item
pressed_active*: style_item
text_normal*: color
text_hover*: color
text_pressed*: color
text_normal_active*: color
text_hover_active*: color
text_pressed_active*: color
text_background*: color
text_alignment*: uint32
rounding*: float32
padding*: vec2
touch_padding*: vec2
image_padding*: vec2
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_slider* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
bar_normal*: color
bar_hover*: color
bar_active*: color
bar_filled*: color
cursor_normal*: style_item
cursor_hover*: style_item
cursor_active*: style_item
border*: float32
rounding*: float32
bar_height*: float32
padding*: vec2
spacing*: vec2
cursor_size*: vec2
show_buttons*: int32
inc_button*: style_button
dec_button*: style_button
inc_symbol*: symbol_type
dec_symbol*: symbol_type
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_progress* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
cursor_normal*: style_item
cursor_hover*: style_item
cursor_active*: style_item
cursor_border_color*: color
rounding*: float32
border*: float32
cursor_border*: float32
cursor_rounding*: float32
padding*: vec2
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_scrollbar* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
cursor_normal*: style_item
cursor_hover*: style_item
cursor_active*: style_item
cursor_border_color*: color
border*: float32
rounding*: float32
border_cursor*: float32
rounding_cursor*: float32
padding*: vec2
show_buttons*: int32
inc_button*: style_button
dec_button*: style_button
inc_symbol*: symbol_type
dec_symbol*: symbol_type
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_edit* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
scrollbar*: style_scrollbar
cursor_normal*: color
cursor_hover*: color
cursor_text_normal*: color
cursor_text_hover*: color
text_normal*: color
text_hover*: color
text_active*: color
selected_normal*: color
selected_hover*: color
selected_text_normal*: color
selected_text_hover*: color
border*: float32
rounding*: float32
cursor_size*: float32
scrollbar_size*: vec2
padding*: vec2
row_padding*: float32
style_property* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
label_normal*: color
label_hover*: color
label_active*: color
sym_left*: symbol_type
sym_right*: symbol_type
border*: float32
rounding*: float32
padding*: vec2
edit*: style_edit
inc_button*: style_button
dec_button*: style_button
userdata*: handle
draw_begin*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
draw_end*: proc (a2: ptr command_buffer; a3: handle) {.cdecl.}
style_chart* = object
background*: style_item
border_color*: color
selected_color*: color
color*: color
border*: float32
rounding*: float32
padding*: vec2
style_combo* = object
normal*: style_item
hover*: style_item
active*: style_item
border_color*: color
label_normal*: color
label_hover*: color
label_active*: color
symbol_normal*: color
symbol_hover*: color
symbol_active*: color
button*: style_button
sym_normal*: symbol_type
sym_hover*: symbol_type
sym_active*: symbol_type
border*: float32
rounding*: float32
content_padding*: vec2
button_padding*: vec2
spacing*: vec2
style_tab* = object
background*: style_item
border_color*: color
text*: color
tab_maximize_button*: style_button
tab_minimize_button*: style_button
node_maximize_button*: style_button
node_minimize_button*: style_button
sym_minimize*: symbol_type
sym_maximize*: symbol_type
border*: float32
rounding*: float32
indent*: float32
padding*: vec2
spacing*: vec2
style_header_align* {.size: sizeof(int32).} = enum
HEADER_LEFT, HEADER_RIGHT
style_window_header* = object
normal*: style_item
hover*: style_item
active*: style_item
close_button*: style_button
minimize_button*: style_button
close_symbol*: symbol_type
minimize_symbol*: symbol_type
maximize_symbol*: symbol_type
label_normal*: color
label_hover*: color
label_active*: color
align*: style_header_align
padding*: vec2
label_padding*: vec2
spacing*: vec2
style_window* = object
header*: style_window_header
fixed_background*: style_item
background*: color
border_color*: color
popup_border_color*: color
combo_border_color*: color
contextual_border_color*: color
menu_border_color*: color
group_border_color*: color
tooltip_border_color*: color
scaler*: style_item
border*: float32
combo_border*: float32
contextual_border*: float32
menu_border*: float32
group_border*: float32
tooltip_border*: float32
popup_border*: float32
rounding*: float32
spacing*: vec2
scrollbar_size*: vec2
min_size*: vec2
padding*: vec2
group_padding*: vec2
popup_padding*: vec2
combo_padding*: vec2
contextual_padding*: vec2
menu_padding*: vec2
tooltip_padding*: vec2
style* = object
font*: ptr user_font
cursors*: array[CURSOR_COUNT, ptr cursor]
cursor_active*: ptr cursor
cursor_last*: ptr cursor
cursor_visible*: int32
text*: style_text
button*: style_button
contextual_button*: style_button
menu_button*: style_button
option*: style_toggle
checkbox*: style_toggle
selectable*: style_selectable
slider*: style_slider
progress*: style_progress
property*: style_property
edit*: style_edit
chart*: style_chart
scrollh*: style_scrollbar
scrollv*: style_scrollbar
tab*: style_tab
combo*: style_combo
window*: style_window
type
modify* {.size: sizeof(int32).} = enum
FIXED = false, MODIFIABLE = true
type
orientation* {.size: sizeof(int32).} = enum
VERTICAL, HORIZONTAL
type
collapse_states* {.size: sizeof(int32).} = enum
MINIMIZED = false, MAXIMIZED = true
type
show_states* {.size: sizeof(int32).} = enum
HIDDEN = false, SHOWN = true
type
chart_event* {.size: sizeof(int32).} = enum
charT_HOVERING = 0x00000001, charT_CLICKED = 0x00000002
type
color_format* {.size: sizeof(int32).} = enum
RGB, RGBA
type
popup_type* {.size: sizeof(int32).} = enum
POPUP_STATIC, POPUP_DYNAMIC
type
layout_format* {.size: sizeof(int32).} = enum
DYNAMIC, STATIC
type
tree_type* {.size: sizeof(int32).} = enum
TREE_NODE, TREE_TAB
type
style_colors* {.size: sizeof(int32).} = enum
COLOR_TEXT, COLOR_WINDOW, COLOR_HEADER, COLOR_BORDER,
COLOR_BUTTON, COLOR_BUTTON_HOVER, COLOR_BUTTON_ACTIVE,
COLOR_TOGGLE, COLOR_TOGGLE_HOVER, COLOR_TOGGLE_CURSOR,
COLOR_SELECT, COLOR_SELECT_ACTIVE, COLOR_SLIDER,
COLOR_SLIDER_CURSOR, COLOR_SLIDER_CURSOR_HOVER,
COLOR_SLIDER_CURSOR_ACTIVE, COLOR_PROPERTY, COLOR_EDIT,
COLOR_EDIT_CURSOR, COLOR_COMBO, COLOR_CHART, COLOR_CHART_COLOR,
COLOR_CHART_COLOR_HIGHLIGHT, COLOR_SCROLLBAR, COLOR_SCROLLBAR_CURSOR,
COLOR_SCROLLBAR_CURSOR_HOVER, COLOR_SCROLLBAR_CURSOR_ACTIVE,
COLOR_TAB_HEADER, COLOR_COUNT
type
widget_layout_states* {.size: sizeof(int32).} = enum
WIDGET_INVALID, WIDGET_VALID, WIDGET_ROM
type
widget_states* {.size: sizeof(int32).} = enum
WIDGET_STATE_MODIFIED = (1 shl (1)), WIDGET_STATE_INACTIVE = (1 shl (2)),
WIDGET_STATE_ENTERED = (1 shl (3)), WIDGET_STATE_HOVER = (1 shl (4)),
WIDGET_STATE_ACTIVED = (1 shl (5)), WIDGET_STATE_LEFT = (1 shl (6))
const WIDGET_STATE_HOVERED = widget_states(WIDGET_STATE_HOVER.int32 or WIDGET_STATE_MODIFIED.int32)
const WIDGET_STATE_ACTIVE = widget_states(WIDGET_STATE_ACTIVED.int32 or WIDGET_STATE_MODIFIED.int32)
type
text_align* {.size: sizeof(int32).} = enum
TEXT_ALIGN_LEFT = 0x00000001, TEXT_ALIGN_CENTERED = 0x00000002,
TEXT_ALIGN_RIGHT = 0x00000004, TEXT_ALIGN_TOP = 0x00000008,
TEXT_ALIGN_MIDDLE = 0x00000010, TEXT_ALIGN_BOTTOM = 0x00000020
type
text_alignment* {.size: sizeof(int32).} = enum
TEXT_LEFT = TEXT_ALIGN_MIDDLE.int32 or TEXT_ALIGN_LEFT.int32,
TEXT_CENTERED = TEXT_ALIGN_MIDDLE.int32 or TEXT_ALIGN_CENTERED.int32,
TEXT_RIGHT = TEXT_ALIGN_MIDDLE.int32 or TEXT_ALIGN_RIGHT.int32
type
edit_flags* {.size: sizeof(int32).} = enum
EDIT_DEFAULT = 0, EDIT_READ_ONLY = (1 shl (0)),
EDIT_AUTO_SELECT = (1 shl (1)), EDIT_SIG_ENTER = (1 shl (2)),
EDIT_ALLOW_TAB = (1 shl (3)), EDIT_NO_CURSOR = (1 shl (4)),
EDIT_SELECTABLE = (1 shl (5)), EDIT_CLIPBOARD = (1 shl (6)),
EDIT_CTRL_ENTER_NEWLINE = (1 shl (7)),
EDIT_NO_HORIZONTAL_SCROLL = (1 shl (8)),
EDIT_ALWAYS_INSERT_MODE = (1 shl (9)), EDIT_MULTILINE = (1 shl (11)),
EDIT_GOTO_END_ON_ACTIVATE = (1 shl (12))
type
edit_types* {.size: sizeof(int32).} = enum
EDIT_SIMPLE = EDIT_ALWAYS_INSERT_MODE,
EDIT_FIELD = EDIT_SIMPLE.int32 or EDIT_SELECTABLE.int32 or EDIT_CLIPBOARD.int32,
EDIT_EDITOR = EDIT_SELECTABLE.int32 or EDIT_MULTILINE.int32 or EDIT_ALLOW_TAB.int32 or EDIT_CLIPBOARD.int32,
EDIT_BOX = EDIT_ALWAYS_INSERT_MODE.int32 or EDIT_SELECTABLE.int32 or EDIT_MULTILINE.int32 or EDIT_ALLOW_TAB.int32 or EDIT_CLIPBOARD.int32
type
edit_events* {.size: sizeof(int32).} = enum
EDIT_ACTIVE = (1 shl (0)), EDIT_INACTIVE = (1 shl (1)),
EDIT_ACTIVATED = (1 shl (2)), EDIT_DEACTIVATED = (1 shl (3)),
EDIT_COMMITED = (1 shl (4))
type
panel_flags* {.size: sizeof(int32).} = enum
WINDOW_BORDER = (1 shl (0)), WINDOW_MOVABLE = (1 shl (1)),
WINDOW_SCALABLE = (1 shl (2)), WINDOW_CLOSABLE = (1 shl (3)),
WINDOW_MINIMIZABLE = (1 shl (4)), WINDOW_NO_SCROLLBAR = (1 shl (5)),
WINDOW_TITLE = (1 shl (6)), WINDOW_SCROLL_AUTO_HIDE = (1 shl (7)),
WINDOW_BACKGROUND = (1 shl (8)), WINDOW_SCALE_LEFT = (1 shl (9))
type
text_edit_mode* {.size: sizeof(int32).} = enum
TEXT_EDIT_MODE_VIEW, TEXT_EDIT_MODE_INSERT, TEXT_EDIT_MODE_REPLACE
proc filter_default(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_default", cdecl.}
var filter* : InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_default(addr te, unicode)
proc filter_ascii(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_ascii".}
var asciiFilter* : InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_ascii(addr te, unicode)
proc filter_float(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_float".}
var floatFilter*: InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_float(addr te, unicode)
proc filter_decimal(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_decimal".}
var decimalFilter*: InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_decimal(addr te, unicode)
proc filter_hex(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_hex".}
var hexFilter*: InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_hex(addr te, unicode)
proc filter_oct(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_oct".}
var octFilter*: InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_oct(addr te, unicode)
proc filter_binary(a2: ptr text_edit; unicode: uint32): int32 {.importc: "nk_filter_binary".}
var binaryFilter*: InputFilter = proc(te: var text_edit, unicode: uint32): int32 {.closure, cdecl.} =
filter_binary(addr te, unicode)
proc textedit_init(a2: ptr text_edit; a3: ptr allocator; size: uint) {. importc: "nk_textedit_init".}
proc init*(te: var text_edit, a: var allocator, size: uint) =
textedit_init(addr te, addr a, size)
proc textedit_init_fixed(a2: ptr text_edit; memory: pointer; size: uint) {. importc: "nk_textedit_init_fixed".}
proc initFixed*(te: var text_edit, memory: pointer, size: uint) =
textedit_init_fixed(addr te, memory, size)
proc textedit_free(a2: ptr text_edit) {.importc: "nk_textedit_free".}
proc free*(te: var text_edit) =
textedit_free(addr te)
proc textedit_text(a2: ptr text_edit; a3: cstring; total_len: int32) {.importc: "nk_textedit_text".}
proc text*(te: var text_edit, t: string, totalLen: int32) =
textedit_text(addr te, t, totalLen)
proc textedit_delete(a2: ptr text_edit; where: int32; len: int32) {.importc: "nk_textedit_delete".}
proc delete*(te: var text_edit, where: int32, len: int32) =
textedit_delete(addr te, where, len)
proc textedit_delete_selection*(a2: ptr text_edit) {.importc: "nk_textedit_delete_selection".}
proc deleteSelection*(te: var text_edit) =
textedit_delete_selection(addr te)
proc textedit_select_all(a2: ptr text_edit) {.importc: "nk_textedit_select_all".}
proc selectAll*(te: var text_edit) =
textedit_select_all(addr te)
proc textedit_cut(a2: ptr text_edit): int32 {.importc: "nk_textedit_cut".}
proc cut*(te: var text_edit): int32 =
textedit_cut(addr te)
proc textedit_paste(a2: ptr text_edit; a3: cstring; len: int32): int32 {.importc: "nk_textedit_paste".}
proc paste*(te: var text_edit, text: string, len: int32): int32 =
textedit_paste(addr te, text, len)
proc textedit_undo*(a2: ptr text_edit) {.importc: "nk_textedit_undo".}
proc undo*(te: var text_edit) =
textedit_undo(addr te)
proc textedit_redo(a2: ptr text_edit) {.importc: "nk_textedit_redo".}
proc redo*(te: var text_edit) =
textedit_redo(addr te)
type
command_type* {.size: sizeof(int32).} = enum
COMMAND_NOP, COMMAND_SCISSOR, COMMAND_LINE, COMMAND_CURVE,
COMMAND_RECT, COMMAND_RECT_FILLED, COMMAND_RECT_MULTI_COLOR,
COMMAND_CIRCLE, COMMAND_CIRCLE_FILLED, COMMAND_ARC,
COMMAND_ARC_FILLED, COMMAND_TRIANGLE, COMMAND_TRIANGLE_FILLED,
COMMAND_POLYGON, COMMAND_POLYGON_FILLED, COMMAND_POLYLINE,
COMMAND_TEXT, COMMAND_IMAGE
type
command* = object
typ*: command_type
next*: uint
command_scissor* = object
header*: command
x*: int16
y*: int16
w*: uint16
h*: uint16
command_line* = object
header*: command
line_thickness*: uint16
begin*: vec2i
e*: vec2i
color*: color
command_curve* = object
header*: command
line_thickness*: uint16
begin*: vec2i
e*: vec2i
ctrl*: array[2, vec2i]
color*: color
command_rect* = object
header*: command
rounding*: uint16
line_thickness*: uint16
x*: int16
y*: int16
w*: uint16
h*: uint16
color*: color
command_rect_filled* = object
header*: command
rounding*: uint16
x*: int16
y*: int16
w*: uint16
h*: uint16
color*: color
command_rect_multi_color* = object
header*: command
x*: int16
y*: int16
w*: uint16
h*: uint16
left*: color
top*: color
bottom*: color
right*: color
command_triangle* = object
header*: command
line_thickness*: uint16
a*: vec2i
b*: vec2i
c*: vec2i
color*: color
command_triangle_filled* = object
header*: command
a*: vec2i
b*: vec2i
c*: vec2i
color*: color
command_circle* = object
header*: command
x*: int16
y*: int16
line_thickness*: uint16
w*: uint16
h*: uint16
color*: color
command_circle_filled* = object
header*: command
x*: int16
y*: int16
w*: uint16
h*: uint16
color*: color
command_arc* = object
header*: command
cx*: int16
cy*: int16
r*: uint16
line_thickness*: uint16
a*: array[2, float32]
color*: color
command_arc_filled* = object
header*: command
cx*: int16
cy*: int16
r*: uint16
a*: array[2, float32]
color*: color
command_polygon* = object
header*: command
color*: color
line_thickness*: uint16
point_count*: uint16
points*: array[1, vec2i]
command_polygon_filled* = object
header*: command
color*: color
point_count*: uint16
points*: array[1, vec2i]
command_polyline* = object
header*: command
color*: color
line_thickness*: uint16
point_count*: uint16
points*: array[1, vec2i]
command_image* = object
header*: command
x*: int16
y*: int16
w*: uint16
h*: uint16
img*: img
col*: color
command_text* = object
header*: command
font*: ptr user_font
background*: color
foreground*: color
x*: int16
y*: int16
w*: uint16
h*: uint16
height*: float32
length*: int32
string*: array[1, char]
command_clipping* {.size: sizeof(int32).} = enum
CLIPPING_OFF = nk_false, CLIPPING_ON = nk_true
proc stroke_line(b: ptr command_buffer; x0: float32; y0: float32; x1: float32;
y1: float32; line_thickness: float32; a8: color) {.importc: "nk_stroke_line".}
proc strokeLine*(cmdBuf: var command_buffer, x0, y0, x1, y1, lineThickness: float32, col: color) =
stroke_line(addr cmdBuf, x0, y0, x1, y1, lineThickness, col)
proc stroke_curve(a2: ptr command_buffer; a3: float32; a4: float32; a5: float32;
a6: float32; a7: float32; a8: float32; a9: float32; a10: float32;
line_thickness: float32; a12: color) {.importc: "nk_stroke_curve".}
proc strokeCurve*(cmdBuf: var command_buffer, ax, ay, ctrl0x, ctrl0y, ctrl1x, ctrl1y, bx, by, lineThickness: float32, col: color) =
stroke_curve(addr cmdBuf, ax, ay, ctrl0x, ctrl0y, ctrl1x, ctrl1y, bx, by, lineThickness, col)
proc stroke_rect(a2: ptr command_buffer; a3: rect; rounding: float32;
line_thickness: float32; a6: color) {.importc: "nk_stroke_rect".}
proc strokeRect*(cmdBuf: var command_buffer, r: rect, rounding, lineThickness: float32, col: color) =
stroke_rect(addr cmdBuf, r, rounding, lineThickness, col)
proc stroke_circle(a2: ptr command_buffer; a3: rect; line_thickness: float32;
a5: color) {.importc: "nk_stroke_circle".}
proc strokeCircle*(cmdBuf: var command_buffer, r: rect, lineThickness: float32, col: color) =
stroke_circle(addr cmdBuf, r, lineThickness, col)
proc stroke_arc(a2: ptr command_buffer; cx: float32; cy: float32; radius: float32;
a_min: float32; a_max: float32; line_thickness: float32; a9: color) {. importc: "nk_stroke_arc".}
proc strokeArc*(cmdBuf: var command_buffer, cx, cy, radius, aMin, aMax, lineThickness: float32, col: color) =
stroke_arc(addr cmdBuf, cx, cy, radius, aMin, aMax, lineThickness, col)
proc stroke_triangle(a2: ptr command_buffer; a3: float32; a4: float32; a5: float32;
a6: float32; a7: float32; a8: float32; line_thichness: float32;
a10: color) {.importc: "nk_stroke_triangle".}
proc strokeTriangle*(cmdBuf: var command_buffer, x0, y0, x1, y1, x2, y2, lineThickness: float32, col: color) =
stroke_triangle(addr cmdBuf, x0, y0, x1, y1, x2, y2, lineThickness, col)
proc stroke_polyline(a2: ptr command_buffer; points: ptr float32;
point_count: int32; line_thickness: float32; col: color) {. importc: "nk_stroke_polyline".}
proc strokePolyLine*(cmdBuf: var command_buffer, points: var float32, pointCount: int32, lineThickness: float32, col: color) =
stroke_polyline(addr cmdBuf, addr points, pointCount, lineThickness, col)
proc stroke_polygon(a2: ptr command_buffer; a3: ptr float32; point_count: int32;
line_thickness: float32; a6: color) {.importc: "nk_stroke_polygon".}
proc strokePolygon*(cmdBuf: var command_buffer, points: var float32, pointCount: int32, lineThickness: float32, col: color) =
stroke_polygon(addr cmdBuf, addr points, pointCount, lineThickness, col)
proc fill_rect(a2: ptr command_buffer; a3: rect; rounding: float32;
a5: color) {.importc: "nk_fill_rect".}
proc fillRect*(cmdBuf: var command_buffer, r: rect, rounding: float32, col: color) =
fill_rect(addr cmdBuf, r, rounding, col)
proc fill_rect_multi_color(a2: ptr command_buffer; a3: rect; left: color;
top: color; right: color; bottom: color) {. importc: "nk_fill_rect_multi_color".}
proc fillRectMultiColor*(cmdBuf: var command_buffer, r: rect, left, top, right, bottom: color) =
fill_rect_multi_color(addr cmdBuf, r, left, top, right, bottom)
proc fill_circle(a2: ptr command_buffer; a3: rect; a4: color) {.importc: "nk_fill_circle".}
proc fillCircle*(cmdBuf: var command_buffer, r: rect, col: color) =
fill_circle(addr cmdBuf, r, col)
proc fill_arc(a2: ptr command_buffer; cx: float32; cy: float32; radius: float32;
a_min: float32; a_max: float32; a8: color) {.importc: "nk_fill_arc".}
proc fillArc*(cmdBuf: var command_buffer, cx, cy, radius, aMin, aMax: float32, col: color) =
fill_arc(addr cmdBuf, cx, cy, radius, aMin, aMax, col)
proc fill_triangle(a2: ptr command_buffer; x0: float32; y0: float32; x1: float32;
y1: float32; x2: float32; y2: float32; a9: color) {.importc: "nk_fill_triangle".}
proc fillTriangle*(cmdBuf: var command_buffer, x0, y0, x1, y1, x2, y2: float32, col: color) =
fill_triangle(addr cmdBuf, x0, y0, x1, y1, x2, y2, col)
proc fill_polygon(a2: ptr command_buffer; a3: ptr float32; point_count: int32;
a5: color) {.importc: "nk_fill_polygon".}
proc fillPolygon*(cmdBuf: var command_buffer, points: var float32, pointCount: int32, col: color) =
fill_polygon(addr cmdBuf, addr points, pointCount, col)
proc push_scissor(a2: ptr command_buffer; a3: rect) {.importc: "nk_push_scissor".}
proc pushScissor*(cmdBuf: var command_buffer, r: rect) =
push_scissor(addr cmdBuf, r)
proc draw_image(a2: ptr command_buffer; a3: rect; a4: ptr img;
a5: color) {.importc: "nk_draw_image".}
proc drawImage*(cmdBuf: var command_buffer, r: rect, img: var img, col: color) =
draw_image(addr cmdBuf, r, addr img, col)
proc draw_text(a2: ptr command_buffer; a3: rect; text: cstring; len: int32;
a6: ptr user_font; a7: color; a8: color) {.importc: "nk_draw_text".}
proc drawText*(cmdBuf: var command_buffer, r: rect, text: string, len: int32, userFont: var user_font, bg, fg: color) =
draw_text(addr cmdBuf, r, text, len, addr userFont, fg, bg)
proc next*(a2: ptr context; a3: ptr command): ptr command {.importc: "nk__next".}
proc begin(a2: ptr context): ptr command {.importc: "nk__begin".}
proc begin*(ctx: var context): ptr command =
begin(addr ctx)
proc input_has_mouse_click*(a2: ptr input; a3: buttons): int32 {.importc: "nk_input_has_mouse_click".}
proc input_has_mouse_click_in_rect(a2: ptr input; a3: buttons; a4: rect): int32 {. importc: "nk_input_has_mouse_click_in_rect".}
proc hasMouseClickInRect*(i: var input, button: buttons, bounds: rect): bool =
bool input_has_mouse_click_in_rect(addr i, button, bounds)
proc input_has_mouse_click_down_in_rect*(a2: ptr input; a3: buttons;
a4: rect; down: int32): int32 {.importc: "nk_input_has_mouse_click_down_in_rect".}
proc hasMouseClickDownInRect*(i: var input, button: buttons, bounds: rect, down: bool): bool =
bool input_has_mouse_click_down_in_rect(addr i, button, bounds, int32 down)
proc input_is_mouse_click_in_rect(a2: ptr input; a3: buttons; a4: rect): int32 {. importc: "nk_input_is_mouse_click_in_rect".}
proc isMouseClickInRect*(i: var input, button: buttons, bounds: rect): bool =
bool input_is_mouse_click_in_rect(addr i, button, bounds)
proc input_is_mouse_click_down_in_rect(i: ptr input; id: buttons;
b: rect; down: int32): int32 {. importc: "nk_input_is_mouse_click_down_in_rect".}
proc isMouseClickDownInRect*(i: var input, button: buttons, bounds: rect, down: bool): bool =
bool input_is_mouse_click_down_in_rect(addr i, button, bounds, int32 down)
proc input_any_mouse_click_in_rect(a2: ptr input; a3: rect): int32 {.importc: "nk_input_any_mouse_click_in_rect".}
proc anyMouseClickInRect*(i: var input, bounds: rect): bool =
bool input_any_mouse_click_in_rect(addr i, bounds)
proc input_is_mouse_prev_hovering_rect(a2: ptr input; a3: rect): int32 {. importc: "nk_input_is_mouse_prev_hovering_rect".}
proc isMousePrevHoveringRect*(i: var input, bounds: rect): bool =
bool input_is_mouse_prev_hovering_rect(addr i, bounds)
proc input_is_mouse_hovering_rect(a2: ptr input; a3: rect): int32 {.importc: "nk_input_is_mouse_hovering_rect".}
proc isMouseHoveringRect*(i: var input, bounds: rect): bool =
bool input_is_mouse_hovering_rect(addr i, bounds)
proc input_mouse_clicked(a2: ptr input; a3: buttons; a4: rect): int32 {. importc: "nk_input_mouse_clicked".}
proc isMouseClicked*(i: var input, button: buttons, bounds: rect): bool =
bool input_mouse_clicked(addr i, button, bounds)
proc input_is_mouse_down(a2: ptr input; a3: buttons): int32 {.importc: "nk_input_is_mouse_down".}
proc isMouseDown*(i: var input, button: buttons): bool =
bool input_is_mouse_down(addr i, button)
proc input_is_mouse_pressed(a2: ptr input; a3: buttons): int32 {.importc: "nk_input_is_mouse_pressed".}
proc isMousePressed*(i: var input, button: buttons): bool =
bool input_is_mouse_pressed(addr i, button)
proc input_is_mouse_released*(a2: ptr input; a3: buttons): int32 {.importc: "nk_input_is_mouse_released".}
proc isMouseReleased*(i: var input, button: buttons): bool =
bool input_is_mouse_released(addr i, button)
proc input_is_key_pressed(a2: ptr input; a3: keys): int32 {.importc: "nk_input_is_key_pressed".}
proc isKeyPresed*(i: var input, key: keys): bool =
bool input_is_key_pressed(addr i, key)
proc input_is_key_released(a2: ptr input; a3: keys): int32 {.importc: "nk_input_is_key_released".}
proc isKeyReleased*(i: var input, key: keys): bool =
bool input_is_key_released(addr i, key)
proc input_is_key_down(a2: ptr input; a3: keys): int32 {.importc: "nk_input_is_key_down".}
proc isKeyDown*(i: var input, key: keys): bool =
bool input_is_key_down(addr i, key)
type
draw_index* = int16
draw_list_stroke* = enum
STROKE_OPEN = nk_false, STROKE_CLOSED = nk_true
const
FORMAT_R8G8B8 = FORMAT_COLOR_BEGIN
FORMAT_COLOR_END = FORMAT_RGBA32
proc draw_list_init(a2: ptr draw_list) {.importc: "nk_draw_list_init".}
proc init*(drawList: var draw_list) =
draw_list_init(addr drawList)
proc draw_list_setup(a2: ptr draw_list; a3: ptr convert_config;
cmds: ptr buffer; vertices: ptr buffer;
elements: ptr buffer) {.importc: "nk_draw_list_setup".}
proc setup*(drawList: var draw_list, convertConfig: var convert_config, cmds, vertices, elements: var buffer) =
draw_list_setup(addr drawList, addr convertConfig, addr cmds, addr vertices, addr elements)
proc draw_list_clear(a2: ptr draw_list) {.importc: "nk_draw_list_clear".}
proc clear*(drawList: var draw_list) =
draw_list_clear(addr drawList)
proc draw_list_begin(a2: ptr draw_list; a3: ptr buffer): ptr draw_command {. importc: "nk__draw_list_begin".}
proc open*(drawList: var draw_list, buf: var buffer): ptr draw_command =
draw_list_begin(addr drawList, addr buf)
proc draw_list_next(a2: ptr draw_command; a3: ptr buffer;
a4: ptr draw_list): ptr draw_command {.importc: "nk__draw_list_next".}
proc next*(drawList: var draw_list, drawCommand: var draw_command, buf: var buffer): ptr draw_command =
draw_list_next(addr drawCommand, addr buf, addr drawList)
proc draw_list_end(a2: ptr draw_list; a3: ptr buffer): ptr draw_command {. importc: "nk__draw_list_end".}
proc close*(drawList: var draw_list, buf: var buffer): ptr draw_command =
draw_list_end(addr drawList, addr buf)
proc draw_list_path_clear(a2: ptr draw_list) {.importc: "nk_draw_list_path_clear".}
proc clearPath*(drawList: var draw_list) =
draw_list_path_clear(addr drawList)
proc draw_list_path_line_to(a2: ptr draw_list; pos: vec2) {.importc: "nk_draw_list_path_line_to".}
proc pathLineTo*(drawList: var draw_list, pos: vec2) =
draw_list_path_line_to(addr drawList, pos)
proc draw_list_path_arc_to_fast(a2: ptr draw_list; center: vec2;
radius: float32; a_min: int32; a_max: int32) {.importc: "nk_draw_list_path_arc_to_fast".}
proc pathArcToFast*(drawList: var draw_list, center: vec2, radius: float32, aMin, aMax: int32) =
draw_list_path_arc_to_fast(addr drawList, center, radius, aMin, aMax)
proc draw_list_path_arc_to(a2: ptr draw_list; center: vec2; radius: float32;
a_min: float32; a_max: float32; segments: uint32) {.importc: "nk_draw_list_path_arc_to".}
proc pathArcTo*(drawList: var draw_list, center: vec2, radius, aMin, aMax: float32, segments: uint32) =
draw_list_path_arc_to(addr drawList, center, radius, aMin, aMax, segments)
proc draw_list_path_rect_to(a2: ptr draw_list; a: vec2; b: vec2;
rounding: float32) {.importc: "nk_draw_list_path_rect_to".}
proc pathRectTo*(drawList: var draw_list, a, b: vec2, rounding: float32) =
draw_list_path_rect_to(addr drawList,a, b, rounding)
proc draw_list_path_curve_to*(a2: ptr draw_list; p2: vec2; p3: vec2;
p4: vec2; num_segments: uint32) {.importc: "nk_draw_list_path_curve_to".}
proc pathCurveTo*(drawList: var draw_list, p2, p3, p4: vec2, numSegments: uint32) =
draw_list_path_curve_to(addr drawList, p2, p3, p4, numSegments)
proc draw_list_path_fill(a2: ptr draw_list; a3: color) {.importc: "nk_draw_list_path_fill".}
proc pathFill*(drawList: var draw_list, col: color) =
draw_list_path_fill(addr drawList, col)
proc draw_list_path_stroke(a2: ptr draw_list; a3: color;
closed: draw_list_stroke; thickness: float32) {. importc: "nk_draw_list_path_stroke".}
proc pathStroke*(drawList: var draw_list, col: color, closed: draw_list_stroke, thickness: float32) =
draw_list_path_stroke(addr drawList, col, closed, thickness)
proc draw_list_stroke_line(a2: ptr draw_list; a: vec2; b: vec2;
a5: color; thickness: float32) {.importc: "nk_draw_list_stroke_line".}
proc strokeLine*(drawList: var draw_list, a, b: vec2, col: color, thickness: float32) =
draw_list_stroke_line(addr drawList, a, b, col, thickness)
proc draw_list_stroke_rect(a2: ptr draw_list; rect: rect; a4: color;
rounding: float32; thickness: float32) {.importc: "nk_draw_list_stroke_rect".}
proc strokeRect*(drawList: var draw_list, bounds: rect, col: color, rounding, thickness: float32) =
draw_list_stroke_rect(addr drawList, bounds, col, rounding, thickness)
proc draw_list_stroke_triangle(a2: ptr draw_list; a: vec2; b: vec2;
c: vec2; a6: color; thickness: float32) {. importc: "nk_draw_list_stroke_triangle".}
proc strokeTriangle*(drawList: var draw_list, a, b, c: vec2, col: color, thickness: float32) =
draw_list_stroke_triangle(addr drawList, a, b, c, col, thickness)
proc draw_list_stroke_circle(a2: ptr draw_list; center: vec2;
radius: float32; a5: color; segs: uint32;
thickness: float32) {.importc: "nk_draw_list_stroke_circle".}
proc strokeCircle*(drawList: var draw_list, center: vec2, radius: float32, col: color, segs: uint32, thickness: float32) =
draw_list_stroke_circle(addr drawList, center, radius, col, segs, thickness)
proc draw_list_stroke_curve(a2: ptr draw_list; p0: vec2; cp0: vec2;
cp1: vec2; p1: vec2; a7: color;
segments: uint32; thickness: float32) {.importc: "nk_draw_list_stroke_curve".}
proc strokeCurve*(drawList: var draw_list, p0, cp0, cp1, p1: vec2, col: color, segments: uint32, thickness: float32) =
draw_list_stroke_curve(addr drawList, p0, cp0, cp1, p1, col, segments, thickness)
proc draw_list_stroke_poly_line(a2: ptr draw_list; pnts: ptr vec2;
cnt: uint32; a5: color;
a6: draw_list_stroke; thickness: float32;
a8: anti_aliasing) {.importc: "nk_draw_list_stroke_poly_line".}
proc strokePolyLine*(drawList: var draw_list, points: var vec2, count: uint32, col: color, stroke: draw_list_stroke, thickness: float32, aa: anti_aliasing) =
draw_list_stroke_poly_line(addr drawList, addr points, count, col, stroke, thickness, aa)
proc draw_list_fill_rect(a2: ptr draw_list; rect: rect; a4: color;
rounding: float32) {.importc: "nk_draw_list_fill_rect".}
proc fillRect*(drawList: var draw_list, bounds: rect, col: color, rounding: float32) =
draw_list_fill_rect(addr drawList, bounds, col, rounding)
proc draw_list_fill_rect_multi_color(a2: ptr draw_list; rect: rect;
left: color; top: color;
right: color; bottom: color) {.importc: "nk_draw_list_fill_rect_multi_color".}
proc fillRectMultiColor*(drawList: var draw_list, bounds: rect, left, top, right, bottom: color) =
draw_list_fill_rect_multi_color(addr drawList, bounds, left, top, right, bottom)
proc draw_list_fill_triangle(a2: ptr draw_list; a: vec2; b: vec2;
c: vec2; a6: color) {.importc: "nk_draw_list_fill_triangle".}
proc fillTriangle*(drawList: var draw_list, a, b, c: vec2, col: color) =
draw_list_fill_triangle(addr drawList, a, b, c, col)
proc draw_list_fill_circle(a2: ptr draw_list; center: vec2; radius: float32;
col: color; segs: uint32) {.importc: "nk_draw_list_fill_circle".}
proc fillCircle*(drawList: var draw_list, center: vec2, radius: float32, col: color, segs: uint32) =
draw_list_fill_circle(addr drawList, center, radius, col, segs)
proc draw_list_fill_poly_convex(a2: ptr draw_list; points: ptr vec2;
count: uint32; a5: color; a6: anti_aliasing) {. importc: "nk_draw_list_fill_poly_convex".}
proc fillConvexPoly*(drawList: var draw_list, points: var vec2, count: uint32, col: color, aa: anti_aliasing) =
draw_list_fill_poly_convex(addr drawList, addr points, count, col, aa)
proc draw_list_add_image(a2: ptr draw_list; texture: img; rect: rect;
a5: color) {.importc: "nk_draw_list_add_image".}
proc addImage*(drawList: var draw_list, i: img, bounds: rect, col: color) =
draw_list_add_image(addr drawList, i, bounds, col)
proc draw_list_add_text(a2: ptr draw_list; a3: ptr user_font; a4: rect;
text: cstring; len: int32; font_height: float32; a8: color) {. importc: "nk_draw_list_add_text".}
proc addText*(drawList: var draw_list, userFont: var user_font, bounds: rect, text: string, len: int32, fontHeight: float32, col: color) =
draw_list_add_text(addr drawList, addr userFont, bounds, text, len, fontHeight, col)
proc style_item_image(img: img): style_item {.importc: "nk_style_item_image".}
proc imageStyleItem*(i: img): style_item =
style_item_image(i)
proc style_item_color(a2: color): style_item {.importc: "nk_style_item_color".}
proc colorStyleItem*(col: color): style_item =
style_item_color(col)
proc style_item_hide(): style_item {.importc: "nk_style_item_hide".}
proc hideStyleItem*(): style_item =
style_item_hide()
type
panel_set* {.size: sizeof(int32).} = enum
PANEL_SET_NONBLOCK = PANEL_CONTEXTUAL.int32 or PANEL_COMBO.int32 or PANEL_MENU.int32 or
PANEL_TOOLTIP.int32,
PANEL_SET_POPUP = PANEL_SET_NONBLOCK.int32 or PANEL_POPUP.int32,
PANEL_SET_SUB = PANEL_SET_POPUP.int32 or PANEL_GROUP.int32
type
window_flags* {.size: sizeof(int32).} = enum
WINDOW_PRIVATE = (1 shl (10)), WINDOW_ROM = (1 shl (11)),
WINDOW_HIDDEN = (1 shl (12)), WINDOW_CLOSED = (1 shl (13)),
WINDOW_MINIMIZED = (1 shl (14)), WINDOW_REMOVE_ROM = (1 shl (15))
const
WINDOW_DYNAMIC = WINDOW_PRIVATE
proc init_default(a2: ptr context; a3: ptr user_font): int32 {.importc: "nk_init_default".}
proc init*(ctx: var context, userFont: var user_font): int32 =
init_default(addr ctx, addr userFont)
proc init_fixed(a2: ptr context; memory: pointer; size: uint;
a5: ptr user_font): int32 {.importc: "nk_init_fixed".}
proc init*(ctx: var context, memory: pointer, size: uint, userFont: var user_font): int32 =
init_fixed(addr ctx, memory, size, addr userFont)
proc init(a2: ptr context; a3: ptr allocator; a4: ptr user_font): int32 {. importc: "nk_init".}
proc init*(ctx: var context, alloc: var allocator, userFont: var user_font): int32 =
init(addr ctx, addr alloc, addr userFont)
proc init_custom(a2: ptr context; cmds: ptr buffer; pool: ptr buffer;
a5: ptr user_font): int32 {.importc: "nk_init_custom".}
proc init*(ctx: var context, cmds: var buffer, pool: var buffer, userFont: var user_font): int32 =
init_custom(addr ctx, addr cmds, addr pool, addr userFont)
proc clear(a2: ptr context) {.importc: "nk_clear".}
proc clear*(ctx: var context) =
clear(addr ctx)
proc free(a2: ptr context) {.importc: "nk_free".}
proc free*(ctx: var context) =
free(addr ctx)
proc begin(a2: ptr context; title: cstring; bounds: rect; flags: uint32): int32 {. importc: "nk_begin".}
proc open*(ctx: var context, title: string, bounds: rect, flags: uint32): bool =
bool begin(addr ctx, title, bounds, flags)
proc begin_titled(a2: ptr context; name: cstring; title: cstring;
bounds: rect; flags: uint32): int32 {.importc: "nk_begin_titled".}
proc openTitled*(ctx: var context, name, title: string, bounds: rect, flags: uint32): bool =
bool begin_titled(addr ctx, name, title, bounds, flags)
proc close(a2: ptr context) {.importc: "nk_end".}
proc close*(ctx: var context) =
close(addr ctx)
proc window_find(ctx: ptr context; name: cstring): ptr window {.importc: "nk_window_find".}
proc findWindow*(ctx: var context, name: string): ptr window =
window_find(addr ctx, name)
proc window_get_bounds(a2: ptr context): rect {.importc: "nk_window_get_bounds".}
proc getWindowBounds*(ctx: var context): rect =
window_get_bounds(addr ctx)
proc window_get_position(a2: ptr context): vec2 {.importc: "nk_window_get_position".}
proc getWindowPosition*(ctx: var context): vec2 =
window_get_position(addr ctx)
proc window_get_size(a2: ptr context): vec2 {.importc: "nk_window_get_size".}
proc getWindowSize*(ctx: var context): vec2 =
window_get_size(addr ctx)
proc window_get_width(a2: ptr context): float32 {.importc: "nk_window_get_width".}
proc getWindowWidth*(ctx: var context): float32 =
window_get_width(addr ctx)
proc window_get_height(a2: ptr context): float32 {.importc: "nk_window_get_height".}
proc getWindowHeight*(ctx: var context): float32 =
window_get_height(addr ctx)
proc window_get_panel(a2: ptr context): ptr panel {.importc: "nk_window_get_panel".}
proc getWindowPanel*(ctx: var context): ptr panel =
window_get_panel(addr ctx)
proc window_get_content_region(a2: ptr context): rect {.importc: "nk_window_get_content_region".}
proc getWindowContentRegion*(ctx: var context): rect =
window_get_content_region(addr ctx)
proc window_get_content_region_min(a2: ptr context): vec2 {.importc: "nk_window_get_content_region_min".}
proc getWindowContentRegionMin*(ctx: var context): vec2 =
window_get_content_region_min(addr ctx)
proc window_get_content_region_max(a2: ptr context): vec2 {.importc: "nk_window_get_content_region_max".}
proc getWindowContentRegionMax*(ctx: var context): vec2 =
window_get_content_region_max(addr ctx)
proc window_get_content_region_size(a2: ptr context): vec2 {.importc: "nk_window_get_content_region_size".}
proc getWindowContentRegionSize*(ctx: var context): vec2 =
window_get_content_region_size(addr ctx)
proc window_get_canvas(a2: ptr context): ptr command_buffer {.importc: "nk_window_get_canvas".}
proc getWindowCanvas*(ctx: var context): ptr command_buffer =
window_get_canvas(addr ctx)
proc window_has_focus(a2: ptr context): int32 {.importc: "nk_window_has_focus".}
proc doesWindowHaveFocus*(ctx: var context): bool =
bool window_has_focus(addr ctx)
proc window_is_collapsed(a2: ptr context; a3: cstring): int32 {.importc: "nk_window_is_collapsed".}
proc isWindowCollasped*(ctx: var context, title: string): bool =
bool window_is_collapsed(addr ctx, title)
proc window_is_closed(a2: ptr context; a3: cstring): int32 {.importc: "nk_window_is_closed".}
proc isWindowClosed*(ctx: var context, title: string): bool =
bool window_is_closed(addr ctx, title)
proc window_is_hidden(a2: ptr context; a3: cstring): int32 {.importc: "nk_window_is_hidden".}
proc isWindowHidden*(ctx: var context, title: string): int32 =
window_is_hidden(addr ctx, title)
proc window_is_active(a2: ptr context; a3: cstring): int32 {.importc: "nk_window_is_active".}
proc isWindowActive*(ctx: var context, title: string): bool =
bool window_is_active(addr ctx, title)
proc window_is_hovered(a2: ptr context): int32 {.importc: "nk_window_is_hovered".}
proc isWindowHovered*(ctx: var context): bool =
bool window_is_hovered(addr ctx)
proc window_is_any_hovered(a2: ptr context): int32 {.importc: "nk_window_is_any_hovered".}
proc isAnyWindowHovered*(ctx: var context): bool =
bool window_is_any_hovered(addr ctx)
proc item_is_any_active(a2: ptr context): int32 {.importc: "nk_item_is_any_active".}
proc isAnyItemActive*(ctx: var context): bool =
bool item_is_any_active(addr ctx)
proc window_set_bounds(a2: ptr context; a3: rect) {.importc: "nk_window_set_bounds".}
proc setWindowBounds*(ctx: var context, bounds: rect) =
window_set_bounds(addr ctx, bounds)
proc window_set_position(a2: ptr context; a3: vec2) {.importc: "nk_window_set_position".}
proc setWindowPosition*(ctx: var context, position: vec2) =
window_set_position(addr ctx, position)
proc window_set_size(a2: ptr context; a3: vec2) {.importc: "nk_window_set_size".}
proc setWindowSize*(ctx: var context, size: vec2) =
window_set_size(addr ctx, size)
proc window_set_focus(a2: ptr context; name: cstring) {.importc: "nk_window_set_focus".}
proc setWindowFocus*(ctx: var context, name: string) =
window_set_focus(addr ctx, name)
proc window_close(ctx: ptr context; name: cstring) {.importc: "nk_window_close".}
proc closeWindow*(ctx: var context, name: string) =
window_close(addr ctx, name)
proc window_collapse(a2: ptr context; name: cstring; a4: collapse_states) {. importc: "nk_window_collapse".}
proc collapseWindow*(ctx: var context, name: string, collapseState: collapse_states) =
window_collapse(addr ctx, name, collapseState)
proc window_collapse_if(a2: ptr context; name: cstring; a4: collapse_states;
cond: int32) {.importc: "nk_window_collapse_if".}
proc collapseWindowIf*(ctx: var context, name: string, collapseState: collapse_states, cond: int32) =
window_collapse_if(addr ctx, name, collapseState, cond)
proc window_show(a2: ptr context; name: cstring; a4: show_states) {.importc: "nk_window_show".}
proc showWindow*(ctx: var context, name: string, showState: show_states) =
window_show(addr ctx, name, showState)
proc window_show_if(a2: ptr context; name: cstring; a4: show_states;
cond: int32) {.importc: "nk_window_show_if".}
proc windowShowIf*(ctx: var context, name: string, showState: show_states, cond: int32) =
window_show_if(addr ctx, name, showState, cond)
proc layout_row_dynamic(a2: ptr context; height: float32; cols: int32) {.importc: "nk_layout_row_dynamic".}
proc layoutDynamicRow*(ctx: var context, height: float32, cols: int32) =
layout_row_dynamic(addr ctx, height, cols)
proc layout_row_static(a2: ptr context; height: float32; item_width: int32;
cols: int32) {.importc: "nk_layout_row_static".}
proc layoutStaticRow*(ctx: var context, height: float32, itemWidth: int32, cols: int32) =
layout_row_static(addr ctx, height, itemWidth, cols)
proc layout_row_begin(a2: ptr context; a3: layout_format;
row_height: float32; cols: int32) {.importc: "nk_layout_row_begin".}
proc beginRowLayout*(ctx: var context, format: layout_format, rowHeight: float32, cols: int32) =
layout_row_begin(addr ctx, format, rowHeight, cols)
proc layout_row_push(a2: ptr context; value: float32) {.importc: "nk_layout_row_push".}
proc pushRowLayout*(ctx: var context, value: float32) =
layout_row_push(addr ctx, value)
proc layout_row_end*(a2: ptr context) {.importc: "nk_layout_row_end".}
proc endRowLayout*(ctx: var context) =
layout_row_end(addr ctx)
proc layout_row(a2: ptr context; a3: layout_format; height: float32;
cols: int32; ratio: ptr float32) {.importc: "nk_layout_row".}
proc layoutRow*(ctx: var context, format: layout_format, height: float32, cols: int32, ratio: var array[2, float32]) =
layout_row(addr ctx, format, height, cols, addr ratio[0])
proc layout_row_template_begin(a2: ptr context; height: float32) {.importc: "nk_layout_row_template_begin".}
proc beginRowLayoutTemplate*(ctx: var context, height: float32) =
layout_row_template_begin(addr ctx, height)
proc layout_row_template_push_dynamic(a2: ptr context) {.importc: "nk_layout_row_template_push_dynamic".}
proc pushDynamicRowLayoutTemplate*(ctx: var context) =
layout_row_template_push_dynamic(addr ctx)
proc layout_row_template_push_variable(a2: ptr context; min_width: float32) {. importc: "nk_layout_row_template_push_variable".}
proc pushVariableRowLayoutTemplate*(ctx: var context, minWidth: float32) =
layout_row_template_push_variable(addr ctx, minWidth)
proc layout_row_template_push_static(a2: ptr context; width: float32) {.importc: "nk_layout_row_template_push_static".}
proc pushStaticRowLayoutTemplate*(ctx: var context, width: float32) =
layout_row_template_push_static(addr ctx, width)
proc layout_row_template_end(a2: ptr context) {.importc: "nk_layout_row_template_end".}
proc endRowLayoutTemplate*(ctx: var context) =
layout_row_template_end(addr ctx)
proc layout_space_begin(a2: ptr context; a3: layout_format; height: float32;
widget_count: int32) {.importc: "nk_layout_space_begin".}
proc beginSpaceLayout*(ctx: var context, format: layout_format, height: float32, widgetCount: int32) =
layout_space_begin(addr ctx, format, height, widgetCount)
proc layout_space_push(a2: ptr context; a3: rect) {.importc: "nk_layout_space_push".}
proc pushSpaceLayout*(ctx: var context, r: rect) =
layout_space_push(addr ctx, r)
proc layout_space_end(a2: ptr context) {.importc: "nk_layout_space_end".}
proc endSpaceLayout*(ctx: var context) =
layout_space_end(addr ctx)
proc layout_space_bounds(a2: ptr context): rect {.importc: "nk_layout_space_bounds".}
proc spaceLayoutBounds*(ctx: var context): rect =
layout_space_bounds(addr ctx)
proc layout_space_to_screen(a2: ptr context; a3: vec2): vec2 {.importc: "nk_layout_space_to_screen".}
proc spaceLayoutToScreen*(ctx: var context, ret: vec2): vec2 =
layout_space_to_screen(addr ctx, ret)
proc layout_space_to_local(a2: ptr context; a3: vec2): vec2 {.importc: "nk_layout_space_to_local".}
proc spaceLayoutToLocal*(ctx: var context, ret: vec2): vec2 =
layout_space_to_local(addr ctx, ret)
proc layout_space_rect_to_screen(a2: ptr context; a3: rect): rect {.importc: "nk_layout_space_rect_to_screen".}
proc spaceLayoutRectToScreen*(ctx: var context, ret: rect): rect =
layout_space_rect_to_screen(addr ctx, ret)
proc layout_space_rect_to_local(a2: ptr context; a3: rect): rect {.importc: "nk_layout_space_rect_to_local".}
proc spaceLayoutRectToLocal*(ctx: var context, ret: rect): rect =
layout_space_rect_to_local(addr ctx, ret)
proc layout_ratio_from_pixel(a2: ptr context; pixel_width: float32): float32 {. importc: "nk_layout_ratio_from_pixel".}
proc ratioLayoutFromPixel*(ctx: var context, pixelWidth: float32): float32 =
layout_ratio_from_pixel(addr ctx, pixelWidth)
proc group_begin(a2: ptr context; title: cstring; a4: uint32): int32 {.importc: "nk_group_begin".}
proc beginGroup*(ctx: var context, title: string, flags: uint32): int32 =
group_begin(addr ctx, title, flags)
proc group_scrolled_offset_begin(a2: ptr context; x_offset: ptr uint32;
y_offset: ptr uint32; a5: cstring; a6: uint32): int32 {. importc: "nk_group_scrolled_offset_begin".}
proc beginScrolleOffsetGroup*(ctx: var context, xOffset, yOffset: var uint32, title: string, flags: uint32): int32 =
group_scrolled_offset_begin(addr ctx, addr xOffset, addr yOffset, title, flags)
proc group_scrolled_begin(a2: ptr context; a3: ptr scroll; title: cstring;
a5: uint32): int32 {.importc: "nk_group_scrolled_begin".}
proc beginScrolledGroup*(ctx: var context, s: var scroll, title: string, flags: uint32): int32 =
group_scrolled_begin(addr ctx, addr s, title, flags)
proc group_scrolled_end(a2: ptr context) {.importc: "nk_group_scrolled_end".}
proc endScrolledGroup*(ctx: var context) =
group_scrolled_end(addr ctx)
proc group_end(a2: ptr context) {.importc: "nk_group_end".}
proc groupEnd*(ctx: var context) =
group_end(addr ctx)
proc list_view_begin(a2: ptr context; o: ptr list_view; id: cstring;
a5: uint32; row_height: int32; row_count: int32): int32 {.importc: "nk_list_view_begin".}
proc beginListView*(ctx: var context, listView: var list_view, id: string, flags: uint32, rowHeight, rowCount: int32): int32 =
list_view_begin(addr ctx, addr listView, id, flags, rowHeight, rowCount)
proc list_view_end(a2: ptr list_view) {.importc: "nk_list_view_end".}
proc endListView*(listeView: var list_view) =
list_view_end(addr listeView)
proc tree_push_hashed(a2: ptr context; a3: tree_type; title: cstring;
initial_state: collapse_states; hash: cstring;
len: int32; seed: int32): int32 {.importc: "nk_tree_push_hashed".}
proc treePushHashed*(ctx: var context, treeType: tree_type, title: string, initialState: collapse_states, hash: string, len, seed: int32): int32 =
tree_push_hashed(addr ctx, treeType, title, initialState, hash, len, seed)
proc tree_image_push_hashed(a2: ptr context; a3: tree_type; a4: img;
title: cstring; initial_state: collapse_states;
hash: cstring; len: int32; seed: int32): int32 {.importc: "nk_tree_image_push_hashed".}
proc treeImagePushHashed*(ctx: var context, treeType: tree_type, i: img, title: string, initialState: collapse_states, hash: string, len, seed: int32): int32 =
tree_image_push_hashed(addr ctx, treeType, i, title, initialState, hash, len, seed)
proc tree_pop(a2: ptr context) {.importc: "nk_tree_pop".}
proc popTree*(ctx: var context) =
tree_pop(addr ctx)
proc tree_state_push(a2: ptr context; a3: tree_type; title: cstring;
state: ptr collapse_states): int32 {.importc: "nk_tree_state_push".}
proc treePushState*(ctx: var context, treeType: tree_type, title: string, state: var collapse_states): int32 =
tree_state_push(addr ctx, treeType, title, addr state)
proc tree_state_image_push(a2: ptr context; a3: tree_type; a4: img;
title: cstring; state: ptr collapse_states): int32 {. importc: "nk_tree_state_image_push".}
proc treePushStateImage*(ctx: var context, treeType: tree_type, i: img, title: string, state: var collapse_states): int32 =
tree_state_image_push(addr ctx, treeType, i, title, addr state)
proc tree_state_pop(a2: ptr context) {.importc: "nk_tree_state_pop".}
proc popTreeState*(ctx: var context) =
tree_state_pop(addr ctx)
proc text(a2: ptr context; a3: cstring; a4: int32; a5: uint32) {.importc: "nk_text".}
proc text*(ctx: var context, text: string, len: int32, alignment: uint32) =
text(addr ctx, text, len, alignment)
proc text_colored(a2: ptr context; a3: cstring; a4: int32; a5: uint32;
a6: color) {.importc: "nk_text_colored".}
proc coloredText*(ctx: var context, text: string, len: int32, alignment: uint32, col: color) =
text_colored(addr ctx, text, len, alignment, col)
proc text_wrap(a2: ptr context; a3: cstring; a4: int32) {.importc: "nk_text_wrap".}
proc wrapText*(ctx: var context, text: string, len: int32) =
text_wrap(addr ctx, text, len)
proc text_wrap_colored(a2: ptr context; a3: cstring; a4: int32; a5: color) {. importc: "nk_text_wrap_colored".}
proc wrapColoredText*(ctx: var context, text: string, len: int32, col: color) =
text_wrap_colored(addr ctx, text, len, col)
proc label(a2: ptr context; a3: cstring; align: uint32) {.importc: "nk_label".}
proc label*(ctx: var context, text: string, alignment: uint32) =
label(addr ctx, text, alignment)
proc label_colored(a2: ptr context; a3: cstring; align: uint32; a5: color) {. importc: "nk_label_colored".}
proc coloredLabel*(ctx: var context, label: string, alignment: uint32, col: color) =
label_colored(addr ctx, label, alignment, col)
proc label_wrap(a2: ptr context; a3: cstring) {.importc: "nk_label_wrap".}
proc wrapLabel*(ctx: var context, label: string) =
label_wrap(addr ctx, label)
proc label_colored_wrap(a2: ptr context; a3: cstring; a4: color) {.importc: "nk_label_colored_wrap".}
proc wrapColoredLabel*(ctx: var context, label: string, col: color) =
label_colored_wrap(addr ctx, label, col)
proc image(a2: ptr context; a3: img) {.importc: "nk_image".}
proc image*(ctx: var context, i: img) =
image(addr ctx, i)
proc button_set_behavior(a2: ptr context; a3: button_behavior) {.importc: "nk_button_set_behavior".}
proc setButtonBehavior*(ctx: var context, buttonBehavior: button_behavior) =
button_set_behavior(addr ctx, buttonBehavior)
proc button_push_behavior(a2: ptr context; a3: button_behavior): int32 {. importc: "nk_button_push_behavior".}
proc pushButtonBehavior*(ctx: var context, buttonBehavior: button_behavior): int32 =
button_push_behavior(addr ctx, buttonBehavior)
proc button_pop_behavior(a2: ptr context): int32 {.importc: "nk_button_pop_behavior".}
proc popButtonBehavior*(ctx: var context): int32 =
button_pop_behavior(addr ctx)
proc button_text(a2: ptr context; title: cstring; len: int32): int32 {.importc: "nk_button_text".}
proc textButton*(ctx: var context, text: string, len: int32): int32 =
button_text(addr ctx, text, len)
proc button_label(a2: ptr context; title: cstring): int32 {.importc: "nk_button_label".}
proc buttonLabel*(ctx: var context, label: string): int32 =
button_label(addr ctx, label)
proc button_color(a2: ptr context; a3: color): int32 {.importc: "nk_button_color".}
proc colorButton*(ctx: var context, col: color): int32 =
button_color(addr ctx, col)
proc button_symbol(a2: ptr context; a3: symbol_type): int32 {.importc: "nk_button_symbol".}
proc symbolButton*(ctx: var context, symbolType: symbol_type): int32 =
button_symbol(addr ctx, symbolType)
proc button_image(a2: ptr context; i: img): int32 {.importc: "nk_button_image".}
proc imageButton*(ctx: var context, i: img): int32 =
button_image(addr ctx, i)
proc button_symbol_label(a2: ptr context; a3: symbol_type; a4: cstring;
text_alignment: uint32): int32 {.importc: "nk_button_symbol_label".}
proc symbolLabelButton*(ctx: var context, symbolType: symbol_type, label: string, textAlignment: uint32): int32 =
button_symbol_label(addr ctx, symbolType, label, textAlignment)
proc button_symbol_text(a2: ptr context; a3: symbol_type; a4: cstring;
a5: int32; alignment: uint32): int32 {.importc: "nk_button_symbol_text".}
proc symbolTextButton*(ctx: var context, symbolType: symbol_type, text: string, len: int32, textAlignment: uint32): int32 =
button_symbol_text(addr ctx, symbolType, text, len, text_alignment)
proc button_image_label(a2: ptr context; i: img; a4: cstring;
text_alignment: uint32): int32 {.importc: "nk_button_image_label".}
proc imageLabelButton*(ctx: var context, i: img, label: string, textAlignment: uint32): int32 =
button_image_label(addr ctx, i, label, textAlignment)
proc button_image_text(a2: ptr context; i: img; a4: cstring; a5: int32;
alignment: uint32): int32 {.importc: "nk_button_image_text".}
proc imageTextButton*(ctx: var context, i: img, text: string, len: int32, textAlignment: uint32): int32 =
button_image_text(addr ctx, i, text, len, textAlignment)
proc button_text_styled(a2: ptr context; a3: ptr style_button;
text: cstring; len: int32): int32 {.importc: "nk_button_text_styled".}
proc styledTextButton*(ctx: var context, buttonStyle: var style_button, text: string, len: int32): int32 =
button_text_styled(addr ctx, addr buttonStyle, text, len)
proc button_label_styled(a2: ptr context; a3: ptr style_button;
title: cstring): int32 {.importc: "nk_button_label_styled".}
proc styledLabelButton*(ctx: var context, buttonStyle: var style_button, label: string): int32 =
button_label_styled(addr ctx, addr buttonStyle, label)
proc button_symbol_styled(a2: ptr context; a3: ptr style_button;
a4: symbol_type): int32 {.importc: "nk_button_symbol_styled".}
proc styledSymbolButton*(ctx: var context, buttonStyle: var style_button, symbolType: symbol_type): int32 =
button_symbol_styled(addr ctx, addr buttonStyle, symbolType)
proc button_image_styled(a2: ptr context; a3: ptr style_button; i: img): int32 {. importc: "nk_button_image_styled".}
proc styledImageButton*(ctx: var context, buttonStyle: var style_button, i: img): int32 =
button_image_styled(addr ctx, addr buttonStyle, i)
proc button_symbol_label_styled(a2: ptr context; a3: ptr style_button;
a4: symbol_type; a5: cstring;
text_alignment: uint32): int32 {.importc: "nk_button_symbol_label_styled".}
proc styledSymbolLabelButton*(ctx: var context, buttonStyle: var style_button, symbolType: symbol_type, label: string, textAlignment: uint32) : int32 =
button_symbol_label_styled(addr ctx, addr buttonStyle, symbolType, label, textAlignment)
proc button_symbol_text_styled(a2: ptr context; a3: ptr style_button;
a4: symbol_type; a5: cstring; a6: int32;
alignment: uint32): int32 {.importc: "nk_button_symbol_text_styled".}
proc styledSymbolTextButton*(ctx: var context, buttonStyle: var style_button, symbolType: symbol_type, text: string, len: int32, textAlignment: uint32): int32 =
button_symbol_text_styled(addr ctx, addr buttonStyle, symbolType, text, len, textAlignment)
proc button_image_label_styled(a2: ptr context; a3: ptr style_button;
i: img; a5: cstring;
text_alignment: uint32): int32 {.importc: "nk_button_image_label_styled".}
proc styledImageLabelButton*(ctx: var context, buttonStyle: var style_button, i: img, label: string, textAlignment: uint32): int32 =
button_image_label_styled(addr ctx, addr buttonStyle, i, label, textAlignment)
proc button_image_text_styled(a2: ptr context; a3: ptr style_button;
i: img; a5: cstring; a6: int32;
alignment: uint32): int32 {.importc: "nk_button_image_text_styled".}
proc styledImageTextButton*(ctx: var context, buttonStyle: var style_button, i: img, text: string, len: int32, textAlignment: uint32): int32 =
button_image_text_styled(addr ctx, addr buttonStyle, i, text, len, textAlignment)
proc check_label(a2: ptr context; a3: cstring; active: int32): int32 {.importc: "nk_check_label".}
proc checkLabel*(ctx: var context, label: string, active: bool): int32 =
check_label(addr ctx, label, int32 active)
proc check_text(a2: ptr context; a3: cstring; a4: int32; active: int32): int32 {.importc: "nk_check_text".}
proc checkText*(ctx: var context, text: string, len: int32, active: bool): int32 =
check_text(addr ctx, text, len, int32 active)
proc check_flags_label(a2: ptr context; a3: cstring; flags: uint32; value: uint32): uint32 {. importc: "nk_check_flags_label".}
proc checkLabelFlags*(ctx: var context, label: string, flags, value: uint32): uint32 =
check_flags_label(addr ctx, label, flags, value)
proc check_flags_text(a2: ptr context; a3: cstring; a4: int32; flags: uint32;
value: uint32): uint32 {.importc: "nk_check_flags_text".}
proc checkTextFlags*(ctx: var context, text: string, len: int32, flags, value: uint32): uint32 =
check_flags_text(addr ctx, text, len, flags, value)
proc checkbox_label(a2: ptr context; a3: cstring; active: ptr int32): int32 {.importc: "nk_checkbox_label".}
proc checkboxLabel*(ctx: var context, label: string, active: var bool): int32 =
checkbox_label(addr ctx, label, cast[ptr int32](addr active))
proc checkbox_text(a2: ptr context; a3: cstring; a4: int32; active: ptr int32): int32 {. importc: "nk_checkbox_text".}
proc checkboxText*(ctx: var context, text: string, len: int32, active: var bool): int32 =
checkbox_text(addr ctx, text, len, cast[ptr int32](addr active))
proc checkbox_flags_label(a2: ptr context; a3: cstring; flags: ptr uint32;
value: uint32): int32 {.importc: "nk_checkbox_flags_label".}
proc checkboxLabelFlags*(ctx: var context, label: string, flags: var uint32, value: uint32): int32 =
checkbox_flags_label(addr ctx, label, addr flags, value)
proc checkbox_flags_text(a2: ptr context; a3: cstring; a4: int32;
flags: ptr uint32; value: uint32): int32 {.importc: "nk_checkbox_flags_text".}
proc checkboxFlagsText*(ctx: var context, text: string, len: int32, flags: var uint32, value: uint32): int32 =
checkbox_flags_text(addr ctx, text, len, addr flags, value)
proc radio_label(a2: ptr context; a3: cstring; active: ptr int32): int32 {.importc: "nk_radio_label".}
proc radioLabel*(ctx: var context, label: string, active: var bool): int32 =
radio_label(addr ctx, label, cast[ptr int32](addr active))
proc radio_text(a2: ptr context; a3: cstring; a4: int32; active: ptr int32): int32 {. importc: "nk_radio_text".}
proc radioText*(ctx: var context, text: string, len: int32, active: var bool): int32 =
radio_text(addr ctx, text, len, cast[ptr int32](addr active))
proc option_label(a2: ptr context; a3: cstring; active: int32): int32 {.importc: "nk_option_label".}
proc optionLabel*(ctx: var context, label: string, active: bool): int32 =
option_label(addr ctx, label, int32 active)
proc option_text(a2: ptr context; a3: cstring; a4: int32; active: int32): int32 {. importc: "nk_option_text".}
proc optionText*(ctx: var context, text: string, len: int32, active: bool): int32 =
option_text(addr ctx, text, len, int32 active)
proc selectable_label(a2: ptr context; a3: cstring; align: uint32;
value: ptr int32): int32 {.importc: "nk_selectable_label".}
proc selectableLabel*(ctx: var context, label: string, textAlignment: uint32, value: var int32): int32 =
selectable_label(addr ctx, label, textAlignment, addr value)
proc selectable_text(a2: ptr context; a3: cstring; a4: int32; align: uint32;
value: ptr int32): int32 {.importc: "nk_selectable_text".}
proc seletableText*(ctx: var context, text: string, len: int32, textAlignment: uint32, value: var int32): int32 =
selectable_text(addr ctx, text, len, textAlignment, addr value)
proc selectable_image_label(a2: ptr context; a3: img; a4: cstring;
align: uint32; value: ptr int32): int32 {.importc: "nk_selectable_image_label".}
proc selectableImageLabel*(ctx: var context, i: img, label: string, textAlignment: uint32, value: var int32): int32 =
selectable_image_label(addr ctx, i, label, textAlignment, addr value)
proc selectable_image_text*(a2: ptr context; a3: img; a4: cstring; a5: int32;
align: uint32; value: ptr int32): int32 {.importc: "nk_selectable_image_text".}
proc selectableImageText*(ctx: var context, i: img, text: string, len: int32, textAlignment: uint32, value: var int32): int32 =
selectable_image_text(addr ctx, i, text, len, textAlignment, addr value)
proc select_label(a2: ptr context; a3: cstring; align: uint32; value: int32): int32 {. importc: "nk_select_label".}
proc selectLabel*(ctx: var context, label: string, textAlignment: uint32, value: int32): int32 =
select_label(addr ctx, label, textAlignment, value)
proc select_text(a2: ptr context; a3: cstring; a4: int32; align: uint32;
value: int32): int32 {.importc: "nk_select_text".}
proc selectText*(ctx: var context, text: string, len: int32, textAlignment: uint32, value: int32): int32 =
select_text(addr ctx, text, len, textAlignment, value)
proc select_image_label(a2: ptr context; a3: img; a4: cstring;
align: uint32; value: int32): int32 {.importc: "nk_select_image_label".}
proc selectImageLabel*(ctx: var context, i: img, label: string, textAlignment: uint32, value: int32):int32 =
select_image_label(addr ctx, i, label, textAlignment, value)
proc select_image_text(a2: ptr context; a3: img; a4: cstring; a5: int32;
align: uint32; value: int32): int32 {.importc: "nk_select_image_text".}
proc selectImageText*(ctx: var context, i: img, text: string, len: int32, textAlignment: uint32, value: int32): int32 =
select_image_text(addr ctx, i, text, len, textAlignment, value)
proc slide_float(a2: ptr context; min: float32; val: float32; max: float32;
step: float32): float32 {.importc: "nk_slide_float".}
proc slideFloat*(ctx: var context, min, val, max, step: float32): float32 =
slide_float(addr ctx, min, val, max, step)
proc slide_int(a2: ptr context; min: int32; val: int32; max: int32; step: int32): int32 {. importc: "nk_slide_int".}
proc slideInt*(ctx: var context, min, val, max, step: int32): int32 =
slide_int(addr ctx, min, val, max, step)
proc slider_float(a2: ptr context; min: float32; val: ptr float32; max: float32;
step: float32): int32 {.importc: "nk_slider_float".}
proc sliderFloat*(ctx: var context, min: float32, val: var float32, max, step: float32): int32 =
slider_float(addr ctx, min, addr val, max, step)
proc slider_int(a2: ptr context; min: int32; val: ptr int32; max: int32; step: int32): int32 {. importc: "nk_slider_int".}
proc sliderInt*(ctx: var context, min: int32, val: var int32, max: int32, step: int32): int32 =
slider_int(addr ctx, min, addr val, max, step)
proc progress(a2: ptr context; cur: ptr uint; max: uint; modifyable: int32): int32 {. importc: "nk_progress".}
proc progress*(ctx: var context, cur: var uint, max: uint, modifiable: bool): int32 =
progress(addr ctx, addr cur, max, int32 modifiable)
proc prog(a2: ptr context; cur: uint; max: uint; modifyable: int32): uint {. importc: "nk_prog".}
proc prog*(ctx: var context, cur, max: uint, modifiable: bool): uint =
prog(addr ctx, cur, max, int32 modifiable)
proc color_picker(a2: ptr context; a3: color; a4: color_format): color {. importc: "nk_color_picker".}
proc colorPicker*(ctx: var context, col: color, format: color_format): color =
color_picker(addr ctx, col, format)
proc color_pick(a2: ptr context; a3: ptr color; a4: color_format): int32 {. importc: "nk_color_pick".}
proc pickColor*(ctx: var context, col: var color, format: color_format): int32 =
color_pick(addr ctx, addr col, format)
proc property_int(a2: ptr context; name: cstring; min: int32; val: ptr int32;
max: int32; step: int32; inc_per_pixel: float32) {.importc: "nk_property_int".}
proc propertyInt*(ctx: var context, title: string, min: int32, val: var int32, max, step: int32, incPerPixel: float32) =
property_int(addr ctx, title, min, addr val, max, step, incPerPixel)
proc property_float(a2: ptr context; name: cstring; min: float32; val: ptr float32;
max: float32; step: float32; inc_per_pixel: float32) {.importc: "nk_property_float".}
proc propertyFloat*(ctx: var context, name: string, min: float32, val: var float32, max, step, incPerPixel: float32) =
property_float(addr ctx, name, min, addr val, max, step, incPerPixel)
proc property_double(a2: ptr context; name: cstring; min: cdouble;
val: ptr cdouble; max: cdouble; step: cdouble;
inc_per_pixel: float32) {.importc: "nk_property_double".}
proc propertyDouble*(ctx: var context, name: string, min: float64, val: var float64, max, step: float64, incPerPixel: float32) =
property_double(addr ctx, name, min, addr val, max, step, incPerPixel)
proc propertyi(a2: ptr context; name: cstring; min: int32; val: int32; max: int32;
step: int32; inc_per_pixel: float32): int32 {.importc: "nk_propertyi".}
proc propertyI*(ctx: var context, name: string, min, val, max, step: int32, incPerPixel: float32): int32 =
propertyi(addr ctx, name, min, val, max, step, incPerPixel)
proc propertyf(a2: ptr context; name: cstring; min: float32; val: float32;
max: float32; step: float32; inc_per_pixel: float32): float32 {.importc: "nk_propertyf".}
proc propertyF*(ctx: var context, name: string, min, val, max, step, incPerPixel: float32): float32 =
propertyf(addr ctx, name, min, val, max, step, incPerPixel)
proc propertyd(a2: ptr context; name: cstring; min: cdouble; val: cdouble;
max: cdouble; step: cdouble; inc_per_pixel: float32): cdouble {.importc: "nk_propertyd".}
proc propertyD*(ctx: var context, name: string, min, val, max, step: float64, incPerPixel: float32): float64 =
propertyd(addr ctx, name, min, val, max, step, incPerPixel)
proc edit_focus(a2: ptr context; flags: uint32) {.importc: "nk_edit_focus".}
proc focusEdit*(ctx: var context, flags: uint32) =
edit_focus(addr ctx, flags)
proc edit_unfocus(a2: ptr context) {.importc: "nk_edit_unfocus".}
proc unfocusEdit*(ctx: var context) =
edit_unfocus(addr ctx)
proc edit_string(a2: ptr context; a3: uint32; buffer: cstring; len: ptr int32;
max: int32; a7: plugin_filter): uint32 {.importc: "nk_edit_string".}
proc editString*(ctx: var context, u: uint32, buffer: string, len: var int32, max: int32, f: InputFilter): uint32 =
edit_string(addr ctx, u, buffer, addr len, max, cast[plugin_filter](f))
proc edit_buffer(a2: ptr context; a3: uint32; a4: ptr text_edit;
a5: plugin_filter): uint32 {.importc: "nk_edit_buffer".}
proc editBuffer*(ctx: var context, flags: uint32, textEdit: var text_edit, filter: plugin_filter): uint32 =
edit_buffer(addr ctx, flags, addr textEdit, filter)
proc edit_string_zero_terminated(a2: ptr context; a3: uint32;
buffer: cstring; max: int32; a6: plugin_filter): uint32 {. importc: "nk_edit_string_zero_terminated".}
proc editStringZeroTerminated*(ctx: var context, flags: uint32, buffer: string, max: int32, filter: plugin_filter): uint32 =
edit_string_zero_terminated(addr ctx, flags, buffer, max, filter)
proc chart_begin(a2: ptr context; a3: chart_type; num: int32; min: float32;
max: float32): int32 {.importc: "nk_chart_begin".}
proc chartBegin*(ctx: var context, chartType: chart_type, num: int32, minValue, maxValue: float32): int32 =
chart_begin(addr ctx, chartTYpe, num, minValue, maxValue)
proc chart_begin_colored(a2: ptr context; a3: chart_type; a4: color;
active: color; num: int32; min: float32; max: float32): int32 {. importc: "nk_chart_begin_colored".}
proc chartBeginColored*(ctx: var context, chartType: chart_type, col, active: color, num: int32, minValue, maxValue: float32): int32 =
chart_begin_colored(addr ctx, chartType, col, active, num, minValue, maxValue)
proc chart_add_slot(ctx: ptr context; a3: chart_type; count: int32;
min_value: float32; max_value: float32) {.importc: "nk_chart_add_slot".}
proc chartAddSlot*(ctx: var context, chartType: chart_type, count: int32, minValue, maxValue: float32) =
chart_add_slot(addr ctx, chartType, count, minValue, maxValue)
proc chart_add_slot_colored(ctx: ptr context; a3: chart_type; a4: color;
active: color; count: int32; min_value: float32;
max_value: float32) {.importc: "nk_chart_add_slot_colored".}
proc chartAddSlotColored*(ctx: var context, chartType: chart_type, col, active: color, count: int32, minValue, maxValue: float32) =
chart_add_slot_colored(addr ctx, chartType, col, active, count, minValue, maxValue)
proc chart_push(a2: ptr context; a3: float32): uint32 {.importc: "nk_chart_push".}
proc chartPush*(ctx: var context, value: float32): uint32 =
chart_push(addr ctx, value)
proc chart_push_slot(a2: ptr context; a3: float32; a4: int32): uint32 {.importc: "nk_chart_push_slot".}
proc chartPushSlot*(ctx: var context, value: float32, slot: int32): uint32 =
chart_push_slot(addr ctx, value, slot)
proc chart_end(a2: ptr context) {.importc: "nk_chart_end".}
proc chartEnd*(ctx: var context) =
chart_end(addr ctx)
proc plot(a2: ptr context; a3: chart_type; values: ptr float32; count: int32;
offset: int32) {.importc: "nk_plot".}
proc plot*(ctx: var context, chartType: chart_type, values: var float32, count, offset: int32) =
plot(addr ctx, chartType, addr values, count, offset)
type
value_getter = proc (user: pointer; index: int32): float32 {.cdecl.}
ValueGetter* = proc (user: pointer; index: int32): float32 {.closure, cdecl.}
proc plot_function(a2: ptr context; a3: chart_type; userdata: pointer;
value_getter: value_getter; count: int32;
offset: int32) {.importc: "nk_plot_function".}
proc plotFunction*(ctx: var context, chartType: chart_type, userData: pointer, valueGetter: ValueGetter, count, offset: int32) =
plot_function(addr ctx, chartType, userData, valueGetter, count, offset)
proc popup_begin(a2: ptr context; a3: popup_type; a4: cstring; a5: uint32;
bounds: rect): int32 {.importc: "nk_popup_begin".}
proc beginPopup*(ctx: var context, popupType: popup_type, title: string, flags: uint32, bounds: rect): int32 =
popup_begin(addr ctx, popupType, title, flags, bounds)
proc popup_close(a2: ptr context) {.importc: "nk_popup_close".}
proc closePopup*(ctx: var context) =
popup_close(addr ctx)
proc popup_end(a2: ptr context) {.importc: "nk_popup_end".}
proc endPopup*(ctx: var context) =
popup_end(addr ctx)
proc combo(a2: ptr context; items: cstringArray; count: int32; selected: int32;
item_height: int32; size: vec2): int32 {.importc: "nk_combo".}
proc combo*(ctx: var context, items: cstringArray, count, selected, itemHeight: int32, size: vec2): int32 =
combo(addr ctx, items, count, selected, itemHeight, size)
proc combo_separator(a2: ptr context; items_separated_by_separator: cstring;
separator: int32; selected: int32; count: int32;
item_height: int32; size: vec2): int32 {.importc: "nk_combo_separator".}
proc comboSeparator*(ctx: var context, itemsSeparatedBySeparator: string, separator, selected, count, itemHeight: int32, size: vec2): int32 =
combo_separator(addr ctx, itemsSeparatedBySeparator, separator, selected, count, itemHeight, size)
proc combo_string(a2: ptr context; items_separated_by_zeros: cstring;
selected: int32; count: int32; item_height: int32; size: vec2): int32 {. importc: "nk_combo_string".}
proc comboString*(ctx: var context, itemsSeparatedByZeros: string, selected, count, itenHeight: int32, size: vec2): int32 =
combo_string(addr ctx, itemsSeparatedByZeros, selected, count, itenHeight, size)
type
item_getter = proc (a2: pointer; a3: int32; a4: cstringArray) {.cdecl.}
ItemGetter* = proc (a2: pointer; a3: int32; a4: cstringArray) {.closure, cdecl.}
proc combo_callback(a2: ptr context; item_getter: proc (a2: pointer; a3: int32;
a4: cstringArray) {.cdecl.}; userdata: pointer; selected: int32; count: int32;
item_height: int32; size: vec2): int32 {.importc: "nk_combo_callback".}
proc comboCallback*(ctx: var context, itemGetter: ItemGetter, userData: pointer, selected, count, itemHeight: int32, size: vec2): int32 =
combo_callback(addr ctx, itemGetter, userData, selected, count, itemHeight, size)
proc combobox(a2: ptr context; items: cstringArray; count: int32;
selected: ptr int32; item_height: int32; size: vec2) {.importc: "nk_combobox".}
proc combobox*(ctx: var context, items: cstringArray, count: int32, selected: var int32, itemHeight: int32, size: vec2) =
combobox(addr ctx, items, count, addr selected, itemHeight, size)
proc combobox_string(a2: ptr context; items_separated_by_zeros: cstring;
selected: ptr int32; count: int32; item_height: int32;
size: vec2) {.importc: "nk_combobox_string".}
proc comboboxString*(ctx: var context, itemsSeparatedByZeros: string, selected: var int32, count: int32, itemHeight: int32, size: vec2) =
combobox_string(addr ctx, itemsSeparatedByZeros, addr selected, count, itemHeight, size)
proc combobox_separator(a2: ptr context;
items_separated_by_separator: cstring; separator: int32;
selected: ptr int32; count: int32; item_height: int32;
size: vec2) {.importc: "nk_combobox_separator".}
proc comboboxSeparator*(ctx: var context, itemsSeparatedBySeparator: string, separator: int32, selected: var int32, count: int32, itemHeight: int32, size: vec2) =
combobox_separator(addr ctx, itemsSeparatedBySeparator, separator, addr selected, count, itemHeight, size)
proc combobox_callback(a2: ptr context; item_getter: item_getter; a4: pointer; selected: ptr int32; count: int32;
item_height: int32; size: vec2) {.importc: "nk_combobox_callback".}
proc comboboxCallback*(ctx: var context, itemGetter: ItemGetter, userData: pointer,
outText: var int32, count: int32, itemHeight: int32, size: vec2) =
combobox_callback(addr ctx, itemGetter, userData, addr outText, count, itemHeight, size)
proc combo_begin_text(a2: ptr context; selected: cstring; a4: int32; size: vec2): int32 {. importc: "nk_combo_begin_text".}
proc comboBeginText*(ctx: var context, text: string, len: int32, size: vec2): int32 =
combo_begin_text(addr ctx, text, len, size)
proc combo_begin_label(a2: ptr context; selected: cstring; size: vec2): int32 {. importc: "nk_combo_begin_label".}
proc comboBeginLabel*(ctx: var context, text: string, size: vec2): int32 =
combo_begin_label(addr ctx, text, size)
proc combo_begin_color(a2: ptr context; color: color; size: vec2): int32 {. importc: "nk_combo_begin_color".}
proc comboBeginColor*(ctx: var context, col: color, size: vec2): int32 =
combo_begin_color(addr ctx, col, size)
proc combo_begin_symbol(a2: ptr context; a3: symbol_type; size: vec2): int32 {. importc: "nk_combo_begin_symbol".}
proc comboBeginSymbol*(ctx: var context, symbolType: symbol_type, size: vec2): int32 =
combo_begin_symbol(addr ctx, symbolType, size)
proc combo_begin_symbol_label(a2: ptr context; selected: cstring;
a4: symbol_type; size: vec2): int32 {.importc: "nk_combo_begin_symbol_label".}
proc comboBeginSymbolLabel*(ctx: var context, text: string, symbolType: symbol_type, size: vec2): int32 =
combo_begin_symbol_label(addr ctx, text, symbolType, size)
proc combo_begin_symbol_text(a2: ptr context; selected: cstring; a4: int32;
a5: symbol_type; size: vec2): int32 {.importc: "nk_combo_begin_symbol_text".}
proc comboBeginSymbolText*(ctx: var context, text: string, len: int32, symbolType: symbol_type, size: vec2): int32 =
combo_begin_symbol_text(addr ctx, text, len, symbolType, size)
proc combo_begin_image(a2: ptr context; i: img; size: vec2): int32 {. importc: "nk_combo_begin_image".}
proc comboBeginImage*(ctx: var context, i: img, size: vec2): int32 =
combo_begin_image(addr ctx, i, size)
proc combo_begin_image_label(a2: ptr context; selected: cstring; a4: img;
size: vec2): int32 {.importc: "nk_combo_begin_image_label".}
proc comboBeginImageLabel*(ctx: var context, text: string, i: img, size: vec2): int32 =
combo_begin_image_label(addr ctx, text, i, size)
proc combo_begin_image_text(a2: ptr context; selected: cstring; a4: int32;
a5: img; size: vec2): int32 {.importc: "nk_combo_begin_image_text".}
proc comboBeginImageText*(ctx: var context, text: string, len: int32, i: img, size: vec2): int32 =
combo_begin_image_text(addr ctx, text, len, i, size)
proc combo_item_label(a2: ptr context; a3: cstring; alignment: uint32): int32 {. importc: "nk_combo_item_label".}
proc comboItemLabel*(ctx: var context, text: string, alignment: uint32): int32 =
combo_item_label(addr ctx, text, alignment)
proc combo_item_text(a2: ptr context; a3: cstring; a4: int32; alignment: uint32): int32 {. importc: "nk_combo_item_text".}
proc comboItemText*(ctx: var context, text: string, len: int32, alignment: uint32): int32 =
combo_item_text(addr ctx, text, len, alignment)
proc combo_item_image_label(a2: ptr context; a3: img; a4: cstring;
alignment: uint32): int32 {.importc: "nk_combo_item_image_label".}
proc comboItemImageLabel*(ctx: var context, i: img, text: string, alignment: uint32): int32 =
combo_item_image_label(addr ctx, i, text, alignment)
proc combo_item_image_text(a2: ptr context; a3: img; a4: cstring; a5: int32;
alignment: uint32): int32 {.importc: "nk_combo_item_image_text".}
proc comboItemImageText*(ctx: var context, i: img, text: string, len: int32, alignment: uint32): int32 =
combo_item_image_text(addr ctx, i, text, len, alignment)
proc combo_item_symbol_label(a2: ptr context; a3: symbol_type; a4: cstring;
alignment: uint32): int32 {.importc: "nk_combo_item_symbol_label".}
proc comboItemSymbolLabel*(ctx: var context, symbolType: symbol_type, text: string, alignment: uint32): int32 =
combo_item_symbol_label(addr ctx, symbolType, text, alignment)
proc combo_item_symbol_text(a2: ptr context; a3: symbol_type; a4: cstring;
a5: int32; alignment: uint32): int32 {.importc: "nk_combo_item_symbol_text".}
proc comboItemSymbolText*(ctx: var context, symbolType: symbol_type, text: string, len: int32, alignment: uint32): int32 =
combo_item_symbol_text(addr ctx, symbolType, text, len, alignment)
proc combo_close*(a2: ptr context) {.importc: "nk_combo_close".}
proc comboClose*(ctx: var context) =
combo_close(addr ctx)
proc combo_end(a2: ptr context) {.importc: "nk_combo_end".}
proc comboEnd*(ctx: var context) =
combo_end(addr ctx)
proc contextual_begin(a2: ptr context; a3: uint32; a4: vec2;
trigger_bounds: rect): int32 {.importc: "nk_contextual_begin".}
proc contextualBegin*(ctx: var context, flags: uint32, size: vec2, triggerBounds: rect): int32 =
contextual_begin(addr ctx, flags, size, triggerBounds)
proc contextual_item_text(a2: ptr context; a3: cstring; a4: int32; align: uint32): int32 {. importc: "nk_contextual_item_text".}
proc contextualItemText*(ctx: var context, text: string, len: int32, alignment: uint32): int32 =
contextual_item_text(addr ctx, text, len, alignment)
proc contextual_item_label(a2: ptr context; a3: cstring; align: uint32): int32 {. importc: "nk_contextual_item_label".}
proc contextualItemLabel*(ctx: var context, text: string, alignment: uint32): int32 =
contextual_item_label(addr ctx, text, alignment)
proc contextual_item_image_label(a2: ptr context; a3: img; a4: cstring;
alignment: uint32): int32 {.importc: "nk_contextual_item_image_label".}
proc contextualItemImageLabel*(ctx: var context, i: img, text: string, alignment: uint32): int32 =
contextual_item_image_label(addr ctx, i, text, alignment)
proc contextual_item_image_text(a2: ptr context; a3: img; a4: cstring;
len: int32; alignment: uint32): int32 {.importc: "nk_contextual_item_image_text".}
proc contextualItemImageText*(ctx: var context, i: img, text: string, len: int32, alignment: uint32): int32 =
contextual_item_image_text(addr ctx, i, text, len, alignment)
proc contextual_item_symbol_label(a2: ptr context; a3: symbol_type;
a4: cstring; alignment: uint32): int32 {.importc: "nk_contextual_item_symbol_label".}
proc contextualItemSymbolLabel*(ctx: var context, symbolType: symbol_type, text: string, alignment: uint32): int32 =
contextual_item_symbol_label(addr ctx, symbolType, text, alignment)
proc contextual_item_symbol_text(a2: ptr context; a3: symbol_type;
a4: cstring; a5: int32; alignment: uint32): int32 {. importc: "nk_contextual_item_symbol_text".}
proc contextualItemSymbolText*(ctx: var context, symbolType: symbol_type, text: string, len: int32, alignment: uint32): int32 =
contextual_item_symbol_text(addr ctx, symbolType, text, len, alignment)
proc contextual_close(a2: ptr context) {.importc: "nk_contextual_close".}
proc contextualClose*(ctx: var context) =
contextual_close(addr ctx)
proc contextual_end(a2: ptr context) {.importc: "nk_contextual_end".}
proc contextualEnd*(ctx: var context) =
contextual_end(addr ctx)
proc nk_tooltip(a2: ptr context; a3: cstring) {.importc: "nk_tooltip".}
proc tooltip*(ctx: var context, text: string) =
nk_tooltip(addr ctx, text)
proc tooltip_begin(a2: ptr context; width: float32): int32 {.importc: "nk_tooltip_begin".}
proc openTooltip*(ctx: var context, width: float32): int32 =
tooltip_begin(addr ctx, width)
proc tooltip_end(a2: ptr context) {.importc: "nk_tooltip_end".}
proc closeTooltip*(ctx: var context) =
tooltip_end(addr ctx)
proc menubar_begin(a2: ptr context) {.importc: "nk_menubar_begin".}
proc openMenubar*(ctx: var context) =
menubar_begin(addr ctx)
proc menubar_end(a2: ptr context) {.importc: "nk_menubar_end".}
proc closeMenubar*(ctx: var context) =
menubar_end(addr ctx)
proc menu_begin_text(a2: ptr context; title: cstring; title_len: int32;
align: uint32; size: vec2): int32 {.importc: "nk_menu_begin_text".}
proc beginMenuText*(ctx: var context, text: string, len: int32, alignment: uint32, size: vec2): int32 =
menu_begin_text(addr ctx, text, len, alignment, size)
proc menu_begin_label(a2: ptr context; a3: cstring; align: uint32; size: vec2): int32 {.importc: "nk_menu_begin_label".}
proc beginMenuLabel*(ctx: var context, text: string, alignment: uint32, size: vec2): int32 =
menu_begin_label(addr ctx, text, alignment, size)
proc menu_begin_image(a2: ptr context; a3: cstring; a4: img; size: vec2): int32 {. importc: "nk_menu_begin_image".}
proc beginMenuImage*(ctx: var context, text: string, i: img, size: vec2): int32 =
menu_begin_image(addr ctx, text, i, size)
proc menu_begin_image_text(a2: ptr context; a3: cstring; a4: int32;
align: uint32; a6: img; size: vec2): int32 {. importc: "nk_menu_begin_image_text".}
proc beginMenuImageText*(ctx: var context, text: string, len: int32, alignment: uint32, i: img, size: vec2): int32 =
menu_begin_image_text(addr ctx, text, len, alignment, i, size)
proc menu_begin_image_label(a2: ptr context; a3: cstring; align: uint32;
a5: img; size: vec2): int32 {.importc: "nk_menu_begin_image_label".}
proc beginMenuImageLabel*(ctx: var context, text: string, alignment: uint32, i: img, size: vec2): int32 =
menu_begin_image_label(addr ctx, text, alignment, i, size)
proc menu_begin_symbol*(a2: ptr context; a3: cstring; a4: symbol_type;
size: vec2): int32 {.importc: "nk_menu_begin_symbol".}
proc beginMenuSymbol*(ctx: var context, text: string, symbolType: symbol_type, size: vec2): int32 =
menu_begin_symbol(addr ctx, text, symbolType, size)
proc menu_begin_symbol_text(a2: ptr context; a3: cstring; a4: int32;
align: uint32; a6: symbol_type; size: vec2): int32 {. importc: "nk_menu_begin_symbol_text".}
proc beginMenuSymbolText*(ctx: var context, text: string, len: int32, alignment: uint32, symbolType: symbol_type, size: vec2): int32 =
menu_begin_symbol_text(addr ctx, text, len, alignment, symbolType, size)
proc menu_begin_symbol_label(a2: ptr context; a3: cstring; align: uint32;
a5: symbol_type; size: vec2): int32 {.importc: "nk_menu_begin_symbol_label".}
proc beginMenuSymbolLabel*(ctx: var context, text: string, alignment: uint32, symbolType: symbol_type, size: vec2): int32 =
menu_begin_symbol_label(addr ctx, text, alignment, symbolType, size)
proc menu_item_text(a2: ptr context; a3: cstring; a4: int32; align: uint32): int32 {. importc: "nk_menu_item_text".}
proc menuItemText*(ctx: var context, text: string, len: int32, alignment: uint32): int32 =
menuItemText(addr ctx, text, len, alignment)
proc menu_item_label(a2: ptr context; a3: cstring; alignment: uint32): int32 {. importc: "nk_menu_item_label".}
proc menuItemLabel*(ctx: var context, text: string, alignment: uint32): int32 =
menu_item_label(addr ctx, text, alignment)
proc menu_item_image_label(a2: ptr context; a3: img; a4: cstring;
alignment: uint32): int32 {.importc: "nk_menu_item_image_label".}
proc menuItemImageLabel*(ctx: var context, i: img, text: string, alignment: uint32): int32 =
menu_item_image_label(addr ctx, i, text, alignment)
proc menu_item_image_text(a2: ptr context; a3: img; a4: cstring; len: int32;
alignment: uint32): int32 {.importc: "nk_menu_item_image_text".}
proc menuItemImageText*(ctx: var context, i: img, text: string, len: int32, alignment: uint32): int32 =
menu_item_image_text(addr ctx, i, text, len, alignment)
proc menu_item_symbol_text(a2: ptr context; a3: symbol_type; a4: cstring;
a5: int32; alignment: uint32): int32 {.importc: "nk_menu_item_symbol_text".}
proc menuItemSymbolText*(ctx: var context, symbolType: symbol_type, text: string, len: int32, alignment: uint32): int32 =
menu_item_symbol_text(addr ctx, symbolType, text, len, alignment)
proc menu_item_symbol_label(a2: ptr context; a3: symbol_type; a4: cstring;
alignment: uint32): int32 {.importc: "nk_menu_item_symbol_label".}
proc menuItemSymbolLabel*(ctx: var context, symbolType: symbol_type, lbl: string, alignment: uint32): int32 =
menu_item_symbol_label(addr ctx, symbolType, lbl, alignment)
proc menu_close(a2: ptr context) {.importc: "nk_menu_close".}
proc closeMenu*(ctx: var context) =
menu_close(addr ctx)
proc menu_end(a2: ptr context) {.importc: "nk_menu_end".}
proc endMenu*(ctx: var context) =
menu_end(addr ctx)
proc convert(a2: ptr context; cmds: ptr buffer; vertices: ptr buffer;
elements: ptr buffer; a6: ptr convert_config) {.importc: "nk_convert".}
proc convertDrawCommands*(ctx: var context, cmds, vertices, elements: var buffer, convertConfig: var convert_config) =
convert(addr ctx, addr cmds, addr vertices, addr elements, addr convertConfig)
proc draw_begin(a2: ptr context; a3: ptr buffer): ptr draw_command {.importc: "nk__draw_begin".}
proc firstDrawCommand*(ctx: var context, buf: var buffer): ptr draw_command =
draw_begin(addr ctx, addr buf)
proc draw_end(a2: ptr context; a3: ptr buffer): ptr draw_command {.importc: "nk__draw_end".}
proc lastDrawCommand*(ctx: var context, buf: var buffer): ptr draw_command =
draw_end(addr ctx, addr buf)
proc draw_next(a2: ptr draw_command; a3: ptr buffer; a4: ptr context): ptr draw_command {. importc: "nk__draw_next".}
proc nextDrawCommand*(cmd: ptr draw_command, buf: var buffer, ctx: var context): ptr draw_command =
draw_next(cmd, addr buf, addr ctx)
proc input_begin*(a2: ptr context) {.importc: "nk_input_begin".}
proc openInput*(ctx: var context) =
input_begin(addr ctx)
proc input_motion(a2: ptr context; x: int32; y: int32) {.importc: "nk_input_motion".}
proc inputMotion*(ctx: var context, x, y: int32) =
input_motion(addr ctx, x, y)
proc input_key(a2: ptr context; a3: keys; down: int32) {.importc: "nk_input_key".}
proc inputKey*(ctx: var context, key: keys, down: int32) =
input_key(addr ctx, key, down)
proc input_button(a2: ptr context; a3: buttons; x: int32; y: int32; down: int32) {. importc: "nk_input_button".}
proc inputButton*(ctx: var context, button: buttons, x, y, down: int32) =
input_button(addr ctx, button, x, y, down)
proc input_scroll(a2: ptr context; y: float32) {.importc: "nk_input_scroll".}
proc inputScroll*(ctx: var context, y: float32) =
input_scroll(addr ctx, y)
proc input_char(a2: ptr context; a3: char) {.importc: "nk_input_char".}
proc inputChar*(ctx: var context, c: char) =
input_char(addr ctx, c)
proc input_glyph(a2: ptr context; a3: glyph) {.importc: "nk_input_glyph".}
proc inputGlyph*(ctx: var context, g: glyph) =
input_glyph(addr ctx, g)
proc input_unicode(a2: ptr context; a3: uint32) {.importc: "nk_input_unicode".}
proc inputUnicode*(ctx: var context, u: uint32) =
input_unicode(addr ctx, u)
proc input_end(a2: ptr context) {.importc: "nk_input_end".}
proc closeInput*(ctx: var context) =
input_end(addr ctx)
proc style_default(a2: ptr context) {.importc: "nk_style_default".}
proc defaultStyle*(ctx: var context) =
style_default(addr ctx)
proc style_from_table(a2: ptr context; a3: ptr color) {.importc: "nk_style_from_table".}
proc newStyleFromTable*(ctx: var context, colors: var color) =
style_from_table(addr ctx, addr colors)
proc style_load_cursor(a2: ptr context; a3: style_cursor; a4: ptr cursor) {. importc: "nk_style_load_cursor".}
proc loadCursor*(ctx: var context, cursor: style_cursor, cursors: var cursor) =
style_load_cursor(addr ctx, cursor, addr cursors)
proc style_load_all_cursors(a2: ptr context; a3: ptr cursor) {.importc: "nk_style_load_all_cursors".}
proc loadAllCursors*(ctx: var context, cursors: var cursor) =
style_load_all_cursors(addr ctx, addr cursors)
proc style_get_color_by_name(a2: style_colors): cstring {.importc: "nk_style_get_color_by_name".}
proc getColorByName*(sc: style_colors): string =
$style_get_color_by_name(sc)
proc style_set_font(a2: ptr context; a3: ptr user_font) {.importc: "nk_style_set_font".}
proc setFont*(ctx: var context, f: var user_font) =
style_set_font(addr ctx, addr f)
proc style_set_cursor(a2: ptr context; a3: style_cursor): int32 {.importc: "nk_style_set_cursor".}
proc setCursor*(ctx: var context, cursor: style_cursor): int32 =
style_set_cursor(addr ctx, cursor)
proc style_show_cursor*(a2: ptr context) {.importc: "nk_style_show_cursor".}
proc showCursor*(ctx: var context) =
style_show_cursor(addr ctx)
proc style_hide_cursor(a2: ptr context) {.importc: "nk_style_hide_cursor".}
proc hideCursor*(ctx: var context) =
style_hide_cursor(addr ctx)
proc style_push_font(a2: ptr context; a3: ptr user_font): int32 {.importc: "nk_style_push_font".}
proc pushFont*(ctx: var context, f: var user_font): int32 =
style_push_font(addr ctx, addr f)
proc style_push_float(a2: ptr context; a3: ptr float32; a4: float32): int32 {.importc: "nk_style_push_float".}
proc pushFloat*(ctx: var context, floats: var float32, f: float32): int32 =
style_push_float(addr ctx, addr floats, f)
proc style_push_vec2(a2: ptr context; a3: ptr vec2; a4: vec2): int32 {.importc: "nk_style_push_vec2".}
proc pushVec2*(ctx: var context, vecs: var vec2, v: vec2): int32 =
style_push_vec2(addr ctx, addr vecs, v)
proc style_push_style_item(a2: ptr context; a3: ptr style_item;
a4: style_item): int32 {.importc: "nk_style_push_style_item".}
proc pushStyleItem*(ctx: var context, items: var style_item, item: style_item): int32 =
style_push_style_item(addr ctx, addr items, item)
proc style_push_flags(a2: ptr context; a3: ptr uint32; a4: uint32): int32 {. importc: "nk_style_push_flags".}
proc pushFlags*(ctx: var context, flags: var uint32, f: uint32): int32 =
style_push_flags(addr ctx, addr flags, f)
proc style_push_color(a2: ptr context; a3: ptr color; a4: color): int32 {. importc: "nk_style_push_color".}
proc pushColor*(ctx: var context, cols: var color, col: color): int32 =
style_push_color(addr ctx, addr cols, col)
proc style_pop_font*(a2: ptr context): int32 {.importc: "nk_style_pop_font".}
proc popFont*(ctx: var context): int32 =
style_pop_font(addr ctx)
proc style_pop_float*(a2: ptr context): int32 {.importc: "nk_style_pop_float".}
proc popFloat*(ctx: var context): int32 =
style_pop_float(addr ctx)
proc style_pop_vec2(a2: ptr context): int32 {.importc: "nk_style_pop_vec2".}
proc popVec2*(ctx: var context): int32 =
style_pop_vec2(addr ctx)
proc style_pop_style_item(a2: ptr context): int32 {.importc: "nk_style_pop_style_item".}
proc popStyleItem*(ctx: var context): int32 =
style_pop_style_item(addr ctx)
proc style_pop_flags*(a2: ptr context): int32 {.importc: "nk_style_pop_flags".}
proc popFlags*(ctx: var context): int32 =
style_pop_flags(addr ctx)
proc style_pop_color(a2: ptr context): int32 {.importc: "nk_style_pop_color".}
proc popColor*(ctx: var context): int32 =
style_pop_color(addr ctx)
proc widget_bounds(a2: ptr context): rect {.importc: "nk_widget_bounds".}
proc bounds*(ctx: var context): rect =
widget_bounds(addr ctx)
proc widget_position(a2: ptr context): vec2 {.importc: "nk_widget_position".}
proc position*(ctx: var context): vec2 =
widget_position(addr ctx)
proc widget_size(a2: ptr context): vec2 {.importc: "nk_widget_size".}
proc size*(ctx: var context): vec2 =
widget_size(addr ctx)
proc widget_width(a2: ptr context): float32 {.importc: "nk_widget_width".}
proc width*(ctx: var context): float32 =
widget_width(addr ctx)
proc widget_height(a2: ptr context): float32 {.importc: "nk_widget_height".}
proc height*(ctx: var context): float32 =
widget_height(addr ctx)
proc widget_is_hovered(a2: ptr context): int32 {.importc: "nk_widget_is_hovered".}
proc isHovered*(ctx: var context): bool =
bool widget_is_hovered(addr ctx)
proc widget_is_mouse_clicked(a2: ptr context; a3: buttons): int32 {.importc: "nk_widget_is_mouse_clicked".}
proc isMouseClicked*(ctx: var context, button: buttons): bool =
bool widget_is_mouse_clicked(addr ctx, button)
proc widget_has_mouse_click_down(a2: ptr context; a3: buttons; down: int32): int32 {. importc: "nk_widget_has_mouse_click_down".}
proc hasMouseClickDown*(ctx: var context, button: buttons, down: int32): bool =
bool widget_has_mouse_click_down(addr ctx, button, down)
proc spacing(a2: ptr context; cols: int32) {.importc: "nk_spacing".}
proc spacing*(ctx: var context, cols: int32) =
spacing(addr ctx, cols)
proc widget(a2: ptr rect; a3: ptr context): widget_layout_states {.importc: "nk_widget".}
proc widget*(bounds: var rect, ctx: var context): widget_layout_states =
widget(addr bounds, addr ctx)
proc widget_fitting(a2: ptr rect; a3: ptr context; a4: vec2): widget_layout_states {. importc: "nk_widget_fitting".}
proc widgetFitting*(bounds: var rect, ctx: var context, itemPadding: vec2): widget_layout_states =
widget_fitting(addr bounds, addr ctx, itemPadding)
proc rgb(r: int32; g: int32; b: int32): color {.importc: "nk_rgb".}
proc newColorRGB*(r,g,b: int32): color =
rgb(r, g, b)
proc rgb_iv*(rgb: ptr int32): color {.importc: "nk_rgb_iv".}
proc newColorRGB*(rgb: var int32): color =
rgb_iv(addr rgb)
proc rgb_bv(rgb: ptr char): color {.importc: "nk_rgb_bv".}
proc newColorRGB*(rgb: var char): color =
rgb_bv(addr rgb)
proc rgb_f(r: float32; g: float32; b: float32): color {.importc: "nk_rgb_f".}
proc newColorRGB*(r,g,b: float32): color =
rgb_f(r, g, b)
proc rgb_fv(rgb: ptr float32): color {.importc: "nk_rgb_fv".}
proc newColorRGB*(rgb: var float32): color =
rgb_fv(addr rgb)
proc rgb_hex(rgb: cstring): color {.importc: "nk_rgb_hex".}
proc newColorRGB*(rgb: string): color =
rgb_hex(rgb)
proc rgba(r: int32; g: int32; b: int32; a: int32): color {.importc: "nk_rgba".}
proc newColorRGBA*(r,g,b,a: int32): color =
rgba(r,g,b,a)
proc rgba_u32(a2: uint32): color {.importc: "nk_rgba_u32".}
proc newColorRGBA*(rgba: uint32): color =
rgba_u32(rgba)
proc rgba_iv*(rgba: ptr int32): color {.importc: "nk_rgba_iv".}
proc newColorRGBA*(rgba: var int32): color =
rgba_iv(addr rgba)
proc rgba_bv(rgba: ptr char): color {.importc: "nk_rgba_bv".}
proc newColorRGBA*(rgba: var char): color =
rgba_bv(addr rgba)
proc rgba_f(r: float32; g: float32; b: float32; a: float32): color {.importc: "nk_rgba_f".}
proc newColorRGBA*(r, g, b, a: float32): color =
rgba_f(r, g, b, a)
proc rgba_fv(rgba: ptr float32): color {.importc: "nk_rgba_fv".}
proc newColorRGBA*(rgba: var float32): color =
rgba_fv(addr rgba)
proc nk_rgba_hex(rgba: cstring): color {.importc: "nk_rgba_hex".}
proc newColorRGBA*(rgba: string): color =
nk_rgba_hex(rgba)
proc hsv(h: int32; s: int32; v: int32): color {.importc: "nk_hsv".}
proc newColorHSV*(h, s, v: int32): color =
hsv(h, s, v)
proc hsv_iv(hsv: ptr int32): color {.importc: "nk_hsv_iv".}
proc newColorHSV*(hsv: var int32): color =
hsv_iv(addr hsv)
proc hsv_bv(hsv: ptr char): color {.importc: "nk_hsv_bv".}
proc newColorHSV*(hsv: var char): color =
hsv_bv(addr hsv)
proc hsv_f(h: float32; s: float32; v: float32): color {.importc: "nk_hsv_f".}
proc newColorHSV*(h, s, v: float32): color =
hsv_f(h, s, v)
proc hsv_fv(hsv: ptr float32): color {.importc: "nk_hsv_fv".}
proc newColorHSV*(hsv: var float32): color =
hsv_fv(addr hsv)
proc hsva(h: int32; s: int32; v: int32; a: int32): color {.importc: "nk_hsva".}
proc newColorHSVA*(h, s, v, a: int32) : color =
hsva(h, s, v, a)
proc hsva_iv(hsva: ptr int32): color {.importc: "nk_hsva_iv".}
proc newColorHSVA*(hsva: var int32): color =
hsva_iv(addr hsva)
proc nk_hsva_bv(hsva: ptr char): color {.importc: "nk_hsva_bv".}
proc newColorHSVA*(hsva: var char): color =
nk_hsva_bv(addr hsva)
proc nk_hsva_f(h: float32; s: float32; v: float32; a: float32): color {.importc: "nk_hsva_f".}
proc newColorHSVA*(h, s, v, a: float32): color =
nk_hsva_f(h, s, v, a)
proc nk_hsva_fv(hsva: ptr float32): color {.importc: "nk_hsva_fv".}
proc newColorHSVA*(hsva: var float32): color =
nk_hsva_fv(addr hsva)
proc nk_color_f(r: ptr float32; g: ptr float32; b: ptr float32; a: ptr float32; a6: color) {. importc: "nk_color_f".}
proc f*(col: color, r, g, b, a: var float32) =
nk_color_f(addr r, addr g, addr b, addr a, col)
proc color_fv(rgba_out: ptr float32; a3: color) {.importc: "nk_color_fv".}
proc fv*(col: color, rgbaOut: var float32) =
colorfv(addr rgbaOut, col)
proc color_d(r: ptr float64; g: ptr float64; b: ptr float64; a: ptr float64; a6: color) {. importc: "nk_color_d".}
proc d*(col: color, r, g, b, a: var float64) =
color_d(addr r, addr g, addr b, addr a, col)
proc color_dv(rgba_out: ptr float64; a3: color) {.importc: "nk_color_dv".}
proc dv*(col: color, rgbaOut: var float64) =
color_dv(addr rgbaOut, col)
proc color_u32(a2: color): uint32 {.importc: "nk_color_u32".}
proc u32*(col: color): uint32 =
color_u32(col)
proc color_hex_rgba(output: cstring; a3: color) {.importc: "nk_color_hex_rgba".}
proc hexRGBA*(col: color, output: string) =
color_hex_rgba(output, col)
proc color_hex_rgb(output: cstring; a3: color) {.importc: "nk_color_hex_rgb".}
proc hexRGB*(col: color, output: string) =
color_hex_rgb(output, col)
proc color_hsv_i(out_h: ptr int32; out_s: ptr int32; out_v: ptr int32; a5: color) {. importc: "nk_color_hsv_i".}
proc hsvI*(col: color, h, s, v: var int32) =
color_hsv_i(addr h, addr s, addr v, col)
proc color_hsv_b(out_h: ptr char; out_s: ptr char; out_v: ptr char;
a5: color) {.importc: "nk_color_hsv_b".}
proc hsvB*(col: color, h, s, v: var char) =
color_hsv_b(addr h, addr s, addr v, col)
proc color_hsv_iv(hsv_out: ptr int32; a3: color) {.importc: "nk_color_hsv_iv".}
proc hsvIv*(col: color, hsvOut: var int32) =
color_hsv_iv(addr hsvOut, col)
proc color_hsv_bv(hsv_out: ptr char; a3: color) {.importc: "nk_color_hsv_bv".}
proc hsvBv*(col: color, hsvOut: var char) =
color_hsv_bv(addr hsvOut, col)
proc color_hsv_f(out_h: ptr float32; out_s: ptr float32; out_v: ptr float32; a5: color) {. importc: "nk_color_hsv_f".}
proc hsvF*(col: color, h, s, v, a: var float32) =
color_hsv_f(addr h, addr s, addr v, col)
proc color_hsv_fv(hsv_out: ptr float32; a3: color) {.importc: "nk_color_hsv_fv".}
proc hsvFv*(col: color, hsvOut: var float32) =
color_hsv_fv(addr hsvOut, col)
proc color_hsva_i(h: ptr int32; s: ptr int32; v: ptr int32; a: ptr int32; a6: color) {. importc: "nk_color_hsva_i".}
proc hsvaI*(col: color, h, s, v, a: var int32) =
color_hsva_i(addr h, addr s, addr v, addr a, col)
proc color_hsva_b(h: ptr char; s: ptr char; v: ptr char; a: ptr char;
a6: color) {.importc: "nk_color_hsva_b".}
proc hsvaB*(col: color, h, s, v, a: var char) =
color_hsva_b(addr h, addr s, addr v, addr a, col)
proc color_hsva_iv(hsva_out: ptr int32; a3: color) {.importc: "nk_color_hsva_iv".}
proc hsvaIv*(col: color, hsvaOut: var int32) =
color_hsva_iv(addr hsvaOut, col)
proc color_hsva_bv(hsva_out: ptr char; a3: color) {.importc: "nk_color_hsva_bv".}
proc hsvaBv*(col: color, hsvaOut: var char) =
color_hsva_bv(addr hsvaOut, col)
proc color_hsva_f(out_h: ptr float32; out_s: ptr float32; out_v: ptr float32;
out_a: ptr float32; a6: color) {.importc: "nk_color_hsva_f".}
proc hsvaF*(col: color, h, s, v, a: var float32) =
color_hsva_f(addr h, addr s, addr v, addr a, col)
proc color_hsva_fv*(hsva_out: ptr float32; a3: color) {.importc: "nk_color_hsva_fv".}
proc hsvaFv*(col: color, hsvaOut: var float32) =
color_hsva_fv(addr hsvaOut, col)
proc nk_handle_ptr(a2: pointer): handle {.importc: "nk_handle_ptr".}
proc handlePtr*(p: pointer): handle =
nk_handle_ptr(p)
proc nk_handle_id(a2: int32): handle {.importc: "nk_handle_id".}
proc handleId*(id: int32): handle =
nk_handle_id(id)
proc nk_image_handle(a2: handle): img {.importc: "nk_image_handle".}
proc imageHandle*(hnd: handle): img =
nk_image_handle(hnd)
proc nk_image_ptr(a2: pointer): img {.importc: "nk_image_ptr".}
proc imagePtr*(p: pointer): img =
nk_image_ptr(p)
proc nk_image_id(a2: int32): img {.importc: "nk_image_id".}
proc imageId*(id: int32): img =
nk_image_id(id)
proc image_is_subimage*(i: ptr img): int32 {.importc: "nk_image_is_subimage".}
proc imageIsSubImage*(i: var img): bool =
bool image_is_subimage(addr i)
proc nk_subimage_ptr(a2: pointer; w: uint16; h: uint16; sub_region: rect): img {. importc: "nk_subimage_ptr".}
proc subimagePtr*(p: pointer, w, h: uint16, subRegion: rect) : img =
nk_subimage_ptr(p, w, h, subRegion)
proc nk_subimage_id(a2: int32; w: uint16; h: uint16; sub_region: rect): img {. importc: "nk_subimage_id".}
proc subImageId*(id: int32, w, h: uint16, subRegion: rect): img =
nk_subimage_id(id, w, h, subRegion)
proc nk_subimage_handle*(a2: handle; w: uint16; h: uint16; sub_region: rect): img {. importc: "nk_subimage_handle".}
proc subImageHandle*(hnd: handle, w, h: uint16, subRegion: rect): img =
nk_subimage_handle(hnd, w, h, subRegion)
proc nk_murmur_hash(key: pointer; len: int32; seed: uint32): uint32 {.importc: "nk_murmur_hash".}
proc murmurHash*(key: pointer, len: int32, seed: uint32): uint32 =
nk_murmur_hash(key, len, seed)
proc triangle_from_direction(result: ptr vec2; r: rect; pad_x: float32;
pad_y: float32; a6: heading) {.importc: "nk_triangle_from_direction".}
proc triangleFromDirection*(result: var vec2, r: rect, padX, padY: float32, h: heading) =
triangle_from_direction(addr result, r, padX, padY, h)
proc newVec2*(x, y: float32): vec2 {.importc: "nk_vec2".}
proc newVec2i*(x, y: int32): vec2 {.importc: "nk_vec2i".}
proc vec2v(xy: ptr float32): vec2 {.importc: "nk_vec2v".}
proc newVec2v*(xy: var float32): vec2 =
vec2v(addr xy)
proc vec2iv(xy: ptr int32): vec2 {.importc: "nk_vec2iv".}
proc newVec2iv*(xy: var int32): vec2 =
vec2iv(addr xy)
proc get_null_rect(): rect {.importc: "nk_get_null_rect".}
proc nullRect*(): rect =
get_null_rect()
proc newRect*(x, y, w, h: float32): rect {.importc: "nk_rect".}
proc newRecti*(x, y, w, h: int32): rect {.importc: "nk_recti".}
proc recta(pos: vec2; size: vec2): rect {.importc: "nk_recta".}
proc a*(pos, size: vec2): rect =
recta(pos, size)
proc rectv(xywh: ptr float32): rect {.importc: "nk_rectv".}
proc v*(xywh: var float32): rect =
rectv(addr xywh)
proc rectiv(xywh: ptr int32): rect {.importc: "nk_rectiv".}
proc iv*(xywh: var int32): rect =
rectiv(addr xywh)
proc rect_pos(a2: rect): vec2 {.importc: "nk_rect_pos".}
proc pos*(r: rect): vec2 =
rect_pos(r)
proc rect_size(a2: rect): vec2 {.importc: "nk_rect_size".}
proc size*(r: rect): vec2 =
rect_size(r)
proc nk_strlen(str: cstring): int32 {.importc: "nk_strlen".}
proc strLen*(str: string): int32 =
nk_strlen(str)
proc stricmp(s1: cstring; s2: cstring): int32 {.importc: "nk_stricmp".}
proc icmp*(s1, s2: string): int32 =
stricmp(s1, s2)
proc stricmpn(s1: cstring; s2: cstring; n: int32): int32 {.importc: "nk_stricmpn".}
proc icmpn*(s1, s2: string, n: int32): int32 =
stricmpn(s1, s2, n)
proc strtoi(str: cstring; endptr: cstringArray): int32 {.importc: "nk_strtoi".}
proc toi*(str: string, endptr: cstringArray): int32 =
strtoi(str, endptr)
proc strtof(str: cstring; endptr: cstringArray): float32 {.importc: "nk_strtof".}
proc tof*(str: string, endptr: cstringArray): float32 =
strtof(str, endptr)
proc strtod(str: cstring; endptr: cstringArray): float64 {.importc: "nk_strtod".}
proc tod*(str: string, endptr: cstringArray): float64 =
strtod(str, endptr)
proc strfilter(text: cstring; regexp: cstring): int32 {.importc: "nk_strfilter".}
proc filterString*(text: string, regexp: string): int32 =
strfilter(text, regexp)
proc strmatch_fuzzy_string(str: cstring; pattern: cstring; out_score: ptr int32): int32 {. importc: "nk_strmatch_fuzzy_string".}
proc matchFuzzyString*(str: string, pattern: string, outScore: var int32): int32 =
strmatch_fuzzy_string(str, pattern, addr outScore)
proc strmatch_fuzzy_text(txt: cstring; txt_len: int32; pattern: cstring;
out_score: ptr int32): int32 {.importc: "nk_strmatch_fuzzy_text".}
proc matchFuzzyTest*(text: string, textLen: int32, pattern: string, outScore: var int32): int32 =
strmatch_fuzzy_text(text, textLen, pattern, addr outScore)
proc utf_decode(a2: cstring; a3: ptr uint32; a4: int32): int32 {.importc: "nk_utf_decode".}
proc decodeUTF*(c: string, u: var uint32, clen: int32): int32 =
utf_decode(c, addr u, clen)
proc utf_encode(a2: uint32; a3: cstring; a4: int32): int32 {.importc: "nk_utf_encode".}
proc encodeUTF*(u: uint32, c: string, clen: int32): int32 =
utf_encode(u, c, clen)
proc utf_len(a2: cstring; byte_len: int32): int32 {.importc: "nk_utf_len".}
proc lenUTF*(s: string, byteLen: int32): int32 =
utf_len(s, byteLen)
proc utf_at(buffer: cstring; length: int32; index: int32; unicode: ptr uint32;
len: ptr int32): cstring {.importc: "nk_utf_at".}
proc atUTF*(buffer: string, length, index: int32, unicode: var uint32, len: var int32): string =
$utf_at(buffer, length, index, addr unicode, addr len)
type
baked_font* = object
height*: float32
ascent*: float32
descent*: float32
glyph_offset*: uint32
glyph_count*: uint32
ranges*: ptr uint32
font_config* = object
next*: ptr font_config
ttf_blob*: pointer
ttf_size*: uint
ttf_data_owned_by_atlas*: cuchar
merge_mode*: cuchar
pixel_snap*: cuchar
oversample_v*: cuchar
oversample_h*: cuchar
padding*: array[3, cuchar]
size*: float32
coord_type*: font_coord_type
spacing*: vec2
range*: ptr uint32
font*: ptr baked_font
fallback_glyph*: uint32
font_glyph* = object
codepoint*: uint32
xadvance*: float32
x0*: float32
y0*: float32
x1*: float32
y1*: float32
w*: float32
h*: float32
u0*: float32
v0*: float32
u1*: float32
v1*: float32
font* = object
next*: ptr font
handle*: user_font
info*: baked_font
scale*: float32
glyphs*: ptr font_glyph
fallback*: ptr font_glyph
fallback_codepoint*: uint32
texture*: handle
config*: ptr font_config
font_atlas_format* {.size: sizeof(int32).} = enum
FONT_ATLAS_ALPHA8, FONT_ATLAS_RGBA32
type
font_atlas* = object
pixel*: pointer
tex_width*: int32
tex_height*: int32
permanent*: allocator
temporary*: allocator
custom*: recti
cursors*: array[CURSOR_COUNT, cursor]
glyph_count*: int32
glyphs*: ptr font_glyph
default_font*: ptr font
fonts*: ptr font
config*: ptr font_config
font_num*: int32
proc font_default_glyph_ranges*(): ptr uint32 {.importc: "nk_font_default_glyph_ranges".}
proc glyphRange*(): var uint32 =
font_default_glyph_ranges()[]
proc font_chinese_glyph_ranges*(): ptr uint32 {.importc: "nk_font_chinese_glyph_ranges".}
proc chineseGlyphRanges*(): var uint32 =
font_chinese_glyph_ranges()[]
proc font_cyrillic_glyph_ranges*(): ptr uint32 {.importc: "nk_font_cyrillic_glyph_ranges".}
proc cyrillicGlyphRanges*(): var uint32 =
font_cyrillic_glyph_ranges()[]
proc font_korean_glyph_ranges(): ptr uint32 {.importc: "nk_font_korean_glyph_ranges".}
proc koreanGyphRanges*(): var uint32 =
font_korean_glyph_ranges()[]
proc font_atlas_init_default(a2: ptr font_atlas) {.importc: "nk_font_atlas_init_default".}
proc init*(atlas: var font_atlas) =
font_atlas_init_default(addr atlas)
proc font_atlas_init*(a2: ptr font_atlas; a3: ptr allocator) {.importc: "nk_font_atlas_init".}
proc init*(atlas: var font_atlas, alloc: var allocator) =
font_atlas_init(addr atlas, addr alloc)
proc font_atlas_init_custom(a2: ptr font_atlas; persistent: ptr allocator;
transient: ptr allocator) {.importc: "nk_font_atlas_init_custom".}
proc initCustom*(atlas: var font_atlas, persistent, transient: var allocator) =
font_atlas_init_custom(addr atlas, addr persistent, addr transient)
proc font_atlas_begin(a2: ptr font_atlas) {.importc: "nk_font_atlas_begin".}
proc open*(atlas: var font_atlas) =
font_atlas_begin(addr atlas)
proc font_atlas_add(a2: ptr font_atlas; a3: ptr font_config): ptr font {. importc: "nk_font_atlas_add".}
proc add*(atlas: var font_atlas, config: var font_config): var font =
font_atlas_add(addr atlas, addr config)[]
proc font_atlas_add_from_memory(atlas: ptr font_atlas; memory: pointer;
size: uint; height: float32;
config: ptr font_config): ptr font {.importc: "nk_font_atlas_add_from_memory".}
proc addFromMemory*(atlas: var font_atlas, memory: pointer, size: uint, height: float32, config: ptr font_config) : ptr font =
font_atlas_add_from_memory(addr atlas, memory, size, height, config)
proc font_atlas_add_compressed*(a2: ptr font_atlas; memory: pointer;
size: uint; height: float32;
a6: ptr font_config): ptr font {.importc: "nk_font_atlas_add_compressed".}
proc addCompressed*(atlas: var font_atlas, memory: pointer, size: uint, height: float32, config: var font_config) : ptr font =
font_atlas_add_compressed(addr atlas, memory, size, height, addr config)
proc font_atlas_add_compressed_base85(a2: ptr font_atlas; data: cstring;
height: float32; config: ptr font_config): ptr font {.importc: "nk_font_atlas_add_compressed_base85".}
proc addCompressedBase85*(atlas: var font_atlas, data: string, height: float32, config: var font_config): ptr font =
font_atlas_add_compressed_base85(addr atlas, data, height, addr config)
proc font_atlas_bake(a2: ptr font_atlas; width: ptr int32; height: ptr int32;
a5: font_atlas_format): pointer {.importc: "nk_font_atlas_bake".}
proc bake*(atlas: var font_atlas, width, height: var int32, format: font_atlas_format): pointer =
font_atlas_bake(addr atlas, addr width, addr height, format)
proc font_atlas_end(a2: ptr font_atlas; tex: handle;
a4: ptr draw_null_texture) {.importc: "nk_font_atlas_end".}
proc close*(atlas: var font_atlas, tex: handle, null: var draw_null_texture) =
font_atlas_end(addr atlas, tex, addr null)
proc font_find_glyph(a2: ptr font; unicode: uint32): ptr font_glyph {.importc: "nk_font_find_glyph".}
proc findGlyph*(f: var font, unicode: uint32): font_glyph =
font_find_glyph(addr f, unicode)[]
proc font_atlas_cleanup(atlas: ptr font_atlas) {.importc: "nk_font_atlas_cleanup".}
proc cleanup*(atlas: var font_atlas) =
font_atlas_cleanup(addr atlas)
proc font_atlas_clear(a2: ptr font_atlas) {.importc: "nk_font_atlas_clear".}
proc clear*(atlas: var font_atlas) =
font_atlas_clear(addr atlas)
proc font_atlas_add_default(a2: ptr font_atlas; height: float32;
a4: ptr font_config): ptr font {.importc: "nk_font_atlas_add_default".}
proc add*(atlas: var font_atlas, height: float32, fontConfig: var font_config): ptr font =
font_atlas_add_default(addr atlas, height, addr fontConfig)
proc font_atlas_add_from_file*(atlas: ptr font_atlas; file_path: cstring;
height: float32; a5: ptr font_config): ptr font {.importc: "nk_font_atlas_add_from_file".}
proc addFromFile*(atlas: var font_atlas, filePath: string, height: float32, fontConfig: var font_config): ptr font =
font_atlas_add_from_file(addr atlas, filePath, height, addr fontConfig)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.