path: root/src/undo.c

/*
 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
 * Copyright (C) 1999-2001 Hiroyuki Yamamoto
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/* code ported from gedit */
/* This is for my patient girlfirend Regina */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <glib.h>
#include <gtk/gtktextview.h>

#include <string.h> /* for strlen */
#include <stdlib.h> /* for mbstowcs */

#include "undo.h"
#include "utils.h"
#include "prefs_common.h"

typedef struct _UndoInfo UndoInfo;

struct _UndoInfo 
{
	UndoAction action;
	gchar *text;
	gint start_pos;
	gint end_pos;
	gfloat window_position;
	gint mergeable;
};

static void undo_free_list	(GList	       **list_pointer);
static void undo_check_size	(UndoMain	*undostruct);
static gint undo_merge		(GList		*list,
				 guint		 start_pos,
				 guint		 end_pos,
				 gint		 action,
				 const guchar	*text);
static void undo_add		(const gchar	*text,
				 gint		 start_pos,
				 gint		 end_pos,
				 UndoAction	 action,
				 UndoMain	*undostruct);
static gint undo_get_selection	(GtkTextView	*textview,
				 guint		*start,
				 guint		*end);
static void undo_insert_text_cb	(GtkTextBuffer	*textbuf,
				 GtkTextIter	*iter,
				 gchar		*new_text,
				 gint		 new_text_length,
				 UndoMain	*undostruct);
static void undo_delete_text_cb	(GtkTextBuffer	*textbuf,
				 GtkTextIter	*start,
				 GtkTextIter	*end,
				 UndoMain	*undostruct);

static void undo_paste_clipboard_cb	(GtkTextView	*textview,
					 UndoMain	*undostruct);

void undo_undo			(UndoMain	*undostruct);
void undo_redo			(UndoMain	*undostruct);


UndoMain *undo_init(GtkWidget *text) 
{
	UndoMain *undostruct;
	GtkTextView *textview = GTK_TEXT_VIEW(text);
	GtkTextBuffer *textbuf;

	g_return_val_if_fail(text != NULL, NULL);

	textbuf = gtk_text_view_get_buffer(textview);

	undostruct = g_new(UndoMain, 1);
	undostruct->textview = textview;
	undostruct->undo = NULL;
	undostruct->redo = NULL;
	undostruct->paste = 0;
	undostruct->undo_state = FALSE;
	undostruct->redo_state = FALSE;

	g_signal_connect(G_OBJECT(textbuf), "insert-text",
			 G_CALLBACK(undo_insert_text_cb), undostruct);
	g_signal_connect(G_OBJECT(textbuf), "delete-range",
			 G_CALLBACK(undo_delete_text_cb), undostruct);
	g_signal_connect(G_OBJECT(textview), "paste-clipboard",
			 G_CALLBACK(undo_paste_clipboard_cb), undostruct);

	return undostruct;
}

void undo_destroy (UndoMain *undostruct) 
{
	undo_free_list(&undostruct->undo);
	undo_free_list(&undostruct->redo);
	g_free(undostruct);
}

static UndoInfo *undo_object_new(gchar *text, gint start_pos, gint end_pos, 
				 UndoAction action, gfloat window_position) 
{
	UndoInfo *undoinfo;
	undoinfo = g_new (UndoInfo, 1);
	undoinfo->text      = text;
	undoinfo->start_pos = start_pos;
	undoinfo->end_pos   = end_pos;
	undoinfo->action    = action;
	undoinfo->window_position = window_position;
	return undoinfo;
}

static void undo_object_free(UndoInfo *undo) 
{
	g_free (undo->text);
	g_free (undo);
}

/**
 * undo_free_list:
 * @list_pointer: list to be freed
 *
 * frees and undo structure list
 **/
static void undo_free_list(GList **list_pointer) 
{
	UndoInfo *undo;
	GList *cur, *list = *list_pointer;

	if (list == NULL) return;

	for (cur = list; cur != NULL; cur = cur->next) {
		undo = (UndoInfo *)cur->data;
		undo_object_free(undo);
	}

	g_list_free(list);
	*list_pointer = NULL;
}

