ref: 196da4ec6f429683a351312d1f0bcb05847e7f89
dir: /sys/src/cmd/mothra/libpanel/textwin.c/
/* * Text windows * void twhilite(Textwin *t, int sel0, int sel1, int on) * hilite (on=1) or unhilite (on=0) a range of characters * void twselect(Textwin *t, Mouse *m) * set t->sel0, t->sel1 from mouse input. * Also hilites selection. * Caller should first unhilite previous selection. * void twreplace(Textwin *t, int r0, int r1, Rune *ins, int nins) * Replace the given range of characters with the given insertion. * Caller should unhilite selection while this is called. * void twscroll(Textwin *t, int top) * Character with index top moves to the top line of the screen. * int twpt2rune(Textwin *t, Point p) * which character is displayed at point p? * void twreshape(Textwin *t, Rectangle r) * save r and redraw the text * Textwin *twnew(Bitmap *b, Font *f, Rune *text, int ntext) * create a new text window * void twfree(Textwin *t) * get rid of a surplus Textwin */ #include <u.h> #include <libc.h> #include <draw.h> #include <event.h> #include <panel.h> #include "pldefs.h" #define SLACK 100 /* * Is text at point a before or after that at point b? */ int tw_before(Textwin *t, Point a, Point b){ return a.y<b.y || a.y<b.y+t->hgt && a.x<b.x; } /* * Return the character index indicated by point p, or -1 * if its off-screen. The screen must be up-to-date. * * Linear search should be binary search. */ int twpt2rune(Textwin *t, Point p){ Point *el, *lp; el=t->loc+(t->bot-t->top); for(lp=t->loc;lp!=el;lp++) if(tw_before(t, p, *lp)){ if(lp==t->loc) return t->top; return lp-t->loc+t->top-1; } return t->bot; } /* * Return ul corner of the character with the given index */ Point tw_rune2pt(Textwin *t, int i){ if(i<t->top) return t->r.min; if(i>t->bot) return t->r.max; return t->loc[i-t->top]; } /* * Store p at t->loc[l], extending t->loc if necessary */ void tw_storeloc(Textwin *t, int l, Point p){ int nloc; if(l>=t->eloc-t->loc){ nloc=l+SLACK; t->loc=pl_erealloc(t->loc, nloc*sizeof(Point)); t->eloc=t->loc+nloc; } t->loc[l]=p; } /* * Set the locations at which the given runes should appear. * Returns the index of the first rune not set, which might not * be last because we reached the bottom of the window. * * N.B. this zaps the loc of r[last], so that value should be saved first, * if it's important. */ int tw_setloc(Textwin *t, int first, int last, Point ul){ Rune *r, *er; int x, dt, lp; char buf[UTFmax+1]; er=t->text+last; for(r=t->text+first,lp=first-t->top;r!=er && ul.y+t->hgt<=t->r.max.y;r++,lp++){ tw_storeloc(t, lp, ul); switch(*r){ case '\n': ul.x=t->r.min.x; ul.y+=t->hgt; break; case '\t': x=ul.x-t->r.min.x+t->mintab+t->tabstop; x-=x%t->tabstop; ul.x=x+t->r.min.x; if(ul.x>t->r.max.x){ ul.x=t->r.min.x; ul.y+=t->hgt; tw_storeloc(t, lp, ul); if(ul.y+t->hgt>t->r.max.y) return r-t->text; ul.x+=+t->tabstop; } break; default: buf[runetochar(buf, r)]='\0'; dt=stringwidth(t->font, buf); ul.x+=dt; if(ul.x>t->r.max.x){ ul.x=t->r.min.x; ul.y+=t->hgt; tw_storeloc(t, lp, ul); if(ul.y+t->hgt>t->r.max.y) return r-t->text; ul.x+=dt; } break; } } tw_storeloc(t, lp, ul); return r-t->text; } /* * Draw the given runes at their locations. * Bug -- saving up multiple characters would * reduce the number of calls to string, * and probably make this a lot faster. */ void tw_draw(Textwin *t, int first, int last){ Rune *r, *er; Point *lp, ul, ur; char buf[UTFmax+1]; if(first<t->top) first=t->top; if(last>t->bot) last=t->bot; if(last<=first) return; er=t->text+last; for(r=t->text+first,lp=t->loc+(first-t->top);r!=er;r++,lp++){ if(lp->y+t->hgt>t->r.max.y){ fprint(2, "chr %C, index %ld of %d, loc %d %d, off bottom\n", *r, lp-t->loc, t->bot-t->top, lp->x, lp->y); return; } switch(*r){ case '\n': ur=*lp; break; case '\t': ur=*lp; if(lp[1].y!=lp[0].y) ul=Pt(t->r.min.x, lp[1].y); else ul=*lp; pl_clr(t->b, Rpt(ul, Pt(lp[1].x, ul.y+t->hgt))); break; default: buf[runetochar(buf, r)]='\0'; /***/ pl_clr(t->b, Rpt(*lp, addpt(*lp, stringsize(t->font, buf)))); ur=string(t->b, *lp, display->black, ZP, t->font, buf); break; } if(lp[1].y!=lp[0].y) /***/ pl_clr(t->b, Rpt(ur, Pt(t->r.max.x, ur.y+t->hgt))); } } /* * Hilight the characters with tops between ul and ur */ void tw_hilitep(Textwin *t, Point ul, Point ur){ Point swap; int y; if(tw_before(t, ur, ul)){ swap=ul; ul=ur; ur=swap;} y=ul.y+t->hgt; if(y>t->r.max.y) y=t->r.max.y; if(ul.y==ur.y) pl_highlight(t->b, Rpt(ul, Pt(ur.x, y))); else{ pl_highlight(t->b, Rpt(ul, Pt(t->r.max.x, y))); ul=Pt(t->r.min.x, y); pl_highlight(t->b, Rpt(ul, Pt(t->r.max.x, ur.y))); ul=Pt(t->r.min.x, ur.y); y=ur.y+t->hgt; if(y>t->r.max.y) y=t->r.max.y; pl_highlight(t->b, Rpt(ul, Pt(ur.x, y))); } } /* * Hilite/unhilite the given range of characters */ void twhilite(Textwin *t, int sel0, int sel1, int on){ Point ul, ur; int swap, y; if(sel1<sel0){ swap=sel0; sel0=sel1; sel1=swap; } if(sel1<t->top || t->bot<sel0) return; if(sel0<t->top) sel0=t->top; if(sel1>t->bot) sel1=t->bot; if(!on){ if(sel1==sel0){ ul=t->loc[sel0-t->top]; y=ul.y+t->hgt; if(y>t->r.max.y) y=t->r.max.y; pl_clr(t->b, Rpt(ul, Pt(ul.x+1, y))); }else tw_draw(t, sel0, sel1); return; } ul=t->loc[sel0-t->top]; if(sel1==sel0) ur=addpt(ul, Pt(1, 0)); else ur=t->loc[sel1-t->top]; tw_hilitep(t, ul, ur); } /* * Set t->sel[01] from mouse input. * Also hilites the selection. * Caller should unhilite the previous * selection before calling this. */ void twselect(Textwin *t, Mouse *m){ int sel0, sel1, newsel; Point p0, p1, newp; sel0=sel1=twpt2rune(t, m->xy); p0=tw_rune2pt(t, sel0); p1=addpt(p0, Pt(1, 0)); twhilite(t, sel0, sel1, 1); for(;;){ if(display->bufp > display->buf) flushimage(display, 1); *m=emouse(); if((m->buttons&7)!=1) break; newsel=twpt2rune(t, m->xy); newp=tw_rune2pt(t, newsel); if(eqpt(newp, p0)) newp=addpt(newp, Pt(1, 0)); if(!eqpt(newp, p1)){ if((sel0<=sel1 && sel1<newsel) || (newsel<sel1 && sel1<sel0)) tw_hilitep(t, p1, newp); else if((sel0<=newsel && newsel<sel1) || (sel1<newsel && newsel<=sel0)){ twhilite(t, sel1, newsel, 0); if(newsel==sel0) tw_hilitep(t, p0, newp); }else if((newsel<sel0 && sel0<=sel1) || (sel1<sel0 && sel0<=newsel)){ twhilite(t, sel0, sel1, 0); tw_hilitep(t, p0, newp); } sel1=newsel; p1=newp; } } if(sel0<=sel1){ t->sel0=sel0; t->sel1=sel1; } else{ t->sel0=sel1; t->sel1=sel0; } } /* * Clear the area following the last displayed character */ void tw_clrend(Textwin *t){ Point ul; int y; ul=t->loc[t->bot-t->top]; y=ul.y+t->hgt; if(y>t->r.max.y) y=t->r.max.y; pl_clr(t->b, Rpt(ul, Pt(t->r.max.x, y))); ul=Pt(t->r.min.x, y); pl_clr(t->b, Rpt(ul, t->r.max)); } /* * Move part of a line of text, truncating the source or padding * the destination on the right if necessary. */ void tw_moverect(Textwin *t, Point uld, Point urd, Point uls, Point urs){ int sw, dw, d; if(urs.y!=uls.y) urs=Pt(t->r.max.x, uls.y); if(urd.y!=uld.y) urd=Pt(t->r.max.x, uld.y); sw=uls.x-urs.x; dw=uld.x-urd.x; if(dw>sw){ d=dw-sw; pl_clr(t->b, Rect(urd.x-d, urd.y, urd.x, urd.y+t->hgt)); dw=sw; } pl_cpy(t->b, uld, Rpt(uls, Pt(uls.x+dw, uls.y+t->hgt))); } /* * Move a block of characters up or to the left: * Identify contiguous runs of characters whose width doesn't change, and * move them in one bitblt per run. * If we get to a point where source and destination are x-aligned, * they will remain x-aligned for the rest of the block. * Then, if they are y-aligned, they're already in the right place. * Otherwise, we can move them in three bitblts; one if all the * remaining characters are on one line. */ void tw_moveup(Textwin *t, Point *dp, Point *sp, Point *esp){ Point uld, uls; /* upper left of destination/source */ int y; while(sp!=esp && sp->x!=dp->x){ uld=*dp; uls=*sp; while(sp!=esp && sp->y==uls.y && dp->y==uld.y && sp->x-uls.x==dp->x-uld.x){ sp++; dp++; } tw_moverect(t, uld, *dp, uls, *sp); } if(sp==esp || esp->y==dp->y) return; if(esp->y==sp->y){ /* one line only */ pl_cpy(t->b, *dp, Rpt(*sp, Pt(esp->x, sp->y+t->hgt))); return; } y=sp->y+t->hgt; pl_cpy(t->b, *dp, Rpt(*sp, Pt(t->r.max.x, y))); pl_cpy(t->b, Pt(t->r.min.x, dp->y+t->hgt), Rect(t->r.min.x, y, t->r.max.x, esp->y)); y=dp->y+esp->y-sp->y; pl_cpy(t->b, Pt(t->r.min.x, y), Rect(t->r.min.x, esp->y, esp->x, esp->y+t->hgt)); } /* * Same as above, but moving down and in reverse order, so as not to overwrite stuff * not moved yet. */ void tw_movedn(Textwin *t, Point *dp, Point *bsp, Point *esp){ Point *sp, urs, urd; int dy; dp+=esp-bsp; sp=esp; dy=dp->y-sp->y; while(sp!=bsp && dp[-1].x==sp[-1].x){ --dp; --sp; } if(dy!=0){ if(sp->y==esp->y) pl_cpy(t->b, *dp, Rect(sp->x, sp->y, esp->x, esp->y+t->hgt)); else{ pl_cpy(t->b, Pt(t->r.min.x, sp->x+dy), Rect(t->r.min.x, sp->y, esp->x, esp->y+t->hgt)); pl_cpy(t->b, Pt(t->r.min.x, dp->y+t->hgt), Rect(t->r.min.x, sp->y+t->hgt, t->r.max.x, esp->y)); pl_cpy(t->b, *dp, Rect(sp->x, sp->y, t->r.max.x, sp->y+t->hgt)); } } while(sp!=bsp){ urd=*dp; urs=*sp; while(sp!=bsp && sp[-1].y==sp[0].y && dp[-1].y==dp[0].y && sp[-1].x-sp[0].x==dp[-1].x-dp[0].x){ --sp; --dp; } tw_moverect(t, *dp, urd, *sp, urs); } } /* * Move the given range of characters, already drawn on * the given textwin, to the given location. * Start and end must both index characters that are initially on-screen. */ void tw_relocate(Textwin *t, int first, int last, Point dst){ Point *srcloc; int nbyte; if(first<t->top || last<first || t->bot<last) return; nbyte=(last-first+1)*sizeof(Point); srcloc=pl_emalloc(nbyte); memmove(srcloc, &t->loc[first-t->top], nbyte); tw_setloc(t, first, last, dst); if(tw_before(t, dst, srcloc[0])) tw_moveup(t, t->loc+first-t->top, srcloc, srcloc+(last-first)); else tw_movedn(t, t->loc+first-t->top, srcloc, srcloc+(last-first)); } /* * Replace the runes with indices from r0 to r1-1 with the text * pointed to by text, and with length ntext. * Open up a hole in t->text, t->loc. * Insert new text, calculate their locs (save the extra loc that's overwritten first) * (swap saved & overwritten locs) * move tail. * calc locs and draw new text after tail, if necessary. * draw new text, if necessary */ void twreplace(Textwin *t, int r0, int r1, Rune *ins, int nins){ int olen, nlen, tlen, dtop; olen=t->etext-t->text; nlen=olen+nins-(r1-r0); tlen=t->eslack-t->text; if(nlen>tlen){ tlen=nlen+SLACK; t->text=pl_erealloc(t->text, tlen*sizeof(Rune)); t->eslack=t->text+tlen; } if(olen!=nlen) memmove(t->text+r0+nins, t->text+r1, (olen-r1)*sizeof(Rune)); if(nins!=0) /* ins can be 0 if nins==0 */ memmove(t->text+r0, ins, nins*sizeof(Rune)); t->etext=t->text+nlen; if(r0>t->bot) /* insertion is completely below visible text */ return; if(r1<t->top){ /* insertion is completely above visible text */ dtop=nlen-olen; t->top+=dtop; t->bot+=dtop; return; } if(1 || t->bot<=r0+nins){ /* no useful text on screen below r0 */ if(r0<=t->top) /* no useful text above, either */ t->top=r0; t->bot=tw_setloc(t, r0, nlen, t->loc[r0-t->top]); tw_draw(t, r0, t->bot); tw_clrend(t); return; } /* * code for case where there is useful text below is missing (see `1 ||' above) */ } /* * This works but is stupid. */ void twscroll(Textwin *t, int top){ while(top!=0 && t->text[top-1]!='\n') --top; t->top=top; t->bot=tw_setloc(t, top, t->etext-t->text, t->r.min); tw_draw(t, t->top, t->bot); tw_clrend(t); } void twreshape(Textwin *t, Rectangle r){ t->r=r; t->bot=tw_setloc(t, t->top, t->etext-t->text, t->r.min); tw_draw(t, t->top, t->bot); tw_clrend(t); } Textwin *twnew(Image *b, Font *f, Rune *text, int ntext){ Textwin *t; t=pl_emalloc(sizeof(Textwin)); t->text=pl_emalloc((ntext+SLACK)*sizeof(Rune)); t->loc=pl_emalloc(SLACK*sizeof(Point)); t->eloc=t->loc+SLACK; t->etext=t->text+ntext; t->eslack=t->etext+SLACK; if(ntext) memmove(t->text, text, ntext*sizeof(Rune)); t->top=0; t->bot=0; t->sel0=0; t->sel1=0; t->b=b; t->font=f; t->hgt=f->height; t->mintab=stringwidth(f, "0"); t->tabstop=8*t->mintab; return t; } void twfree(Textwin *t){ free(t->loc); free(t->text); free(t); } /* * Correct the character locations in a textwin after the panel is moved. * This horrid hack would not be necessary if loc values were relative * to the panel, rather than absolute. */ void twmove(Textwin *t, Point d){ Point *lp; t->r = rectaddpt(t->r, d); for(lp=t->loc; lp<t->eloc; lp++) *lp = addpt(*lp, d); }