Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <draw.h>

#include <thread.h>

#include <cursor.h>

#include <mouse.h>

#include <keyboard.h>

#include <frame.h>

#include <fcall.h>

#include <plumb.h>

#include "dat.h"

#include "fns.h"

/*

 * Structure of Undo list:

 * 	The Undo structure follows any associated data, so the list

 *	can be read backwards: read the structure, then read whatever

 *	data is associated (insert string, file name) and precedes it.

 *	The structure includes the previous value of the modify bit

 *	and a sequence number; successive Undo structures with the

 *	same sequence number represent simultaneous changes.

 */

typedef struct Undo Undo;

struct Undo

{

	short	type;		/* Delete, Insert, Filename */

	short	mod;	/* modify bit */

	uint		seq;		/* sequence number */

	uint		p0;		/* location of change (unused in f) */

	uint		n;		/* # runes in string or file name */

};

enum

{

	Undosize = sizeof(Undo)/sizeof(Rune),

};

File*

fileaddtext(File *f, Text *t)

{

	if(f == nil){

		f = emalloc(sizeof(File));

		f->unread = TRUE;

	}

	f->text = realloc(f->text, (f->ntext+1)*sizeof(Text*));

	f->text[f->ntext++] = t;

	f->curtext = t;

	return f;

}

void

filedeltext(File *f, Text *t)

{

	int i;

	for(i=0; i<f->ntext; i++)

		if(f->text[i] == t)

			goto Found;

	error("can't find text in filedeltext");

    Found:

	f->ntext--;

	if(f->ntext == 0){

		fileclose(f);

		return;

	}

	memmove(f->text+i, f->text+i+1, (f->ntext-i)*sizeof(Text*));

	if(f->curtext == t)

		f->curtext = f->text[0];

}

void

fileinsert(File *f, uint p0, Rune *s, uint ns)

{

	if(p0 > f->nc)

		error("internal error: fileinsert");

	if(f->seq > 0)

		fileuninsert(f, &f->delta, p0, ns);

	bufinsert(f, p0, s, ns);

	if(ns)

		f->mod = TRUE;

}

void

fileuninsert(File *f, Buffer *delta, uint p0, uint ns)

{

	Undo u;

	/* undo an insertion by deleting */

	u.type = Delete;

	u.mod = f->mod;

	u.seq = f->seq;

	u.p0 = p0;

	u.n = ns;

	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);

}

void

filedelete(File *f, uint p0, uint p1)

{

	if(!(p0<=p1 && p0<=f->nc && p1<=f->nc))

		error("internal error: filedelete");

	if(f->seq > 0)

		fileundelete(f, &f->delta, p0, p1);

	bufdelete(f, p0, p1);

	if(p1 > p0)

		f->mod = TRUE;

}

void

fileundelete(File *f, Buffer *delta, uint p0, uint p1)

{

	Undo u;

	Rune *buf;

	uint i, n;

	/* undo a deletion by inserting */

	u.type = Insert;

	u.mod = f->mod;

	u.seq = f->seq;

	u.p0 = p0;

	u.n = p1-p0;

	buf = fbufalloc();

	for(i=p0; i<p1; i+=n){

		n = p1 - i;

		if(n > RBUFSIZE)

			n = RBUFSIZE;

		bufread(f, i, buf, n);

		bufinsert(delta, delta->nc, buf, n);

	}

	fbuffree(buf);

	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);

}

void

filesetname(File *f, Rune *name, int n)

{

	if(f->seq > 0)

		fileunsetname(f, &f->delta);

	free(f->name);

	f->name = runemalloc(n);

	runemove(f->name, name, n);

	f->nname = n;

	f->unread = TRUE;

}

void

fileunsetname(File *f, Buffer *delta)

{

	Undo u;

	/* undo a file name change by restoring old name */

	u.type = Filename;

	u.mod = f->mod;

	u.seq = f->seq;

	u.p0 = 0;	/* unused */

	u.n = f->nname;

	if(f->nname)

		bufinsert(delta, delta->nc, f->name, f->nname);

	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);

}

