Return to hide.c CVS log

Up to [Research Unix] / researchv10no / cmd / view2d

Annotation of researchv10no/cmd/view2d/hide.c, revision 1.1

1.1     ! root        1: #include       <jerq.h>
        !             2: 
        !             3: #define                ONE             512
        !             4: 
        !             5: Point buf1[128], buf2[128], *old = buf2, *new = buf1;
        !             6: 
        !             7: jdraw(b)
        !             8:        Bitmap *b;
        !             9: {
        !            10: }
        !            11: #ifdef AGH
        !            12: /*
        !            13:        for(j = nx+ny-3; j > 0; j--)
        !            14:        {
        !            15:                y = min(ny-1, j);
        !            16:                lasty = x = j-y;
        !            17:                while(y != lasty)
        !            18:                {
        !            19:                        POLY(x, y, x, y-1, x+1, y-1, x+1, y);
        !            20:                        x++;
        !            21:                        y--;
        !            22:                }
        !            23:                wait(CPU);
        !            24:        }
        !            25: */
        !            26:        Point left, right, p, *np, *op;
        !            27:        int wleft;
        !            28: 
        !            29:        old[0].y = -1;
        !            30:        np = new;
        !            31:        op = old;
        !            32:        nextpt(np++);
        !            33:        nextpt(np++);
        !            34:        left = np[-1];
        !            35:        segment(b, new[0], new[1], F_OR);
        !            36: 
        !            37:        while(nextpt(&right))
        !            38:        {
        !            39:                if(left.x > right.x)
        !            40:                {
        !            41:                        left = right;
        !            42:                        np->y = -1;
        !            43:                        np = old; old = new; new = np; op = old;
        !            44:                        continue;
        !            45:                }
        !            46:                if(left.x < op->x)
        !            47:                {
        !            48:                        *np++ = left;
        !            49:                        *np++ = right;
        !            50:                        segment(b, left, right, F_OR);
        !            51:                }
        !            52:                else if(left.x > op->x)
        !            53:                        *np++ = *op++;
        !            54:                else
        !            55:                {
        !            56:                        
        !            57:                }
        !            58:                left = right;
        !            59:        }
        !            60: }
        !            61: 
        !            62: addseg(b, l, ls, r, rs)
        !            63:        Bitmap *b;
        !            64:        Point l, r;
        !            65:        register Segment *ls, *rs;
        !            66: {
        !            67:        register Segment *s;
        !            68: 
        !            69:        if(l.x != ls->l.x)
        !            70:        {
        !            71:                s = newseg(l, ls->r);
        !            72:                ls->r = l;
        !            73:                s->next = ls->next;
        !            74:                ls->next = s;
        !            75:                if(ls == rs) rs = s;
        !            76:        }
        !            77:        else
        !            78:                ls->l.y = l.y;
        !            79:        recalc(ls);
        !            80:        if(r.x != rs->r.x)
        !            81:        {
        !            82:                s = newseg(r, rs->r);
        !            83:                rs->r = r;
        !            84:                s->next = rs->next;
        !            85:                rs->next = s;
        !            86:        }
        !            87:        else
        !            88:                rs->r.y = r.y;
        !            89:        recalc(rs);
        !            90:        segment(b, l, r, F_OR);
        !            91: }
        !            92: 
        !            93: static Segment *
        !            94: newseg(l, r)
        !            95:        Point l, r;
        !            96: {
        !            97:        register Segment *s;
        !            98: 
        !            99:        s = (Segment *)alloc(sizeof *s);
        !           100:        s->next = 0;
        !           101:        s->l = l;
        !           102:        s->r = r;
        !           103:        recalc(s);
        !           104:        return(s);
        !           105: }
        !           106: 
        !           107: recalc(s)
        !           108:        register Segment *s;
        !           109: {
        !           110:        s->m = muldiv(s->r.y-s->l.y, ONE, s->r.x-s->l.x);
        !           111:        s->b = s->l.y - muldiv(s->m, s->l.x, ONE);
        !           112: }
        !           113: 
        !           114: crosses(s, l, r, p)
        !           115:        Segment *s;
        !           116:        Point l, r, *p;
        !           117: {
        !           118:        register m, b;
        !           119: 
        !           120:        m = muldiv(r.y-l.y, ONE, r.x-l.x);
        !           121:        if(m == s->m) return(0);
        !           122:        b = l.y - s->m*l.x;
        !           123:        p->x = muldiv(s->b-b, ONE, m-s->m);
        !           124:        p->y = m*p->x + b;
        !           125:        return((p->x >= s->l.x) && (p->x <= s->r.x) && (p->x >= l.x) && (p->x <= r.x));
        !           126: }
        !           127: 
        !           128: ptrels(p, s)
        !           129:        Point p;
        !           130:        Segment *s;
        !           131: {
        !           132:        register Segment *s;
        !           133: 
        !           134:        if((s->l.y < 0) || (s->r.y < 0)) return(1);
        !           135:        return((muldiv(s->m, p.x, ONE)+s->b) - p.y);
        !           136: }
        !           137: #endif

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