Move standard WGL function declarations to wingdi.h.
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 = NULL;
36   while(p) {
37     pNext = p->next;
38     ME_DestroyDisplayItem(p);    
39     p = pNext;
40   } 
41   p = editor->pRedoStack;
42   editor->pRedoStack = NULL;
43   while(p) {
44     pNext = p->next;
45     ME_DestroyDisplayItem(p);    
46     p = pNext;
47   } 
48 }
49
50 ME_UndoItem *ME_AddUndoItem(ME_TextEditor *editor, ME_DIType type, ME_DisplayItem *pdi) {
51   if (editor->nUndoMode == umIgnore)
52     return NULL;
53   else
54   {
55     ME_DisplayItem *pItem = (ME_DisplayItem *)ALLOC_OBJ(ME_UndoItem);
56     switch(type)
57     {
58     case diUndoEndTransaction:
59       break;
60     case diUndoSetParagraphFormat:
61       assert(pdi);
62       CopyMemory(&pItem->member.para, &pdi->member.para, sizeof(ME_Paragraph));
63       pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
64       CopyMemory(pItem->member.para.pFmt, pdi->member.para.pFmt, sizeof(PARAFORMAT2));
65       break;
66     case diUndoInsertRun:
67       assert(pdi);
68       CopyMemory(&pItem->member.run, &pdi->member.run, sizeof(ME_Run));
69       pItem->member.run.strText = ME_StrDup(pItem->member.run.strText);
70       ME_AddRefStyle(pItem->member.run.style);
71       break;
72     case diUndoSetCharFormat:
73     case diUndoSetDefaultCharFormat:
74       break;
75     case diUndoDeleteRun:
76     case diUndoJoinParagraphs:
77       break;
78     case diUndoSplitParagraph:
79       pItem->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
80       pItem->member.para.pFmt->cbSize = sizeof(PARAFORMAT2);
81       pItem->member.para.pFmt->dwMask = 0;
82  
83       break;
84     default:
85       assert(0 == "AddUndoItem, unsupported item type");
86       return NULL;
87     }
88     pItem->type = type;
89     pItem->prev = NULL;
90     if (editor->nUndoMode == umAddToUndo || editor->nUndoMode == umAddBackToUndo)
91     {
92       if (editor->nUndoMode == umAddToUndo)
93         TRACE("Pushing id=%s to undo stack, deleting redo stack\n", ME_GetDITypeName(type));
94       else
95         TRACE("Pushing id=%s to undo stack\n", ME_GetDITypeName(type));
96       pItem->next = editor->pUndoStack;
97       if (editor->pUndoStack)
98         editor->pUndoStack->prev = pItem;
99       editor->pUndoStack = pItem;
100       /* any new operation (not redo) clears the redo stack */
101       if (editor->nUndoMode == umAddToUndo) {
102         ME_DisplayItem *p = editor->pRedoStack;
103         while(p)
104         {
105           ME_DisplayItem *pp = p->next;
106           ME_DestroyDisplayItem(p);
107           p = pp;
108         }
109         editor->pRedoStack = NULL;
110       }
111     }
112     else if (editor->nUndoMode == umAddToRedo)
113     {
114       TRACE("Pushing id=%s to redo stack\n", ME_GetDITypeName(type));
115       pItem->next = editor->pRedoStack;
116       if (editor->pRedoStack)
117         editor->pRedoStack->prev = pItem;
118       editor->pRedoStack = pItem;
119     }
120     else
121       assert(0);
122     return (ME_UndoItem *)pItem;
123   }
124 }
125
126 void ME_CommitUndo(ME_TextEditor *editor) {
127   
128   if (editor->nUndoMode == umIgnore)
129     return;
130   
131   assert(editor->nUndoMode == umAddToUndo);
132   
133   /* no transactions, no need to commit */
134   if (!editor->pUndoStack)
135     return;
136
137   /* no need to commit empty transactions */
138   if (editor->pUndoStack->type == diUndoEndTransaction)
139     return;
140     
141   ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
142   ME_SendSelChange(editor);
143   editor->nModifyStep++;
144 }
145
146 void ME_PlayUndoItem(ME_TextEditor *editor, ME_DisplayItem *pItem)
147 {
148   ME_UndoItem *pUItem = (ME_UndoItem *)pItem;
149
150   if (editor->nUndoMode == umIgnore)
151     return;
152   TRACE("Playing undo/redo item, id=%s\n", ME_GetDITypeName(pItem->type));
153
154   switch(pItem->type)
155   {
156   case diUndoEndTransaction:
157     assert(0);
158   case diUndoSetParagraphFormat:
159   {
160     ME_Cursor tmp;
161     ME_CursorFromCharOfs(editor, pItem->member.para.nCharOfs, &tmp);
162     ME_SetParaFormat(editor, ME_FindItemBack(tmp.pRun, diParagraph), pItem->member.para.pFmt);
163     break;
164   }
165   case diUndoSetCharFormat:
166   {
167     ME_SetCharFormat(editor, pUItem->nStart, pUItem->nLen, &pItem->member.ustyle->fmt);
168     break;
169   }
170   case diUndoSetDefaultCharFormat:
171   {
172     ME_SetDefaultCharFormat(editor, &pItem->member.ustyle->fmt);
173     break;
174   }
175   case diUndoInsertRun:
176   {
177     ME_InsertRun(editor, pItem->member.run.nCharOfs, pItem);
178     break;
179   }
180   case diUndoDeleteRun:
181   {
182     ME_InternalDeleteText(editor, pUItem->nStart, pUItem->nLen);
183     break;
184   }
185   case diUndoJoinParagraphs:
186   {
187     ME_Cursor tmp;
188     ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
189     /* the only thing that's needed is paragraph offset, so no need to split runs */
190     ME_JoinParagraphs(editor, ME_GetParagraph(tmp.pRun));
191     break;
192   }
193   case diUndoSplitParagraph:
194   {
195     ME_Cursor tmp;
196     ME_DisplayItem *new_para;
197     ME_CursorFromCharOfs(editor, pUItem->nStart, &tmp);
198     if (tmp.nOffset)
199       tmp.pRun = ME_SplitRunSimple(editor, tmp.pRun, tmp.nOffset);
200     new_para = ME_SplitParagraph(editor, tmp.pRun, tmp.pRun->member.run.style);
201     assert(pItem->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
202     CopyMemory(new_para->member.para.pFmt, pItem->member.para.pFmt, sizeof(PARAFORMAT2));
203     break;
204   }
205   default:
206     assert(0 == "PlayUndoItem, unexpected type");
207   }
208 }
209
210 void ME_Undo(ME_TextEditor *editor) {
211   ME_DisplayItem *p;
212   ME_UndoMode nMode = editor->nUndoMode;
213   
214   if (editor->nUndoMode == umIgnore)
215     return;
216   assert(nMode == umAddToUndo || nMode == umIgnore);
217   
218   /* no undo items ? */
219   if (!editor->pUndoStack)
220     return;
221     
222   /* watch out for uncommited transactions ! */
223   assert(editor->pUndoStack->type == diUndoEndTransaction);
224   
225   editor->nUndoMode = umAddToRedo;
226   p = editor->pUndoStack->next;
227   ME_DestroyDisplayItem(editor->pUndoStack);
228   do {
229     ME_DisplayItem *pp = p;
230     ME_PlayUndoItem(editor, p);
231     p = p->next;
232     ME_DestroyDisplayItem(pp);
233   } while(p && p->type != diUndoEndTransaction);
234   ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
235   editor->pUndoStack = p;
236   if (p)
237     p->prev = NULL;
238   editor->nUndoMode = nMode;
239   editor->nModifyStep--;
240   ME_UpdateRepaint(editor);
241 }
242
243 void ME_Redo(ME_TextEditor *editor) {
244   ME_DisplayItem *p;
245   ME_UndoMode nMode = editor->nUndoMode;
246   
247   assert(nMode == umAddToUndo || nMode == umIgnore);
248   
249   if (editor->nUndoMode == umIgnore)
250     return;
251   /* no redo items ? */
252   if (!editor->pRedoStack)
253     return;
254     
255   /* watch out for uncommited transactions ! */
256   assert(editor->pRedoStack->type == diUndoEndTransaction);
257   
258   editor->nUndoMode = umAddBackToUndo;
259   p = editor->pRedoStack->next;
260   ME_DestroyDisplayItem(editor->pRedoStack);
261   do {
262     ME_DisplayItem *pp = p;
263     ME_PlayUndoItem(editor, p);
264     p = p->next;
265     ME_DestroyDisplayItem(pp);
266   } while(p && p->type != diUndoEndTransaction);
267   ME_AddUndoItem(editor, diUndoEndTransaction, NULL);
268   editor->pRedoStack = p;
269   if (p)
270     p->prev = NULL;
271   editor->nUndoMode = nMode;
272   editor->nModifyStep++;
273   ME_UpdateRepaint(editor);
274 }