@@ -28,7 +28,8 @@

 #define IDLETIMEOUTSECONDS 10

 #define COMMANDBUFSIZE 1024

-#define DEFAULTFONTHEIGHT 16

+#define DEFAULTFONTHEIGHT 14

+#define SELECTBUFBLOCK 16384

 #define COMMAND_WARNING "(!)"

 #define COMMAND_GOTOLINE "Go to line:"

@@ -63,6 +64,12 @@ typedef struct re_t {

         int headerdirty;

         int contentsdirty;

         int command_first_key;

+        int selactive;

+        int sellinefrom,sellineto;

+        int selcolfrom,selcolto;

+        long sizeselectbuf;

+        long usedselectbuf;

+        char *selectbuf;

         char *command;

         char commandbuf[COMMANDBUFSIZE];

         char cachelastsearch[COMMANDBUFSIZE];

@@ -94,13 +101,19 @@ int re_processcommand(re_t *re);

 int re_moveupdown(re_t *re, int totalinc);

 int re_moveleftright(re_t *re, int totalinc);

 int re_changefontsize(re_t *re, int direction);

+int re_sel_setstart(re_t *re, int line, int col);

+int re_sel_setend(re_t *re, int line, int col);

+int re_sel_toggle(re_t *re);

+int re_sel_lincolisinside(re_t *re, int line, int col);

+int re_sel_lincolisbefore(re_t *re, int line, int col);

+int re_sel_lincolisafter(re_t *re, int line, int col);

+int re_selectbuf_fill(re_t *re,long frompos,long size, int nadditionalspaces);

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

 long re_getmatchingbracket(re_t *re,long posini, char originalchar, char *matchingchar);

 int re_drawheader_editing(re_t *re);

 int re_drawheader_command(re_t *re);

 int re_drawcontents(re_t *re);

-

 int

 main(int argc, char *argv[])

 {

@@ -340,6 +353,8 @@ re_free(re_t *re)

                 reui_free(re->ui),re->ui=NULL;

         if(re->data!=NULL)

                 redata_free(re->data),re->data=NULL;

+        if(re->selectbuf!=NULL)

+                free(re->selectbuf),re->selectbuf=NULL,re->usedselectbuf=re->sizeselectbuf=NULL;

         free(re),re=NULL;

         return;

 }

@@ -531,9 +546,32 @@ fprintf(stderr,"SDL_TEXTEDITING: composition:\"%s\" start:%i len:%i\n",event->ed

 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);

+#warning #error BUG: Played with selections a bit, resized font twice, go down a lot of lines, when after about last line previously displayed it segfaulted

+                int oldcol=re->curline,oldline=re->curcol;

+                if(re_moveupdown(re,(event->key.keysym.sym==SDLK_UP)?-1:1)==0 && (SDL_GetModState()&KMOD_SHIFT)!=0 && (re->curcol!=oldcol || re->curline!=oldline)) {

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

+                                if(re->selactive==0 || re_sel_lincolisafter(re,oldcol,oldline))

+                                        re_sel_setend(re,oldcol,oldline);

+                                re_sel_setstart(re,re->curline,re->curcol);

+                        } else {

+                                if(re->selactive==0 || re_sel_lincolisbefore(re,oldcol,oldline))

+                                        re_sel_setstart(re,oldcol,oldline);

+                                re_sel_setend(re,re->curline,re->curcol);

+                        }

+                }

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

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

+                int oldcol=re->curline,oldline=re->curcol;

+                if(re_moveleftright(re,(event->key.keysym.sym==SDLK_LEFT)?-1:1)==0 && (SDL_GetModState()&KMOD_SHIFT)!=0 && (re->curcol!=oldcol || re->curline!=oldline)) {

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

+                                if(re->selactive==0 || re_sel_lincolisafter(re,oldcol,oldline))

+                                        re_sel_setend(re,oldcol,oldline);

+                                re_sel_setstart(re,re->curline,re->curcol);

+                        } else {

+                                if(re->selactive==0 || re_sel_lincolisbefore(re,oldcol,oldline))

+                                        re_sel_setstart(re,oldcol,oldline);

+                                re_sel_setend(re,re->curline,re->curcol);

+                        }

