2 * RichEdit - functions dealing with editor object
4 * Copyright 2004 by Krzysztof Foltman
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.
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.
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
23 WINE_DEFAULT_DEBUG_CHANNEL(richedit
);
25 void ME_EmptyUndoStack(ME_TextEditor
*editor
)
27 ME_DisplayItem
*p
, *pNext
;
29 if (editor
->nUndoMode
== umIgnore
)
32 TRACE("Emptying undo stack\n");
34 p
= editor
->pUndoStack
;
35 editor
->pUndoStack
= editor
->pUndoStackBottom
= NULL
;
36 editor
->nUndoStackSize
= 0;
39 ME_DestroyDisplayItem(p
);
42 p
= editor
->pRedoStack
;
43 editor
->pRedoStack
= NULL
;
46 ME_DestroyDisplayItem(p
);
51 ME_UndoItem
*ME_AddUndoItem(ME_TextEditor
*editor
, ME_DIType type
, const ME_DisplayItem
*pdi
) {
52 if (editor
->nUndoMode
== umIgnore
)
54 else if (editor
->nUndoLimit
== 0)
58 ME_DisplayItem
*pItem
= ALLOC_OBJ(ME_UndoItem
);
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
:
67 case diUndoSetParagraphFormat
:
69 pItem
->member
.para
= pdi
->member
.para
;
70 pItem
->member
.para
.pFmt
= ALLOC_OBJ(PARAFORMAT2
);
71 *pItem
->member
.para
.pFmt
= *pdi
->member
.para
.pFmt
;
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
)
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
);
83 else pItem
->member
.run
.ole_obj
= NULL
;
85 case diUndoSetCharFormat
:
88 case diUndoJoinParagraphs
:
90 case diUndoSplitParagraph
:
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
;
104 assert(0 == "AddUndoItem, unsupported item type");
109 if (editor
->nUndoMode
== umAddToUndo
|| editor
->nUndoMode
== umAddBackToUndo
)
111 if (editor
->pUndoStack
112 && editor
->pUndoStack
->type
== diUndoPotentialEndTransaction
)
114 editor
->pUndoStack
->type
= diUndoEndTransaction
;
116 if (editor
->nUndoMode
== umAddToUndo
)
117 TRACE("Pushing id=%s to undo stack, deleting redo stack\n", ME_GetDITypeName(type
));
119 TRACE("Pushing id=%s to undo stack\n", ME_GetDITypeName(type
));
121 pItem
->next
= editor
->pUndoStack
;
122 if (type
== diUndoEndTransaction
|| type
== diUndoPotentialEndTransaction
)
123 editor
->nUndoStackSize
++;
124 if (editor
->pUndoStack
)
125 editor
->pUndoStack
->prev
= pItem
;
127 editor
->pUndoStackBottom
= pItem
;
128 editor
->pUndoStack
= pItem
;
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
;
139 ME_DisplayItem
*pp
= p
->next
;
140 ME_DestroyDisplayItem(p
);
143 editor
->nUndoStackSize
--;
145 /* any new operation (not redo) clears the redo stack */
146 if (editor
->nUndoMode
== umAddToUndo
) {
147 ME_DisplayItem
*p
= editor
->pRedoStack
;
150 ME_DisplayItem
*pp
= p
->next
;
151 ME_DestroyDisplayItem(p
);
154 editor
->pRedoStack
= NULL
;
157 else if (editor
->nUndoMode
== umAddToRedo
)
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
;
167 return (ME_UndoItem
*)pItem
;
172 * Commits preceding changes into a transaction that can be undone together.
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.
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.
180 * This can also be used to conclude a coalescing transaction (used for grouping
183 void ME_CommitUndo(ME_TextEditor
*editor
) {
184 if (editor
->nUndoMode
== umIgnore
)
187 assert(editor
->nUndoMode
== umAddToUndo
);
189 /* no transactions, no need to commit */
190 if (!editor
->pUndoStack
)
193 /* no need to commit empty transactions */
194 if (editor
->pUndoStack
->type
== diUndoEndTransaction
)
197 if (editor
->pUndoStack
->type
== diUndoPotentialEndTransaction
)
199 /* Previous transaction was as a result of characters typed,
200 * so the end of this transaction is confirmed. */
201 editor
->pUndoStack
->type
= diUndoEndTransaction
;
205 ME_AddUndoItem(editor
, diUndoEndTransaction
, NULL
);
209 * Groups supsequent changes with previous ones for an undo if coalescing.
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
216 * This allows multiple consecutively typed characters to be grouped together
217 * to be undone by a single undo operation.
219 void ME_ContinueCoalescingTransaction(ME_TextEditor
*editor
)
223 if (editor
->nUndoMode
== umIgnore
)
226 assert(editor
->nUndoMode
== umAddToUndo
);
228 p
= editor
->pUndoStack
;
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
);
240 * Commits preceding changes into a undo transaction that can be expanded.
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.
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.
253 void ME_CommitCoalescingUndo(ME_TextEditor
*editor
)
255 if (editor
->nUndoMode
== umIgnore
)
258 assert(editor
->nUndoMode
== umAddToUndo
);
260 /* no transactions, no need to commit */
261 if (!editor
->pUndoStack
)
264 /* no need to commit empty transactions */
265 if (editor
->pUndoStack
->type
== diUndoEndTransaction
)
267 if (editor
->pUndoStack
->type
== diUndoPotentialEndTransaction
)
270 ME_AddUndoItem(editor
, diUndoPotentialEndTransaction
, NULL
);
273 static void ME_PlayUndoItem(ME_TextEditor
*editor
, ME_DisplayItem
*pItem
)
275 ME_UndoItem
*pUItem
= (ME_UndoItem
*)pItem
;
277 if (editor
->nUndoMode
== umIgnore
)
279 TRACE("Playing undo/redo item, id=%s\n", ME_GetDITypeName(pItem
->type
));
283 case diUndoPotentialEndTransaction
:
284 case diUndoEndTransaction
:
286 case diUndoSetParagraphFormat
:
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
;
297 case diUndoSetCharFormat
:
299 ME_Cursor start
, end
;
300 ME_CursorFromCharOfs(editor
, pUItem
->nStart
, &start
);
302 ME_MoveCursorChars(editor
, &end
, pUItem
->nLen
);
303 ME_SetCharFormat(editor
, &start
, &end
, &pItem
->member
.ustyle
->fmt
);
306 case diUndoInsertRun
:
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
);
316 case diUndoDeleteRun
:
319 ME_CursorFromCharOfs(editor
, pUItem
->nStart
, &tmp
);
320 ME_InternalDeleteText(editor
, &tmp
, pUItem
->nLen
, TRUE
);
323 case diUndoJoinParagraphs
:
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
);
331 case diUndoSplitParagraph
:
334 ME_DisplayItem
*this_para
, *new_para
;
336 int paraFlags
= pItem
->member
.para
.nFlags
& (MEPF_ROWSTART
|MEPF_CELL
|MEPF_ROWEND
);
337 ME_CursorFromCharOfs(editor
, pUItem
->nStart
, &tmp
);
339 ME_SplitRunSimple(editor
, &tmp
);
340 assert(pUItem
->eol_str
);
341 this_para
= tmp
.pPara
;
342 bFixRowStart
= this_para
->member
.para
.nFlags
& MEPF_ROWSTART
;
345 /* Re-insert the paragraph before the table, making sure the nFlag value
347 this_para
->member
.para
.nFlags
&= ~MEPF_ROWSTART
;
349 new_para
= ME_SplitParagraph(editor
, tmp
.pRun
, tmp
.pRun
->member
.run
.style
,
350 pUItem
->eol_str
, paraFlags
);
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
)
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
;
367 assert(0 == "PlayUndoItem, unexpected type");
371 BOOL
ME_Undo(ME_TextEditor
*editor
) {
373 ME_UndoMode nMode
= editor
->nUndoMode
;
375 if (editor
->nUndoMode
== umIgnore
)
377 assert(nMode
== umAddToUndo
|| nMode
== umIgnore
);
379 /* no undo items ? */
380 if (!editor
->pUndoStack
)
383 /* watch out for uncommitted transactions ! */
384 assert(editor
->pUndoStack
->type
== diUndoEndTransaction
385 || editor
->pUndoStack
->type
== diUndoPotentialEndTransaction
);
387 editor
->nUndoMode
= umAddToRedo
;
388 p
= editor
->pUndoStack
->next
;
389 ME_DestroyDisplayItem(editor
->pUndoStack
);
390 editor
->pUndoStack
= p
;
393 ME_PlayUndoItem(editor
, p
);
394 editor
->pUndoStack
= p
->next
;
395 ME_DestroyDisplayItem(p
);
396 p
= editor
->pUndoStack
;
397 } while(p
&& p
->type
!= diUndoEndTransaction
);
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
);
409 BOOL
ME_Redo(ME_TextEditor
*editor
) {
411 ME_UndoMode nMode
= editor
->nUndoMode
;
413 assert(nMode
== umAddToUndo
|| nMode
== umIgnore
);
415 if (editor
->nUndoMode
== umIgnore
)
417 /* no redo items ? */
418 if (!editor
->pRedoStack
)
421 /* watch out for uncommitted transactions ! */
422 assert(editor
->pRedoStack
->type
== diUndoEndTransaction
);
424 editor
->nUndoMode
= umAddBackToUndo
;
425 p
= editor
->pRedoStack
->next
;
426 ME_DestroyDisplayItem(editor
->pRedoStack
);
427 editor
->pRedoStack
= p
;
430 ME_PlayUndoItem(editor
, p
);
431 editor
->pRedoStack
= p
->next
;
432 ME_DestroyDisplayItem(p
);
433 p
= editor
->pRedoStack
;
434 } while(p
&& p
->type
!= diUndoEndTransaction
);
437 ME_MoveCursorFromTableRowStartParagraph(editor
);
438 ME_AddUndoItem(editor
, diUndoEndTransaction
, NULL
);
439 ME_CheckTablesForCorruption(editor
);
440 editor
->nUndoMode
= nMode
;
441 ME_UpdateRepaint(editor
, FALSE
);