@@ -2,7 +2,7 @@ CC=gcc

 CFLAGS=-g -Wall -Wformat-truncation=0 -Ideps -I/usr/include/SDL2

 LDFLAGS=-lSDL2 -lSDL2_image -lSDL2_ttf

-all: re tests

+all: re tests tests_ui

 recenteditor.o: recenteditor.c re_data.h ext/socklib.h

@@ -14,6 +14,8 @@ re_ui.o: re_ui.c re_ui.h hack_regular.h

 re_tests.o: re_tests.c re_data.h

+re_tests_ui.o: re_tests_ui.c re_ui.h

+

 sha3.o: sha3/sha3.c sha3/sha3.h

 	$(CC) $(CFLAGS) -Isha3 -c -o sha3.o sha3/sha3.c

@@ -35,5 +37,8 @@ re: recenteditor.o re_data.o re_plugin_unsaved.o sha3.o re_ui.o hack_regular.o s

 tests: re_tests.o re_data.o sha3.o

 	$(CC) $(LDFLAGS) -o tests re_tests.o re_data.o sha3.o

+tests_ui: re_tests_ui.o re_ui.o hack_regular.o

+	$(CC) $(LDFLAGS) -o tests_ui re_tests_ui.o re_ui.o hack_regular.o

+

 clean:

 	rm -f recenteditor.o re_data.o re_tests.o re_plugin_unsaved.o sha3.o re_ui.o hack_regular.c hack_regular.h hack_regular.o re tests 

new file mode 100644

@@ -0,0 +1,150 @@

+/*

+ * re_tests_ui.c

+ *

+ * A programmers editor

+ *

+ * Tests (ensure correct functionality of modules)

+ *

+ * Author: Dario Rodriguez dario@softhome.net

+ * This program is licensed under the terms of GNU GPL v2.1+

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <unistd.h>

+#include <string.h>

+#include <limits.h>

+#include <fcntl.h>

+#include <errno.h>

+

+#include "re_ui.h"

+

+#define TEST_OK "OK"

+

+typedef struct test_ui_t  {

+        int needs_realui;

+        char *name;

+        char *(*fn)(reui_t *,char *,int , int, int, int);

+} test_ui_t;

+

+char *test_utf8len(reui_t *ui, char *teststring, int expectednchars, int dummy1, int dummy2,int dummy3);

+char *test_utf8col(reui_t *ui, char *teststring, int dummy0, int col, int expectedoffset,int dummy3);

+char *test_utf8charlen(reui_t *ui, char *teststring, int dummy0, int dummy1, int offset,int charsizeatoffset);

+

+int

+main(int argc, char *argv[])

+{

+        struct reui_t dummyui;

+        struct {

+                char string[1024];

+                int nchars;

+                int col;

+                int offsetcol;

+                int charsizeatoffsetcol;

+        } teststrings[]={

+                {{"This is a latin1 string"},51-28,1,1,1},

+                {{"lowercase acute vowels:\xc3\xa1\xc3\xa9\xc3\xad\xc3\xb3\xc3\xba"},23+5,23+1,23+2,2},

+        };

+        test_ui_t tests[]={

+                {0,"utf8len",test_utf8len},

+                {0,"utf8col",test_utf8col},

+                {0,"utf8charlen",test_utf8charlen},

+        };

+        int flag_exit=0,flag_all=0;

+        reui_t *ui;

+        int i,s;

+        int nerrors,total;

+        char *res;

+        for(i=1;i<argc;i++) {

+                if(strcmp(argv[i],"--help")==0) {

+                        fprintf(stderr,"Syntax: %s [--all] [--exit] [--help]\nExplanation:\n\t--all: do even the slow tests\n\t--exit: exit program at first unsuccessful test\n\t--help: this text\n",argv[0]);

+                        return(1);

+                } else if(strcmp(argv[i],"--all")==0) {

+                        flag_all=1;

+                } else if(strcmp(argv[i],"--exit")==0) {

+                        flag_exit=1;

+                }

+        }

+        nerrors=0;

+        total=0;

+        /* flag_all is not used right now, next line is to silence the compiler */

