Lines Matching defs:size

108 /// NK_UINT_DRAW_INDEX              | Defining this will set the size of vertex index elements when using NK_VERTEX_BUFFER_OUTPUT to 32bit instead of the default of 16bit
132 /// 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.
133 /// NK_MAX_NUMBER_BUFFER | Maximum buffer size for the conversion buffer between float and string Under normal circumstances this should be more than sufficient.
413 /* Make sure correct type size:
467 struct nk_cursor {struct nk_image img; struct nk_vec2 size, offset;};
541 /// __nk_init_fixed__ | Initializes context from single fixed size memory block
568 /// Initializes a `nk_context` struct from single fixed size memory block
575 /// int nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size, const struct nk_user_font *font);
585 /// __size__ | Must contain the total size of __memory__
590 NK_API int nk_init_fixed(struct nk_context*, void *memory, nk_size size, const struct nk_user_font*);
1316 /// Each window holds frame persistent state like position, size, flags, state tables,
1395 /// nk_window_get_bounds | Returns a rectangle with screen position and size of the currently processed window.
1397 /// nk_window_get_size | Returns the size with width and height of the currently processed window
1401 /// nk_window_get_content_region | Returns the position and size of the currently visible and non-clipped space inside the currently processed window
1404 /// nk_window_get_content_region_size | Returns the size of the currently visible and non-clipped space inside the currently processed window
1416 /// nk_window_set_bounds | Updates position and size of the currently processed window
1418 /// nk_window_set_size | Updates the size of the currently processed window
1476 /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame
1496 /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame
1533 /// Returns a rectangle with screen position and size of the currently processed window
1545 /// Returns a `nk_rect` struct with window upper left window position and size
1565 /// Returns the size with width and height of the currently processed window.
1631 /// Returns the position and size of the currently visible and non-clipped space
1645 /// Returns `nk_rect` struct with screen position and size (no scrollbar offset)
1688 /// Returns the size of the currently visible and non-clipped space inside the
1702 /// Returns `nk_vec2` struct with size the visible space inside the current window
1856 /// Updates position and size of window with passed in name
1864 /// __name__ | Identifier of the window to modify both position and size
1865 /// __bounds__ | Must point to a `nk_rect` struct with the new position and size
1882 /// Updates size of window with passed in name
1890 /// __name__ | Identifier of the window to modify both window size
1891 /// __size__ | Must point to a `nk_vec2` struct with new window size
1994 /// Layouting in general describes placing widget inside a window with position and size.
2037 /// the size of each widget dynamically by formula:
2138 /// const float size[] = {60,40};
2169 /// The row template layout has three different per widget size specifier. The first
2172 /// The second size specifier is `nk_layout_row_template_push_variable`
2173 /// which defines a minimum widget size but it also can grow if more space is available
2204 /// row auto repeat and directly sets position and size of a widget. Position
2205 /// and size hereby can be either specified as ratio of allocated space or
2206 /// allocated space local position and pixel size. Since this API is quite
2236 /// nk_layout_ratio_from_pixel | Utility functions to calculate window ratio from pixel size
2241 /// nk_layout_row_push | Pushes another column with given size or window ratio
2243 /// nk_layout_row | Specifies row columns in array as either window ratio or size
2248 /// nk_layout_row_template_push_static | Adds a static column that does not grow and will always have the same size
2251 /// nk_layout_space_begin | Begins a new layouting space that allows to specify each widgets position and size
2252 /// nk_layout_space_push | Pushes position and size of the next widget in own coordinate space either as pixel or ratio
2298 /// Return `nk_rect` with both position and size of the next row
2302 /// Utility functions to calculate window ratio from pixel size
2312 /// Returns `nk_rect` with both position and size of the next row
2332 /// in row with same @item_width horizontal size. Once called all subsequent widget
2355 /// __fmt__ | either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
2384 /// Specifies row columns in array as either window ratio or size
2392 /// __fmt__ | Either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
2434 /// Adds a static column that does not grow and will always have the same size
2457 /// Begins a new layouting space that allows to specify each widgets position and size.
2465 /// __fmt__ | Either `NK_DYNAMIC` for window ratio or `NK_STATIC` for fixed size columns
2471 /// Pushes position and size of the next widget in own coordinate space either as pixel or ratio
2479 /// __bounds__ | Position and size in laoyut space local coordinates
2651 /// Starts a new widget group. Requires a previous layouting function to specify a pos/size.
2666 /// Starts a new widget group. Requires a previous layouting function to specify a pos/size.
2694 /// a size. Does not keep track of scrollbar.
2712 /// layouting function to specify a size. Does not keep track of scrollbar.
2801 /// calculates a auto height based on the currently used font size
3478 NK_API int nk_combo(struct nk_context*, const char **items, int count, int selected, int item_height, struct nk_vec2 size);
3479 NK_API int nk_combo_separator(struct nk_context*, const char *items_separated_by_separator, int separator, int selected, int count, int item_height, struct nk_vec2 size);
3480 NK_API int nk_combo_string(struct nk_context*, const char *items_separated_by_zeros, int selected, int count, int item_height, struct nk_vec2 size);
3481 NK_API int nk_combo_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void *userdata, int selected, int count, int item_height, struct nk_vec2 size);
3482 NK_API void nk_combobox(struct nk_context*, const char **items, int count, int *selected, int item_height, struct nk_vec2 size);
3483 NK_API void nk_combobox_string(struct nk_context*, const char *items_separated_by_zeros, int *selected, int count, int item_height, struct nk_vec2 size);
3484 NK_API void nk_combobox_separator(struct nk_context*, const char *items_separated_by_separator, int separator,int *selected, int count, int item_height, struct nk_vec2 size);
3485 NK_API void nk_combobox_callback(struct nk_context*, void(*item_getter)(void*, int, const char**), void*, int *selected, int count, int item_height, struct nk_vec2 size);
3491 NK_API int nk_combo_begin_text(struct nk_context*, const char *selected, int, struct nk_vec2 size);
3492 NK_API int nk_combo_begin_label(struct nk_context*, const char *selected, struct nk_vec2 size);
3493 NK_API int nk_combo_begin_color(struct nk_context*, struct nk_color color, struct nk_vec2 size);
3494 NK_API int nk_combo_begin_symbol(struct nk_context*, enum nk_symbol_type, struct nk_vec2 size);
3495 NK_API int nk_combo_begin_symbol_label(struct nk_context*, const char *selected, enum nk_symbol_type, struct nk_vec2 size);
3496 NK_API int nk_combo_begin_symbol_text(struct nk_context*, const char *selected, int, enum nk_symbol_type, struct nk_vec2 size);
3497 NK_API int nk_combo_begin_image(struct nk_context*, struct nk_image img, struct nk_vec2 size);
3498 NK_API int nk_combo_begin_image_label(struct nk_context*, const char *selected, struct nk_image, struct nk_vec2 size);
3499 NK_API int nk_combo_begin_image_text(struct nk_context*, const char *selected, int, struct nk_image, struct nk_vec2 size);
3541 NK_API int nk_menu_begin_text(struct nk_context*, const char* title, int title_len, nk_flags align, struct nk_vec2 size);
3542 NK_API int nk_menu_begin_label(struct nk_context*, const char*, nk_flags align, struct nk_vec2 size);
3543 NK_API int nk_menu_begin_image(struct nk_context*, const char*, struct nk_image, struct nk_vec2 size);
3544 NK_API int nk_menu_begin_image_text(struct nk_context*, const char*, int,nk_flags align,struct nk_image, struct nk_vec2 size);
3545 NK_API int nk_menu_begin_image_label(struct nk_context*, const char*, nk_flags align,struct nk_image, struct nk_vec2 size);
3546 NK_API int nk_menu_begin_symbol(struct nk_context*, const char*, enum nk_symbol_type, struct nk_vec2 size);
3547 NK_API int nk_menu_begin_symbol_text(struct nk_context*, const char*, int,nk_flags align,enum nk_symbol_type, struct nk_vec2 size);
3548 NK_API int nk_menu_begin_symbol_label(struct nk_context*, const char*, nk_flags align,enum nk_symbol_type, struct nk_vec2 size);
3719 NK_API struct nk_rect nk_recta(struct nk_vec2 pos, struct nk_vec2 size);
3793 information (offset, size, ...). So it is still possible to provide your own
3909 /* size of the glyph */
3957 /* size of the loaded TTF file memory block
3970 float size;
4046 NK_API struct nk_font* nk_font_atlas_add_from_memory(struct nk_font_atlas *atlas, void *memory, nk_size size, float height, const struct nk_font_config *config);
4050 NK_API struct nk_font *nk_font_atlas_add_compressed(struct nk_font_atlas*, void *memory, nk_size size, float height, const struct nk_font_config*);
4074 size memory block. In this case all control lies in the hand of the user
4076 the library should consume. Of course using the fixed size API removes the
4096 nk_size size;
4118 struct nk_memory {void *ptr;nk_size size;};
4127 /* memory and size of the current memory block */
4136 nk_size size;
4137 /* current size of the buffer */
4143 NK_API void nk_buffer_init(struct nk_buffer*, const struct nk_allocator*, nk_size size);
4144 NK_API void nk_buffer_init_fixed(struct nk_buffer*, void *memory, nk_size size);
4146 NK_API void nk_buffer_push(struct nk_buffer*, enum nk_buffer_allocation_type type, const void *memory, nk_size size, nk_size align);
4161 * to manage and manipulate dynamic or fixed size string content. This is _NOT_
4173 NK_API void nk_str_init(struct nk_str*, const struct nk_allocator*, nk_size size);
4174 NK_API void nk_str_init_fixed(struct nk_str*, void *memory, nk_size size);
4228 * a fixed size nk_text_edit struct, which has an internal undo/redo stack.
4314 NK_API void nk_textedit_init(struct nk_text_edit*, struct nk_allocator*, nk_size size);
4315 NK_API void nk_textedit_init_fixed(struct nk_text_edit*, void *memory, nk_size size);
5458 * flags, colors, fonts and for button_behavior. Each has it's own fixed size stack
5494 #define NK_CONFIG_STACK(type,size)\
5497 struct nk_config_stack_##type##_element elements[size];\
5535 unsigned int size;
5554 unsigned int size;
5566 nk_size size;
5767 /* Make sure correct type size:
5818 NK_LIB void nk_memset(void *ptr, int c0, nk_size size);
5819 NK_LIB void nk_zero(void *ptr, nk_size size);
5834 NK_LIB void* nk_malloc(nk_handle unused, void *old,nk_size size);
5838 NK_LIB void* nk_buffer_alloc(struct nk_buffer *b, enum nk_buffer_allocation_type type, nk_size size, nk_size align);
5839 NK_LIB void* nk_buffer_realloc(struct nk_buffer *b, nk_size capacity, nk_size *size);
5844 NK_LIB void* nk_command_buffer_push(struct nk_command_buffer* b, enum nk_command_type t, nk_size size);
5876 NK_LIB void nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size);
6192 nk_recta(struct nk_vec2 pos, struct nk_vec2 size)
6194 return nk_rect(pos.x, pos.y, size.x, size.y);
6391 nk_memset(void *ptr, int c0, nk_size size)
6408 if (size < 3 * nk_wsize) {
6409 while (size--) *dst++ = (nk_byte)c0;
6416 size -= t;
6423 t = size / nk_wsize;
6430 t = (size & nk_wmask);
6442 nk_zero(void *ptr, nk_size size)
6445 NK_MEMSET(ptr, 0, size);
8009 nk_malloc(nk_handle unused, void *old,nk_size size)
8013 return malloc(size);
8044 b->memory.size = initial_size;
8045 b->size = initial_size;
8050 nk_buffer_init_fixed(struct nk_buffer *b, void *m, nk_size size)
8054 NK_ASSERT(size);
8055 if (!b || !m || !size) return;
8060 b->memory.size = size;
8061 b->size = size;
8094 nk_buffer_realloc(struct nk_buffer *b, nk_size capacity, nk_size *size)
8100 NK_ASSERT(size);
8101 if (!b || !size || !b->pool.alloc || !b->pool.free)
8104 buffer_size = b->memory.size;
8109 *size = capacity;
8115 if (b->size == buffer_size) {
8116 /* no back buffer so just set correct size */
8117 b->size = capacity;
8123 back_size = buffer_size - b->size;
8125 src = nk_ptr_add(void, temp, b->size);
8127 b->size = capacity - back_size;
8133 nk_size size, nk_size align)
8141 NK_ASSERT(size);
8142 if (!b || !size) return 0;
8143 b->needed += size;
8145 /* calculate total size with needed alignment + size */
8148 else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size);
8153 full = ((b->allocated + size + alignment) > b->size);
8154 else full = ((b->size - NK_MIN(b->size,(size + alignment))) <= b->allocated);
8165 capacity = (nk_size)((float)b->memory.size * b->grow_factor);
8166 capacity = NK_MAX(capacity, nk_round_up_pow2((nk_uint)(b->allocated + size)));
8167 b->memory.ptr = nk_buffer_realloc(b, capacity, &b->memory.size);
8173 else unaligned = nk_ptr_add(void, b->memory.ptr, b->size - size);
8177 b->allocated += size + alignment;
8178 else b->size -= (size + alignment);
8185 const void *memory, nk_size size, nk_size align)
8187 void *mem = nk_buffer_alloc(b, type, size, align);
8189 NK_MEMCPY(mem, memory, size);
8198 buffer->marker[type].offset = buffer->size;
8208 buffer->needed -= (buffer->memory.size - buffer->marker[type].offset);
8210 buffer->size = buffer->marker[type].offset;
8211 else buffer->size = buffer->memory.size;
8228 b->size = b->memory.size;
8249 s->size = b->memory.size;
8273 return buffer->memory.size;
8299 nk_str_init(struct nk_str *str, const struct nk_allocator *alloc, nk_size size)
8301 nk_buffer_init(&str->buffer, alloc, size);
8305 nk_str_init_fixed(struct nk_str *str, void *memory, nk_size size)
8307 nk_buffer_init_fixed(&str->buffer, memory, size);
8403 if ((s->buffer.allocated + (nk_size)len >= s->buffer.memory.size) &&
8765 enum nk_command_type t, nk_size size)
8776 cmd = (struct nk_command*)nk_buffer_alloc(b->base,NK_BUFFER_FRONT,size,align);
8781 unaligned = (nk_byte*)cmd + size;
8785 NK_MEMSET(cmd, 0, size + alignment);
9064 nk_size size = 0;
9069 size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count;
9070 cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size);
9085 nk_size size = 0;
9090 size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count;
9092 nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size);
9106 nk_size size = 0;
9111 size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count;
9112 cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size);
9269 if (!buffer || !buffer->size || !canvas->cmd_count)
9273 offset = buffer->memory.size - canvas->cmd_offset;
9280 nk_size size;
9291 size = buffer->memory.size;
9292 offset = size - canvas->cmd_offset;
9375 nk_size size;
9380 size = nk_buffer_total(list->buffer);
9381 cmd = nk_ptr_add(struct nk_draw_command, memory, size - list->cmd_offset);
9442 * and don't forget to specify the new element size in your drawing
9666 nk_size size;
9673 size = pnt_size * ((thick_line) ? 5 : 3) * points_count;
9674 normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align);
9900 nk_size size = 0;
9909 size = pnt_size * points_count;
9910 normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align);
10525 res |= (cmds->needed > cmds->allocated + (cmds->memory.size - cmds->size)) ? NK_CONVERT_COMMAND_BUFFER_FULL: 0;
11611 nk_tt__hheap_alloc(struct nk_tt__hheap *hh, nk_size size)
11619 int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
11622 sizeof(struct nk_tt__hheap_chunk) + size * (nk_size)count);
11629 return (char *) (hh->head) + size * (nk_size)hh->num_remaining_in_head_chunk;
12810 tmp->ranges[i].font_size = cfg->size;
12887 float font_scale = nk_tt_ScaleForPixelHeight(&tmp->info, cfg->size);
12895 dst_font->height = cfg->size;
13427 cfg.size = pixel_height;
13509 NK_ASSERT(config->size > 0.0f);
13511 if (!atlas || !config || !config->ttf_blob || !config->ttf_size || config->size <= 0.0f||
13583 nk_size size, float height, const struct nk_font_config *config)
13587 NK_ASSERT(size);
13594 if (!atlas || !atlas->temporary.alloc || !atlas->temporary.free || !memory || !size ||
13600 cfg.ttf_size = size;
13601 cfg.size = height;
13610 nk_size size;
13621 memory = nk_file_load(file_path, &size, &atlas->permanent);
13626 cfg.ttf_size = size;
13627 cfg.size = height;
13663 cfg.size = height;
13792 nk_font_init(font, config->size, config->fallback_glyph, atlas->glyphs,
13815 cursor->size = nk_cursor_data[i][1];
14991 nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size,
14997 nk_buffer_init_fixed(&ctx->memory, memory, size);
15013 nk_pool_init_fixed(&ctx->pool, pool->memory.ptr, pool->memory.size);
15222 mouse_bounds.w = cursor->size.x;
15223 mouse_bounds.h = cursor->size.y;
15334 nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size)
15337 NK_ASSERT(size >= sizeof(struct nk_page));
15338 if (size < sizeof(struct nk_page)) return;
15339 pool->capacity = (unsigned)(size - sizeof(struct nk_page)) / sizeof(struct nk_page_element);
15342 pool->size = size;
15347 if (!pool->pages || pool->pages->size >= pool->capacity) {
15353 NK_ASSERT(pool->pages->size < pool->capacity);
15356 nk_size size = sizeof(struct nk_page);
15357 size += NK_POOL_DEFAULT_CAPACITY * sizeof(union nk_page_data);
15358 page = (struct nk_page*)pool->alloc.alloc(pool->alloc.userdata,0, size);
15361 page->size = 0;
15363 } return &pool->pages->win[pool->pages->size++];
15389 /* allocate new page element from back of fixed size memory buffer */
15390 NK_STORAGE const nk_size size = sizeof(struct nk_page_element);
15392 elem = (struct nk_page_element*)nk_buffer_alloc(&ctx->memory, NK_BUFFER_BACK, size, align);
15423 void *buffer_end = (nk_byte*)ctx->memory.memory.ptr + ctx->memory.size;
15425 ctx->memory.size -= sizeof(struct nk_page_element);
15461 tbl->size = 0;
15468 tbl->size = 0;
15491 if (!win->tables || win->tables->size >= NK_VALUE_PAGE_CAPACITY) {
15498 win->tables->keys[win->tables->size] = name;
15499 win->tables->values[win->tables->size] = value;
15500 return &win->tables->values[win->tables->size++];
15508 unsigned int size = iter->size;
15509 for (i = 0; i < size; ++i) {
15514 } size = NK_VALUE_PAGE_CAPACITY;
16703 const char *name, struct nk_vec2 size)
16707 win->bounds.w = size.x;
16708 win->bounds.h = size.y;
17066 nk_contextual_begin(struct nk_context *ctx, nk_flags flags, struct nk_vec2 size,
17109 body.w = size.x;
17110 body.h = size.y;
17357 const char *id, int is_clicked, struct nk_rect header, struct nk_vec2 size)
17372 body.w = size.x;
17374 body.h = size.y;
17390 nk_flags align, struct nk_vec2 size)
17411 return nk_menu_begin(ctx, win, title, is_clicked, header, size);
17414 const char *text, nk_flags align, struct nk_vec2 size)
17416 return nk_menu_begin_text(ctx, text, nk_strlen(text), align, size);
17420 struct nk_vec2 size)
17441 return nk_menu_begin(ctx, win, id, is_clicked, header, size);
17445 enum nk_symbol_type sym, struct nk_vec2 size)
17466 return nk_menu_begin(ctx, win, id, is_clicked, header, size);
17470 nk_flags align, struct nk_image img, struct nk_vec2 size)
17492 return nk_menu_begin(ctx, win, title, is_clicked, header, size);
17496 const char *title, nk_flags align, struct nk_image img, struct nk_vec2 size)
17498 return nk_menu_begin_image_text(ctx, title, nk_strlen(title), align, img, size);
17502 nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size)
17524 return nk_menu_begin(ctx, win, title, is_clicked, header, size);
17528 const char *title, nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size )
17530 return nk_menu_begin_symbol_text(ctx, title, nk_strlen(title), align,sym,size);
18186 /* scaling fixed size widgets item width */
18306 /* calculate widget position and size */
18614 /* calculate size of the text and tooltip */
21158 /* remove one cursor size to support visual cursor */
21742 const struct nk_vec2 size = nk_text_calculate_text_bounds(font,
21746 r->x1 = size.x;
21747 r->baseline_y_delta = size.y;
21749 r->ymax = size.y;
22674 nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size)
22678 if (!state || !memory || !size) return;
22681 nk_str_init_fixed(&state->string, memory, size);
22684 nk_textedit_init(struct nk_text_edit *state, struct nk_allocator *alloc, nk_size size)
22691 nk_str_init(&state->string, alloc, size);
23645 float size;
23664 size = font->width(font->userdata, font->height, name, name_len);
23666 label.w = (float)size + 2 * style->padding.x;
23678 size = font->width(font->userdata, font->height, buffer, *len);
23679 size += style->edit.cursor_size;
23698 size = font->width(font->userdata, font->height, string, num_len);
23703 edit.w = (float)size + 2 * style->padding.x;
23766 text_edit->string.buffer.memory.size = NK_MAX_NUMBER_BUFFER;
23768 text_edit->string.buffer.size = NK_MAX_NUMBER_BUFFER;
24554 struct nk_vec2 size, int is_clicked, struct nk_rect header)
24570 body.w = size.x;
24572 body.h = size.y;
24588 struct nk_vec2 size)
24673 return nk_combo_begin(ctx, win, size, is_clicked, header);
24676 nk_combo_begin_label(struct nk_context *ctx, const char *selected, struct nk_vec2 size)
24678 return nk_combo_begin_text(ctx, selected, nk_strlen(selected), size);
24681 nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_vec2 size)
24755 return nk_combo_begin(ctx, win, size, is_clicked, header);
24758 nk_combo_begin_symbol(struct nk_context *ctx, enum nk_symbol_type symbol, struct nk_vec2 size)
24842 return nk_combo_begin(ctx, win, size, is_clicked, header);
24846 enum nk_symbol_type symbol, struct nk_vec2 size)
24938 return nk_combo_begin(ctx, win, size, is_clicked, header);
24941 nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 size)
25015 return nk_combo_begin(ctx, win, size, is_clicked, header);
25019 struct nk_image img, struct nk_vec2 size)
25106 return nk_combo_begin(ctx, win, size, is_clicked, header);
25110 const char *selected, enum nk_symbol_type type, struct nk_vec2 size)
25112 return nk_combo_begin_symbol_text(ctx, selected, nk_strlen(selected), type, size);
25116 const char *selected, struct nk_image img, struct nk_vec2 size)
25118 return nk_combo_begin_image_text(ctx, selected, nk_strlen(selected), img, size);
25164 int selected, int item_height, struct nk_vec2 size)
25181 size.y = NK_MIN(size.y, (float)max_height);
25182 if (nk_combo_begin_label(ctx, items[selected], size)) {
25194 int separator, int selected, int count, int item_height, struct nk_vec2 size)
25214 size.y = NK_MIN(size.y, (float)max_height);
25226 if (nk_combo_begin_text(ctx, current_item, length, size)) {
25243 int selected, int count, int item_height, struct nk_vec2 size)
25245 return nk_combo_separator(ctx, items_separated_by_zeros, '\0', selected, count, item_height, size);
25249 void *userdata, int selected, int count, int item_height, struct nk_vec2 size)
25267 size.y = NK_MIN(size.y, (float)max_height);
25270 if (nk_combo_begin_label(ctx, item, size)) {
25282 int *selected, int item_height, struct nk_vec2 size)
25284 *selected = nk_combo(ctx, items, count, *selected, item_height, size);
25288 int *selected, int count, int item_height, struct nk_vec2 size)
25290 *selected = nk_combo_string(ctx, items_separated_by_zeros, *selected, count, item_height, size);
25294 int separator,int *selected, int count, int item_height, struct nk_vec2 size)
25297 *selected, count, item_height, size);
25302 void *userdata, int *selected, int count, int item_height, struct nk_vec2 size)
25304 *selected = nk_combo_callback(ctx, item_getter, userdata, *selected, count, item_height, size);
25386 /* calculate size of the text and tooltip */
25508 /// - 2017/11/07 (2.00.3) - Fixed window size and position modifier functions.
25511 /// - 2017/09/14 (2.00.0) - BREAKING CHANGE: Modifing window position and size funtions now
25523 /// - 2017/07/07 (1.40.3) - Fixed table internal bug caused by storing table size in
25538 /// - 2017/05/10 (1.38.3) - Fixed wrong min window size mouse scaling over boundries.
25540 /// - 2017/05/09 (1.38.1) - Fixed scaler dragging behavior if window size hits minimum size.
25601 /// - 2016/09/20 (1.22.2) - Fixed color button size calculation.
25617 /// for width and height to have more control over the popup size.
25660 /// - 2016/08/30 (1.12.0) - Removed scaler size. The size of the scaler is now
25661 /// determined by the scrollbar size.