sys/src/cmd/acme/rows.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <thread.h>
   5 #include <cursor.h>
   6 #include <mouse.h>
   7 #include <keyboard.h>
   8 #include <frame.h>
   9 #include <fcall.h>
  10 #include <bio.h>
  11 #include <plumb.h>
  12 #include "dat.h"
  13 #include "fns.h"
  14
  15 void
  16 rowinit(Row *row, Rectangle r)
  17 {
  18         Rectangle r1;
  19         Text *t;
  20
  21         draw(screen, r, display->white, nil, ZP);
  22         row->r = r;
  23         row->col = nil;
  24         row->ncol = 0;
  25         r1 = r;
  26         r1.max.y = r1.min.y + font->height;
  27         t = &row->tag;
  28         textinit(t, fileaddtext(nil, t), r1, rfget(FALSE, FALSE, FALSE, nil), tagcols);
  29         t->what = Rowtag;
  30         t->row = row;
  31         t->w = nil;
  32         t->col = nil;
  33         r1.min.y = r1.max.y;
  34         r1.max.y += Border;
  35         draw(screen, r1, display->black, nil, ZP);
  36         textinsert(t, 0, L"Newcol Kill Putall Dump Exit ", 29, TRUE);
  37         textsetselect(t, t->file->nc, t->file->nc);
  38 }
  39
  40 Column*
  41 rowadd(Row *row, Column *c, int x)
  42 {
  43         Rectangle r, r1;
  44         Column *d;
  45         int i;
  46
  47         d = nil;
  48         r = row->r;
  49         r.min.y = row->tag.r.max.y+Border;
  50         if(x<r.min.x && row->ncol>0){   /*steal 40% of last column by default */
  51                 d = row->col[row->ncol-1];
  52                 x = d->r.min.x + 3*Dx(d->r)/5;
  53         }
  54         /* look for column we'll land on */
  55         for(i=0; i<row->ncol; i++){
  56                 d = row->col[i];
  57                 if(x < d->r.max.x)
  58                         break;
  59         }
  60         if(row->ncol > 0){
  61                 if(i < row->ncol)
  62                         i++;    /* new column will go after d */
  63                 r = d->r;
  64                 if(Dx(r) < 100)
  65                         return nil;
  66                 draw(screen, r, display->white, nil, ZP);
  67                 r1 = r;
  68                 r1.max.x = min(x, r.max.x-50);
  69                 if(Dx(r1) < 50)
  70                         r1.max.x = r1.min.x+50;
  71                 colresize(d, r1);
  72                 r1.min.x = r1.max.x;
  73                 r1.max.x = r1.min.x+Border;
  74                 draw(screen, r1, display->black, nil, ZP);
  75                 r.min.x = r1.max.x;
  76         }
  77         if(c == nil){
  78                 c = emalloc(sizeof(Column));
  79                 colinit(c, r);
  80                 incref(&reffont);
  81         }else
  82                 colresize(c, r);
  83         c->row = row;
  84         c->tag.row = row;
  85         row->col = realloc(row->col, (row->ncol+1)*sizeof(Column*));
  86         memmove(row->col+i+1, row->col+i, (row->ncol-i)*sizeof(Column*));
  87         row->col[i] = c;
  88         row->ncol++;
  89         clearmouse();
  90         return c;
  91 }
  92
  93 void
  94 rowresize(Row *row, Rectangle r)
  95 {
  96         int i, dx, odx;
  97         Rectangle r1, r2;
  98         Column *c;
  99
 100         dx = Dx(r);
 101         odx = Dx(row->r);
 102         row->r = r;
 103         r1 = r;
 104         r1.max.y = r1.min.y + font->height;
 105         textresize(&row->tag, r1);
 106         r1.min.y = r1.max.y;
 107         r1.max.y += Border;
 108         draw(screen, r1, display->black, nil, ZP);
 109         r.min.y = r1.max.y;
 110         r1 = r;
 111         r1.max.x = r1.min.x;
 112         for(i=0; i<row->ncol; i++){
 113                 c = row->col[i];
 114                 r1.min.x = r1.max.x;
 115                 if(i == row->ncol-1)
 116                         r1.max.x = r.max.x;
 117                 else
 118                         r1.max.x = r1.min.x+Dx(c->r)*dx/odx;
 119                 if(i > 0){
 120                         r2 = r1;
 121                         r2.max.x = r2.min.x+Border;
 122                         draw(screen, r2, display->black, nil, ZP);
 123                         r1.min.x = r2.max.x;
 124                 }
 125                 colresize(c, r1);
 126         }
 127 }
 128
 129 void
 130 rowdragcol(Row *row, Column *c, int)
 131 {
 132         Rectangle r;
 133         int i, b, x;
 134         Point p, op;
 135         Column *d;
 136
 137         clearmouse();
 138         setcursor(mousectl, &boxcursor);
 139         b = mouse->buttons;
 140         op = mouse->xy;
 141         while(mouse->buttons == b)
 142                 readmouse(mousectl);
 143         setcursor(mousectl, nil);
 144         if(mouse->buttons){
 145                 while(mouse->buttons)
 146                         readmouse(mousectl);
 147                 return;
 148         }
 149
 150         for(i=0; i<row->ncol; i++)
 151                 if(row->col[i] == c)
 152                         goto Found;
 153         error("can't find column");
 154
 155   Found:
 156         p = mouse->xy;
 157         if((abs(p.x-op.x)<5 && abs(p.y-op.y)<5))
 158                 return;
 159         if((i>0 && p.x<row->col[i-1]->r.min.x) || (i<row->ncol-1 && p.x>c->r.max.x)){
 160                 /* shuffle */
 161                 x = c->r.min.x;
 162                 rowclose(row, c, FALSE);
 163                 if(rowadd(row, c, p.x) == nil)  /* whoops! */
 164                 if(rowadd(row, c, x) == nil)            /* WHOOPS! */
 165                 if(rowadd(row, c, -1)==nil){            /* shit! */
 166                         rowclose(row, c, TRUE);
 167                         return;
 168                 }
 169                 colmousebut(c);
 170                 return;
 171         }
 172         if(i == 0)
 173                 return;
 174         d = row->col[i-1];
 175         if(p.x < d->r.min.x+80+Scrollwid)
 176                 p.x = d->r.min.x+80+Scrollwid;
 177         if(p.x > c->r.max.x-80-Scrollwid)
 178                 p.x = c->r.max.x-80-Scrollwid;
 179         r = d->r;
 180         r.max.x = c->r.max.x;
 181         draw(screen, r, display->white, nil, ZP);
 182         r.max.x = p.x;
 183         colresize(d, r);
 184         r = c->r;
 185         r.min.x = p.x;
 186         r.max.x = r.min.x;
 187         r.max.x += Border;
 188         draw(screen, r, display->black, nil, ZP);
 189         r.min.x = r.max.x;
 190         r.max.x = c->r.max.x;
 191         colresize(c, r);
 192         colmousebut(c);
 193 }
 194
 195 void
 196 rowclose(Row *row, Column *c, int dofree)
 197 {
 198         Rectangle r;
 199         int i;
 200
 201         for(i=0; i<row->ncol; i++)
 202                 if(row->col[i] == c)
 203                         goto Found;
 204         error("can't find column");
 205   Found:
 206         r = c->r;
 207         if(dofree)
 208                 colcloseall(c);
 209         memmove(row->col+i, row->col+i+1, (row->ncol-i)*sizeof(Column*));
 210         row->ncol--;
 211         row->col = realloc(row->col, row->ncol*sizeof(Column*));
 212         if(row->ncol == 0){
 213                 draw(screen, r, display->white, nil, ZP);
 214                 return;
 215         }
 216         if(i == row->ncol){             /* extend last column right */
 217                 c = row->col[i-1];
 218                 r.min.x = c->r.min.x;
 219                 r.max.x = row->r.max.x;
 220         }else{                  /* extend next window left */
 221                 c = row->col[i];
 222                 r.max.x = c->r.max.x;
 223         }
 224         draw(screen, r, display->white, nil, ZP);
 225         colresize(c, r);
 226 }
 227
 228 Column*
 229 rowwhichcol(Row *row, Point p)
 230 {
 231         int i;
 232         Column *c;
 233
 234         for(i=0; i<row->ncol; i++){
 235                 c = row->col[i];
 236                 if(ptinrect(p, c->r))
 237                         return c;
 238         }
 239         return nil;
 240 }
 241
 242 Text*
 243 rowwhich(Row *row, Point p)
 244 {
 245         Column *c;
 246
 247         if(ptinrect(p, row->tag.all))
 248                 return &row->tag;
 249         c = rowwhichcol(row, p);
 250         if(c)
 251                 return colwhich(c, p);
 252         return nil;
 253 }
 254
 255 Text*
 256 rowtype(Row *row, Rune r, Point p)
 257 {
 258         Window *w;
 259         Text *t;
 260
 261         clearmouse();
 262         qlock(row);
 263         if(bartflag)
 264                 t = barttext;
 265         else
 266                 t = rowwhich(row, p);
 267         if(t!=nil && !(t->what==Tag && ptinrect(p, t->scrollr))){
 268                 w = t->w;
 269                 if(w == nil)
 270                         texttype(t, r);
 271                 else{
 272                         winlock(w, 'K');
 273                         wintype(w, t, r);
 274                         winunlock(w);
 275                 }
 276         }
 277         qunlock(row);
 278         return t;
 279 }
 280
 281 int
 282 rowclean(Row *row)
 283 {
 284         int clean;
 285         int i;
 286
 287         clean = TRUE;
 288         for(i=0; i<row->ncol; i++)
 289                 clean &= colclean(row->col[i]);
 290         return clean;
 291 }
 292
 293 void
 294 rowdump(Row *row, char *file)
 295 {
 296         int i, j, fd, m, n, dumped;
 297         uint q0, q1;
 298         Biobuf *b;
 299         char *buf, *a, *fontname;
 300         Rune *r;
 301         Column *c;
 302         Window *w, *w1;
 303         Text *t;
 304
 305         if(row->ncol == 0)
 306                 return;
 307         buf = fbufalloc();
 308         if(file == nil){
 309                 if(home == nil){
 310                         warning(nil, "can't find file for dump: $home not defined\n");
 311                         goto Rescue;
 312                 }
 313                 sprint(buf, "%s/acme.dump", home);
 314                 file = buf;
 315         }
 316         fd = create(file, OWRITE, 0600);
 317         if(fd < 0){
 318                 warning(nil, "can't open %s: %r\n", file);
 319                 goto Rescue;
 320         }
 321         b = emalloc(sizeof(Biobuf));
 322         Binit(b, fd, OWRITE);
 323         r = fbufalloc();
 324         Bprint(b, "%s\n", wdir);
 325         Bprint(b, "%s\n", fontnames[0]);
 326         Bprint(b, "%s\n", fontnames[1]);
 327         for(i=0; i<row->ncol; i++){
 328                 c = row->col[i];
 329                 Bprint(b, "%11d", 100*(c->r.min.x-row->r.min.x)/Dx(row->r));
 330                 if(i == row->ncol-1)
 331                         Bputc(b, '\n');
 332                 else
 333                         Bputc(b, ' ');
 334         }
 335         for(i=0; i<row->ncol; i++){
 336                 c = row->col[i];
 337                 for(j=0; j<c->nw; j++)
 338                         c->w[j]->body.file->dumpid = 0;
 339         }
 340         for(i=0; i<row->ncol; i++){
 341                 c = row->col[i];
 342                 for(j=0; j<c->nw; j++){
 343                         w = c->w[j];
 344                         wincommit(w, &w->tag);
 345                         t = &w->body;
 346                         /* windows owned by others get special treatment */
 347                         if(w->nopen[QWevent] > 0)
 348                                 if(w->dumpstr == nil)
 349                                         continue;
 350                         /* zeroxes of external windows are tossed */
 351                         if(t->file->ntext > 1)
 352                                 for(n=0; n<t->file->ntext; n++){
 353                                         w1 = t->file->text[n]->w;
 354                                         if(w == w1)
 355                                                 continue;
 356                                         if(w1->nopen[QWevent])
 357                                                 goto Continue2;
 358                                 }
 359                         fontname = "";
 360                         if(t->reffont->f != font)
 361                                 fontname = t->reffont->f->name;
 362                         if(t->file->nname)
 363                                 a = runetobyte(t->file->name, t->file->nname);
 364                         else
 365                                 a = emalloc(1);
 366                         if(t->file->dumpid){
 367                                 dumped = FALSE;
 368                                 Bprint(b, "x%11d %11d %11d %11d %11d %s\n", i, t->file->dumpid,
 369                                         w->body.q0, w->body.q1,
 370                                         100*(w->r.min.y-c->r.min.y)/Dy(c->r),
 371                                         fontname);
 372                         }else if(w->dumpstr){
 373                                 dumped = FALSE;
 374                                 Bprint(b, "e%11d %11d %11d %11d %11d %s\n", i, t->file->dumpid,
 375                                         0, 0,
 376                                         100*(w->r.min.y-c->r.min.y)/Dy(c->r),
 377                                         fontname);
 378                         }else if((w->dirty==FALSE && access(a, 0)==0) || w->isdir){
 379                                 dumped = FALSE;
 380                                 t->file->dumpid = w->id;
 381                                 Bprint(b, "f%11d %11d %11d %11d %11d %s\n", i, w->id,
 382                                         w->body.q0, w->body.q1,
 383                                         100*(w->r.min.y-c->r.min.y)/Dy(c->r),
 384                                         fontname);
 385                         }else{
 386                                 dumped = TRUE;
 387                                 t->file->dumpid = w->id;
 388                                 Bprint(b, "F%11d %11d %11d %11d %11d %11d %s\n", i, j,
 389                                         w->body.q0, w->body.q1,
 390                                         100*(w->r.min.y-c->r.min.y)/Dy(c->r),
 391                                         w->body.file->nc, fontname);
 392                         }
 393                         free(a);
 394                         winctlprint(w, buf, 0);
 395                         Bwrite(b, buf, strlen(buf));
 396                         m = min(RBUFSIZE, w->tag.file->nc);
 397                         bufread(w->tag.file, 0, r, m);
 398                         n = 0;
 399                         while(n<m && r[n]!='\n')
 400                                 n++;
 401                         r[n++] = '\n';
 402                         Bprint(b, "%.*S", n, r);
 403                         if(dumped){
 404                                 q0 = 0;
 405                                 q1 = t->file->nc;
 406                                 while(q0 < q1){
 407                                         n = q1 - q0;
 408                                         if(n > BUFSIZE/UTFmax)
 409                                                 n = BUFSIZE/UTFmax;
 410                                         bufread(t->file, q0, r, n);
 411                                         Bprint(b, "%.*S", n, r);
 412                                         q0 += n;
 413                                 }
 414                         }
 415                         if(w->dumpstr){
 416                                 if(w->dumpdir)
 417                                         Bprint(b, "%s\n%s\n", w->dumpdir, w->dumpstr);
 418                                 else
 419                                         Bprint(b, "\n%s\n", w->dumpstr);
 420                         }
 421     Continue2:;
 422                 }
 423         }
 424         Bterm(b);
 425         close(fd);
 426         free(b);
 427         fbuffree(r);
 428
 429    Rescue:
 430         fbuffree(buf);
 431 }
 432
 433 static
 434 char*
 435 rdline(Biobuf *b, int *linep)
 436 {
 437         char *l;
 438
 439         l = Brdline(b, '\n');
 440         if(l)
 441                 (*linep)++;
 442         return l;
 443 }
 444
 445 /*
 446  * Get font names from load file so we don't load fonts we won't use
 447  */
 448 void
 449 rowloadfonts(char *file)
 450 {
 451         int i;
 452         Biobuf *b;
 453         char *l;
 454
 455         b = Bopen(file, OREAD);
 456         if(b == nil)
 457                 return;
 458         /* current directory */
 459         l = Brdline(b, '\n');
 460         if(l == nil)
 461                 goto Return;
 462         /* global fonts */
 463         for(i=0; i<2; i++){
 464                 l = Brdline(b, '\n');
 465                 if(l == nil)
 466                         goto Return;
 467                 l[Blinelen(b)-1] = 0;
 468                 if(*l && strcmp(l, fontnames[i])!=0){
 469                         free(fontnames[i]);
 470                         fontnames[i] = estrdup(l);
 471                 }
 472         }
 473     Return:
 474         Bterm(b);
 475 }
 476
 477 int
 478 rowload(Row *row, char *file, int initing)
 479 {
 480         int i, j, line, percent, y, nr, nfontr, n, ns, ndumped, dumpid, x, fd;
 481         Biobuf *b, *bout;
 482         char *buf, *l, *t, *fontname;
 483         Rune *r, rune, *fontr;
 484         Column *c, *c1, *c2;
 485         uint q0, q1;
 486         Rectangle r1, r2;
 487         Window *w;
 488
 489         buf = fbufalloc();
 490         if(file == nil){
 491                 if(home == nil){
 492                         warning(nil, "can't find file for load: $home not defined\n");
 493                         goto Rescue1;
 494                 }
 495                 sprint(buf, "%s/acme.dump", home);
 496                 file = buf;
 497         }
 498         b = Bopen(file, OREAD);
 499         if(b == nil){
 500                 warning(nil, "can't open load file %s: %r\n", file);
 501                 goto Rescue1;
 502         }
 503         /* current directory */
 504         line = 0;
 505         l = rdline(b, &line);
 506         if(l == nil)
 507                 goto Rescue2;
 508         l[Blinelen(b)-1] = 0;
 509         if(chdir(l) < 0){
 510                 warning(nil, "can't chdir %s\n", l);
 511                 goto Rescue2;
 512         }
 513         /* global fonts */
 514         for(i=0; i<2; i++){
 515                 l = rdline(b, &line);
 516                 if(l == nil)
 517                         goto Rescue2;
 518                 l[Blinelen(b)-1] = 0;
 519                 if(*l && strcmp(l, fontnames[i])!=0)
 520                         rfget(i, TRUE, i==0 && initing, l);
 521         }
 522         if(initing && row->ncol==0)
 523                 rowinit(row, screen->clipr);
 524         l = rdline(b, &line);
 525         if(l == nil)
 526                 goto Rescue2;
 527         j = Blinelen(b)/12;
 528         if(j<=0 || j>10)
 529                 goto Rescue2;
 530         for(i=0; i<j; i++){
 531                 percent = atoi(l+i*12);
 532                 if(percent<0 || percent>=100)
 533                         goto Rescue2;
 534                 x = row->r.min.x+percent*Dx(row->r)/100;
 535                 if(i < row->ncol){
 536                         if(i == 0)
 537                                 continue;
 538                         c1 = row->col[i-1];
 539                         c2 = row->col[i];
 540                         r1 = c1->r;
 541                         r2 = c2->r;
 542                         r1.max.x = x;
 543                         r2.min.x = x+Border;
 544                         if(Dx(r1) < 50 || Dx(r2) < 50)
 545                                 continue;
 546                         draw(screen, Rpt(r1.min, r2.max), display->white, nil, ZP);
 547                         colresize(c1, r1);
 548                         colresize(c2, r2);
 549                         r2.min.x = x;
 550                         r2.max.x = x+Border;
 551                         draw(screen, r2, display->black, nil, ZP);
 552                 }
 553                 if(i >= row->ncol)
 554                         rowadd(row, nil, x);
 555         }
 556         for(;;){
 557                 l = rdline(b, &line);
 558                 if(l == nil)
 559                         break;
 560                 dumpid = 0;
 561                 switch(l[0]){
 562                 case 'e':
 563                         if(Blinelen(b) < 1+5*12+1)
 564                                 goto Rescue2;
 565                         l = rdline(b, &line);   /* ctl line; ignored */
 566                         if(l == nil)
 567                                 goto Rescue2;
 568                         l = rdline(b, &line);   /* directory */
 569                         if(l == nil)
 570                                 goto Rescue2;
 571                         l[Blinelen(b)-1] = 0;
 572                         if(*l == '\0'){
 573                                 if(home == nil)
 574                                         r = bytetorune("./", &nr);
 575                                 else{
 576                                         t = emalloc(strlen(home)+1+1);
 577                                         sprint(t, "%s/", home);
 578                                         r = bytetorune(t, &nr);
 579                                         free(t);
 580                                 }
 581                         }else
 582                                 r = bytetorune(l, &nr);
 583                         l = rdline(b, &line);   /* command */
 584                         if(l == nil)
 585                                 goto Rescue2;
 586                         t = emalloc(Blinelen(b)+1);
 587                         memmove(t, l, Blinelen(b));
 588                         run(nil, t, r, nr, TRUE, nil, nil, FALSE);
 589                         /* r is freed in run() */
 590                         continue;
 591                 case 'f':
 592                         if(Blinelen(b) < 1+5*12+1)
 593                                 goto Rescue2;
 594                         fontname = l+1+5*12;
 595                         ndumped = -1;
 596                         break;
 597                 case 'F':
 598                         if(Blinelen(b) < 1+6*12+1)
 599                                 goto Rescue2;
 600                         fontname = l+1+6*12;
 601                         ndumped = atoi(l+1+5*12+1);
 602                         break;
 603                 case 'x':
 604                         if(Blinelen(b) < 1+5*12+1)
 605                                 goto Rescue2;
 606                         fontname = l+1+5*12;
 607                         ndumped = -1;
 608                         dumpid = atoi(l+1+1*12);
 609                         break;
 610                 default:
 611                         goto Rescue2;
 612                 }
 613                 l[Blinelen(b)-1] = 0;
 614                 fontr = nil;
 615                 nfontr = 0;
 616                 if(*fontname)
 617                         fontr = bytetorune(fontname, &nfontr);
 618                 i = atoi(l+1+0*12);
 619                 j = atoi(l+1+1*12);
 620                 q0 = atoi(l+1+2*12);
 621                 q1 = atoi(l+1+3*12);
 622                 percent = atoi(l+1+4*12);
 623                 if(i<0 || i>10)
 624                         goto Rescue2;
 625                 if(i > row->ncol)
 626                         i = row->ncol;
 627                 c = row->col[i];
 628                 y = c->r.min.y+(percent*Dy(c->r))/100;
 629                 if(y<c->r.min.y || y>=c->r.max.y)
 630                         y = -1;
 631                 if(dumpid == 0)
 632                         w = coladd(c, nil, nil, y);
 633                 else
 634                         w = coladd(c, nil, lookid(dumpid, TRUE), y);
 635                 if(w == nil)
 636                         continue;
 637                 w->dumpid = j;
 638                 l = rdline(b, &line);
 639                 if(l == nil)
 640                         goto Rescue2;
 641                 l[Blinelen(b)-1] = 0;
 642                 r = bytetorune(l+5*12, &nr);
 643                 ns = -1;
 644                 for(n=0; n<nr; n++){
 645                         if(r[n] == '/')
 646                                 ns = n;
 647                         if(r[n] == ' ')
 648                                 break;
 649                 }
 650                 if(dumpid == 0)
 651                         winsetname(w, r, n);
 652                 for(; n<nr; n++)
 653                         if(r[n] == '|')
 654                                 break;
 655                 wincleartag(w);
 656                 textinsert(&w->tag, w->tag.file->nc, r+n+1, nr-(n+1), TRUE);
 657                 if(ndumped >= 0){
 658                         /* simplest thing is to put it in a file and load that */
 659                         sprint(buf, "/tmp/d%d.%.4sacme", getpid(), getuser());
 660                         fd = create(buf, OWRITE|ORCLOSE, 0600);
 661                         if(fd < 0){
 662                                 free(r);
 663                                 warning(nil, "can't create temp file: %r\n");
 664                                 goto Rescue2;
 665                         }
 666                         bout = emalloc(sizeof(Biobuf));
 667                         Binit(bout, fd, OWRITE);
 668                         for(n=0; n<ndumped; n++){
 669                                 rune = Bgetrune(b);
 670                                 if(rune == '\n')
 671                                         line++;
 672                                 if(rune == (Rune)Beof){
 673                                         free(r);
 674                                         Bterm(bout);
 675                                         free(bout);
 676                                         close(fd);
 677                                         goto Rescue2;
 678                                 }
 679                                 Bputrune(bout, rune);
 680                         }
 681                         Bterm(bout);
 682                         free(bout);
 683                         textload(&w->body, 0, buf, 1);
 684                         close(fd);
 685                         w->body.file->mod = TRUE;
 686                         for(n=0; n<w->body.file->ntext; n++)
 687                                 w->body.file->text[n]->w->dirty = TRUE;
 688                         winsettag(w);
 689                 }else if(dumpid==0 && r[ns+1]!='+' && r[ns+1]!='-')
 690                         get(&w->body, nil, nil, FALSE, XXX, nil, 0);
 691                 if(fontr){
 692                         fontx(&w->body, nil, nil, 0, 0, fontr, nfontr);
 693                         free(fontr);
 694                 }
 695                 free(r);
 696                 if(q0>w->body.file->nc || q1>w->body.file->nc || q0>q1)
 697                         q0 = q1 = 0;
 698                 textshow(&w->body, q0, q1, 1);
 699                 w->maxlines = min(w->body.nlines, max(w->maxlines, w->body.maxlines));
 700         }
 701         Bterm(b);
 702         fbuffree(buf);
 703         return TRUE;
 704
 705 Rescue2:
 706         warning(nil, "bad load file %s:%d\n", file, line);
 707         Bterm(b);
 708 Rescue1:
 709         fbuffree(buf);
 710         return FALSE;
 711 }
 712
 713 void
 714 allwindows(void (*f)(Window*, void*), void *arg)
 715 {
 716         int i, j;
 717         Column *c;
 718
 719         for(i=0; i<row.ncol; i++){
 720                 c = row.col[i];
 721                 for(j=0; j<c->nw; j++)
 722                         (*f)(c->w[j], arg);
 723         }
 724 }