+        total+=(flag_all&0);

+        /* end of hack */

+        memset(&dummyui,0,sizeof(reui_t));

+        for(s=0;s<(sizeof(teststrings)/sizeof(teststrings[0]));s++) {

+                fprintf(stderr,"\"%s\"\n",teststrings[s].string);

+                for(i=0;i<(sizeof(tests)/sizeof(tests[0]));i++,total++) {

+                        ui=&dummyui;

+                        if(tests[i].needs_realui && (ui=reui_init(NULL))==NULL) {

+                                fprintf(stderr,"ERROR: problem initializing ui module\n");

+                                return(1);

+                        }

+                        fprintf(stderr,"%i:%s...",total+1,tests[i].name);

+                        res=tests[i].fn(ui,teststrings[s].string,teststrings[s].nchars,teststrings[s].col,teststrings[s].offsetcol,teststrings[s].charsizeatoffsetcol);

+                                if(strcmp(res,TEST_OK)==0) {

+                                fprintf(stderr," ok.\n");

+                        } else {

+                                fprintf(stderr," ERROR: %s <= %s(\"%s\",%i,%i,%i,%i)\n",res,tests[i].name,teststrings[s].string,teststrings[s].nchars,teststrings[s].col,teststrings[s].offsetcol,teststrings[s].charsizeatoffsetcol);

+                                nerrors++;

+                                if(flag_exit) {

+                                        /* exit on first error */

+                                        s=sizeof(teststrings)/sizeof(teststrings[0]);

+                                        break;

+                                }

+                        }

+                        if(tests[i].needs_realui)

+                                reui_free(ui),ui=NULL;

+                }

+        }

+        fprintf(stderr,"\n");

+        if(nerrors==0)

+                fprintf(stderr,"All %i tests passed OK\n",total);

+        else

+                fprintf(stderr,"%i test(s) failed of %i tests run.\n",nerrors,total);

+        if(ui!=NULL && ui!=&dummyui)

+                reui_free(ui),ui=NULL;

+        return((nerrors==0)?0:1);

+}

+

+char *

+test_utf8len(reui_t *ui, char *teststring, int expectednchars, int dummy1, int dummy2, int dummy3)

+{

+        int res;

+        static char errorstr[1024];

+        res=reui_utf8len(ui,teststring,strlen(teststring));

+        if(res!=expectednchars) {

+                snprintf(errorstr,sizeof(errorstr),"expected %i chars, got %i chars",expectednchars,res);

+                errorstr[sizeof(errorstr)-1]='\0';

+                return(errorstr);

+        }

+        return(TEST_OK);

+}

+

+char *test_utf8col(reui_t *ui, char *teststring, int dummy0, int col, int expectedoffset, int dummy3)

+{

+        char *ptr;

+        static char errorstr[1024];

+        ptr=reui_utf8col(ui,teststring,strlen(teststring),col);

+        if(ptr!=(teststring+expectedoffset)) {

+                snprintf(errorstr,sizeof(errorstr),"expected offset %i, got offset %i (\"%s\")",expectedoffset,(int) ((ptr==NULL)?-1:ptr-teststring),ptr);

+                errorstr[sizeof(errorstr)-1]='\0';

+                return(errorstr);

+        }

+        return(TEST_OK);

+}

+

+char *

+test_utf8charlen(reui_t *ui, char *teststring, int dummy0, int dummy1, int offset,int charsizeatoffset)

+{

+        int res;

+        static char errorstr[1024];

+        res=reui_utf8charlen(ui,teststring+offset,strlen(teststring+offset));

+        if(res!=(charsizeatoffset)) {

+                snprintf(errorstr,sizeof(errorstr),"expected char size %i, got char size %i (\"%s\")",charsizeatoffset,res,teststring+offset);

+                errorstr[sizeof(errorstr)-1]='\0';

+                return(errorstr);

+        }

+        return(TEST_OK);

+}

+

+

