@@ -24,7 +24,8 @@

 #include "sha3/sha3.h"

 //#define CHUNKSIZE 32768

-#define CHUNKSIZE 160

+//#define CHUNKSIZE 160

+#define CHUNKSIZE 16

 #define UNDOBLOCK 1024

 #define ADDNBLOCK 1024

 #define UNDOGROWSIZE (256*1024)

@@ -35,6 +36,7 @@ static int redata_hash_gen(redata_t *redata, char *filename, char *buf, long buf

 static char *securesave_genname(char *filename, char *buf, int bufsize);

 static void *mymemrchr(const void *s, int c, size_t n);

 static void meminvert(void *start, void *end);

+static size_t memrchroffset(char *ptr, int c, size_t n);

 #if 0

 static void

@@ -45,15 +47,22 @@ redata_debug_chunkdump(redata_t *redata, char *title)

         title=(title==NULL)?"":title;

         fprintf(stderr,"%s:CHUNKDUMP (sizechunks:%i)\n",title,redata->sizechunks);

         for(m=0;m<redata->sizechunks;m++) {

-                fprintf(stderr,"%s:chunk[%i]:\"",title,m);

+                fprintf(stderr,"%s:chunk[%i] len:%-5i data:\"",title,m,redata->chunks[m]->useddata);

                 for(k=0;k<redata->chunks[m]->useddata;k++) {

                         c=redata->chunks[m]->data[k];

-                        c=(c>=' ' && c<='~')?c:'.';

-                        fprintf(stderr,"%c",c);

+                        if(c=='\n' || c=='\0')

+                                fprintf(stderr,"\\%c",(c=='\n')?'n':'0');

+                        else if(c<' ' || c>'~' || c=='\\')

+                                fprintf(stderr,"\\x%02X",((unsigned char *)redata->chunks[m]->data)[k]);

+                        else

+                                fprintf(stderr,"%c",c);

                 }

                 fprintf(stderr,"\"\n");

         }

 }

+#define CHUNKDEBUG(a) redata_debug_chunkdump a

+#else

+#define CHUNKDEBUG(a)

 #endif

 redata_t *

@@ -247,6 +256,7 @@ redata_chunk_deletechunk(redata_t *redata, int chunkno)

                 redata->available+=chunk->useddata;

                 chunk->useddata=0;

                 chunk->whatin_fresh=0;

+                redata_chunk_unfreshnext(redata, chunkno);

         }

         for(i=chunkno;(i+1)<redata->sizechunks;i++)

                 redata->chunks[i]=redata->chunks[i+1];

@@ -320,8 +330,9 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto

                 memmove(from->data+posfrom,from->data+posfrom+size,from->useddata-posfrom-size);

                 from->useddata-=size;

                 to->useddata+=size;

-                from->whatin_fresh=0;

-                to->whatin_fresh=0;

+                redata_chunk_unfreshrange(redata,chunkfrom,chunkto);

+                redata_chunk_unfreshnext(redata,chunkfrom);

+                redata_chunk_unfreshnext(redata,chunkto);

         } else {

                 /* from==to */

                 rechunk_t *chunk=redata->chunks[chunkfrom];

@@ -334,6 +345,7 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto

                         memcpy(chunk->data+posto-size,redata->tmpchunk->data,size);

                 }

                 chunk->whatin_fresh=0;

+                redata_chunk_unfreshnext(redata,chunkfrom);

         }

         return(0);

 }

@@ -351,8 +363,9 @@ redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, lo

         memmove(chunk->data+posto+buflen,chunk->data+posto,chunk->useddata-posto);

         memcpy(chunk->data+posto,buf,buflen);

         chunk->useddata+=buflen;

-        chunk->whatin_fresh=0;

         redata->available-=buflen;

+        chunk->whatin_fresh=0;

+        redata_chunk_unfreshnext(redata,chunkto);

         return(0);

 }

@@ -370,8 +383,9 @@ redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

         chunk=redata->chunks[chunkno];

         memmove(chunk->data+pos,chunk->data+pos+n,chunk->useddata-pos-n);

         chunk->useddata-=n;

-        chunk->whatin_fresh=0;

         redata->available+=n;

+        chunk->whatin_fresh=0;

+        redata_chunk_unfreshnext(redata,chunkno);

         return(0);

 }

@@ -409,6 +423,38 @@ redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n)

         return(redata_chunk_movedata(redata,chunkno+1,0,chunkno,redata->chunks[chunkno]->useddata,n));

 }

+int

+redata_chunk_unfreshnext(redata_t *redata, int chunkno)

+{

+        int next;

+        if(redata==NULL || chunkno<0 || chunkno>=redata->sizechunks)

+                return(-1); /* sanity check failed */

+        /* invalidate whatin for next chunks until one not empty */

+        for(next=chunkno+1;next<redata->sizechunks;next++) {

+                redata->chunks[next]->whatin_fresh=0;

+                if(redata->chunks[next]->useddata!=0)

+                        break;

+        }

+        return(0);

+}

