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