@@ -198,21 +198,58 @@ reui_printf(reui_t *ui, int x, int y, char *rgba, char *format, ...)

 int

 reui_utf8len(reui_t *ui, char *ptr, int size)

 {

+        int len,i;

         /* calculate the number of utf8-charaters in buffer */

         if(ui==NULL || size<0 || (ptr==NULL && size!=0))

                 return(-1);

-#warning TODO

-        return(size);

-#warning Also consider tabs

+        /* for now we only count the number of code points */

+        /* in UTF8: 0x00-0x7f single byte chars

+         *          0xc0-0xff leading bytes

+         *          0x80-0xbf continuation bytes (ignore these for len)*/

+/*#warning TODO: XXX support combining code points (at least U+0300 - U+036F ( https://en.wikipedia.org/wiki/Combining_character ) */

+        for(len=0,i=0;i<size;i++)

+                len+=((ptr[i]&0xc0)!=0x80)?1:0;

+        return(len);

+/*#warning TODO: XXX Also consider tabs*/

 }

 char *

 reui_utf8col(reui_t *ui, char *ptr, int size, int col)

 {

+        int len,i;

         /* return a pointer to the "n"th ("col"th) utf8-character in buffer */

-#warning TODO

-        if(col<size)

-                return(ptr+col);

-        return(NULL);

-#warning Also consider tabs

+        if(ui==NULL || size<0 || (ptr==NULL && size!=0))

+                return(NULL); /* sanity check failed */

+        /* see reui_utf8len() for explanation of algorithm */

+/*#warning TODO: support combining code points (at least U+0300 - U+036F ( https://en.wikipedia.org/wiki/Combining_character ) */

+        if(col>=size)

+                return(NULL);/* col greater than maximum possible char. count */

+        /* skip "col" amount of single byte chars and leading bytes */

+        for(len=0,i=0;len<col && i<size;i++)

+                len+=((ptr[i]&0xc0)!=0x80)?1:0;

+        /* if we landed in a continuation byte, advance until next single byte chars or leading byte */

+        while(i<size && (ptr[i]&0xc0)==0x80)

+                i++;

+        if(i>=size)

+                return(NULL); /* col is beyond end of string */

+        return(ptr+i);

+/*#warning TODO: XXX Also consider tabs*/

+}

+

+int

+reui_utf8charlen(reui_t *ui, char *ptr, int maxsize)

+{

+        int i;

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

+        if(ui==NULL || ptr==NULL || maxsize<1)

+                return(0); /* sanity check failed */

+/*#warning TODO: support combining code points (at least U+0300 - U+036F ( https://en.wikipedia.org/wiki/Combining_character ) */

+        if(((unsigned char *)ptr)[0]<0x80)

+                return(1); /* single byte char */

+        if((ptr[0]&0xc0)==0x80)

+                return(0); /* error: this is continuation, not leading byte */

+        for(i=1;i<maxsize && (ptr[i]&0xc0)==0x80;i++)

+                ;

+        return(i);

 }

+

@@ -51,3 +51,6 @@ int reui_utf8len(reui_t *ui, char *ptr, int size);

 /* return a pointer to the "n"th ("col"th) utf8-character in buffer */

 char *reui_utf8col(reui_t *ui, char *ptr, int size, int col);

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

+int reui_utf8charlen(reui_t *ui, char *ptr, int maxsize);

+

@@ -27,6 +27,7 @@ typedef struct re_t {

         long cursorpos;

         int lastcol,lastrow;

         int maxrow,maxcol;

+        int contentsdirty;

 } re_t;

 volatile int flag_sigint;

@@ -43,6 +44,7 @@ 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_drawheader(re_t *re);

 int re_drawcontents(re_t *re);

@@ -98,11 +100,12 @@ 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;

-        reui_fill(re->ui,0,0,re->ui->w,re->ui->fontheight,"\x00\x00\xff\xff");

-        reui_printf(re->ui,0,0,"\xff\xff\x00\xff","Fichero: %s",re->filename);

+        re_drawheader(re);

         re_drawcontents(re);

         flag_had_events=0;

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

+                if(re->contentsdirty)

+                        re_drawcontents(re);

                 if(re->ui->rendererdirty)

                         reui_present(re->ui);

                 sselect_wait(ssel,(flag_had_events)?10:100);