void undo_set_change_state_func(UndoMain *undostruct, UndoChangeStateFunc func,
				gpointer data)
{
	g_return_if_fail(undostruct != NULL);

	undostruct->change_state_func = func;
	undostruct->change_state_data = data;
}

/**
 * undo_check_size:
 * @compose: document to check
 *
 * Checks that the size of compose->undo does not excede settings->undo_levels and
 * frees any undo level above sett->undo_level.
 *
 **/
static void undo_check_size(UndoMain *undostruct) 
{
	UndoInfo *last_undo;
	guint length;

	if (prefs_common.undolevels < 1) return;

	/* No need to check for the redo list size since the undo
	   list gets freed on any call to compose_undo_add */
	length = g_list_length(undostruct->undo);
	if (length >= prefs_common.undolevels && prefs_common.undolevels > 0) {
		last_undo = (UndoInfo *)g_list_last(undostruct->undo)->data;
		undostruct->undo = g_list_remove(undostruct->undo, last_undo);
		undo_object_free(last_undo);
	}
}

/**
 * undo_merge:
 * @last_undo:
 * @start_pos:
 * @end_pos:
 * @action:
 *
 * This function tries to merge the undo object at the top of
 * the stack with a new set of data. So when we undo for example
 * typing, we can undo the whole word and not each letter by itself
 *
 * Return Value: TRUE is merge was sucessful, FALSE otherwise
 **/
static gint undo_merge(GList *list, guint start_pos, guint end_pos,
		       gint action, const guchar *text) 
{
	guchar *temp_string;
	UndoInfo *last_undo;

	/* This are the cases in which we will NOT merge :
	   1. if (last_undo->mergeable == FALSE)
	   [mergeable = FALSE when the size of the undo data was not 1.
	   or if the data was size = 1 but = '\n' or if the undo object
	   has been "undone" already ]
	   2. The size of text is not 1
	   3. If the new merging data is a '\n'
	   4. If the last char of the undo_last data is a space/tab
	   and the new char is not a space/tab ( so that we undo
	   words and not chars )
	   5. If the type (action) of undo is different from the last one
	   Chema */

	if (list == NULL) return FALSE;

	last_undo = list->data;

	if (!last_undo->mergeable) return FALSE;

	if (end_pos - start_pos != 1 ||
	    text[0] == '\n' ||
	    action != last_undo->action ||
	    action == UNDO_ACTION_REPLACE_INSERT ||
	    action == UNDO_ACTION_REPLACE_DELETE) {
		last_undo->mergeable = FALSE;
		return FALSE;
	}

	if (action == UNDO_ACTION_DELETE) {
		gboolean checkit = TRUE;

		if (last_undo->start_pos != end_pos &&
		    last_undo->start_pos != start_pos) {
			last_undo->mergeable = FALSE;
			return FALSE;
		} else if (last_undo->start_pos == start_pos) {
			/* Deleted with the delete key */
			if (text[0] != ' ' && text[0] != '\t' &&
			    (last_undo->text[last_undo->end_pos - last_undo->start_pos - 1] == ' ' ||
			     last_undo->text[last_undo->end_pos - last_undo->start_pos - 1] == '\t'))
				checkit = FALSE;

			temp_string = g_strdup_printf("%s%s", last_undo->text, text);
			last_undo->end_pos++;
			g_free(last_undo->text);
			last_undo->text = temp_string;
		} else {
			/* Deleted with the backspace key */
			if (text[0] != ' ' && text[0] != '\t' &&
			    (last_undo->text[0] == ' ' ||
			     last_undo->text[0] == '\t'))
				checkit = FALSE;

			temp_string = g_strdup_printf("%s%s", text, last_undo->text);
			last_undo->start_pos = start_pos;
			g_free(last_undo->text);
			last_undo->text = temp_string;
		}

		if (!checkit) {
			last_undo->mergeable = FALSE;
			return FALSE;
		}
	} else if (action == UNDO_ACTION_INSERT) {
		if (last_undo->end_pos != start_pos) {
			last_undo->mergeable = FALSE;
			return FALSE;
		} else {
			temp_string = g_strdup_printf("%s%s", last_undo->text, text);
			g_free(last_undo->text);
			last_undo->end_pos = end_pos;
			last_undo->text = temp_string;
		}
	} else
		debug_print("Unknown action [%i] inside undo merge encountered", action);

	return TRUE;
}