+

+int

+redata_chunk_unfreshrange(redata_t *redata, int fromchunkno, int tochunkno)

+{

+        int chunkno;

+        if(redata==NULL || fromchunkno<0 || fromchunkno>=redata->sizechunks || tochunkno<0 || tochunkno>=redata->sizechunks)

+                return(-1); /* sanity check failed */

+        if(fromchunkno>tochunkno) {

+                chunkno=fromchunkno;

+                fromchunkno=tochunkno;

+                tochunkno=chunkno;

+        }

+        /* invalidate whatin in range */

+        for(chunkno=fromchunkno;chunkno<=tochunkno;chunkno++)

+                redata->chunks[chunkno]->whatin_fresh=0;

+        return(0);

+}

+

 int

 redata_whatin_refresh(redata_t *redata, int chunkno)

@@ -423,10 +469,16 @@ redata_whatin_refresh(redata_t *redata, int chunkno)

                 return(0);

         memset(&(chunk->whatin),0,sizeof(whatin_t));

         nlcount=0;

-        for(i=0,lim=chunk->useddata;i<lim;i++) {

+        for(i=0,lim=chunk->useddata;i<lim;i++)

                 nlcount+=(chunk->data[i]=='\n')?1:0;

-        }

         chunk->whatin.nlcount=nlcount;

+        if(chunkno>0) {

+                int prev;

+                for(prev=chunkno-1;prev>0 && redata->chunks[prev]->useddata==0;prev--)

+                        ;

+                if(redata->chunks[prev]->useddata>0 && redata->chunks[prev]->data[redata->chunks[prev]->useddata-1]!='\n')

+                        chunk->whatin.iscontinuation=1;

+        }

         chunk->whatin_fresh=1;

         return(0);

 }

@@ -435,14 +487,14 @@ redata_whatin_refresh(redata_t *redata, int chunkno)

 int

 redata_fix_nl(redata_t *redata, int chunkno)

 {

+        rechunk_t *chunk,*nextchunk;

+        int linesize, nextlinesize, avail, nextavail;

+        unsigned char *ptr,*nextptr;

         /* make sure a line of len<chunksize is entirely inside one chunk (to simplify the syntax highlighting code) */

         if(redata==NULL || chunkno<0 || chunkno>=redata->sizechunks || redata->chunks[chunkno]==NULL)

                 return(-1); /* sanity check failed */

         if(chunkno==(redata->sizechunks-1) || redata->chunks[chunkno]->useddata==0 || redata->chunks[chunkno]->data[redata->chunks[chunkno]->useddata-1]=='\n')

                 return(0); /* Nothing to do (last chunk, chunk empty or already fixed) */

-        rechunk_t *chunk,*nextchunk;

-        int linesize, nextlinesize, avail, nextavail;

-        unsigned char *ptr,*nextptr;

         chunk=redata->chunks[chunkno];

         nextchunk=redata->chunks[chunkno+1];

         ptr=mymemrchr(chunk->data,'\n',chunk->useddata);

@@ -763,6 +815,20 @@ redata_undo_reactivatelast(redata_t *redata, undostack_t *stack)

         return(0);

 }

+int

+redata_undo_groupinit(redata_t *redata, undostack_t *stack)

+{

+        /* stores the current position in (undostack).groupinit */

+#warning TODO

+        return(-1);

+}

+

+int redata_undo_groupcommit(redata_t *redata, undostack_t *stack)

+{

+        /* marks as hint_groupedwithnext from stored groupinit position in undostack to last-1 position (if groupinit pos is the last pos, do nothing)*/

+#warning TODO

+        return(-1);

+}

 int

 redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostack_t *fromhere)

@@ -1333,6 +1399,14 @@ redata_generic_utf8charlen(char *ptr, int maxsize)

         return(i);

 }

+inline int

+redata_generic_utf8isstartbyte(int candidate)

+{

+        if((candidate&0xc0)!=0x80)

+                return(1);

+        return(0);

+}

+

 static int

 redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes)

@@ -1389,94 +1463,225 @@ redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *

         return(0);

 }

-/*#define DEBUG_LINE_INFO*/

-

-#ifdef DEBUG_LINE_INFO

-#define LINEINFODEBUG(a) fprintf a

-#else

-#define LINEINFODEBUG(a)

-#endif

-

 int

-redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len)

