undo.c File Reference

#include "editor.h"

Include dependency graph for undo.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (richedit)
static void	destroy_undo_item (struct undo_item *undo)
static void	empty_redo_stack (ME_TextEditor *editor)
void	ME_EmptyUndoStack (ME_TextEditor *editor)
static struct undo_item *	add_undo (ME_TextEditor *editor, enum undo_type type)
BOOL	add_undo_insert_run (ME_TextEditor *editor, int pos, const WCHAR *str, int len, int flags, ME_Style *style)
BOOL	add_undo_set_para_fmt (ME_TextEditor *editor, const ME_Paragraph *para)
BOOL	add_undo_set_char_fmt (ME_TextEditor *editor, int pos, int len, const CHARFORMAT2W *fmt)
BOOL	add_undo_join_paras (ME_TextEditor *editor, int pos)
BOOL	add_undo_split_para (ME_TextEditor *editor, const ME_Paragraph *para, ME_String *eol_str, const ME_Cell *cell)
BOOL	add_undo_delete_run (ME_TextEditor *editor, int pos, int len)
void	ME_CommitUndo (ME_TextEditor *editor)
void	ME_ContinueCoalescingTransaction (ME_TextEditor *editor)
void	ME_CommitCoalescingUndo (ME_TextEditor *editor)
static void	ME_PlayUndoItem (ME_TextEditor *editor, struct undo_item *undo)
BOOL	ME_Undo (ME_TextEditor *editor)
BOOL	ME_Redo (ME_TextEditor *editor)

Function Documentation

add_undo()

static struct undo_item * add_undo ( ME_TextEditor *  editor, enum undo_type  type  )

static

Definition at line 72 of file undo.c.

{
    struct undo_item *undo, *item;
    struct list *head;
 
    if (editor->nUndoMode == umIgnore) return NULL;
    if (editor->nUndoLimit == 0) return NULL;
 
    undo = heap_alloc( sizeof(*undo) );
    if (!undo) return NULL;
    undo->type = type;
 
    if (editor->nUndoMode == umAddToUndo || editor->nUndoMode == umAddBackToUndo)
    {
 
        head = list_head( &editor->undo_stack );
        if (head)
        {
            item = LIST_ENTRY( head, struct undo_item, entry );
            if (item->type == undo_potential_end_transaction)
                item->type = undo_end_transaction;
        }
 
        if (editor->nUndoMode == umAddToUndo)
            TRACE("Pushing id=%d to undo stack, deleting redo stack\n", type);
        else
            TRACE("Pushing id=%d to undo stack\n", type);
 
        list_add_head( &editor->undo_stack, &undo->entry );
 
        if (type == undo_end_transaction || type == undo_potential_end_transaction)
            editor->nUndoStackSize++;
 
        if (editor->nUndoStackSize > editor->nUndoLimit)
        {
            struct undo_item *cursor2;
            /* remove oldest undo from stack */
            LIST_FOR_EACH_ENTRY_SAFE_REV( item, cursor2, &editor->undo_stack, struct undo_item, entry )
            {
                BOOL done = (item->type == undo_end_transaction);
                list_remove( &item->entry );
                destroy_undo_item( item );
                if (done) break;
            }
            editor->nUndoStackSize--;
        }
 
        /* any new operation (not redo) clears the redo stack */
        if (editor->nUndoMode == umAddToUndo) empty_redo_stack( editor );
    }
    else if (editor->nUndoMode == umAddToRedo)
    {
        TRACE("Pushing id=%d to redo stack\n", type);
        list_add_head( &editor->redo_stack, &undo->entry );
    }
 
    return undo;
}

Referenced by add_undo_delete_run(), add_undo_insert_run(), add_undo_join_paras(), add_undo_set_char_fmt(), add_undo_set_para_fmt(), add_undo_split_para(), ME_CommitCoalescingUndo(), ME_CommitUndo(), ME_Redo(), and ME_Undo().

add_undo_delete_run()

BOOL add_undo_delete_run	(	ME_TextEditor *	editor,
		int	pos,
		int	len
	)

Definition at line 204 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_delete_run );
    if (!undo) return FALSE;
 
    undo->u.delete_run.pos = pos;
    undo->u.delete_run.len = len;
 
    return TRUE;
}

Referenced by run_insert().

add_undo_insert_run()

BOOL add_undo_insert_run	(	ME_TextEditor *	editor,
		int	pos,
		const WCHAR *	str,
		int	len,
		int	flags,
		ME_Style *	style
	)

