Return to pot.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / pot

Annotation of researchv9/jerq/src/lib/pot/pot.c, revision 1.1.1.1

1.1       root        1: #include       <CC/jerq.h>
                      2: #include       "pot.pri"
                      3: 
                      4: Pot *base = 0;
                      5: 
                      6: Pot.Pot(Rectangle rect, short fl, short v)
                      7: {
                      8:        r = rect;
                      9:        flags = fl&P_MASK;
                     10:        val = v;
                     11:        help = "";
                     12:        next = base;
                     13:        base = this;
                     14: }
                     15: 
                     16: void
                     17: Pot.draw()
                     18: {
                     19:        rectf(&display, r, F_OR);
                     20: }
                     21: 
                     22: void
                     23: Pot.mod(int i)
                     24: {
                     25:        rectf(&display, r, F_OR);
                     26:        i++;    /* shut CC up */
                     27: }
                     28: 
                     29: void
                     30: Pot.resize(Rectangle rect)
                     31: {
                     32:        r = rect;
                     33: }
                     34: 
                     35: hitpot(int but)
                     36: {
                     37:        register Pot *pot;
                     38:        Point p;
                     39: 
                     40:        p = mouse.xy;
                     41:        for(pot = base; pot; pot = pot->next)
                     42:                if(ptinrect(p, inset(pot->r, -25))) break;
                     43:        if(pot == 0) return(0);
                     44:        pot->mod(but);
                     45:        return(1);
                     46: }
                     47: 
                     48: void
                     49: helppot(int but)
                     50: {
                     51:        register Pot *pot;
                     52:        Point p;
                     53: 
                     54:        p = mouse.xy;
                     55:        for(pot = base; pot; pot = pot->next)
                     56:                if(ptinrect(p, inset(pot->r, -25))) break;
                     57:        if(pot && pot->help && pot->help[0])
                     58:        {
                     59:                int x = strwidth(&defont, pot->help);
                     60:                Bitmap *b;
                     61: 
                     62:                if((p.x = pot->r.o.x-x-100) > 0)
                     63:                        p.y = (pot->r.o.y+pot->r.c.y)/2-7;
                     64:                else if((p.x = pot->r.c.x+100)+x < XMAX)
                     65:                        p.y = (pot->r.o.y+pot->r.c.y)/2-7;
                     66:                if(b = balloc(raddp(Rect(0, 0, x+6, 20), p)))
                     67:                {
                     68:                        rectf(b, b->rect, F_OR);
                     69:                        rectf(b, inset(b->rect, 1), F_CLR);
                     70:                        string(&defont, pot->help, b, add(b->rect.o, Pt(3, 3)), F_OR);
                     71:                        screenswap(b, b->rect, b->rect);
                     72:                        while(button(but)) nap(2);
                     73:                        screenswap(b, b->rect, b->rect);
                     74:                        bfree(b);
                     75:                }
                     76:        }
                     77: }
                     78: 
                     79: void
                     80: drawpot()
                     81: {
                     82:        register Pot *pot;
                     83: 
                     84:        for(pot = base; pot; pot = pot->next)
                     85:                pot->draw();
                     86: }
                     87: 
                     88: void
                     89: reshapepot(Rectangle oldr, Rectangle newr)
                     90: {
                     91:        register Pot *pot;
                     92:        Rectangle r;
                     93:        Point o = oldr.c-oldr.o, n = newr.c-newr.o;
                     94: 
                     95:        for(pot = base; pot; pot = pot->next)
                     96:        {
                     97:                r.o.x = muldiv(pot->r.o.x-oldr.o.x, n.x, o.x);
                     98:                r.o.y = muldiv(pot->r.o.y-oldr.o.y, n.y, o.y);
                     99:                r.c.x = muldiv(pot->r.c.x-oldr.o.x, n.x, o.x);
                    100:                r.c.y = muldiv(pot->r.c.y-oldr.o.y, n.y, o.y);
                    101:                pot->resize(r);
                    102:        }
                    103: }
                    104: 
                    105: void
                    106: prval(Point p, short v)
                    107: {
                    108:        char buf[20];
                    109: 
                    110:        sprintf(buf, "%d", v);
                    111:        string(&defont, buf, &display, p, F_XOR);
                    112: }
                    113: 
                    114: Rectangle
                    115: rcenter(Rectangle r, Rectangle q)
                    116: {
                    117:        Point qc = div(add(q.o, q.c), 2);
                    118:        Point rc = div(add(r.o, r.c), 2);
                    119: 
                    120:        return(raddp(r, sub(qc, rc)));
                    121: }
                    122: 
                    123: extern void
                    124: bord(Bitmap *bp, Rectangle r, int i, int c)
                    125: {
                    126:        rectf(bp, Rectangle(r.o.x, r.o.y, r.c.x, r.o.y+i), c);
                    127:        rectf(bp, Rect(r.o.x, r.o.y+i, r.o.x+i, r.c.y-i), c);
                    128:        rectf(bp, Rect(r.c.x-i, r.o.y+i, r.c.x, r.c.y-i), c);
                    129:        rectf(bp, Rect(r.o.x, r.c.y-1, r.c.x, r.c.y), c);
                    130: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.