Return to draw.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libis

Annotation of 43BSDTahoe/new/X/libis/draw.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     $Source: /u1/X/libis/RCS/draw.c,v $
        !             3:  *     $Header: draw.c,v 1.1 86/11/17 14:33:49 swick Rel $
        !             4:  */
        !             5: 
        !             6: #ifndef lint
        !             7: static char *rcsid_draw_c = "$Header: draw.c,v 1.1 86/11/17 14:33:49 swick Rel $";
        !             8: #endif lint
        !             9: 
        !            10: #include "is-copyright.h"
        !            11: 
        !            12: /*     draw.c          Draw lines, curves, and polygons on the screen
        !            13:  *
        !            14:  *     DrawCurve       Draw a generalized line/polygon/combination
        !            15:  *
        !            16:  *     Copyright (c) 1986, Integrated Solutions, Inc.
        !            17:  */
        !            18: 
        !            19: /*
        !            20:  *     ToDo:
        !            21:  *             Dash/Pattern
        !            22:  *             Curves
        !            23:  */
        !            24: 
        !            25: #include "Xis.h"
        !            26: 
        !            27: #define        imin(i,j)       ((i)<(j)?(i):(j))
        !            28: #define        imax(i,j)       ((i)>(j)?(i):(j))
        !            29: 
        !            30: static
        !            31: Draw_Solid(srcpix, xbase, ybase, func, vertcount, verts, clipcount, clips, zmask, bwidth, bheight)
        !            32: int    srcpix;         /* Pixel value to write */
        !            33: int    xbase, ybase;   /* Origin of curve */
        !            34: int    func;           /* Opcode */
        !            35: int    vertcount;      /* Length of Vertex array */
        !            36: Vertex *verts;         /* Vertices */
        !            37: int    clipcount;      /* Length of clip array */
        !            38: CLIP   *clips;         /* clipping rectangles */
        !            39: int    zmask;          /* plane mask */
        !            40: int    bwidth, bheight;/* brush width and height */
        !            41: {
        !            42:     PIXMAP *fillpix;
        !            43:     extern PIXMAP *MakePixmap();
        !            44: 
        !            45:     fillpix = MakePixmap((BITMAP *)NULL, srcpix, 0);
        !            46:     do {       /* for each clipping region */
        !            47:        register int xp, yp;
        !            48:        register Vertex *v = verts;
        !            49:        register int vc = vertcount;
        !            50: 
        !            51:        do {    /* for each vertex */
        !            52:            register    xo = xp, yo = yp;
        !            53:            /* first vertex is always VertexDontDraw and !VertexRelative */
        !            54:            /* xo,yo do not matter and xp,yp get initialized first time */
        !            55: 
        !            56:            if (v->flags & VertexRelative) {
        !            57:                xp += v->x;
        !            58:                yp += v->y;
        !            59:            } else {
        !            60:                xp = v->x + xbase;
        !            61:                yp = v->y + ybase;
        !            62:            }
        !            63:            /* XXX - ignore VertexCurved for now */
        !            64:            /* XXX - ignore VertexDrawLastPoint for now */
        !            65:            if (!(v->flags & VertexDontDraw)) {
        !            66:                CLIP bounds;
        !            67: 
        !            68:                /* bounding rectangle of two points */
        !            69:                bounds.top = imin(yo, yp);
        !            70:                bounds.left = imin(xo, xp);
        !            71:                bounds.width = imax(xo, xp) + bwidth - bounds.left;
        !            72:                bounds.height = imax(yo, yp) + bheight - bounds.top;
        !            73: 
        !            74:                if (Overlap(bounds, clips[clipcount-1])) {
        !            75:                    /* vector at least partly visible */
        !            76:                    CLIP i;
        !            77:                    i = Intersection(clips[clipcount-1], bounds);
        !            78:                    CheckCursor(i);
        !            79:                    if ((xo == xp) || (yo == yp)) {
        !            80:                        /* horizontal or vertical vector */
        !            81:                        GIP_RasterOp((unsigned char)func,
        !            82:                            fillpix, 0, 0,
        !            83:                            &ScreenPixmap, i.left, i.top,
        !            84:                            (BITMAP *)0, 0, 0,
        !            85:                            i.width, i.height, zmask);
        !            86:                    } else {
        !            87:                        /* non-horizontal and non-vertical vector */
        !            88:                        GIP_Vector((unsigned char)func,
        !            89:                            fillpix, 0, 0,
        !            90:                            &ScreenPixmap, xo, yo, xp, yp,
        !            91:                            i.left, i.top, i.left+i.width-1, i.top+i.height-1,
        !            92:                            bwidth, bheight, zmask);
        !            93:                    }
        !            94:                }
        !            95:            }
        !            96:            v++;
        !            97:        } while (--vc > 0);
        !            98:     } while (--clipcount > 0);
        !            99:     if (!--fillpix->refcnt)
        !           100:        FreePixmap (fillpix);
        !           101:     RestoreCursor();
        !           102: }
        !           103: 
        !           104: DrawCurve(verts, vertcount, xbase, ybase, srcpix, altpix, mode,
        !           105:           bwidth, bheight, pat, patlen, patmul, clips, clipcount, func, zmask)
        !           106: Vertex *verts;
        !           107: int    vertcount, xbase, ybase, srcpix, altpix, mode, bwidth, bheight;
        !           108: int    pat, patlen, patmul, clipcount, func, zmask;
        !           109: CLIP   *clips;
        !           110: {
        !           111: 
        !           112: #ifdef DEBUG
        !           113: if (debug & D_DrawCurve)
        !           114:     printf("DrawCurve(verts=0x%x, vertcount=%d, xbase=%d, ybase=%d,\n  srcpix=%d, altpix=%d, mode=%d, bwidth=%d, bheight=%d\n  pat=%d, patlen=%d, patmul=%d\n  clips=0x%x, clipcount=%d, func=%d, zmask=0x%04x)\n",
        !           115:        verts, vertcount, xbase, ybase, srcpix, altpix, mode, bwidth, bheight,
        !           116:        pat, patlen, patmul, clips, clipcount, func, zmask);
        !           117: #endif DEBUG
        !           118: 
        !           119:     switch (mode) { /* XXX - ignores dash/pattern for now */
        !           120:     case DrawSolidLine:
        !           121:        Draw_Solid(srcpix, xbase, ybase, func, vertcount, verts,
        !           122:                    clipcount, clips, zmask, bwidth, bheight);
        !           123:        break;
        !           124:     case DrawDashedLine:
        !           125:        Draw_Solid(srcpix, xbase, ybase, func, vertcount, verts,
        !           126:                    clipcount, clips, zmask, bwidth, bheight);
        !           127:        break;
        !           128:     case DrawPatternedLine:
        !           129:        Draw_Solid(srcpix, xbase, ybase, func, vertcount, verts,
        !           130:                    clipcount, clips, zmask, bwidth, bheight);
        !           131:        break;
        !           132:     }
        !           133: }

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