+redata_line_rawinfo(redata_t *redata, long pos, long *startpos, char **startptr, int *len, int *is_continuation)

 {

-        int chunkno;

-        long start;

-        unsigned char *ptr,*end;

+        long chunkpos,newpos,endpos;

+        int nchunk;

         rechunk_t *chunk;

-        if(redata==NULL || pos<0)

+        if(redata==NULL || pos<0 || pos>=redata_getused(redata))

                 return(-1);

-        /* search chunk of pos */

-        for(chunkno=0,start=0;chunkno<redata->sizechunks;start+=(redata->chunks[chunkno]==NULL)?0:redata->chunks[chunkno]->useddata,chunkno++) {

-        LINEINFODEBUG((stderr,"redata_line_info: searchchunk: pos:%li chunkno:%i start:%li\n",pos,chunkno,start));

-                if(redata->chunks[chunkno]==NULL)

+        for(nchunk=0,chunkpos=0

+          ;nchunk<redata->sizechunks

+          ;chunkpos+=(chunk!=NULL)?chunk->useddata:0,nchunk++) {

+                if((chunk=redata->chunks[nchunk])==NULL)

                         continue;

-                if((start+redata->chunks[chunkno]->useddata)>pos)

+                if(pos>=chunkpos && pos<(chunkpos+chunk->useddata))

                         break;

         }

-        if(chunkno>=redata->sizechunks)

-                return(-1);

-        chunk=redata->chunks[chunkno];

-        /* search line start */

-        LINEINFODEBUG((stderr,"redata_line_info: searchstart: pos:%li start:%li offset:%li\n",pos,start,(pos-start)));

-        for(ptr=chunk->data+(pos-start);ptr>chunk->data && ptr[-1]!='\n';ptr--)

+        if(nchunk>=redata->sizechunks)

+                return(-1); /* pos not found */

+        for(newpos=pos;newpos>chunkpos && chunk->data[newpos-chunkpos-1]!='\n';newpos--)

                 ;

-        /* search line end */

-        LINEINFODEBUG((stderr,"redata_line_info: searchend: pos:%li start:%li offset:%li\n",pos,start,(pos-start)));

-        for(end=chunk->data+(pos-start)+1;end<=(chunk->data+chunk->useddata) && end[-1]!='\n';end++)

+        for(endpos=pos;endpos<(chunkpos+chunk->useddata) && chunk->data[endpos-chunkpos]!='\n';endpos++)

                 ;

-        /* fill results */

-        LINEINFODEBUG((stderr,"redata_line_info: filling results: len:%li\n",end-ptr));

+        if(endpos==(chunkpos+chunk->useddata))

+                endpos--;

         if(startpos!=NULL)

-                *startpos=(pos-((chunk->data+(pos-start))-ptr));

+                *startpos=newpos;

         if(startptr!=NULL)

-                *startptr=(char *) ptr;

+                *startptr=(char *) (chunk->data+(newpos-chunkpos));

         if(len!=NULL)

-                *len=end-ptr;

+                *len=endpos-newpos+1;

+        if(is_continuation!=NULL) {

+                if(!(chunk->whatin_fresh))

+                        redata_whatin_refresh(redata,nchunk);

+                *is_continuation=(newpos==chunkpos && chunk->whatin.iscontinuation)?1:0;

+        }

         return(0);

 }

 int

-redata_pos2linecol(redata_t *redata, long pos, int *resline, int *rescol)

+redata_line_realstart(redata_t *redata, long pos, long *startpos)

 {

-        int line,col;

-        int nchunk;

-        int chunkpos;

-        rechunk_t *chunk;

-        int i,o;

-        if(redata==NULL)

+        int is_continuation;

+        long nextpos,newpos;

+        if(redata==NULL || pos<0)

+                return(-1); /* sanity check failed */

+        nextpos=pos;

+        do {

+                if(redata_line_rawinfo(redata,nextpos,&newpos,NULL,NULL,&is_continuation)==-1)

+                        return(-1);

+                nextpos=newpos-1;

+        } while(is_continuation && newpos>0);

+        if(startpos!=NULL)

+                *startpos=newpos;

+        return(0);

+}

+

+int

+redata_line_realend(redata_t *redata, long pos, long *endpos)

+{

+        long nextpos,newpos;

+        long datasize;

+        char *ptr;

+        int len;

+        int has_nl;

+        if(redata==NULL || pos<0)

+                return(-1); /* sanity check failed */

+        nextpos=pos;

+        if((datasize=redata_getused(redata))<=0)

+                return(-1); /* couldn't get last pos or there is no data */

+        do {

+                if(redata_line_rawinfo(redata,nextpos,&newpos,&ptr,&len,NULL)==-1 || len==0)

+                        return(-1);

+                nextpos=newpos+len;

+                has_nl=(len>0 && ptr[len-1]=='\n')?1:0;

+        } while(!has_nl && nextpos<datasize);

+        if(endpos!=NULL)

+                *endpos=newpos+len-1;

+        return(0);

+}

+

+int

+redata_line_prevrealstart(redata_t *redata, long pos, long *startpos)

+{

+        long newpos,prevpos;

+        if(redata==NULL || pos<0)

                 return(-1);

-        /* search chunk of pos while calculating first lineno of chunk */

-        for(nchunk=0,line=0,chunkpos=0

-          ;nchunk<redata->sizechunks

-          ;line+=chunk->whatin.nlcount,chunkpos+=chunk->useddata,nchunk++) {

-                chunk=redata->chunks[nchunk];

-                if(!(chunk->whatin_fresh))

-                        redata_whatin_refresh(redata,nchunk);

-                if(pos<(chunkpos+chunk->useddata))

+        if(redata_line_realstart(redata,pos,&newpos)==-1)

+                return(-1); /* couldn't get start of line */

+        if(redata_line_realstart(redata,newpos-1,&prevpos)==-1)

+                return(-1); /* couldn't get start of line */

+        if(startpos!=NULL)

+                *startpos=prevpos;

+        return(0);

+}

+

+int

+redata_line_nextrealstart(redata_t *redata, long pos, long *startpos)

+{

+        long newpos,nextpos;

+        if(redata==NULL || pos<0)

+                return(-1);

+        if(redata_line_realend(redata,pos,&newpos)==-1)

+                return(-1); /* couldn't get end of line */

+        if(redata_line_realstart(redata,newpos+1,&nextpos)==-1)

+                return(-1); /* couldn't get start of line */

+        if(startpos!=NULL)

+                *startpos=nextpos;

+        return(0);

+}

+

+int

+redata_line_inccol(redata_t *redata, long pos, int ncolrequest, long *newpos, int *ncoldone)

+{

+        long curpos,startpos;

+        char *ptr;

+        int len;

+        int n,i;

+        int done;

+        if(redata==NULL || pos<0 || ncolrequest<0)

+                return(-1); /* sanity check failed */

+        if(ncolrequest==0) {

+                if(newpos!=NULL)

+                        *newpos=pos;

+                if(ncoldone!=NULL)

+                        *ncoldone=0;

+                return(0); /* nothing to do */

+        }

+        for(n=0,curpos=pos;n<=ncolrequest;) {

+                if(redata_line_rawinfo(redata,curpos,&startpos,&ptr,&len,NULL)==-1 || len==0)

+                        return(-1); /* couldn't get current line data */

+                done=0;

+                /* advance until we are positioned on the next char to the requested one */

+                for(i=startpos-curpos;i<len;i++) {

+                        if(redata_generic_utf8isstartbyte(ptr[i]))

+                                n++;

+                        if(ptr[i]=='\n' || n>ncolrequest) {

+                                done=1;

+                                break;

+                        }

+                }

+                curpos=startpos+i;

+                if(done)

                         break;

         }

-        if(nchunk>=redata->sizechunks)

-                return(-1); /* pos not found */

-        /* search chunk line/col */

-        for(i=0,o=chunkpos,col=0;o<pos && i<chunk->useddata;i++,o++) {

-                if(chunk->data[i]=='\n')

-                        line++,col=0;

-                else

-                        col++;

+        if(newpos!=NULL)

+                *newpos=curpos;

+        if(ncoldone!=NULL)

+                *ncoldone=n-1;

+        return(0);

+}

+

+

+int

+redata_pos2linecol(redata_t *redata, long pos, int *resline, int *rescol)

+{

+        if(redata==NULL || pos<0 || pos>=redata_getused(redata))

+                return(-1);

+        /* calculate line */

+        if(resline!=NULL) {

+                long chunkpos,newpos;

+                int startline;

+                int nchunk;

+                rechunk_t *chunk;

+                int i;

+                for(nchunk=0,chunkpos=0,startline=0

+                  ;nchunk<redata->sizechunks

+                  ;chunkpos+=(chunk!=NULL)?chunk->useddata:0

+                    ,startline+=(chunk!=NULL)?chunk->whatin.nlcount:0,nchunk++) {

+                        if((chunk=redata->chunks[nchunk])==NULL)

+                                continue;

+                        if(!(chunk->whatin_fresh))

+                                redata_whatin_refresh(redata,nchunk);

+                        if(pos>=chunkpos && pos<(chunkpos+chunk->useddata))

+                                break;

+                }

+                if(nchunk>=redata->sizechunks)

+                        return(-1); /* pos not found */

+                for(newpos=chunkpos,i=0;newpos<pos && i<chunk->useddata;newpos++,i++) {

+                        if(chunk->data[i]=='\n')

+                                startline++;

+                }

+                *resline=startline;

+        }

+        /* calculate col */

+        if(rescol!=NULL) {

+                long realstart,curpos,startpos;

+                char *ptr;

+                int len;

+                int n,i;

+                int done;

+                if(redata_line_realstart(redata,pos,&realstart)==-1)

+                        return(-1); /* startpos for pos not found */

+                for(n=0,curpos=realstart;curpos<pos;) {

+                        if(redata_line_rawinfo(redata,curpos,&startpos,&ptr,&len,NULL)==-1 || len==0)

+                                return(-1); /* couldn't get current line data */

+                        done=0;

+                        for(i=0;i<len && (startpos+i)<pos;i++) {

+                                if(redata_generic_utf8isstartbyte(ptr[i]))

+                                        n++;

+                                if(ptr[i]=='\n') {

+                                        done=1;

+                                        break;

+                                }

+                        }

+                        curpos=startpos+i;

+                        if(done)

+                                break;

+                }

+                *rescol=n;

         }

-        if(resline!=NULL)

-                *resline=line;

-        if(rescol!=NULL)

-                *rescol=col;

         return(0);

-#warning DEBUG THIS

 }

 int

-redata_linecol2pos(redata_t *redata, int line, int col, long *pos)

+redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone)

 {

-#warning TODO

+#warning TODO: XXX Implement this function

+#warning TODO: XXX: Add a parameter so this is like reata_line_inccol (colrequest, coldone) --  maybe also linetrequest linedone? (zed doesn''t let you go to the last line doing a Ctrl+q+l to an arbitrarily large number...)

+#warning TODO: XXX: The extra parameters are super-handy because the main user of this function is Control+Q+L "Go To Line" and we want to go to nearest pos

         return(-1);

 }

@@ -1514,3 +1719,14 @@ meminvert(void *start, void *end)

         }

 }

