dbe/midbe.c

   1 /******************************************************************************
   2  *
   3  * Copyright (c) 1994, 1995  Hewlett-Packard Company
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  19  * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Except as contained in this notice, the name of the Hewlett-Packard
  25  * Company shall not be used in advertising or otherwise to promote the
  26  * sale, use or other dealings in this Software without prior written
  27  * authorization from the Hewlett-Packard Company.
  28  *
  29  *     Machine-independent DBE code
  30  *
  31  *****************************************************************************/
  32
  33 /* INCLUDES */
  34
  35 #ifdef HAVE_DIX_CONFIG_H
  36 #include <dix-config.h>
  37 #endif
  38
  39 #include <X11/X.h>
  40 #include <X11/Xproto.h>
  41 #include "misc.h"
  42 #include "os.h"
  43 #include "windowstr.h"
  44 #include "scrnintstr.h"
  45 #include "pixmapstr.h"
  46 #include "extnsionst.h"
  47 #include "dixstruct.h"
  48 #include "resource.h"
  49 #include "opaque.h"
  50 #include "dbestruct.h"
  51 #include "midbestr.h"
  52 #include "regionstr.h"
  53 #include "gcstruct.h"
  54 #include "inputstr.h"
  55 #include "midbe.h"
  56 #include "xace.h"
  57
  58 #include <stdio.h>
  59
  60 static DevPrivateKeyRec miDbeWindowPrivPrivKeyRec;
  61
  62 #define miDbeWindowPrivPrivKey (&miDbeWindowPrivPrivKeyRec)
  63 \f
  64 /******************************************************************************
  65  *
  66  * DBE MI Procedure: miDbeGetVisualInfo
  67  *
  68  * Description:
  69  *
  70  *     This is the MI function for the DbeGetVisualInfo request.  This function
  71  *     is called through pDbeScreenPriv->GetVisualInfo.  This function is also
  72  *     called for the DbeAllocateBackBufferName request at the extension level;
  73  *     it is called by ProcDbeAllocateBackBufferName() in dbe.c.
  74  *
  75  *     If memory allocation fails or we can not get the visual info, this
  76  *     function returns FALSE.  Otherwise, it returns TRUE for success.
  77  *
  78  *****************************************************************************/
  79
  80 static Bool
  81 miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo * pScrVisInfo)
  82 {
  83     register int i, j, k;
  84     register int count;
  85     DepthPtr pDepth;
  86     XdbeVisualInfo *visInfo;
  87
  88     /* Determine number of visuals for this screen. */
  89     for (i = 0, count = 0; i < pScreen->numDepths; i++) {
  90         count += pScreen->allowedDepths[i].numVids;
  91     }
  92
  93     /* Allocate an array of XdbeVisualInfo items. */
  94     if (!(visInfo = (XdbeVisualInfo *) malloc(count * sizeof(XdbeVisualInfo)))) {
  95         return FALSE;           /* memory alloc failure */
  96     }
  97
  98     for (i = 0, k = 0; i < pScreen->numDepths; i++) {
  99         /* For each depth of this screen, get visual information. */
 100
 101         pDepth = &pScreen->allowedDepths[i];
 102
 103         for (j = 0; j < pDepth->numVids; j++) {
 104             /* For each visual for this depth of this screen, get visual ID
 105              * and visual depth.  Since this is MI code, we will always return
 106              * the same performance level for all visuals (0).  A higher
 107              * performance level value indicates higher performance.
 108              */
 109             visInfo[k].visual = pDepth->vids[j];
 110             visInfo[k].depth = pDepth->depth;
 111             visInfo[k].perflevel = 0;
 112             k++;
 113         }
 114     }
 115
 116     /* Record the number of visuals and point visual_depth to
 117      * the array of visual info.
 118      */
 119     pScrVisInfo->count = count;
 120     pScrVisInfo->visinfo = visInfo;
 121
 122     return TRUE;                /* success */
 123
 124 }                               /* miDbeGetVisualInfo() */
 125 \f
 126 /******************************************************************************
 127  *
 128  * DBE MI Procedure: miAllocBackBufferName
 129  *
 130  * Description:
 131  *
 132  *     This is the MI function for the DbeAllocateBackBufferName request.
 133  *
 134  *****************************************************************************/
 135
 136 static int
 137 miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
 138 {
 139     ScreenPtr pScreen;
 140     DbeWindowPrivPtr pDbeWindowPriv;
 141     MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
 142     DbeScreenPrivPtr pDbeScreenPriv;
 143     GCPtr pGC;
 144     xRectangle clearRect;
 145     int rc;
 146
 147     pScreen = pWin->drawable.pScreen;
 148     pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
 149
 150     if (pDbeWindowPriv->nBufferIDs == 0) {
 151         /* There is no buffer associated with the window.
 152          * We have to create the window priv priv.  Remember, the window
 153          * priv was created at the DIX level, so all we need to do is
 154          * create the priv priv and attach it to the priv.
 155          */
 156
 157         pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 158
 159         /* Setup the window priv priv. */
 160         pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
 161         pDbeWindowPrivPriv->pDbeWindowPriv = pDbeWindowPriv;
 162
 163         /* Get a front pixmap. */
 164         if (!(pDbeWindowPrivPriv->pFrontBuffer =
 165               (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
 166                                         pDbeWindowPriv->height,
 167                                         pWin->drawable.depth, 0))) {
 168             return BadAlloc;
 169         }
 170
 171         /* Get a back pixmap. */
 172         if (!(pDbeWindowPrivPriv->pBackBuffer =
 173               (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
 174                                         pDbeWindowPriv->height,
 175                                         pWin->drawable.depth, 0))) {
 176             (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
 177             return BadAlloc;
 178         }
 179
 180         /* Security creation/labeling check. */
 181         rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,
 182                       dbeDrawableResType, pDbeWindowPrivPriv->pBackBuffer,
 183                       RT_WINDOW, pWin, DixCreateAccess);
 184
 185         /* Make the back pixmap a DBE drawable resource. */
 186         if (rc != Success || !AddResource(bufId, dbeDrawableResType,
 187                                           pDbeWindowPrivPriv->pBackBuffer)) {
 188             /* free the buffer and the drawable resource */
 189             FreeResource(bufId, RT_NONE);
 190             return (rc == Success) ? BadAlloc : rc;
 191         }
 192
 193         /* Clear the back buffer. */
 194         pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
 195         if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
 196             ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
 197             clearRect.x = clearRect.y = 0;
 198             clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
 199             clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
 200             (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
 201                                        pBackBuffer, pGC, 1, &clearRect);
 202         }
 203         FreeScratchGC(pGC);
 204
 205     }                           /* if no buffer associated with the window */
 206
 207     else {
 208         /* A buffer is already associated with the window.
 209          * Place the new buffer ID information at the head of the ID list.
 210          */
 211
 212         /* Associate the new ID with an existing pixmap. */
 213         pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
 214         if (!AddResource(bufId, dbeDrawableResType,
 215                          (pointer) pDbeWindowPrivPriv->pBackBuffer)) {
 216             return BadAlloc;
 217         }
 218
 219     }
 220
 221     return Success;
 222
 223 }                               /* miDbeAllocBackBufferName() */
 224 \f
 225 /******************************************************************************
 226  *
 227  * DBE MI Procedure: miDbeAliasBuffers
 228  *
 229  * Description:
 230  *
 231  *     This function associates all XIDs of a buffer with the back pixmap
 232  *     stored in the window priv.
 233  *
 234  *****************************************************************************/
 235
 236 static void
 237 miDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv)
 238 {
 239     int i;
 240     MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv =
 241         MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
 242
 243     for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) {
 244         ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType,
 245                             (pointer) pDbeWindowPrivPriv->pBackBuffer);
 246     }
 247
 248 }                               /* miDbeAliasBuffers() */
 249 \f
 250 /******************************************************************************
 251  *
 252  * DBE MI Procedure: miDbeSwapBuffers
 253  *
 254  * Description:
 255  *
 256  *     This is the MI function for the DbeSwapBuffers request.
 257  *
 258  *****************************************************************************/
 259
 260 static int
 261 miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
 262 {
 263     DbeScreenPrivPtr pDbeScreenPriv;
 264     GCPtr pGC;
 265     WindowPtr pWin;
 266     MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
 267     PixmapPtr pTmpBuffer;
 268     xRectangle clearRect;
 269
 270     pWin = swapInfo[0].pWindow;
 271     pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
 272     pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin);
 273     pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
 274
 275     /*
 276      **********************************************************************
 277      ** Setup before swap.
 278      **********************************************************************
 279      */
 280
 281     switch (swapInfo[0].swapAction) {
 282     case XdbeUndefined:
 283         break;
 284
 285     case XdbeBackground:
 286         break;
 287
 288     case XdbeUntouched:
 289         ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer, pGC);
 290         (*pGC->ops->CopyArea) ((DrawablePtr) pWin,
 291                                (DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer,
 292                                pGC, 0, 0, pWin->drawable.width,
 293                                pWin->drawable.height, 0, 0);
 294         break;
 295
 296     case XdbeCopied:
 297         break;
 298
 299     }
 300
 301     /*
 302      **********************************************************************
 303      ** Swap.
 304      **********************************************************************
 305      */
 306
 307     ValidateGC((DrawablePtr) pWin, pGC);
 308     (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer,
 309                            (DrawablePtr) pWin, pGC, 0, 0,
 310                            pWin->drawable.width, pWin->drawable.height, 0, 0);
 311
 312     /*
 313      **********************************************************************
 314      ** Tasks after swap.
 315      **********************************************************************
 316      */
 317
 318     switch (swapInfo[0].swapAction) {
 319     case XdbeUndefined:
 320         break;
 321
 322     case XdbeBackground:
 323         if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
 324             ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
 325             clearRect.x = 0;
 326             clearRect.y = 0;
 327             clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
 328             clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
 329             (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
 330                                        pBackBuffer, pGC, 1, &clearRect);
 331         }
 332         break;
 333
 334     case XdbeUntouched:
 335         /* Swap pixmap pointers. */
 336         pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer;
 337         pDbeWindowPrivPriv->pBackBuffer = pDbeWindowPrivPriv->pFrontBuffer;
 338         pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer;
 339
 340         miDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv);
 341
 342         break;
 343
 344     case XdbeCopied:
 345         break;
 346
 347     }
 348
 349     /* Remove the swapped window from the swap information array and decrement
 350      * pNumWindows to indicate to the DIX level how many windows were actually
 351      * swapped.
 352      */
 353
 354     if (*pNumWindows > 1) {
 355         /* We were told to swap more than one window, but we only swapped the
 356          * first one.  Remove the first window in the list by moving the last
 357          * window to the beginning.
 358          */
 359         swapInfo[0].pWindow = swapInfo[*pNumWindows - 1].pWindow;
 360         swapInfo[0].swapAction = swapInfo[*pNumWindows - 1].swapAction;
 361
 362         /* Clear the last window information just to be safe. */
 363         swapInfo[*pNumWindows - 1].pWindow = (WindowPtr) NULL;
 364         swapInfo[*pNumWindows - 1].swapAction = 0;
 365     }
 366     else {
 367         /* Clear the window information just to be safe. */
 368         swapInfo[0].pWindow = (WindowPtr) NULL;
 369         swapInfo[0].swapAction = 0;
 370     }
 371
 372     (*pNumWindows)--;
 373
 374     FreeScratchGC(pGC);
 375
 376     return Success;
 377
 378 }                               /* miSwapBuffers() */
 379 \f
 380 /******************************************************************************
 381  *
 382  * DBE MI Procedure: miDbeWinPrivDelete
 383  *
 384  * Description:
 385  *
 386  *     This is the MI function for deleting the dbeWindowPrivResType resource.
 387  *     This function is invoked indirectly by calling FreeResource() to free
 388  *     the resources associated with a DBE buffer ID.  There are 5 ways that
 389  *     miDbeWinPrivDelete() can be called by FreeResource().  They are:
 390  *
 391  *     - A DBE window is destroyed, in which case the DbeDestroyWindow()
 392  *       wrapper is invoked.  The wrapper calls FreeResource() for all DBE
 393  *       buffer IDs.
 394  *
 395  *     - miDbeAllocBackBufferName() calls FreeResource() to clean up resources
 396  *       after a buffer allocation failure.
 397  *
 398  *     - The PositionWindow wrapper, miDbePositionWindow(), calls
 399  *       FreeResource() when it fails to create buffers of the new size.
 400  *       FreeResource() is called for all DBE buffer IDs.
 401  *
 402  *     - FreeClientResources() calls FreeResource() when a client dies or the
 403  *       the server resets.
 404  *
 405  *     When FreeResource() is called for a DBE buffer ID, the delete function
 406  *     for the only other type of DBE resource, dbeDrawableResType, is also
 407  *     invoked.  This delete function (DbeDrawableDelete) is a NOOP to make
 408  *     resource deletion easier.  It is not guaranteed which delete function is
 409  *     called first.  Hence, we will let miDbeWinPrivDelete() free all DBE
 410  *     resources.
 411  *
 412  *     This function deletes/frees the following stuff associated with
 413  *     the window private:
 414  *
 415  *     - the ID node in the ID list representing the passed in ID.
 416  *
 417  *     In addition, pDbeWindowPriv->nBufferIDs is decremented.
 418  *
 419  *     If this function is called for the last/only buffer ID for a window,
 420  *     these are additionally deleted/freed:
 421  *
 422  *     - the front and back pixmaps
 423  *     - the window priv itself
 424  *
 425  *****************************************************************************/
 426
 427 static void
 428 miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)
 429 {
 430     MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
 431
 432     if (pDbeWindowPriv->nBufferIDs != 0) {
 433         /* We still have at least one more buffer ID associated with this
 434          * window.
 435          */
 436         return;
 437     }
 438
 439     /* We have no more buffer IDs associated with this window.  We need to
 440      * free some stuff.
 441      */
 442
 443     pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
 444
 445     /* Destroy the front and back pixmaps. */
 446     if (pDbeWindowPrivPriv->pFrontBuffer) {
 447         (*pDbeWindowPriv->pWindow->drawable.pScreen->
 448          DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
 449     }
 450     if (pDbeWindowPrivPriv->pBackBuffer) {
 451         (*pDbeWindowPriv->pWindow->drawable.pScreen->
 452          DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
 453     }
 454
 455 }                               /* miDbeWinPrivDelete() */
 456 \f
 457 /******************************************************************************
 458  *
 459  * DBE MI Procedure: miDbePositionWindow
 460  *
 461  * Description:
 462  *
 463  *     This function was cloned from miMbxPositionWindow() in mimultibuf.c.
 464  *     This function resizes the buffer when the window is resized.
 465  *
 466  *****************************************************************************/
 467
 468 static Bool
 469 miDbePositionWindow(WindowPtr pWin, int x, int y)
 470 {
 471     ScreenPtr pScreen;
 472     DbeScreenPrivPtr pDbeScreenPriv;
 473     DbeWindowPrivPtr pDbeWindowPriv;
 474     int width, height;
 475     int dx, dy, dw, dh;
 476     int sourcex, sourcey;
 477     int destx, desty;
 478     int savewidth, saveheight;
 479     PixmapPtr pFrontBuffer;
 480     PixmapPtr pBackBuffer;
 481     Bool clear;
 482     GCPtr pGC;
 483     xRectangle clearRect;
 484     Bool ret;
 485
 486     /*
 487      **************************************************************************
 488      ** 1. Unwrap the member routine.
 489      **************************************************************************
 490      */
 491
 492     pScreen = pWin->drawable.pScreen;
 493     pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 494     pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
 495
 496     /*
 497      **************************************************************************
 498      ** 2. Do any work necessary before the member routine is called.
 499      **
 500      **    In this case we do not need to do anything.
 501      **************************************************************************
 502      */
 503
 504     /*
 505      **************************************************************************
 506      ** 3. Call the member routine, saving its result if necessary.
 507      **************************************************************************
 508      */
 509
 510     ret = (*pScreen->PositionWindow) (pWin, x, y);
 511
 512     /*
 513      **************************************************************************
 514      ** 4. Rewrap the member routine, restoring the wrapper value first in case
 515      **    the wrapper (or something that it wrapped) change this value.
 516      **************************************************************************
 517      */
 518
 519     pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;
 520     pScreen->PositionWindow = miDbePositionWindow;
 521
 522     /*
 523      **************************************************************************
 524      ** 5. Do any work necessary after the member routine has been called.
 525      **************************************************************************
 526      */
 527
 528     if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) {
 529         return ret;
 530     }
 531
 532     if (pDbeWindowPriv->width == pWin->drawable.width &&
 533         pDbeWindowPriv->height == pWin->drawable.height) {
 534         return ret;
 535     }
 536
 537     width = pWin->drawable.width;
 538     height = pWin->drawable.height;
 539
 540     dx = pWin->drawable.x - pDbeWindowPriv->x;
 541     dy = pWin->drawable.y - pDbeWindowPriv->y;
 542     dw = width - pDbeWindowPriv->width;
 543     dh = height - pDbeWindowPriv->height;
 544
 545     GravityTranslate(0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);
 546
 547     clear = ((pDbeWindowPriv->width < (unsigned short) width) ||
 548              (pDbeWindowPriv->height < (unsigned short) height) ||
 549              (pWin->bitGravity == ForgetGravity));
 550
 551     sourcex = 0;
 552     sourcey = 0;
 553     savewidth = pDbeWindowPriv->width;
 554     saveheight = pDbeWindowPriv->height;
 555
 556     /* Clip rectangle to source and destination. */
 557     if (destx < 0) {
 558         savewidth += destx;
 559         sourcex -= destx;
 560         destx = 0;
 561     }
 562
 563     if (destx + savewidth > width) {
 564         savewidth = width - destx;
 565     }
 566
 567     if (desty < 0) {
 568         saveheight += desty;
 569         sourcey -= desty;
 570         desty = 0;
 571     }
 572
 573     if (desty + saveheight > height) {
 574         saveheight = height - desty;
 575     }
 576
 577     pDbeWindowPriv->width = width;
 578     pDbeWindowPriv->height = height;
 579     pDbeWindowPriv->x = pWin->drawable.x;
 580     pDbeWindowPriv->y = pWin->drawable.y;
 581
 582     pGC = GetScratchGC(pWin->drawable.depth, pScreen);
 583
 584     if (clear) {
 585         if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
 586             clearRect.x = 0;
 587             clearRect.y = 0;
 588             clearRect.width = width;
 589             clearRect.height = height;
 590         }
 591         else {
 592             clear = FALSE;
 593         }
 594     }
 595
 596     /* Create DBE buffer pixmaps equal to size of resized window. */
 597     pFrontBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
 598                                              pWin->drawable.depth, 0);
 599
 600     pBackBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
 601                                             pWin->drawable.depth, 0);
 602
 603     if (!pFrontBuffer || !pBackBuffer) {
 604         /* We failed at creating 1 or 2 of the pixmaps. */
 605
 606         if (pFrontBuffer) {
 607             (*pScreen->DestroyPixmap) (pFrontBuffer);
 608         }
 609
 610         if (pBackBuffer) {
 611             (*pScreen->DestroyPixmap) (pBackBuffer);
 612         }
 613
 614         /* Destroy all buffers for this window. */
 615         while (pDbeWindowPriv) {
 616             /* DbeWindowPrivDelete() will free the window private if there no
 617              * more buffer IDs associated with this window.
 618              */
 619             FreeResource(pDbeWindowPriv->IDs[0], RT_NONE);
 620             pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
 621         }
 622
 623         FreeScratchGC(pGC);
 624         return FALSE;
 625     }
 626
 627     else {
 628         /* Clear out the new DBE buffer pixmaps. */
 629
 630         MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
 631
 632         pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
 633
 634         /* I suppose this could avoid quite a bit of work if
 635          * it computed the minimal area required.
 636          */
 637         ValidateGC(&pFrontBuffer->drawable, pGC);
 638         if (clear) {
 639             (*pGC->ops->PolyFillRect) ((DrawablePtr) pFrontBuffer, pGC, 1,
 640                                        &clearRect);
 641         }
 642         /* Copy the contents of the old front pixmap to the new one. */
 643         if (pWin->bitGravity != ForgetGravity) {
 644             (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
 645                                    pFrontBuffer, (DrawablePtr) pFrontBuffer,
 646                                    pGC, sourcex, sourcey, savewidth, saveheight,
 647                                    destx, desty);
 648         }
 649
 650         ValidateGC(&pBackBuffer->drawable, pGC);
 651         if (clear) {
 652             (*pGC->ops->PolyFillRect) ((DrawablePtr) pBackBuffer, pGC, 1,
 653                                        &clearRect);
 654         }
 655         /* Copy the contents of the old back pixmap to the new one. */
 656         if (pWin->bitGravity != ForgetGravity) {
 657             (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
 658                                    pBackBuffer, (DrawablePtr) pBackBuffer, pGC,
 659                                    sourcex, sourcey, savewidth, saveheight,
 660                                    destx, desty);
 661         }
 662
 663         /* Destroy the old pixmaps, and point the DBE window priv to the new
 664          * pixmaps.
 665          */
 666
 667         (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
 668         (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
 669
 670         pDbeWindowPrivPriv->pFrontBuffer = pFrontBuffer;
 671         pDbeWindowPrivPriv->pBackBuffer = pBackBuffer;
 672
 673         /* Make sure all XID are associated with the new back pixmap. */
 674         miDbeAliasBuffers(pDbeWindowPriv);
 675
 676         FreeScratchGC(pGC);
 677     }
 678
 679     return ret;
 680
 681 }                               /* miDbePositionWindow() */
 682 \f
 683 /******************************************************************************
 684  *
 685  * DBE MI Procedure: miDbeResetProc
 686  *
 687  * Description:
 688  *
 689  *     This function is called from DbeResetProc(), which is called at the end
 690  *     of every server generation.  This function peforms any MI-specific
 691  *     shutdown tasks.
 692  *
 693  *****************************************************************************/
 694
 695 static void
 696 miDbeResetProc(ScreenPtr pScreen)
 697 {
 698     DbeScreenPrivPtr pDbeScreenPriv;
 699
 700     pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 701
 702     /* Unwrap wrappers */
 703     pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
 704
 705 }                               /* miDbeResetProc() */
 706 \f
 707 /******************************************************************************
 708  *
 709  * DBE MI Procedure: miDbeInit
 710  *
 711  * Description:
 712  *
 713  *     This is the MI initialization function called by DbeExtensionInit().
 714  *
 715  *****************************************************************************/
 716
 717 Bool
 718 miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)
 719 {
 720     if (!dixRegisterPrivateKey(&miDbeWindowPrivPrivKeyRec, PRIVATE_DBE_WINDOW,
 721                                sizeof(MiDbeWindowPrivPrivRec)))
 722         return FALSE;
 723
 724     /* Wrap functions. */
 725     pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;
 726     pScreen->PositionWindow = miDbePositionWindow;
 727
 728     /* Initialize the per-screen DBE function pointers. */
 729     pDbeScreenPriv->GetVisualInfo = miDbeGetVisualInfo;
 730     pDbeScreenPriv->AllocBackBufferName = miDbeAllocBackBufferName;
 731     pDbeScreenPriv->SwapBuffers = miDbeSwapBuffers;
 732     pDbeScreenPriv->BeginIdiom = 0;
 733     pDbeScreenPriv->EndIdiom = 0;
 734     pDbeScreenPriv->ResetProc = miDbeResetProc;
 735     pDbeScreenPriv->WinPrivDelete = miDbeWinPrivDelete;
 736
 737     return TRUE;
 738
 739 }                               /* miDbeInit() */