Definition at line 131 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_insert_run );
    if (!undo) return FALSE;
 
    undo->u.insert_run.str = heap_alloc( (len + 1) * sizeof(WCHAR) );
    if (!undo->u.insert_run.str)
    {
        ME_EmptyUndoStack( editor );
        return FALSE;
    }
    memcpy( undo->u.insert_run.str, str, len * sizeof(WCHAR) );
    undo->u.insert_run.str[len] = 0;
    undo->u.insert_run.pos = pos;
    undo->u.insert_run.len = len;
    undo->u.insert_run.flags = flags;
    undo->u.insert_run.style = style;
    ME_AddRefStyle( style );
    return TRUE;
}

Referenced by ME_InternalDeleteText().

add_undo_join_paras()

BOOL add_undo_join_paras	(	ME_TextEditor *	editor,
		int	pos
	)

Definition at line 176 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_join_paras );
    if (!undo) return FALSE;
 
    undo->u.join_paras.pos = pos;
    return TRUE;
}

Referenced by para_split().

add_undo_set_char_fmt()

BOOL add_undo_set_char_fmt	(	ME_TextEditor *	editor,
		int	pos,
		int	len,
		const CHARFORMAT2W *	fmt
	)

Definition at line 164 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_set_char_fmt );
    if (!undo) return FALSE;
 
    undo->u.set_char_fmt.pos = pos;
    undo->u.set_char_fmt.len = len;
    undo->u.set_char_fmt.fmt = *fmt;
 
    return TRUE;
}

Referenced by ME_SetCharFormat().

add_undo_set_para_fmt()

BOOL add_undo_set_para_fmt	(	ME_TextEditor *	editor,
		const ME_Paragraph *	para
	)

Definition at line 152 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_set_para_fmt );
    if (!undo) return FALSE;
 
    undo->u.set_para_fmt.pos = para->nCharOfs;
    undo->u.set_para_fmt.fmt = para->fmt;
    undo->u.set_para_fmt.border = para->border;
 
    return TRUE;
}

Referenced by ME_PlayUndoItem(), para_join(), and para_set_fmt().

add_undo_split_para()

BOOL add_undo_split_para	(	ME_TextEditor *	editor,
		const ME_Paragraph *	para,
		ME_String *	eol_str,
		const ME_Cell *	cell
	)

Definition at line 185 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_split_para );
    if (!undo) return FALSE;
 
    undo->u.split_para.pos = para->nCharOfs - eol_str->nLen;
    undo->u.split_para.eol_str = eol_str;
    undo->u.split_para.fmt = para->fmt;
    undo->u.split_para.border = para->border;
    undo->u.split_para.flags = para->prev_para->member.para.nFlags & ~MEPF_CELL;
 
    if (cell)
    {
        undo->u.split_para.cell_border = cell->border;
        undo->u.split_para.cell_right_boundary = cell->nRightBoundary;
    }
    return TRUE;
}

Referenced by para_join().

destroy_undo_item()

static void destroy_undo_item ( struct undo_item *  undo )

static

Definition at line 25 of file undo.c.

{
    switch( undo->type )
    {
    case undo_insert_run:
        heap_free( undo->u.insert_run.str );
        ME_ReleaseStyle( undo->u.insert_run.style );
        break;
    case undo_split_para:
        ME_DestroyString( undo->u.split_para.eol_str );
        break;
    default:
        break;
    }
 
    heap_free( undo );
}

Referenced by add_undo(), empty_redo_stack(), ME_ContinueCoalescingTransaction(), ME_EmptyUndoStack(), ME_Redo(), and ME_Undo().

empty_redo_stack()

static void empty_redo_stack ( ME_TextEditor *  editor )

static

Definition at line 43 of file undo.c.

{
    struct undo_item *cursor, *cursor2;
    LIST_FOR_EACH_ENTRY_SAFE( cursor, cursor2, &editor->redo_stack, struct undo_item, entry )
    {
        list_remove( &cursor->entry );
        destroy_undo_item( cursor );
    }
}

Referenced by add_undo(), and ME_EmptyUndoStack().

ME_CommitCoalescingUndo()

void ME_CommitCoalescingUndo

(

ME_TextEditor *

editor

)

Commits preceding changes into a undo transaction that can be expanded.

This function allows the transaction to be reopened with ME_ContinueCoalescingTransaction in order to continue the transaction. If an undo item is added to the undo stack as a result of a change without the transaction being reopened, then the transaction will be ended, and the changes will become a part of the next transaction.

This is used to allow typed characters to be grouped together since each typed character results in a single event, and each event adding undo items must be committed. Using this function as opposed to ME_CommitUndo allows multiple events to be grouped, and undone together.

