hw/xnest/Window.c

   1 /*
   2
   3 Copyright 1993 by Davor Matic
   4
   5 Permission to use, copy, modify, distribute, and sell this software
   6 and its documentation for any purpose is hereby granted without fee,
   7 provided that the above copyright notice appear in all copies and that
   8 both that copyright notice and this permission notice appear in
   9 supporting documentation.  Davor Matic makes no representations about
  10 the suitability of this software for any purpose.  It is provided "as
  11 is" without express or implied warranty.
  12
  13 */
  14
  15 #ifdef HAVE_XNEST_CONFIG_H
  16 #include <xnest-config.h>
  17 #endif
  18
  19 #include <X11/X.h>
  20 #include <X11/Xproto.h>
  21 #include "gcstruct.h"
  22 #include "window.h"
  23 #include "windowstr.h"
  24 #include "pixmapstr.h"
  25 #include "colormapst.h"
  26 #include "scrnintstr.h"
  27 #include "region.h"
  28
  29 #include "mi.h"
  30
  31 #include "Xnest.h"
  32
  33 #include "Display.h"
  34 #include "Screen.h"
  35 #include "XNGC.h"
  36 #include "Drawable.h"
  37 #include "Color.h"
  38 #include "Visual.h"
  39 #include "Events.h"
  40 #include "Args.h"
  41
  42 DevPrivateKeyRec xnestWindowPrivateKeyRec;
  43
  44 static int
  45 xnestFindWindowMatch(WindowPtr pWin, pointer ptr)
  46 {
  47     xnestWindowMatch *wm = (xnestWindowMatch *) ptr;
  48
  49     if (wm->window == xnestWindow(pWin)) {
  50         wm->pWin = pWin;
  51         return WT_STOPWALKING;
  52     }
  53     else
  54         return WT_WALKCHILDREN;
  55 }
  56
  57 WindowPtr
  58 xnestWindowPtr(Window window)
  59 {
  60     xnestWindowMatch wm;
  61     int i;
  62
  63     wm.pWin = NullWindow;
  64     wm.window = window;
  65
  66     for (i = 0; i < xnestNumScreens; i++) {
  67         WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);
  68         if (wm.pWin)
  69             break;
  70     }
  71
  72     return wm.pWin;
  73 }
  74
  75 Bool
  76 xnestCreateWindow(WindowPtr pWin)
  77 {
  78     unsigned long mask;
  79     XSetWindowAttributes attributes;
  80     Visual *visual;
  81     ColormapPtr pCmap;
  82
  83     if (pWin->drawable.class == InputOnly) {
  84         mask = 0L;
  85         visual = CopyFromParent;
  86     }
  87     else {
  88         mask = CWEventMask | CWBackingStore;
  89         attributes.event_mask = ExposureMask;
  90         attributes.backing_store = NotUseful;
  91
  92         if (pWin->parent) {
  93             if (pWin->optional &&
  94                 pWin->optional->visual != wVisual(pWin->parent)) {
  95                 visual =
  96                     xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
  97                 mask |= CWColormap;
  98                 if (pWin->optional->colormap) {
  99                     dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
 100                                             RT_COLORMAP, serverClient,
 101                                             DixUseAccess);
 102                     attributes.colormap = xnestColormap(pCmap);
 103                 }
 104                 else
 105                     attributes.colormap = xnestDefaultVisualColormap(visual);
 106             }
 107             else
 108                 visual = CopyFromParent;
 109         }
 110         else {                  /* root windows have their own colormaps at creation time */
 111             visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
 112             dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
 113                                     RT_COLORMAP, serverClient, DixUseAccess);
 114             mask |= CWColormap;
 115             attributes.colormap = xnestColormap(pCmap);
 116         }
 117     }
 118
 119     xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,
 120                                                   xnestWindowParent(pWin),
 121                                                   pWin->origin.x -
 122                                                   wBorderWidth(pWin),
 123                                                   pWin->origin.y -
 124                                                   wBorderWidth(pWin),
 125                                                   pWin->drawable.width,
 126                                                   pWin->drawable.height,
 127                                                   pWin->borderWidth,
 128                                                   pWin->drawable.depth,
 129                                                   pWin->drawable.class,
 130                                                   visual, mask, &attributes);
 131     xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
 132     xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
 133     xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
 134     xnestWindowPriv(pWin)->width = pWin->drawable.width;
 135     xnestWindowPriv(pWin)->height = pWin->drawable.height;
 136     xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
 137     xnestWindowPriv(pWin)->sibling_above = None;
 138     if (pWin->nextSib)
 139         xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
 140     xnestWindowPriv(pWin)->bounding_shape = RegionCreate(NULL, 1);
 141     xnestWindowPriv(pWin)->clip_shape = RegionCreate(NULL, 1);
 142
 143     if (!pWin->parent)          /* only the root window will have the right colormap */
 144         xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
 145
 146     return True;
 147 }
 148
 149 Bool
 150 xnestDestroyWindow(WindowPtr pWin)
 151 {
 152     if (pWin->nextSib)
 153         xnestWindowPriv(pWin->nextSib)->sibling_above =
 154             xnestWindowPriv(pWin)->sibling_above;
 155     RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);
 156     RegionDestroy(xnestWindowPriv(pWin)->clip_shape);
 157     XDestroyWindow(xnestDisplay, xnestWindow(pWin));
 158     xnestWindowPriv(pWin)->window = None;
 159
 160     if (pWin->optional && pWin->optional->colormap && pWin->parent)
 161         xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
 162
 163     return True;
 164 }
 165
 166 Bool
 167 xnestPositionWindow(WindowPtr pWin, int x, int y)
 168 {
 169     xnestConfigureWindow(pWin,
 170                          CWParent |
 171                          CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
 172
 173     return True;
 174 }
 175
 176 void
 177 xnestConfigureWindow(WindowPtr pWin, unsigned int mask)
 178 {
 179     unsigned int valuemask;
 180     XWindowChanges values;
 181
 182     if (mask & CWParent &&
 183         xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {
 184         XReparentWindow(xnestDisplay, xnestWindow(pWin),
 185                         xnestWindowParent(pWin),
 186                         pWin->origin.x - wBorderWidth(pWin),
 187                         pWin->origin.y - wBorderWidth(pWin));
 188         xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
 189         xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
 190         xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
 191         xnestWindowPriv(pWin)->sibling_above = None;
 192         if (pWin->nextSib)
 193             xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
 194     }
 195
 196     valuemask = 0;
 197
 198     if (mask & CWX &&
 199         xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {
 200         valuemask |= CWX;
 201         values.x =
 202             xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
 203     }
 204
 205     if (mask & CWY &&
 206         xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {
 207         valuemask |= CWY;
 208         values.y =
 209             xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
 210     }
 211
 212     if (mask & CWWidth && xnestWindowPriv(pWin)->width != pWin->drawable.width) {
 213         valuemask |= CWWidth;
 214         values.width = xnestWindowPriv(pWin)->width = pWin->drawable.width;
 215     }
 216
 217     if (mask & CWHeight &&
 218         xnestWindowPriv(pWin)->height != pWin->drawable.height) {
 219         valuemask |= CWHeight;
 220         values.height = xnestWindowPriv(pWin)->height = pWin->drawable.height;
 221     }
 222
 223     if (mask & CWBorderWidth &&
 224         xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {
 225         valuemask |= CWBorderWidth;
 226         values.border_width =
 227             xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
 228     }
 229
 230     if (valuemask)
 231         XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);
 232
 233     if (mask & CWStackingOrder &&
 234         xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {
 235         WindowPtr pSib;
 236
 237         /* find the top sibling */
 238         for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);
 239
 240         /* the top sibling */
 241         valuemask = CWStackMode;
 242         values.stack_mode = Above;
 243         XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);
 244         xnestWindowPriv(pSib)->sibling_above = None;
 245
 246         /* the rest of siblings */
 247         for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {
 248             valuemask = CWSibling | CWStackMode;
 249             values.sibling = xnestWindowSiblingAbove(pSib);
 250             values.stack_mode = Below;
 251             XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask,
 252                              &values);
 253             xnestWindowPriv(pSib)->sibling_above =
 254                 xnestWindowSiblingAbove(pSib);
 255         }
 256     }
 257 }
 258
 259 Bool
 260 xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
 261 {
 262     XSetWindowAttributes attributes;
 263
 264     if (mask & CWBackPixmap)
 265         switch (pWin->backgroundState) {
 266         case None:
 267             attributes.background_pixmap = None;
 268             break;
 269
 270         case ParentRelative:
 271             attributes.background_pixmap = ParentRelative;
 272             break;
 273
 274         case BackgroundPixmap:
 275             attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);
 276             break;
 277
 278         case BackgroundPixel:
 279             mask &= ~CWBackPixmap;
 280             break;
 281         }
 282
 283     if (mask & CWBackPixel) {
 284         if (pWin->backgroundState == BackgroundPixel)
 285             attributes.background_pixel = xnestPixel(pWin->background.pixel);
 286         else
 287             mask &= ~CWBackPixel;
 288     }
 289
 290     if (mask & CWBorderPixmap) {
 291         if (pWin->borderIsPixel)
 292             mask &= ~CWBorderPixmap;
 293         else
 294             attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);
 295     }
 296
 297     if (mask & CWBorderPixel) {
 298         if (pWin->borderIsPixel)
 299             attributes.border_pixel = xnestPixel(pWin->border.pixel);
 300         else
 301             mask &= ~CWBorderPixel;
 302     }
 303
 304     if (mask & CWBitGravity)
 305         attributes.bit_gravity = pWin->bitGravity;
 306
 307     if (mask & CWWinGravity)    /* dix does this for us */
 308         mask &= ~CWWinGravity;
 309
 310     if (mask & CWBackingStore)  /* this is really not useful */
 311         mask &= ~CWBackingStore;
 312
 313     if (mask & CWBackingPlanes) /* this is really not useful */
 314         mask &= ~CWBackingPlanes;
 315
 316     if (mask & CWBackingPixel)  /* this is really not useful */
 317         mask &= ~CWBackingPixel;
 318
 319     if (mask & CWOverrideRedirect)
 320         attributes.override_redirect = pWin->overrideRedirect;
 321
 322     if (mask & CWSaveUnder)     /* this is really not useful */
 323         mask &= ~CWSaveUnder;
 324
 325     if (mask & CWEventMask)     /* events are handled elsewhere */
 326         mask &= ~CWEventMask;
 327
 328     if (mask & CWDontPropagate) /* events are handled elsewhere */
 329         mask &= ~CWDontPropagate;
 330
 331     if (mask & CWColormap) {
 332         ColormapPtr pCmap;
 333
 334         dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
 335                                 RT_COLORMAP, serverClient, DixUseAccess);
 336
 337         attributes.colormap = xnestColormap(pCmap);
 338
 339         xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
 340     }
 341
 342     if (mask & CWCursor)        /* this is handeled in cursor code */
 343         mask &= ~CWCursor;
 344
 345     if (mask)
 346         XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),
 347                                 mask, &attributes);
 348
 349     return True;
 350 }
 351
 352 Bool
 353 xnestRealizeWindow(WindowPtr pWin)
 354 {
 355     xnestConfigureWindow(pWin, CWStackingOrder);
 356     xnestShapeWindow(pWin);
 357     XMapWindow(xnestDisplay, xnestWindow(pWin));
 358
 359     return True;
 360 }
 361
 362 Bool
 363 xnestUnrealizeWindow(WindowPtr pWin)
 364 {
 365     XUnmapWindow(xnestDisplay, xnestWindow(pWin));
 366
 367     return True;
 368 }
 369
 370 void
 371 xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
 372 {
 373 }
 374
 375 void
 376 xnestClipNotify(WindowPtr pWin, int dx, int dy)
 377 {
 378     xnestConfigureWindow(pWin, CWStackingOrder);
 379     xnestShapeWindow(pWin);
 380 }
 381
 382 static Bool
 383 xnestWindowExposurePredicate(Display * display, XEvent * event, XPointer ptr)
 384 {
 385     return (event->type == Expose && event->xexpose.window == *(Window *) ptr);
 386 }
 387
 388 void
 389 xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
 390 {
 391     XEvent event;
 392     Window window;
 393     BoxRec Box;
 394
 395     XSync(xnestDisplay, False);
 396
 397     window = xnestWindow(pWin);
 398
 399     while (XCheckIfEvent(xnestDisplay, &event,
 400                          xnestWindowExposurePredicate, (char *) &window)) {
 401
 402         Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;
 403         Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;
 404         Box.x2 = Box.x1 + event.xexpose.width;
 405         Box.y2 = Box.y1 + event.xexpose.height;
 406
 407         event.xexpose.type = ProcessedExpose;
 408
 409         if (RegionContainsRect(pRgn, &Box) != rgnIN)
 410             XPutBackEvent(xnestDisplay, &event);
 411     }
 412
 413     miWindowExposures(pWin, pRgn, other_exposed);
 414 }
 415
 416 void
 417 xnestSetShape(WindowPtr pWin, int kind)
 418 {
 419     xnestShapeWindow(pWin);
 420     miSetShape(pWin, kind);
 421 }
 422
 423 static Bool
 424 xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
 425 {
 426     BoxPtr pBox1, pBox2;
 427     unsigned int n1, n2;
 428
 429     if (pReg1 == pReg2)
 430         return True;
 431
 432     if (pReg1 == NullRegion || pReg2 == NullRegion)
 433         return False;
 434
 435     pBox1 = RegionRects(pReg1);
 436     n1 = RegionNumRects(pReg1);
 437
 438     pBox2 = RegionRects(pReg2);
 439     n2 = RegionNumRects(pReg2);
 440
 441     if (n1 != n2)
 442         return False;
 443
 444     if (pBox1 == pBox2)
 445         return True;
 446
 447     if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec)))
 448         return False;
 449
 450     return True;
 451 }
 452
 453 void
 454 xnestShapeWindow(WindowPtr pWin)
 455 {
 456     Region reg;
 457     BoxPtr pBox;
 458     XRectangle rect;
 459     int i;
 460
 461     if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,
 462                           wBoundingShape(pWin))) {
 463
 464         if (wBoundingShape(pWin)) {
 465             RegionCopy(xnestWindowPriv(pWin)->bounding_shape,
 466                        wBoundingShape(pWin));
 467
 468             reg = XCreateRegion();
 469             pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);
 470             for (i = 0;
 471                  i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);
 472                  i++) {
 473                 rect.x = pBox[i].x1;
 474                 rect.y = pBox[i].y1;
 475                 rect.width = pBox[i].x2 - pBox[i].x1;
 476                 rect.height = pBox[i].y2 - pBox[i].y1;
 477                 XUnionRectWithRegion(&rect, reg, reg);
 478             }
 479             XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
 480                                 ShapeBounding, 0, 0, reg, ShapeSet);
 481             XDestroyRegion(reg);
 482         }
 483         else {
 484             RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);
 485
 486             XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
 487                               ShapeBounding, 0, 0, None, ShapeSet);
 488         }
 489     }
 490
 491     if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin))) {
 492
 493         if (wClipShape(pWin)) {
 494             RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));
 495
 496             reg = XCreateRegion();
 497             pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);
 498             for (i = 0;
 499                  i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape); i++) {
 500                 rect.x = pBox[i].x1;
 501                 rect.y = pBox[i].y1;
 502                 rect.width = pBox[i].x2 - pBox[i].x1;
 503                 rect.height = pBox[i].y2 - pBox[i].y1;
 504                 XUnionRectWithRegion(&rect, reg, reg);
 505             }
 506             XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
 507                                 ShapeClip, 0, 0, reg, ShapeSet);
 508             XDestroyRegion(reg);
 509         }
 510         else {
 511             RegionEmpty(xnestWindowPriv(pWin)->clip_shape);
 512
 513             XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
 514                               ShapeClip, 0, 0, None, ShapeSet);
 515         }
 516     }
 517 }