vsgImGui: include/vsgImGui/imstb_textedit.h Source File

vsgImGui 0.5.0 VulkanSceneGraph, ImGui and ImPlot integration library

Loading...
Searching...
No Matches
imstb_textedit.h
1// [DEAR IMGUI]
2// This is a slightly modified version of stb_textedit.h 1.14.
3// Those changes would need to be pushed into nothings/stb:
4// - Fix in stb_textedit_discard_redo (see https://github.com/nothings/stb/issues/321)
5// - Fix in stb_textedit_find_charpos to handle last line (see https://github.com/ocornut/imgui/issues/6000 + #6783)
6// Grep for [DEAR IMGUI] to find the changes.
7// - Also renamed macros used or defined outside of IMSTB_TEXTEDIT_IMPLEMENTATION block from STB_TEXTEDIT_* to IMSTB_TEXTEDIT_*
8
9// stb_textedit.h - v1.14 - public domain - Sean Barrett
10// Development of this library was sponsored by RAD Game Tools
11//
12// This C header file implements the guts of a multi-line text-editing
13// widget; you implement display, word-wrapping, and low-level string
14// insertion/deletion, and stb_textedit will map user inputs into
15// insertions & deletions, plus updates to the cursor position,
16// selection state, and undo state.
17//
18// It is intended for use in games and other systems that need to build
19// their own custom widgets and which do not have heavy text-editing
20// requirements (this library is not recommended for use for editing large
21// texts, as its performance does not scale and it has limited undo).
22//
23// Non-trivial behaviors are modelled after Windows text controls.
24//
25//
26// LICENSE
27//
28// See end of file for license information.
29//
30//
31// DEPENDENCIES
32//
33// Uses the C runtime function 'memmove', which you can override
34// by defining IMSTB_TEXTEDIT_memmove before the implementation.
35// Uses no other functions. Performs no runtime allocations.
36//
37//
38// VERSION HISTORY
39//
40// 1.14 (2021-07-11) page up/down, various fixes
41// 1.13 (2019-02-07) fix bug in undo size management
42// 1.12 (2018-01-29) user can change STB_TEXTEDIT_KEYTYPE, fix redo to avoid crash
43// 1.11 (2017-03-03) fix HOME on last line, dragging off single-line textfield
44// 1.10 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
45// 1.9 (2016-08-27) customizable move-by-word
46// 1.8 (2016-04-02) better keyboard handling when mouse button is down
47// 1.7 (2015-09-13) change y range handling in case baseline is non-0
48// 1.6 (2015-04-15) allow STB_TEXTEDIT_memmove
49// 1.5 (2014-09-10) add support for secondary keys for OS X
50// 1.4 (2014-08-17) fix signed/unsigned warnings
51// 1.3 (2014-06-19) fix mouse clicking to round to nearest char boundary
52// 1.2 (2014-05-27) fix some RAD types that had crept into the new code
53// 1.1 (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE )
54// 1.0 (2012-07-26) improve documentation, initial public release
55// 0.3 (2012-02-24) bugfixes, single-line mode; insert mode
56// 0.2 (2011-11-28) fixes to undo/redo
57// 0.1 (2010-07-08) initial version
58//
59// ADDITIONAL CONTRIBUTORS
60//
61// Ulf Winklemann: move-by-word in 1.1
62// Fabian Giesen: secondary key inputs in 1.5
63// Martins Mozeiko: STB_TEXTEDIT_memmove in 1.6
64// Louis Schnellbach: page up/down in 1.14
65//
66// Bugfixes:
67// Scott Graham
68// Daniel Keller
69// Omar Cornut
70// Dan Thompson
71//
72// USAGE
73//
74// This file behaves differently depending on what symbols you define
75// before including it.
76//
77//
78// Header-file mode:
79//
80// If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this,
81// it will operate in "header file" mode. In this mode, it declares a
82// single public symbol, STB_TexteditState, which encapsulates the current
83// state of a text widget (except for the string, which you will store
84// separately).
85//
86// To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a
87// primitive type that defines a single character (e.g. char, wchar_t, etc).
88//
89// To save space or increase undo-ability, you can optionally define the
90// following things that are used by the undo system:
91//
92// STB_TEXTEDIT_POSITIONTYPE small int type encoding a valid cursor position
93// STB_TEXTEDIT_UNDOSTATECOUNT the number of undo states to allow
94// STB_TEXTEDIT_UNDOCHARCOUNT the number of characters to store in the undo buffer
95//
96// If you don't define these, they are set to permissive types and
97// moderate sizes. The undo system does no memory allocations, so
98// it grows STB_TexteditState by the worst-case storage which is (in bytes):
99//
100// [4 + 3 * sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATECOUNT
101// + sizeof(STB_TEXTEDIT_CHARTYPE) * STB_TEXTEDIT_UNDOCHARCOUNT
102//
103//
104// Implementation mode:
105//
106// If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it
107// will compile the implementation of the text edit widget, depending
108// on a large number of symbols which must be defined before the include.
109//
110// The implementation is defined only as static functions. You will then
111// need to provide your own APIs in the same file which will access the
112// static functions.
113//
114// The basic concept is that you provide a "string" object which
115// behaves like an array of characters. stb_textedit uses indices to
116// refer to positions in the string, implicitly representing positions
117// in the displayed textedit. This is true for both plain text and
118// rich text; even with rich text stb_truetype interacts with your
119// code as if there was an array of all the displayed characters.
120//
121// Symbols that must be the same in header-file and implementation mode:
122//
123// STB_TEXTEDIT_CHARTYPE the character type
124// STB_TEXTEDIT_POSITIONTYPE small type that is a valid cursor position
125// STB_TEXTEDIT_UNDOSTATECOUNT the number of undo states to allow
126// STB_TEXTEDIT_UNDOCHARCOUNT the number of characters to store in the undo buffer
127//
128// Symbols you must define for implementation mode:
129//
130// STB_TEXTEDIT_STRING the type of object representing a string being edited,
131// typically this is a wrapper object with other data you need
132//
133// STB_TEXTEDIT_STRINGLEN(obj) the length of the string (ideally O(1))
134// STB_TEXTEDIT_LAYOUTROW(&r,obj,n) returns the results of laying out a line of characters
135// starting from character #n (see discussion below)
136// STB_TEXTEDIT_GETWIDTH(obj,n,i) returns the pixel delta from the xpos of the i'th character
137// to the xpos of the i+1'th char for a line of characters
138// starting at character #n (i.e. accounts for kerning
139// with previous char)
140// STB_TEXTEDIT_KEYTOTEXT(k) maps a keyboard input to an insertable character
141// (return type is int, -1 means not valid to insert)
142// STB_TEXTEDIT_GETCHAR(obj,i) returns the i'th character of obj, 0-based
143// STB_TEXTEDIT_NEWLINE the character returned by _GETCHAR() we recognize
144// as manually wordwrapping for end-of-line positioning
145//
146// STB_TEXTEDIT_DELETECHARS(obj,i,n) delete n characters starting at i
147// STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n) insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
148//
149// STB_TEXTEDIT_K_SHIFT a power of two that is or'd in to a keyboard input to represent the shift key
150//
151// STB_TEXTEDIT_K_LEFT keyboard input to move cursor left
152// STB_TEXTEDIT_K_RIGHT keyboard input to move cursor right
153// STB_TEXTEDIT_K_UP keyboard input to move cursor up
154// STB_TEXTEDIT_K_DOWN keyboard input to move cursor down
155// STB_TEXTEDIT_K_PGUP keyboard input to move cursor up a page
156// STB_TEXTEDIT_K_PGDOWN keyboard input to move cursor down a page
157// STB_TEXTEDIT_K_LINESTART keyboard input to move cursor to start of line // e.g. HOME
158// STB_TEXTEDIT_K_LINEEND keyboard input to move cursor to end of line // e.g. END
159// STB_TEXTEDIT_K_TEXTSTART keyboard input to move cursor to start of text // e.g. ctrl-HOME
160// STB_TEXTEDIT_K_TEXTEND keyboard input to move cursor to end of text // e.g. ctrl-END
161// STB_TEXTEDIT_K_DELETE keyboard input to delete selection or character under cursor
162// STB_TEXTEDIT_K_BACKSPACE keyboard input to delete selection or character left of cursor
163// STB_TEXTEDIT_K_UNDO keyboard input to perform undo
164// STB_TEXTEDIT_K_REDO keyboard input to perform redo
165//
166// Optional:
167// STB_TEXTEDIT_K_INSERT keyboard input to toggle insert mode
168// STB_TEXTEDIT_IS_SPACE(ch) true if character is whitespace (e.g. 'isspace'),
169// required for default WORDLEFT/WORDRIGHT handlers
170// STB_TEXTEDIT_MOVEWORDLEFT(obj,i) custom handler for WORDLEFT, returns index to move cursor to
171// STB_TEXTEDIT_MOVEWORDRIGHT(obj,i) custom handler for WORDRIGHT, returns index to move cursor to
172// STB_TEXTEDIT_K_WORDLEFT keyboard input to move cursor left one word // e.g. ctrl-LEFT
173// STB_TEXTEDIT_K_WORDRIGHT keyboard input to move cursor right one word // e.g. ctrl-RIGHT
174// STB_TEXTEDIT_K_LINESTART2 secondary keyboard input to move cursor to start of line
175// STB_TEXTEDIT_K_LINEEND2 secondary keyboard input to move cursor to end of line
176// STB_TEXTEDIT_K_TEXTSTART2 secondary keyboard input to move cursor to start of text
177// STB_TEXTEDIT_K_TEXTEND2 secondary keyboard input to move cursor to end of text
178//
179// Keyboard input must be encoded as a single integer value; e.g. a character code
180// and some bitflags that represent shift states. to simplify the interface, SHIFT must
181// be a bitflag, so we can test the shifted state of cursor movements to allow selection,
182// i.e. (STB_TEXTEDIT_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow.
183//
184// You can encode other things, such as CONTROL or ALT, in additional bits, and
185// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example,
186// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN
187// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit,
188// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the
189// API below. The control keys will only match WM_KEYDOWN events because of the
190// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN
191// bit so it only decodes WM_CHAR events.
192//
193// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed
194// row of characters assuming they start on the i'th character--the width and
195// the height and the number of characters consumed. This allows this library
196// to traverse the entire layout incrementally. You need to compute word-wrapping
197// here.
198//
199// Each textfield keeps its own insert mode state, which is not how normal
200// applications work. To keep an app-wide insert mode, update/copy the
201// "insert_mode" field of STB_TexteditState before/after calling API functions.
202//
203// API
204//
205// void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
206//
207// void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
208// void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
209// int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
210// int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
211// void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXEDIT_KEYTYPE key)
212//
213// Each of these functions potentially updates the string and updates the
214// state.
215//
216// initialize_state:
217// set the textedit state to a known good default state when initially
218// constructing the textedit.
219//
220// click:
221// call this with the mouse x,y on a mouse down; it will update the cursor
222// and reset the selection start/end to the cursor point. the x,y must
223// be relative to the text widget, with (0,0) being the top left.
224//
225// drag:
226// call this with the mouse x,y on a mouse drag/up; it will update the
227// cursor and the selection end point
228//
229// cut:
230// call this to delete the current selection; returns true if there was
231// one. you should FIRST copy the current selection to the system paste buffer.
232// (To copy, just copy the current selection out of the string yourself.)
233//
234// paste:
235// call this to paste text at the current cursor point or over the current
236// selection if there is one.
237//
238// key:
239// call this for keyboard inputs sent to the textfield. you can use it
240// for "key down" events or for "translated" key events. if you need to
241// do both (as in Win32), or distinguish Unicode characters from control
242// inputs, set a high bit to distinguish the two; then you can define the
243// various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit
244// set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is
245// clear. STB_TEXTEDIT_KEYTYPE defaults to int, but you can #define it to
246// anything other type you wante before including.
247//
248//
249// When rendering, you can read the cursor position and selection state from
250// the STB_TexteditState.
251//
252//
253// Notes:
254//
255// This is designed to be usable in IMGUI, so it allows for the possibility of
256// running in an IMGUI that has NOT cached the multi-line layout. For this
257// reason, it provides an interface that is compatible with computing the
258// layout incrementally--we try to make sure we make as few passes through
259// as possible. (For example, to locate the mouse pointer in the text, we
260// could define functions that return the X and Y positions of characters
261// and binary search Y and then X, but if we're doing dynamic layout this
262// will run the layout algorithm many times, so instead we manually search
263// forward in one pass. Similar logic applies to e.g. up-arrow and
264// down-arrow movement.)
265//
266// If it's run in a widget that *has* cached the layout, then this is less
267// efficient, but it's not horrible on modern computers. But you wouldn't
268// want to edit million-line files with it.
269
270
277
278#ifndef INCLUDE_IMSTB_TEXTEDIT_H
279#define INCLUDE_IMSTB_TEXTEDIT_H
280
282//
283// STB_TexteditState
284//
285// Definition of STB_TexteditState which you should store
286// per-textfield; it includes cursor position, selection state,
287// and undo state.
288//
289
290#ifndef IMSTB_TEXTEDIT_UNDOSTATECOUNT
291#define IMSTB_TEXTEDIT_UNDOSTATECOUNT 99
292#endif
293#ifndef IMSTB_TEXTEDIT_UNDOCHARCOUNT
294#define IMSTB_TEXTEDIT_UNDOCHARCOUNT 999
295#endif
296#ifndef IMSTB_TEXTEDIT_CHARTYPE
297#define IMSTB_TEXTEDIT_CHARTYPE int
298#endif
299#ifndef IMSTB_TEXTEDIT_POSITIONTYPE
300#define IMSTB_TEXTEDIT_POSITIONTYPE int
301#endif
302
303 typedef struct
304{
305 // private data
306 IMSTB_TEXTEDIT_POSITIONTYPE where;
307 IMSTB_TEXTEDIT_POSITIONTYPE insert_length;
308 IMSTB_TEXTEDIT_POSITIONTYPE delete_length;
309 int char_storage;
310} StbUndoRecord;
311
312 typedef struct
313{
314 // private data
315 StbUndoRecord undo_rec [IMSTB_TEXTEDIT_UNDOSTATECOUNT];
316 IMSTB_TEXTEDIT_CHARTYPE undo_char[IMSTB_TEXTEDIT_UNDOCHARCOUNT];
317 short undo_point, redo_point;
318 int undo_char_point, redo_char_point;
319} StbUndoState;
320
321 typedef struct
322{
324 //
325 // public data
326 //
327
328 int cursor;
329 // position of the text cursor within the string
330
331 int select_start; // selection start point
332 int select_end;
333 // selection start and end point in characters; if equal, no selection.
334 // note that start may be less than or greater than end (e.g. when
335 // dragging the mouse, start is where the initial click was, and you
336 // can drag in either direction)
337
338 unsigned char insert_mode;
339 // each textfield keeps its own insert mode state. to keep an app-wide
340 // insert mode, copy this value in/out of the app state
341
342 int row_count_per_page;
343 // page size in number of row.
344 // this value MUST be set to >0 for pageup or pagedown in multilines documents.
345
347 //
348 // private data
349 //
350 unsigned char cursor_at_end_of_line; // not implemented yet
351 unsigned char initialized;
352 unsigned char has_preferred_x;
353 unsigned char single_line;
354 unsigned char padding1, padding2, padding3;
355 float preferred_x; // this determines where the cursor up/down tries to seek to along x
356 StbUndoState undostate;
357} STB_TexteditState;
358
359
361//
362// StbTexteditRow
363//
364// Result of layout query, used by stb_textedit to determine where
365// the text in each row is.
366
367// result of layout query
368 typedef struct
369{
370 float x0,x1; // starting x location, end x location (allows for align=right, etc)
371 float baseline_y_delta; // position of baseline relative to previous row's baseline
372 float ymin,ymax; // height of row above and below baseline
373 int num_chars;
374} StbTexteditRow;
375#endif //INCLUDE_IMSTB_TEXTEDIT_H
376
377
384
385
386// implementation isn't include-guarded, since it might have indirectly
387// included just the "header" portion
388#ifdef IMSTB_TEXTEDIT_IMPLEMENTATION
389
390#ifndef IMSTB_TEXTEDIT_memmove
391#include <string.h>
392#define IMSTB_TEXTEDIT_memmove memmove
393#endif
394
395
397//
398// Mouse input handling
399//
400
401// traverse the layout to locate the nearest character to a display position
402static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)
403{
404 StbTexteditRow r;
405 int n = STB_TEXTEDIT_STRINGLEN(str);
406 float base_y = 0, prev_x;
407 int i=0, k;
408
409 r.x0 = r.x1 = 0;
410 r.ymin = r.ymax = 0;
411 r.num_chars = 0;
412
413 // search rows to find one that straddles 'y'
414 while (i < n) {
415 STB_TEXTEDIT_LAYOUTROW(&r, str, i);
416 if (r.num_chars <= 0)
417 return n;
418
419 if (i==0 && y < base_y + r.ymin)
420 return 0;
421
422 if (y < base_y + r.ymax)
423 break;
424
425 i += r.num_chars;
426 base_y += r.baseline_y_delta;
427 }
428
429 // below all text, return 'after' last character
430 if (i >= n)
431 return n;
432
433 // check if it's before the beginning of the line
434 if (x < r.x0)
435 return i;
436
437 // check if it's before the end of the line
438 if (x < r.x1) {
439 // search characters in row for one that straddles 'x'
440 prev_x = r.x0;
441 for (k=0; k < r.num_chars; ++k) {
442 float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
443 if (x < prev_x+w) {
444 if (x < prev_x+w/2)
445 return k+i;
446 else
447 return k+i+1;
448 }
449 prev_x += w;
450 }
451 // shouldn't happen, but if it does, fall through to end-of-line case
452 }
453
454 // if the last character is a newline, return that. otherwise return 'after' the last character
455 if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
456 return i+r.num_chars-1;
457 else
458 return i+r.num_chars;
459}
460
461// API click: on mouse down, move the cursor to the clicked location, and reset the selection
462static void stb_textedit_click(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
463{
464 // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
465 // goes off the top or bottom of the text
466 if( state->single_line )
467 {
468 StbTexteditRow r;
469 STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
470 y = r.ymin;
471 }
472
473 state->cursor = stb_text_locate_coord(str, x, y);
474 state->select_start = state->cursor;
475 state->select_end = state->cursor;
476 state->has_preferred_x = 0;
477}
478
479// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
480static void stb_textedit_drag(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
481{
482 int p = 0;
483
484 // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
485 // goes off the top or bottom of the text
486 if( state->single_line )
487 {
488 StbTexteditRow r;
489 STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
490 y = r.ymin;
491 }
492
493 if (state->select_start == state->select_end)
494 state->select_start = state->cursor;
495
496 p = stb_text_locate_coord(str, x, y);
497 state->cursor = state->select_end = p;
498}
499
501//
502// Keyboard input handling
503//
504
505// forward declarations
506static void stb_text_undo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state);
507static void stb_text_redo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state);
508static void stb_text_makeundo_delete(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
509static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);
510static void stb_text_makeundo_replace(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);
511
512typedef struct
513{
514 float x,y; // position of n'th character
515 float height; // height of line
516 int first_char, length; // first char of row, and length
517 int prev_first; // first char of previous row
518} StbFindState;
519
520// find the x/y location of a character, and remember info about the previous row in
521// case we get a move-up event (for page up, we'll have to rescan)
522static void stb_textedit_find_charpos(StbFindState *find, IMSTB_TEXTEDIT_STRING *str, int n, int single_line)
523{
524 StbTexteditRow r;
525 int prev_start = 0;
526 int z = STB_TEXTEDIT_STRINGLEN(str);
527 int i=0, first;
528
529 if (n == z && single_line) {
530 // special case if it's at the end (may not be needed?)
531 STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
532 find->y = 0;
533 find->first_char = 0;
534 find->length = z;
535 find->height = r.ymax - r.ymin;
536 find->x = r.x1;
537 return;
538 }
539
540 // search rows to find the one that straddles character n
541 find->y = 0;
542
543 for(;;) {
544 STB_TEXTEDIT_LAYOUTROW(&r, str, i);
545 if (n < i + r.num_chars)
546 break;
547 if (i + r.num_chars == z && z > 0 && STB_TEXTEDIT_GETCHAR(str, z - 1) != STB_TEXTEDIT_NEWLINE) // [DEAR IMGUI] special handling for last line
548 break; // [DEAR IMGUI]
549 prev_start = i;
550 i += r.num_chars;
551 find->y += r.baseline_y_delta;
552 if (i == z) // [DEAR IMGUI]
553 {
554 r.num_chars = 0; // [DEAR IMGUI]
555 break; // [DEAR IMGUI]
556 }
557 }
558
559 find->first_char = first = i;
560 find->length = r.num_chars;
561 find->height = r.ymax - r.ymin;
562 find->prev_first = prev_start;
563
564 // now scan to find xpos
565 find->x = r.x0;
566 for (i=0; first+i < n; ++i)
567 find->x += STB_TEXTEDIT_GETWIDTH(str, first, i);
568}
569
570#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)
571
572// make the selection/cursor state valid if client altered the string
573static void stb_textedit_clamp(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
574{
575 int n = STB_TEXTEDIT_STRINGLEN(str);
576 if (STB_TEXT_HAS_SELECTION(state)) {
577 if (state->select_start > n) state->select_start = n;
578 if (state->select_end > n) state->select_end = n;
579 // if clamping forced them to be equal, move the cursor to match
580 if (state->select_start == state->select_end)
581 state->cursor = state->select_start;
582 }
583 if (state->cursor > n) state->cursor = n;
584}
585
586// delete characters while updating undo
587static void stb_textedit_delete(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
588{
589 stb_text_makeundo_delete(str, state, where, len);
590 STB_TEXTEDIT_DELETECHARS(str, where, len);
591 state->has_preferred_x = 0;
592}
593
594// delete the section
595static void stb_textedit_delete_selection(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
596{
597 stb_textedit_clamp(str, state);
598 if (STB_TEXT_HAS_SELECTION(state)) {
599 if (state->select_start < state->select_end) {
600 stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start);
601 state->select_end = state->cursor = state->select_start;
602 } else {
603 stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end);
604 state->select_start = state->cursor = state->select_end;
605 }
606 state->has_preferred_x = 0;
607 }
608}
609
610// canoncialize the selection so start <= end
611static void stb_textedit_sortselection(STB_TexteditState *state)
612{
613 if (state->select_end < state->select_start) {
614 int temp = state->select_end;
615 state->select_end = state->select_start;
616 state->select_start = temp;
617 }
618}
619
620// move cursor to first character of selection
621static void stb_textedit_move_to_first(STB_TexteditState *state)
622{
623 if (STB_TEXT_HAS_SELECTION(state)) {
624 stb_textedit_sortselection(state);
625 state->cursor = state->select_start;
626 state->select_end = state->select_start;
627 state->has_preferred_x = 0;
628 }
629}
630
631// move cursor to last character of selection
632static void stb_textedit_move_to_last(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
633{
634 if (STB_TEXT_HAS_SELECTION(state)) {
635 stb_textedit_sortselection(state);
636 stb_textedit_clamp(str, state);
637 state->cursor = state->select_end;
638 state->select_start = state->select_end;
639 state->has_preferred_x = 0;
640 }
641}
642
643#ifdef STB_TEXTEDIT_IS_SPACE
644static int is_word_boundary( IMSTB_TEXTEDIT_STRING *str, int idx )
645{
646 return idx > 0 ? (STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str,idx-1) ) && !STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str, idx) ) ) : 1;
647}
648
649#ifndef STB_TEXTEDIT_MOVEWORDLEFT
650static int stb_textedit_move_to_word_previous( IMSTB_TEXTEDIT_STRING *str, int c )
651{
652 --c; // always move at least one character
653 while( c >= 0 && !is_word_boundary( str, c ) )
654 --c;
655
656 if( c < 0 )
657 c = 0;
658
659 return c;
660}
661#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous
662#endif
663
664#ifndef STB_TEXTEDIT_MOVEWORDRIGHT
665static int stb_textedit_move_to_word_next( IMSTB_TEXTEDIT_STRING *str, int c )
666{
667 const int len = STB_TEXTEDIT_STRINGLEN(str);
668 ++c; // always move at least one character
669 while( c < len && !is_word_boundary( str, c ) )
670 ++c;
671
672 if( c > len )
673 c = len;
674
675 return c;
676}
677#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next
678#endif
679
680#endif
681
682// update selection and cursor to match each other
683static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
684{
685 if (!STB_TEXT_HAS_SELECTION(state))
686 state->select_start = state->select_end = state->cursor;
687 else
688 state->cursor = state->select_end;
689}
690
691// API cut: delete selection
692static int stb_textedit_cut(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
693{
694 if (STB_TEXT_HAS_SELECTION(state)) {
695 stb_textedit_delete_selection(str,state); // implicitly clamps
696 state->has_preferred_x = 0;
697 return 1;
698 }
699 return 0;
700}
701
702// API paste: replace existing selection with passed-in text
703static int stb_textedit_paste_internal(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, IMSTB_TEXTEDIT_CHARTYPE *text, int len)
704{
705 // if there's a selection, the paste should delete it
706 stb_textedit_clamp(str, state);
707 stb_textedit_delete_selection(str,state);
708 // try to insert the characters
709 if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
710 stb_text_makeundo_insert(state, state->cursor, len);
711 state->cursor += len;
712 state->has_preferred_x = 0;
713 return 1;
714 }
715 // note: paste failure will leave deleted selection, may be restored with an undo (see https://github.com/nothings/stb/issues/734 for details)
716 return 0;
717}
718
719#ifndef STB_TEXTEDIT_KEYTYPE
720#define STB_TEXTEDIT_KEYTYPE int
721#endif
722
723// API key: process a keyboard input
724static void stb_textedit_key(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)
725{
726retry:
727 switch (key) {
728 default: {
729 int c = STB_TEXTEDIT_KEYTOTEXT(key);
730 if (c > 0) {
731 IMSTB_TEXTEDIT_CHARTYPE ch = (IMSTB_TEXTEDIT_CHARTYPE) c;
732
733 // can't add newline in single-line mode
734 if (c == '\n' && state->single_line)
735 break;
736
737 if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) {
738 stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
739 STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
740 if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
741 ++state->cursor;
742 state->has_preferred_x = 0;
743 }
744 } else {
745 stb_textedit_delete_selection(str,state); // implicitly clamps
746 if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
747 stb_text_makeundo_insert(state, state->cursor, 1);
748 ++state->cursor;
749 state->has_preferred_x = 0;
750 }
751 }
752 }
753 break;
754 }
755
756#ifdef STB_TEXTEDIT_K_INSERT
757 case STB_TEXTEDIT_K_INSERT:
758 state->insert_mode = !state->insert_mode;
759 break;
760#endif
761
762 case STB_TEXTEDIT_K_UNDO:
763 stb_text_undo(str, state);
764 state->has_preferred_x = 0;
765 break;
766
767 case STB_TEXTEDIT_K_REDO:
768 stb_text_redo(str, state);
769 state->has_preferred_x = 0;
770 break;
771
772 case STB_TEXTEDIT_K_LEFT:
773 // if currently there's a selection, move cursor to start of selection
774 if (STB_TEXT_HAS_SELECTION(state))
775 stb_textedit_move_to_first(state);
776 else
777 if (state->cursor > 0)
778 --state->cursor;
779 state->has_preferred_x = 0;
780 break;
781
782 case STB_TEXTEDIT_K_RIGHT:
783 // if currently there's a selection, move cursor to end of selection
784 if (STB_TEXT_HAS_SELECTION(state))
785 stb_textedit_move_to_last(str, state);
786 else
787 ++state->cursor;
788 stb_textedit_clamp(str, state);
789 state->has_preferred_x = 0;
790 break;
791
792 case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT:
793 stb_textedit_clamp(str, state);
794 stb_textedit_prep_selection_at_cursor(state);
795 // move selection left
796 if (state->select_end > 0)
797 --state->select_end;
798 state->cursor = state->select_end;
799 state->has_preferred_x = 0;
800 break;
801
802#ifdef STB_TEXTEDIT_MOVEWORDLEFT
803 case STB_TEXTEDIT_K_WORDLEFT:
804 if (STB_TEXT_HAS_SELECTION(state))
805 stb_textedit_move_to_first(state);
806 else {
807 state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
808 stb_textedit_clamp( str, state );
809 }
810 break;
811
812 case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT:
813 if( !STB_TEXT_HAS_SELECTION( state ) )
814 stb_textedit_prep_selection_at_cursor(state);
815
816 state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
817 state->select_end = state->cursor;
818
819 stb_textedit_clamp( str, state );
820 break;
821#endif
822
823#ifdef STB_TEXTEDIT_MOVEWORDRIGHT
824 case STB_TEXTEDIT_K_WORDRIGHT:
825 if (STB_TEXT_HAS_SELECTION(state))
826 stb_textedit_move_to_last(str, state);
827 else {
828 state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
829 stb_textedit_clamp( str, state );
830 }
831 break;
832
833 case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT:
834 if( !STB_TEXT_HAS_SELECTION( state ) )
835 stb_textedit_prep_selection_at_cursor(state);
836
837 state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
838 state->select_end = state->cursor;
839
840 stb_textedit_clamp( str, state );
841 break;
842#endif
843
844 case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT:
845 stb_textedit_prep_selection_at_cursor(state);
846 // move selection right
847 ++state->select_end;
848 stb_textedit_clamp(str, state);
849 state->cursor = state->select_end;
850 state->has_preferred_x = 0;
851 break;
852
853 case STB_TEXTEDIT_K_DOWN:
854 case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT:
855 case STB_TEXTEDIT_K_PGDOWN:
856 case STB_TEXTEDIT_K_PGDOWN | STB_TEXTEDIT_K_SHIFT: {
857 StbFindState find;
858 StbTexteditRow row;
859 int i, j, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
860 int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGDOWN;
861 int row_count = is_page ? state->row_count_per_page : 1;
862
863 if (!is_page && state->single_line) {
864 // on windows, up&down in single-line behave like left&right
865 key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT);
866 goto retry;
867 }
868
869 if (sel)
870 stb_textedit_prep_selection_at_cursor(state);
871 else if (STB_TEXT_HAS_SELECTION(state))
872 stb_textedit_move_to_last(str, state);
873
874 // compute current position of cursor point
875 stb_textedit_clamp(str, state);
876 stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
877
878 for (j = 0; j < row_count; ++j) {
879 float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
880 int start = find.first_char + find.length;
881
882 if (find.length == 0)
883 break;
884
885 // [DEAR IMGUI]
886 // going down while being on the last line shouldn't bring us to that line end
887 if (STB_TEXTEDIT_GETCHAR(str, find.first_char + find.length - 1) != STB_TEXTEDIT_NEWLINE)
888 break;
889
890 // now find character position down a row
891 state->cursor = start;
892 STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
893 x = row.x0;
894 for (i=0; i < row.num_chars; ++i) {
895 float dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
896 #ifdef IMSTB_TEXTEDIT_GETWIDTH_NEWLINE
897 if (dx == IMSTB_TEXTEDIT_GETWIDTH_NEWLINE)
898 break;
899 #endif
900 x += dx;
901 if (x > goal_x)
902 break;
903 ++state->cursor;
904 }
905 stb_textedit_clamp(str, state);
906
907 state->has_preferred_x = 1;
908 state->preferred_x = goal_x;
909
910 if (sel)
911 state->select_end = state->cursor;
912
913 // go to next line
914 find.first_char = find.first_char + find.length;
915 find.length = row.num_chars;
916 }
917 break;
918 }
919
920 case STB_TEXTEDIT_K_UP:
921 case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT:
922 case STB_TEXTEDIT_K_PGUP:
923 case STB_TEXTEDIT_K_PGUP | STB_TEXTEDIT_K_SHIFT: {
924 StbFindState find;
925 StbTexteditRow row;
926 int i, j, prev_scan, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
927 int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGUP;
928 int row_count = is_page ? state->row_count_per_page : 1;
929
930 if (!is_page && state->single_line) {
931 // on windows, up&down become left&right
932 key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT);
933 goto retry;
934 }
935
936 if (sel)
937 stb_textedit_prep_selection_at_cursor(state);
938 else if (STB_TEXT_HAS_SELECTION(state))
939 stb_textedit_move_to_first(state);
940
941 // compute current position of cursor point
942 stb_textedit_clamp(str, state);
943 stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
944
945 for (j = 0; j < row_count; ++j) {
946 float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
947
948 // can only go up if there's a previous row
949 if (find.prev_first == find.first_char)
950 break;
951
952 // now find character position up a row
953 state->cursor = find.prev_first;
954 STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
955 x = row.x0;
956 for (i=0; i < row.num_chars; ++i) {
957 float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
958 #ifdef IMSTB_TEXTEDIT_GETWIDTH_NEWLINE
959 if (dx == IMSTB_TEXTEDIT_GETWIDTH_NEWLINE)
960 break;
961 #endif
962 x += dx;
963 if (x > goal_x)
964 break;
965 ++state->cursor;
966 }
967 stb_textedit_clamp(str, state);
968
969 state->has_preferred_x = 1;
970 state->preferred_x = goal_x;
971
972 if (sel)
973 state->select_end = state->cursor;
974
975 // go to previous line
976 // (we need to scan previous line the hard way. maybe we could expose this as a new API function?)
977 prev_scan = find.prev_first > 0 ? find.prev_first - 1 : 0;
978 while (prev_scan > 0 && STB_TEXTEDIT_GETCHAR(str, prev_scan - 1) != STB_TEXTEDIT_NEWLINE)
979 --prev_scan;
980 find.first_char = find.prev_first;
981 find.prev_first = prev_scan;
982 }
983 break;
984 }
985
986 case STB_TEXTEDIT_K_DELETE:
987 case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT:
988 if (STB_TEXT_HAS_SELECTION(state))
989 stb_textedit_delete_selection(str, state);
990 else {
991 int n = STB_TEXTEDIT_STRINGLEN(str);
992 if (state->cursor < n)
993 stb_textedit_delete(str, state, state->cursor, 1);
994 }
995 state->has_preferred_x = 0;
996 break;
997
998 case STB_TEXTEDIT_K_BACKSPACE:
999 case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT:
1000 if (STB_TEXT_HAS_SELECTION(state))
1001 stb_textedit_delete_selection(str, state);
1002 else {
1003 stb_textedit_clamp(str, state);
1004 if (state->cursor > 0) {
1005 stb_textedit_delete(str, state, state->cursor-1, 1);
1006 --state->cursor;
1007 }
1008 }
1009 state->has_preferred_x = 0;
1010 break;
1011
1012#ifdef STB_TEXTEDIT_K_TEXTSTART2
1013 case STB_TEXTEDIT_K_TEXTSTART2:
1014#endif
1015 case STB_TEXTEDIT_K_TEXTSTART:
1016 state->cursor = state->select_start = state->select_end = 0;
1017 state->has_preferred_x = 0;
1018 break;
1019
1020#ifdef STB_TEXTEDIT_K_TEXTEND2
1021 case STB_TEXTEDIT_K_TEXTEND2:
1022#endif
1023 case STB_TEXTEDIT_K_TEXTEND:
1024 state->cursor = STB_TEXTEDIT_STRINGLEN(str);
1025 state->select_start = state->select_end = 0;
1026 state->has_preferred_x = 0;
1027 break;
1028
1029#ifdef STB_TEXTEDIT_K_TEXTSTART2
1030 case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT:
1031#endif
1032 case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT:
1033 stb_textedit_prep_selection_at_cursor(state);
1034 state->cursor = state->select_end = 0;
1035 state->has_preferred_x = 0;
1036 break;
1037
1038#ifdef STB_TEXTEDIT_K_TEXTEND2
1039 case STB_TEXTEDIT_K_TEXTEND2 | STB_TEXTEDIT_K_SHIFT:
1040#endif
1041 case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT:
1042 stb_textedit_prep_selection_at_cursor(state);
1043 state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str);
1044 state->has_preferred_x = 0;
1045 break;
1046
1047
1048#ifdef STB_TEXTEDIT_K_LINESTART2
1049 case STB_TEXTEDIT_K_LINESTART2:
1050#endif
1051 case STB_TEXTEDIT_K_LINESTART:
1052 stb_textedit_clamp(str, state);
1053 stb_textedit_move_to_first(state);
1054 if (state->single_line)
1055 state->cursor = 0;
1056 else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
1057 --state->cursor;
1058 state->has_preferred_x = 0;
1059 break;
1060
1061#ifdef STB_TEXTEDIT_K_LINEEND2
1062 case STB_TEXTEDIT_K_LINEEND2:
1063#endif
1064 case STB_TEXTEDIT_K_LINEEND: {
1065 int n = STB_TEXTEDIT_STRINGLEN(str);
1066 stb_textedit_clamp(str, state);
1067 stb_textedit_move_to_first(state);
1068 if (state->single_line)
1069 state->cursor = n;
1070 else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
1071 ++state->cursor;
1072 state->has_preferred_x = 0;
1073 break;
1074 }
1075
1076#ifdef STB_TEXTEDIT_K_LINESTART2
1077 case STB_TEXTEDIT_K_LINESTART2 | STB_TEXTEDIT_K_SHIFT:
1078#endif
1079 case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT:
1080 stb_textedit_clamp(str, state);
1081 stb_textedit_prep_selection_at_cursor(state);
1082 if (state->single_line)
1083 state->cursor = 0;
1084 else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
1085 --state->cursor;
1086 state->select_end = state->cursor;
1087 state->has_preferred_x = 0;
1088 break;
1089
1090#ifdef STB_TEXTEDIT_K_LINEEND2
1091 case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT:
1092#endif
1093 case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: {
1094 int n = STB_TEXTEDIT_STRINGLEN(str);
1095 stb_textedit_clamp(str, state);
1096 stb_textedit_prep_selection_at_cursor(state);
1097 if (state->single_line)
1098 state->cursor = n;
1099 else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
1100 ++state->cursor;
1101 state->select_end = state->cursor;
1102 state->has_preferred_x = 0;
1103 break;
1104 }
1105 }
1106}
1107
1109//
1110// Undo processing
1111//
1112// @OPTIMIZE: the undo/redo buffer should be circular
1113
1114static void stb_textedit_flush_redo(StbUndoState *state)
1115{
1116 state->redo_point = IMSTB_TEXTEDIT_UNDOSTATECOUNT;
1117 state->redo_char_point = IMSTB_TEXTEDIT_UNDOCHARCOUNT;
1118}
1119
1120// discard the oldest entry in the undo list
1121static void stb_textedit_discard_undo(StbUndoState *state)
1122{
1123 if (state->undo_point > 0) {
1124 // if the 0th undo state has characters, clean those up
1125 if (state->undo_rec[0].char_storage >= 0) {
1126 int n = state->undo_rec[0].insert_length, i;
1127 // delete n characters from all other records
1128 state->undo_char_point -= n;
1129 IMSTB_TEXTEDIT_memmove(state->undo_char, state->undo_char + n, (size_t) (state->undo_char_point*sizeof(IMSTB_TEXTEDIT_CHARTYPE)));
1130 for (i=0; i < state->undo_point; ++i)
1131 if (state->undo_rec[i].char_storage >= 0)
1132 state->undo_rec[i].char_storage -= n; // @OPTIMIZE: get rid of char_storage and infer it
1133 }
1134 --state->undo_point;
1135 IMSTB_TEXTEDIT_memmove(state->undo_rec, state->undo_rec+1, (size_t) (state->undo_point*sizeof(state->undo_rec[0])));
1136 }
1137}
1138
1139// discard the oldest entry in the redo list--it's bad if this
1140// ever happens, but because undo & redo have to store the actual
1141// characters in different cases, the redo character buffer can
1142// fill up even though the undo buffer didn't
1143static void stb_textedit_discard_redo(StbUndoState *state)
1144{
1145 int k = IMSTB_TEXTEDIT_UNDOSTATECOUNT-1;
1146
1147 if (state->redo_point <= k) {
1148 // if the k'th undo state has characters, clean those up
1149 if (state->undo_rec[k].char_storage >= 0) {
1150 int n = state->undo_rec[k].insert_length, i;
1151 // move the remaining redo character data to the end of the buffer
1152 state->redo_char_point += n;
1153 IMSTB_TEXTEDIT_memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point-n, (size_t) ((IMSTB_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point)*sizeof(IMSTB_TEXTEDIT_CHARTYPE)));
1154 // adjust the position of all the other records to account for above memmove
1155 for (i=state->redo_point; i < k; ++i)
1156 if (state->undo_rec[i].char_storage >= 0)
1157 state->undo_rec[i].char_storage += n;
1158 }
1159 // now move all the redo records towards the end of the buffer; the first one is at 'redo_point'
1160 // [DEAR IMGUI]
1161 size_t move_size = (size_t)((IMSTB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point - 1) * sizeof(state->undo_rec[0]));
1162 const char* buf_begin = (char*)state->undo_rec; (void)buf_begin;
1163 const char* buf_end = (char*)state->undo_rec + sizeof(state->undo_rec); (void)buf_end;
1164 IM_ASSERT(((char*)(state->undo_rec + state->redo_point)) >= buf_begin);
1165 IM_ASSERT(((char*)(state->undo_rec + state->redo_point + 1) + move_size) <= buf_end);
1166 IMSTB_TEXTEDIT_memmove(state->undo_rec + state->redo_point+1, state->undo_rec + state->redo_point, move_size);
1167
1168 // now move redo_point to point to the new one
1169 ++state->redo_point;
1170 }
1171}
1172
1173static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)
1174{
1175 // any time we create a new undo record, we discard redo
1176 stb_textedit_flush_redo(state);
1177
1178 // if we have no free records, we have to make room, by sliding the
1179 // existing records down
1180 if (state->undo_point == IMSTB_TEXTEDIT_UNDOSTATECOUNT)
1181 stb_textedit_discard_undo(state);
1182
1183 // if the characters to store won't possibly fit in the buffer, we can't undo
1184 if (numchars > IMSTB_TEXTEDIT_UNDOCHARCOUNT) {
1185 state->undo_point = 0;
1186 state->undo_char_point = 0;
1187 return NULL;
1188 }
1189
1190 // if we don't have enough free characters in the buffer, we have to make room
1191 while (state->undo_char_point + numchars > IMSTB_TEXTEDIT_UNDOCHARCOUNT)
1192 stb_textedit_discard_undo(state);
1193
1194 return &state->undo_rec[state->undo_point++];
1195}
1196
1197static IMSTB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
1198{
1199 StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
1200 if (r == NULL)
1201 return NULL;
1202
1203 r->where = pos;
1204 r->insert_length = (IMSTB_TEXTEDIT_POSITIONTYPE) insert_len;
1205 r->delete_length = (IMSTB_TEXTEDIT_POSITIONTYPE) delete_len;
1206
1207 if (insert_len == 0) {
1208 r->char_storage = -1;
1209 return NULL;
1210 } else {
1211 r->char_storage = state->undo_char_point;
1212 state->undo_char_point += insert_len;
1213 return &state->undo_char[r->char_storage];
1214 }
1215}
1216
1217static void stb_text_undo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
1218{
1219 StbUndoState *s = &state->undostate;
1220 StbUndoRecord u, *r;
1221 if (s->undo_point == 0)
1222 return;
1223
1224 // we need to do two things: apply the undo record, and create a redo record
1225 u = s->undo_rec[s->undo_point-1];
1226 r = &s->undo_rec[s->redo_point-1];
1227 r->char_storage = -1;
1228
1229 r->insert_length = u.delete_length;
1230 r->delete_length = u.insert_length;
1231 r->where = u.where;
1232
1233 if (u.delete_length) {
1234 // if the undo record says to delete characters, then the redo record will
1235 // need to re-insert the characters that get deleted, so we need to store
1236 // them.
1237
1238 // there are three cases:
1239 // there's enough room to store the characters
1240 // characters stored for *redoing* don't leave room for redo
1241 // characters stored for *undoing* don't leave room for redo
1242 // if the last is true, we have to bail
1243
1244 if (s->undo_char_point + u.delete_length >= IMSTB_TEXTEDIT_UNDOCHARCOUNT) {
1245 // the undo records take up too much character space; there's no space to store the redo characters
1246 r->insert_length = 0;
1247 } else {
1248 int i;
1249
1250 // there's definitely room to store the characters eventually
1251 while (s->undo_char_point + u.delete_length > s->redo_char_point) {
1252 // should never happen:
1253 if (s->redo_point == IMSTB_TEXTEDIT_UNDOSTATECOUNT)
1254 return;
1255 // there's currently not enough room, so discard a redo record
1256 stb_textedit_discard_redo(s);
1257 }
1258 r = &s->undo_rec[s->redo_point-1];
1259
1260 r->char_storage = s->redo_char_point - u.delete_length;
1261 s->redo_char_point = s->redo_char_point - u.delete_length;
1262
1263 // now save the characters
1264 for (i=0; i < u.delete_length; ++i)
1265 s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i);
1266 }
1267
1268 // now we can carry out the deletion
1269 STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length);
1270 }
1271
1272 // check type of recorded action:
1273 if (u.insert_length) {
1274 // easy case: was a deletion, so we need to insert n characters
1275 STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
1276 s->undo_char_point -= u.insert_length;
1277 }
1278
1279 state->cursor = u.where + u.insert_length;
1280
1281 s->undo_point--;
1282 s->redo_point--;
1283}
1284
1285static void stb_text_redo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
1286{
1287 StbUndoState *s = &state->undostate;
1288 StbUndoRecord *u, r;
1289 if (s->redo_point == IMSTB_TEXTEDIT_UNDOSTATECOUNT)
1290 return;
1291
1292 // we need to do two things: apply the redo record, and create an undo record
1293 u = &s->undo_rec[s->undo_point];
1294 r = s->undo_rec[s->redo_point];
1295
1296 // we KNOW there must be room for the undo record, because the redo record
1297 // was derived from an undo record
1298
1299 u->delete_length = r.insert_length;
1300 u->insert_length = r.delete_length;
1301 u->where = r.where;
1302 u->char_storage = -1;
1303
1304 if (r.delete_length) {
1305 // the redo record requires us to delete characters, so the undo record
1306 // needs to store the characters
1307
1308 if (s->undo_char_point + u->insert_length > s->redo_char_point) {
1309 u->insert_length = 0;
1310 u->delete_length = 0;
1311 } else {
1312 int i;
1313 u->char_storage = s->undo_char_point;
1314 s->undo_char_point = s->undo_char_point + u->insert_length;
1315
1316 // now save the characters
1317 for (i=0; i < u->insert_length; ++i)
1318 s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i);
1319 }
1320
1321 STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length);
1322 }
1323
1324 if (r.insert_length) {
1325 // easy case: need to insert n characters
1326 STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
1327 s->redo_char_point += r.insert_length;
1328 }
1329
1330 state->cursor = r.where + r.insert_length;
1331
1332 s->undo_point++;
1333 s->redo_point++;
1334}
1335
1336static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)
1337{
1338 stb_text_createundo(&state->undostate, where, 0, length);
1339}
1340
1341static void stb_text_makeundo_delete(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
1342{
1343 int i;
1344 IMSTB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0);
1345 if (p) {
1346 for (i=0; i < length; ++i)
1347 p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
1348 }
1349}
1350
1351static void stb_text_makeundo_replace(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
1352{
1353 int i;
1354 IMSTB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
1355 if (p) {
1356 for (i=0; i < old_length; ++i)
1357 p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
1358 }
1359}
1360
1361// reset the state to default
1362static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)
1363{
1364 state->undostate.undo_point = 0;
1365 state->undostate.undo_char_point = 0;
1366 state->undostate.redo_point = IMSTB_TEXTEDIT_UNDOSTATECOUNT;
1367 state->undostate.redo_char_point = IMSTB_TEXTEDIT_UNDOCHARCOUNT;
1368 state->select_end = state->select_start = 0;
1369 state->cursor = 0;
1370 state->has_preferred_x = 0;
1371 state->preferred_x = 0;
1372 state->cursor_at_end_of_line = 0;
1373 state->initialized = 1;
1374 state->single_line = (unsigned char) is_single_line;
1375 state->insert_mode = 0;
1376 state->row_count_per_page = 0;
1377}
1378
1379// API initialize
1380static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
1381{
1382 stb_textedit_clear_state(state, is_single_line);
1383}
1384
1385#if defined(__GNUC__) || defined(__clang__)
1386#pragma GCC diagnostic push
1387#pragma GCC diagnostic ignored "-Wcast-qual"
1388#endif
1389
1390static int stb_textedit_paste(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, IMSTB_TEXTEDIT_CHARTYPE const *ctext, int len)
1391{
1392 return stb_textedit_paste_internal(str, state, (IMSTB_TEXTEDIT_CHARTYPE *) ctext, len);
1393}
1394
1395#if defined(__GNUC__) || defined(__clang__)
1396#pragma GCC diagnostic pop
1397#endif
1398
1399#endif//IMSTB_TEXTEDIT_IMPLEMENTATION
1400
1401/*
1402------------------------------------------------------------------------------
1403This software is available under 2 licenses -- choose whichever you prefer.
1404------------------------------------------------------------------------------
1405ALTERNATIVE A - MIT License
1406Copyright (c) 2017 Sean Barrett
1407Permission is hereby granted, free of charge, to any person obtaining a copy of
1408this software and associated documentation files (the "Software"), to deal in
1409the Software without restriction, including without limitation the rights to
1410use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
1411of the Software, and to permit persons to whom the Software is furnished to do
1412so, subject to the following conditions:
1413The above copyright notice and this permission notice shall be included in all
1414copies or substantial portions of the Software.
1415THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1416IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1417FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1418AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1419LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
1420OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1421SOFTWARE.
1422------------------------------------------------------------------------------
1423ALTERNATIVE B - Public Domain (www.unlicense.org)
1424This is free and unencumbered software released into the public domain.
1425Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
1426software, either in source code form or as a compiled binary, for any purpose,
1427commercial or non-commercial, and by any means.
1428In jurisdictions that recognize copyright laws, the author or authors of this
1429software dedicate any and all copyright interest in the software to the public
1430domain. We make this dedication for the benefit of the public at large and to
1431the detriment of our heirs and successors. We intend this dedication to be an
1432overt act of relinquishment in perpetuity of all present and future rights to
1433this software under copyright law.
1434THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1435IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1436FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1437AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1438ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
1439WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1440------------------------------------------------------------------------------
1441*/
STB_TexteditState
Definition imstb_textedit.h:322
StbTexteditRow
Definition imstb_textedit.h:369
StbUndoRecord
Definition imstb_textedit.h:304
StbUndoState
Definition imstb_textedit.h:313