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 }
207
208 /**
209 * Groups supsequent changes with previous ones for an undo if coalescing.
210 *
211 * Has no effect if the previous changes were followed by a ME_CommitUndo. This
212 * function will only have an affect if the previous changes were followed by
213 * a call to ME_CommitCoalescingUndo, which allows the transaction to be
214 * continued.
215 *
216 * This allows multiple consecutively typed characters to be grouped together
217 * to be undone by a single undo operation.
218 */
219 void ME_ContinueCoalescingTransaction(ME_TextEditor *editor)
220 {
221 ME_DisplayItem* p;
222
223 if (editor->nUndoMode == umIgnore)
224 return;
225
226 assert(editor->nUndoMode == umAddToUndo);
227
228 p = editor->pUndoStack;
229
230 if (p && p->type == diUndoPotentialEndTransaction) {
231 assert(p->next); /* EndTransactions shouldn't be at bottom of undo stack */
232 editor->pUndoStack = p->next;
233 editor->pUndoStack->prev = NULL;
234 editor->nUndoStackSize--;
235 ME_DestroyDisplayItem(p);
236 }
237 }
238
239 /**
240 * Commits preceding changes into a undo transaction that can be expanded.
241 *
242 * This function allows the transaction to be reopened with
243 * ME_ContinueCoalescingTransaction in order to continue the transaction. If an
244 * undo item is added to the undo stack as a result of a change without the
245 * transaction being reopened, then the transaction will be ended, and the
246 * changes will become a part of the next transaction.
247 *
248 * This is used to allow typed characters to be grouped together since each
249 * typed character results in a single event, and each event adding undo items
250 * must be committed. Using this function as opposed to ME_CommitUndo allows
251 * multiple events to be grouped, and undone together.
252 */
253 void ME_CommitCoalescingUndo(ME_TextEditor *editor)
254 {
255 if (editor->nUndoMode == umIgnore)
256 return;
257
258 assert(editor->nUndoMode == umAddToUndo);
259
260 /* no transactions, no need to commit */
261 if (!editor->pUndoStack)
262 return;
263
264 /* no need to commit empty transactions */
265 if (editor->pUndoStack->type == diUndoEndTransaction)
266 return;
267 if (editor->pUndoStack->type == diUndoPotentialEndTransaction)
268 return;
269
270 ME_AddUndoItem(editor, diUndoPotentialEndTransaction, NULL);
271 }
272
273 static void ME_PlayUndoItem(ME_TextEditor *editor, ME_DisplayItem *pItem)
274 {
275 ME_UndoItem *pUItem = (ME_UndoItem *)pItem;
276
277 if (editor->nUndoMode == umIgnore)
278 return;
279 TRACE("Playing undo/redo item, id=%s\n", ME_GetDITypeName(pItem->type));
280
281 switch(pItem->type)
282 {
283 case diUndoPotentialEndTransaction:
284 case diUndoEndTransaction:
285 assert(0);
286 case diUndoSetParagraphFormat:
287 {
288 ME_Cursor tmp;
289 ME_DisplayItem *para;
290 ME_CursorFromCharOfs(editor, pItem->member.para.nCharOfs, &tmp);
291 para = ME_FindItemBack(tmp.pRun, diParagraph);
292 ME_AddUndoItem(editor, diUndoSetParagraphFormat, para);
293 *para->member.para.pFmt = *pItem->member.para.pFmt;
294 para->member.para.border = pItem->member.para.border;
295 break;
296 }
297 case diUndoSetCharFormat:
298 {
299 ME_Cursor start, end;
300 ME_CursorFromCharOfs(editor, pUItem->nStart, &start);
301 end = start;
302 ME_MoveCursorChars(editor, &end, pUItem->nLen);
303 ME_SetCharFormat(editor, &start, &end, &pItem->member.ustyle->fmt);
304 break;
305 }
306 case diUndoInsertRun:
307 {
308 ME_Cursor tmp;
309 ME_CursorFromCharOfs(editor, pItem->member.run.nCharOfs, &tmp);
310 ME_InsertRunAtCursor(editor, &tmp, pItem->member.run.style,
311 pItem->member.run.strText->szData,
312 pItem->member.run.strText->nLen,
313 pItem->member.run.nFlags);
314 break;
315 }
316 case diUndoDeleteRun:
317 {
318 ME_Cursor tmp;
319 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
320 ME_InternalDeleteText(editor, &tmp, pUItem->nLen, TRUE);
321 break;
322 }
323 case diUndoJoinParagraphs:
324 {
325 ME_Cursor tmp;
326 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
327 /* the only thing that's needed is paragraph offset, so no need to split runs */
328 ME_JoinParagraphs(editor, tmp.pPara, TRUE);
329 break;
330 }
331 case diUndoSplitParagraph:
332 {
333 ME_Cursor tmp;
334 ME_DisplayItem *this_para, *new_para;
335 BOOL bFixRowStart;
336 int paraFlags = pItem->member.para.nFlags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND);
337 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
338 if (tmp.nOffset)
339 ME_SplitRunSimple(editor, &tmp);
340 assert(pUItem->eol_str);
341 this_para = tmp.pPara;
342 bFixRowStart = this_para->member.para.nFlags & MEPF_ROWSTART;
343 if (bFixRowStart)
344 {
345 /* Re-insert the paragraph before the table, making sure the nFlag value
346 * is correct. */
347 this_para->member.para.nFlags &= ~MEPF_ROWSTART;
348 }
349 new_para = ME_SplitParagraph(editor, tmp.pRun, tmp.pRun->member.run.style,
350 pUItem->eol_str, paraFlags);
351 if (bFixRowStart)
352 new_para->member.para.nFlags |= MEPF_ROWSTART;
353 assert(pItem->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
354 *new_para->member.para.pFmt = *pItem->member.para.pFmt;
355 new_para->member.para.border = pItem->member.para.border;
356 if (pItem->member.para.pCell)
357 {
358 ME_DisplayItem *pItemCell, *pCell;
359 pItemCell = pItem->member.para.pCell;
360 pCell = new_para->member.para.pCell;
361 pCell->member.cell.nRightBoundary = pItemCell->member.cell.nRightBoundary;
362 pCell->member.cell.border = pItemCell->member.cell.border;
363 }
364 break;
365 }
366 default:
367 assert(0 == "PlayUndoItem, unexpected type");
368 }
369 }
370
371 BOOL ME_Undo(ME_TextEditor *editor) {
372 ME_DisplayItem *p;
373 ME_UndoMode nMode = editor->nUndoMode;
374
375 if (editor->nUndoMode == umIgnore)
376 return FALSE;
377 assert(nMode == umAddToUndo || nMode == umIgnore);
378
379 /* no undo items ? */
380 if (!editor->pUndoStack)
381 return FALSE;
382
383 /* watch out for uncommitted transactions ! */
384 assert(editor->pUndoStack->type == diUndoEndTransaction
385 || editor->pUndoStack->type == diUndoPotentialEndTransaction);
386
387 editor->nUndoMode = umAddToRedo;
388 p = editor->pUndoStack->next;
389 ME_DestroyDisplayItem(editor->pUndoStack);
390 editor->pUndoStack = p;
391 do {
392 p->prev = NULL;
393 ME_PlayUndoItem(editor, p);
394 editor->pUndoStack = p->next;
395 ME_DestroyDisplayItem(p);
396 p = editor->pUndoStack;
397 } while(p && p->type != diUndoEndTransaction);
398 if (p)
399 p->prev = NULL;
400 ME_MoveCursorFromTableRowStartParagraph(editor);
401 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
402 ME_CheckTablesForCorruption(editor);
403 editor->nUndoStackSize--;
404 editor->nUndoMode = nMode;
405 ME_UpdateRepaint(editor, FALSE);
406 return TRUE;
407 }
408
409 BOOL ME_Redo(ME_TextEditor *editor) {
410 ME_DisplayItem *p;
411 ME_UndoMode nMode = editor->nUndoMode;
412
413 assert(nMode == umAddToUndo || nMode == umIgnore);
414
415 if (editor->nUndoMode == umIgnore)
416 return FALSE;
417 /* no redo items ? */
418 if (!editor->pRedoStack)
419 return FALSE;
420
421 /* watch out for uncommitted transactions ! */
422 assert(editor->pRedoStack->type == diUndoEndTransaction);
423
424 editor->nUndoMode = umAddBackToUndo;
425 p = editor->pRedoStack->next;
426 ME_DestroyDisplayItem(editor->pRedoStack);
427 editor->pRedoStack = p;
428 do {
429 p->prev = NULL;
430 ME_PlayUndoItem(editor, p);
431 editor->pRedoStack = p->next;
432 ME_DestroyDisplayItem(p);
433 p = editor->pRedoStack;
434 } while(p && p->type != diUndoEndTransaction);
435 if (p)
436 p->prev = NULL;
437 ME_MoveCursorFromTableRowStartParagraph(editor);
438 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
439 ME_CheckTablesForCorruption(editor);
440 editor->nUndoMode = nMode;
441 ME_UpdateRepaint(editor, FALSE);
442 return TRUE;
443 }
444
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.