sync with trunk r46493
[reactos.git] / dll / win32 / riched20 / undo.c
1 /*
2 * RichEdit - functions dealing with editor object
3 *
4 * Copyright 2004 by Krzysztof Foltman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "editor.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
24
25 void ME_EmptyUndoStack(ME_TextEditor *editor)
26 {
27 ME_DisplayItem *p, *pNext;
28
29 if (editor->nUndoMode == umIgnore)
30 return;
31
32 TRACE("Emptying undo stack\n");
33
34 p = editor->pUndoStack;
35 editor->pUndoStack = editor->pUndoStackBottom = NULL;
36 editor->nUndoStackSize = 0;
37 while(p) {
38 pNext = p->next;
39 ME_DestroyDisplayItem(p);
40 p = pNext;
41 }
42 p = editor->pRedoStack;
43 editor->pRedoStack = NULL;
44 while(p) {
45 pNext = p->next;
46 ME_DestroyDisplayItem(p);
47 p = pNext;
48 }
49 }
50
51 ME_UndoItem *ME_AddUndoItem(ME_TextEditor *editor, ME_DIType type, const ME_DisplayItem *pdi) {
52 if (editor->nUndoMode == umIgnore)
53 return NULL;
54 else if (editor->nUndoLimit == 0)
55 return NULL;
56 else
57 {
58 ME_DisplayItem *pItem = ALLOC_OBJ(ME_UndoItem);
59 switch(type)
60 {
61 case diUndoPotentialEndTransaction:
62 /* only should be added for manually typed chars, not undos or redos */
63 assert(editor->nUndoMode == umAddToUndo);
64 /* intentional fall-through to next case */
65 case diUndoEndTransaction:
66 break;
67 case diUndoSetParagraphFormat:
68 assert(pdi);
69 pItem->member.para = pdi->member.para;
70 pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
71 *pItem->member.para.pFmt = *pdi->member.para.pFmt;
72 break;
73 case diUndoInsertRun:
74 assert(pdi);
75 pItem->member.run = pdi->member.run;
76 pItem->member.run.strText = ME_StrDup(pItem->member.run.strText);
77 ME_AddRefStyle(pItem->member.run.style);
78 if (pdi->member.run.ole_obj)
79 {
80 pItem->member.run.ole_obj = ALLOC_OBJ(*pItem->member.run.ole_obj);
81 ME_CopyReObject(pItem->member.run.ole_obj, pdi->member.run.ole_obj);
82 }
83 else pItem->member.run.ole_obj = NULL;
84 break;
85 case diUndoSetCharFormat:
86 break;
87 case diUndoDeleteRun:
88 case diUndoJoinParagraphs:
89 break;
90 case diUndoSplitParagraph:
91 {
92 ME_DisplayItem *prev_para = pdi->member.para.prev_para;
93 assert(pdi->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
94 pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
95 pItem->member.para.pFmt->cbSize = sizeof(PARAFORMAT2);
96 pItem->member.para.pFmt->dwMask = 0;
97 *pItem->member.para.pFmt = *pdi->member.para.pFmt;
98 pItem->member.para.border = pdi->member.para.border;
99 pItem->member.para.nFlags = prev_para->member.para.nFlags & ~MEPF_CELL;
100 pItem->member.para.pCell = NULL;
101 break;
102 }
103 default:
104 assert(0 == "AddUndoItem, unsupported item type");
105 return NULL;
106 }
107 pItem->type = type;
108 pItem->prev = NULL;
109 if (editor->nUndoMode == umAddToUndo || editor->nUndoMode == umAddBackToUndo)
110 {
111 if (editor->pUndoStack
112 && editor->pUndoStack->type == diUndoPotentialEndTransaction)
113 {
114 editor->pUndoStack->type = diUndoEndTransaction;
115 }
116 if (editor->nUndoMode == umAddToUndo)
117 TRACE("Pushing id=%s to undo stack, deleting redo stack\n", ME_GetDITypeName(type));
118 else
119 TRACE("Pushing id=%s to undo stack\n", ME_GetDITypeName(type));
120
121 pItem->next = editor->pUndoStack;
122 if (type == diUndoEndTransaction || type == diUndoPotentialEndTransaction)
123 editor->nUndoStackSize++;
124 if (editor->pUndoStack)
125 editor->pUndoStack->prev = pItem;
126 else
127 editor->pUndoStackBottom = pItem;
128 editor->pUndoStack = pItem;
129
130 if (editor->nUndoStackSize > editor->nUndoLimit)
131 { /* remove oldest undo from stack */
132 ME_DisplayItem *p = editor->pUndoStackBottom;
133 while (p->type !=diUndoEndTransaction)
134 p = p->prev; /*find new stack bottom */
135 editor->pUndoStackBottom = p->prev;
136 editor->pUndoStackBottom->next = NULL;
137 do
138 {
139 ME_DisplayItem *pp = p->next;
140 ME_DestroyDisplayItem(p);
141 p = pp;
142 } while (p);
143 editor->nUndoStackSize--;
144 }
145 /* any new operation (not redo) clears the redo stack */
146 if (editor->nUndoMode == umAddToUndo) {
147 ME_DisplayItem *p = editor->pRedoStack;
148 while(p)
149 {
150 ME_DisplayItem *pp = p->next;
151 ME_DestroyDisplayItem(p);
152 p = pp;
153 }
154 editor->pRedoStack = NULL;
155 }
156 }
157 else if (editor->nUndoMode == umAddToRedo)
158 {
159 TRACE("Pushing id=%s to redo stack\n", ME_GetDITypeName(type));
160 pItem->next = editor->pRedoStack;
161 if (editor->pRedoStack)
162 editor->pRedoStack->prev = pItem;
163 editor->pRedoStack = pItem;
164 }
165 else
166 assert(0);
167 return (ME_UndoItem *)pItem;
168 }
169 }
170
171 /**
172 * Commits preceding changes into a transaction that can be undone together.
173 *
174 * This should be called after all the changes occur associated with an event
175 * so that the group of changes can be undone atomically as a transaction.
176 *
177 * This will have no effect the undo mode is set to ignore changes, or if no
178 * changes preceded calling this function before the last time it was called.
179 *
180 * This can also be used to conclude a coalescing transaction (used for grouping
181 * typed characters).
182 */
183 void ME_CommitUndo(ME_TextEditor *editor) {
184 if (editor->nUndoMode == umIgnore)
185 return;
186
187 assert(editor->nUndoMode == umAddToUndo);
188
189 /* no transactions, no need to commit */
190 if (!editor->pUndoStack)
191 return;
192
193 /* no need to commit empty transactions */
194 if (editor->pUndoStack->type == diUndoEndTransaction)
195 return;
196
197 if (editor->pUndoStack->type == diUndoPotentialEndTransaction)
198 {
199 /* Previous transaction was as a result of characters typed,
200 * so the end of this transaction is confirmed. */
201 editor->pUndoStack->type = diUndoEndTransaction;
202 return;
203 }
204
205 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
206 ME_SendSelChange(editor);
207 }
208
209 /**
210 * Groups supsequent changes with previous ones for an undo if coalescing.
211 *
212 * Has no effect if the previous changes were followed by a ME_CommitUndo. This
213 * function will only have an affect if the previous changes were followed by
214 * a call to ME_CommitCoalescingUndo, which allows the transaction to be
215 * continued.
216 *
217 * This allows multiple consecutively typed characters to be grouped together
218 * to be undone by a single undo operation.
219 */
220 void ME_ContinueCoalescingTransaction(ME_TextEditor *editor)
221 {
222 ME_DisplayItem* p;
223
224 if (editor->nUndoMode == umIgnore)
225 return;
226
227 assert(editor->nUndoMode == umAddToUndo);
228
229 p = editor->pUndoStack;
230
231 if (p && p->type == diUndoPotentialEndTransaction) {
232 assert(p->next); /* EndTransactions shouldn't be at bottom of undo stack */
233 editor->pUndoStack = p->next;
234 editor->pUndoStack->prev = NULL;
235 editor->nUndoStackSize--;
236 ME_DestroyDisplayItem(p);
237 }
238 }
239
240 /**
241 * Commits preceding changes into a undo transaction that can be expanded.
242 *
243 * This function allows the transaction to be reopened with
244 * ME_ContinueCoalescingTransaction in order to continue the transaction. If an
245 * undo item is added to the undo stack as a result of a change without the
246 * transaction being reopened, then the transaction will be ended, and the
247 * changes will become a part of the next transaction.
248 *
249 * This is used to allow typed characters to be grouped together since each
250 * typed character results in a single event, and each event adding undo items
251 * must be committed. Using this function as opposed to ME_CommitUndo allows
252 * multiple events to be grouped, and undone together.
253 */
254 void ME_CommitCoalescingUndo(ME_TextEditor *editor)
255 {
256 if (editor->nUndoMode == umIgnore)
257 return;
258
259 assert(editor->nUndoMode == umAddToUndo);
260
261 /* no transactions, no need to commit */
262 if (!editor->pUndoStack)
263 return;
264
265 /* no need to commit empty transactions */
266 if (editor->pUndoStack->type == diUndoEndTransaction)
267 return;
268 if (editor->pUndoStack->type == diUndoPotentialEndTransaction)
269 return;
270
271 ME_AddUndoItem(editor, diUndoPotentialEndTransaction, NULL);
272 ME_SendSelChange(editor);
273 }
274
275 static void ME_PlayUndoItem(ME_TextEditor *editor, ME_DisplayItem *pItem)
276 {
277 ME_UndoItem *pUItem = (ME_UndoItem *)pItem;
278
279 if (editor->nUndoMode == umIgnore)
280 return;
281 TRACE("Playing undo/redo item, id=%s\n", ME_GetDITypeName(pItem->type));
282
283 switch(pItem->type)
284 {
285 case diUndoPotentialEndTransaction:
286 case diUndoEndTransaction:
287 assert(0);
288 case diUndoSetParagraphFormat:
289 {
290 ME_Cursor tmp;
291 ME_DisplayItem *para;
292 ME_CursorFromCharOfs(editor, pItem->member.para.nCharOfs, &tmp);
293 para = ME_FindItemBack(tmp.pRun, diParagraph);
294 ME_AddUndoItem(editor, diUndoSetParagraphFormat, para);
295 *para->member.para.pFmt = *pItem->member.para.pFmt;
296 para->member.para.border = pItem->member.para.border;
297 break;
298 }
299 case diUndoSetCharFormat:
300 {
301 ME_Cursor start, end;
302 ME_CursorFromCharOfs(editor, pUItem->nStart, &start);
303 end = start;
304 ME_MoveCursorChars(editor, &end, pUItem->nLen);
305 ME_SetCharFormat(editor, &start, &end, &pItem->member.ustyle->fmt);
306 break;
307 }
308 case diUndoInsertRun:
309 {
310 ME_Cursor tmp;
311 ME_CursorFromCharOfs(editor, pItem->member.run.nCharOfs, &tmp);
312 ME_InsertRunAtCursor(editor, &tmp, pItem->member.run.style,
313 pItem->member.run.strText->szData,
314 pItem->member.run.strText->nLen,
315 pItem->member.run.nFlags);
316 break;
317 }
318 case diUndoDeleteRun:
319 {
320 ME_Cursor tmp;
321 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
322 ME_InternalDeleteText(editor, &tmp, pUItem->nLen, TRUE);
323 break;
324 }
325 case diUndoJoinParagraphs:
326 {
327 ME_Cursor tmp;
328 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
329 /* the only thing that's needed is paragraph offset, so no need to split runs */
330 ME_JoinParagraphs(editor, tmp.pPara, TRUE);
331 break;
332 }
333 case diUndoSplitParagraph:
334 {
335 ME_Cursor tmp;
336 ME_DisplayItem *this_para, *new_para;
337 BOOL bFixRowStart;
338 int paraFlags = pItem->member.para.nFlags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND);
339 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
340 if (tmp.nOffset)
341 tmp.pRun = ME_SplitRunSimple(editor, tmp.pRun, tmp.nOffset);
342 assert(pUItem->eol_str);
343 this_para = tmp.pPara;
344 bFixRowStart = this_para->member.para.nFlags & MEPF_ROWSTART;
345 if (bFixRowStart)
346 {
347 /* Re-insert the paragraph before the table, making sure the nFlag value
348 * is correct. */
349 this_para->member.para.nFlags &= ~MEPF_ROWSTART;
350 }
351 new_para = ME_SplitParagraph(editor, tmp.pRun, tmp.pRun->member.run.style,
352 pUItem->eol_str, paraFlags);
353 if (bFixRowStart)
354 new_para->member.para.nFlags |= MEPF_ROWSTART;
355 assert(pItem->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
356 *new_para->member.para.pFmt = *pItem->member.para.pFmt;
357 new_para->member.para.border = pItem->member.para.border;
358 if (pItem->member.para.pCell)
359 {
360 ME_DisplayItem *pItemCell, *pCell;
361 pItemCell = pItem->member.para.pCell;
362 pCell = new_para->member.para.pCell;
363 pCell->member.cell.nRightBoundary = pItemCell->member.cell.nRightBoundary;
364 pCell->member.cell.border = pItemCell->member.cell.border;
365 }
366 break;
367 }
368 default:
369 assert(0 == "PlayUndoItem, unexpected type");
370 }
371 }
372
373 BOOL ME_Undo(ME_TextEditor *editor) {
374 ME_DisplayItem *p;
375 ME_UndoMode nMode = editor->nUndoMode;
376
377 if (editor->nUndoMode == umIgnore)
378 return FALSE;
379 assert(nMode == umAddToUndo || nMode == umIgnore);
380
381 /* no undo items ? */
382 if (!editor->pUndoStack)
383 return FALSE;
384
385 /* watch out for uncommitted transactions ! */
386 assert(editor->pUndoStack->type == diUndoEndTransaction
387 || editor->pUndoStack->type == diUndoPotentialEndTransaction);
388
389 editor->nUndoMode = umAddToRedo;
390 p = editor->pUndoStack->next;
391 ME_DestroyDisplayItem(editor->pUndoStack);
392 editor->pUndoStack = p;
393 do {
394 p->prev = NULL;
395 ME_PlayUndoItem(editor, p);
396 editor->pUndoStack = p->next;
397 ME_DestroyDisplayItem(p);
398 p = editor->pUndoStack;
399 } while(p && p->type != diUndoEndTransaction);
400 if (p)
401 p->prev = NULL;
402 ME_MoveCursorFromTableRowStartParagraph(editor);
403 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
404 ME_CheckTablesForCorruption(editor);
405 editor->nUndoStackSize--;
406 editor->nUndoMode = nMode;
407 ME_UpdateRepaint(editor);
408 return TRUE;
409 }
410
411 BOOL ME_Redo(ME_TextEditor *editor) {
412 ME_DisplayItem *p;
413 ME_UndoMode nMode = editor->nUndoMode;
414
415 assert(nMode == umAddToUndo || nMode == umIgnore);
416
417 if (editor->nUndoMode == umIgnore)
418 return FALSE;
419 /* no redo items ? */
420 if (!editor->pRedoStack)
421 return FALSE;
422
423 /* watch out for uncommitted transactions ! */
424 assert(editor->pRedoStack->type == diUndoEndTransaction);
425
426 editor->nUndoMode = umAddBackToUndo;
427 p = editor->pRedoStack->next;
428 ME_DestroyDisplayItem(editor->pRedoStack);
429 editor->pRedoStack = p;
430 do {
431 p->prev = NULL;
432 ME_PlayUndoItem(editor, p);
433 editor->pRedoStack = p->next;
434 ME_DestroyDisplayItem(p);
435 p = editor->pRedoStack;
436 } while(p && p->type != diUndoEndTransaction);
437 if (p)
438 p->prev = NULL;
439 ME_MoveCursorFromTableRowStartParagraph(editor);
440 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
441 ME_CheckTablesForCorruption(editor);
442 editor->nUndoMode = nMode;
443 ME_UpdateRepaint(editor);
444 return TRUE;
445 }