uint

fileload(File *f, uint p0, int fd, int *nulls)

{

	if(f->seq > 0)

		error("undo in file.load unimplemented");

	return bufload(f, p0, fd, nulls);

}

/* return sequence number of pending redo */

uint

fileredoseq(File *f)

{

	Undo u;

	Buffer *delta;

	delta = &f->epsilon;

	if(delta->nc == 0)

		return 0;

	bufread(delta, delta->nc-Undosize, (Rune*)&u, Undosize);

	return u.seq;

}

void

fileundo(File *f, int isundo, uint *q0p, uint *q1p)

{

	Undo u;

	Rune *buf;

	uint i, j, n, up;

	uint stop;

	Buffer *delta, *epsilon;

	if(isundo){

		/* undo; reverse delta onto epsilon, seq decreases */

		delta = &f->delta;

		epsilon = &f->epsilon;

		stop = f->seq;

	}else{

		/* redo; reverse epsilon onto delta, seq increases */

		delta = &f->epsilon;

		epsilon = &f->delta;

		stop = 0;	/* don't know yet */

	}

	buf = fbufalloc();

	while(delta->nc > 0){

		up = delta->nc-Undosize;

		bufread(delta, up, (Rune*)&u, Undosize);

		if(isundo){

			if(u.seq < stop){

				f->seq = u.seq;

				goto Return;

			}

		}else{

			if(stop == 0)

				stop = u.seq;

			if(u.seq > stop)

				goto Return;

		}

		switch(u.type){

		default:

			fprint(2, "undo: 0x%ux\n", u.type);

			abort();

			break;

		case Delete:

			f->seq = u.seq;

			fileundelete(f, epsilon, u.p0, u.p0+u.n);

			f->mod = u.mod;

			bufdelete(f, u.p0, u.p0+u.n);

			for(j=0; j<f->ntext; j++)

				textdelete(f->text[j], u.p0, u.p0+u.n, FALSE);

			*q0p = u.p0;

			*q1p = u.p0;

			break;

		case Insert:

			f->seq = u.seq;

			fileuninsert(f, epsilon, u.p0, u.n);

			f->mod = u.mod;

			up -= u.n;

			for(i=0; i<u.n; i+=n){

				n = u.n - i;

				if(n > RBUFSIZE)

					n = RBUFSIZE;

				bufread(delta, up+i, buf, n);

				bufinsert(f, u.p0+i, buf, n);

				for(j=0; j<f->ntext; j++)

					textinsert(f->text[j], u.p0+i, buf, n, FALSE);

			}

			*q0p = u.p0;

			*q1p = u.p0+u.n;

			break;

		case Filename:

			f->seq = u.seq;

			fileunsetname(f, epsilon);

			f->mod = u.mod;

			up -= u.n;

			free(f->name);

			if(u.n == 0)

				f->name = nil;

			else

				f->name = runemalloc(u.n);

			bufread(delta, up, f->name, u.n);

			f->nname = u.n;

			break;

		}

		bufdelete(delta, up, delta->nc);

	}

	if(isundo)

		f->seq = 0;

    Return:

	fbuffree(buf);

}

void

filereset(File *f)

{

	bufreset(&f->delta);

	bufreset(&f->epsilon);

	f->seq = 0;

}

void

fileclose(File *f)

{

	free(f->name);

	f->nname = 0;

	f->name = nil;

	free(f->text);

	f->ntext = 0;

	f->text = nil;

	bufclose(f);

	bufclose(&f->delta);

	bufclose(&f->epsilon);

	elogclose(f);

	free(f);

}

void

filemark(File *f)

{

	if(f->epsilon.nc)

		bufdelete(&f->epsilon, 0, f->epsilon.nc);

	f->seq = seq;

}