xorg-server-1.4/afb/afbhrzvert.c

   1 /* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
   2 /***********************************************************
   3
   4 Copyright (c) 1987  X Consortium
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a copy
   7 of this software and associated documentation files (the "Software"), to deal
   8 in the Software without restriction, including without limitation the rights
   9 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 copies of the Software, and to permit persons to whom the Software is
  11 furnished to do so, subject to the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included in
  14 all copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  19 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  20 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23 Except as contained in this notice, the name of the X Consortium shall not be
  24 used in advertising or otherwise to promote the sale, use or other dealings
  25 in this Software without prior written authorization from the X Consortium.
  26
  27
  28 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  29
  30                         All Rights Reserved
  31
  32 Permission to use, copy, modify, and distribute this software and its
  33 documentation for any purpose and without fee is hereby granted,
  34 provided that the above copyright notice appear in all copies and that
  35 both that copyright notice and this permission notice appear in
  36 supporting documentation, and that the name of Digital not be
  37 used in advertising or publicity pertaining to distribution of the
  38 software without specific, written prior permission.
  39
  40 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  41 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  42 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  43 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  44 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  45 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  46 SOFTWARE.
  47
  48 ******************************************************************/
  49
  50 #ifdef HAVE_DIX_CONFIG_H
  51 #include <dix-config.h>
  52 #endif
  53
  54 #include <X11/X.h>
  55
  56 #include "gc.h"
  57 #include "window.h"
  58 #include "pixmap.h"
  59 #include "region.h"
  60
  61 #include "afb.h"
  62 #include "maskbits.h"
  63
  64 /* horizontal solid line
  65    abs(len) > 1
  66 */
  67 void
  68 afbHorzS(pbase, nlwidth, sizeDst, depthDst, x1, y1, len, rrops)
  69 PixelType *pbase;               /* pointer to base of bitmap */
  70 register int nlwidth;           /* width in longwords of bitmap */
  71 int sizeDst;
  72 int depthDst;
  73 int x1;                                         /* initial point */
  74 int y1;
  75 int len;                                /* length of line */
  76 register unsigned char *rrops;
  77 {
  78         register PixelType *addrl;
  79         register PixelType startmask;
  80         register PixelType endmask;
  81         register int nlmiddle;
  82         register int d;
  83         int saveNLmiddle;
  84
  85         /* force the line to go left to right
  86            but don't draw the last point
  87         */
  88         if (len < 0) {
  89                 x1 += len;
  90                 x1 += 1;
  91                 len = -len;
  92         }
  93
  94         /* all bits inside same longword */
  95         if ( ((x1 & PIM) + len) < PPW) {
  96                 maskpartialbits(x1, len, startmask);
  97
  98                 for (d = 0; d < depthDst; d++) {
  99                         addrl = afbScanline(pbase, x1, y1, nlwidth);
 100                         pbase += sizeDst;       /* @@@ NEXT PLANE @@@ */
 101
 102                         switch (rrops[d]) {
 103                                 case RROP_BLACK:
 104                                         *addrl &= ~startmask;
 105                                         break;
 106                                 case RROP_WHITE:
 107                                         *addrl |= startmask;
 108                                         break;
 109                                 case RROP_INVERT:
 110                                         *addrl ^= startmask;
 111                                         break;
 112                                 case RROP_NOP:
 113                                         break;
 114                         } /* switch */
 115                 } /* for (d = ...) */
 116         } else {
 117                 maskbits(x1, len, startmask, endmask, nlmiddle);
 118                 saveNLmiddle = nlmiddle;
 119
 120                 for (d = 0; d < depthDst; d++) {
 121                         addrl = afbScanline(pbase, x1, y1, nlwidth);
 122                         pbase += sizeDst;       /* @@@ NEXT PLANE @@@ */
 123                         nlmiddle = saveNLmiddle;
 124
 125                         switch (rrops[d]) {
 126                                 case RROP_BLACK:
 127                                         if (startmask)
 128                                                 *addrl++ &= ~startmask;
 129                                         Duff (nlmiddle, *addrl++ = 0x0);
 130                                         if (endmask)
 131                                                 *addrl &= ~endmask;
 132                                         break;
 133
 134                                 case RROP_WHITE:
 135                                         if (startmask)
 136                                                 *addrl++ |= startmask;
 137                                         Duff (nlmiddle, *addrl++ = ~0);
 138                                         if (endmask)
 139                                                 *addrl |= endmask;
 140                                         break;
 141
 142                                 case RROP_INVERT:
 143                                         if (startmask)
 144                                                 *addrl++ ^= startmask;
 145                                         Duff (nlmiddle, *addrl++ ^= ~0);
 146                                         if (endmask)
 147                                                 *addrl ^= endmask;
 148                                         break;
 149
 150                                 case RROP_NOP:
 151                                         break;
 152                         } /* switch */
 153                 } /* for (d = ... ) */
 154         }
 155 }
 156
 157 /* vertical solid line
 158    this uses do loops because pcc (Ultrix 1.2, bsd 4.2) generates
 159    better code.  sigh.  we know that len will never be 0 or 1, so
 160    it's OK to use it.
 161 */
 162 void
 163 afbVertS(pbase, nlwidth, sizeDst, depthDst, x1, y1, len, rrops)
 164 PixelType *pbase;               /* pointer to base of bitmap */
 165 register int nlwidth;           /* width in longwords of bitmap */
 166 int sizeDst;
 167 int depthDst;
 168 int x1, y1;                             /* initial point */
 169 register int len;               /* length of line */
 170 unsigned char *rrops;
 171 {
 172         register PixelType *addrl;
 173         register PixelType bitmask;
 174         int saveLen;
 175         int d;
 176
 177         if (len < 0) {
 178                 nlwidth = -nlwidth;
 179                 len = -len;
 180         }
 181
 182         saveLen = len;
 183
 184         for (d = 0; d < depthDst; d++) {
 185                 addrl = afbScanline(pbase, x1, y1, nlwidth);
 186                 pbase += sizeDst;       /* @@@ NEXT PLANE @@@ */
 187                 len = saveLen;
 188
 189                 switch (rrops[d]) {
 190                         case RROP_BLACK:
 191                                 bitmask = mfbGetrmask(x1 & PIM);
 192                                 Duff(len, *addrl &= bitmask; afbScanlineInc(addrl, nlwidth) );
 193                                 break;
 194
 195                         case RROP_WHITE:
 196                                 bitmask = mfbGetmask(x1 & PIM);
 197                                 Duff(len, *addrl |= bitmask; afbScanlineInc(addrl, nlwidth) );
 198                                 break;
 199
 200                         case RROP_INVERT:
 201                                 bitmask = mfbGetmask(x1 & PIM);
 202                                 Duff(len, *addrl ^= bitmask; afbScanlineInc(addrl, nlwidth) );
 203                                 break;
 204
 205                         case RROP_NOP:
 206                                 break;
 207                 } /* switch */
 208         } /* for (d = ...) */
 209 }