+static size_t

+memrchroffset(char *ptr, int c, size_t n)

+{

+        size_t i;

+        for(i=n-1;i>=0;i--) {

+                if(((unsigned char *)ptr)[i]==c)

+                        return(i);

+        }

+        return(-1);

+}

+

@@ -17,6 +17,7 @@

 typedef struct whatin_t {

         int nlcount;

+        int iscontinuation;

 } whatin_t;

 typedef struct rechunk_t {

@@ -34,12 +35,14 @@ typedef struct undo_t {

         long posdest;

         char prehash[129];

         char posthash[129];

+        int hint_groupedwithnext;

 } undo_t;

 typedef struct undostack_t {

         int sizeundo;

         int usedundo;

         undo_t *undo;

+        int groupinit;

         long sizebuf;

         long usedbuf;

         char *buf;

@@ -98,6 +101,9 @@ int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf

 int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);

 int redata_chunk_splithere(redata_t *redata, int chunkno, int pos);

 int redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n);

+int redata_chunk_unfreshnext(redata_t *redata, int chunkno);

+int redata_chunk_unfreshrange(redata_t *redata, int fromchunkno, int tochunkno);

+

 int redata_whatin_refresh(redata_t *redata, int chunkno);

 int redata_fix_nl(redata_t *redata, int chunkno);

 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);