/**
 * compose_undo_add:
 * @text:
 * @start_pos:
 * @end_pos:
 * @action: either UNDO_ACTION_INSERT or UNDO_ACTION_DELETE
 * @compose:
 * @view: The view so that we save the scroll bar position.
 *
 * Adds text to the undo stack. It also performs test to limit the number
 * of undo levels and deltes the redo list
 **/

static void undo_add(const gchar *text, 
		     gint start_pos, gint end_pos,
		     UndoAction action, UndoMain *undostruct) 
{
	UndoInfo *undoinfo;
	GtkAdjustment *vadj;

	g_return_if_fail(text != NULL);
	g_return_if_fail(end_pos >= start_pos);

	undo_free_list(&undostruct->redo);

	/* Set the redo sensitivity */
	undostruct->change_state_func(undostruct,
				      UNDO_STATE_UNCHANGED, UNDO_STATE_FALSE,
				      undostruct->change_state_data);

	if (undostruct->paste != 0) {
		if (action == UNDO_ACTION_INSERT) 
			action = UNDO_ACTION_REPLACE_INSERT;
		else 
			action = UNDO_ACTION_REPLACE_DELETE;
		undostruct->paste = undostruct->paste + 1;
		if (undostruct->paste == 3) 
			undostruct->paste = 0;
	}

	if (undo_merge(undostruct->undo, start_pos, end_pos, action, text))
		return;

	undo_check_size(undostruct);

	vadj = GTK_ADJUSTMENT(GTK_TEXT_VIEW(undostruct->textview)->vadjustment);
	undoinfo = undo_object_new(g_strdup(text), start_pos, end_pos, action,
				   vadj->value);

	if (end_pos - start_pos != 1 || text[0] == '\n')
		undoinfo->mergeable = FALSE;
	else
		undoinfo->mergeable = TRUE;

	undostruct->undo = g_list_prepend(undostruct->undo, undoinfo);

	undostruct->change_state_func(undostruct,
				      UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
				      undostruct->change_state_data);
}

/**
 * undo_undo:
 * @w: not used
 * @data: not used
 *
 * Executes an undo request on the current document
 **/
void undo_undo(UndoMain *undostruct) 
{
	UndoInfo *undoinfo;
	GtkTextView *textview;
	GtkTextBuffer *buffer;
	GtkTextIter iter, start_iter, end_iter;
	GtkTextMark *mark;

	g_return_if_fail(undostruct != NULL);

	if (undostruct->undo == NULL) return;

	/* The undo data we need is always at the top op the
	   stack. So, therefore, the first one */
	undoinfo = (UndoInfo *)undostruct->undo->data;
	g_return_if_fail(undoinfo != NULL);
	undoinfo->mergeable = FALSE;
	undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
	undostruct->undo = g_list_remove(undostruct->undo, undoinfo);

	textview = undostruct->textview;
	buffer = gtk_text_view_get_buffer(textview);

	undo_block(undostruct);

	/* Check if there is a selection active */
	mark = gtk_text_buffer_get_insert(buffer);
	gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
	gtk_text_buffer_place_cursor(buffer, &iter);

	/* Move the view (scrollbars) to the correct position */
	gtk_adjustment_set_value(GTK_ADJUSTMENT(textview->vadjustment),
				 undoinfo->window_position);

	switch (undoinfo->action) {
	case UNDO_ACTION_DELETE:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &iter, undoinfo->start_pos);
		gtk_text_buffer_insert(buffer, &iter, undoinfo->text, -1);
		debug_print("UNDO_ACTION_DELETE %s\n", undoinfo->text);
		break;
	case UNDO_ACTION_INSERT:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &start_iter, undoinfo->start_pos);
		gtk_text_buffer_get_iter_at_offset
			(buffer, &end_iter, undoinfo->end_pos);
		gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
		debug_print("UNDO_ACTION_INSERT %d\n", undoinfo->end_pos-undoinfo->start_pos);
		break;
	case UNDO_ACTION_REPLACE_INSERT:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &start_iter, undoinfo->start_pos);
		gtk_text_buffer_get_iter_at_offset
			(buffer, &end_iter, undoinfo->end_pos);
		debug_print("UNDO_ACTION_REPLACE %s\n", undoinfo->text);
		/* "pull" another data structure from the list */
		undoinfo = (UndoInfo *)undostruct->undo->data;
		g_return_if_fail(undoinfo != NULL);
		undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
		undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
		g_return_if_fail(undoinfo->action == UNDO_ACTION_REPLACE_DELETE);
		gtk_text_buffer_insert(buffer, &start_iter, undoinfo->text, -1);
		debug_print("UNDO_ACTION_REPLACE %s\n", undoinfo->text);
		break;
	case UNDO_ACTION_REPLACE_DELETE:
		g_warning("This should not happen. UNDO_REPLACE_DELETE");
		break;
	default:
		g_assert_not_reached();
		break;
	}

	undostruct->change_state_func(undostruct,
				      UNDO_STATE_UNCHANGED, UNDO_STATE_TRUE,
				      undostruct->change_state_data);

	if (undostruct->undo == NULL)
		undostruct->change_state_func(undostruct,
					      UNDO_STATE_FALSE,
					      UNDO_STATE_UNCHANGED,
					      undostruct->change_state_data);

	undo_unblock(undostruct);
}