Definition at line 301 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
 
  assert(editor->nUndoMode == umAddToUndo);
 
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  /* no need to commit empty transactions */
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_end_transaction ||
      item->type == undo_potential_end_transaction)
      return;
 
  add_undo( editor, undo_potential_end_transaction );
}

Referenced by handle_enter(), handle_wm_char(), and ME_KeyDown().

ME_CommitUndo()

void ME_CommitUndo

(

ME_TextEditor *

editor

)

Commits preceding changes into a transaction that can be undone together.

This should be called after all the changes occur associated with an event so that the group of changes can be undone atomically as a transaction.

This will have no effect the undo mode is set to ignore changes, or if no changes preceded calling this function before the last time it was called.

This can also be used to conclude a coalescing transaction (used for grouping typed characters).

Definition at line 227 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
  
  assert(editor->nUndoMode == umAddToUndo);
  
  /* no transactions, no need to commit */
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  /* no need to commit empty transactions */
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_end_transaction) return;
 
  if (item->type == undo_potential_end_transaction)
  {
      item->type = undo_end_transaction;
      return;
  }
 
  add_undo( editor, undo_end_transaction );
}

Referenced by editor_copy_or_cut(), editor_handle_message(), handle_EM_SETCHARFORMAT(), handle_enter(), handle_wm_char(), IRichEditOle_fnInsertObject(), ME_KeyDown(), ME_ReplaceSel(), ME_StreamIn(), and paste_emf().

ME_ContinueCoalescingTransaction()

void ME_ContinueCoalescingTransaction

(

ME_TextEditor *

editor

)

Groups subsequent changes with previous ones for an undo if coalescing.

Has no effect if the previous changes were followed by a ME_CommitUndo. This function will only have an affect if the previous changes were followed by a call to ME_CommitCoalescingUndo, which allows the transaction to be continued.

This allows multiple consecutively typed characters to be grouped together to be undone by a single undo operation.

Definition at line 265 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
 
  assert(editor->nUndoMode == umAddToUndo);
 
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_potential_end_transaction)
  {
    list_remove( &item->entry );
    editor->nUndoStackSize--;
    destroy_undo_item( item );
  }
}

Referenced by handle_enter(), handle_wm_char(), and ME_KeyDown().

ME_EmptyUndoStack()

void ME_EmptyUndoStack

(

ME_TextEditor *

editor

)

Definition at line 53 of file undo.c.

{
  struct undo_item *cursor, *cursor2;
  if (editor->nUndoMode == umIgnore)
    return;
  
  TRACE("Emptying undo stack\n");
 
  editor->nUndoStackSize = 0;
 
  LIST_FOR_EACH_ENTRY_SAFE( cursor, cursor2, &editor->undo_stack, struct undo_item, entry )
  {
      list_remove( &cursor->entry );
      destroy_undo_item( cursor );
  }
 
  empty_redo_stack( editor );
}

Referenced by add_undo_insert_run(), editor_handle_message(), fnTextSrv_TxSetText(), ME_DestroyEditor(), ME_ReplaceSel(), and ME_StreamIn().

ME_PlayUndoItem()

static void ME_PlayUndoItem ( ME_TextEditor *  editor, struct undo_item *  undo  )

static

Definition at line 323 of file undo.c.

