Lines Matching defs:buffer
50 /// - Optional font baker and vertex buffer output
62 /// - Hardware accessible anti-aliased vertex buffer output
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.
611 /// buffers. The first buffer is for allocating draw commands while the second buffer is
621 /// __cmds__ | Must point to a previously initialized memory buffer either fixed or dynamic to store draw commands into
622 /// __pool__ | Must point to a previously initialized memory buffer either fixed or dynamic to store windows, panels and tables
731 /// __nk_input_char__ | Adds a single ASCII text character into an internal text buffer
732 /// __nk_input_glyph__ | Adds a single multi-byte UTF-8 character into an internal text buffer
733 /// __nk_input_unicode__| Adds a single unicode rune into an internal text buffer
851 /// Copies a single ASCII character into an internal text buffer
870 /// internal text buffer.
887 /// into an internal text buffer.
923 /// Each frame therefore fills the command buffer with draw commands
925 /// After that the command buffer needs to be cleared and a new frame can be
926 /// started. It is probably important to note that the command buffer is the main
927 /// drawing API and the optional vertex buffer API only takes this format and
1035 /// allocate a memory buffer that will store each unique drawing output.
1037 /// with your allocated buffer by memcmp. If memcmp detects differences
1038 /// you have to copy the command buffer into the allocated buffer
1227 /// __cmds__ | Must point to a previously initialized buffer to hold converted vertex draw commands
1228 /// __vertices__| Must point to a previously initialized buffer to hold all produced vertices
1229 /// __elements__| Must point to a previously initialized buffer to hold all produced vertex indices
1236 /// NK_CONVERT_SUCCESS | Signals a successful draw command to vertex buffer conversion
1238 /// NK_CONVERT_COMMAND_BUFFER_FULL | The provided buffer for storing draw commands is full or failed to allocate more memory
1239 /// NK_CONVERT_VERTEX_BUFFER_FULL | The provided buffer for storing vertices is full or failed to allocate more memory
1240 /// NK_CONVERT_ELEMENT_BUFFER_FULL | The provided buffer for storing indicies is full or failed to allocate more memory
1244 /// Returns a draw vertex command buffer iterator to iterate over the vertex draw command buffer
1253 /// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer
1255 /// Returns vertex draw command pointer pointing to the first command inside the vertex draw command buffer
1259 /// Returns the vertex draw command at the end of the vertex draw command buffer
1268 /// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer
1270 /// Returns vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer
1274 /// Increments the vertex draw command buffer iterator
1283 /// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer
1286 /// Returns vertex draw command pointer pointing to the end of the last vertex draw command inside the vertex draw command buffer
1290 /// Iterates over each vertex draw command inside a vertex draw command buffer
1299 /// __buf__ | Must point to an previously by `nk_convert` filled out vertex draw command buffer
1405 /// nk_window_get_canvas | Returns the draw command buffer. Can be used to draw custom widgets
1706 /// Returns the draw command buffer. Can be used to draw custom widgets
1710 /// Do not keep the returned command buffer pointer around it is only valid until `nk_end`
3444 NK_API nk_flags nk_edit_string(struct nk_context*, nk_flags, char *buffer, int *len, int max, nk_plugin_filter);
3445 NK_API nk_flags nk_edit_string_zero_terminated(struct nk_context*, nk_flags, char *buffer, int max, nk_plugin_filter);
3746 NK_API const char* nk_utf_at(const char *buffer, int length, int index, nk_rune *unicode, int *len);
3756 slightly more advanced features is font handling with vertex buffer output.
3759 1.) Using your own implementation without vertex buffer output
3786 2.) Using your own implementation with vertex buffer output
3789 vertex buffer output it is not enough if you do. To get font handling working
3794 font and use the vertex buffer output.
3831 and can be used with or without the vertex buffer output.
4065 /* A basic (double)-buffer with linear allocation and resetting as only
4066 freeing policy. The buffer's main purpose is to control all memory management
4077 ability to automatically resize a buffer if not enough memory is provided so
4078 you have to take over the resizing. While being a fixed sized buffer sounds
4121 /* buffer marker to free a buffer to a certain offset */
4137 /* current size of the buffer */
4160 /* Basic string buffer which is only used in context with the text editor
4166 struct nk_buffer buffer;
4230 * to have a dynamically growing buffer.
4334 Each frame therefore fills the command buffer with draw commands
4336 After that the command buffer needs to be cleared and a new frame can be
4337 started. It is probably important to note that the command buffer is the main
4338 drawing API and the optional vertex buffer API only takes this format and
4342 command buffer of each window by calling `nk_window_get_canvas` after
4397 /* command base and header of every command inside the buffer */
4653 /* The optional vertex buffer draw list provides a 2D drawing context
4737 struct nk_buffer *buffer;
5341 struct nk_command_buffer *buffer;
5398 char buffer[NK_MAX_NUMBER_BUFFER];
5417 struct nk_command_buffer buffer;
5595 /* draw buffer used for overlay drawing operation like cursor */
5832 /* buffer */
6014 NK_LIB void nk_do_property(nk_flags *ws, struct nk_command_buffer *out, struct nk_rect property, const char *name, struct nk_property_variant *variant, float inc_per_pixel, char *buffer, int *len, int *state, int *cursor, int *select_begin, int *select_end, const struct nk_style_property *style, enum nk_property_filter filter, struct nk_input *in, const struct nk_user_font *font, struct nk_text_edit *text_edit, enum nk_button_behavior behavior);
6993 NK_ASSERT(str != buf && "buffer and argument are not allowed to overlap!");
7042 /* copy string value representation into buffer */
7055 /* copy string value representation into buffer */
7171 /* copy string value representation into buffer */
7961 nk_utf_at(const char *buffer, int length, int index,
7970 NK_ASSERT(buffer);
7974 if (!buffer || !unicode || !len) return 0;
7981 text = buffer;
7995 return buffer + src_len;
8022 nk_buffer_init_default(struct nk_buffer *buffer)
8028 nk_buffer_init(buffer, &alloc, NK_BUFFER_DEFAULT_INITIAL_SIZE);
8116 /* no back buffer so just set correct size */
8120 /* copy back buffer to the end of the new buffer */
8151 /* check if buffer has enough memory*/
8164 /* buffer is full so allocate bigger buffer if dynamic */
8192 nk_buffer_mark(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
8194 NK_ASSERT(buffer);
8195 if (!buffer) return;
8196 buffer->marker[type].active = nk_true;
8198 buffer->marker[type].offset = buffer->size;
8199 else buffer->marker[type].offset = buffer->allocated;
8202 nk_buffer_reset(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
8204 NK_ASSERT(buffer);
8205 if (!buffer) return;
8207 /* reset back buffer either back to marker or empty */
8208 buffer->needed -= (buffer->memory.size - buffer->marker[type].offset);
8209 if (buffer->marker[type].active)
8210 buffer->size = buffer->marker[type].offset;
8211 else buffer->size = buffer->memory.size;
8212 buffer->marker[type].active = nk_false;
8214 /* reset front buffer either back to back marker or empty */
8215 buffer->needed -= (buffer->allocated - buffer->marker[type].offset);
8216 if (buffer->marker[type].active)
8217 buffer->allocated = buffer->marker[type].offset;
8218 else buffer->allocated = 0;
8219 buffer->marker[type].active = nk_false;
8255 nk_buffer_memory(struct nk_buffer *buffer)
8257 NK_ASSERT(buffer);
8258 if (!buffer) return 0;
8259 return buffer->memory.ptr;
8262 nk_buffer_memory_const(const struct nk_buffer *buffer)
8264 NK_ASSERT(buffer);
8265 if (!buffer) return 0;
8266 return buffer->memory.ptr;
8269 nk_buffer_total(struct nk_buffer *buffer)
8271 NK_ASSERT(buffer);
8272 if (!buffer) return 0;
8273 return buffer->memory.size;
8293 nk_buffer_init(&str->buffer, &alloc, 32);
8301 nk_buffer_init(&str->buffer, alloc, size);
8307 nk_buffer_init_fixed(&str->buffer, memory, size);
8317 mem = (char*)nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
8402 if (!s || !str || !len || (nk_size)pos > s->buffer.allocated) return 0;
8403 if ((s->buffer.allocated + (nk_size)len >= s->buffer.memory.size) &&
8404 (s->buffer.type == NK_BUFFER_FIXED)) return 0;
8406 copylen = (int)s->buffer.allocated - pos;
8411 mem = nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
8417 dst = nk_ptr_add(char, s->buffer.memory.ptr, pos + len + (copylen - 1));
8418 src = nk_ptr_add(char, s->buffer.memory.ptr, pos + (copylen-1));
8420 mem = nk_ptr_add(void, s->buffer.memory.ptr, pos);
8422 s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
8431 const char *buffer;
8440 buffer = nk_str_get_const(str);
8442 return nk_str_insert_at_char(str, (int)(begin - buffer), cstr, len);
8524 if (!s || len < 0 || (nk_size)len > s->buffer.allocated) return;
8525 NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
8526 s->buffer.allocated -= (nk_size)len;
8527 s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
8547 end = (const char*)str->buffer.memory.ptr + str->buffer.allocated;
8554 if (!s || !len || (nk_size)pos > s->buffer.allocated ||
8555 (nk_size)(pos + len) > s->buffer.allocated) return;
8557 if ((nk_size)(pos + len) < s->buffer.allocated) {
8559 char *dst = nk_ptr_add(char, s->buffer.memory.ptr, pos);
8560 char *src = nk_ptr_add(char, s->buffer.memory.ptr, pos + len);
8561 NK_MEMCPY(dst, src, s->buffer.allocated - (nk_size)(pos + len));
8562 NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
8563 s->buffer.allocated -= (nk_size)len;
8565 s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
8582 temp = (char *)s->buffer.memory.ptr;
8585 s->buffer.memory.ptr = begin;
8587 s->buffer.memory.ptr = temp;
8595 if (!s || pos > (int)s->buffer.allocated) return 0;
8596 return nk_ptr_add(char, s->buffer.memory.ptr, pos);
8618 text = (char*)str->buffer.memory.ptr;
8619 text_len = (int)str->buffer.allocated;
8638 if (!s || pos > (int)s->buffer.allocated) return 0;
8639 return nk_ptr_add(char, s->buffer.memory.ptr, pos);
8661 text = (char*)str->buffer.memory.ptr;
8662 text_len = (int)str->buffer.allocated;
8689 if (!s || !s->len || !s->buffer.allocated) return 0;
8690 return (char*)s->buffer.memory.ptr;
8696 if (!s || !s->len || !s->buffer.allocated) return 0;
8697 return (const char*)s->buffer.memory.ptr;
8703 if (!s || !s->len || !s->buffer.allocated) return 0;
8710 if (!s || !s->len || !s->buffer.allocated) return 0;
8711 return (int)s->buffer.allocated;
8717 nk_buffer_clear(&str->buffer);
8724 nk_buffer_free(&str->buffer);
9246 canvas->buffer = cmds;
9262 nk__draw_list_begin(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
9268 NK_ASSERT(buffer);
9269 if (!buffer || !buffer->size || !canvas->cmd_count)
9272 memory = (nk_byte*)buffer->memory.ptr;
9273 offset = buffer->memory.size - canvas->cmd_offset;
9278 nk__draw_list_end(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
9285 NK_ASSERT(buffer);
9287 if (!buffer || !canvas)
9290 memory = (nk_byte*)buffer->memory.ptr;
9291 size = buffer->memory.size;
9299 const struct nk_buffer *buffer, const struct nk_draw_list *canvas)
9302 NK_ASSERT(buffer);
9304 if (!cmd || !buffer || !canvas)
9307 end = nk__draw_list_end(canvas, buffer);
9318 nk_buffer_alloc(list->buffer, NK_BUFFER_FRONT,
9323 void *memory = nk_buffer_memory(list->buffer);
9335 memory = nk_buffer_memory(list->buffer);
9350 nk_buffer_alloc(list->buffer, NK_BUFFER_BACK, cmd_size, cmd_align);
9354 nk_byte *memory = (nk_byte*)nk_buffer_memory(list->buffer);
9355 nk_size total = nk_buffer_total(list->buffer);
9379 memory = nk_buffer_memory(list->buffer);
9380 size = nk_buffer_total(list->buffer);
9992 nk_buffer_reset(list->buffer, NK_BUFFER_FRONT);
10131 points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
10142 points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
10532 const struct nk_buffer *buffer)
10534 return nk__draw_list_begin(&ctx->draw_list, buffer);
10537 nk__draw_end(const struct nk_context *ctx, const struct nk_buffer *buffer)
10539 return nk__draw_list_end(&ctx->draw_list, buffer);
10543 const struct nk_buffer *buffer, const struct nk_context *ctx)
10545 return nk__draw_list_next(cmd, buffer, &ctx->draw_list);
12308 unsigned char buffer[NK_TT_MAX_OVERSAMPLE];
12316 NK_MEMSET(buffer, 0, (nk_size)kernel_width);
12324 total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
12325 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
12331 total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
12332 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
12338 total += (unsigned int)pixels[i] - buffer[i & NK_TT__OVER_MASK];
12339 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
12345 total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
12346 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
12352 total += (unsigned int)(pixels[i] - buffer[i & NK_TT__OVER_MASK]);
12353 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i];
12361 total -= (unsigned int)(buffer[i & NK_TT__OVER_MASK]);
12371 unsigned char buffer[NK_TT_MAX_OVERSAMPLE];
12379 NK_MEMSET(buffer, 0, (nk_size)kernel_width);
12387 total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
12388 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
12394 total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
12395 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
12401 total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
12402 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
12408 total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
12409 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
12415 total += (unsigned int)(pixels[i*stride_in_bytes] - buffer[i & NK_TT__OVER_MASK]);
12416 buffer[(i+kernel_width) & NK_TT__OVER_MASK] = pixels[i*stride_in_bytes];
12424 total -= (unsigned int)(buffer[i & NK_TT__OVER_MASK]);
13323 nk_adler32(unsigned int adler32, unsigned char *buffer, unsigned int buflen)
13332 s1 += buffer[0]; s2 += s1;
13333 s1 += buffer[1]; s2 += s1;
13334 s1 += buffer[2]; s2 += s1;
13335 s1 += buffer[3]; s2 += s1;
13336 s1 += buffer[4]; s2 += s1;
13337 s1 += buffer[5]; s2 += s1;
13338 s1 += buffer[6]; s2 += s1;
13339 s1 += buffer[7]; s2 += s1;
13340 buffer += 8;
13343 s1 += *buffer++; s2 += s1;
15012 /* take memory from buffer and alloc fixed pool */
15015 /* create dynamic pool from buffer allocator */
15041 ctx->current->buffer.userdata = handle;
15133 nk_start_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer)
15136 NK_ASSERT(buffer);
15137 if (!ctx || !buffer) return;
15138 buffer->begin = ctx->memory.allocated;
15139 buffer->end = buffer->begin;
15140 buffer->last = buffer->begin;
15141 buffer->clip = nk_null_rect;
15148 nk_start_buffer(ctx, &win->buffer);
15158 /* save buffer fill state for popup */
15160 buf->begin = win->buffer.end;
15161 buf->end = win->buffer.end;
15162 buf->parent = win->buffer.last;
15175 buf->last = win->buffer.last;
15176 buf->end = win->buffer.end;
15179 nk_finish_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer)
15182 NK_ASSERT(buffer);
15183 if (!ctx || !buffer) return;
15184 buffer->end = ctx->memory.allocated;
15196 nk_finish_buffer(ctx, &win->buffer);
15209 nk_byte *buffer = 0;
15230 buffer = (nk_byte*)ctx->memory.memory.ptr;
15233 if (it->buffer.last == it->buffer.begin || (it->flags & NK_WINDOW_HIDDEN)||
15237 cmd = nk_ptr_add(struct nk_command, buffer, it->buffer.last);
15238 while (next && ((next->buffer.last == next->buffer.begin) ||
15242 if (next) cmd->next = next->buffer.begin;
15255 cmd = nk_ptr_add(struct nk_command, buffer, buf->last);
15270 nk_byte *buffer;
15275 buffer = (nk_byte*)ctx->memory.memory.ptr;
15281 while (iter && ((iter->buffer.begin == iter->buffer.end) ||
15285 return nk_ptr_add_const(struct nk_command, buffer, iter->buffer.begin);
15291 nk_byte *buffer;
15296 buffer = (nk_byte*)ctx->memory.memory.ptr;
15297 next = nk_ptr_add_const(struct nk_command, buffer, cmd->next);
15389 /* allocate new page element from back of fixed size memory buffer */
15421 /* if possible remove last element from back of fixed memory buffer */
15634 out = &win->buffer;
15637 win->buffer.userdata = ctx->userdata;
15741 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
15762 if (nk_do_button_symbol(&ws, &win->buffer, button,
15785 if (nk_do_button_symbol(&ws, &win->buffer, button, (layout->flags & NK_WINDOW_MINIMIZED)?
15823 nk_unify(&clip, &win->buffer.clip, layout->clip.x, layout->clip.y,
15850 out = &window->buffer;
16079 /* window is hidden so clear command buffer */
16081 nk_command_buffer_reset(&window->buffer);
16299 nk_command_buffer_init(&win->buffer, &ctx->memory, NK_CLIPPING_ON);
16521 return &ctx->current->buffer;
16861 popup->buffer = win->buffer;
16864 nk_push_scissor(&popup->buffer, nk_null_rect);
16925 nk_command_buffer_init(&popup->buffer, &ctx->memory, NK_CLIPPING_ON);
16961 popup->buffer = win->buffer;
16962 nk_push_scissor(&popup->buffer, nk_null_rect);
16966 win->buffer = popup->buffer;
17016 nk_push_scissor(&popup->buffer, nk_null_rect);
17019 win->buffer = popup->buffer;
17022 nk_push_scissor(&win->buffer, win->layout->clip);
17147 if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
17182 if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer, bounds,
17218 if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
17338 out = &win->buffer;
17408 if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, header,
17438 if (nk_do_button_image(&ctx->last_widget_state, &win->buffer, header,
17463 if (nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, header,
17488 if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
17521 if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer,
17657 out = &win->buffer;
18379 out = &win->buffer;
18426 nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT,
18432 nk_draw_image(&win->buffer, sym, img, nk_white);
18564 out = &win->buffer;
18608 if (nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT, button, in, style->font))
18626 nk_do_selectable_image(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT,
18628 } else nk_do_selectable(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT,
18715 panel.buffer = win->buffer;
18720 win->buffer = panel.buffer;
18721 win->buffer.clip = panel.layout->clip;
18784 pan.buffer = win->buffer;
18792 nk_push_scissor(&pan.buffer, clip);
18795 win->buffer = pan.buffer;
18796 nk_push_scissor(&win->buffer, parent->clip);
19367 nk_widget_text(&win->buffer, bounds, str, len, &text, alignment, style->font);
19394 nk_widget_text_wrap(&win->buffer, bounds, str, len, &text, style->font);
19665 nk_draw_image(&win->buffer, bounds, &img, nk_white);
19680 nk_draw_image(&win->buffer, bounds, &img, col);
20137 return nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
20187 ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds,
20189 nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button);
20214 return nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, bounds,
20247 return nk_do_button_image(&ctx->last_widget_state, &win->buffer, bounds,
20281 return nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
20328 return nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
20549 nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &active,
20644 nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active,
20886 return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds,
20915 return nk_do_selectable_image(&ctx->last_widget_state, &win->buffer, bounds,
20944 return nk_do_selectable_symbol(&ctx->last_widget_state, &win->buffer, bounds,
21223 *value = nk_do_slider(&ctx->last_widget_state, &win->buffer, bounds, min_value,
21381 *cur = nk_do_progress(&ctx->last_widget_state, &win->buffer, bounds,
22439 characters in different cases, the redo character buffer can
22440 fill up even though the undo buffer didn't */
22476 /* if the characters to store won't possibly fit in the buffer,
22484 /* if we don't have enough free characters in the buffer,
23166 /* handle case when cursor is at end of text buffer */
23440 edit->string.buffer.allocated = (nk_size)*len;
23443 *len = (int)edit->string.buffer.allocated;
23501 ret_flags = nk_do_edit(&ctx->last_widget_state, &win->buffer, bounds, flags,
23517 char *buffer, int max, nk_plugin_filter filter)
23520 int len = nk_strlen(buffer);
23521 result = nk_edit_string(ctx, flags, buffer, &len, max, filter);
23522 buffer[NK_MIN(NK_MAX(max-1,0), len)] = '\0';
23631 float inc_per_pixel, char *buffer, int *len,
23678 size = font->width(font->userdata, font->height, buffer, *len);
23681 dst = buffer;
23749 /* property has been activated so setup buffer */
23750 NK_MEMCPY(buffer, dst, (nk_size)*length);
23751 *cursor = nk_utf_len(buffer, *length);
23754 dst = buffer;
23765 text_edit->string.buffer.allocated = (nk_size)*length;
23766 text_edit->string.buffer.memory.size = NK_MAX_NUMBER_BUFFER;
23767 text_edit->string.buffer.memory.ptr = dst;
23768 text_edit->string.buffer.size = NK_MAX_NUMBER_BUFFER;
23783 buffer[*len] = '\0';
23787 variant->value.i = nk_strtoi(buffer, 0);
23791 nk_string_float_limit(buffer, NK_MAX_FLOAT_PRECISION);
23792 variant->value.f = nk_strtof(buffer, 0);
23796 nk_string_float_limit(buffer, NK_MAX_FLOAT_PRECISION);
23797 variant->value.d = nk_strtod(buffer, 0);
23851 char *buffer = 0;
23885 buffer = win->property.buffer;
23892 buffer = dummy_buffer;
23905 nk_do_property(&ctx->last_widget_state, &win->buffer, bounds, name,
23906 variant, inc_per_pixel, buffer, len, state, cursor, select_begin,
23913 NK_MEMCPY(win->property.buffer, buffer, (nk_size)*len);
24082 nk_draw_image(&win->buffer, bounds, &background->data.image, nk_white);
24084 nk_fill_rect(&win->buffer, bounds, style->rounding, style->border_color);
24085 nk_fill_rect(&win->buffer, nk_shrink_rect(bounds, style->border),
24133 struct nk_command_buffer *out = &win->buffer;
24201 struct nk_command_buffer *out = &win->buffer;
24532 return nk_do_color_picker(&ctx->last_widget_state, &win->buffer, color, fmt, bounds,
24630 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
24633 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
24634 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
24666 nk_widget_text(&win->buffer, label, selected, len, &text,
24670 nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
24716 nk_draw_image(&win->buffer, header, &background->data.image,nk_white);
24718 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
24719 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
24749 nk_fill_rect(&win->buffer, bounds, 0, color);
24752 nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
24801 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
24804 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
24805 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
24835 nk_draw_symbol(&win->buffer, symbol, bounds, sym_background, symbol_color,
24839 nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state,
24890 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
24893 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
24894 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
24919 nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
24927 nk_draw_symbol(&win->buffer, symbol, image, text.background, symbol_color,
24936 nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font);
24976 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
24978 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
24979 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
25009 nk_draw_image(&win->buffer, bounds, &img, nk_white);
25012 nk_draw_button_symbol(&win->buffer, &bounds, &content, ctx->last_widget_state,
25059 nk_draw_image(&win->buffer, header, &background->data.image, nk_white);
25062 nk_fill_rect(&win->buffer, header, style->combo.rounding, background->data.color);
25063 nk_stroke_rect(&win->buffer, header, style->combo.rounding, style->combo.border, style->combo.border_color);
25088 nk_draw_button_symbol(&win->buffer, &button, &content, ctx->last_widget_state,
25096 nk_draw_image(&win->buffer, image, &img, nk_white);
25104 nk_widget_text(&win->buffer, label, selected, len, &text, NK_TEXT_LEFT, style->font);
25489 /// or clear each passed buffer after calling nk_convert.
25536 /// - 2017/06/06 (1.38.5) - Fixed `nk_convert` return flag for command buffer.
25547 /// - 2017/04/09 (1.35.3) - Fixed buffer heap corruption.
25627 /// just use the vertex,element and command buffer + two pointer
25628 /// inside the command buffer retrieved by calls `nk__draw_begin`