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