Return to ddxput.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / libqvss

Annotation of 43BSD/contrib/X/libqvss/ddxput.c, revision 1.1

1.1     ! root        1: /* Copyright 1985, Massachusetts Institute of Technology */
        !             2: 
        !             3: /* put.c       Perform a raster operation with a source bitmap
        !             4:  *
        !             5:  *     PixmapPut       Puts a pixmap up on the screen
        !             6:  *     PixmapBitsPut   Puts a pixmap up on the screen
        !             7:  *     BitmapBitsPut   Puts a pixmap up on the screen
        !             8:  *
        !             9:  * Modification History:
        !            10:  *
        !            11:  *   Carver 8601.13 Added extern statement for SSmap
        !            12:  *
        !            13:  *   Carver 8601.06 Added line to PixmapPut to adjust the func to compensate
        !            14:  *                 for the reverse flag being set in the pixmap descriptor.
        !            15:  *
        !            16:  *   Carver 8510.10 Put in support for source bitmap/sub-bitmap mask
        !            17:  *                 copy areas.
        !            18:  *
        !            19:  *   Carver 8510.09 In PixmapBitsPut fixed the table lookup on foreground
        !            20:  *                 and background.
        !            21:  */
        !            22: 
        !            23: #include "ddxqvss.h"
        !            24: #include "vstagbl.h"
        !            25: 
        !            26: extern BITMAP pbm;
        !            27: 
        !            28: PixmapPut (src, srcx, srcy, width, height, dstx, dsty, clips, clipcount,
        !            29:           func, zmask)
        !            30:        register PIXMAP *src;
        !            31:        int srcx, srcy, width, height, dstx, dsty, clipcount, zmask;
        !            32:        register int func;
        !            33:        CLIP *clips;
        !            34: {
        !            35:        BITMAP *bm = (BITMAP *) src->data;
        !            36:        extern char SSMap[];
        !            37: 
        !            38:        if (!(zmask & 1))  return;
        !            39: 
        !            40:        /* ADJUST MAP FOR REVERSE PIXMAP */
        !            41: 
        !            42:        func = SSMap[ func | (src->kind & InvertFlag)];
        !            43: 
        !            44:        copyrmsk( VSTA$K_SRC_BITMAP, (short *)bm->data, bm->width, bm->height,
        !            45:                srcx, srcy, width, height, 
        !            46:                (short *)pbm.data, pbm.width, pbm.height,
        !            47:                dstx, dsty, func, clipcount, clips);
        !            48:        return;
        !            49: }
        !            50: 
        !            51: 
        !            52: /*ARGSUSED*/
        !            53: PixmapBitsPut (width, height, format, data, xymask, dstx, dsty,
        !            54:               clips, clipcount, func, zmask)
        !            55:        char *data;
        !            56:        int width, height, format, dstx, dsty, clipcount, zmask;
        !            57:        BITMAP *xymask;
        !            58:        CLIP *clips;
        !            59:        int func;
        !            60: {
        !            61:        BitmapBitsPut (width, height, data, 1, 0, xymask, dstx, dsty,
        !            62:                       clips, clipcount, func, zmask);
        !            63: }
        !            64: 
        !            65: 
        !            66: BitmapBitsPut (width, height, data, fore, back, xymask, dstx, dsty,
        !            67:               clips, clipcount, func, zmask)
        !            68:        char *data;
        !            69:        int width, height, fore, back, dstx, dsty, clipcount, zmask;
        !            70:        register BITMAP *xymask;
        !            71:        CLIP *clips;
        !            72:        register int func;
        !            73: {
        !            74:        int mask_x = pbm.width, mask_y = pbm.height;
        !            75:        extern char FBMap[];
        !            76: 
        !            77:        if (!(zmask & 1))  return;
        !            78: 
        !            79:        /* USE FBMap TABLE TO CONVERT FORE/BACK INTO A SINGLE SOURCE
        !            80:           MAPPING FUNCTION */
        !            81: 
        !            82:        if (fore & 1) func += 0x20;
        !            83:        if (back & 1) func += 0x10;
        !            84: 
        !            85:        func = FBMap[func];
        !            86: 
        !            87:        if (xymask == NULL) 
        !            88:                {
        !            89:                copyrmsk (VSTA$K_SRC_BITMAP, (short *) data, width, height,
        !            90:                          0, 0, mask_x, mask_y, (short *) pbm.data, pbm.width,
        !            91:                          pbm.height, dstx, dsty, func, clipcount, clips);
        !            92:                }
        !            93:        else
        !            94:                {
        !            95:                        
        !            96:                copybmsk (
        !            97:                        VSTA$K_SRC_BITMAP, (short *)data, width, height, 
        !            98:                        0, 0, 
        !            99:                        (short *) xymask->data, xymask->width, xymask->height,
        !           100:                        0, 0, width, height,
        !           101:                        (short *)pbm.data, pbm.width, pbm.height,
        !           102:                        dstx, dsty, func, clipcount, clips);
        !           103:                };
        !           104: 
        !           105: 
        !           106: 
        !           107:        return;
        !           108: }

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