@@ -109,6 +115,8 @@ int redata_undo_removelast(redata_t *redata, undostack_t *stack);

 int redata_undo_wipe(redata_t *redata, undostack_t *stack);

 int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

 int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

+int redata_undo_groupinit(redata_t *redata, undostack_t *stack);

+int redata_undo_groupcommit(redata_t *redata, undostack_t *stack);

 /* high level stuff */

 int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr);

@@ -140,10 +148,25 @@ int redata_generic_utf8len(char *ptr, int size);

 char *redata_generic_utf8col(char *ptr, int size, int col);

 /* returns the len in bytes of the character starting at ptr (zero on error)*/

 int redata_generic_utf8charlen(char *ptr, int maxsize);

+/* returns true if it's the forst byte of an UTF char */

+int redata_generic_utf8isstartbyte(int candidate);

 /* line convenience funtions */

-int redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len);

+/* get pointer to full line (if it doesn't fit in a chunk, is_continuation is 1 and/or doesn't have an ending nl */

+int redata_line_rawinfo(redata_t *redata, long pos, long *startpos, char **startptr, int *len, int *is_continuation);

+/* get the startpos of line, even if it doesn't fit in one chunk */

+int redata_line_realstart(redata_t *redata, long pos, long *startpos);

+/* get the endpos of line, even if it doesn't fit in one chunk */

+int redata_line_realend(redata_t *redata, long pos, long *endpos);

+/* get pos of previous line real start */

+int redata_line_prevrealstart(redata_t *redata, long pos, long *startpos);

+/* get pos of next line real start */

+int redata_line_nextrealstart(redata_t *redata, long pos, long *startpos);

+/* advance "n" cols */

+int redata_line_inccol(redata_t *redata, long pos, int ncolrequest, long *newpos, int *ncoldone);

+/* get the line/col of a pos (col is calculated using the utf8 convenience functions) */

 int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

-int redata_linecol2pos(redata_t *redata, int line, int col, long *pos);

+/* get the pos of that line/col (calculated using the utf8 convenience functions) */

+int redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone);

