Warning: Attempt to read property "date" on null in /usr/local/www/websvn.planix.org/blame.php on line 247

Warning: Attempt to read property "msg" on null in /usr/local/www/websvn.planix.org/blame.php on line 247
WebSVN – planix.SVN – Blame – /os/branches/feature_unix/sys/src/cmd/samterm/flayer.c – Rev 2

Subversion Repositories planix.SVN

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include <u.h>
2 
#include <libc.h>
3 
#include <draw.h>
4 
#include <thread.h>
5 
#include <mouse.h>
6 
#include <keyboard.h>
7 
#include <frame.h>
8 
#include "flayer.h"
9 
#include "samterm.h"
10 
 
11 
#define	DELTA	10
12 
 
13 
static Flayer	**llist;	/* front to back */
14 
static int	nllist;
15 
static int	nlalloc;
16 
static Rectangle lDrect;
17 
 
18 
Vis		visibility(Flayer *);
19 
void		newvisibilities(int);
20 
void		llinsert(Flayer*);
21 
void		lldelete(Flayer*);
22 
 
23 
Image	*maincols[NCOL];
24 
Image	*cmdcols[NCOL];
25 
 
26 
void
27 
flstart(Rectangle r)
28 
{
29 
	lDrect = r;
30 
 
31 
	/* Main text is yellowish */
32 
	maincols[BACK] = allocimagemix(display, DPaleyellow, DWhite);
33 
	maincols[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DDarkyellow);
34 
	maincols[BORD] = allocimage(display, Rect(0,0,2,2), screen->chan, 1, DYellowgreen);
35 
	maincols[TEXT] = display->black;
36 
	maincols[HTEXT] = display->black;
37 
 
38 
	/* Command text is blueish */
39 
	cmdcols[BACK] = allocimagemix(display, DPalebluegreen, DWhite);
40 
	cmdcols[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DPalegreygreen);
41 
	cmdcols[BORD] = allocimage(display, Rect(0,0,2,2), screen->chan, 1, DPurpleblue);
42 
	cmdcols[TEXT] = display->black;
43 
	cmdcols[HTEXT] = display->black;
44 
}
45 
 
46 
void
47 
flnew(Flayer *l, Rune *(*fn)(Flayer*, long, ulong*), int u0, void *u1)
48 
{
49 
	if(nllist == nlalloc){
50 
		nlalloc += DELTA;
51 
		llist = realloc(llist, nlalloc*sizeof(Flayer**));
52 
		if(llist == 0)
53 
			panic("flnew");
54 
	}
55 
	l->textfn = fn;
56 
	l->user0 = u0;
57 
	l->user1 = u1;
58 
	l->lastsr = ZR;
59 
	llinsert(l);
60 
}
61 
 
62 
Rectangle
63 
flrect(Flayer *l, Rectangle r)
64 
{
65 
	rectclip(&r, lDrect);
66 
	l->entire = r;
67 
	l->scroll = insetrect(r, FLMARGIN);
68 
	r.min.x =
69 
	 l->scroll.max.x = r.min.x+FLMARGIN+FLSCROLLWID+(FLGAP-FLMARGIN);
70 
	return r;
71 
}
72 
 
73 
static void
74 
fontbuggered(char *name)
75 
{
76 
	fprint(2, "samterm: font %s has zero-width \"0\" character\n", name);
77 
	threadexits("font zero-width");
78 
}
79 
 
80 
void
81 
flinit(Flayer *l, Rectangle r, Font *ft, Image **cols)
82 
{
83 
	lldelete(l);
84 
	llinsert(l);
85 
	l->visible = All;
86 
	l->origin = l->p0 = l->p1 = 0;
87 
	frinit(&l->f, insetrect(flrect(l, r), FLMARGIN), ft, screen, cols);
88 
	l->f.maxtab = maxtab*stringwidth(ft, "0");
89 
	if(l->f.maxtab == 0)
90 
		fontbuggered(ft->name);
91 
	newvisibilities(1);
92 
	draw(screen, l->entire, l->f.cols[BACK], nil, ZP);
93 
	scrdraw(l, 0L);
94 
	flborder(l, 0);
95 
}
96 
 
97 
void
98 
flclose(Flayer *l)
99 
{
100 
	if(l->visible == All)
101 
		draw(screen, l->entire, display->white, nil, ZP);
102 
	else if(l->visible == Some){
103 
		if(l->f.b == 0)
104 
			l->f.b = allocimage(display, l->entire, screen->chan, 0, DNofill);
105 
		if(l->f.b){
106 
			draw(l->f.b, l->entire, display->white, nil, ZP);
107 
			flrefresh(l, l->entire, 0);
108 
		}
109 
	}
110 
	frclear(&l->f, 1);
111 
	lldelete(l);
112 
	if(l->f.b && l->visible!=All)
113 
		freeimage(l->f.b);
114 
	l->textfn = 0;
115 
	newvisibilities(1);
116 
}
117 
 
