home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / server / ddx / cfb / cfbsolid.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-11  |  6.6 KB  |  291 lines
  1. /*
  2.  * $XConsortium: cfbsolid.c,v 1.5 91/07/11 21:48:24 keith Exp $
  3.  *
  4.  * Copyright 1990 Massachusetts Institute of Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of M.I.T. not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  M.I.T. makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  *
  23.  * Author:  Keith Packard, MIT X Consortium
  24.  */
  25.  
  26.  
  27. #include "X.h"
  28. #include "Xmd.h"
  29. #include "servermd.h"
  30. #include "gcstruct.h"
  31. #include "window.h"
  32. #include "pixmapstr.h"
  33. #include "scrnintstr.h"
  34. #include "windowstr.h"
  35.  
  36. #include "cfb.h"
  37. #include "cfbmskbits.h"
  38. #include "cfbrrop.h"
  39.  
  40. #if defined(FAST_CONSTANT_OFFSET_MODE) && (RROP != GXcopy)
  41. # define Expand(left,right,leftAdjust) {\
  42.     int part = nmiddle & 3; \
  43.     int widthStep; \
  44.     widthStep = widthDst - nmiddle - leftAdjust; \
  45.     nmiddle >>= 2; \
  46.     pdst = pdstRect; \
  47.     while (h--) { \
  48.     left \
  49.     pdst += part; \
  50.     switch (part) { \
  51.         RROP_UNROLL_CASE3(pdst) \
  52.     } \
  53.     m = nmiddle; \
  54.     while (m) { \
  55.         pdst += 4; \
  56.         RROP_UNROLL_LOOP4(pdst,-4) \
  57.         m--; \
  58.     } \
  59.     right \
  60.     pdst += widthStep; \
  61.     } \
  62. }
  63. #else
  64. # ifdef RROP_UNROLL
  65. #  define Expand(left,right,leftAdjust) {\
  66.     int part = nmiddle & RROP_UNROLL_MASK; \
  67.     int widthStep; \
  68.     widthStep = widthDst - nmiddle - leftAdjust; \
  69.     nmiddle >>= RROP_UNROLL_SHIFT; \
  70.     pdst = pdstRect; \
  71.     while (h--) { \
  72.     left \
  73.     pdst += part; \
  74.     switch (part) { \
  75.         RROP_UNROLL_CASE(pdst) \
  76.     } \
  77.     m = nmiddle; \
  78.     while (m) { \
  79.         pdst += RROP_UNROLL; \
  80.         RROP_UNROLL_LOOP(pdst) \
  81.         m--; \
  82.     } \
  83.     right \
  84.     pdst += widthStep; \
  85.     } \
  86. }
  87.  
  88. # else
  89. #  define Expand(left, right, leftAdjust) { \
  90.     while (h--) { \
  91.     pdst = pdstRect; \
  92.     left \
  93.     m = nmiddle; \
  94.     while (m--) {\
  95.         RROP_SOLID(pdst); \
  96.         pdst++; \
  97.     } \
  98.     right \
  99.     pdstRect += widthDst; \
  100.     } \
  101. }
  102. # endif
  103. #endif
  104.     
  105.  
  106. void
  107. RROP_NAME(cfbFillRectSolid) (pDrawable, pGC, nBox, pBox)
  108.     DrawablePtr        pDrawable;
  109.     GCPtr        pGC;
  110.     int            nBox;
  111.     BoxPtr        pBox;
  112. {
  113.     register int    m;
  114.     register unsigned long   *pdst;
  115.     RROP_DECLARE
  116.     register unsigned long   leftMask, rightMask;
  117.     unsigned long   *pdstBase, *pdstRect;
  118.     int            nmiddle;
  119.     int            h;
  120.     int            w;
  121.     int            widthDst;
  122.     cfbPrivGCPtr    devPriv;
  123.  
  124.     devPriv = ((cfbPrivGCPtr) (pGC->devPrivates[cfbGCPrivateIndex].ptr));
  125.  
  126.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
  127.  
  128.     RROP_FETCH_GC(pGC)
  129.     
  130.     for (; nBox; nBox--, pBox++)
  131.     {
  132.         pdstRect = pdstBase + pBox->y1 * widthDst;
  133.         h = pBox->y2 - pBox->y1;
  134.     w = pBox->x2 - pBox->x1;
  135. #if PPW == 4
  136.     if (w == 1)
  137.     {
  138.         register char    *pdstb = ((char *) pdstRect) + pBox->x1;
  139.         int        incr = widthDst << 2;
  140.  
  141.         while (h--)
  142.         {
  143.         RROP_SOLID (pdstb);
  144.         pdstb += incr;
  145.         }
  146.     }
  147.     else
  148.     {
  149. #endif
  150.     pdstRect += (pBox->x1 >> PWSH);
  151.     if ((pBox->x1 & PIM) + w <= PPW)
  152.     {
  153.         maskpartialbits(pBox->x1, w, leftMask);
  154.         pdst = pdstRect;
  155.         while (h--) {
  156.         RROP_SOLID_MASK (pdst, leftMask);
  157.         pdst += widthDst;
  158.         }
  159.     }
  160.     else
  161.     {
  162.         maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
  163.         if (leftMask)
  164.         {
  165.         if (rightMask)    /* left mask and right mask */
  166.         {
  167.             Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
  168.                RROP_SOLID_MASK (pdst, rightMask);, 1)
  169.         }
  170.         else    /* left mask and no right mask */
  171.         {
  172.             Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
  173.                ;, 1)
  174.         }
  175.         }
  176.         else
  177.         {
  178.         if (rightMask)    /* no left mask and right mask */
  179.         {
  180.             Expand(;,
  181.                RROP_SOLID_MASK (pdst, rightMask);, 0)
  182.         }
  183.         else    /* no left mask and no right mask */
  184.         {
  185.             Expand(;,
  186.                 ;, 0)
  187.         }
  188.         }
  189.     }
  190. #if PPW == 4
  191.     }
  192. #endif
  193.     }
  194. }
  195.  
  196. void
  197. RROP_NAME(cfbSolidSpans) (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
  198.     DrawablePtr pDrawable;
  199.     GCPtr    pGC;
  200.     int        nInit;            /* number of spans to fill */
  201.     DDXPointPtr pptInit;        /* pointer to list of start points */
  202.     int        *pwidthInit;        /* pointer to list of n widths */
  203.     int     fSorted;
  204. {
  205.     unsigned long   *pdstBase;
  206.     int            widthDst;
  207.  
  208.     RROP_DECLARE
  209.     
  210.     register unsigned long  *pdst;
  211.     register int        nlmiddle;
  212.     register unsigned long  startmask, endmask;
  213.     register int        w;
  214.     int                x;
  215.     
  216.                 /* next three parameters are post-clip */
  217.     int            n;        /* number of spans to fill */
  218.     DDXPointPtr        ppt;    /* pointer to list of start points */
  219.     int            *pwidthFree;/* copies of the pointers to free */
  220.     DDXPointPtr        pptFree;
  221.     int            *pwidth;
  222.     cfbPrivGCPtr    devPriv;
  223.  
  224.     devPriv = (cfbPrivGCPtr)pGC->devPrivates[cfbGCPrivateIndex].ptr;
  225.     RROP_FETCH_GCPRIV(devPriv)
  226.     n = nInit * miFindMaxBand(devPriv->pCompositeClip);
  227.     pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
  228.     pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
  229.     if(!pptFree || !pwidthFree)
  230.     {
  231.     if (pptFree) DEALLOCATE_LOCAL(pptFree);
  232.     if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
  233.     return;
  234.     }
  235.     pwidth = pwidthFree;
  236.     ppt = pptFree;
  237.     n = miClipSpans(devPriv->pCompositeClip,
  238.              pptInit, pwidthInit, nInit,
  239.              ppt, pwidth, fSorted);
  240.  
  241.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
  242.  
  243.     while (n--)
  244.     {
  245.     x = ppt->x;
  246.     pdst = pdstBase + (ppt->y * widthDst);
  247.     ++ppt;
  248.     w = *pwidth++;
  249.     if (!w)
  250.         continue;
  251. #if PPW == 4
  252.     if (w <= 4)
  253.     {
  254.         register char   *addrb;
  255.  
  256.         addrb = ((char *) pdst) + x;
  257.         while (w--)
  258.         {
  259.         RROP_SOLID (addrb);
  260.         addrb++;
  261.         }
  262.     }
  263. #else
  264.     if ((x & PIM) + w <= PPW)
  265.     {
  266.         pdst += x >> PWSH;
  267.         maskpartialbits (x, w, startmask);
  268.         RROP_SOLID_MASK (pdst, startmask);
  269.     }
  270. #endif
  271.     else
  272.     {
  273.         pdst += x >> PWSH;
  274.         maskbits (x, w, startmask, endmask, nlmiddle);
  275.         if (startmask)
  276.         {
  277.         RROP_SOLID_MASK (pdst, startmask);
  278.         ++pdst;
  279.         }
  280.         
  281.         RROP_SPAN(pdst,nlmiddle)
  282.         if (endmask)
  283.         {
  284.         RROP_SOLID_MASK (pdst, endmask);
  285.         }
  286.     }
  287.     }
  288.     DEALLOCATE_LOCAL(pptFree);
  289.     DEALLOCATE_LOCAL(pwidthFree);
  290. }
  291.