src/history.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15  *
  16  * See the COPYING file for license information.
  17  *
  18  * Guillaume Chazarain <booh@altern.org>
  19  */
  20
  21 /*********************
  22  * History handling. *
  23  *********************/
  24
  25 #include "gliv.h"
  26
  27 extern rt_struct *rt;
  28 extern options_struct *options;
  29
  30 static GList *list = NULL;
  31 static GList *node = NULL;      /* Currrent position in the list. */
  32
  33 /*
  34  * Number of elements in the list, it would 50 days with 1 event
  35  * each millisecond to overflow, so we feel safe.
  36  */
  37 static guint32 count;
  38
  39 static gboolean used;           /* Wether the history has been initialized. */
  40
  41 void init_history(void)
  42 {
  43     if (options->history_size != 0) {
  44         node = list = g_new0(GList, 1);
  45         count = 0;
  46         used = TRUE;
  47     } else
  48         used = FALSE;
  49 }
  50
  51 /* Returns item->next. */
  52 static GList *free_item(GList * item)
  53 {
  54     GList *next;
  55
  56     if (item->prev != NULL)
  57         item->prev->next = NULL;
  58
  59     if (item->next != NULL)
  60         item->next->prev = NULL;
  61
  62     g_free(item->data);
  63     next = item->next;
  64     g_list_free_1(item);
  65     count--;
  66
  67     return next;
  68 }
  69
  70 static void free_list(GList * item)
  71 {
  72     while (item != NULL)
  73         item = free_item(item);
  74 }
  75
  76 static void clean_list(void)
  77 {
  78     while (count > options->history_size) {
  79         if (node == list)
  80             node = node->next;
  81         list = free_item(list);
  82     }
  83
  84     list->prev = NULL;
  85 }
  86
  87 void append_history(void)
  88 {
  89     GList *item;
  90
  91     if (used == FALSE || options->history_size == 0)
  92         return;
  93
  94     item = g_list_alloc();
  95     item->data = g_new(state_struct, 1);
  96
  97     matrix_cpy(item->data, NULL);
  98
  99     item->prev = node;
 100     item->next = NULL;
 101
 102     if (list == NULL)
 103         list = item;
 104     else {
 105         if (node->next != NULL)
 106             free_list(node->next);
 107
 108         node->next = item;
 109     }
 110
 111     node = item;
 112     count++;
 113
 114     if (options->history_size > 0)
 115         clean_list();
 116 }
 117
 118 static void set_state(GList * item)
 119 {
 120     if (item != NULL && item->data != NULL) {
 121         node = item;
 122         matrix_cpy(NULL, item->data);
 123         refresh(REFRESH_IMAGE | REFRESH_STATUS);
 124     }
 125 }
 126
 127 void undo(void)
 128 {
 129     set_state(g_list_previous(node));
 130 }
 131
 132 void redo(void)
 133 {
 134     set_state(g_list_next(node));
 135 }
 136
 137 void clear_history(void)
 138 {
 139     if (list != NULL) {
 140         free_list(list);
 141         node = list = NULL;
 142         count = 0;
 143         init_history();
 144         append_history();
 145     }
 146 }