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