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