@@ -21,6 +21,21 @@

 #define LINEFORCESCROLL 1

 #define COLFORCESCROLL 5

+#define COMMANDBUFSIZE 1024

+

+#define COMMAND_WARNING "(!)"

+#define COMMAND_GOTOLINE "Go to line: "

+

+#define COLOR_STATUSBG "\x00\x00\xff\xff"

+#define COLOR_STATUSFG "\xff\xff\x00\xff"

+

+#define COLOR_QUERYBG "\xc0\xff\x00\xff"

+#define COLOR_QUERYFG "\x3f\x00\xff\xff"

+

+#define COLOR_WARNINGBG "\xff\x00\x00\xff"

+#define COLOR_WARNINGFG "\xff\xff\x00\xff"

+

+

 typedef struct re_t {

         redata_t *data;

         reui_t *ui;

@@ -31,7 +46,11 @@ typedef struct re_t {

         int originline,origincol;

         int curline,curcol;

         int maxrow,maxcol;

+        int headerdirty;

         int contentsdirty;

+        char *command;

+        char commandbuf[COMMANDBUFSIZE];

+        int ignorenkeys;

 } re_t;

 volatile int flag_sigint;

@@ -47,10 +66,15 @@ re_t *re_init(void);

 void re_free(re_t *re);

 int re_setfilename(re_t *re, char *filename);

-int re_processkey(re_t *re, SDL_Event *event);

+int re_processkey_editing(re_t *re, SDL_Event *event);

+int re_processkey_commandwait(re_t *re, SDL_Event *event);

+int re_processkey_commanddata(re_t *re, SDL_Event *event);

+int re_processcommand(re_t *re);

 int re_moveupdown(re_t *re, int totalinc);

 int re_moveleftright(re_t *re, int totalinc);

-int re_drawheader(re_t *re);

+int re_rtrim(re_t *re, long curpos, int *trimmed);

+int re_drawheader_editing(re_t *re);

+int re_drawheader_command(re_t *re);

 int re_drawcontents(re_t *re);

@@ -106,10 +130,25 @@ main(int argc, char *argv[])

         re->x=0,re->y=re->ui->fontheight,re->w=re->ui->w,re->h=re->ui->h-re->y;

         re->maxrow=re->h/re->ui->fontheight-1;

         re->maxcol=re->w/re->ui->fontwidth-1;

-        re_drawheader(re);

-        re_drawcontents(re);

+        re->headerdirty=1;

+        re->contentsdirty=1;

         flag_had_events=0;

+        SDL_StartTextInput();

         while(do_exit==0 && flag_sigint==0) {

+                if(re->headerdirty) {

+                        if(re->command==NULL) {

+fprintf(stderr,"REDRAW Header (editing)\n");

+                                re_drawheader_editing(re);

+                        } else {

+fprintf(stderr,"REDRAW Header (command)\n");

+                                re_drawheader_command(re);

+                                if(strcmp(re->command,COMMAND_WARNING)==0) {

+                                        /* the warnings only get shown once, remove it */

+                                        re->command=NULL;

+                                        re->commandbuf[0]='\0';

+                                }

+                        }

+                }

                 if(re->contentsdirty)

                         re_drawcontents(re);

                 if(re->ui->rendererdirty)

@@ -124,7 +163,14 @@ main(int argc, char *argv[])

                                         do_exit=1;

                                         break;

                                 case SDL_KEYDOWN:

-                                        re_processkey(re,&event);

+                                case SDL_TEXTINPUT:

+                                case SDL_TEXTEDITING:

+                                        if(re->command==NULL || strcmp(re->command,COMMAND_WARNING)==0)

+                                                re_processkey_editing(re,&event);

+                                        else if(re->command[0]=='\0')

+                                                re_processkey_commandwait(re,&event);

+                                        else

+                                                re_processkey_commanddata(re,&event);

                                         break;

                                 case SDL_WINDOWEVENT:

                                         if(event.window.event==SDL_WINDOWEVENT_SHOWN

@@ -137,6 +183,7 @@ main(int argc, char *argv[])

                         }

                 }

         }

+        SDL_StopTextInput();

         sselect_free(ssel),ssel=NULL;

         re_free(re),re=NULL;

         return(0);

@@ -209,14 +256,79 @@ re_setfilename(re_t *re, char *filename)

 }

 int

-re_processkey(re_t *re, SDL_Event *event)