+                }

         } else if((SDL_GetModState()&KMOD_CTRL)!=0 && (event->key.keysym.sym==SDLK_PAGEDOWN || event->key.keysym.sym==SDLK_PAGEUP)) {

                 re->cursorpos=(event->key.keysym.sym==SDLK_PAGEDOWN)?(redata_getused(re->data)-1):0;

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

@@ -688,6 +726,87 @@ re_processkey_commandwait(re_t *re, SDL_Event *event)

                 re->command=COMMAND_EXIT;

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

                 re->headerdirty=1;

+        } else if(re->command_first_key=='k' && event->key.keysym.sym==SDLK_h) {

+#warning #error TODO: IF Ctrl+C, get a buffer of the right size into re (re->selectbuf), use redata_extract() to get those bytes into the buffer

+#warning #error TODO: IF Ctrl+X, do as in Ctrl+X, but delete the bytes from redata afterwards

+#warning #error TODO: IF Ctrl+V, insert the bytes in re->selectbuf into the curent cursor pos

+                re_sel_toggle(re);

+                re->command=NULL;

+                re->headerdirty=1;

+        } else if(re->command_first_key=='k' && event->key.keysym.sym==SDLK_b) {

+                re_sel_setstart(re,re->curline,re->curcol);

+                re->command=NULL;

+                re->headerdirty=1;

+        } else if(re->command_first_key=='k' && event->key.keysym.sym==SDLK_k) {

+                re_sel_setend(re,re->curline,re->curcol);

+                re->command=NULL;

+                re->headerdirty=1;

+        } else if(re->command_first_key=='k' && event->key.keysym.sym==SDLK_y) {

+                long frompos,topos,coldone;

+                /* wordstar-style blockdel (ctrl+k+y) */

+                if(re->selactive

+                  && redata_linecol2pos(re->data,re->sellinefrom,re->selcolfrom,&frompos,NULL)==0

+                  && redata_linecol2pos(re->data,re->sellineto,re->selcolto,&topos,&coldone)==0) {

+                        re_selectbuf_fill(re,frompos,topos-frompos,re->selcolto-coldone);

+                        redata_undo_groupinit(re->data,NULL);

+                        redata_op_del(re->data,frompos,topos-frompos,NULL);

+                        redata_undo_groupcommit(re->data,NULL);

+                        if(re->cursorpos>frompos) {

+                                re->cursorpos=frompos;

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

+                                re_fixorigin(re);

+                        }

+                        re->headerdirty=1;

+                        re->contentsdirty=1;

+                }

+                if(re->selactive)

+                        re_sel_toggle(re);

+                re->command=NULL;

+                re->headerdirty=1;

+        } else if(re->command_first_key=='k' && (event->key.keysym.sym==SDLK_c || event->key.keysym.sym==SDLK_v)) {

+                long frompos,topos,insertpos;

+                int tocoldone,coldone;

+                /* wordstar-style blockcopy (ctrl+k+c) or move (ctrl+k+v)*/

+                int is_move=(event->key.keysym.sym==SDLK_v)?1:0;

+                if(re->selactive

+                  && redata_linecol2pos(re->data,re->sellinefrom,re->selcolfrom,&frompos,NULL)==0

+                  && redata_linecol2pos(re->data,re->sellineto,re->selcolto,&topos,&tocoldone)==0

+                  && redata_linecol2pos(re->data,re->curline,re->curcol,&insertpos,&coldone)==0

+                  && re_selectbuf_fill(re,frompos,topos-frompos,re->selcolto-tocoldone)==0

+                  && redata_preallocate(re->data,redata_getused(re->data)+(re->curcol-coldone)+(is_move?0:re->usedselectbuf))==0) {

+                        if(is_move && insertpos>=frompos && insertpos<topos) {

+                                re->curline=re->sellinefrom;

+                                re->curcol=re->selcolfrom;

+                                redata_linecol2pos(re->data,re->curline,re->curcol,&insertpos,&coldone);

+                        }

+                        redata_undo_groupinit(re->data,NULL);

+                        if(coldone<re->curcol

+                          && redata_op_addn(re->data,insertpos,' ',re->curcol-coldone,NULL)==0) {

+                                insertpos+=re->curcol-coldone;

+                        }

+                        if(is_move) {

+                                redata_op_del(re->data,frompos,re->usedselectbuf,NULL);

+                                redata_op_add(re->data,insertpos-((insertpos>frompos)?re->usedselectbuf:0),re->selectbuf,re->usedselectbuf,NULL);

+                                re->cursorpos=insertpos-((insertpos>frompos)?re->usedselectbuf:0)+re->usedselectbuf;

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

+                                redata_pos2linecol(re->data,re->cursorpos-re->usedselectbuf,&(re->sellinefrom),&(re->selcolfrom));

+                                re->sellineto=re->curline;

+                                re->selcolto=re->curcol;

+                        } else {

+                                redata_op_add(re->data,insertpos,re->selectbuf,re->usedselectbuf,NULL);

+                                re->cursorpos=insertpos+re->usedselectbuf;

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

+                                redata_pos2linecol(re->data,insertpos,&(re->sellinefrom),&(re->selcolfrom));

+                                re->sellineto=re->curline;

+                                re->selcolto=re->curcol;

+                        }

+                        redata_undo_groupcommit(re->data,NULL);

+                        re_fixorigin(re);

+                        re->headerdirty=1;

+                        re->contentsdirty=1;

+                }

+                re->command=NULL;

+                re->headerdirty=1;

         } else {

                 re->command=NULL;

                 re->headerdirty=1;

@@ -968,6 +1087,130 @@ re_changefontsize(re_t *re, int direction)

         return(0);

 }

