path: root/src/undo.c

#ifdef UNDO
/*
----------------------------------------------------------------------------------------
UNDO and REDO features works with an 'undo' struct list.
Which contains:
      p_ant: pointer to 'undo' struct. If NULL, this node is the first change
             for the session.
      struct ent * added: 'ent' elements added by the change
      struct ent * removed: 'ent' elements removed by the change
      struct undo_range_shift * range_shift: range shifted by change
      row_hidded: integers list (int *) hidden rows on screen
      row_showed: integers list (int *) visible rows on screen
      col_hidded: integers list (int *) hidden columns on screen
      col_showed: integers list (int *) visible columns on screen
             NOTE: the first position of the lists contains (number of elements - 1) in the list
      p_sig: pointer to 'undo' struct, If NULL, this node is the last change in
             the session.

Follows one level UNDO/REDO scheme. A change (C1) is made, then an UNDO operation, and
another change (C2). From there later changes are removed.
Scheme:

+ C1 -> + -> UNDO -
^                 \
|_                |
  \---------------/
|
|
|
 \-> C2 --> + ...

undo_shift_range struct contains:
    int delta_rows: delta rows for the range shift
    int delta_cols: delta columns for the range shift
    int tlrow:      Upper left row defining the range of the shift
                    (As if a cell range shift is made)
    int tlcol:      Upper left column defining the range of the shift
                    (As if a cell range shift is made)
    int brrow:      Lower right row defining the range of the shift
                    (As if a cell range shift is made)
    int brcol:      Lower right column defining the range of the shift
                    (As if a cell range shift is made)

Implemented actions for UNDO/REDO:
1. Remove content from cell or range
2. Input content into a cell
3. Edit a cell
4. Change alginment of range or cell
5. Paste range or cell
6. Shift range or cell with sh, sj, sk, sl
7. Insert row or column
8. Delete row or column
9. Paste row or column
10. Hide/show rows and columns
11. Sort of a range
12. Change in the format of a range or cell
13. '-' and '+' commands in normal mode
14. Lock and unlock of cells
15. datefmt command

NOT implemented:
1. Change format of an entire column
2. Recover equations after redo of changes over ents that have equations on them.

----------------------------------------------------------------------------------------
*/

#include <stdlib.h>
#include "undo.h"
#include "macros.h"
#include "curses.h"
#include "conf.h"
#include "sc.h"
#include "cmds.h"
#include "color.h" // for set_ucolor
#include "marks.h"
#include "shift.h"

// undolist
static struct undo * undo_list = NULL;

// current position in the list
static int undo_list_pos = 0;

// Number of elements in the list
static int undo_list_len = 0;

// Temporal variable
static struct undo undo_item;

// Init 'unto_item'
void create_undo_action() {
    undo_item.added       = NULL;
    undo_item.removed     = NULL;
    undo_item.p_ant       = NULL;
    undo_item.p_sig       = NULL;
    undo_item.range_shift = NULL;

    undo_item.row_hidded  = NULL;
    undo_item.row_showed  = NULL;
    undo_item.col_hidded  = NULL;
    undo_item.col_showed  = NULL;
    return;
}

// Save undo_item copy with 'ent' elements modified, and the undo range shift
// struct into the undolist
void end_undo_action() {
    add_to_undolist(undo_item);

    // in case we need to dismissed this undo_item!
    if ((undo_item.added      == NULL &&
        undo_item.removed     == NULL && undo_item.range_shift == NULL &&
        undo_item.row_hidded  == NULL && undo_item.row_showed  == NULL &&
        undo_item.col_hidded  == NULL && undo_item.col_showed  == NULL) || loading) {
        if (undo_list->p_ant != NULL) undo_list = undo_list->p_ant;
        undo_list_pos--;
        clear_from_current_pos();
    }

    return;
}

// Add a undo node to the undolist,
// allocate memory for undo struct,
// fill variable with undo_item value and append it to the list
void add_to_undolist(struct undo u) {
        // If not at the end of the list, remove from the end
        if ( undo_list != NULL && undo_list_pos != len_undo_list() )
            clear_from_current_pos();

        struct undo * ul = (struct undo *) malloc (sizeof(struct undo));
        ul->p_sig = NULL;

        // Add 'ent' elements
        ul->added = u.added;
        ul->removed = u.removed;
        ul->range_shift = u.range_shift;
        ul->row_hidded = u.row_hidded;
        ul->col_hidded = u.col_hidded;
        ul->row_showed = u.row_showed;
        ul->col_showed = u.col_showed;

        if (undo_list == NULL) {
            ul->p_ant = NULL;
            undo_list = ul;
        } else {
            ul->p_ant = undo_list;

            // Voy hasta el final de la lista
            while (undo_list->p_sig != NULL) undo_list = undo_list->p_sig;

            undo_list->p_sig = ul;
            undo_list = undo_list->p_sig;
        }
        undo_list_pos++;
        undo_list_len++;
    return;
}

// Cascade free UNDO node memory
void free_undo_node(struct undo * ul) {

    struct ent * de;
    struct ent * en;
    struct undo * e;

    // Remove from current position
    while (ul != NULL) {
        en = ul->added;
        while (en != NULL) {
            de = en->next;
            clearent(en);
            free(en);
            en = de;
        }
        en = ul->removed;
        while (en != NULL) {
            de = en->next;
            clearent(en);
            free(en);
            en = de;
        }
        e = ul->p_sig;

        if (ul->range_shift != NULL) free(ul->range_shift); // Free undo_range_shift memory
        if (ul->row_hidded  != NULL) free(ul->row_hidded); // Free hidden row memory
        if (ul->col_hidded  != NULL) free(ul->col_hidded); // Free hidden col memory
        if (ul->row_showed  != NULL) free(ul->row_showed); // Free showed row memory
        if (ul->col_showed  != NULL) free(ul->col_showed); // Free showed col memory

        free(ul);
        undo_list_len--;
        ul = e;
    }
    return;
}

// Remove nodes below the current position from the undolist
void clear_from_current_pos() {
    if (undo_list == NULL) return;

    if (undo_list->p_ant == NULL) {
        free_undo_node(undo_list);
        undo_list = NULL;
    } else {
        struct undo * ul = undo_list->p_sig; // Previous
        free_undo_node(ul);
        undo_list->p_sig = NULL;
    }

    return;
}

// Remove undolist content
void clear_undo_list () {
    if (undo_list == NULL) return;

    // Go to the beginning of the list
    while (undo_list->p_ant != NULL ) {
        undo_list = undo_list->p_ant;
    }

    struct undo * ul = undo_list;

    free_undo_node(ul);

    undo_list = NULL;
    undo_list_pos = 0;

    return;
}

int len_undo_list() {
    return undo_list_len;
}

// Take a range of 'ent' elements and create new ones (as many as elements
// inside the specified range).
// Then copy the content of the original ones to the new ones and save them into
// the 'added' or 'removed' list of undo_item, according to the char type.
void copy_to_undostruct (int row_desde, int col_desde, int row_hasta, int col_hasta, char type) {
    int c, r;
    for (r = row_desde; r <= row_hasta; r++)
        for (c = col_desde; c <= col_hasta; c++) {
            struct ent * e = (struct ent *) malloc( (unsigned) sizeof(struct ent) );
            cleanent(e);
            copyent(e, lookat(r, c), 0, 0, 0, 0, r, c, 0);

            // Append 'ent' element at the beginning
            if (type == 'a') {
                e->next = undo_item.added;
                undo_item.added = e;
            } else {
                e->next = undo_item.removed;
                undo_item.removed = e;
            }

        }
    return;
}

// Takes a range, a rows an