ole32: Add IContextCallback interface to context object.
[wine] / dlls / 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 = (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 }