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 openarray[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): bool =
  bool 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 endGroup*(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): bool =
  bool 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): bool =
  bool 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): bool =
  bool 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): bool =
  bool 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): bool =
  bool 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): bool =
  bool  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): bool =
  bool 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): bool =
  bool 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)