/**
 * undo_redo:
 * @w: not used
 * @data: not used
 *
 * executes a redo request on the current document
 **/
void undo_redo(UndoMain *undostruct) 
{
	UndoInfo *redoinfo;
	GtkTextView *textview;
	GtkTextBuffer *buffer;
	GtkTextIter iter, start_iter, end_iter;
	GtkTextMark *mark;

	g_return_if_fail(undostruct != NULL);

	if (undostruct->redo == NULL) return;

	redoinfo = (UndoInfo *)undostruct->redo->data;
	g_return_if_fail (redoinfo != NULL);
	undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
	undostruct->redo = g_list_remove(undostruct->redo, redoinfo);

	textview = undostruct->textview;
	buffer = gtk_text_view_get_buffer(textview);

	undo_block(undostruct);

	/* Check if there is a selection active */
	mark = gtk_text_buffer_get_insert(buffer);
	gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
	gtk_text_buffer_place_cursor(buffer, &iter);

	/* Move the view to the right position. */
	gtk_adjustment_set_value(textview->vadjustment, 
				 redoinfo->window_position);

	switch (redoinfo->action) {
	case UNDO_ACTION_INSERT:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &iter, redoinfo->start_pos);
		gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
		debug_print("UNDO_ACTION_DELETE %s\n",redoinfo->text);
		break;
	case UNDO_ACTION_DELETE:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &start_iter, redoinfo->start_pos);
		gtk_text_buffer_get_iter_at_offset
			(buffer, &end_iter, redoinfo->end_pos);
		gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
		debug_print("UNDO_ACTION_INSERT %d\n", 
			    redoinfo->end_pos-redoinfo->start_pos);
		break;
	case UNDO_ACTION_REPLACE_DELETE:
		gtk_text_buffer_get_iter_at_offset
			(buffer, &start_iter, redoinfo->start_pos);
		gtk_text_buffer_get_iter_at_offset
			(buffer, &end_iter, redoinfo->end_pos);
		gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
		debug_print("UNDO_ACTION_REPLACE %s\n", redoinfo->text);
		/* "pull" another data structure from the list */
		redoinfo = (UndoInfo *)undostruct->redo->data;
		g_return_if_fail(redoinfo != NULL);
		undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
		undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
		g_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT);
		gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1);
		break;
	case UNDO_ACTION_REPLACE_INSERT:
		g_warning("This should not happen. Redo: UNDO_REPLACE_INSERT");
		break;
	default:
		g_assert_not_reached();
		break;
	}

	undostruct->change_state_func(undostruct,
				      UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED, 
				      undostruct->change_state_data);

	if (undostruct->redo == NULL)
		undostruct->change_state_func(undostruct,
					      UNDO_STATE_UNCHANGED,
					      UNDO_STATE_FALSE,
					      undostruct->change_state_data);

	undo_unblock(undostruct);
}

