@@ -48,7 +48,7 @@ static int reui_fillrounded(SDL_Surface *dst, int xo, int yo, int w, int h, int

 static int reui_triangle(SDL_Surface *dst, int x, int y, int w, int h, char direction, const char *rgba);

 reui_t *

-reui_init(int fontheight)

+reui_init(int fontheight, reui_t *parent)

 {

         reui_t *ui;

         SDL_Rect screenrect;

@@ -70,10 +70,16 @@ reui_init(int fontheight)

         ui->amask=0xff000000;

 #endif

         /* video */

-        if(SDL_Init(SDL_INIT_VIDEO)<0

-          || SDL_GetDisplayBounds(0,&screenrect)!=0) {

-                reui_free(ui),ui=NULL;

-                return(NULL);

+        if(parent==NULL) {

+                if(SDL_Init(SDL_INIT_VIDEO)<0

+                  || SDL_GetDisplayBounds(0,&screenrect)!=0) {

+                        reui_free(ui),ui=NULL;

+                        return(NULL);

+                }

+        } else {

+                ui->parent=(void *)parent;

+                screenrect.w=parent->screenw;

+                screenrect.h=parent->screenh;

         }

         ui->screenw=screenrect.w;

         ui->screenh=screenrect.h;

@@ -143,7 +149,7 @@ reui_free(reui_t *ui)

                 SDL_DestroyTexture(ui->onepx),ui->onepx=NULL;

         if(ui->font!=NULL)

                 TTF_CloseFont(ui->font),ui->font=NULL;

-        if(TTF_WasInit())

+        if(ui->parent==NULL && TTF_WasInit())

                 TTF_Quit();

         if(ui->fontdata!=NULL)

                 SDL_FreeRW(ui->fontdata),ui->fontdata=NULL;

@@ -153,7 +159,8 @@ reui_free(reui_t *ui)

                 SDL_DestroyRenderer(ui->renderer),ui->renderer=NULL;

         if(ui->win!=NULL)

                 SDL_DestroyWindow(ui->win),ui->win=NULL;

-        SDL_Quit();

+        if(ui->parent==NULL)

+                SDL_Quit();

         free(ui),ui=NULL;

 }

@@ -18,6 +18,7 @@

 typedef struct reui_t {

+        void *parent;

         int screenw,screenh;

         int w,h;

         Uint32 rmask, gmask, bmask, amask;

@@ -33,7 +34,7 @@ typedef struct reui_t {

         int rendererdirty;

 } reui_t;

-reui_t *reui_init(int fontheight);

+reui_t *reui_init(int fontheight, reui_t *parent);

 void reui_free(reui_t *ui);

 int reui_title(reui_t *ui, char *titlefilename);

@@ -29,6 +29,7 @@

 #define COMMANDBUFSIZE 1024

 #define DEFAULTFONTHEIGHT 14

 #define SELECTBUFBLOCK 16384

+#define SIZEBLOCKPRINTS 32

 #define COMMAND_WARNING "(!)"

 #define COMMAND_INFO "(i)"

@@ -56,6 +57,14 @@

 #define COLOR_INFOFG "\xee\xee\x46\xff"

 #define COLOR_INFOFGLIGHT "\x84\xa4\x4c\xff"

+typedef struct print_t {

+        reui_t *ui;

+        redata_t *data;

+        int originline;

+        int origincol;

+        int dirty;

+} printout_t;

+

 typedef struct re_t {

         redata_t *data;

         reui_t *ui;

@@ -82,6 +91,9 @@ typedef struct re_t {

         question_t *question;

         int showingwarning;

         int ignorenkeys;

+        int sizeprints;

+        int usedprints;

+        printout_t *prints;

 } re_t;

 volatile int flag_sigint;

@@ -119,11 +131,13 @@ int re_sel_lincolisend(re_t *re, int line, int col);

 int re_selectbuf_resize(re_t *re,long size);

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

 int re_selectbuf_replace(re_t *re,char *newdata);

+int re_addprint(re_t *re);

+int re_delprint(re_t *re, int nprint);

 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 re_drawcontents(re_t *re, printout_t *printout);

 int

 main(int argc, char *argv[])

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

         int flag_had_events;

         time_t lastidle,now;

         int load_pending;

+        int i;

         if(argc!=2 || strcmp(argv[argc-1],"--help")==0) {

                 fprintf(stderr,"Syntax: %s filename\n",argv[0]);

                 return(1);

@@ -224,18 +239,64 @@ fprintf(stderr,"REDRAW Header (command)\n");

                         }

                 }

                 if(re->contentsdirty)

-                        re_drawcontents(re);

+                        re_drawcontents(re,NULL);

                 if(re->ui->rendererdirty) {

 #if 0

 fprintf(stderr,"RENDER\n");

 #endif

                         reui_present(re->ui);

                 }

+                for(i=0;i<re->sizeprints;i++) {

+                        if(re->prints[i].ui==NULL)

+                                continue;

+                        if(re->prints[i].dirty)

+                                re_drawcontents(re,re->prints+i);

+                        if(re->prints[i].ui->rendererdirty)

+                                reui_present(re->prints[i].ui);

+                }

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

                 flag_had_events=(flag_had_events>0)?flag_had_events-1:0;

                 SDL_PumpEvents();

                 while(SDL_PeepEvents(&event,1,SDL_GETEVENT,SDL_FIRSTEVENT,SDL_LASTEVENT)>0) {

+                        Uint32 windowID;

                         flag_had_events=10;

+                        /* Process printout events */

+                        if((event.type==SDL_WINDOWEVENT && (windowID=event.window.windowID)!=SDL_GetWindowID(re->ui->win))

+                          || (event.type==SDL_KEYDOWN && (windowID=event.key.windowID)!=SDL_GetWindowID(re->ui->win))

+                          || (event.type==SDL_TEXTEDITING && (windowID=event.edit.windowID)!=SDL_GetWindowID(re->ui->win))

+                          || (event.type==SDL_TEXTINPUT && (windowID=event.text.windowID)!=SDL_GetWindowID(re->ui->win))

+                          ) {

+                                for(i=0;i<re->sizeprints;i++) {

+                                        if(re->prints[i].ui!=NULL

+                                          && windowID==SDL_GetWindowID(re->prints[i].ui->win)) {

+                                                break;

+                                        }

+                                }

+                                if(i>=re->sizeprints)

+                                        continue; /* unknown window */

+                                switch(event.type) {

+                                        case SDL_WINDOWEVENT:

+                                                if(event.window.event==SDL_WINDOWEVENT_SHOWN

+                                                  || event.window.event==SDL_WINDOWEVENT_EXPOSED) {

+                                                        re->prints[i].dirty=1;

+                                                } else if((event.window.event==SDL_WINDOWEVENT_RESIZED

+                                                  || event.window.event==SDL_WINDOWEVENT_SIZE_CHANGED)

+                                                  && (event.window.data1!=re->prints[i].ui->w || event.window.data2!=re->prints[i].ui->h)) {

+                                                        reui_resize(re->prints[i].ui,event.window.data1,event.window.data2);

+                                                        re->prints[i].dirty=1;

+                                                } else if(event.window.event==SDL_WINDOWEVENT_CLOSE) {

+                                                        re_delprint(re,i);

+                                                }

+                                                break;

+                                        case SDL_KEYDOWN:

+                                                if(event.key.keysym.sym==SDLK_ESCAPE) {

+                                                        re_delprint(re,i);

+                                                }

+                                                break;

+                                }

+                                continue; /* only want window events from printouts */

+                        }

+                        /* process main window events */

                         switch(event.type) {

                                 case SDL_QUIT:

                                         if(redata_needs_saving(re->data)) {

@@ -370,7 +431,7 @@ re_init(void)

                 return(NULL); /* insuf. mem. */

         }

         re->fontheightpercent=100;

-        if((re->ui=reui_init(DEFAULTFONTHEIGHT*re->fontheightpercent/100))==NULL) {

+        if((re->ui=reui_init(DEFAULTFONTHEIGHT*re->fontheightpercent/100,NULL))==NULL) {

                 re_free(re),re=NULL;

                 return(NULL); /* video init error */

         }

@@ -380,8 +441,15 @@ re_init(void)

 void

 re_free(re_t *re)

 {

+        int i;

         if(re==NULL)

                 return; /* all done */

+        for(i=0;i<re->sizeprints;i++) {

+                if(re->prints[i].ui!=NULL)

+                        re_delprint(re,i);

+        }

+        if(re->prints!=NULL)

+                free(re->prints),re->prints=NULL,re->sizeprints=re->usedprints=0;

         if(re->ui!=NULL)

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

         if(re->data!=NULL)

@@ -813,6 +881,8 @@ fprintf(stderr,"SDL_KEYDOWN: BACKSPACE%s\n",(event==&fakeevent)?" (fake)":"");

                         re->contentsdirty=1;

                 }

                 re->ignorenkeys++;

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

+                re_addprint(re);

         }

         return(0);

 }

@@ -1490,6 +1560,61 @@ re_selectbuf_replace(re_t *re,char *newdata)

         return(0);

 }

+int

+re_addprint(re_t *re)

+{

+        int i;

+        long frompos,topos;

+        int coldone;

+        if(re==NULL || re->selactive==0)

+                return(-1);

+        /* ensure space for the new printout */

+        if(re->usedprints==re->sizeprints) {

+                printout_t *newprints;

+                if((newprints=realloc(re->prints,sizeof(printout_t)*(re->sizeprints+SIZEBLOCKPRINTS)))==NULL)

+                        return(-1); /* insuf. mem. */

+                re->prints=newprints;

+                memset(re->prints+re->sizeprints,0,sizeof(printout_t)*SIZEBLOCKPRINTS);

+                re->sizeprints+=SIZEBLOCKPRINTS;

+        }

+        for(i=0;i<re->sizeprints;i++) {

+                if(re->prints[i].ui==NULL)

+                        break;

+        }

+        if(i>=re->sizeprints)

+                return(-1); /* INTERNAL ERROR */

+        /* setup window */

+        if((re->prints[i].ui=reui_init(DEFAULTFONTHEIGHT*re->fontheightpercent/100,re->ui))==NULL)

+                return(-1); /* couldn't init window */

+        if((re->prints[i].data=redata_init(redata_highlighter_register,NULL))==NULL) {

+                reui_free(re->prints[i].ui),re->prints[i].ui=NULL;

+                return(-1); /* couldn't init data store */

+        }

+        re->usedprints++;

+        /* copy contents (and set clipboard contents and unselect)*/

+        if(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_op_add(re->prints[i].data,0,re->selectbuf,strlen(re->selectbuf),NULL);

+                SDL_SetClipboardText(re->selectbuf);

+                re_sel_toggle(re);

+                re->contentsdirty=1;

+        }

+        re->prints[i].dirty=1;

+        return(0);

+}

+

+int

+re_delprint(re_t *re, int nprint)

+{

+        if(re==NULL || nprint<0 || nprint>re->sizeprints || re->prints[nprint].ui==NULL)

+                return(-1);

+        reui_free(re->prints[nprint].ui),re->prints[nprint].ui=NULL;

+        if(re->prints[nprint].data!=NULL)

+                redata_free(re->prints[nprint].data),re->prints[nprint].data=NULL;

+        re->usedprints--;

+        return(0);

+}

 int

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

@@ -1663,8 +1788,14 @@ re_drawheader_command(re_t *re)

 int

-re_drawcontents(re_t *re)

+re_drawcontents(re_t *re, printout_t *printout)

 {

+        reui_t *ui;

+        redata_t *data;

+        int x0,y0,w,h;

+        int originline,origincol;

+        int curline,curcol;

+        int maxcol,maxrow;

         long pos,newpos;

         char *ptr;

         int len;

@@ -1688,42 +1819,71 @@ re_drawcontents(re_t *re)

         const char *hint;

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

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

-        if(re==NULL)

+        if(re==NULL || (printout!=NULL && (printout->ui==NULL || printout->data==NULL)))

                 return(-1);

-        if(redata_linecol2pos(re->data,re->curline,re->curcol,&cursorpos,NULL)!=0)

+        ui=re->ui;

+        data=re->data;

+        x0=re->x;

+        y0=re->y;

+        w=re->w;

+        h=re->h;

+        originline=re->originline;

+        origincol=re->origincol;

+        curline=re->curline;

+        curcol=re->curcol;

+        maxcol=re->maxcol;

+        maxrow=re->maxrow;

+        if(printout!=NULL) {

+                ui=printout->ui;

+                data=printout->data;

+                x0=0;

+                y0=0;

+                w=ui->w;

+                h=ui->h;

+                originline=curline=printout->originline;

+                origincol=curcol=printout->origincol;

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

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

+        }

+        if(redata_linecol2pos(data,curline,curcol,&cursorpos,NULL)!=0)

                 return(0); /* error obtaining position */

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

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

+        reui_fill(ui,x0,y0,w,h,"\xdf\xdf\xdf\xff");

+        row=curline-originline;

         pos=cursorpos;

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

-                if(redata_line_rawinfo(re->data,pos,&newpos,NULL,NULL,&is_continuation)==-1)

+                if(redata_line_rawinfo(data,pos,&newpos,NULL,NULL,&is_continuation)==-1)

                         return(-1);

                 pos=(newpos>0)?newpos-1:0;

                 if(!is_continuation)

                         row--;

         }

-        /* highlight current line */

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

+        /* highlight current line (in printouts, highlight alternating lines) */

+        if(printout==NULL) {

+                reui_fill(ui,x0,y0+(curline-originline)*ui->fontheight,w,ui->fontheight+1,"\xef\xef\xef\xff");

+        } else {

+                for(y=y0;y<(y0+h);y+=ui->fontheight*2)

+                        reui_fill(ui,x0,y,w,ui->fontheight+1,"\xef\xef\xef\xff");

+        }

         /* highlight the selection */

-        if(re->selactive) {

+        if(printout==NULL && re->selactive) {

                 const char *selcolor;

                 tmprow=row;

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

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

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

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

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

+                        } else if((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) {

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

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

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

+                                if(x1<(x0+w))

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

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

+                                reui_fill(ui,x0,y0+row*ui->fontheight,w,ui->fontheight+1,selcolor);

+                        } else if((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);

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

+                                if(x2>(x0))

+                                        reui_fill(ui,x0,y0+row*ui->fontheight,x2-x0,ui->fontheight+1,selcolor);

                         }

                 }

@@ -1731,23 +1891,23 @@ re_drawcontents(re_t *re)

         }

         /* draw the lines */

         drawn_cursor=0;

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

+        colors=redata_highlighter_getcolors(data,&ncolors);

         matchingpos=-1;

         matchingchar='\0';

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

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

                 /* definition of vars for tracking linecolor usage */

                 int curlinecolor; /* current linecolor */

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

                 /* end of definitions */

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

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

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

                 }

                 in_error=0;

-                linecolors=(colors==NULL)?NULL:redata_highlighter_getline(re->data,re->originline+row,&nlinecolors);

+                linecolors=(colors==NULL)?NULL:redata_highlighter_getline(data,originline+row,&nlinecolors);

                 curlinecolor=0;

                 usedlenlinecolor=0;

-                for(tmpcol=0,pos=realstart,availcol=0;tmpcol<(re->origincol+re->maxcol) && pos<=realend;pos=newpos+len,tmpcol+=availcol) {

-                        if(redata_line_rawinfo(re->data,pos,&newpos,&ptr,&len,&is_continuation)==-1) {

+                for(tmpcol=0,pos=realstart,availcol=0;tmpcol<(origincol+maxcol) && pos<=realend;pos=newpos+len,tmpcol+=availcol) {

+                        if(redata_line_rawinfo(data,pos,&newpos,&ptr,&len,&is_continuation)==-1) {

                                 in_error=1;

                                 break; /* couldn't get this line part info */

                         }

@@ -1759,7 +1919,7 @@ re_drawcontents(re_t *re)

                                 used=usedcol=0;

                                 /* while the avail text is larger than the linecolor len */

                                 while(curlinecolor<nlinecolors && (len-has_nl-used)>=(linecolors[curlinecolor].len-usedlenlinecolor)) {

-                                        reui_write(re->ui,re->x+(tmpcol-re->origincol+usedcol)*re->ui->fontwidth,y,colors[linecolors[curlinecolor].color].rgba,ptr+used,linecolors[curlinecolor].len-usedlenlinecolor);

+                                        reui_write(ui,x0+(tmpcol-origincol+usedcol)*ui->fontwidth,y,colors[linecolors[curlinecolor].color].rgba,ptr+used,linecolors[curlinecolor].len-usedlenlinecolor);

                                         usedcol+=redata_generic_utf8len(ptr+used,linecolors[curlinecolor].len-usedlenlinecolor);

                                         used+=linecolors[curlinecolor].len-usedlenlinecolor;

                                         curlinecolor++;

@@ -1767,68 +1927,75 @@ re_drawcontents(re_t *re)

                                 }

                                 /* for the last bytes of avail text, after writing them we save how many bytes we have processed of that linecolor to be able to continue later */

                                 if(curlinecolor<nlinecolors && (len-has_nl-used)>0 && (linecolors[curlinecolor].len-usedlenlinecolor)>(len-has_nl-used)) {

-                                        reui_write(re->ui,re->x+(tmpcol-re->origincol+usedcol)*re->ui->fontwidth,y,colors[linecolors[curlinecolor].color].rgba,ptr+used,(len-has_nl-used));

+                                        reui_write(ui,x0+(tmpcol-origincol+usedcol)*ui->fontwidth,y,colors[linecolors[curlinecolor].color].rgba,ptr+used,(len-has_nl-used));

                                         usedcol+=redata_generic_utf8len(ptr+used,(len-has_nl-used));

                                         usedlenlinecolor+=(len-has_nl-used);

                                         used+=(len-has_nl-used);

                                 }

                         } else {

-                                reui_write(re->ui,re->x+(tmpcol-re->origincol)*re->ui->fontwidth,y,"\x00\x00\x00\xff",ptr,len-has_nl);

+                                reui_write(ui,x0+(tmpcol-origincol)*ui->fontwidth,y,"\x00\x00\x00\xff",ptr,len-has_nl);

                         }

-                        if(row==(re->curline-re->originline)) {

-                                if(re->curcol>=tmpcol && re->curcol<(tmpcol+availcol)) {

+                        if(row==(curline-originline)) {

+                                if(curcol>=tmpcol && curcol<(tmpcol+availcol)) {

                                         int utf8charlen;

                                         /* draw cursor */

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

+                                        reui_fill(ui,x0+ui->fontwidth*(curcol-origincol),y,ui->fontwidth,ui->fontheight+1,"\x00\x00\x00\xff");

                                         drawn_cursor=1;

-                                        curptr=redata_generic_utf8col(ptr,len-has_nl,re->curcol-tmpcol);

+                                        curptr=redata_generic_utf8col(ptr,len-has_nl,curcol-tmpcol);

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

                                         utf8charlen=redata_generic_utf8charlen(curptr,curptrlen);

-                                        reui_write(re->ui,re->x+re->ui->fontwidth*(re->curcol-re->origincol),y,"\xff\xff\xff\xff",curptr,utf8charlen);

+                                        reui_write(ui,x0+ui->fontwidth*(curcol-origincol),y,"\xff\xff\xff\xff",curptr,utf8charlen);

                                         /* get matching braces/parens/anglebracket/curlybraces for highlighting */

                                         if(utf8charlen==1 && strchr("[]{}<>()",*curptr)!=NULL)

                                                 matchingpos=re_getmatchingbracket(re,cursorpos,*curptr,&matchingchar);

                                 }

                         }

                 }

-                if(row==(re->curline-re->originline) && !drawn_cursor)

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

+                if(row==(curline-originline) && !drawn_cursor)

+                        reui_fill(ui,x0+ui->fontwidth*(curcol-origincol),y,ui->fontwidth,ui->fontheight+1,"\x00\x00\x00\xff");

                 if(in_error)

                         break;

                 pos=realend+1;

-/*LONG LINE LEFT FOR DEBUGGING PURPOSES: reui_write(re->ui,re->x+re->ui->fontwidth*(re->curcol-re->origincol),y,"\xff\xff\xff\xff",curptr,redata_generic_utf8charlen(ptr,curptrlen));*/

+/*LONG LINE LEFT FOR DEBUGGING PURPOSES: reui_write(ui,x0+ui->fontwidth*(curcol-origincol),y,"\xff\xff\xff\xff",curptr,redata_generic_utf8charlen(ptr,curptrlen));*/

         }

         /* highlight matching parens/brace/... if applicable */

-        if(matchingpos!=-1 && redata_pos2linecol(re->data,matchingpos,&mline,&mcol)!=-1) {

+        if(printout==NULL && matchingpos!=-1 && redata_pos2linecol(data,matchingpos,&mline,&mcol)!=-1) {

                 int x,y;

                 char *fg="\xff\x00\x00\x80";

                 char *bg="\xff\xff\xff\xaf";

-                x=re->x+(mcol-re->origincol)*re->ui->fontwidth+(re->ui->fontwidth/2);

-                x=(x<re->x)?re->x:(x>=(re->x+re->w))?(re->x+re->w-1):x;

-                y=re->y+(mline-re->originline)*re->ui->fontheight+(re->ui->fontheight/2);

-                y=(y<re->y)?re->y:(y>=(re->y+re->h))?(re->y+re->h-1):y;

-                if(mline<re->originline)

-                        reui_balloon(re->ui, 'n', x, re->y, fg, bg, &matchingchar,1);

-                else if(mline>=(re->originline+re->maxrow))

-                        reui_balloon(re->ui, 's', x, re->y+re->h-1, fg, bg, &matchingchar,1);

-                else if(mcol<re->origincol)

-                        reui_balloon(re->ui, 'w', re->x, y, fg, bg, &matchingchar,1);

-                else if(mcol>=(re->origincol+re->maxcol))

-                        reui_balloon(re->ui, 'e', re->x+re->w-1,y, fg, bg, &matchingchar,1);

+                x=x0+(mcol-origincol)*ui->fontwidth+(ui->fontwidth/2);

+                x=(x<x0)?x0:(x>=(x0+w))?(x0+w-1):x;

+                y=y0+(mline-originline)*ui->fontheight+(ui->fontheight/2);

+                y=(y<y0)?y0:(y>=(y0+h))?(y0+h-1):y;

+                if(mline<originline)

+                        reui_balloon(ui, 'n', x, y0, fg, bg, &matchingchar,1);

+                else if(mline>=(originline+maxrow))

+                        reui_balloon(ui, 's', x, y0+h-1, fg, bg, &matchingchar,1);

+                else if(mcol<origincol)

+                        reui_balloon(ui, 'w', x0, y, fg, bg, &matchingchar,1);

+                else if(mcol>=(origincol+maxcol))

+                        reui_balloon(ui, 'e', x0+w-1,y, fg, bg, &matchingchar,1);

                 else

-                        reui_balloon(re->ui, '\0', x,y, fg, bg, &matchingchar,1);

+                        reui_balloon(ui, '\0', x,y, fg, bg, &matchingchar,1);

         }

         /* display prototypes info if applicable */

-        hint=redata_prototypes_get(re->data, cursorpos);

-        if(hint!=NULL) {

-                if((re->curline-re->originline)>=(re->maxrow/2))

-                        reui_balloon(re->ui, '\0', re->x+re->w/2, re->y+re->ui->fontheight*3/2, "\x80\x80\x80\xff", "\xff\xff\xff\xcf",(char *) hint,strlen(hint));

-                else

-                        reui_balloon(re->ui, '\0', re->x+re->w/2, re->y+re->h-re->ui->fontheight*3/2, "\x80\x80\x80\xff", "\xff\xff\xff\xcf",(char *)hint,strlen(hint));

+        if(printout==NULL) {

+                hint=redata_prototypes_get(data, cursorpos);

+                if(hint!=NULL) {

+                        if((curline-originline)>=(maxrow/2))

+                                reui_balloon(ui, '\0', x0+w/2, y0+ui->fontheight*3/2, "\x80\x80\x80\xff", "\xff\xff\xff\xcf",(char *) hint,strlen(hint));

+                        else

+                                reui_balloon(ui, '\0', x0+w/2, y0+h-ui->fontheight*3/2, "\x80\x80\x80\xff", "\xff\xff\xff\xcf",(char *)hint,strlen(hint));

+                }

         }

         /* all done */

-        re->contentsdirty=0;

-        re->ui->rendererdirty=1;

+        if(printout==NULL) {

+                re->contentsdirty=0;

+                ui->rendererdirty=1;

+        } else {

+                printout->dirty=0;

+                printout->ui->rendererdirty=1;

+        }

         return(0);

 }