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 = (ME_DisplayItem *)ALLOC_OBJ(ME_UndoItem);
59 ((ME_UndoItem *)pItem)->nCR = ((ME_UndoItem *)pItem)->nLF = -1;
60 switch(type)
61 {
62 case diUndoPotentialEndTransaction:
63 /* only should be added for manually typed chars, not undos or redos */
64 assert(editor->nUndoMode == umAddToUndo);
65 /* intentional fall-through to next case */
66 case diUndoEndTransaction:
67 break;
68 case diUndoSetParagraphFormat:
69 assert(pdi);
70 pItem->member.para = pdi->member.para;
71 pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
72 *pItem->member.para.pFmt = *pdi->member.para.pFmt;
73 break;
74 case diUndoInsertRun:
75 assert(pdi);
76 pItem->member.run = pdi->member.run;
77 pItem->member.run.strText = ME_StrDup(pItem->member.run.strText);
78 ME_AddRefStyle(pItem->member.run.style);
79 if (pdi->member.run.ole_obj)
80 {
81 pItem->member.run.ole_obj = ALLOC_OBJ(*pItem->member.run.ole_obj);
82 ME_CopyReObject(pItem->member.run.ole_obj, pdi->member.run.ole_obj);
83 }
84 else pItem->member.run.ole_obj = NULL;
85 break;
86 case diUndoSetCharFormat:
87 break;
88 case diUndoDeleteRun:
89 case diUndoJoinParagraphs:
90 break;
91 case diUndoSplitParagraph:
92 {
93 ME_DisplayItem *prev_para = pdi->member.para.prev_para;
94 assert(pdi->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
95 pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
96 pItem->member.para.pFmt->cbSize = sizeof(PARAFORMAT2);
97 pItem->member.para.pFmt->dwMask = 0;
98 *pItem->member.para.pFmt = *pdi->member.para.pFmt;
99 pItem->member.para.border = pdi->member.para.border;
100 pItem->member.para.nFlags = prev_para->member.para.nFlags & ~MEPF_CELL;
101 pItem->member.para.pCell = NULL;
102 break;
103 }
104 default:
105 assert(0 == "AddUndoItem, unsupported item type");
106 return NULL;
107 }
108 pItem->type = type;
109 pItem->prev = NULL;
110 if (editor->nUndoMode == umAddToUndo || editor->nUndoMode == umAddBackToUndo)
111 {
112 if (editor->pUndoStack
113 && editor->pUndoStack->type == diUndoPotentialEndTransaction)
114 {
115 editor->pUndoStack->type = diUndoEndTransaction;
116 }
117 if (editor->nUndoMode == umAddToUndo)
118 TRACE("Pushing id=%s to undo stack, deleting redo stack\n", ME_GetDITypeName(type));
119 else
120 TRACE("Pushing id=%s to undo stack\n", ME_GetDITypeName(type));
121
122 pItem->next = editor->pUndoStack;
123 if (type == diUndoEndTransaction || type == diUndoPotentialEndTransaction)
124 editor->nUndoStackSize++;
125 if (editor->pUndoStack)
126 editor->pUndoStack->prev = pItem;
127 else
128 editor->pUndoStackBottom = pItem;
129 editor->pUndoStack = pItem;
130
131 if (editor->nUndoStackSize > editor->nUndoLimit)
132 { /* remove oldest undo from stack */
133 ME_DisplayItem *p = editor->pUndoStackBottom;
134 while (p->type !=diUndoEndTransaction)
135 p = p->prev; /*find new stack bottom */
136 editor->pUndoStackBottom = p->prev;
137 editor->pUndoStackBottom->next = NULL;
138 do
139 {
140 ME_DisplayItem *pp = p->next;
141 ME_DestroyDisplayItem(p);
142 p = pp;
143 } while (p);
144 editor->nUndoStackSize--;
145 }
146 /* any new operation (not redo) clears the redo stack */
147 if (editor->nUndoMode == umAddToUndo) {
148 ME_DisplayItem *p = editor->pRedoStack;
149 while(p)
150 {
151 ME_DisplayItem *pp = p->next;
152 ME_DestroyDisplayItem(p);
153 p = pp;
154 }
155 editor->pRedoStack = NULL;
156 }
157 }
158 else if (editor->nUndoMode == umAddToRedo)
159 {
160 TRACE("Pushing id=%s to redo stack\n", ME_GetDITypeName(type));
161 pItem->next = editor->pRedoStack;
162 if (editor->pRedoStack)
163 editor->pRedoStack->prev = pItem;
164 editor->pRedoStack = pItem;
165 }
166 else
167 assert(0);
168 return (ME_UndoItem *)pItem;
169 }
170 }
171
172 /**
173 * Commits preceding changes into a transaction that can be undone together.
174 *
175 * This should be called after all the changes occur associated with an event
176 * so that the group of changes can be undone atomically as a transaction.
177 *
178 * This will have no effect the undo mode is set to ignore changes, or if no
179 * changes preceded calling this function before the last time it was called.
180 *
181 * This can also be used to conclude a coalescing transaction (used for grouping
182 * typed characters).
183 */
184 void ME_CommitUndo(ME_TextEditor *editor) {
185 if (editor->nUndoMode == umIgnore)
186 return;
187
188 assert(editor->nUndoMode == umAddToUndo);
189
190 /* no transactions, no need to commit */
191 if (!editor->pUndoStack)
192 return;
193
194 /* no need to commit empty transactions */
195 if (editor->pUndoStack->type == diUndoEndTransaction)
196 return;
197
198 if (editor->pUndoStack->type == diUndoPotentialEndTransaction)
199 {
200 /* Previous transaction was as a result of characters typed,
201 * so the end of this transaction is confirmed. */
202 editor->pUndoStack->type = diUndoEndTransaction;
203 return;
204 }
205
206 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
207 ME_SendSelChange(editor);
208 }
209
210 /**
211 * Groups supsequent changes with previous ones for an undo if coalescing.
212 *
213 * Has no effect if the previous changes were followed by a ME_CommitUndo. This
214 * function will only have an affect if the previous changes were followed by
215 * a call to ME_CommitCoalescingUndo, which allows the transaction to be
216 * continued.
217 *
218 * This allows multiple consecutively typed characters to be grouped together
219 * to be undone by a single undo operation.
220 */
221 void ME_ContinueCoalescingTransaction(ME_TextEditor *editor)
222 {
223 ME_DisplayItem* p;
224
225 if (editor->nUndoMode == umIgnore)
226 return;
227
228 assert(editor->nUndoMode == umAddToUndo);
229
230 p = editor->pUndoStack;
231
232 if (p && p->type == diUndoPotentialEndTransaction) {
233 assert(p->next); /* EndTransactions shouldn't be at bottom of undo stack */
234 editor->pUndoStack = p->next;
235 editor->pUndoStack->prev = NULL;
236 editor->nUndoStackSize--;
237 ME_DestroyDisplayItem(p);
238 }
239 }
240
241 /**
242 * Commits preceding changes into a undo transaction that can be expanded.
243 *
244 * This function allows the transaction to be reopened with
245 * ME_ContinueCoalescingTransaction in order to continue the transaction. If an
246 * undo item is added to the undo stack as a result of a change without the
247 * transaction being reopened, then the transaction will be ended, and the
248 * changes will become a part of the next transaction.
249 *
250 * This is used to allow typed characters to be grouped together since each
251 * typed character results in a single event, and each event adding undo items
252 * must be committed. Using this function as opposed to ME_CommitUndo allows
253 * multiple events to be grouped, and undone together.
254 */
255 void ME_CommitCoalescingUndo(ME_TextEditor *editor)
256 {
257 if (editor->nUndoMode == umIgnore)
258 return;
259
260 assert(editor->nUndoMode == umAddToUndo);
261
262 /* no transactions, no need to commit */
263 if (!editor->pUndoStack)
264 return;
265
266 /* no need to commit empty transactions */
267 if (editor->pUndoStack->type == diUndoEndTransaction)
268 return;
269 if (editor->pUndoStack->type == diUndoPotentialEndTransaction)
270 return;
271
272 ME_AddUndoItem(editor, diUndoPotentialEndTransaction, NULL);
273 ME_SendSelChange(editor);
274 }
275
276 static void ME_PlayUndoItem(ME_TextEditor *editor, ME_DisplayItem *pItem)
277 {
278 ME_UndoItem *pUItem = (ME_UndoItem *)pItem;
279
280 if (editor->nUndoMode == umIgnore)
281 return;
282 TRACE("Playing undo/redo item, id=%s\n", ME_GetDITypeName(pItem->type));
283
284 switch(pItem->type)
285 {
286 case diUndoPotentialEndTransaction:
287 case diUndoEndTransaction:
288 assert(0);
289 case diUndoSetParagraphFormat:
290 {
291 ME_Cursor tmp;
292 ME_DisplayItem *para;
293 ME_CursorFromCharOfs(editor, pItem->member.para.nCharOfs, &tmp);
294 para = ME_FindItemBack(tmp.pRun, diParagraph);
295 ME_AddUndoItem(editor, diUndoSetParagraphFormat, para);
296 *para->member.para.pFmt = *pItem->member.para.pFmt;
297 para->member.para.border = pItem->member.para.border;
298 break;
299 }
300 case diUndoSetCharFormat:
301 {
302 ME_SetCharFormat(editor, pUItem->nStart, pUItem->nLen, &pItem->member.ustyle->fmt);
303 break;
304 }
305 case diUndoInsertRun:
306 {
307 ME_InsertRun(editor, pItem->member.run.nCharOfs, pItem);
308 break;
309 }
310 case diUndoDeleteRun:
311 {
312 ME_InternalDeleteText(editor, pUItem->nStart, pUItem->nLen, TRUE);
313 break;
314 }
315 case diUndoJoinParagraphs:
316 {
317 ME_Cursor tmp;
318 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
319 /* the only thing that's needed is paragraph offset, so no need to split runs */
320 ME_JoinParagraphs(editor, ME_GetParagraph(tmp.pRun), TRUE);
321 break;
322 }
323 case diUndoSplitParagraph:
324 {
325 ME_Cursor tmp;
326 ME_DisplayItem *this_para, *new_para;
327 BOOL bFixRowStart;
328 int paraFlags = pItem->member.para.nFlags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND);
329 ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
330 if (tmp.nOffset)
331 tmp.pRun = ME_SplitRunSimple(editor, tmp.pRun, tmp.nOffset);
332 assert(pUItem->nCR >= 0);
333 assert(pUItem->nLF >= 0);
334 this_para = ME_GetParagraph(tmp.pRun);
335 bFixRowStart = this_para->member.para.nFlags & MEPF_ROWSTART;
336 if (bFixRowStart)
337 {
338 /* Re-insert the paragraph before the table, making sure the nFlag value
339 * is correct. */
340 this_para->member.para.nFlags &= ~MEPF_ROWSTART;
341 }
342 new_para = ME_SplitParagraph(editor, tmp.pRun, tmp.pRun->member.run.style,
343 pUItem->nCR, pUItem->nLF, paraFlags);
344 if (bFixRowStart)
345 new_para->member.para.nFlags |= MEPF_ROWSTART;
346 assert(pItem->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
347 *new_para->member.para.pFmt = *pItem->member.para.pFmt;
348 new_para->member.para.border = pItem->member.para.border;
349 if (pItem->member.para.pCell)
350 {
351 ME_DisplayItem *pItemCell, *pCell;
352 pItemCell = pItem->member.para.pCell;
353 pCell = new_para->member.para.pCell;
354 pCell->member.cell.nRightBoundary = pItemCell->member.cell.nRightBoundary;
355 pCell->member.cell.border = pItemCell->member.cell.border;
356 }
357 break;
358 }
359 default:
360 assert(0 == "PlayUndoItem, unexpected type");
361 }
362 }
363
364 BOOL ME_Undo(ME_TextEditor *editor) {
365 ME_DisplayItem *p;
366 ME_UndoMode nMode = editor->nUndoMode;
367
368 if (editor->nUndoMode == umIgnore)
369 return FALSE;
370 assert(nMode == umAddToUndo || nMode == umIgnore);
371
372 /* no undo items ? */
373 if (!editor->pUndoStack)
374 return FALSE;
375
376 /* watch out for uncommitted transactions ! */
377 assert(editor->pUndoStack->type == diUndoEndTransaction
378 || editor->pUndoStack->type == diUndoPotentialEndTransaction);
379
380 editor->nUndoMode = umAddToRedo;
381 p = editor->pUndoStack->next;
382 ME_DestroyDisplayItem(editor->pUndoStack);
383 editor->pUndoStack = p;
384 do {
385 p->prev = NULL;
386 ME_PlayUndoItem(editor, p);
387 editor->pUndoStack = p->next;
388 ME_DestroyDisplayItem(p);
389 p = editor->pUndoStack;
390 } while(p && p->type != diUndoEndTransaction);
391 if (p)
392 p->prev = NULL;
393 ME_MoveCursorFromTableRowStartParagraph(editor);
394 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
395 ME_CheckTablesForCorruption(editor);
396 editor->nUndoStackSize--;
397 editor->nUndoMode = nMode;
398 ME_UpdateRepaint(editor);
399 return TRUE;
400 }
401
402 BOOL ME_Redo(ME_TextEditor *editor) {
403 ME_DisplayItem *p;
404 ME_UndoMode nMode = editor->nUndoMode;
405
406 assert(nMode == umAddToUndo || nMode == umIgnore);
407
408 if (editor->nUndoMode == umIgnore)
409 return FALSE;
410 /* no redo items ? */
411 if (!editor->pRedoStack)
412 return FALSE;
413
414 /* watch out for uncommitted transactions ! */
415 assert(editor->pRedoStack->type == diUndoEndTransaction);
416
417 editor->nUndoMode = umAddBackToUndo;
418 p = editor->pRedoStack->next;
419 ME_DestroyDisplayItem(editor->pRedoStack);
420 editor->pRedoStack = p;
421 do {
422 p->prev = NULL;
423 ME_PlayUndoItem(editor, p);
424 editor->pRedoStack = p->next;
425 ME_DestroyDisplayItem(p);
426 p = editor->pRedoStack;
427 } while(p && p->type != diUndoEndTransaction);
428 if (p)
429 p->prev = NULL;
430 ME_MoveCursorFromTableRowStartParagraph(editor);
431 ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
432 ME_CheckTablesForCorruption(editor);
433 editor->nUndoMode = nMode;
434 ME_UpdateRepaint(editor);
435 return TRUE;
436 }
437
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.