118 
void
119 
flborder(Flayer *l, int wide)
120 
{
121 
	if(flprepare(l)){
122 
		border(l->f.b, l->entire, FLMARGIN, l->f.cols[BACK], ZP);
123 
		border(l->f.b, l->entire, wide? FLMARGIN : 1, l->f.cols[BORD], ZP);
124 
		if(l->visible==Some)
125 
			flrefresh(l, l->entire, 0);
126 
	}
127 
}
128 
 
129 
Flayer *
130 
flwhich(Point p)
131 
{
132 
	int i;
133 
 
134 
	if(p.x==0 && p.y==0)
135 
		return nllist? llist[0] : 0;
136 
	for(i=0; i<nllist; i++)
137 
		if(ptinrect(p, llist[i]->entire))
138 
			return llist[i];
139 
	return 0;
140 
}
141 
 
142 
void
143 
flupfront(Flayer *l)
144 
{
145 
	int v = l->visible;
146 
 
147 
	lldelete(l);
148 
	llinsert(l);
149 
	if(v!=All)
150 
		newvisibilities(0);
151 
}
152 
 
153 
void
154 
newvisibilities(int redraw)
155 
	/* if redraw false, we know it's a flupfront, and needn't
156 
	 * redraw anyone becoming partially covered */
157 
{
158 
	int i;
159 
	Vis ov;
160 
	Flayer *l;
161 
 
162 
	for(i = 0; i<nllist; i++){
163 
		l = llist[i];
164 
		l->lastsr = ZR;	/* make sure scroll bar gets redrawn */
165 
		ov = l->visible;
166 
		l->visible = visibility(l);
167 
#define	V(a, b)	(((a)<<2)|((b)))
168 
		switch(V(ov, l->visible)){
169 
		case V(Some, None):
170 
			if(l->f.b)
171 
				freeimage(l->f.b);
172 
		case V(All, None):
173 
		case V(All, Some):
174 
			l->f.b = 0;
175 
			frclear(&l->f, 0);
176 
			break;
177 
 
178 
		case V(Some, Some):
179 
			if(l->f.b==0 && redraw)
180 
		case V(None, Some):
181 
				flprepare(l);
182 
			if(l->f.b && redraw){
183 
				flrefresh(l, l->entire, 0);
184 
				freeimage(l->f.b);
185 
				l->f.b = 0;
186 
				frclear(&l->f, 0);
187 
			}
188 
		case V(None, None):
189 
		case V(All, All):
190 
			break;
191 
 
192 
		case V(Some, All):
193 
			if(l->f.b){
194 
				draw(screen, l->entire, l->f.b, nil, l->entire.min);
195 
				freeimage(l->f.b);
196 
				l->f.b = screen;
197 
				break;
198 
			}
199 
		case V(None, All):
200 
			flprepare(l);
201 
			break;
202 
		}
203 
		if(ov==None && l->visible!=None)
204 
			flnewlyvisible(l);
205 
	}
206 
}
207 
 
208 
void
209 
llinsert(Flayer *l)
210 
{
211 
	int i;
212 
	for(i=nllist; i>0; --i)
213 
		llist[i]=llist[i-1];
214 
	llist[0]=l;
215 
	nllist++;
216 
}
217 
 
218 
void
219 
lldelete(Flayer *l)
220 
{
221 
	int i;
222 
 
223 
	for(i=0; i<nllist; i++)
224 
		if(llist[i]==l){
225 
			--nllist;
226 
			for(; i<nllist; i++)
227 
				llist[i] = llist[i+1];
228 
			return;
229 
		}
230 
	panic("lldelete");
231 
}
232 
 
233 
void
234 
flinsert(Flayer *l, Rune *sp, Rune *ep, long p0)
235 
{
236 
	if(flprepare(l)){
237 
		frinsert(&l->f, sp, ep, p0-l->origin);
238 
		scrdraw(l, scrtotal(l));
239 
		if(l->visible==Some)
240 
			flrefresh(l, l->entire, 0);
241 
	}
242 
}
243 
 
244 
void
245 
fldelete(Flayer *l, long p0, long p1)
246 
{
247 
	if(flprepare(l)){
248 
		p0 -= l->origin;
249 
		if(p0 < 0)
250 
			p0 = 0;
251 
		p1 -= l->origin;
252 
		if(p1<0)
253 
			p1 = 0;
254 
		frdelete(&l->f, p0, p1);
255 
		scrdraw(l, scrtotal(l));
256 
		if(l->visible==Some)
257 
			flrefresh(l, l->entire, 0);
258 
	}
259 
}
260 
 