+int

+re_sel_setstart(re_t *re, int line, int col)

+{

+        if(re==NULL || line<0 || col<0)

+                return(-1);

+        re->sellinefrom=line;

+        re->selcolfrom=col;

+        if(re->selactive==0

+          || (re->sellineto<re->sellinefrom)

+          || (re->sellineto==re->sellinefrom && re->selcolto<re->selcolfrom)) {

+              re->sellineto=re->sellinefrom;

+              re->selcolto=re->selcolfrom;

+        }

+        re->selactive=1;

+        re->contentsdirty=1;

+        return(0);

+}

+

+int

+re_sel_setend(re_t *re, int line, int col)

+{

+        if(re==NULL || line<0 || col<0)

+                return(-1);

+        re->sellineto=line;

+        re->selcolto=col;

+        if(re->selactive==0

+          || (re->sellineto<re->sellinefrom)

+          || (re->sellineto==re->sellinefrom && re->selcolto<re->selcolfrom)) {

+              re->sellinefrom=re->sellineto;

+              re->selcolfrom=re->selcolto;

+        }

+        re->selactive=1;

+        re->contentsdirty=1;

+        return(0);

+}

+

+int

+re_sel_toggle(re_t *re)

+{

+        if(re==NULL)

+                return(-1);

+        re->selactive=1-re->selactive;

+        re->contentsdirty=1;

+        return(0);

+}

+

+int

+re_sel_lincolisinside(re_t *re, int line, int col)

+{

+        if(re==NULL || line<0 || col<0)

+                return(0);

+        if(line==re->sellinefrom && line==re->sellineto) {

+                if(col>=re->selcolfrom && col<re->selcolto)

+                        return(1);

+                return(0);

+        } else if(line==re->sellinefrom) {

+                if(col>=re->selcolfrom)

+                        return(1);

+                return(0);

+        } else if(line>re->sellinefrom && line<re->sellineto) {

+                return(1);

+        } else if(line==re->sellineto) {

+                if(col<re->selcolto)

+                        return(1);

+                return(0);

+        }

+        return(0);

+}

+

+int

+re_sel_lincolisbefore(re_t *re, int line, int col)

+{

+        if(re==NULL || line<0 || col<0)

+                return(0);

+        if(line<re->sellinefrom || (line==re->sellinefrom && col<re->selcolfrom))

+                return(1);

+        return(0);

+}

+

+int

+re_sel_lincolisafter(re_t *re, int line, int col)

+{

+        if(re==NULL || line<0 || col<0)

+                return(0);

+        if(line>re->sellineto || (line==re->sellineto && col>=re->selcolto))

+                return(1);

+        return(0);

+}

+

+int

+re_selectbuf_fill(re_t *re,long frompos,long size, int nadditionalspaces)

+{

+        int nchunk,off,avail;

+        long n;

+        if(re==NULL || size<0 || nadditionalspaces<0 || (frompos+size)>redata_getused(re->data) || redata_getposptr(re->data,frompos,&nchunk,&off)!=0)

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

+        re->usedselectbuf=0;

+        if((size+nadditionalspaces)>re->sizeselectbuf) {

+                long newsize;

+                char *newptr;

+                newsize=(size+nadditionalspaces+SELECTBUFBLOCK-1)/SELECTBUFBLOCK;

+                newsize*=SELECTBUFBLOCK;

+                if((newptr=realloc(re->selectbuf,newsize))==NULL)

+                        return(-1);

+                re->selectbuf=newptr;

+                re->sizeselectbuf=newsize;

+        }

+        for(n=0;n<size && nchunk<re->data->sizechunks;nchunk++,off=0) {

+                avail=re->data->chunks[nchunk]->useddata-off;

+                if(avail<=0)

+                        continue;

+                if(avail>(size-n))

+                        avail=size-n;

+                memcpy(re->selectbuf+n,re->data->chunks[nchunk]->data+off,avail);

+                n+=avail;

+        }

+        re->usedselectbuf=n;

+        if(nadditionalspaces>0) {

+                memset(re->selectbuf+re->usedselectbuf,' ',nadditionalspaces);

+                re->usedselectbuf+=nadditionalspaces;

+        }

+        return(0);

+}

