From 366865dd020904116086e6d9ec46b8f70c42cdd1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Thu, 11 Jul 2019 15:25:52 +1000 Subject: Undo System: replace with simpler binary diffing buffer storage Applying/undoing incremental changes didn't fit well when mixed with periodic snapshots from mem-file undo. This moves to a much simpler undo system. - Uses array storage with de-duplication from `BLI_array_store`. - Loads the buffer into existing text data, for better performance on large files. - Has the advantage that Python operators can be supported since we don't depend on hard coded undo operations. Solves T67045, T66695, T65909. --- source/blender/blenkernel/BKE_text.h | 47 +- source/blender/blenkernel/intern/text.c | 1405 +++----------------- source/blender/editors/include/ED_text.h | 4 +- source/blender/editors/interface/interface_ops.c | 3 +- .../blender/editors/space_text/text_autocomplete.c | 16 +- source/blender/editors/space_text/text_ops.c | 66 +- source/blender/editors/space_text/text_undo.c | 175 ++- source/blender/makesdna/DNA_text_types.h | 2 - source/blender/makesrna/intern/rna_text_api.c | 4 +- 9 files changed, 296 insertions(+), 1426 deletions(-) (limited to 'source/blender') diff --git a/source/blender/blenkernel/BKE_text.h b/source/blender/blenkernel/BKE_text.h index c78faa9dd18..6509788932c 100644 --- a/source/blender/blenkernel/BKE_text.h +++ b/source/blender/blenkernel/BKE_text.h @@ -30,7 +30,6 @@ extern "C" { struct Main; struct Text; struct TextLine; -struct TextUndoBuf; void BKE_text_free_lines(struct Text *text); void BKE_text_free(struct Text *text); @@ -49,8 +48,8 @@ void BKE_text_copy_data(struct Main *bmain, const int flag); struct Text *BKE_text_copy(struct Main *bmain, const struct Text *ta); void BKE_text_make_local(struct Main *bmain, struct Text *text, const bool lib_local); -void BKE_text_clear(struct Text *text, struct TextUndoBuf *utxt); -void BKE_text_write(struct Text *text, struct TextUndoBuf *utxt, const char *str); +void BKE_text_clear(struct Text *text); +void BKE_text_write(struct Text *text, const char *str); int BKE_text_file_modified_check(struct Text *text); void BKE_text_file_modified_ignore(struct Text *text); @@ -77,29 +76,26 @@ void txt_move_eol(struct Text *text, const bool sel); void txt_move_toline(struct Text *text, unsigned int line, const bool sel); void txt_move_to(struct Text *text, unsigned int line, unsigned int ch, const bool sel); void txt_pop_sel(struct Text *text); -void txt_delete_char(struct Text *text, struct TextUndoBuf *utxt); -void txt_delete_word(struct Text *text, struct TextUndoBuf *utxt); -void txt_delete_selected(struct Text *text, struct TextUndoBuf *utxt); +void txt_delete_char(struct Text *text); +void txt_delete_word(struct Text *text); +void txt_delete_selected(struct Text *text); void txt_sel_all(struct Text *text); void txt_sel_clear(struct Text *text); void txt_sel_line(struct Text *text); char *txt_sel_to_buf(struct Text *text, int *r_buf_strlen); -void txt_insert_buf(struct Text *text, struct TextUndoBuf *utxt, const char *in_buffer); -void txt_undo_add_op(struct Text *text, struct TextUndoBuf *utxt, int op); -void txt_do_undo(struct Text *text, struct TextUndoBuf *utxt); -void txt_do_redo(struct Text *text, struct TextUndoBuf *utxt); -void txt_split_curline(struct Text *text, struct TextUndoBuf *utxt); -void txt_backspace_char(struct Text *text, struct TextUndoBuf *utxt); -void txt_backspace_word(struct Text *text, struct TextUndoBuf *utxt); -bool txt_add_char(struct Text *text, struct TextUndoBuf *utxt, unsigned int add); -bool txt_add_raw_char(struct Text *text, struct TextUndoBuf *utxt, unsigned int add); -bool txt_replace_char(struct Text *text, struct TextUndoBuf *utxt, unsigned int add); -void txt_unindent(struct Text *text, struct TextUndoBuf *utxt); -void txt_comment(struct Text *text, struct TextUndoBuf *utxt); -void txt_indent(struct Text *text, struct TextUndoBuf *utxt); -void txt_uncomment(struct Text *text, struct TextUndoBuf *utxt); -void txt_move_lines(struct Text *text, struct TextUndoBuf *utxt, const int direction); -void txt_duplicate_line(struct Text *text, struct TextUndoBuf *utxt); +void txt_insert_buf(struct Text *text, const char *in_buffer); +void txt_split_curline(struct Text *text); +void txt_backspace_char(struct Text *text); +void txt_backspace_word(struct Text *text); +bool txt_add_char(struct Text *text, unsigned int add); +bool txt_add_raw_char(struct Text *text, unsigned int add); +bool txt_replace_char(struct Text *text, unsigned int add); +void txt_unindent(struct Text *text); +void txt_comment(struct Text *text); +void txt_indent(struct Text *text); +void txt_uncomment(struct Text *text); +void txt_move_lines(struct Text *text, const int direction); +void txt_duplicate_line(struct Text *text); int txt_setcurr_tab_spaces(struct Text *text, int space); bool txt_cursor_is_line_start(struct Text *text); bool txt_cursor_is_line_end(struct Text *text); @@ -125,10 +121,9 @@ enum { TXT_MOVE_LINE_DOWN = 1, }; -typedef struct TextUndoBuf { - char *buf; - int pos, len; -} TextUndoBuf; +/* Fast non-validating buffer conversion for undo. */ +char *txt_to_buf_for_undo(struct Text *text, int *r_buf_strlen); +void txt_from_buf_for_undo(struct Text *text, const char *buf, int buf_len); #ifdef __cplusplus } diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c index 1d6de646255..b922aabc171 100644 --- a/source/blender/blenkernel/intern/text.c +++ b/source/blender/blenkernel/intern/text.c @@ -79,96 +79,24 @@ * * Display * -- + * * The st->top determines at what line the top of the text is displayed. * If the user moves the cursor the st containing that cursor should * be popped ... other st's retain their own top location. - * - * Undo - * -- - * Undo/Redo works by storing - * events in a queue, and a pointer - * to the current position in the - * queue... - * - * Events are stored using an - * arbitrary op-code system - * to keep track of - * a) the two cursors (normal and selected) - * b) input (visible and control (ie backspace)) - * - * input data is stored as its - * ASCII value, the opcodes are - * then selected to not conflict. - * - * opcodes with data in between are - * written at the beginning and end - * of the data to allow undo and redo - * to simply check the code at the current - * undo position */ -/* Undo opcodes */ - -enum { - /* Complex editing */ - /* 1 - opcode is followed by 1 byte for ascii character and opcode (repeat)) */ - /* 2 - opcode is followed by 2 bytes for utf-8 character and opcode (repeat)) */ - /* 3 - opcode is followed by 3 bytes for utf-8 character and opcode (repeat)) */ - /* 4 - opcode is followed by 4 bytes for unicode character and opcode (repeat)) */ - UNDO_INSERT_1 = 013, - UNDO_INSERT_2 = 014, - UNDO_INSERT_3 = 015, - UNDO_INSERT_4 = 016, - - UNDO_BS_1 = 017, - UNDO_BS_2 = 020, - UNDO_BS_3 = 021, - UNDO_BS_4 = 022, - - UNDO_DEL_1 = 023, - UNDO_DEL_2 = 024, - UNDO_DEL_3 = 025, - UNDO_DEL_4 = 026, - - /* Text block (opcode is followed - * by 4 character length ID + the text - * block itself + the 4 character length - * ID (repeat) and opcode (repeat)) */ - UNDO_DBLOCK = 027, /* Delete block */ - UNDO_IBLOCK = 030, /* Insert block */ - - /* Misc */ - UNDO_INDENT = 032, - UNDO_UNINDENT = 033, - UNDO_COMMENT = 034, - UNDO_UNCOMMENT = 035, - - UNDO_MOVE_LINES_UP = 036, - UNDO_MOVE_LINES_DOWN = 037, - - UNDO_DUPLICATE = 040, -}; - /***/ static void txt_pop_first(Text *text); static void txt_pop_last(Text *text); -static void txt_undo_add_blockop(Text *text, TextUndoBuf *utxt, int op, const char *buf); static void txt_delete_line(Text *text, TextLine *line); -static void txt_delete_sel(Text *text, TextUndoBuf *utxt); +static void txt_delete_sel(Text *text); static void txt_make_dirty(Text *text); /***/ /** - * Set to true when undoing (so we don't generate undo steps while undoing). - * - * Also use to disable undo entirely. - */ -static bool undoing; - -/** - * \note caller must handle `undo_buf` and `compiled` members. + * \note caller must handle `compiled` member. */ void BKE_text_free_lines(Text *text) { @@ -516,29 +444,17 @@ void BKE_text_make_local(Main *bmain, Text *text, const bool lib_local) BKE_id_make_local_generic(bmain, &text->id, true, lib_local); } -void BKE_text_clear(Text *text, TextUndoBuf *utxt) /* called directly from rna */ +void BKE_text_clear(Text *text) /* called directly from rna */ { - const bool undoing_orig = undoing; - undoing = (utxt == NULL); - txt_sel_all(text); - txt_delete_sel(text, utxt); - - undoing = undoing_orig; - + txt_delete_sel(text); txt_make_dirty(text); } -void BKE_text_write(Text *text, TextUndoBuf *utxt, const char *str) /* called directly from rna */ +void BKE_text_write(Text *text, const char *str) /* called directly from rna */ { - const bool undoing_orig = undoing; - undoing = (utxt == NULL); - - txt_insert_buf(text, utxt, str); + txt_insert_buf(text, str); txt_move_eof(text, 0); - - undoing = undoing_orig; - txt_make_dirty(text); } @@ -1270,7 +1186,7 @@ bool txt_has_sel(Text *text) return ((text->curl != text->sell) || (text->curc != text->selc)); } -static void txt_delete_sel(Text *text, TextUndoBuf *utxt) +static void txt_delete_sel(Text *text) { TextLine *tmpl; char *buf; @@ -1288,12 +1204,6 @@ static void txt_delete_sel(Text *text, TextUndoBuf *utxt) txt_order_cursors(text, false); - if (!undoing) { - buf = txt_sel_to_buf(text, NULL); - txt_undo_add_blockop(text, utxt, UNDO_DBLOCK, buf); - MEM_freeN(buf); - } - buf = MEM_mallocN(text->curc + (text->sell->len - text->selc) + 1, "textline_string"); strncpy(buf, text->curl->line, text->curc); @@ -1349,6 +1259,106 @@ void txt_sel_line(Text *text) text->selc = text->sell->len; } +/* -------------------------------------------------------------------- */ +/** \name Buffer Conversion for Undo/Redo + * + * Buffer conversion functions that rely on the buffer already being validated. + * + * The only requirement for these functions is that they're reverse-able, + * the undo logic doesn't inspect their content. + * + * Currently buffers: + * - Always ends with a new-line. + * - Are not null terminated. + * \{ */ + +/** + * Create a buffer, the only requirement is #txt_from_buf_for_undo can decode it. + */ +char *txt_to_buf_for_undo(Text *text, int *r_buf_len) +{ + int buf_len = 0; + for (const TextLine *l = text->lines.first; l; l = l->next) { + buf_len += l->len + 1; + } + char *buf = MEM_mallocN(buf_len, __func__); + char *buf_step = buf; + for (const TextLine *l = text->lines.first; l; l = l->next) { + memcpy(buf_step, l->line, l->len); + buf_step += l->len; + *buf_step++ = '\n'; + } + *r_buf_len = buf_len; + return buf; +} + +/** + * Decode a buffer from #txt_to_buf_for_undo. + */ +void txt_from_buf_for_undo(Text *text, const char *buf, int buf_len) +{ + const char *buf_end = buf + buf_len; + const char *buf_step = buf; + + /* First re-use existing lines. + * Good for undo since it means in practice many operations re-use all + * except for the modified line. */ + TextLine *l_src = text->lines.first; + BLI_listbase_clear(&text->lines); + while (buf_step != buf_end && l_src) { + /* New lines are ensured by #txt_to_buf_for_undo. */ + const char *buf_step_next = strchr(buf_step, '\n'); + const int len = buf_step_next - buf_step; + + TextLine *l = l_src; + l_src = l_src->next; + if (l->len != len) { + l->line = MEM_reallocN(l->line, len + 1); + l->len = len; + } + MEM_SAFE_FREE(l->format); + + memcpy(l->line, buf_step, len); + l->line[len] = '\0'; + BLI_addtail(&text->lines, l); + buf_step = buf_step_next + 1; + } + + /* If we have extra lines. */ + while (l_src != NULL) { + TextLine *l_src_next = l_src->next; + MEM_freeN(l_src->line); + if (l_src->format) { + MEM_freeN(l_src->format); + } + MEM_freeN(l_src); + l_src = l_src_next; + } + + while (buf_step != buf_end) { + /* New lines are ensured by #txt_to_buf_for_undo. */ + const char *buf_step_next = strchr(buf_step, '\n'); + const int len = buf_step_next - buf_step; + + TextLine *l = MEM_mallocN(sizeof(TextLine), "textline"); + l->line = MEM_mallocN(len + 1, "textline_string"); + l->len = len; + l->format = NULL; + + memcpy(l->line, buf_step, len); + l->line[len] = '\0'; + BLI_addtail(&text->lines, l); + buf_step = buf_step_next + 1; + } + + text->curl = text->sell = text->lines.first; + text->curc = text->selc = 0; + + txt_make_dirty(text); +} + +/** \} */ + /***************************/ /* Cut and paste functions */ /***************************/ @@ -1575,9 +1585,8 @@ char *txt_sel_to_buf(Text *text, int *r_buf_strlen) return buf; } -void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer) +void txt_insert_buf(Text *text, const char *in_buffer) { - const bool undoing_orig = undoing; int l = 0, len; size_t i = 0, j; TextLine *add; @@ -1587,24 +1596,19 @@ void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer) return; } - txt_delete_sel(text, utxt); + txt_delete_sel(text); len = strlen(in_buffer); buffer = BLI_strdupn(in_buffer, len); len += txt_extended_ascii_as_utf8(&buffer); - if (!undoing) { - txt_undo_add_blockop(text, utxt, UNDO_IBLOCK, buffer); - } - undoing = true; - /* Read the first line (or as close as possible */ while (buffer[i] && buffer[i] != '\n') { - txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &i)); + txt_add_raw_char(text, BLI_str_utf8_as_unicode_step(buffer, &i)); } if (buffer[i] == '\n') { - txt_split_curline(text, utxt); + txt_split_curline(text); i++; while (i < len) { @@ -1622,7 +1626,7 @@ void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer) } else { for (j = i - l; j < i && j < len;) { - txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &j)); + txt_add_raw_char(text, BLI_str_utf8_as_unicode_step(buffer, &j)); } break; } @@ -1630,1046 +1634,13 @@ void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer) } MEM_freeN(buffer); - undoing = undoing_orig; -} - -/******************/ -/* Undo functions */ -/******************/ - -static bool max_undo_test(TextUndoBuf *utxt, int x) -{ - /* Normally over-allocating is preferred, - * however in this case the buffer is small enough and re-allocation - * fast enough for each undo step that it's not a problem to allocate each time. - * This also saves on some memory when we have many text buffers - * that would have an empty undo memory allocated. - */ - - /* Add one for the null terminator. */ - utxt->len = utxt->pos + x + 1; - if (utxt->len > TXT_MAX_UNDO) { - /* XXX error("Undo limit reached, buffer cleared\n"); */ - MEM_freeN(utxt->buf); - return false; - } - else { - /* Small reallocations on each undo step is fine. */ - utxt->buf = MEM_recallocN(utxt->buf, utxt->len); - } - return true; -} - -static void txt_undo_end(Text *UNUSED(text), TextUndoBuf *utxt) -{ - int undo_pos_end = utxt->pos + 1; - BLI_assert(undo_pos_end + 1 == utxt->len); - utxt->buf[undo_pos_end] = '\0'; -} - -/* Call once undo is done. */ -#ifndef NDEBUG - -#endif - -#if 0 /* UNUSED */ -static void dump_buffer(TextUndoBuf *utxt) -{ - int i = 0; - - while (i++ < utxt->undo_pos) - printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]); -} - -/* Note: this function is outdated and must be updated if needed for future use */ -void txt_print_undo(Text *text) -{ - int i = 0; - int op; - const char *ops; - int linep, charp; - - dump_buffer(text); - - printf("---< Undo Buffer >---\n"); - - printf("UndoPosition is %d\n", utxt->pos); - - while (i <= utxt->pos) { - op = utxt->buf[i]; - - if (op == UNDO_INSERT_1) { - ops = "Insert ascii "; - } - else if (op == UNDO_INSERT_2) { - ops = "Insert 2 bytes "; - } - else if (op == UNDO_INSERT_3) { - ops = "Insert 3 bytes "; - } - else if (op == UNDO_INSERT_4) { - ops = "Insert unicode "; - } - else if (op == UNDO_BS_1) { - ops = "Backspace for ascii "; - } - else if (op == UNDO_BS_2) { - ops = "Backspace for 2 bytes "; - } - else if (op == UNDO_BS_3) { - ops = "Backspace for 3 bytes "; - } - else if (op == UNDO_BS_4) { - ops = "Backspace for unicode "; - } - else if (op == UNDO_DEL_1) { - ops = "Delete ascii "; - } - else if (op == UNDO_DEL_2) { - ops = "Delete 2 bytes "; - } - else if (op == UNDO_DEL_3) { - ops = "Delete 3 bytes "; - } - else if (op == UNDO_DEL_4) { - ops = "Delete unicode "; - } - else if (op == UNDO_DBLOCK) { - ops = "Delete text block"; - } - else if (op == UNDO_IBLOCK) { - ops = "Insert text block"; - } - else if (op == UNDO_INDENT) { - ops = "Indent "; - } - else if (op == UNDO_UNINDENT) { - ops = "Unindent "; - } - else if (op == UNDO_COMMENT) { - ops = "Comment "; - } - else if (op == UNDO_UNCOMMENT) { - ops = "Uncomment "; - } - else { - ops = "Unknown"; - } - - printf("Op (%o) at %d = %s", op, i, ops); - if (op >= UNDO_INSERT_1 && op <= UNDO_DEL_4) { - i++; - printf(" - Char is "); - switch (op) { - case UNDO_INSERT_1: - case UNDO_BS_1: - case UNDO_DEL_1: - printf("%c", utxt->buf[i]); - i++; - break; - case UNDO_INSERT_2: - case UNDO_BS_2: - case UNDO_DEL_2: - printf("%c%c", utxt->buf[i], utxt->buf[i + 1]); - i += 2; - break; - case UNDO_INSERT_3: - case UNDO_BS_3: - case UNDO_DEL_3: - printf("%c%c%c", utxt->buf[i], utxt->buf[i + 1], utxt->buf[i + 2]); - i += 3; - break; - case UNDO_INSERT_4: - case UNDO_BS_4: - case UNDO_DEL_4: { - unsigned int uc; - char c[BLI_UTF8_MAX + 1]; - size_t c_len; - uc = utxt->buf[i]; - i++; - uc = uc + (utxt->buf[i] << 8); - i++; - uc = uc + (utxt->buf[i] << 16); - i++; - uc = uc + (utxt->buf[i] << 24); - i++; - c_len = BLI_str_utf8_from_unicode(uc, c); - c[c_len] = '\0'; - puts(c); - break; - } - } - } - else if (op == UNDO_DBLOCK || op == UNDO_IBLOCK) { - i++; - - linep = utxt->buf[i]; - i++; - linep = linep + (utxt->buf[i] << 8); - i++; - linep = linep + (utxt->buf[i] << 16); - i++; - linep = linep + (utxt->buf[i] << 24); - i++; - - printf(" (length %d) <", linep); - - while (linep > 0) { - putchar(utxt->buf[i]); - linep--; - i++; - } - - linep = utxt->buf[i]; - i++; - linep = linep + (utxt->buf[i] << 8); - i++; - linep = linep + (utxt->buf[i] << 16); - i++; - linep = linep + (utxt->buf[i] << 24); - i++; - printf("> (%d)", linep); - } - else if (op == UNDO_INDENT || op == UNDO_UNINDENT) { - i++; - - charp = utxt->buf[i]; - i++; - charp = charp + (utxt->buf[i] << 8); - i++; - - linep = utxt->buf[i]; - i++; - linep = linep + (utxt->buf[i] << 8); - i++; - linep = linep + (utxt->buf[i] << 16); - i++; - linep = linep + (utxt->buf[i] << 24); - i++; - - printf("to <%d, %d> ", linep, charp); - - charp = utxt->buf[i]; - i++; - charp = charp + (utxt->buf[i] << 8); - i++; - - linep = utxt->buf[i]; - i++; - linep = linep + (utxt->buf[i] << 8); - i++; - linep = linep + (utxt->buf[i] << 16); - i++; - linep = linep + (utxt->buf[i] << 24); - i++; - - printf("from <%d, %d>", linep, charp); - } - - printf(" %d\n", i); - i++; - } -} -#endif - -static void txt_undo_store_uint16(char *undo_buf, int *undo_pos, unsigned short value) -{ - undo_buf[*undo_pos] = (value)&0xff; - (*undo_pos)++; - undo_buf[*undo_pos] = (value >> 8) & 0xff; - (*undo_pos)++; -} - -static void txt_undo_store_uint32(char *undo_buf, int *undo_pos, unsigned int value) -{ - undo_buf[*undo_pos] = (value)&0xff; - (*undo_pos)++; - undo_buf[*undo_pos] = (value >> 8) & 0xff; - (*undo_pos)++; - undo_buf[*undo_pos] = (value >> 16) & 0xff; - (*undo_pos)++; - undo_buf[*undo_pos] = (value >> 24) & 0xff; - (*undo_pos)++; -} - -/* store the cur cursor to the undo buffer (6 bytes)*/ -static void txt_undo_store_cur(Text *text, TextUndoBuf *utxt) -{ - txt_undo_store_uint16(utxt->buf, &utxt->pos, text->curc); - txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->curl)); -} - -/* store the sel cursor to the undo buffer (6 bytes) */ -static void txt_undo_store_sel(Text *text, TextUndoBuf *utxt) -{ - txt_undo_store_uint16(utxt->buf, &utxt->pos, text->selc); - txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->sell)); -} - -/* store both cursors to the undo buffer (12 bytes) */ -static void txt_undo_store_cursors(Text *text, TextUndoBuf *utxt) -{ - txt_undo_store_cur(text, utxt); - txt_undo_store_sel(text, utxt); -} - -/* store an operator along with a block of data */ -static void txt_undo_add_blockop(Text *text, TextUndoBuf *utxt, int op, const char *buf) -{ - unsigned int length = strlen(buf); - - if (!max_undo_test(utxt, 2 + 12 + 4 + length + 4 + 1)) { - return; - } - /* 2 bytes */ - utxt->pos++; - utxt->buf[utxt->pos] = op; - utxt->pos++; - /* 12 bytes */ - txt_undo_store_cursors(text, utxt); - /* 4 bytes */ - txt_undo_store_uint32(utxt->buf, &utxt->pos, length); - /* 'length' bytes */ - memcpy(utxt->buf + utxt->pos, buf, length); - utxt->pos += length; - /* 4 bytes */ - txt_undo_store_uint32(utxt->buf, &utxt->pos, length); - /* 1 byte */ - utxt->buf[utxt->pos] = op; - - txt_undo_end(text, utxt); -} - -/* store a regular operator */ -void txt_undo_add_op(Text *text, TextUndoBuf *utxt, int op) -{ - if (!max_undo_test(utxt, 2 + 12 + 1)) { - return; - } - - /* 2 bytes */ - utxt->pos++; - utxt->buf[utxt->pos] = op; - utxt->pos++; - /* 12 bytes */ - txt_undo_store_cursors(text, utxt); - /* 1 byte */ - utxt->buf[utxt->pos] = op; - - txt_undo_end(text, utxt); -} - -/* store an operator for a single character */ -static void txt_undo_add_charop(Text *text, TextUndoBuf *utxt, int op_start, unsigned int c) -{ - char utf8[BLI_UTF8_MAX]; - size_t i, utf8_size = BLI_str_utf8_from_unicode(c, utf8); - - if (utf8_size < 4 && 0) { - if (!max_undo_test(utxt, 2 + 6 + utf8_size + 1)) { - return; - } - /* 2 bytes */ - utxt->pos++; - utxt->buf[utxt->pos] = op_start + utf8_size - 1; - utxt->pos++; - /* 6 bytes */ - txt_undo_store_cur(text, utxt); - /* 'utf8_size' bytes */ - for (i = 0; i < utf8_size; i++) { - utxt->buf[utxt->pos] = utf8[i]; - utxt->pos++; - } - /* 1 byte */ - utxt->buf[utxt->pos] = op_start + utf8_size - 1; - } - else { - if (!max_undo_test(utxt, 2 + 6 + 4 + 1)) { - return; - } - /* 2 bytes */ - utxt->pos++; - utxt->buf[utxt->pos] = op_start + 3; - utxt->pos++; - /* 6 bytes */ - txt_undo_store_cur(text, utxt); - /* 4 bytes */ - txt_undo_store_uint32(utxt->buf, &utxt->pos, c); - /* 1 byte */ - utxt->buf[utxt->pos] = op_start + 3; - } - - txt_undo_end(text, utxt); -} - -/* extends Link */ -struct LinkInt { - struct LinkInt *next, *prev; - int value; -}; - -/** - * UnindentLines points to a #ListBase composed of #LinkInt elements, listing the numbers - * of the lines that should not be indented back. - */ -static void txt_undo_add_unprefix_op(Text *text, - TextUndoBuf *utxt, - char undo_op, - const ListBase *line_index_mask, - const int line_index_mask_len) -{ - struct LinkInt *idata; - - BLI_assert(BLI_listbase_count(line_index_mask) == line_index_mask_len); - - /* OP byte + u32 count + counted u32 line numbers + u32 count + 12-bytes selection + OP byte. */ - if (!max_undo_test(utxt, 2 + 4 + (line_index_mask_len * 4) + 4 + 12 + 1)) { - return; - } - - /* 2 bytes */ - utxt->pos++; - utxt->buf[utxt->pos] = undo_op; - utxt->pos++; - /* Adding number of line numbers to read - * 4 bytes */ - txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len); - - /* Adding line-numbers of lines that shall not be indented if undoing. - * 'line_index_mask_len * 4' bytes */ - for (idata = line_index_mask->first; idata; idata = idata->next) { - txt_undo_store_uint32(utxt->buf, &utxt->pos, idata->value); - } - - /* Adding number of line numbers to read again. - * 4 bytes */ - txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len); - /* Adding current selection. - * 12 bytes */ - txt_undo_store_cursors(text, utxt); - /* Closing with OP (same as above). - * 1 byte */ - utxt->buf[utxt->pos] = undo_op; - /* Marking as last undo operation */ - txt_undo_end(text, utxt); -} - -static unsigned short txt_undo_read_uint16(const char *undo_buf, int *undo_pos) -{ - unsigned short val; - val = undo_buf[*undo_pos]; - (*undo_pos)--; - val = (val << 8) + undo_buf[*undo_pos]; - (*undo_pos)--; - return val; -} - -static unsigned int txt_undo_read_uint32(const char *undo_buf, int *undo_pos) -{ - unsigned int val; - val = undo_buf[*undo_pos]; - (*undo_pos)--; - val = (val << 8) + undo_buf[*undo_pos]; - (*undo_pos)--; - val = (val << 8) + undo_buf[*undo_pos]; - (*undo_pos)--; - val = (val << 8) + undo_buf[*undo_pos]; - (*undo_pos)--; - return val; -} - -/* read the cur cursor from the undo buffer */ -static void txt_undo_read_cur(const char *undo_buf, - int *undo_pos, - unsigned int *curln, - unsigned short *curc) -{ - *curln = txt_undo_read_uint32(undo_buf, undo_pos); - *curc = txt_undo_read_uint16(undo_buf, undo_pos); -} - -/* read the sel cursor from the undo buffer */ -static void txt_undo_read_sel(const char *undo_buf, - int *undo_pos, - unsigned int *selln, - unsigned short *selc) -{ - *selln = txt_undo_read_uint32(undo_buf, undo_pos); - *selc = txt_undo_read_uint16(undo_buf, undo_pos); -} - -/* read both cursors from the undo buffer */ -static void txt_undo_read_cursors(const char *undo_buf, - int *undo_pos, - unsigned int *curln, - unsigned short *curc, - unsigned int *selln, - unsigned short *selc) -{ - txt_undo_read_sel(undo_buf, undo_pos, selln, selc); - txt_undo_read_cur(undo_buf, undo_pos, curln, curc); -} - -static unsigned int txt_undo_read_unicode(const char *undo_buf, int *undo_pos, short bytes) -{ - unsigned int unicode; - char utf8[BLI_UTF8_MAX + 1]; - - switch (bytes) { - case 1: /* ascii */ - unicode = undo_buf[*undo_pos]; - (*undo_pos)--; - break; - case 2: /* 2-byte symbol */ - utf8[2] = '\0'; - utf8[1] = undo_buf[*undo_pos]; - (*undo_pos)--; - utf8[0] = undo_buf[*undo_pos]; - (*undo_pos)--; - unicode = BLI_str_utf8_as_unicode(utf8); - break; - case 3: /* 3-byte symbol */ - utf8[3] = '\0'; - utf8[2] = undo_buf[*undo_pos]; - (*undo_pos)--; - utf8[1] = undo_buf[*undo_pos]; - (*undo_pos)--; - utf8[0] = undo_buf[*undo_pos]; - (*undo_pos)--; - unicode = BLI_str_utf8_as_unicode(utf8); - break; - case 4: /* 32-bit unicode symbol */ - unicode = txt_undo_read_uint32(undo_buf, undo_pos); - break; - default: - /* should never happen */ - BLI_assert(0); - unicode = 0; - break; - } - - return unicode; -} - -static unsigned short txt_redo_read_uint16(const char *undo_buf, int *undo_pos) -{ - unsigned short val; - val = undo_buf[*undo_pos]; - (*undo_pos)++; - val = val + (undo_buf[*undo_pos] << 8); - (*undo_pos)++; - return val; -} - -static unsigned int txt_redo_read_uint32(const char *undo_buf, int *undo_pos) -{ - unsigned int val; - val = undo_buf[*undo_pos]; - (*undo_pos)++; - val = val + (undo_buf[*undo_pos] << 8); - (*undo_pos)++; - val = val + (undo_buf[*undo_pos] << 16); - (*undo_pos)++; - val = val + (undo_buf[*undo_pos] << 24); - (*undo_pos)++; - return val; -} - -/* redo read cur cursor from the undo buffer */ -static void txt_redo_read_cur(const char *undo_buf, - int *undo_pos, - unsigned int *curln, - unsigned short *curc) -{ - *curc = txt_redo_read_uint16(undo_buf, undo_pos); - *curln = txt_redo_read_uint32(undo_buf, undo_pos); -} - -/* redo read sel cursor from the undo buffer */ -static void txt_redo_read_sel(const char *undo_buf, - int *undo_pos, - unsigned int *selln, - unsigned short *selc) -{ - *selc = txt_redo_read_uint16(undo_buf, undo_pos); - *selln = txt_redo_read_uint32(undo_buf, undo_pos); -} - -/* redo read both cursors from the undo buffer */ -static void txt_redo_read_cursors(const char *undo_buf, - int *undo_pos, - unsigned int *curln, - unsigned short *curc, - unsigned int *selln, - unsigned short *selc) -{ - txt_redo_read_cur(undo_buf, undo_pos, curln, curc); - txt_redo_read_sel(undo_buf, undo_pos, selln, selc); -} - -static unsigned int txt_redo_read_unicode(const char *undo_buf, int *undo_pos, short bytes) -{ - unsigned int unicode; - char utf8[BLI_UTF8_MAX + 1]; - - switch (bytes) { - case 1: /* ascii */ - unicode = undo_buf[*undo_pos]; - (*undo_pos)++; - break; - case 2: /* 2-byte symbol */ - utf8[0] = undo_buf[*undo_pos]; - (*undo_pos)++; - utf8[1] = undo_buf[*undo_pos]; - (*undo_pos)++; - utf8[2] = '\0'; - unicode = BLI_str_utf8_as_unicode(utf8); - break; - case 3: /* 3-byte symbol */ - utf8[0] = undo_buf[*undo_pos]; - (*undo_pos)++; - utf8[1] = undo_buf[*undo_pos]; - (*undo_pos)++; - utf8[2] = undo_buf[*undo_pos]; - (*undo_pos)++; - utf8[3] = '\0'; - unicode = BLI_str_utf8_as_unicode(utf8); - break; - case 4: /* 32-bit unicode symbol */ - unicode = txt_redo_read_uint32(undo_buf, undo_pos); - break; - default: - /* should never happen */ - BLI_assert(0); - unicode = 0; - break; - } - - return unicode; -} - -void txt_do_undo(Text *text, TextUndoBuf *utxt) -{ - int op = utxt->buf[utxt->pos]; - int prev_flags; - unsigned int linep; - unsigned int uni_char; - unsigned int curln, selln; - unsigned short curc, selc; - unsigned short charp; - char *buf; - - if (utxt->pos < 0) { - return; - } - - utxt->pos--; - - undoing = 1; - - switch (op) { - case UNDO_INSERT_1: - case UNDO_INSERT_2: - case UNDO_INSERT_3: - case UNDO_INSERT_4: - utxt->pos -= op - UNDO_INSERT_1 + 1; - - /* get and restore the cursors */ - txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - txt_delete_char(text, utxt); - - utxt->pos--; - break; - - case UNDO_BS_1: - case UNDO_BS_2: - case UNDO_BS_3: - case UNDO_BS_4: - charp = op - UNDO_BS_1 + 1; - uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp); - - /* get and restore the cursors */ - txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - txt_add_char(text, utxt, uni_char); - - utxt->pos--; - break; - - case UNDO_DEL_1: - case UNDO_DEL_2: - case UNDO_DEL_3: - case UNDO_DEL_4: - charp = op - UNDO_DEL_1 + 1; - uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp); - - /* get and restore the cursors */ - txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - txt_add_char(text, utxt, uni_char); - - txt_move_left(text, 0); - - utxt->pos--; - break; - - case UNDO_DBLOCK: { - int i; - /* length of the string in the buffer */ - linep = txt_undo_read_uint32(utxt->buf, &utxt->pos); - - buf = MEM_mallocN(linep + 1, "dblock buffer"); - for (i = 0; i < linep; i++) { - buf[(linep - 1) - i] = utxt->buf[utxt->pos]; - utxt->pos--; - } - buf[i] = 0; - - /* skip over the length that was stored again */ - utxt->pos -= 4; - - /* Get the cursor positions */ - txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - - /* move cur to location that needs buff inserted */ - txt_move_to(text, curln, curc, 0); - - txt_insert_buf(text, utxt, buf); - MEM_freeN(buf); - - /* restore the cursors */ - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - utxt->pos--; - - break; - } - case UNDO_IBLOCK: { - int i; - /* length of the string in the buffer */ - linep = txt_undo_read_uint32(utxt->buf, &utxt->pos); - - /* txt_backspace_char removes utf8-characters, not bytes */ - buf = MEM_mallocN(linep + 1, "iblock buffer"); - for (i = 0; i < linep; i++) { - buf[(linep - 1) - i] = utxt->buf[utxt->pos]; - utxt->pos--; - } - buf[i] = 0; - linep = BLI_strlen_utf8(buf); - MEM_freeN(buf); - - /* skip over the length that was stored again */ - utxt->pos -= 4; - - /* get and restore the cursors */ - txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - if ((curln == selln) && (curc == selc)) { - /* disable tabs to spaces since moving right may involve skipping multiple spaces */ - prev_flags = text->flags; - text->flags &= ~TXT_TABSTOSPACES; - - for (i = 0; i < linep; i++) { - txt_move_right(text, 1); - } - - text->flags = prev_flags; - } - - txt_delete_selected(text, utxt); - - utxt->pos--; - break; - } - case UNDO_INDENT: - case UNDO_COMMENT: - case UNDO_DUPLICATE: - case UNDO_MOVE_LINES_UP: - case UNDO_MOVE_LINES_DOWN: - /* get and restore the cursors */ - txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - if (op == UNDO_INDENT) { - txt_unindent(text, utxt); - } - else if (op == UNDO_COMMENT) { - txt_uncomment(text, utxt); - } - else if (op == UNDO_DUPLICATE) { - txt_delete_line(text, text->curl->next); - } - else if (op == UNDO_MOVE_LINES_UP) { - txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN); - } - else if (op == UNDO_MOVE_LINES_DOWN) { - txt_move_lines(text, utxt, TXT_MOVE_LINE_UP); - } - - utxt->pos--; - break; - case UNDO_UNINDENT: - case UNDO_UNCOMMENT: { - void (*txt_prefix_fn)(Text *, TextUndoBuf *); - void (*txt_unprefix_fn)(Text *, TextUndoBuf *); - int count; - int i; - /* Get and restore the cursors */ - txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - /* Un-unindent */ - if (op == UNDO_UNINDENT) { - txt_prefix_fn = txt_indent; - txt_unprefix_fn = txt_unindent; - } - else { - txt_prefix_fn = txt_comment; - txt_unprefix_fn = txt_uncomment; - } - - txt_prefix_fn(text, utxt); - - /* Get the count */ - count = txt_undo_read_uint32(utxt->buf, &utxt->pos); - /* Iterate! */ - txt_pop_sel(text); - - for (i = 0; i < count; i++) { - txt_move_to(text, txt_undo_read_uint32(utxt->buf, &utxt->pos), 0, 0); - /* Un-un-unindent/comment */ - txt_unprefix_fn(text, utxt); - } - /* Restore selection */ - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - /* Jumo over count */ - txt_undo_read_uint32(utxt->buf, &utxt->pos); - /* Jump over closing OP byte */ - utxt->pos--; - break; - } - default: - // XXX error("Undo buffer error - resetting"); - utxt->pos = -1; - - break; - } - - undoing = 0; -} - -void txt_do_redo(Text *text, TextUndoBuf *utxt) -{ - char op; - char *buf; - unsigned int linep; - unsigned short charp; - unsigned int uni_uchar; - unsigned int curln, selln; - unsigned short curc, selc; - - utxt->pos++; - op = utxt->buf[utxt->pos]; - - if (!op) { - utxt->pos--; - return; - } - - undoing = 1; - - switch (op) { - case UNDO_INSERT_1: - case UNDO_INSERT_2: - case UNDO_INSERT_3: - case UNDO_INSERT_4: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - charp = op - UNDO_INSERT_1 + 1; - uni_uchar = txt_redo_read_unicode(utxt->buf, &utxt->pos, charp); - - txt_add_char(text, utxt, uni_uchar); - break; - - case UNDO_BS_1: - case UNDO_BS_2: - case UNDO_BS_3: - case UNDO_BS_4: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - utxt->pos += op - UNDO_BS_1 + 1; - - /* move right so we backspace the correct char */ - txt_move_right(text, 0); - txt_backspace_char(text, utxt); - - break; - - case UNDO_DEL_1: - case UNDO_DEL_2: - case UNDO_DEL_3: - case UNDO_DEL_4: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - utxt->pos += op - UNDO_DEL_1 + 1; - - txt_delete_char(text, utxt); - - break; - - case UNDO_DBLOCK: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - /* length of the block */ - linep = txt_redo_read_uint32(utxt->buf, &utxt->pos); - - utxt->pos += linep; - - /* skip over the length that was stored again */ - utxt->pos += 4; - - txt_delete_sel(text, utxt); - - break; - - case UNDO_IBLOCK: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, curln, curc, 1); - - /* length of the block */ - linep = txt_redo_read_uint32(utxt->buf, &utxt->pos); - - buf = MEM_mallocN(linep + 1, "iblock buffer"); - memcpy(buf, &utxt->buf[utxt->pos], linep); - utxt->pos += linep; - buf[linep] = 0; - - txt_insert_buf(text, utxt, buf); - MEM_freeN(buf); - - /* skip over the length that was stored again */ - utxt->pos += 4; - - break; - - case UNDO_INDENT: - case UNDO_COMMENT: - case UNDO_UNCOMMENT: - case UNDO_DUPLICATE: - case UNDO_MOVE_LINES_UP: - case UNDO_MOVE_LINES_DOWN: - utxt->pos++; - - /* get and restore the cursors */ - txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - if (op == UNDO_INDENT) { - txt_indent(text, utxt); - } - else if (op == UNDO_COMMENT) { - txt_comment(text, utxt); - } - else if (op == UNDO_UNCOMMENT) { - txt_uncomment(text, utxt); - } - else if (op == UNDO_DUPLICATE) { - txt_duplicate_line(text, utxt); - } - else if (op == UNDO_MOVE_LINES_UP) { - /* offset the cursor by + 1 */ - txt_move_to(text, curln + 1, curc, 0); - txt_move_to(text, selln + 1, selc, 1); - - txt_move_lines(text, utxt, TXT_MOVE_LINE_UP); - } - else if (op == UNDO_MOVE_LINES_DOWN) { - /* offset the cursor by - 1 */ - txt_move_to(text, curln - 1, curc, 0); - txt_move_to(text, selln - 1, selc, 1); - - txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN); - } - - /* re-restore the cursors since they got moved when redoing */ - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - - break; - case UNDO_UNINDENT: { - int count; - int i; - - utxt->pos++; - /* Scan all the stuff described in txt_undo_add_unindent_op */ - count = txt_redo_read_uint32(utxt->buf, &utxt->pos); - for (i = 0; i < count; i++) { - txt_redo_read_uint32(utxt->buf, &utxt->pos); - } - /* Count again */ - txt_redo_read_uint32(utxt->buf, &utxt->pos); - /* Get the selection and re-unindent */ - txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc); - txt_move_to(text, curln, curc, 0); - txt_move_to(text, selln, selc, 1); - txt_unindent(text, utxt); - break; - } - default: - // XXX error("Undo buffer error - resetting"); - utxt->pos = -1; - - break; - } - - undoing = 0; } /**************************/ /* Line editing functions */ /**************************/ -void txt_split_curline(Text *text, TextUndoBuf *utxt) +void txt_split_curline(Text *text) { TextLine *ins; char *left, *right; @@ -2678,11 +1649,7 @@ void txt_split_curline(Text *text, TextUndoBuf *utxt) return; } - txt_delete_sel(text, utxt); - - if (!undoing) { - txt_undo_add_charop(text, utxt, UNDO_INSERT_1, '\n'); - } + txt_delete_sel(text); /* Make the two half strings */ @@ -2765,7 +1732,7 @@ static void txt_combine_lines(Text *text, TextLine *linea, TextLine *lineb) txt_clean_text(text); } -void txt_duplicate_line(Text *text, TextUndoBuf *utxt) +void txt_duplicate_line(Text *text) { TextLine *textline; @@ -2779,14 +1746,10 @@ void txt_duplicate_line(Text *text, TextUndoBuf *utxt) txt_make_dirty(text); txt_clean_text(text); - - if (!undoing) { - txt_undo_add_op(text, utxt, UNDO_DUPLICATE); - } } } -void txt_delete_char(Text *text, TextUndoBuf *utxt) +void txt_delete_char(Text *text) { unsigned int c = '\n'; @@ -2795,7 +1758,7 @@ void txt_delete_char(Text *text, TextUndoBuf *utxt) } if (txt_has_sel(text)) { /* deleting a selection */ - txt_delete_sel(text, utxt); + txt_delete_sel(text); txt_make_dirty(text); return; } @@ -2811,6 +1774,7 @@ void txt_delete_char(Text *text, TextUndoBuf *utxt) else { /* Just deleting a char */ size_t c_len = 0; c = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &c_len); + UNUSED_VARS(c); memmove(text->curl->line + text->curc, text->curl->line + text->curc + c_len, @@ -2823,20 +1787,16 @@ void txt_delete_char(Text *text, TextUndoBuf *utxt) txt_make_dirty(text); txt_clean_text(text); - - if (!undoing) { - txt_undo_add_charop(text, utxt, UNDO_DEL_1, c); - } } -void txt_delete_word(Text *text, TextUndoBuf *utxt) +void txt_delete_word(Text *text) { txt_jump_right(text, true, true); - txt_delete_sel(text, utxt); + txt_delete_sel(text); txt_make_dirty(text); } -void txt_backspace_char(Text *text, TextUndoBuf *utxt) +void txt_backspace_char(Text *text) { unsigned int c = '\n'; @@ -2845,7 +1805,7 @@ void txt_backspace_char(Text *text, TextUndoBuf *utxt) } if (txt_has_sel(text)) { /* deleting a selection */ - txt_delete_sel(text, utxt); + txt_delete_sel(text); txt_make_dirty(text); return; } @@ -2864,6 +1824,7 @@ void txt_backspace_char(Text *text, TextUndoBuf *utxt) size_t c_len = 0; const char *prev = BLI_str_prev_char_utf8(text->curl->line + text->curc); c = BLI_str_utf8_as_unicode_and_size(prev, &c_len); + UNUSED_VARS(c); /* source and destination overlap, don't use memcpy() */ memmove(text->curl->line + text->curc - c_len, @@ -2878,16 +1839,12 @@ void txt_backspace_char(Text *text, TextUndoBuf *utxt) txt_make_dirty(text); txt_clean_text(text); - - if (!undoing) { - txt_undo_add_charop(text, utxt, UNDO_BS_1, c); - } } -void txt_backspace_word(Text *text, TextUndoBuf *utxt) +void txt_backspace_word(Text *text) { txt_jump_left(text, true, true); - txt_delete_sel(text, utxt); + txt_delete_sel(text); txt_make_dirty(text); } @@ -2896,17 +1853,17 @@ void txt_backspace_word(Text *text, TextUndoBuf *utxt) * Remember to change this string according to max tab size */ static char tab_to_spaces[] = " "; -static void txt_convert_tab_to_spaces(Text *text, TextUndoBuf *utxt) +static void txt_convert_tab_to_spaces(Text *text) { /* sb aims to pad adjust the tab-width needed so that the right number of spaces * is added so that the indention of the line is the right width (i.e. aligned * to multiples of TXT_TABSIZE) */ const char *sb = &tab_to_spaces[text->curc % TXT_TABSIZE]; - txt_insert_buf(text, utxt, sb); + txt_insert_buf(text, sb); } -static bool txt_add_char_intern(Text *text, TextUndoBuf *utxt, unsigned int add, bool replace_tabs) +static bool txt_add_char_intern(Text *text, unsigned int add, bool replace_tabs) { char *tmp, ch[BLI_UTF8_MAX]; size_t add_len; @@ -2916,21 +1873,17 @@ static bool txt_add_char_intern(Text *text, TextUndoBuf *utxt, unsigned int add, } if (add == '\n') { - txt_split_curline(text, utxt); + txt_split_curline(text); return true; } /* insert spaces rather than tabs */ if (add == '\t' && replace_tabs) { - txt_convert_tab_to_spaces(text, utxt); + txt_convert_tab_to_spaces(text); return true; } - txt_delete_sel(text, utxt); - - if (!undoing) { - txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add); - } + txt_delete_sel(text); add_len = BLI_str_utf8_from_unicode(add, ch); @@ -2953,23 +1906,23 @@ static bool txt_add_char_intern(Text *text, TextUndoBuf *utxt, unsigned int add, return 1; } -bool txt_add_char(Text *text, TextUndoBuf *utxt, unsigned int add) +bool txt_add_char(Text *text, unsigned int add) { - return txt_add_char_intern(text, utxt, add, (text->flags & TXT_TABSTOSPACES) != 0); + return txt_add_char_intern(text, add, (text->flags & TXT_TABSTOSPACES) != 0); } -bool txt_add_raw_char(Text *text, TextUndoBuf *utxt, unsigned int add) +bool txt_add_raw_char(Text *text, unsigned int add) { - return txt_add_char_intern(text, utxt, add, 0); + return txt_add_char_intern(text, add, 0); } -void txt_delete_selected(Text *text, TextUndoBuf *utxt) +void txt_delete_selected(Text *text) { - txt_delete_sel(text, utxt); + txt_delete_sel(text); txt_make_dirty(text); } -bool txt_replace_char(Text *text, TextUndoBuf *utxt, unsigned int add) +bool txt_replace_char(Text *text, unsigned int add) { unsigned int del; size_t del_size = 0, add_size; @@ -2981,10 +1934,11 @@ bool txt_replace_char(Text *text, TextUndoBuf *utxt, unsigned int add) /* If text is selected or we're at the end of the line just use txt_add_char */ if (text->curc == text->curl->len || txt_has_sel(text) || add == '\n') { - return txt_add_char(text, utxt, add); + return txt_add_char(text, add); } del = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &del_size); + UNUSED_VARS(del); add_size = BLI_str_utf8_from_unicode(add, ch); if (add_size > del_size) { @@ -3010,16 +1964,6 @@ bool txt_replace_char(Text *text, TextUndoBuf *utxt, unsigned int add) txt_pop_sel(text); txt_make_dirty(text); txt_clean_text(text); - - /* Should probably create a new op for this */ - if (!undoing) { - txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add); - text->curc -= add_size; - txt_pop_sel(text); - txt_undo_add_charop(text, utxt, UNDO_DEL_1, del); - text->curc += add_size; - txt_pop_sel(text); - } return true; } @@ -3098,26 +2042,14 @@ static void txt_select_prefix(Text *text, const char *add) * * \note caller must handle undo. */ -static void txt_select_unprefix(Text *text, - const char *remove, - ListBase *r_line_index_mask, - int *r_line_index_mask_len) +static void txt_select_unprefix(Text *text, const char *remove) { int num = 0; const int indentlen = strlen(remove); bool unindented_first = false; - int curl_span_init = 0; - BLI_assert(!ELEM(NULL, text->curl, text->sell)); - BLI_listbase_clear(r_line_index_mask); - *r_line_index_mask_len = 0; - - if (!undoing) { - curl_span_init = txt_get_span(text->lines.first, text->curl); - } - while (true) { bool changed = false; if (STREQLEN(text->curl->line, remove, indentlen)) { @@ -3128,16 +2060,6 @@ static void txt_select_unprefix(Text *text, memmove(text->curl->line, text->curl->line + indentlen, text->curl->len + 1); changed = true; } - else { - if (!undoing) { - /* Create list element for 0 indent line */ - struct LinkInt *idata = MEM_mallocN(sizeof(struct LinkInt), __func__); - idata->value = curl_span_init + num; - BLI_assert(idata->value == txt_get_span(text->lines.first, text->curl)); - BLI_addtail(r_line_index_mask, idata); - (*r_line_index_mask_len) += 1; - } - } txt_make_dirty(text); txt_clean_text(text); @@ -3166,7 +2088,7 @@ static void txt_select_unprefix(Text *text, /* caller must handle undo */ } -void txt_comment(Text *text, TextUndoBuf *utxt) +void txt_comment(Text *text) { const char *prefix = "#"; @@ -3175,32 +2097,20 @@ void txt_comment(Text *text, TextUndoBuf *utxt) } txt_select_prefix(text, prefix); - - if (!undoing) { - txt_undo_add_op(text, utxt, UNDO_COMMENT); - } } -void txt_uncomment(Text *text, TextUndoBuf *utxt) +void txt_uncomment(Text *text) { const char *prefix = "#"; - ListBase line_index_mask; - int line_index_mask_len; if (ELEM(NULL, text->curl, text->sell)) { return; } - txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len); - - if (!undoing) { - txt_undo_add_unprefix_op(text, utxt, UNDO_UNCOMMENT, &line_index_mask, line_index_mask_len); - } - - BLI_freelistN(&line_index_mask); + txt_select_unprefix(text, prefix); } -void txt_indent(Text *text, TextUndoBuf *utxt) +void txt_indent(Text *text) { const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t"; @@ -3209,32 +2119,20 @@ void txt_indent(Text *text, TextUndoBuf *utxt) } txt_select_prefix(text, prefix); - - if (!undoing) { - txt_undo_add_op(text, utxt, UNDO_INDENT); - } } -void txt_unindent(Text *text, TextUndoBuf *utxt) +void txt_unindent(Text *text) { const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t"; - ListBase line_index_mask; - int line_index_mask_len; if (ELEM(NULL, text->curl, text->sell)) { return; } - txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len); - - if (!undoing) { - txt_undo_add_unprefix_op(text, utxt, UNDO_UNINDENT, &line_index_mask, line_index_mask_len); - } - - BLI_freelistN(&line_index_mask); + txt_select_unprefix(text, prefix); } -void txt_move_lines(struct Text *text, TextUndoBuf *utxt, const int direction) +void txt_move_lines(struct Text *text, const int direction) { TextLine *line_other; @@ -3263,11 +2161,6 @@ void txt_move_lines(struct Text *text, TextUndoBuf *utxt, const int direction) txt_make_dirty(text); txt_clean_text(text); - - if (!undoing) { - txt_undo_add_op( - text, utxt, (direction == TXT_MOVE_LINE_DOWN) ? UNDO_MOVE_LINES_DOWN : UNDO_MOVE_LINES_UP); - } } int txt_setcurr_tab_spaces(Text *text, int space) diff --git a/source/blender/editors/include/ED_text.h b/source/blender/editors/include/ED_text.h index 7638249d49a..ed71439bd37 100644 --- a/source/blender/editors/include/ED_text.h +++ b/source/blender/editors/include/ED_text.h @@ -26,7 +26,7 @@ struct ARegion; struct SpaceText; -struct TextUndoBuf; +struct UndoStep; struct UndoType; bool ED_text_region_location_from_cursor(struct SpaceText *st, @@ -37,6 +37,6 @@ bool ED_text_region_location_from_cursor(struct SpaceText *st, /* text_undo.c */ void ED_text_undosys_type(struct UndoType *ut); -struct TextUndoBuf *ED_text_undo_push_init(struct bContext *C); +struct UndoStep *ED_text_undo_push_init(struct bContext *C); #endif /* __ED_TEXT_H__ */ diff --git a/source/blender/editors/interface/interface_ops.c b/source/blender/editors/interface/interface_ops.c index 7d2ccd9c3ec..f2b2a478ba9 100644 --- a/source/blender/editors/interface/interface_ops.c +++ b/source/blender/editors/interface/interface_ops.c @@ -1052,8 +1052,7 @@ static int reports_to_text_exec(bContext *C, wmOperator *UNUSED(op)) str = BKE_reports_string(reports, (G.debug & G_DEBUG) ? RPT_DEBUG : RPT_INFO); if (str) { - TextUndoBuf *utxt = NULL; // FIXME - BKE_text_write(txt, utxt, str); + BKE_text_write(txt, str); MEM_freeN(str); return OPERATOR_FINISHED; diff --git a/source/blender/editors/space_text/text_autocomplete.c b/source/blender/editors/space_text/text_autocomplete.c index c36175489b3..b6c660ae5b2 100644 --- a/source/blender/editors/space_text/text_autocomplete.c +++ b/source/blender/editors/space_text/text_autocomplete.c @@ -260,7 +260,7 @@ static void get_suggest_prefix(Text *text, int offset) texttool_suggest_prefix(line + i, len); } -static void confirm_suggestion(Text *text, TextUndoBuf *utxt) +static void confirm_suggestion(Text *text) { SuggItem *sel; int i, over = 0; @@ -285,7 +285,7 @@ static void confirm_suggestion(Text *text, TextUndoBuf *utxt) // for (i = 0; i < skipleft; i++) // txt_move_left(text, 0); BLI_assert(memcmp(sel->name, &line[i], over) == 0); - txt_insert_buf(text, utxt, sel->name + over); + txt_insert_buf(text, sel->name + over); // for (i = 0; i < skipleft; i++) // txt_move_right(text, 0); @@ -308,8 +308,8 @@ static int text_autocomplete_invoke(bContext *C, wmOperator *op, const wmEvent * ED_area_tag_redraw(CTX_wm_area(C)); if (texttool_suggest_first() == texttool_suggest_last()) { - TextUndoBuf *utxt = ED_text_undo_push_init(C); - confirm_suggestion(st->text, utxt); + ED_text_undo_push_init(C); + confirm_suggestion(st->text); text_update_line_edited(st->text->curl); text_autocomplete_free(C, op); ED_undo_push(C, op->type->name); @@ -371,8 +371,8 @@ static int text_autocomplete_modal(bContext *C, wmOperator *op, const wmEvent *e case MIDDLEMOUSE: if (event->val == KM_PRESS) { if (text_do_suggest_select(st, ar)) { - TextUndoBuf *utxt = ED_text_undo_push_init(C); - confirm_suggestion(st->text, utxt); + ED_text_undo_push_init(C); + confirm_suggestion(st->text); text_update_line_edited(st->text->curl); ED_undo_push(C, op->type->name); swallow = 1; @@ -410,8 +410,8 @@ static int text_autocomplete_modal(bContext *C, wmOperator *op, const wmEvent *e case PADENTER: if (event->val == KM_PRESS) { if (tools & TOOL_SUGG_LIST) { - TextUndoBuf *utxt = ED_text_undo_push_init(C); - confirm_suggestion(st->text, utxt); + ED_text_undo_push_init(C); + confirm_suggestion(st->text); text_update_line_edited(st->text->curl); ED_undo_push(C, op->type->name); swallow = 1; diff --git a/source/blender/editors/space_text/text_ops.c b/source/blender/editors/space_text/text_ops.c index 33bacb0a95f..4992a73f936 100644 --- a/source/blender/editors/space_text/text_ops.c +++ b/source/blender/editors/space_text/text_ops.c @@ -840,7 +840,7 @@ static int text_paste_exec(bContext *C, wmOperator *op) text_drawcache_tag_update(CTX_wm_space_text(C), 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); /* Convert clipboard content indentation to spaces if specified */ if (text->flags & TXT_TABSTOSPACES) { @@ -849,7 +849,7 @@ static int text_paste_exec(bContext *C, wmOperator *op) buf = new_buf; } - txt_insert_buf(text, utxt, buf); + txt_insert_buf(text, buf); text_update_edited(text); MEM_freeN(buf); @@ -893,9 +893,9 @@ static int text_duplicate_line_exec(bContext *C, wmOperator *UNUSED(op)) { Text *text = CTX_data_edit_text(C); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); - txt_duplicate_line(text, utxt); + txt_duplicate_line(text); WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text); @@ -971,8 +971,8 @@ static int text_cut_exec(bContext *C, wmOperator *UNUSED(op)) txt_copy_clipboard(text); - TextUndoBuf *utxt = ED_text_undo_push_init(C); - txt_delete_selected(text, utxt); + ED_text_undo_push_init(C); + txt_delete_selected(text); text_update_cursor_moved(C); WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text); @@ -1008,14 +1008,14 @@ static int text_indent_exec(bContext *C, wmOperator *UNUSED(op)) text_drawcache_tag_update(CTX_wm_space_text(C), 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); if (txt_has_sel(text)) { txt_order_cursors(text, false); - txt_indent(text, utxt); + txt_indent(text); } else { - txt_add_char(text, utxt, '\t'); + txt_add_char(text, '\t'); } text_update_edited(text); @@ -1049,10 +1049,10 @@ static int text_unindent_exec(bContext *C, wmOperator *UNUSED(op)) text_drawcache_tag_update(CTX_wm_space_text(C), 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); txt_order_cursors(text, false); - txt_unindent(text, utxt); + txt_unindent(text); text_update_edited(text); @@ -1090,15 +1090,15 @@ static int text_line_break_exec(bContext *C, wmOperator *UNUSED(op)) // double check tabs/spaces before splitting the line curts = txt_setcurr_tab_spaces(text, space); - TextUndoBuf *utxt = ED_text_undo_push_init(C); - txt_split_curline(text, utxt); + ED_text_undo_push_init(C); + txt_split_curline(text); for (a = 0; a < curts; a++) { if (text->flags & TXT_TABSTOSPACES) { - txt_add_char(text, utxt, ' '); + txt_add_char(text, ' '); } else { - txt_add_char(text, utxt, '\t'); + txt_add_char(text, '\t'); } } @@ -1139,10 +1139,10 @@ static int text_comment_exec(bContext *C, wmOperator *UNUSED(op)) if (txt_has_sel(text)) { text_drawcache_tag_update(CTX_wm_space_text(C), 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); txt_order_cursors(text, false); - txt_comment(text, utxt); + txt_comment(text); text_update_edited(text); text_update_cursor_moved(C); @@ -1177,10 +1177,10 @@ static int text_uncomment_exec(bContext *C, wmOperator *UNUSED(op)) if (txt_has_sel(text)) { text_drawcache_tag_update(CTX_wm_space_text(C), 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); txt_order_cursors(text, false); - txt_uncomment(text, utxt); + txt_uncomment(text); text_update_edited(text); text_update_cursor_moved(C); @@ -1446,9 +1446,9 @@ static int move_lines_exec(bContext *C, wmOperator *op) Text *text = CTX_data_edit_text(C); const int direction = RNA_enum_get(op->ptr, "direction"); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); - txt_move_lines(text, utxt, direction); + txt_move_lines(text, direction); text_update_cursor_moved(C); WM_event_add_notifier(C, NC_TEXT | NA_EDITED, text); @@ -2230,13 +2230,13 @@ static int text_delete_exec(bContext *C, wmOperator *op) } } - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); if (type == DEL_PREV_WORD) { if (txt_cursor_is_line_start(text)) { - txt_backspace_char(text, utxt); + txt_backspace_char(text); } - txt_backspace_word(text, utxt); + txt_backspace_word(text); } else if (type == DEL_PREV_CHAR) { @@ -2252,13 +2252,13 @@ static int text_delete_exec(bContext *C, wmOperator *op) } } - txt_backspace_char(text, utxt); + txt_backspace_char(text); } else if (type == DEL_NEXT_WORD) { if (txt_cursor_is_line_end(text)) { - txt_delete_char(text, utxt); + txt_delete_char(text); } - txt_delete_word(text, utxt); + txt_delete_word(text); } else if (type == DEL_NEXT_CHAR) { @@ -2274,7 +2274,7 @@ static int text_delete_exec(bContext *C, wmOperator *op) } } - txt_delete_char(text, utxt); + txt_delete_char(text); } text_update_line_edited(text->curl); @@ -3190,18 +3190,18 @@ static int text_insert_exec(bContext *C, wmOperator *op) str = RNA_string_get_alloc(op->ptr, "text", NULL, 0); - TextUndoBuf *utxt = ED_text_undo_push_init(C); + ED_text_undo_push_init(C); if (st && st->overwrite) { while (str[i]) { code = BLI_str_utf8_as_unicode_step(str, &i); - done |= txt_replace_char(text, utxt, code); + done |= txt_replace_char(text, code); } } else { while (str[i]) { code = BLI_str_utf8_as_unicode_step(str, &i); - done |= txt_add_char(text, utxt, code); + done |= txt_add_char(text, code); } } @@ -3319,8 +3319,8 @@ static int text_find_and_replace(bContext *C, wmOperator *op, short mode) if (found) { if (mode == TEXT_REPLACE) { - TextUndoBuf *utxt = ED_text_undo_push_init(C); - txt_insert_buf(text, utxt, st->replacestr); + ED_text_undo_push_init(C); + txt_insert_buf(text, st->replacestr); if (text->curl && text->curl->format) { MEM_freeN(text->curl->format); text->curl->format = NULL; diff --git a/source/blender/editors/space_text/text_undo.c b/source/blender/editors/space_text/text_undo.c index 66cbaa8bb5b..6ecb2b731b0 100644 --- a/source/blender/editors/space_text/text_undo.c +++ b/source/blender/editors/space_text/text_undo.c @@ -25,6 +25,7 @@ #include "DNA_text_types.h" +#include "BLI_array_store.h" #include "BLI_array_utils.h" #include "BLT_translation.h" @@ -35,6 +36,7 @@ #include "BKE_report.h" #include "BKE_text.h" #include "BKE_undo_system.h" +#include "BKE_main.h" #include "WM_api.h" #include "WM_types.h" @@ -53,18 +55,32 @@ #include "text_intern.h" #include "text_format.h" -/* TODO(campbell): undo_system: move text undo out of text block. */ - /* -------------------------------------------------------------------- */ /** \name Implements ED Undo System * \{ */ +#define ARRAY_CHUNK_SIZE 128 + typedef struct TextUndoStep { UndoStep step; UndoRefID_Text text_ref; - TextUndoBuf data; + struct { + BArrayState *state; + int buf_len; + } data; + + struct { + int line, line_select; + int column, column_select; + } cursor; + } TextUndoStep; +static struct { + BArrayStore *buffer_store; + int users; +} g_text_buffers = {NULL}; + static bool text_undosys_poll(bContext *UNUSED(C)) { /* Only use when operators initialized. */ @@ -77,12 +93,8 @@ static void text_undosys_step_encode_init(struct bContext *C, UndoStep *us_p) TextUndoStep *us = (TextUndoStep *)us_p; BLI_assert(BLI_array_is_zeroed(&us->data, 1)); - UNUSED_VARS(C); + UNUSED_VARS(C, us); /* XXX, use to set the undo type only. */ - - us->data.buf = NULL; - us->data.len = 0; - us->data.pos = -1; } static bool text_undosys_step_encode(struct bContext *C, @@ -93,104 +105,66 @@ static bool text_undosys_step_encode(struct bContext *C, Text *text = CTX_data_edit_text(C); - /* No undo data was generated. Hint, use global undo here. */ - if ((us->data.pos == -1) || (us->data.buf == NULL)) { - return false; + int buf_len = 0; + + uchar *buf = (uchar *)txt_to_buf_for_undo(text, &buf_len); + if (g_text_buffers.buffer_store == NULL) { + g_text_buffers.buffer_store = BLI_array_store_create(1, ARRAY_CHUNK_SIZE); } + g_text_buffers.users += 1; + const size_t total_size_prev = BLI_array_store_calc_size_compacted_get( + g_text_buffers.buffer_store); - us_p->is_applied = true; + us->data.state = BLI_array_store_state_add(g_text_buffers.buffer_store, buf, buf_len, NULL); + MEM_freeN(buf); - us->text_ref.ptr = text; + us->cursor.line = txt_get_span(text->lines.first, text->curl); + us->cursor.column = text->curc; - us->step.data_size = us->data.len; - - return true; -} - -static void text_undosys_step_decode_undo_impl(Text *text, TextUndoStep *us) -{ - BLI_assert(us->step.is_applied == true); - TextUndoBuf data = us->data; - while (data.pos > -1) { - txt_do_undo(text, &data); + if (txt_has_sel(text)) { + us->cursor.line_select = (text->curl == text->sell) ? + us->cursor.line : + txt_get_span(text->lines.first, text->sell); + us->cursor.column_select = text->selc; } - BLI_assert(data.pos == -1); - us->step.is_applied = false; -} - -static void text_undosys_step_decode_redo_impl(Text *text, TextUndoStep *us) -{ - BLI_assert(us->step.is_applied == false); - TextUndoBuf data = us->data; - data.pos = -1; - while (data.pos < us->data.pos) { - txt_do_redo(text, &data); + else { + us->cursor.line_select = us->cursor.line; + us->cursor.column_select = us->cursor.column; } - BLI_assert(data.pos == us->data.pos); - us->step.is_applied = true; -} -static void text_undosys_step_decode_undo(TextUndoStep *us, bool is_final) -{ - TextUndoStep *us_iter = us; - while (us_iter->step.next && (us_iter->step.next->type == us_iter->step.type)) { - if (us_iter->step.next->is_applied == false) { - break; - } - us_iter = (TextUndoStep *)us_iter->step.next; - } - Text *text_prev = NULL; - while ((us_iter != us) || (is_final && us_iter == us)) { - Text *text = us_iter->text_ref.ptr; - text_undosys_step_decode_undo_impl(text, us_iter); - if (text_prev != text) { - text_update_edited(text); - text_prev = text; - } - if (is_final) { - break; - } - us_iter = (TextUndoStep *)us_iter->step.prev; - } -} + us_p->is_applied = true; -static void text_undosys_step_decode_redo(TextUndoStep *us) -{ - TextUndoStep *us_iter = us; - while (us_iter->step.prev && (us_iter->step.prev->type == us_iter->step.type)) { - if (us_iter->step.prev->is_applied == true) { - break; - } - us_iter = (TextUndoStep *)us_iter->step.prev; - } - Text *text_prev = NULL; - while (us_iter && (us_iter->step.is_applied == false)) { - Text *text = us_iter->text_ref.ptr; - text_undosys_step_decode_redo_impl(text, us_iter); - if (text_prev != text) { - text_update_edited(text); - text_prev = text; - } - if (us_iter == us) { - break; - } - us_iter = (TextUndoStep *)us_iter->step.next; - } + us->text_ref.ptr = text; + + us->step.data_size = BLI_array_store_calc_size_compacted_get(g_text_buffers.buffer_store) - + total_size_prev; + + return true; } -static void text_undosys_step_decode( - struct bContext *C, struct Main *UNUSED(bmain), UndoStep *us_p, int dir, bool is_final) +static void text_undosys_step_decode(struct bContext *C, + struct Main *UNUSED(bmain), + UndoStep *us_p, + int UNUSED(dir), + bool UNUSED(is_final)) { TextUndoStep *us = (TextUndoStep *)us_p; + Text *text = us->text_ref.ptr; + size_t buf_len; - if (dir < 0) { - text_undosys_step_decode_undo(us, is_final); + { + const uchar *buf = BLI_array_store_state_data_get_alloc(us->data.state, &buf_len); + txt_from_buf_for_undo(text, (const char *)buf, buf_len); + MEM_freeN((void *)buf); } - else { - text_undosys_step_decode_redo(us); + + const bool has_select = ((us->cursor.line != us->cursor.line_select) || + (us->cursor.column != us->cursor.column_select)); + if (has_select) { + txt_move_to(text, us->cursor.line_select, us->cursor.column_select, false); } + txt_move_to(text, us->cursor.line, us->cursor.column, has_select); - Text *text = us->text_ref.ptr; SpaceText *st = CTX_wm_space_text(C); if (st) { /* Not essential, always show text being undo where possible. */ @@ -204,7 +178,14 @@ static void text_undosys_step_decode( static void text_undosys_step_free(UndoStep *us_p) { TextUndoStep *us = (TextUndoStep *)us_p; - MEM_SAFE_FREE(us->data.buf); + + BLI_array_store_state_remove(g_text_buffers.buffer_store, us->data.state); + + g_text_buffers.users -= 1; + if (g_text_buffers.users == 0) { + BLI_array_store_destroy(g_text_buffers.buffer_store); + g_text_buffers.buffer_store = NULL; + } } static void text_undosys_foreach_ID_ref(UndoStep *us_p, @@ -240,12 +221,16 @@ void ED_text_undosys_type(UndoType *ut) * \{ */ /* Use operator system to finish the undo step. */ -TextUndoBuf *ED_text_undo_push_init(bContext *C) +UndoStep *ED_text_undo_push_init(bContext *C) { UndoStack *ustack = ED_undo_stack_get(); - UndoStep *us_p = BKE_undosys_step_push_init_with_type(ustack, C, NULL, BKE_UNDOSYS_TYPE_TEXT); - TextUndoStep *us = (TextUndoStep *)us_p; - return &us->data; + Main *bmain = CTX_data_main(C); + wmWindowManager *wm = bmain->wm.first; + if (wm->op_undo_depth <= 1) { + UndoStep *us_p = BKE_undosys_step_push_init_with_type(ustack, C, NULL, BKE_UNDOSYS_TYPE_TEXT); + return us_p; + } + return NULL; } /** \} */ diff --git a/source/blender/makesdna/DNA_text_types.h b/source/blender/makesdna/DNA_text_types.h index 8dfaf95a10a..4eec2c1fde8 100644 --- a/source/blender/makesdna/DNA_text_types.h +++ b/source/blender/makesdna/DNA_text_types.h @@ -55,8 +55,6 @@ typedef struct Text { } Text; #define TXT_TABSIZE 4 -#define TXT_INIT_UNDO 1024 -#define TXT_MAX_UNDO (TXT_INIT_UNDO * TXT_INIT_UNDO) /* text flags */ enum { diff --git a/source/blender/makesrna/intern/rna_text_api.c b/source/blender/makesrna/intern/rna_text_api.c index ad36a56ac6a..4ca48226ee9 100644 --- a/source/blender/makesrna/intern/rna_text_api.c +++ b/source/blender/makesrna/intern/rna_text_api.c @@ -34,13 +34,13 @@ static void rna_Text_clear(Text *text) { - BKE_text_clear(text, NULL); + BKE_text_clear(text); WM_main_add_notifier(NC_TEXT | NA_EDITED, text); } static void rna_Text_write(Text *text, const char *str) { - BKE_text_write(text, NULL, str); + BKE_text_write(text, str); WM_main_add_notifier(NC_TEXT | NA_EDITED, text); } -- cgit v1.2.3