Return to draw.c CVS log

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

Annotation of 43BSDTahoe/new/X/libapollo/draw.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char *rcsid_draw_c = "$Header: draw.c,v 10.1 86/11/29 13:51:24 jg Rel $";
                      3: #endif lint
                      4:     /*
                      5: 
                      6:     Copyright 1986 by the University of Utah
                      7: 
                      8:     Permission to use, copy, modify, and distribute this
                      9:     software and its documentation for any purpose and without
                     10:     fee is hereby granted, provided that the above copyright
                     11:     notice appear in all copies and that both that copyright
                     12:     notice and this permission notice appear in supporting
                     13:     documentation, and that the name of the University of Utah
                     14:     not be used in advertising or publicity pertaining to 
                     15:     distribution of the software without specific, written 
                     16:     prior permission. The University of Utah makes no
                     17:     representations about the suitability of this software for
                     18:     any purpose.  It is provided "as is" without express or
                     19:     implied warranty.
                     20: 
                     21:     */
                     22: 
                     23: /* draw.c      Draw lines, curves, and polygons on the screen
                     24:  *
                     25:  *     DrawCurve       Draw a generalized line/polygon/combination
                     26:  *
                     27:  */
                     28: 
                     29: /*
                     30:  *     ToDo:
                     31:  *             Brush shapes
                     32:  *              Patterned Curves
                     33:  *             Curves
                     34:  */
                     35: 
                     36: #include "Xapollo.h"
                     37: status_$t status;
                     38: 
                     39: static
                     40: Draw_Solid(srcpix, xbase, ybase, op, vertcount, verts, clipcount, clips, zmask)
                     41:     int srcpix;        /* Pixel value to write */
                     42:     int xbase, ybase;  /* Origin of curve */
                     43:     int op;            /* Opcode */
                     44:     int vertcount;     /* Length of Vertex array */
                     45:     Vertex *verts;     /* Vertices */
                     46:     int clipcount;     /* Length of clip array */
                     47:     CLIP *clips;       /* clipping rectangles */
                     48:     int zmask;
                     49: {
                     50:     register Vertex *v = verts;
                     51:     char *kind;
                     52:     int i;
                     53:     int allmask = -1;
                     54:     gpr_$window_t cwindow;
                     55: 
                     56:     gpr_$set_draw_value((gpr_$pixel_value_t)srcpix, status);
                     57:     set_zmask( zmask );
                     58:     set_op( op );
                     59:     do {
                     60:        register int xp, yp;
                     61:        register Vertex *v = verts;
                     62:        register int vc = vertcount;
                     63: 
                     64:         GetNextClip(clips, cwindow);
                     65:         CheckCursor(cwindow.x_coord, cwindow.y_coord,
                     66:                     cwindow.x_size, cwindow.y_size);
                     67:         gpr_$set_clip_window( cwindow, status);   
                     68:        do {
                     69: 
                     70:            if (v->flags & VertexRelative) {
                     71:                xp += v->x;
                     72:                yp += v->y;
                     73:              }
                     74:            else {
                     75:                xp = v->x + xbase;
                     76:                yp = v->y + ybase;
                     77:              }
                     78:            /* XXX - ignore VertexCurved for now */
                     79:            /* XXX - ignore VertexDrawLastPoint for now */
                     80: 
                     81:            if (v->flags & VertexDontDraw)
                     82:                gpr_$move((short)xp, (short)yp, status);
                     83:            else
                     84:                gpr_$line((short)xp, (short)yp, status);
                     85: 
                     86:            v++;
                     87:          } while (--vc > 0);
                     88:       } while (--clipcount > 0);
                     89:     RestoreCursor();   
                     90: }
                     91: 
                     92: DrawCurve (verts, vertcount, xbase, ybase, srcpix, altpix, mode,
                     93:           bwidth, bheight, pat, patlen, patmul, clips, clipcount, func, zmask)
                     94:        Vertex *verts;
                     95:        int vertcount, xbase, ybase, srcpix, altpix, mode, bwidth, bheight;
                     96:        int pat, patlen, patmul, clipcount, zmask;
                     97:        register int func;
                     98:        CLIP *clips;
                     99: {
                    100:     static gpr_$line_pattern_t pattern = {0, 0, 0, 0};
                    101:     int op = func;
                    102: 
                    103:     pattern[0] = pat; /* must invert bits ? */ 
                    104:     if (mode == DrawSolidLine) patlen = 0;
                    105:     gpr_$set_line_pattern((short)patmul, pattern, (short)patlen, status);
                    106:     if (bwidth == 1 && bheight == 1)
                    107:        switch (mode) {
                    108:        case DrawSolidLine:
                    109:            Draw_Solid(srcpix, xbase, ybase, op,
                    110:                       vertcount, verts, clipcount, clips, zmask);
                    111:            break;
                    112:        case DrawDashedLine:
                    113:            Draw_Solid(srcpix, xbase, ybase, op,
                    114:                       vertcount, verts, clipcount, clips, zmask);
                    115:            break;
                    116:        case DrawPatternedLine:
                    117:            Draw_Solid(srcpix, xbase, ybase, op,
                    118:                       vertcount, verts, clipcount, clips, zmask);
                    119:            break;
                    120:        }
                    121:     else
                    122:        switch (mode) {
                    123:            /* XXX - ignores brush specification for now */
                    124:        case DrawSolidLine:
                    125:            Draw_Solid(srcpix, xbase, ybase, op,
                    126:                       vertcount, verts, clipcount, clips, zmask);
                    127:            break;
                    128:        case DrawDashedLine:
                    129:            Draw_Solid(srcpix, xbase, ybase, op,
                    130:                       vertcount, verts, clipcount, clips, zmask);
                    131:            break;
                    132:        case DrawPatternedLine:
                    133:            Draw_Solid(srcpix, xbase, ybase, op,
                    134:                       vertcount, verts, clipcount, clips, zmask);
                    135:            break;
                    136:        }
                    137: 
                    138: }

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