+

 int

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

@@ -1124,7 +1367,7 @@ re_drawcontents(re_t *re)

         long pos,newpos;

         char *ptr;

         int len;

-        int y,row;

+        int y,row,tmprow;

         char *curptr;

         int curptrlen;

         int has_nl;

@@ -1141,9 +1384,17 @@ re_drawcontents(re_t *re)

         char matchingchar;

         int mline,mcol;

         const char *hint;

+        const char selcolornormal[]={"\xde\xcf\x7f\xff"};

+        const char selcolorcurline[]={"\xf0\xea\xc9\xff"};

         if(re==NULL)

                 return(-1);

+#if 0

+fprintf(stderr,"re_drawcontents: pre  reuifill1\n");

+#endif

         reui_fill(re->ui,re->x,re->y,re->w,re->h,"\xdf\xdf\xdf\xff");

+#if 0

+fprintf(stderr,"re_drawcontents: post reuifill1\n");

+#endif

         row=re->curline-re->originline;

         pos=re->cursorpos;

         while(row>0 && pos>0) {

@@ -1154,7 +1405,50 @@ re_drawcontents(re_t *re)

                         row--;

         }

         /* highlight current line */

+#if 0

+fprintf(stderr,"re_drawcontents: pre  reuifill2\n");

+#endif

         reui_fill(re->ui,re->x,re->y+(re->curline-re->originline)*re->ui->fontheight,re->w,re->ui->fontheight+1,"\xef\xef\xef\xff");

+#if 0

+fprintf(stderr,"re_drawcontents: post reuifill2\n");

+#endif

+        /* highlight the selection */

+        if(re->selactive) {

+                const char *selcolor;

+                tmprow=row;

+#if 0

+fprintf(stderr,"re_drawcontents: reuifill3: ");

+#endif

+                for(y=re->y;y<(re->y+re->h);y+=re->ui->fontheight,row++) {

+                        selcolor=(row==(re->curline-re->originline))?selcolorcurline:selcolornormal;

+                        if((re->originline+row)==re->sellinefrom && (re->originline+row)==re->sellineto) {

+                                reui_fill(re->ui,re->x+(re->selcolfrom-re->origincol)*re->ui->fontwidth,re->y+row*re->ui->fontheight,(re->selcolto-re->selcolfrom)*re->ui->fontwidth,re->ui->fontheight+1,selcolor);

+                        } else if((re->originline+row)==re->sellinefrom) {

+                                int x1;

+                                x1=re->x+(re->selcolfrom-re->origincol)*re->ui->fontwidth;

+                                if(x1<(re->x+re->w))

+                                        reui_fill(re->ui,x1,re->y+row*re->ui->fontheight,re->w-x1,re->ui->fontheight+1,selcolor);

+                        } else if((re->originline+row)>re->sellinefrom && (re->originline+row)<re->sellineto) {

+#if 0

+fprintf(stderr,"{(ui,%i,%i,%i,%i,#%02X%02X%02X%02X)",re->x,re->y+row*re->ui->fontheight,re->w,re->ui->fontheight+1,((unsigned char *)selcolor)[0],((unsigned char *)selcolor)[1],((unsigned char *)selcolor)[2],((unsigned char *)selcolor)[3]);

+#endif

+                                reui_fill(re->ui,re->x,re->y+row*re->ui->fontheight,re->w,re->ui->fontheight+1,selcolor);

+#if 0

+fprintf(stderr,"}");

+#endif

+                        } else if((re->originline+row)==re->sellineto) {

+                                int x2;

+                                x2=re->x+(re->selcolto-re->origincol)*re->ui->fontwidth;

+                                if(x2>(re->x))

+                                        reui_fill(re->ui,re->x,re->y+row*re->ui->fontheight,x2-re->x,re->ui->fontheight+1,selcolor);

+                        }

+

+                }

+                row=tmprow;

+#if 0

+fprintf(stderr,"\n");

+#endif

+        }

         /* draw the lines */

         drawn_cursor=0;

         colors=redata_highlighter_getcolors(re->data,&ncolors);

@@ -1164,7 +1458,7 @@ re_drawcontents(re_t *re)

                 /* definition of vars for tracking linecolor usage */

                 int curlinecolor; /* current linecolor */

                 int usedlenlinecolor; /* number of bytes of current linecolor already drawn */

-                /* end of deifinitions */

+                /* end of definitions */

                 if(redata_line_realstart(re->data,pos,&realstart)==-1 || redata_line_realend(re->data,pos,&realend)==-1) {

                         break; /* couldn't get real start/end */

                 }