Return to copy.c CVS log

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

Annotation of 43BSDTahoe/new/X/libibm/libsrc/copy.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char *rcsid_copy_c = "$Header: copy.c,v 10.1 86/11/19 10:40:31 jg Exp $";
                      3: #endif lint
                      4: /* copy.c - Copy one rectangular section of the screen buffer to another
                      5:  *
                      6:  *      CopyArea        Copies a rectangular section of the screen buffer
                      7:  *
                      8:  *     Author:
                      9:  *             Scott Bates
                     10:  *             Brown University
                     11:  *             IRIS, Box 1946
                     12:  *             Providence, RI 02912
                     13:  *
                     14:  *
                     15:  *             Copyright (c) 1986 Brown University
                     16:  *
                     17:  * Permission to use, copy, modify and distribute this software and its
                     18:  * documentation for any purpose and without fee is hereby granted, provided
                     19:  * that the above copyright notice appear in all copies, and that both
                     20:  * that copyright notice and this permission notice appear in supporting
                     21:  * documentation, and that the name of Brown University not be used in
                     22:  * advertising or publicity pertaining to distribution of the software
                     23:  * without specific, written prior permission. Brown University makes no
                     24:  * representations about the suitability of this software for any purpose.
                     25:  * It is provided "as-is" without express or implied warranty.
                     26:  */
                     27: 
                     28: #include "private.h"
                     29: #include "bitblt.h"
                     30: 
                     31: /*
                     32:  * Screen to screen copy
                     33:  */
                     34: 
                     35: CopyArea (srcx, srcy, width, height, dstx, dsty, clips, clipcount, func, zmask)
                     36:         register srcx, srcy, dstx, dsty;
                     37:        int clipcount, zmask, func;
                     38:        int width, height; 
                     39:         CLIP *clips;
                     40: {
                     41:        register Blt_Rectangle *source = &SrcRect;
                     42:        register Blt_Rectangle *dest = &DstRect;
                     43: 
                     44: #ifdef TRACE_X
                     45:        fprintf(stderr, "In CopyArea\n");
                     46:        fflush(stderr);
                     47: #endif TRACE_X
                     48: 
                     49:        /*
                     50:         * Limit copy to one plane
                     51:         */
                     52: 
                     53:         if ((zmask & 1) == 0)
                     54:                return;
                     55: 
                     56:        /*
                     57:         * Fill in source and destination rectangles
                     58:         */
                     59: 
                     60:         FillInRect(srcx, srcy, width, height, source);
                     61:         FillInRect(dstx, dsty, width, height, dest);
                     62: 
                     63:        /*
                     64:         * Copy screen source to screen destination
                     65:         */
                     66: 
                     67:         CopyBits((u_short *) pbm.data, pbm.width, pbm.height, source,
                     68:                  (u_short *) pbm.data, pbm.width, pbm.height, dest,
                     69:                 NILMASK, NIL, NIL, func, clipcount, clips);
                     70: }

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