+re_processkey_editing(re_t *re, SDL_Event *event)

 {

-        long newpos;

-        char *ptr;

-        int len;

-        int has_nl;

-        if(re==NULL || event==NULL || event->type!=SDL_KEYDOWN)

+        SDL_Event returnevent;

+        if(re==NULL || event==NULL)

                 return(-1); /* sanity check failed */

+        /* convert RETURN KEYDOWN to TEXTINPUT */

+        if(event->type==SDL_KEYDOWN && event->key.keysym.sym==SDLK_RETURN) {

+                memset(&returnevent,0,sizeof(SDL_Event));

+                event=&returnevent;

+                event->type=SDL_TEXTINPUT;

+                strncpy(event->text.text,"\n",sizeof(event->text.text));

+                event->text.text[sizeof(event->text.text)-1]='\0';

+        }

+        /* special case: text editing event */

+        if(event->type==SDL_TEXTINPUT) {

+                int len;

+                long realend;

+                int at_end;

+                if(re->ignorenkeys>0) {

+                        re->ignorenkeys--;

+                        return(0); /* this is an already processed key, ignore it */

+                }

+#if 1

+fprintf(stderr,"SDL_TEXTINPUT:\"%s\"\n",event->text.text);

+#endif

+                if(redata_line_realend(re->data,re->cursorpos,&realend)==-1)

+                        return(-1); /* couldn't get current line info */

+                at_end=(re->cursorpos==realend)?1:0;

+                if(event->text.text[0]==' ' && event->text.text[1]=='\0' && at_end) {

+                        /* instead of adding a space at the end of the line, we move the cursor to the right */

+                        re_moveleftright(re,1);

+                        return(0); /* no need to add spaces at the end of the line */

+                }

+                redata_undo_groupinit(re->data,NULL);

+                if(event!=&returnevent && at_end) {

+                        int col;

+                        if(redata_pos2linecol(re->data,re->cursorpos,NULL,&col)==-1)

+                                return(-1); /* couldn't get line info */

+                        if(redata_op_addn(re->data,re->cursorpos,' ',re->curcol-col,NULL)!=0)

+                                return(-1); /* couldn't add spaces up to current displayed pos */

+                        /* increment cursorpos; spaces are 1 byte, so the number of columns advanced is the number of bytes advanced */

+                        re->cursorpos+=re->curcol-col;

+                }

+                len=strlen(event->text.text);

+                if(redata_op_add(re->data,re->cursorpos,event->text.text,len,NULL)!=0)

+                        return(-1); /* couldn't add requested text */

+                re->cursorpos+=len;

+                if(event==&returnevent) {

+                        int trimmed;

+                        if(re_rtrim(re,re->cursorpos-len,&trimmed))

+                                re->cursorpos-=trimmed;

+                        re->curline++;

+                        re->curcol=0;

+                } else {

+                        re->curcol+=redata_generic_utf8len(event->text.text,len);

+                }

+                redata_undo_groupcommit(re->data,NULL);

+                re->headerdirty=1;

+                re->contentsdirty=1;

+        }

+#if 0

+        else if(event->type==SDL_TEXTEDITING) {

+                /* NOTE: on window enter events we cam also receive this event (!) */

+#warning TODO: CJK support

+fprintf(stderr,"SDL_TEXTEDITING: composition:\"%s\" start:%i len:%i\n",event->edit.text,event->edit.start,event->edit.length);

+        }

+#endif

+        /* default case: keydown event */

+        if(event->type!=SDL_KEYDOWN)

+                return(0); /* Ignore other possible events */

+#if 1

+fprintf(stderr,"SDL_KEYDOWN: sym:%i\n",event->key.keysym.sym);

+#endif

         if(event->key.keysym.sym==SDLK_DOWN || event->key.keysym.sym==SDLK_UP) {

                 re_moveupdown(re,(event->key.keysym.sym==SDLK_UP)?-1:1);

         } else if(event->key.keysym.sym==SDLK_LEFT || event->key.keysym.sym==SDLK_RIGHT) {

@@ -224,11 +336,14 @@ re_processkey(re_t *re, SDL_Event *event)

         } else if(event->key.keysym.sym==SDLK_PAGEDOWN || event->key.keysym.sym==SDLK_PAGEUP) {

                 re_moveupdown(re,(event->key.keysym.sym==SDLK_PAGEUP)?-(re->maxrow):re->maxrow);

         } else if(event->key.keysym.sym==SDLK_HOME || event->key.keysym.sym==SDLK_END) {

-                if(redata_line_info(re->data,re->cursorpos,&newpos,&ptr,&len)==-1)

-                        return(-1); /* couldn't get current line data */

-                has_nl=((len>0 && ptr[len-1]=='\n')?1:0);

-                re->cursorpos=(event->key.keysym.sym==SDLK_HOME)?newpos:newpos+len-has_nl;

-                redata_pos2linecol(re->data,re->cursorpos,&(re->curline),&(re->curcol));

+                long newpos;

+                if((event->key.keysym.sym==SDLK_HOME && redata_line_realstart(re->data,re->cursorpos,&newpos)==-1)

+                  || (event->key.keysym.sym==SDLK_END && redata_line_realend(re->data,re->cursorpos,&newpos)==-1)) {

+                        return(-1); /* couldn't get destination pos data */

+                }

+                re->cursorpos=newpos;

+                if(redata_pos2linecol(re->data,re->cursorpos,NULL,&(re->curcol))==-1)

+                        return(-1); /* couldn't get col of current pos */;

                 if(re->curcol<re->origincol) {

                         re->origincol=re->curcol;

                         re->origincol=(re->origincol<0)?0:re->origincol;

@@ -237,42 +352,184 @@ re_processkey(re_t *re, SDL_Event *event)

                         re->origincol=re->curcol+COLFORCESCROLL-re->maxcol;

                         re->origincol=(re->origincol<0)?0:re->origincol;

                 }

+                re->headerdirty=1;

+                re->contentsdirty=1;

+        } else if(event->key.keysym.sym==SDLK_BACKSPACE && re->cursorpos>0) {

+                int line,col;

+                long startpos,newpos,realstart,start;

+                char *ptr;

+                int len;

+                int trimmed;

+                int doneinc;

+                if(redata_pos2linecol(re->data,re->cursorpos,&line,&col)==-1)

+                        return(-1); /* couldn't get current line data */

+                if(col<re->curcol) {

+                        re_moveleftright(re,-1);

+                        return(0); /* were hovering to the right of last char, only had to move left */

+                }

+                redata_undo_groupinit(re->data,NULL);

+                /* delete the last character */

+                if(col>0) {

+                        if(redata_line_realstart(re->data,re->cursorpos,&realstart)==-1)

+                                return(-1); /* couldn't get line info */

+                        /* get the start of the part to delete */

+                        doneinc=0;

+                        for(ptr=NULL,len=0,start=0,newpos=re->cursorpos;doneinc!=1;) {

+                                if((newpos-1)<realstart)

+                                        break;

+                                newpos--;

+                                if(ptr==NULL || (start+len)<=newpos || newpos<start) {

+                                        if(redata_line_rawinfo(re->data,newpos,&start,&ptr,&len,NULL)==-1)

+                                                return(-1); /* couldn't get line data */

+                                }

+                                if(redata_generic_utf8isstartbyte(ptr[newpos-start]))

+                                        doneinc++;

+                        }

+                        /* delete */

+                        redata_op_del(re->data,newpos,re->cursorpos-newpos,NULL);

+                        re->cursorpos=newpos;

+                } else {

+                        long delpos;

+                        /* to make the code trivial, we're being lazy on '\n' deletion: we call ...rawinfo() for each byte in the multibyte utf-8 sequence */

+                        for(delpos=re->cursorpos-1

+                          ;delpos>0

+                          && redata_line_rawinfo(re->data,delpos,&startpos,&ptr,&len,NULL)==0;) {

+                                if(redata_generic_utf8isstartbyte(ptr[delpos-startpos]))

+                                        break;

+                        }

+                        redata_op_del(re->data,delpos,re->cursorpos-delpos,NULL);

+                        re->cursorpos=delpos;

+                }

+                redata_pos2linecol(re->data,re->cursorpos,&(re->curline),&(re->curcol));

+                /* if cursor at end of line and there are trailing spaces at the end, delete them too */

+                if(re_rtrim(re,re->cursorpos,&trimmed))

+                        re->cursorpos-=trimmed;

+                /* end of deletion */

+                redata_undo_groupcommit(re->data,NULL);

+                re->headerdirty=1;

                 re->contentsdirty=1;

-                re_drawheader(re);

-        } else if(event->key.keysym.sym==SDLK_a) {

-                ;

+        } else if(event->key.keysym.sym==SDLK_q && (SDL_GetModState()&KMOD_CTRL)!=0) {

+fprintf(stderr,"re_processkey(): received Control+q\n");

+                re->command="";

+                re->headerdirty=1;

         }

-        return(-1);

+        return(0);

+}

+

+int

+re_processkey_commandwait(re_t *re, SDL_Event *event)

+{

+        if(re==NULL || event==NULL)

+                return(-1); /* sanity check failed */

+        /* default case: keydown event */

+        if(event->type!=SDL_KEYDOWN)

+                return(0); /* Ignore other possible events */

+        if(event->key.keysym.sym==SDLK_l) {

+                re->command=COMMAND_GOTOLINE;

+                re->commandbuf[0]='\0';

+                re->headerdirty=1;

+        } else {

+                re->command=NULL;

+                re->headerdirty=1;

+        }

+        if(!(SDL_GetModState()&KMOD_CTRL))

+                re->ignorenkeys=1; /* control was not pressed, we will receive again this key as SDL_TEXTINPUT */

+        return(0);

+}

+

+int

+re_processkey_commanddata(re_t *re, SDL_Event *event)

+{

+        if(re==NULL || event==NULL)

+                return(-1); /* sanity check failed */

+        /* special case: text editing event */

+        if(event->type==SDL_TEXTINPUT) {

+                int len;