Return to ddxfill.c CVS log

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

Annotation of 43BSDTahoe/new/X/libqvss/ddxfill.c, revision 1.1

1.1     ! root        1: /* fill.c      Perform a simple raster operation a section of the screen
        !             2:  *
        !             3:  *     PixFill         Do a function on the screen
        !             4:  *     StippleFill     Fill rectangle with a stipple pattern
        !             5:  *
        !             6:  *     Modification History
        !             7:  *
        !             8:  *     Carver 8510.25 Removed error checking in calls to copyrmsk
        !             9:  *                    and copybmsk.  No errors are ever return.
        !            10:  *
        !            11:  */
        !            12: 
        !            13: #include "ddxqvss.h"
        !            14: #include "qvss.h"
        !            15: #include "vstagbl.h"
        !            16: 
        !            17: extern BITMAP pbm;
        !            18: 
        !            19: /*ARGSUSED*/
        !            20: PixFill (srcpix, xymask, dstx, dsty, width, height, clips, clipcount,
        !            21:         func, zmask)
        !            22:        int srcpix, dstx, dsty, width, height, clipcount, zmask;
        !            23:        register BITMAP *xymask;
        !            24:        register int func;
        !            25:        CLIP *clips;
        !            26: {
        !            27:        int constant = srcpix & 1;
        !            28: 
        !            29:        if (!(zmask & 1)) {
        !            30:            return;
        !            31:        }
        !            32:        if (xymask == 0)
        !            33:          {
        !            34:          copyrmsk (VSTA$K_SRC_CONST, constant, 0, 0, 0, 0,
        !            35:                          width, height, (short *) pbm.data,
        !            36:                          pbm.width, pbm.height, dstx, dsty, func,
        !            37:                          clipcount, clips);
        !            38:          return;
        !            39:          }
        !            40: 
        !            41:        copybmsk (VSTA$K_SRC_CONST, constant, 0, 0, 0, 0,
        !            42:                        (short *) xymask->data, xymask->width, 
        !            43:                        xymask->height, 0, 0, width, height, 
        !            44:                        (short *) pbm.data,
        !            45:                        pbm.width, pbm.height, dstx, dsty, func,
        !            46:                        clipcount, clips);
        !            47:        return;
        !            48: }
        !            49: 
        !            50: extern int errno;
        !            51: #include <errno.h>
        !            52: 
        !            53: int StippleFill (srcpix, xoff, yoff, stipmask, dstx, dsty, width, height,
        !            54:        clips, clipcount, func, zmask)
        !            55:        int srcpix;             /* source pixel */
        !            56:        int xoff, yoff;         /* stipple origin */
        !            57:        BITMAP *stipmask;       /* stipple mask */
        !            58:        int dstx, dsty;         /* destination */
        !            59:        int width, height;
        !            60:        CLIP *clips;            /* clipping rectangles */
        !            61:        int clipcount;
        !            62:        int func;               /* GX display function */
        !            63:        int zmask;              /* plane mask */
        !            64: {
        !            65:        static char funcmap[16][2] = {
        !            66:                {GXandInverted, GXandInverted}, /* GXclear */
        !            67:                {GXandInverted, GXnoop},        /* GXand */
        !            68:                {GXandInverted, GXxor},         /* GXandReverse */
        !            69:                {GXandInverted, GXor},          /* GXcopy */
        !            70:                {GXnoop,        GXandInverted}, /* GXandInverted */
        !            71:                {GXnoop,        GXnoop},        /* GXnoop */
        !            72:                {GXnoop,        GXxor},         /* GXxor */
        !            73:                {GXnoop,        GXor},          /* GXor */
        !            74:                {GXxor,         GXandInverted}, /* GXnor */
        !            75:                {GXxor,         GXnoop},        /* GXequiv */
        !            76:                {GXxor,         GXxor},         /* GXinvert */
        !            77:                {GXxor,         GXor},          /* GXorReverse */
        !            78:                {GXor,          GXandInverted}, /* GXcopyInverted */
        !            79:                {GXor,          GXnoop},        /* GXorInverted */
        !            80:                {GXor,          GXxor},         /* GXnand */
        !            81:                {GXor,          GXor}           /* GXset */
        !            82:        };
        !            83:        int newfunc = funcmap [func][srcpix & 1];
        !            84:                
        !            85:        if (!(zmask & 1)) {
        !            86:            return (1);
        !            87:        }
        !            88:        if ((stipmask->width != 16) || (stipmask->height != 16)) {
        !            89:                errno = EINVAL;
        !            90:                return (0);
        !            91:        }
        !            92:        copyrmsk (VSTA$K_SRC_HT_BITMAP, (short *)stipmask->data, 
        !            93:                stipmask->width, stipmask->height, xoff, yoff,
        !            94:                width, height,
        !            95:                (short *)pbm.data, pbm.width, pbm.height,
        !            96:                dstx, dsty, newfunc, clipcount, clips);
        !            97:        return (1);
        !            98: }

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