void undo_block(UndoMain *undostruct)
{
	GtkTextBuffer *buffer;

	g_return_if_fail(GTK_IS_TEXT_VIEW(undostruct->textview));

	buffer = gtk_text_view_get_buffer(undostruct->textview);
	g_signal_handlers_block_by_func
		(buffer, undo_insert_text_cb, undostruct);
	g_signal_handlers_block_by_func
		(buffer, undo_delete_text_cb, undostruct);
	g_signal_handlers_block_by_func
		(buffer, undo_paste_clipboard_cb, undostruct);
}

void undo_unblock(UndoMain *undostruct)
{
	GtkTextBuffer *buffer;

	g_return_if_fail(GTK_IS_TEXT_VIEW(undostruct->textview));

	buffer = gtk_text_view_get_buffer(undostruct->textview);
	g_signal_handlers_unblock_by_func
		(buffer, undo_insert_text_cb, undostruct);
	g_signal_handlers_unblock_by_func
		(buffer, undo_delete_text_cb, undostruct);
	g_signal_handlers_unblock_by_func
		(buffer, undo_paste_clipboard_cb, undostruct);
}

void undo_insert_text_cb(GtkTextBuffer *textbuf, GtkTextIter *iter,
			 gchar *new_text, gint new_text_length,
			 UndoMain *undostruct) 
{
	gchar *text_to_insert;
	gint pos;

	if (prefs_common.undolevels <= 0) return;

	pos = gtk_text_iter_get_offset(iter);

	Xstrndup_a(text_to_insert, new_text, new_text_length, return);
	undo_add(text_to_insert, pos, pos + g_utf8_strlen(text_to_insert, -1),
		 UNDO_ACTION_INSERT, undostruct);
}

void undo_delete_text_cb(GtkTextBuffer *textbuf, GtkTextIter *start,
			 GtkTextIter *end, UndoMain *undostruct) 
{
	gchar *text_to_delete;
	gint start_pos, end_pos;

	if (prefs_common.undolevels <= 0) return;

	text_to_delete = gtk_text_buffer_get_text(textbuf, start, end, FALSE);
	if (!text_to_delete || !*text_to_delete) return;

	start_pos = gtk_text_iter_get_offset(start);
	end_pos   = gtk_text_iter_get_offset(end);

	undo_add(text_to_delete, start_pos, end_pos, UNDO_ACTION_DELETE,
		 undostruct);
	g_free(text_to_delete);
}

void undo_paste_clipboard_cb(GtkTextView *textview, UndoMain *undostruct)
{
	debug_print("before Paste: %d\n", undostruct->paste);
	if (prefs_common.undolevels > 0)
		if (undo_get_selection(textview, NULL, NULL))
			undostruct->paste = TRUE;
	debug_print("after Paste: %d\n", undostruct->paste);
}

/**
 * undo_get_selection:
 * @text: Text to get the selection from
 * @start: return here the start position of the selection
 * @end: return here the end position of the selection
 *
 * Gets the current selection for View
 *
 * Return Value: TRUE if there is a selection active, FALSE if not
 **/
static gint undo_get_selection(GtkTextView *textview, guint *start, guint *end) 
{
	GtkTextBuffer *buffer;
	GtkTextIter start_iter, end_iter;
	guint start_pos, end_pos;

	buffer = gtk_text_view_get_buffer(textview);
	gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);

	start_pos = gtk_text_iter_get_offset(&start_iter);
	end_pos   = gtk_text_iter_get_offset(&end_iter);

	/* The user can select from end to start too. If so, swap it*/
	if (end_pos < start_pos) {
		guint swap_pos;
		swap_pos  = end_pos;
		end_pos   = start_pos;
		start_pos = swap_pos;
	}

	if (start != NULL)
		*start = start_pos;
		
	if (end != NULL)
		*end = end_pos;

	if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))
		return TRUE;
	else
		return FALSE;
}