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 <plumb.h>
11 #include "dat.h"
12 #include "fns.h"
13 
14 static Rune Lheader[] = {
15 	'N', 'e', 'w', ' ',
16 	'C', 'u', 't', ' ',
17 	'P', 'a', 's', 't', 'e', ' ',
18 	'S', 'n', 'a', 'r', 'f', ' ',
19 	'S', 'o', 'r', 't', ' ',
20 	'Z', 'e', 'r', 'o', 'x', ' ',
21 	'D', 'e', 'l', 'c', 'o', 'l', ' ',
22 	0
23 };
24 
25 void
26 colinit(Column *c, Rectangle r)
27 {
28 	Rectangle r1;
29 	Text *t;
30 
31 	draw(screen, r, display->white, nil, ZP);
32 	c->r = r;
33 	c->w = nil;
34 	c->nw = 0;
35 	t = &c->tag;
36 	t->w = nil;
37 	t->col = c;
38 	r1 = r;
39 	r1.max.y = r1.min.y + font->height;
40 	textinit(t, fileaddtext(nil, t), r1, &reffont, tagcols);
41 	t->what = Columntag;
42 	r1.min.y = r1.max.y;
43 	r1.max.y += Border;
44 	draw(screen, r1, display->black, nil, ZP);
45 	textinsert(t, 0, Lheader, 38, TRUE);
46 	textsetselect(t, t->file->b.nc, t->file->b.nc);
47 	draw(screen, t->scrollr, colbutton, nil, colbutton->r.min);
48 	c->safe = TRUE;
49 }
50 
51 Window*
52 coladd(Column *c, Window *w, Window *clone, int y)
53 {
54 	Rectangle r, r1;
55 	Window *v;
56 	int i, t;
57 
58 	v = nil;
59 	r = c->r;
60 	r.min.y = c->tag.fr.r.max.y+Border;
61 	if(y<r.min.y && c->nw>0){	/* steal half of last window by default */
62 		v = c->w[c->nw-1];
63 		y = v->body.fr.r.min.y+Dy(v->body.fr.r)/2;
64 	}
65 	/* look for window we'll land on */
66 	for(i=0; i<c->nw; i++){
67 		v = c->w[i];
68 		if(y < v->r.max.y)
69 			break;
70 	}
71 	if(c->nw > 0){
72 		if(i < c->nw)
73 			i++;	/* new window will go after v */
74 		/*
75 		 * if v's too small, grow it first.
76 		 */
77 		if(!c->safe || v->body.fr.maxlines<=3){
78 			colgrow(c, v, 1);
79 			y = v->body.fr.r.min.y+Dy(v->body.fr.r)/2;
80 		}
81 		r = v->r;
82 		if(i == c->nw)
83 			t = c->r.max.y;
84 		else
85 			t = c->w[i]->r.min.y-Border;
86 		r.max.y = t;
87 		draw(screen, r, textcols[BACK], nil, ZP);
88 		r1 = r;
89 		y = min(y, t-(v->tag.fr.font->height+v->body.fr.font->height+Border+1));
90 		r1.max.y = min(y, v->body.fr.r.min.y+v->body.fr.nlines*v->body.fr.font->height);
91 		r1.min.y = winresize(v, r1, FALSE);
92 		r1.max.y = r1.min.y+Border;
93 		draw(screen, r1, display->black, nil, ZP);
94 		r.min.y = r1.max.y;
95 	}
96 	if(w == nil){
97 		w = emalloc(sizeof(Window));
98 		w->col = c;
99 		draw(screen, r, textcols[BACK], nil, ZP);
100 		wininit(w, clone, r);
101 	}else{
102 		w->col = c;
103 		winresize(w, r, FALSE);
104 	}
105 //assert(w->body.w == w);
106 	w->tag.col = c;
107 	w->tag.row = c->row;
108 	w->body.col = c;
109 	w->body.row = c->row;
110 	c->w = realloc(c->w, (c->nw+1)*sizeof(Window*));
111 	memmove(c->w+i+1, c->w+i, (c->nw-i)*sizeof(Window*));
112 	c->nw++;
113 	c->w[i] = w;
114 	savemouse(w);
115 	/* near but not on the button */
116 	moveto(mousectl, addpt(w->tag.scrollr.max, Pt(3, 3)));
117 	barttext = &w->body;
118 	c->safe = TRUE;
119 	return w;
120 }
121 
122 void
123 colclose(Column *c, Window *w, int dofree)
124 {
125 	Rectangle r;
126 	int i;
127 
128 	/* w is locked */
129 	if(!c->safe)
130 		colgrow(c, w, 1);
131 	for(i=0; i<c->nw; i++)
132 		if(c->w[i] == w)
133 			goto Found;
134 	error("can't find window");
135   Found:
136 	r = w->r;
137 	w->tag.col = nil;
138 	w->body.col = nil;
139 	w->col = nil;
140 	restoremouse(w);
141 	if(dofree){
142 		windelete(w);
143 		winclose(w);
144 	}
145 	memmove(c->w+i, c->w+i+1, (c->nw-i)*sizeof(Window*));
146 	c->nw--;
147 	c->w = realloc(c->w, c->nw*sizeof(Window*));
148 	if(c->nw == 0){
149 		draw(screen, r, display->white, nil, ZP);
150 		return;
151 	}
152 	if(i == c->nw){		/* extend last window down */
153 		w = c->w[i-1];
154 		r.min.y = w->r.min.y;
155 		r.max.y = c->r.max.y;
156 	}else{			/* extend next window up */
157 		w = c->w[i];
158 		r.max.y = w->r.max.y;
159 	}
160 	draw(screen, r, textcols[BACK], nil, ZP);
161 	if(c->safe)
162 		winresize(w, r, FALSE);
163 }
164 
165 void
166 colcloseall(Column *c)
167 {
168 	int i;
169 	Window *w;
170 
171 	if(c == activecol)
172 		activecol = nil;
173 	textclose(&c->tag);
174 	for(i=0; i<c->nw; i++){
175 		w = c->w[i];
176 		winclose(w);
177 	}
178 	c->nw = 0;
179 	free(c->w);
180 	free(c);
181 	clearmouse();
182 }
183 
184 void
185 colmousebut(Column *c)
186 {
187 	moveto(mousectl, divpt(addpt(c->tag.scrollr.min, c->tag.scrollr.max), 2));
188 }
189 
190 void
191 colresize(Column *c, Rectangle r)
192 {
193 	int i;
194 	Rectangle r1, r2;
195 	Window *w;
196 
197 	clearmouse();
198 	r1 = r;
199 	r1.max.y = r1.min.y + c->tag.fr.font->height;
200 	textresize(&c->tag, r1);
201 	draw(screen, c->tag.scrollr, colbutton, nil, colbutton->r.min);
202 	r1.min.y = r1.max.y;
203 	r1.max.y += Border;
204 	draw(screen, r1, display->black, nil, ZP);
205 	r1.max.y = r.max.y;
206 	for(i=0; i<c->nw; i++){
207 		w = c->w[i];
208 		w->maxlines = 0;
209 		if(i == c->nw-1)
210 			r1.max.y = r.max.y;
211 		else
212 			r1.max.y = r1.min.y+(Dy(w->r)+Border)*Dy(r)/Dy(c->r);
213 		r2 = r1;
214 		r2.max.y = r2.min.y+Border;
215 		draw(screen, r2, display->black, nil, ZP);
216 		r1.min.y = r2.max.y;
217 		r1.min.y = winresize(w, r1, FALSE);
218 	}
219 	c->r = r;
220 }
221 
222 static
223 int
224 colcmp(const void *a, const void *b)
225 {
226 	Rune *r1, *r2;
227 	int i, nr1, nr2;
228 
229 	r1 = (*(Window**)a)->body.file->name;
230 	nr1 = (*(Window**)a)->body.file->nname;
231 	r2 = (*(Window**)b)->body.file->name;
232 	nr2 = (*(Window**)b)->body.file->nname;
233 	for(i=0; i<nr1 && i<nr2; i++){
234 		if(*r1 != *r2)
235 			return *r1-*r2;
236 		r1++;
237 		r2++;
238 	}
239 	return nr1-nr2;
240 }
241 
242 void
243 colsort(Column *c)
244 {
245 	int i, y;
246 	Rectangle r, r1, *rp;
247 	Window **wp, *w;
248 
249 	if(c->nw == 0)
250 		return;
251 	clearmouse();
252 	rp = emalloc(c->nw*sizeof(Rectangle));
253 	wp = emalloc(c->nw*sizeof(Window*));
254 	memmove(wp, c->w, c->nw*sizeof(Window*));
255 	qsort(wp, c->nw, sizeof(Window*), colcmp);
256 	for(i=0; i<c->nw; i++)
257 		rp[i] = wp[i]->r;
258 	r = c->r;
259 	r.min.y = c->tag.fr.r.max.y;
260 	draw(screen, r, textcols[BACK], nil, ZP);
261 	y = r.min.y;
262 	for(i=0; i<c->nw; i++){
263 		w = wp[i];
264 		r.min.y = y;
265 		if(i == c->nw-1)
266 			r.max.y = c->r.max.y;
267 		else
268 			r.max.y = r.min.y+Dy(w->r)+Border;
269 		r1 = r;
270 		r1.max.y = r1.min.y+Border;
271 		draw(screen, r1, display->black, nil, ZP);
272 		r.min.y = r1.max.y;
273 		y = winresize(w, r, FALSE);
274 	}
275 	free(rp);
276 	free(c->w);
277 	c->w = wp;
278 }
279 
280 void
281 colgrow(Column *c, Window *w, int but)
282 {
283 	Rectangle r, cr;
284 	int i, j, k, l, y1, y2, *nl, *ny, tot, nnl, onl, dnl, h;
285 	Window *v;
286 
287 	for(i=0; i<c->nw; i++)
288 		if(c->w[i] == w)
289 			goto Found;
290 	error("can't find window");
291 
292   Found:
293 	cr = c->r;
294 	if(but < 0){	/* make sure window fills its own space properly */
295 		r = w->r;
296 		if(i==c->nw-1 || c->safe==FALSE)
297 			r.max.y = cr.max.y;
298 		else
299 			r.max.y = c->w[i+1]->r.min.y;
300 		winresize(w, r, FALSE);
301 		return;
302 	}
303 	cr.min.y = c->w[0]->r.min.y;
304 	if(but == 3){	/* full size */
305 		if(i != 0){
306 			v = c->w[0];
307 			c->w[0] = w;
308 			c->w[i] = v;
309 		}
310 		draw(screen, cr, textcols[BACK], nil, ZP);
311 		winresize(w, cr, FALSE);
312 		for(i=1; i<c->nw; i++)
313 			c->w[i]->body.fr.maxlines = 0;
314 		c->safe = FALSE;
315 		return;
316 	}
317 	/* store old #lines for each window */
318 	onl = w->body.fr.maxlines;
319 	nl = emalloc(c->nw * sizeof(int));
320 	ny = emalloc(c->nw * sizeof(int));
321 	tot = 0;
322 	for(j=0; j<c->nw; j++){
323 		l = c->w[j]->body.fr.maxlines;
324 		nl[j] = l;
325 		tot += l;
326 	}
327 	/* approximate new #lines for this window */
328 	if(but == 2){	/* as big as can be */
329 		memset(nl, 0, c->nw * sizeof(int));
330 		goto Pack;
331 	}
332 	nnl = min(onl + max(min(5, w->maxlines), onl/2), tot);
333 	if(nnl < w->maxlines)
334 		nnl = (w->maxlines+nnl)/2;
335 	if(nnl == 0)
336 		nnl = 2;
337 	dnl = nnl - onl;
338 	/* compute new #lines for each window */
339 	for(k=1; k<c->nw; k++){
340 		/* prune from later window */
341 		j = i+k;
342 		if(j<c->nw && nl[j]){
343 			l = min(dnl, max(1, nl[j]/2));
344 			nl[j] -= l;
345 			nl[i] += l;
346 			dnl -= l;
347 		}
348 		/* prune from earlier window */
349 		j = i-k;
350 		if(j>=0 && nl[j]){
351 			l = min(dnl, max(1, nl[j]/2));
352 			nl[j] -= l;
353 			nl[i] += l;
354 			dnl -= l;
355 		}
356 	}
357     Pack:
358 	/* pack everyone above */
359 	y1 = cr.min.y;
360 	for(j=0; j<i; j++){
361 		v = c->w[j];
362 		r = v->r;
363 		r.min.y = y1;
364 		r.max.y = y1+Dy(v->tag.all);
365 		if(nl[j])
366 			r.max.y += 1 + nl[j]*v->body.fr.font->height;
367 		if(!c->safe || !eqrect(v->r, r)){
368 			draw(screen, r, textcols[BACK], nil, ZP);
369 			winresize(v, r, c->safe);
370 		}
371 		r.min.y = v->r.max.y;
372 		r.max.y += Border;
373 		draw(screen, r, display->black, nil, ZP);
374 		y1 = r.max.y;
375 	}
376 	/* scan to see new size of everyone below */
377 	y2 = c->r.max.y;
378 	for(j=c->nw-1; j>i; j--){
379 		v = c->w[j];
380 		r = v->r;
381 		r.min.y = y2-Dy(v->tag.all);
382 		if(nl[j])
383 			r.min.y -= 1 + nl[j]*v->body.fr.font->height;
384 		r.min.y -= Border;
385 		ny[j] = r.min.y;
386 		y2 = r.min.y;
387 	}
388 	/* compute new size of window */
389 	r = w->r;
390 	r.min.y = y1;
391 	r.max.y = r.min.y+Dy(w->tag.all);
392 	h = w->body.fr.font->height;
393 	if(y2-r.max.y >= 1+h+Border){
394 		r.max.y += 1;
395 		r.max.y += h*((y2-r.max.y)/h);
396 	}
397 	/* draw window */
398 	if(!c->safe || !eqrect(w->r, r)){
399 		draw(screen, r, textcols[BACK], nil, ZP);
400 		winresize(w, r, c->safe);
401 	}
402 	if(i < c->nw-1){
403 		r.min.y = r.max.y;
404 		r.max.y += Border;
405 		draw(screen, r, display->black, nil, ZP);
406 		for(j=i+1; j<c->nw; j++)
407 			ny[j] -= (y2-r.max.y);
408 	}
409 	/* pack everyone below */
410 	y1 = r.max.y;
411 	for(j=i+1; j<c->nw; j++){
412 		v = c->w[j];
413 		r = v->r;
414 		r.min.y = y1;
415 		r.max.y = y1+Dy(v->tag.all);
416 		if(nl[j])
417 			r.max.y += 1 + nl[j]*v->body.fr.font->height;
418 		if(!c->safe || !eqrect(v->r, r)){
419 			draw(screen, r, textcols[BACK], nil, ZP);
420 			winresize(v, r, c->safe);
421 		}
422 		if(j < c->nw-1){	/* no border on last window */
423 			r.min.y = v->r.max.y;
424 			r.max.y += Border;
425 			draw(screen, r, display->black, nil, ZP);
426 		}
427 		y1 = r.max.y;
428 	}
429 	r = w->r;
430 	r.min.y = y1;
431 	r.max.y = c->r.max.y;
432 	draw(screen, r, textcols[BACK], nil, ZP);
433 	free(nl);
434 	free(ny);
435 	c->safe = TRUE;
436 	winmousebut(w);
437 }
438 
439 void
440 coldragwin(Column *c, Window *w, int but)
441 {
442 	Rectangle r;
443 	int i, b;
444 	Point p, op;
445 	Window *v;
446 	Column *nc;
447 
448 	clearmouse();
449 	setcursor(mousectl, &boxcursor);
450 	b = mouse->buttons;
451 	op = mouse->xy;
452 	while(mouse->buttons == b)
453 		readmouse(mousectl);
454 	setcursor(mousectl, nil);
455 	if(mouse->buttons){
456 		while(mouse->buttons)
457 			readmouse(mousectl);
458 		return;
459 	}
460 
461 	for(i=0; i<c->nw; i++)
462 		if(c->w[i] == w)
463 			goto Found;
464 	error("can't find window");
465 
466   Found:
467 	p = mouse->xy;
468 	if(abs(p.x-op.x)<5 && abs(p.y-op.y)<5){
469 		colgrow(c, w, but);
470 		winmousebut(w);
471 		return;
472 	}
473 	/* is it a flick to the right? */
474 	if(abs(p.y-op.y)<10 && p.x>op.x+30 && rowwhichcol(c->row, p)==c)
475 		p.x = op.x+Dx(w->r);	/* yes: toss to next column */
476 	nc = rowwhichcol(c->row, p);
477 	if(nc!=nil && nc!=c){
478 		colclose(c, w, FALSE);
479 		coladd(nc, w, nil, p.y);
480 		winmousebut(w);
481 		return;
482 	}
483 	if(i==0 && c->nw==1)
484 		return;			/* can't do it */
485 	if((i>0 && p.y<c->w[i-1]->r.min.y) || (i<c->nw-1 && p.y>w->r.max.y)
486 	|| (i==0 && p.y>w->r.max.y)){
487 		/* shuffle */
488 		colclose(c, w, FALSE);
489 		coladd(c, w, nil, p.y);
490 		winmousebut(w);
491 		return;
492 	}
493 	if(i == 0)
494 		return;
495 	v = c->w[i-1];
496 	if(p.y < v->tag.all.max.y)
497 		p.y = v->tag.all.max.y;
498 	if(p.y > w->r.max.y-Dy(w->tag.all)-Border)
499 		p.y = w->r.max.y-Dy(w->tag.all)-Border;
500 	r = v->r;
501 	r.max.y = p.y;
502 	if(r.max.y > v->body.fr.r.min.y){
503 		r.max.y -= (r.max.y-v->body.fr.r.min.y)%v->body.fr.font->height;
504 		if(v->body.fr.r.min.y == v->body.fr.r.max.y)
505 			r.max.y++;
506 	}
507 	if(!eqrect(v->r, r)){
508 		draw(screen, r, textcols[BACK], nil, ZP);
509 		winresize(v, r, c->safe);
510 	}
511 	r.min.y = v->r.max.y;
512 	r.max.y = r.min.y+Border;
513 	draw(screen, r, display->black, nil, ZP);
514 	r.min.y = r.max.y;
515 	if(i == c->nw-1)
516 		r.max.y = c->r.max.y;
517 	else
518 		r.max.y = c->w[i+1]->r.min.y-Border;
519 	if(!eqrect(w->r, r)){
520 		draw(screen, r, textcols[BACK], nil, ZP);
521 		winresize(w, r, c->safe);
522 	}
523 	c->safe = TRUE;
524     	winmousebut(w);
525 }
526 
527 Text*
528 colwhich(Column *c, Point p)
529 {
530 	int i;
531 	Window *w;
532 
533 	if(!ptinrect(p, c->r))
534 		return nil;
535 	if(ptinrect(p, c->tag.all))
536 		return &c->tag;
537 	for(i=0; i<c->nw; i++){
538 		w = c->w[i];
539 		if(ptinrect(p, w->r)){
540 			if(ptinrect(p, w->tag.all))
541 				return &w->tag;
542 			return &w->body;
543 		}
544 	}
545 	return nil;
546 }
547 
548 int
549 colclean(Column *c)
550 {
551 	int i, clean;
552 
553 	clean = TRUE;
554 	for(i=0; i<c->nw; i++)
555 		clean &= winclean(c->w[i], TRUE);
556 	return clean;
557 }