sys/src/cmd/samterm/flayer.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <thread.h>
   5 #include <mouse.h>
   6 #include <keyboard.h>
   7 #include <frame.h>
   8 #include "flayer.h"
   9 #include "samterm.h"
  10
  11 #define DELTA   10
  12
  13 static Flayer   **llist;        /* front to back */
  14 static int      nllist;
  15 static int      nlalloc;
  16 static Rectangle lDrect;
  17
  18 Vis             visibility(Flayer *);
  19 void            newvisibilities(int);
  20 void            llinsert(Flayer*);
  21 void            lldelete(Flayer*);
  22
  23 Image   *maincols[NCOL];
  24 Image   *cmdcols[NCOL];
  25
  26 void
  27 flstart(Rectangle r)
  28 {
  29         lDrect = r;
  30
  31         /* Main text is yellowish */
  32         maincols[BACK] = allocimagemix(display, DPaleyellow, DWhite);
  33         maincols[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DDarkyellow);
  34         maincols[BORD] = allocimage(display, Rect(0,0,2,2), screen->chan, 1, DYellowgreen);
  35         maincols[TEXT] = display->black;
  36         maincols[HTEXT] = display->black;
  37
  38         /* Command text is blueish */
  39         cmdcols[BACK] = allocimagemix(display, DPalebluegreen, DWhite);
  40         cmdcols[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DPalegreygreen);
  41         cmdcols[BORD] = allocimage(display, Rect(0,0,2,2), screen->chan, 1, DPurpleblue);
  42         cmdcols[TEXT] = display->black;
  43         cmdcols[HTEXT] = display->black;
  44 }
  45
  46 void
  47 flnew(Flayer *l, Rune *(*fn)(Flayer*, long, ulong*), int u0, void *u1)
  48 {
  49         if(nllist == nlalloc){
  50                 nlalloc += DELTA;
  51                 llist = realloc(llist, nlalloc*sizeof(Flayer**));
  52                 if(llist == 0)
  53                         panic("flnew");
  54         }
  55         l->textfn = fn;
  56         l->user0 = u0;
  57         l->user1 = u1;
  58         l->lastsr = ZR;
  59         llinsert(l);
  60 }
  61
  62 Rectangle
  63 flrect(Flayer *l, Rectangle r)
  64 {
  65         rectclip(&r, lDrect);
  66         l->entire = r;
  67         l->scroll = insetrect(r, FLMARGIN);
  68         r.min.x =
  69          l->scroll.max.x = r.min.x+FLMARGIN+FLSCROLLWID+(FLGAP-FLMARGIN);
  70         return r;
  71 }
  72
  73 void
  74 flinit(Flayer *l, Rectangle r, Font *ft, Image **cols)
  75 {
  76         lldelete(l);
  77         llinsert(l);
  78         l->visible = All;
  79         l->origin = l->p0 = l->p1 = 0;
  80         frinit(&l->f, insetrect(flrect(l, r), FLMARGIN), ft, screen, cols);
  81         l->f.maxtab = maxtab*stringwidth(ft, "0");
  82         newvisibilities(1);
  83         draw(screen, l->entire, l->f.cols[BACK], nil, ZP);
  84         scrdraw(l, 0L);
  85         flborder(l, 0);
  86 }
  87
  88 void
  89 flclose(Flayer *l)
  90 {
  91         if(l->visible == All)
  92                 draw(screen, l->entire, display->white, nil, ZP);
  93         else if(l->visible == Some){
  94                 if(l->f.b == 0)
  95                         l->f.b = allocimage(display, l->entire, screen->chan, 0, DNofill);
  96                 if(l->f.b){
  97                         draw(l->f.b, l->entire, display->white, nil, ZP);
  98                         flrefresh(l, l->entire, 0);
  99                 }
 100         }
 101         frclear(&l->f, 1);
 102         lldelete(l);
 103         if(l->f.b && l->visible!=All)
 104                 freeimage(l->f.b);
 105         l->textfn = 0;
 106         newvisibilities(1);
 107 }
 108
 109 void
 110 flborder(Flayer *l, int wide)
 111 {
 112         if(flprepare(l)){
 113                 border(l->f.b, l->entire, FLMARGIN, l->f.cols[BACK], ZP);
 114                 border(l->f.b, l->entire, wide? FLMARGIN : 1, l->f.cols[BORD], ZP);
 115                 if(l->visible==Some)
 116                         flrefresh(l, l->entire, 0);
 117         }
 118 }
 119
 120 Flayer *
 121 flwhich(Point p)
 122 {
 123         int i;
 124
 125         if(p.x==0 && p.y==0)
 126                 return nllist? llist[0] : 0;
 127         for(i=0; i<nllist; i++)
 128                 if(ptinrect(p, llist[i]->entire))
 129                         return llist[i];
 130         return 0;
 131 }
 132
 133 void
 134 flupfront(Flayer *l)
 135 {
 136         int v = l->visible;
 137
 138         lldelete(l);
 139         llinsert(l);
 140         if(v!=All)
 141                 newvisibilities(0);
 142 }
 143
 144 void
 145 newvisibilities(int redraw)
 146         /* if redraw false, we know it's a flupfront, and needn't
 147          * redraw anyone becoming partially covered */
 148 {
 149         int i;
 150         Vis ov;
 151         Flayer *l;
 152
 153         for(i = 0; i<nllist; i++){
 154                 l = llist[i];
 155                 l->lastsr = ZR; /* make sure scroll bar gets redrawn */
 156                 ov = l->visible;
 157                 l->visible = visibility(l);
 158 #define V(a, b) (((a)<<2)|((b)))
 159                 switch(V(ov, l->visible)){
 160                 case V(Some, None):
 161                         if(l->f.b)
 162                                 freeimage(l->f.b);
 163                 case V(All, None):
 164                 case V(All, Some):
 165                         l->f.b = 0;
 166                         frclear(&l->f, 0);
 167                         break;
 168
 169                 case V(Some, Some):
 170                         if(l->f.b==0 && redraw)
 171                 case V(None, Some):
 172                                 flprepare(l);
 173                         if(l->f.b && redraw){
 174                                 flrefresh(l, l->entire, 0);
 175                                 freeimage(l->f.b);
 176                                 l->f.b = 0;
 177                                 frclear(&l->f, 0);
 178                         }
 179                 case V(None, None):
 180                 case V(All, All):
 181                         break;
 182
 183                 case V(Some, All):
 184                         if(l->f.b){
 185                                 draw(screen, l->entire, l->f.b, nil, l->entire.min);
 186                                 freeimage(l->f.b);
 187                                 l->f.b = screen;
 188                                 break;
 189                         }
 190                 case V(None, All):
 191                         flprepare(l);
 192                         break;
 193                 }
 194                 if(ov==None && l->visible!=None)
 195                         flnewlyvisible(l);
 196         }
 197 }
 198
 199 void
 200 llinsert(Flayer *l)
 201 {
 202         int i;
 203         for(i=nllist; i>0; --i)
 204                 llist[i]=llist[i-1];
 205         llist[0]=l;
 206         nllist++;
 207 }
 208
 209 void
 210 lldelete(Flayer *l)
 211 {
 212         int i;
 213
 214         for(i=0; i<nllist; i++)
 215                 if(llist[i]==l){
 216                         --nllist;
 217                         for(; i<nllist; i++)
 218                                 llist[i] = llist[i+1];
 219                         return;
 220                 }
 221         panic("lldelete");
 222 }
 223
 224 void
 225 flinsert(Flayer *l, Rune *sp, Rune *ep, long p0)
 226 {
 227         if(flprepare(l)){
 228                 frinsert(&l->f, sp, ep, p0-l->origin);
 229                 scrdraw(l, scrtotal(l));
 230                 if(l->visible==Some)
 231                         flrefresh(l, l->entire, 0);
 232         }
 233 }
 234
 235 void
 236 fldelete(Flayer *l, long p0, long p1)
 237 {
 238         if(flprepare(l)){
 239                 p0 -= l->origin;
 240                 if(p0 < 0)
 241                         p0 = 0;
 242                 p1 -= l->origin;
 243                 if(p1<0)
 244                         p1 = 0;
 245                 frdelete(&l->f, p0, p1);
 246                 scrdraw(l, scrtotal(l));
 247                 if(l->visible==Some)
 248                         flrefresh(l, l->entire, 0);
 249         }
 250 }
 251
 252 int
 253 flselect(Flayer *l)
 254 {
 255         if(l->visible!=All)
 256                 flupfront(l);
 257         if(l->f.p0==l->f.p1)
 258                 if(mousep->msec-l->click<Clicktime && l->f.p0+l->origin==l->p0 &&
 259                         l->f.p0==frcharofpt(&l->f, mousep->xy)){
 260                         l->click = 0;
 261                         return 1;
 262                 }
 263         l->click = mousep->msec;
 264         frselect(&l->f, mousectl);
 265         l->p0 = l->f.p0+l->origin, l->p1 = l->f.p1+l->origin;
 266         return 0;
 267 }
 268
 269 void
 270 flsetselect(Flayer *l, long p0, long p1)
 271 {
 272         ulong fp0, fp1;
 273
 274         l->click = 0;
 275         if(l->visible==None || !flprepare(l)){
 276                 l->p0 = p0, l->p1 = p1;
 277                 return;
 278         }
 279         l->p0 = p0, l->p1 = p1;
 280         flfp0p1(l, &fp0, &fp1);
 281         if(fp0==l->f.p0 && fp1==l->f.p1)
 282                 return;
 283
 284         if(fp1<=l->f.p0 || fp0>=l->f.p1 || l->f.p0==l->f.p1 || fp0==fp1){
 285                 /* no overlap or trivial repainting */
 286                 frdrawsel(&l->f, frptofchar(&l->f, l->f.p0), l->f.p0, l->f.p1, 0);
 287                 frdrawsel(&l->f, frptofchar(&l->f, fp0), fp0, fp1, 1);
 288                 goto Refresh;
 289         }
 290         /* the current selection and the desired selection overlap and are both non-empty */
 291         if(fp0 < l->f.p0){
 292                 /* extend selection backwards */
 293                 frdrawsel(&l->f, frptofchar(&l->f, fp0), fp0, l->f.p0, 1);
 294         }else if(fp0 > l->f.p0){
 295                 /* trim first part of selection */
 296                 frdrawsel(&l->f, frptofchar(&l->f, l->f.p0), l->f.p0, fp0, 0);
 297         }
 298         if(fp1 > l->f.p1){
 299                 /* extend selection forwards */
 300                 frdrawsel(&l->f, frptofchar(&l->f, l->f.p1), l->f.p1, fp1, 1);
 301         }else if(fp1 < l->f.p1){
 302                 /* trim last part of selection */
 303                 frdrawsel(&l->f, frptofchar(&l->f, fp1), fp1, l->f.p1, 0);
 304         }
 305
 306     Refresh:
 307         l->f.p0 = fp0;
 308         l->f.p1 = fp1;
 309         if(l->visible==Some)
 310                 flrefresh(l, l->entire, 0);
 311 }
 312
 313 void
 314 flfp0p1(Flayer *l, ulong *pp0, ulong *pp1)
 315 {
 316         long p0 = l->p0-l->origin, p1 = l->p1-l->origin;
 317
 318         if(p0 < 0)
 319                 p0 = 0;
 320         if(p1 < 0)
 321                 p1 = 0;
 322         if(p0 > l->f.nchars)
 323                 p0 = l->f.nchars;
 324         if(p1 > l->f.nchars)
 325                 p1 = l->f.nchars;
 326         *pp0 = p0;
 327         *pp1 = p1;
 328 }
 329
 330 Rectangle
 331 rscale(Rectangle r, Point old, Point new)
 332 {
 333         r.min.x = r.min.x*new.x/old.x;
 334         r.min.y = r.min.y*new.y/old.y;
 335         r.max.x = r.max.x*new.x/old.x;
 336         r.max.y = r.max.y*new.y/old.y;
 337         return r;
 338 }
 339
 340 void
 341 flresize(Rectangle dr)
 342 {
 343         int i;
 344         Flayer *l;
 345         Frame *f;
 346         Rectangle r, olDrect;
 347         int move;
 348
 349         olDrect = lDrect;
 350         lDrect = dr;
 351         move = 0;
 352         /* no moving on rio; must repaint */
 353         if(0 && Dx(dr)==Dx(olDrect) && Dy(dr)==Dy(olDrect))
 354                 move = 1;
 355         else
 356                 draw(screen, lDrect, display->white, nil, ZP);
 357         for(i=0; i<nllist; i++){
 358                 l = llist[i];
 359                 l->lastsr = ZR;
 360                 f = &l->f;
 361                 if(move)
 362                         r = rectaddpt(rectsubpt(l->entire, olDrect.min), dr.min);
 363                 else{
 364                         r = rectaddpt(rscale(rectsubpt(l->entire, olDrect.min),
 365                                 subpt(olDrect.max, olDrect.min),
 366                                 subpt(dr.max, dr.min)), dr.min);
 367                         if(l->visible==Some && f->b){
 368                                 freeimage(f->b);
 369                                 frclear(f, 0);
 370                         }
 371                         f->b = 0;
 372                         if(l->visible!=None)
 373                                 frclear(f, 0);
 374                 }
 375                 if(!rectclip(&r, dr))
 376                         panic("flresize");
 377                 if(r.max.x-r.min.x<100)
 378                         r.min.x = dr.min.x;
 379                 if(r.max.x-r.min.x<100)
 380                         r.max.x = dr.max.x;
 381                 if(r.max.y-r.min.y<2*FLMARGIN+f->font->height)
 382                         r.min.y = dr.min.y;
 383                 if(r.max.y-r.min.y<2*FLMARGIN+f->font->height)
 384                         r.max.y = dr.max.y;
 385                 if(!move)
 386                         l->visible = None;
 387                 frsetrects(f, insetrect(flrect(l, r), FLMARGIN), f->b);
 388                 if(!move && f->b)
 389                         scrdraw(l, scrtotal(l));
 390         }
 391         newvisibilities(1);
 392 }
 393
 394 int
 395 flprepare(Flayer *l)
 396 {
 397         Frame *f;
 398         ulong n;
 399         Rune *r;
 400
 401         if(l->visible == None)
 402                 return 0;
 403         f = &l->f;
 404         if(f->b == 0){
 405                 if(l->visible == All)
 406                         f->b = screen;
 407                 else if((f->b = allocimage(display, l->entire, screen->chan, 0, 0))==0)
 408                         return 0;
 409                 draw(f->b, l->entire, f->cols[BACK], nil, ZP);
 410                 border(f->b, l->entire, l==llist[0]? FLMARGIN : 1, f->cols[BORD], ZP);
 411                 n = f->nchars;
 412                 frinit(f, f->entire, f->font, f->b, 0);
 413                 f->maxtab = maxtab*stringwidth(f->font, "0");
 414                 r = (*l->textfn)(l, n, &n);
 415                 frinsert(f, r, r+n, (ulong)0);
 416                 frdrawsel(f, frptofchar(f, f->p0), f->p0, f->p1, 0);
 417                 flfp0p1(l, &f->p0, &f->p1);
 418                 frdrawsel(f, frptofchar(f, f->p0), f->p0, f->p1, 1);
 419                 l->lastsr = ZR;
 420                 scrdraw(l, scrtotal(l));
 421         }
 422         return 1;
 423 }
 424
 425 static  int     somevis, someinvis, justvis;
 426
 427 Vis
 428 visibility(Flayer *l)
 429 {
 430         somevis = someinvis = 0;
 431         justvis = 1;
 432         flrefresh(l, l->entire, 0);
 433         justvis = 0;
 434         if(somevis==0)
 435                 return None;
 436         if(someinvis==0)
 437                 return All;
 438         return Some;
 439 }
 440
 441 void
 442 flrefresh(Flayer *l, Rectangle r, int i)
 443 {
 444         Flayer *t;
 445         Rectangle s;
 446
 447     Top:
 448         if((t=llist[i++]) == l){
 449                 if(!justvis)
 450                         draw(screen, r, l->f.b, nil, r.min);
 451                 somevis = 1;
 452         }else{
 453                 if(!rectXrect(t->entire, r))
 454                         goto Top;       /* avoid stacking unnecessarily */
 455                 if(t->entire.min.x>r.min.x){
 456                         s = r;
 457                         s.max.x = t->entire.min.x;
 458                         flrefresh(l, s, i);
 459                         r.min.x = t->entire.min.x;
 460                 }
 461                 if(t->entire.min.y>r.min.y){
 462                         s = r;
 463                         s.max.y = t->entire.min.y;
 464                         flrefresh(l, s, i);
 465                         r.min.y = t->entire.min.y;
 466                 }
 467                 if(t->entire.max.x<r.max.x){
 468                         s = r;
 469                         s.min.x = t->entire.max.x;
 470                         flrefresh(l, s, i);
 471                         r.max.x = t->entire.max.x;
 472                 }
 473                 if(t->entire.max.y<r.max.y){
 474                         s = r;
 475                         s.min.y = t->entire.max.y;
 476                         flrefresh(l, s, i);
 477                         r.max.y = t->entire.max.y;
 478                 }
 479                 /* remaining piece of r is blocked by t; forget about it */
 480                 someinvis = 1;
 481         }
 482 }