@@ -207,8 +210,10 @@ re_processkey(re_t *re, SDL_Event *event)

         int len;

         int has_nl;

         int oldcol;

+        int linecols;

+        int inc;

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

-                return(-1);

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

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

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

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

@@ -227,12 +232,44 @@ re_processkey(re_t *re, SDL_Event *event)

                         re->lastrow++;

                 else if(event->key.keysym.sym==SDLK_UP && re->lastrow>0)

                         re->lastrow--;

-                re_drawcontents(re);

+                re_drawheader(re);

+                re->contentsdirty=1;

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

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

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

+                if(event->key.keysym.sym==SDLK_LEFT && re->cursorpos==0)

+                        return(-1); /* going left but already at leftmost char */

+                linecols=reui_utf8len(re->ui,ptr,len);

+                oldcol=reui_utf8len(re->ui,ptr,re->cursorpos-newpos);

+                inc=(event->key.keysym.sym==SDLK_LEFT)?-1:1;

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

+                if(re->lastcol<=linecols) {

+                        ptr2=reui_utf8col(re->ui,ptr,len,re->lastcol+inc);

+                } else

+                        ptr2=NULL;

+                if(ptr2!=NULL)

+                        re->cursorpos=newpos+(ptr2-ptr);

+                else

+                        re->cursorpos=newpos+(len-has_nl); /* we're past the last col, set cursor to last pos in line */

+                if((re->lastcol+inc)>=0)

+                        re->lastcol+=inc;

+                re_drawheader(re);

+                re->contentsdirty=1;

         }

         return(-1);

 }

+int

+re_drawheader(re_t *re)

+{

+        if(re==NULL)

+                return(-1);

+        reui_fill(re->ui,0,0,re->ui->w,re->ui->fontheight,"\x00\x00\xff\xff");

+        reui_printf(re->ui,0,0,"\xff\xff\x00\xff","Fichero: %s Col:%i Row:%i Pos:%li",re->filename,re->lastcol,re->lastrow,re->cursorpos);

+        return(0);

+}

+

 int

 re_drawcontents(re_t *re)

 {

@@ -240,8 +277,11 @@ re_drawcontents(re_t *re)

         char *ptr;

         int len;

         int y,row;

-        char c;

+        char *curptr;

+        int curptrlen;

         int has_nl;

+        if(re==NULL)

+                return(-1);

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

         row=re->lastrow;

         pos=re->cursorpos;

@@ -260,14 +300,17 @@ re_drawcontents(re_t *re)

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

                 reui_write(re->ui,re->x,y,"\x00\x00\x00\xff",(char *)ptr,len-has_nl);

                 if(row==re->lastrow) {

+     #warning DEBUG write of current char

                         reui_fill(re->ui,re->x+re->ui->fontwidth*re->lastcol,y,re->ui->fontwidth,re->ui->fontheight+1,"\x00\x00\x00\xff");

-#warning TODO: consider multibytes characters and tabs to position on the corect character and to pass the correct number of bytes to reui_write

-                        c=(re->lastcol>=(len-has_nl))?' ':ptr[re->lastcol];

-                        reui_write(re->ui,re->x+re->ui->fontwidth*re->lastcol,y,"\xff\xff\xff\xff",&c,1);

+#warning TODO: consider tabs

+                        curptr=reui_utf8col(re->ui,ptr,len-has_nl,re->lastcol);

+                        curptrlen=(curptr==NULL)?0:(len-has_nl)-(curptr-ptr);

+                        reui_write(re->ui,re->x+re->ui->fontwidth*re->lastcol,y,"\xff\xff\xff\xff",curptr,reui_utf8charlen(re->ui,ptr,curptrlen));

 #warning TODO: if it is one of  '[','{','<','>','}',']', highlight the matching bracket/parens/anglebracket.

                 }

                 pos=newpos+len;

         }

+        re->contentsdirty=0;

         re->ui->rendererdirty=1;

         return(0);

 }

new file mode 100755

Binary files /dev/null and b/tests_ui differ