xorg-server-1.4/mfb/mfbwindow.c

   1 /* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
   2 /***********************************************************
   3
   4 Copyright 1987, 1998  The Open Group
   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.
  11
  12 The above copyright notice and this permission notice shall be included in
  13 all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  18 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 Except as contained in this notice, the name of The Open Group shall not be
  23 used in advertising or otherwise to promote the sale, use or other dealings
  24 in this Software without prior written authorization from The Open Group.
  25
  26
  27 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  28
  29                         All Rights Reserved
  30
  31 Permission to use, copy, modify, and distribute this software and its
  32 documentation for any purpose and without fee is hereby granted,
  33 provided that the above copyright notice appear in all copies and that
  34 both that copyright notice and this permission notice appear in
  35 supporting documentation, and that the name of Digital not be
  36 used in advertising or publicity pertaining to distribution of the
  37 software without specific, written prior permission.
  38
  39 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  40 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  41 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  42 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  43 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  44 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  45 SOFTWARE.
  46
  47 ******************************************************************/
  48
  49 #ifdef HAVE_DIX_CONFIG_H
  50 #include <dix-config.h>
  51 #endif
  52
  53 #include <stdlib.h>
  54
  55 #include <X11/X.h>
  56 #include "scrnintstr.h"
  57 #include "windowstr.h"
  58 #include "mfb.h"
  59 #include "mistruct.h"
  60 #include "regionstr.h"
  61 #include "maskbits.h"
  62
  63 Bool
  64 mfbCreateWindow(pWin)
  65     register WindowPtr pWin;
  66 {
  67     register mfbPrivWin *pPrivWin;
  68
  69     pPrivWin = (mfbPrivWin *)(pWin->devPrivates[mfbWindowPrivateIndex].ptr);
  70     pPrivWin->pRotatedBorder = NullPixmap;
  71     pPrivWin->pRotatedBackground = NullPixmap;
  72     pPrivWin->fastBackground = FALSE;
  73     pPrivWin->fastBorder = FALSE;
  74
  75     return (TRUE);
  76 }
  77
  78 /* This always returns true, because Xfree can't fail.  It might be possible
  79  * on some devices for Destroy to fail */
  80 Bool
  81 mfbDestroyWindow(pWin)
  82     WindowPtr pWin;
  83 {
  84     register mfbPrivWin *pPrivWin;
  85
  86     pPrivWin = (mfbPrivWin *)(pWin->devPrivates[mfbWindowPrivateIndex].ptr);
  87
  88     if (pPrivWin->pRotatedBorder)
  89         (*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBorder);
  90     if (pPrivWin->pRotatedBackground)
  91         (*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBackground);
  92     return (TRUE);
  93 }
  94
  95 /*ARGSUSED*/
  96 Bool mfbMapWindow(pWindow)
  97     WindowPtr pWindow;
  98 {
  99     return (TRUE);
 100 }
 101
 102 /* (x, y) is the upper left corner of the window on the screen
 103    do we really need to pass this?  (is it a;ready in pWin->absCorner?)
 104    we only do the rotation for pixmaps that are 32 bits wide (padded
 105 or otherwise.)
 106    mfbChangeWindowAttributes() has already put a copy of the pixmap
 107 in pPrivWin->pRotated*
 108 */
 109
 110 /*ARGSUSED*/
 111 Bool
 112 mfbPositionWindow(pWin, x, y)
 113     register WindowPtr pWin;
 114     int x, y;
 115 {
 116     register mfbPrivWin *pPrivWin;
 117     int reset = 0;
 118
 119     pPrivWin = (mfbPrivWin *)(pWin->devPrivates[mfbWindowPrivateIndex].ptr);
 120     if (pWin->backgroundState == BackgroundPixmap && pPrivWin->fastBackground)
 121     {
 122         mfbXRotatePixmap(pPrivWin->pRotatedBackground,
 123                          pWin->drawable.x - pPrivWin->oldRotate.x);
 124         mfbYRotatePixmap(pPrivWin->pRotatedBackground,
 125                          pWin->drawable.y - pPrivWin->oldRotate.y);
 126         reset = 1;
 127     }
 128
 129     if (!pWin->borderIsPixel && pPrivWin->fastBorder)
 130     {
 131         while (pWin->backgroundState == ParentRelative)
 132             pWin = pWin->parent;
 133         mfbXRotatePixmap(pPrivWin->pRotatedBorder,
 134                          pWin->drawable.x - pPrivWin->oldRotate.x);
 135         mfbYRotatePixmap(pPrivWin->pRotatedBorder,
 136                          pWin->drawable.y - pPrivWin->oldRotate.y);
 137         reset = 1;
 138     }
 139     if (reset)
 140     {
 141         pPrivWin->oldRotate.x = pWin->drawable.x;
 142         pPrivWin->oldRotate.y = pWin->drawable.y;
 143     }
 144
 145     /* This is the "wrong" fix to the right problem, but it doesn't really
 146      * cost very much.  When the window is moved, we need to invalidate any
 147      * RotatedPixmap that exists in any GC currently validated against this
 148      * window.
 149      */
 150     pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 151
 152     /* Again, we have no failure modes indicated by any of the routines
 153      * we've called, so we have to assume it worked */
 154     return (TRUE);
 155 }
 156
 157 /*ARGSUSED*/
 158 Bool
 159 mfbUnmapWindow(pWindow)
 160     WindowPtr pWindow;
 161 {
 162     return (TRUE);
 163 }
 164
 165 /* UNCLEAN!
 166    this code calls the bitblt helper code directly.
 167
 168    mfbCopyWindow copies only the parts of the destination that are
 169 visible in the source.
 170 */
 171
 172
 173 void
 174 mfbCopyWindow(pWin, ptOldOrg, prgnSrc)
 175     WindowPtr pWin;
 176     DDXPointRec ptOldOrg;
 177     RegionPtr prgnSrc;
 178 {
 179     DDXPointPtr pptSrc;
 180     register DDXPointPtr ppt;
 181     RegionPtr prgnDst;
 182     register BoxPtr pbox;
 183     register int dx, dy;
 184     register int i, nbox;
 185     WindowPtr pwinRoot;
 186
 187     pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
 188
 189     prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
 190
 191     dx = ptOldOrg.x - pWin->drawable.x;
 192     dy = ptOldOrg.y - pWin->drawable.y;
 193     REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
 194     REGION_INTERSECT(pWin->drawable.pScreen, prgnDst, &pWin->borderClip,
 195                      prgnSrc);
 196
 197     pbox = REGION_RECTS(prgnDst);
 198     nbox = REGION_NUM_RECTS(prgnDst);
 199     if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
 200         return;
 201     ppt = pptSrc;
 202
 203     for (i=nbox; --i >= 0; ppt++, pbox++)
 204     {
 205         ppt->x = pbox->x1 + dx;
 206         ppt->y = pbox->y1 + dy;
 207     }
 208
 209     mfbDoBitblt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
 210                 GXcopy, prgnDst, pptSrc);
 211     DEALLOCATE_LOCAL(pptSrc);
 212     REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
 213 }
 214
 215
 216
 217 /* swap in correct PaintWindow* routine.  If we can use a fast output
 218 routine (i.e. the pixmap is paddable to 32 bits), also pre-rotate a copy
 219 of it in devPrivate.
 220 */
 221 Bool
 222 mfbChangeWindowAttributes(pWin, mask)
 223     register WindowPtr pWin;
 224     register unsigned long mask;
 225 {
 226     register unsigned long index;
 227     register mfbPrivWin *pPrivWin;
 228     WindowPtr   pBgWin;
 229
 230     pPrivWin = (mfbPrivWin *)(pWin->devPrivates[mfbWindowPrivateIndex].ptr);
 231     /*
 232      * When background state changes from ParentRelative and
 233      * we had previously rotated the fast border pixmap to match
 234      * the parent relative origin, rerotate to match window
 235      */
 236     if (mask & (CWBackPixmap | CWBackPixel) &&
 237         pWin->backgroundState != ParentRelative &&
 238         pPrivWin->fastBorder &&
 239         (pPrivWin->oldRotate.x != pWin->drawable.x ||
 240          pPrivWin->oldRotate.y != pWin->drawable.y))
 241     {
 242         mfbXRotatePixmap(pPrivWin->pRotatedBorder,
 243                       pWin->drawable.x - pPrivWin->oldRotate.x);
 244         mfbYRotatePixmap(pPrivWin->pRotatedBorder,
 245                       pWin->drawable.y - pPrivWin->oldRotate.y);
 246         pPrivWin->oldRotate.x = pWin->drawable.x;
 247         pPrivWin->oldRotate.y = pWin->drawable.y;
 248     }
 249     while(mask)
 250     {
 251         index = lowbit (mask);
 252         mask &= ~index;
 253         switch(index)
 254         {
 255           case CWBackPixmap:
 256               if (pWin->backgroundState == None)
 257               {
 258                   pPrivWin->fastBackground = FALSE;
 259               }
 260               else if (pWin->backgroundState == ParentRelative)
 261               {
 262                   pPrivWin->fastBackground = FALSE;
 263                   /* Rotate border to match parent origin */
 264                   if (pPrivWin->pRotatedBorder) {
 265                       for (pBgWin = pWin->parent;
 266                            pBgWin->backgroundState == ParentRelative;
 267                            pBgWin = pBgWin->parent);
 268                       mfbXRotatePixmap(pPrivWin->pRotatedBorder,
 269                                     pBgWin->drawable.x - pPrivWin->oldRotate.x);
 270                       mfbYRotatePixmap(pPrivWin->pRotatedBorder,
 271                                     pBgWin->drawable.y - pPrivWin->oldRotate.y);
 272                       pPrivWin->oldRotate.x = pBgWin->drawable.x;
 273                       pPrivWin->oldRotate.y = pBgWin->drawable.y;
 274                   }
 275               }
 276               else if ((pWin->background.pixmap->drawable.width <= PPW) &&
 277                        !(pWin->background.pixmap->drawable.width &
 278                          (pWin->background.pixmap->drawable.width - 1)))
 279               {
 280                   mfbCopyRotatePixmap(pWin->background.pixmap,
 281                                       &pPrivWin->pRotatedBackground,
 282                                       pWin->drawable.x,
 283                                       pWin->drawable.y);
 284                   if (pPrivWin->pRotatedBackground)
 285                   {
 286                       pPrivWin->fastBackground = TRUE;
 287                       pPrivWin->oldRotate.x = pWin->drawable.x;
 288                       pPrivWin->oldRotate.y = pWin->drawable.y;
 289                   }
 290                   else
 291                   {
 292                       pPrivWin->fastBackground = FALSE;
 293                   }
 294               }
 295               else
 296               {
 297                   pPrivWin->fastBackground = FALSE;
 298               }
 299               break;
 300
 301           case CWBackPixel:
 302               pPrivWin->fastBackground = FALSE;
 303               break;
 304
 305           case CWBorderPixmap:
 306               if ((pWin->border.pixmap->drawable.width <= PPW) &&
 307                   !(pWin->border.pixmap->drawable.width &
 308                     (pWin->border.pixmap->drawable.width - 1)))
 309               {
 310                   for (pBgWin = pWin;
 311                        pBgWin->backgroundState == ParentRelative;
 312                        pBgWin = pBgWin->parent);
 313                   mfbCopyRotatePixmap(pWin->border.pixmap,
 314                                       &pPrivWin->pRotatedBorder,
 315                                       pBgWin->drawable.x,
 316                                       pBgWin->drawable.y);
 317                   if (pPrivWin->pRotatedBorder)
 318                   {
 319                       pPrivWin->fastBorder = TRUE;
 320                       pPrivWin->oldRotate.x = pBgWin->drawable.x;
 321                       pPrivWin->oldRotate.y = pBgWin->drawable.y;
 322                   }
 323                   else
 324                   {
 325                       pPrivWin->fastBorder = FALSE;
 326                   }
 327               }
 328               else
 329               {
 330                   pPrivWin->fastBorder = FALSE;
 331               }
 332               break;
 333             case CWBorderPixel:
 334               pPrivWin->fastBorder = FALSE;
 335               break;
 336         }
 337     }
 338     /* Again, we have no failure modes indicated by any of the routines
 339      * we've called, so we have to assume it worked */
 340     return (TRUE);
 341 }