261 
int
262 
flselect(Flayer *l)
263 
{
264 
	int ret;
265 
	if(l->visible!=All)
266 
		flupfront(l);
267 
	frselect(&l->f, mousectl);
268 
	ret = 0;
269 
	if(l->f.p0==l->f.p1){
270 
		if(mousep->msec-l->click<Clicktime && l->f.p0+l->origin==l->p0){
271 
			ret = 1;
272 
			l->click = 0;
273 
		}else
274 
			l->click = mousep->msec;
275 
	}else
276 
		l->click = 0;
277 
	l->p0 = l->f.p0+l->origin, l->p1 = l->f.p1+l->origin;
278 
	return ret;
279 
}
280 
 
281 
void
282 
flsetselect(Flayer *l, long p0, long p1)
283 
{
284 
	ulong fp0, fp1;
285 
 
286 
	l->click = 0;
287 
	if(l->visible==None || !flprepare(l)){
288 
		l->p0 = p0, l->p1 = p1;
289 
		return;
290 
	}
291 
	l->p0 = p0, l->p1 = p1;
292 
	flfp0p1(l, &fp0, &fp1);
293 
	if(fp0==l->f.p0 && fp1==l->f.p1)
294 
		return;
295 
 
296 
	if(fp1<=l->f.p0 || fp0>=l->f.p1 || l->f.p0==l->f.p1 || fp0==fp1){
297 
		/* no overlap or trivial repainting */
298 
		frdrawsel(&l->f, frptofchar(&l->f, l->f.p0), l->f.p0, l->f.p1, 0);
299 
		frdrawsel(&l->f, frptofchar(&l->f, fp0), fp0, fp1, 1);
300 
		goto Refresh;
301 
	}
302 
	/* the current selection and the desired selection overlap and are both non-empty */
303 
	if(fp0 < l->f.p0){
304 
		/* extend selection backwards */
305 
		frdrawsel(&l->f, frptofchar(&l->f, fp0), fp0, l->f.p0, 1);
306 
	}else if(fp0 > l->f.p0){
307 
		/* trim first part of selection */
308 
		frdrawsel(&l->f, frptofchar(&l->f, l->f.p0), l->f.p0, fp0, 0);
309 
	}
310 
	if(fp1 > l->f.p1){
311 
		/* extend selection forwards */
312 
		frdrawsel(&l->f, frptofchar(&l->f, l->f.p1), l->f.p1, fp1, 1);
313 
	}else if(fp1 < l->f.p1){
314 
		/* trim last part of selection */
315 
		frdrawsel(&l->f, frptofchar(&l->f, fp1), fp1, l->f.p1, 0);
316 
	}
317 
 
318 
    Refresh:
319 
	l->f.p0 = fp0;
320 
	l->f.p1 = fp1;
321 
	if(l->visible==Some)
322 
		flrefresh(l, l->entire, 0);
323 
}
324 
 
325 
void
326 
flfp0p1(Flayer *l, ulong *pp0, ulong *pp1)
327 
{
328 
	long p0 = l->p0-l->origin, p1 = l->p1-l->origin;
329 
 
330 
	if(p0 < 0)
331 
		p0 = 0;
332 
	if(p1 < 0)
333 
		p1 = 0;
334 
	if(p0 > l->f.nchars)
335 
		p0 = l->f.nchars;
336 
	if(p1 > l->f.nchars)
337 
		p1 = l->f.nchars;
338 
	*pp0 = p0;
339 
	*pp1 = p1;
340 
}
341 
 
342 
Rectangle
343 
rscale(Rectangle r, Point old, Point new)
344 
{
345 
	r.min.x = r.min.x*new.x/old.x;
346 
	r.min.y = r.min.y*new.y/old.y;
347 
	r.max.x = r.max.x*new.x/old.x;
348 
	r.max.y = r.max.y*new.y/old.y;
349 
	return r;
350 
}
351 
 
