#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;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.