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