352 
void
353 
flresize(Rectangle dr)
354 
{
355 
	int i;
356 
	Flayer *l;
357 
	Frame *f;
358 
	Rectangle r, olDrect;
359 
	int move;
360 
 
361 
	olDrect = lDrect;
362 
	lDrect = dr;
363 
	move = 0;
364 
	/* no moving on rio; must repaint */
365 
	if(0 && Dx(dr)==Dx(olDrect) && Dy(dr)==Dy(olDrect))
366 
		move = 1;
367 
	else
368 
		draw(screen, lDrect, display->white, nil, ZP);
369 
	for(i=0; i<nllist; i++){
370 
		l = llist[i];
371 
		l->lastsr = ZR;
372 
		f = &l->f;
373 
		if(move)
374 
			r = rectaddpt(rectsubpt(l->entire, olDrect.min), dr.min);
375 
		else{
376 
			r = rectaddpt(rscale(rectsubpt(l->entire, olDrect.min),
377 
				subpt(olDrect.max, olDrect.min),
378 
				subpt(dr.max, dr.min)), dr.min);
379 
			if(l->visible==Some && f->b){
380 
				freeimage(f->b);
381 
				frclear(f, 0);
382 
			}
383 
			f->b = 0;
384 
			if(l->visible!=None)
385 
				frclear(f, 0);
386 
		}
387 
		if(!rectclip(&r, dr))
388 
			panic("flresize");
389 
		if(r.max.x-r.min.x<100)
390 
			r.min.x = dr.min.x;
391 
		if(r.max.x-r.min.x<100)
392 
			r.max.x = dr.max.x;
393 
		if(r.max.y-r.min.y<2*FLMARGIN+f->font->height)
394 
			r.min.y = dr.min.y;
395 
		if(r.max.y-r.min.y<2*FLMARGIN+f->font->height)
396 
			r.max.y = dr.max.y;
397 
		if(!move)
398 
			l->visible = None;
399 
		frsetrects(f, insetrect(flrect(l, r), FLMARGIN), f->b);
400 
		if(!move && f->b)
401 
			scrdraw(l, scrtotal(l));
402 
	}
403 
	newvisibilities(1);
404 
}
405 
 
406 
int
407 
flprepare(Flayer *l)
408 
{
409 
	Frame *f;
410 
	ulong n;
411 
	Rune *r;
412 
 
413 
	if(l->visible == None)
414 
		return 0;
415 
	f = &l->f;
416 
	if(f->b == 0){
417 
		if(l->visible == All)
418 
			f->b = screen;
419 
		else if((f->b = allocimage(display, l->entire, screen->chan, 0, 0))==0)
420 
			return 0;
421 
		draw(f->b, l->entire, f->cols[BACK], nil, ZP);
422 
		border(f->b, l->entire, l==llist[0]? FLMARGIN : 1, f->cols[BORD], ZP);
423 
		n = f->nchars;
424 
		frinit(f, f->entire, f->font, f->b, 0);
425 
		f->maxtab = maxtab*stringwidth(f->font, "0");
426 
		if(f->maxtab == 0)
427 
			fontbuggered(f->font->name);
428 
		r = (*l->textfn)(l, n, &n);
429 
		frinsert(f, r, r+n, (ulong)0);
430 
		frdrawsel(f, frptofchar(f, f->p0), f->p0, f->p1, 0);
431 
		flfp0p1(l, &f->p0, &f->p1);
432 
		frdrawsel(f, frptofchar(f, f->p0), f->p0, f->p1, 1);
433 
		l->lastsr = ZR;
434 
		scrdraw(l, scrtotal(l));
435 
	}
436 
	return 1;
437 
}
438 
 
439 
static	int	somevis, someinvis, justvis;
440 
 
441 
Vis
442 
visibility(Flayer *l)
443 
{
444 
	somevis = someinvis = 0;
445 
	justvis = 1;
446 
	flrefresh(l, l->entire, 0);
447 
	justvis = 0;
448 
	if(somevis==0)
449 
		return None;
450 
	if(someinvis==0)
451 
		return All;
452 
	return Some;
453 
}
454 
 
455 
void
456 
flrefresh(Flayer *l, Rectangle r, int i)
457 
{
458 
	Flayer *t;
459 
	Rectangle s;
460 
 
461 
    Top:
462 
	if((t=llist[i++]) == l){
463 
		if(!justvis)
464 
			draw(screen, r, l->f.b, nil, r.min);
465 
		somevis = 1;
466 
	}else{
467 
		if(!rectXrect(t->entire, r))
468 
			goto Top;	/* avoid stacking unnecessarily */
469 
		if(t->entire.min.x>r.min.x){
470 
			s = r;
471 
			s.max.x = t->entire.min.x;
472 
			flrefresh(l, s, i);
473 
			r.min.x = t->entire.min.x;
474 
		}
475 
		if(t->entire.min.y>r.min.y){
476 
			s = r;
477 
			s.max.y = t->entire.min.y;
478 
			flrefresh(l, s, i);
479 
			r.min.y = t->entire.min.y;
480 
		}
481 
		if(t->entire.max.x<r.max.x){
482 
			s = r;
483 
			s.min.x = t->entire.max.x;
484 
			flrefresh(l, s, i);
485 
			r.max.x = t->entire.max.x;
486 
		}
487 
		if(t->entire.max.y<r.max.y){
488 
			s = r;
489 
			s.min.y = t->entire.max.y;
490 
			flrefresh(l, s, i);
491 
			r.max.y = t->entire.max.y;
492 
		}
493 
		/* remaining piece of r is blocked by t; forget about it */
494 
		someinvis = 1;
495 
	}
496 
}