home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xibm.zip / ppc / ppcGC.c < prev    next >
C/C++ Source or Header  |  1992-02-11  |  14KB  |  449 lines
  1. /*
  2.  * Copyright IBM Corporation 1987,1988,1989
  3.  *
  4.  * All Rights Reserved
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software and its
  7.  * documentation for any purpose and without fee is hereby granted,
  8.  * provided that the above copyright notice appear in all copies and that 
  9.  * both that copyright notice and this permission notice appear in
  10.  * supporting documentation, and that the name of IBM not be
  11.  * used in advertising or publicity pertaining to distribution of the
  12.  * software without specific, written prior permission.
  13.  *
  14.  * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  15.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  16.  * IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  17.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  19.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  20.  * SOFTWARE.
  21.  *
  22. */
  23. /***********************************************************
  24.         Copyright IBM Corporation 1987,1988
  25.  
  26.               All Rights Reserved
  27.  
  28. Permission to use, copy, modify, and distribute this software and its
  29. documentation for any purpose and without fee is hereby granted,
  30. provided that the above copyright notice appear in all copies and that
  31. both that copyright notice and this permission notice appear in
  32. supporting documentation, and that the name of IBM not be
  33. used in advertising or publicity pertaining to distribution of the
  34. software without specific, written prior permission.
  35.  
  36. IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  37. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  38. IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  39. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  40. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  41. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  42. SOFTWARE.
  43.  
  44. ******************************************************************/
  45. /***********************************************************
  46. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  47. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  48.  
  49.             All Rights Reserved
  50.  
  51. Permission to use, copy, modify, and distribute this software and its
  52. documentation for any purpose and without fee is hereby granted,
  53. provided that the above copyright notice appear in all copies and that
  54. both that copyright notice and this permission notice appear in
  55. supporting documentation, and that the names of Digital or MIT not be
  56. used in advertising or publicity pertaining to distribution of the
  57. software without specific, written prior permission.
  58.  
  59. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  60. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  61. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  62. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  63. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  64. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  65. SOFTWARE.
  66.  
  67. ******************************************************************/
  68.  
  69. /* $Header: /afs/athena.mit.edu/astaff/project/x11r5/src/athena/ibm/ppc/RCS/ppcGC.c,v 5.1 1992/02/12 00:29:18 jfc Exp $ */
  70. /* $Source: /afs/athena.mit.edu/astaff/project/x11r5/src/athena/ibm/ppc/RCS/ppcGC.c,v $ */
  71.  
  72. #ifndef lint
  73. static char *rcsid = "$Id: ppcGC.c,v 5.1 1992/02/12 00:29:18 jfc Exp $";
  74. #endif
  75.  
  76. #include "X.h"
  77. #include "Xproto.h"
  78. #include "windowstr.h"
  79. #include "window.h"
  80. #include "pixmapstr.h"
  81. #include "scrnintstr.h"
  82. #include "misc.h"
  83. #include "font.h"
  84. #include "gcstruct.h"
  85. #include "cursorstr.h"
  86. #include "region.h"
  87.  
  88. #include "mistruct.h"
  89.  
  90. #include "mfb.h"
  91.  
  92. #include "OScompiler.h"
  93.  
  94. #include "ppc.h"
  95. #include "ppcProcs.h"
  96.  
  97. #include "ibmTrace.h"
  98.  
  99. extern int ibmAllowBackingStore;
  100. extern int mfbGCPrivateInterest;
  101. #define ppcGCInterestValidateMask \
  102. ( GCLineStyle | GCLineWidth | GCJoinStyle | GCBackground | GCForeground \
  103. | GCFunction | GCPlaneMask | GCFillStyle | GC_CALL_VALIDATE_BIT         \
  104. | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode )
  105.  
  106. Bool
  107. ppcCreateGC( pGC )
  108. register GCPtr pGC;
  109. {
  110.     ppcScrnPriv *devScrnPriv = (ppcScrnPriv *)pGC->pScreen->devPrivate;
  111.     ppcPrivGC *pPriv;
  112.     GCOps *pOps;
  113.  
  114.     if (pGC->depth == 1 )
  115.         {
  116.         return (mfbCreateGC(pGC));
  117.         }
  118.  
  119.     if (!( pPriv = (ppcPrivGC *) Xalloc( sizeof( ppcPrivGC ) ) ) )
  120.         return FALSE;
  121.  
  122.     if (!( pOps = (GCOps *) Xalloc( sizeof( GCOps ) ) )) {
  123.         xfree(pPriv);
  124.         return FALSE;
  125.     }
  126.     
  127.     { /* Save & Restore any passed-in variables !! */
  128.         int        orig_depth    = pGC->depth;
  129.         PixmapPtr    orig_tile    = pGC->tile.pixmap;
  130.         PixmapPtr    orig_stipple    = pGC->stipple;
  131.         FontPtr        orig_font    = pGC->font;
  132.         int        orig_numInDashList    = pGC->numInDashList;
  133.         unsigned char    *orig_dash    = pGC->dash;
  134.         unsigned long    orig_serialNumber    = pGC->serialNumber;
  135.         DevUnion    *orig_devPrivates    = pGC->devPrivates;
  136.  
  137.         /* Copy The Prototype GC */
  138.         *pGC = *( devScrnPriv->devPrototypeGC );
  139.  
  140.         /* Now restore the pointers ! */
  141.         pGC->depth    = orig_depth;
  142.         pGC->tile.pixmap    = orig_tile;
  143.         pGC->stipple    = orig_stipple;
  144.         pGC->font    = orig_font;
  145.         pGC->numInDashList = orig_numInDashList;
  146.         pGC->dash    = orig_dash;
  147.         pGC->serialNumber  = orig_serialNumber;
  148.         pGC->devPrivates = orig_devPrivates;
  149.     }
  150.  
  151.     /* Copy The Prototype devPriv */
  152.     pGC->devPrivates[mfbGCPrivateIndex].ptr = (pointer) pPriv;
  153.     *pPriv = *( devScrnPriv->devPrototypeGCPriv );
  154.  
  155.     *pOps = *( pGC->ops );
  156.     pOps->devPrivate.val = 1;
  157.     pGC->ops = pOps;
  158.  
  159.     return TRUE;
  160. }
  161.  
  162. void
  163. ppcDestroyGC( pGC )
  164.     register GC    *pGC;
  165.  
  166. {
  167.     register ppcPrivGC *pPriv;
  168.  
  169.     TRACE( ( "ppcDestroyGC(pGC=0x%x)\n", pGC ) );
  170.  
  171.     pPriv = (ppcPrivGC *) ( pGC->devPrivates[mfbGCPrivateIndex].ptr );
  172.  
  173.     /* (ef) 11/9/87 -- ppc doesn't use rotated tile or stipple, but */
  174.     /*        *does* call mfbValidateGC under some conditions.    */
  175.     /*        mfbValidateGC *does* use rotated tile and stipple   */
  176.     if (pPriv->pRotatedPixmap )
  177.     mfbDestroyPixmap( pPriv->pRotatedPixmap );
  178.  
  179.     if (pPriv->freeCompClip && pPriv->pCompositeClip )
  180.     (* pGC->pScreen->RegionDestroy)( pPriv->pCompositeClip );
  181.     if (pPriv->devPriv )
  182.      (* ( (ppcScrnPrivPtr) (pGC->pScreen->devPrivate) )->DestroyGCPriv)(
  183.                     pPriv->devPriv );
  184.     if(pGC->ops->devPrivate.val) Xfree( pGC->ops );
  185.     Xfree( pGC->devPrivates[mfbGCPrivateIndex].ptr );
  186.     return;
  187. }
  188.  
  189. Mask
  190. ppcChangePixmapGC( pGC, changes )
  191. register GC *pGC;
  192. register Mask changes;
  193. {
  194. register ppcPrivGCPtr devPriv = (ppcPrivGCPtr) (pGC->devPrivates[mfbGCPrivateIndex].ptr );
  195. register unsigned long int index; /* used for stepping through bitfields */
  196. register Mask bsChanges = 0;
  197.  
  198. #define LOWBIT( x ) ( x & - x ) /* Two's complement */
  199. while ( index = LOWBIT( changes )) {
  200.     switch ( index) {
  201.  
  202.     case GCLineStyle:
  203.     case GCLineWidth:
  204.         if (!pGC->lineWidth)
  205.         pGC->ops->Polylines = miZeroLine;
  206.         else if (pGC->lineStyle == LineSolid)
  207.         pGC->ops->Polylines = miWideLine;
  208.         else
  209.         pGC->ops->Polylines = miWideDash;
  210.         changes &= ~( GCLineStyle | GCLineWidth );
  211.         break;
  212.  
  213.     case GCJoinStyle:
  214.         if (pGC->joinStyle == JoinMiter)
  215.         pGC->ops->LineHelper = miMiter;
  216.         else
  217.         pGC->ops->LineHelper = miNotMiter;
  218.         changes &= ~ index; /* i.e. changes &= ~ GCJoinStyle */
  219.         break;
  220.  
  221.     case GCBackground:
  222.         if (pGC->fillStyle != FillOpaqueStippled) {
  223.         changes &= ~ index; /* i.e. changes &= ~GCBackground */
  224.         break;
  225.         } /* else Fall Through */
  226.     case GCForeground:
  227.         if (pGC->fillStyle == FillTiled) {
  228.         changes &= ~ index; /* i.e. changes &= ~GCForeground */
  229.         break;
  230.         } /* else Fall Through */
  231.     case GCFunction:
  232.     case GCPlaneMask:
  233.     case GCFillStyle:
  234.         { /* new_fill */
  235.         int fillStyle = devPriv->colorRrop.fillStyle;
  236.         /* install a suitable fillspans */
  237.         if (fillStyle == FillSolid )
  238.             pGC->ops->FillSpans = ppcSolidPixmapFS;
  239.         else if (fillStyle == FillStippled )
  240.             pGC->ops->FillSpans = ppcStipplePixmapFS;
  241.         else if (fillStyle == FillOpaqueStippled )
  242.             pGC->ops->FillSpans = ppcOpStipplePixmapFS;
  243.         else /*  fillStyle == FillTiled */
  244.             pGC->ops->FillSpans = ppcTilePixmapFS;
  245.         changes &= ~( GCBackground | GCForeground
  246.                 | GCFunction | GCPlaneMask | GCFillStyle );
  247.         break;
  248.         } /* end of new_fill */
  249.  
  250.     default:
  251.         ErrorF( "ppcChangePixmapGC: Unexpected GC Change\n" );
  252.         changes &= ~ index; /* Remove it anyway */
  253.         break;
  254.     }
  255. }
  256.  
  257. return bsChanges;
  258. }
  259.  
  260. /* Clipping conventions
  261.     if the drawable is a window
  262.         CT_REGION ==> pCompositeClip really is the composite
  263.         CT_other ==> pCompositeClip is the window clip region
  264.     if the drawable is a pixmap
  265.         CT_REGION ==> pCompositeClip is the translated client region
  266.         clipped to the pixmap boundary
  267.         CT_other ==> pCompositeClip is the pixmap bounding box
  268. */
  269.  
  270. void
  271. ppcValidateGC( pGC, changes, pDrawable )
  272.     register GCPtr    pGC;
  273.     register Mask    changes;
  274.     DrawablePtr        pDrawable;
  275. {
  276.     register ppcPrivGCPtr devPriv;
  277.     ppcScrnPriv *devScrnPriv = (ppcScrnPriv *)pGC->pScreen->devPrivate;
  278.     WindowPtr pWin;
  279.     Mask bsChanges = 0;
  280.     int oldx, oldy;
  281.  
  282.     devPriv = (ppcPrivGCPtr) (pGC->devPrivates[mfbGCPrivateIndex].ptr );
  283.  
  284.     if (pDrawable->type != devPriv->lastDrawableType) {
  285.     devPriv->lastDrawableType = pDrawable->type;
  286.     bsChanges |= (* devScrnPriv->changeGCtype)( pGC, devPriv );
  287.     changes = ~0;
  288.     }
  289.  
  290.     if (pDrawable->depth == 1) {
  291.     ibmAbort();
  292.     }
  293.  
  294.     pWin = (pDrawable->type == DRAWABLE_WINDOW) ? (WindowPtr) pDrawable : (WindowPtr) NULL;
  295.     oldx = pGC->lastWinOrg.x;
  296.     oldy = pGC->lastWinOrg.y;
  297.     pGC->lastWinOrg.x = pDrawable->x;
  298.     pGC->lastWinOrg.y = pDrawable->y;
  299.  
  300.     changes &= ppcGCInterestValidateMask;
  301.     /* If Nothing REALLY Changed, Just Return */
  302.     if (pDrawable->serialNumber == (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
  303.     if (!( changes &= ~GC_CALL_VALIDATE_BIT))
  304.         return;
  305.  
  306.     /*
  307.     if the client clip is different or moved OR
  308.     the subwindowMode has changed OR
  309.     the window's clip has changed since the last validation
  310.     we need to recompute the composite clip
  311.     */
  312.     if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode))
  313.     || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))) {
  314.  
  315.       /* This test used to be conditional on the window having moved,
  316.      but that is wrong: the GC might be used for a different window now. */
  317.     if (pGC->clientClipType == CT_REGION) {
  318.         /* retranslate client clip */
  319.         (*pGC->pScreen->TranslateRegion)(pGC->clientClip,
  320.                          pGC->lastWinOrg.x + pGC->clipOrg.x,
  321.                          pGC->lastWinOrg.y + pGC->clipOrg.y);
  322.     }
  323.  
  324.     if (pWin) {
  325.         int freeTmpClip, freeCompClip;
  326.         RegionPtr pregWin; /* clip for this window, without
  327.                    client clip */
  328.  
  329.         if (pGC->subWindowMode == IncludeInferiors) {
  330.         pregWin = NotClippedByChildren(pWin);
  331.         freeTmpClip = TRUE;
  332.         }
  333.         else {
  334.         pregWin = &pWin->clipList;
  335.         freeTmpClip = FALSE;
  336.         }
  337.         freeCompClip = devPriv->freeCompClip;
  338.  
  339.         /* if there is no client clip, we can get by with
  340.            just keeping the pointer we got, and remembering
  341.            whether or not should destroy (or maybe re-use)
  342.            it later.  this way, we avoid unnecessary copying
  343.            of regions.  (this wins especially if many clients clip
  344.            by children and have no client clip.)
  345.         */
  346.         if (pGC->clientClipType == CT_NONE) {
  347.         if (freeCompClip == TRUE) {
  348.             (* pGC->pScreen->RegionDestroy) (devPriv->pCompositeClip );
  349.         }
  350.         devPriv->pCompositeClip = pregWin;
  351.         devPriv->freeCompClip = freeTmpClip;
  352.         }
  353.         else {
  354.         /* we need one 'real' region to put into the composite
  355.            clip.
  356.             if pregWin and the current composite clip
  357.            are real, we can get rid of one.
  358.             if the current composite clip is real and
  359.            pregWin isn't, intersect the client clip and
  360.            pregWin into the existing composite clip.
  361.             if pregWin is real and the current composite
  362.            clip isn't, intersect pregWin with the client clip
  363.            and replace the composite clip with it.
  364.             if neither is real, create a new region and
  365.            do the intersection into it.
  366.         */
  367.  
  368.         if (freeTmpClip == TRUE) {
  369.             if (freeCompClip == TRUE) {
  370.             (* pGC->pScreen->Intersect)(
  371.                 devPriv->pCompositeClip,
  372.                 pregWin,
  373.                 pGC->clientClip );
  374.             (* pGC->pScreen->RegionDestroy)( pregWin );
  375.             }
  376.             else if (freeCompClip == FALSE) {
  377.             (* pGC->pScreen->Intersect)(
  378.                pregWin,
  379.                pregWin,
  380.                pGC->clientClip );
  381.             devPriv->pCompositeClip = pregWin;
  382.             }
  383.         }
  384.         else if (freeTmpClip == FALSE) {
  385.             if (freeCompClip == TRUE) {
  386.             (* pGC->pScreen->Intersect)(
  387.             devPriv->pCompositeClip,
  388.             pregWin,
  389.             pGC->clientClip );
  390.             }
  391.             else if (freeCompClip == FALSE) {
  392.             devPriv->pCompositeClip =
  393.                 (* pGC->pScreen->RegionCreate)( NULL, 1 );
  394.             (* pGC->pScreen->Intersect)(
  395.                 devPriv->pCompositeClip,
  396.                 pregWin,
  397.                 pGC->clientClip );
  398.             }
  399.         }
  400.         devPriv->freeCompClip = TRUE;
  401.         }
  402.       } /* end of composite clip for a window */
  403.     else
  404.       {
  405.         BoxRec pixbounds;
  406.  
  407.         pixbounds.x1 = 0;
  408.         pixbounds.y1 = 0;
  409.         pixbounds.x2 = pDrawable->width;
  410.         pixbounds.y2 = pDrawable->height;
  411.  
  412.         if (devPriv->freeCompClip == TRUE)
  413.         (* pGC->pScreen->RegionReset)(
  414.             devPriv->pCompositeClip, &pixbounds );
  415.         else {
  416.         devPriv->freeCompClip = TRUE;
  417.         devPriv->pCompositeClip =
  418.             (* pGC->pScreen->RegionCreate)( &pixbounds, 1 );
  419.         }
  420.  
  421.         if (pGC->clientClipType == CT_REGION)
  422.           (*pGC->pScreen->Intersect)(devPriv->pCompositeClip,
  423.                      devPriv->pCompositeClip,
  424.                      pGC->clientClip);
  425.       } /* end of composite clip for pixmap */
  426.     if (pGC->clientClipType == CT_REGION) {
  427.       /* retranslate client clip */
  428.       (*pGC->pScreen->TranslateRegion)(pGC->clientClip,
  429.                        -(pDrawable->x + pGC->clipOrg.x),
  430.                        -(pDrawable->y + pGC->clipOrg.y));
  431.     }
  432.       }
  433.  
  434.     changes &= ~ ( GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode
  435.         | GC_CALL_VALIDATE_BIT );
  436.  
  437.     /* If needed, Calculate the Color Reduced Raster-Op */
  438.     if (changes & ( GCFillStyle | GCBackground | GCForeground
  439.            | GCPlaneMask | GCFunction ) )
  440.         ppcGetReducedColorRrop( pGC, pDrawable->depth,
  441.                     &devPriv->colorRrop );
  442.  
  443.     (* ( ( pDrawable->type == DRAWABLE_WINDOW )
  444.          ? devScrnPriv->changeWindowGC
  445.          : ppcChangePixmapGC ) )( pGC, changes );
  446.  
  447.     return;
  448. }
  449.