{
 
  if (editor->nUndoMode == umIgnore)
    return;
  TRACE("Playing undo/redo item, id=%d\n", undo->type);
 
  switch(undo->type)
  {
  case undo_potential_end_transaction:
  case undo_end_transaction:
    assert(0);
  case undo_set_para_fmt:
  {
    ME_Cursor tmp;
    cursor_from_char_ofs( editor, undo->u.set_para_fmt.pos, &tmp );
    add_undo_set_para_fmt( editor, tmp.para );
    tmp.para->fmt = undo->u.set_para_fmt.fmt;
    tmp.para->border = undo->u.set_para_fmt.border;
    para_mark_rewrap( editor, tmp.para );
    break;
  }
  case undo_set_char_fmt:
  {
    ME_Cursor start, end;
    cursor_from_char_ofs( editor, undo->u.set_char_fmt.pos, &start );
    end = start;
    ME_MoveCursorChars(editor, &end, undo->u.set_char_fmt.len, FALSE);
    ME_SetCharFormat(editor, &start, &end, &undo->u.set_char_fmt.fmt);
    break;
  }
  case undo_insert_run:
  {
    ME_Cursor tmp;
    cursor_from_char_ofs( editor, undo->u.insert_run.pos, &tmp );
    run_insert( editor, &tmp, undo->u.insert_run.style,
                undo->u.insert_run.str, undo->u.insert_run.len,
                undo->u.insert_run.flags );
    break;
  }
  case undo_delete_run:
  {
    ME_Cursor tmp;
    cursor_from_char_ofs( editor, undo->u.delete_run.pos, &tmp );
    ME_InternalDeleteText(editor, &tmp, undo->u.delete_run.len, TRUE);
    break;
  }
  case undo_join_paras:
  {
    ME_Cursor tmp;
    cursor_from_char_ofs( editor, undo->u.join_paras.pos, &tmp );
    para_join( editor, tmp.para, TRUE );
    break;
  }
  case undo_split_para:
  {
    ME_Cursor tmp;
    ME_Paragraph *this_para, *new_para;
    BOOL bFixRowStart;
    int paraFlags = undo->u.split_para.flags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND);
 
    cursor_from_char_ofs( editor, undo->u.split_para.pos, &tmp );
    if (tmp.nOffset) run_split( editor, &tmp );
    this_para = tmp.para;
    bFixRowStart = this_para->nFlags & MEPF_ROWSTART;
    if (bFixRowStart)
    {
      /* Re-insert the paragraph before the table, making sure the nFlag value
       * is correct. */
      this_para->nFlags &= ~MEPF_ROWSTART;
    }
    new_para = para_split( editor, tmp.run, tmp.run->style,
                           undo->u.split_para.eol_str->szData, undo->u.split_para.eol_str->nLen, paraFlags );
    if (bFixRowStart)
      new_para->nFlags |= MEPF_ROWSTART;
    new_para->fmt = undo->u.split_para.fmt;
    new_para->border = undo->u.split_para.border;
    if (paraFlags)
    {
      para_cell( new_para )->nRightBoundary = undo->u.split_para.cell_right_boundary;
      para_cell( new_para )->border = undo->u.split_para.cell_border;
    }
    break;
  }
  }
}

Referenced by ME_Redo(), and ME_Undo().

ME_Redo()

BOOL ME_Redo

(

ME_TextEditor *

editor

)

Definition at line 448 of file undo.c.

{
  ME_UndoMode nMode = editor->nUndoMode;
  struct list *head;
  struct undo_item *undo, *cursor2;
 
  assert(nMode == umAddToUndo || nMode == umIgnore);
  
  if (editor->nUndoMode == umIgnore) return FALSE;
 
  head = list_head( &editor->redo_stack );
  if (!head) return FALSE;
 
  /* watch out for uncommitted transactions ! */
  undo = LIST_ENTRY( head, struct undo_item, entry );
  assert( undo->type == undo_end_transaction );
 
  editor->nUndoMode = umAddBackToUndo;
  list_remove( &undo->entry );
  destroy_undo_item( undo );
 
  LIST_FOR_EACH_ENTRY_SAFE( undo, cursor2, &editor->redo_stack, struct undo_item, entry )
  {
      if (undo->type == undo_end_transaction) break;
      ME_PlayUndoItem( editor, undo );
      list_remove( &undo->entry );
      destroy_undo_item( undo );
  }
  table_move_from_row_start( editor );
  add_undo( editor, undo_end_transaction );
  editor->nUndoMode = nMode;
  ME_UpdateRepaint(editor, FALSE);
  return TRUE;
}

Referenced by editor_handle_message(), and ME_KeyDown().

ME_Undo()

BOOL ME_Undo

(

ME_TextEditor *

editor

)

Definition at line 410 of file undo.c.

{
  ME_UndoMode nMode = editor->nUndoMode;
  struct list *head;
  struct undo_item *undo, *cursor2;
 
  if (editor->nUndoMode == umIgnore) return FALSE;
  assert(nMode == umAddToUndo || nMode == umIgnore);
 
  head = list_head( &editor->undo_stack );
  if (!head) return FALSE;
 
  /* watch out for uncommitted transactions ! */
  undo = LIST_ENTRY( head, struct undo_item, entry );
  assert(undo->type == undo_end_transaction
        || undo->type == undo_potential_end_transaction);
 
  editor->nUndoMode = umAddToRedo;
 
  list_remove( &undo->entry );
  destroy_undo_item( undo );
 
  LIST_FOR_EACH_ENTRY_SAFE( undo, cursor2, &editor->undo_stack, struct undo_item, entry )
  {
      if (undo->type == undo_end_transaction) break;
      ME_PlayUndoItem( editor, undo );
      list_remove( &undo->entry );
      destroy_undo_item( undo );
  }
 
  table_move_from_row_start( editor );
  add_undo( editor, undo_end_transaction );
  editor->nUndoStackSize--;
  editor->nUndoMode = nMode;
  ME_UpdateRepaint(editor, FALSE);
  return TRUE;
}

Referenced by editor_handle_message(), and ME_KeyDown().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

richedit

)