/* * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina. * * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation on the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial * portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Author: * Rickard E. (Rik) Faith * Kevin E. Martin * */ /** \file * This file provides the only interface to the X server extension support * in programs/Xserver/Xext. Those programs should only include dmxext.h */ #ifdef HAVE_DMX_CONFIG_H #include #endif #include "dmx.h" #include "dmxinit.h" #include "dmxextension.h" #include "dmxwindow.h" #include "dmxcb.h" #include "dmxcursor.h" #include "dmxpixmap.h" #include "dmxgc.h" #include "dmxfont.h" #include "dmxcmap.h" #include "dmxshm.h" #ifdef RENDER #include "dmxpict.h" #endif #ifdef RANDR #include "dmxrandr.h" #endif #include "dmxinput.h" #include "dmxlog.h" #include "dmxgrab.h" #include "dmxsync.h" #include "dmxscrinit.h" #ifdef XV #include "dmxxv.h" #endif #include "windowstr.h" #include "inputstr.h" /* For DeviceIntRec */ #include /* For DMX_BAD_* */ #include "cursorstr.h" #include "propertyst.h" #ifdef PANORAMIX #include "panoramiXsrv.h" #endif #define dmxErrorSet(set, error, name, fmt, ...) \ if (set) (*set) (error, name, fmt, ##__VA_ARGS__) #define dmxLogErrorSet(type, set, error, name, fmt, ...) \ dmxLog (type, fmt "\n", ##__VA_ARGS__); \ dmxErrorSet (set, error, name, fmt, ##__VA_ARGS__) /* The default font is declared in dix/globals.c, but is not included in * _any_ header files. */ extern FontPtr defaultFont; /** This routine provides information to the DMX protocol extension * about a particular screen. */ Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr) { DMXScreenInfo *dmxScreen; if (physical < 0 || physical >= dmxNumScreens) return FALSE; dmxScreen = &dmxScreens[physical]; attr->name = dmxScreen->name; attr->displayName = dmxScreen->display; #ifdef PANORAMIX attr->logicalScreen = noPanoramiXExtension ? dmxScreen->index : 0; #else attr->logicalScreen = dmxScreen->index; #endif attr->screenWindowWidth = dmxScreen->scrnWidth; attr->screenWindowHeight = dmxScreen->scrnHeight; attr->screenWindowXoffset = 0; attr->screenWindowYoffset = 0; attr->rootWindowWidth = WindowTable[physical]->drawable.width; attr->rootWindowHeight = WindowTable[physical]->drawable.height; #ifdef PANORAMIX if (!noPanoramiXExtension) { attr->rootWindowWidth = PanoramiXPixWidth; attr->rootWindowHeight = PanoramiXPixHeight; } #endif attr->rootWindowXoffset = dmxScreen->rootX; attr->rootWindowYoffset = dmxScreen->rootY; attr->rootWindowXorigin = 0; attr->rootWindowYorigin = 0; return TRUE; } /** This routine provides information to the DMX protocol extension * about a particular window. */ Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr) { dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow); attr->screen = pWindow->drawable.pScreen->myNum; attr->window = pWinPriv->window; attr->pos.x = pWindow->drawable.x; attr->pos.y = pWindow->drawable.y; attr->pos.width = pWindow->drawable.width; attr->pos.height = pWindow->drawable.height; if (!pWinPriv->window || pWinPriv->offscreen) { attr->vis.x = 0; attr->vis.y = 0; attr->vis.height = 0; attr->vis.width = 0; return pWinPriv->window ? TRUE : FALSE; } /* Compute display-relative coordinates */ attr->vis.x = pWindow->drawable.x; attr->vis.y = pWindow->drawable.y; attr->vis.width = pWindow->drawable.width; attr->vis.height = pWindow->drawable.height; if (attr->pos.x < 0) { attr->vis.x -= attr->pos.x; attr->vis.width = attr->pos.x + attr->pos.width - attr->vis.x; } if (attr->pos.x + attr->pos.width > pWindow->drawable.pScreen->width) { if (attr->pos.x < 0) attr->vis.width = pWindow->drawable.pScreen->width; else attr->vis.width = pWindow->drawable.pScreen->width - attr->pos.x; } if (attr->pos.y < 0) { attr->vis.y -= attr->pos.y; attr->vis.height = attr->pos.y + attr->pos.height - attr->vis.y; } if (attr->pos.y + attr->pos.height > pWindow->drawable.pScreen->height) { if (attr->pos.y < 0) attr->vis.height = pWindow->drawable.pScreen->height; else attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y; } /* Convert to window-relative coordinates */ attr->vis.x -= attr->pos.x; attr->vis.y -= attr->pos.y; return TRUE; } /** This routine provides information to the DMX protocol extension * about a particular window. */ Bool dmxGetDrawableAttributes(DrawablePtr pDraw, DMXWindowAttributesPtr attr) { if ((pDraw->type == UNDRAWABLE_WINDOW) || (pDraw->type == DRAWABLE_WINDOW)) { WindowPtr pWindow = (WindowPtr) pDraw; dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV (pWindow); attr->screen = pWindow->drawable.pScreen->myNum; attr->window = pWinPriv->window; attr->pos.x = pWindow->drawable.x; attr->pos.y = pWindow->drawable.y; attr->pos.width = pWindow->drawable.width; attr->pos.height = pWindow->drawable.height; if (!pWinPriv->window || pWinPriv->offscreen) { attr->vis.x = 0; attr->vis.y = 0; attr->vis.height = 0; attr->vis.width = 0; return pWinPriv->window ? TRUE : FALSE; } /* Compute display-relative coordinates */ attr->vis.x = pWindow->drawable.x; attr->vis.y = pWindow->drawable.y; attr->vis.width = pWindow->drawable.width; attr->vis.height = pWindow->drawable.height; if (attr->pos.x < 0) { attr->vis.x -= attr->pos.x; attr->vis.width = attr->pos.x + attr->pos.width - attr->vis.x; } if (attr->pos.x + attr->pos.width > pWindow->drawable.pScreen->width) { if (attr->pos.x < 0) attr->vis.width = pWindow->drawable.pScreen->width; else attr->vis.width = pWindow->drawable.pScreen->width - attr->pos.x; } if (attr->pos.y < 0) { attr->vis.y -= attr->pos.y; attr->vis.height = attr->pos.y + attr->pos.height - attr->vis.y; } if (attr->pos.y + attr->pos.height > pWindow->drawable.pScreen->height) { if (attr->pos.y < 0) attr->vis.height = pWindow->drawable.pScreen->height; else attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y; } /* Convert to window-relative coordinates */ attr->vis.x -= attr->pos.x; attr->vis.y -= attr->pos.y; } else { PixmapPtr pPixmap = (PixmapPtr) pDraw; dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV (pPixmap); xRectangle empty = { 0, 0, 0, 0 }; attr->screen = pDraw->pScreen->myNum; attr->window = pPixPriv->pixmap; attr->pos = attr->vis = empty; } return TRUE; } void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr) { attr->width = dmxGlobalWidth; attr->height = dmxGlobalHeight; attr->shiftX = 0; /* NOTE: The upper left hand corner of */ attr->shiftY = 0; /* the desktop is always <0,0>. */ } /** Return the total number of devices, not just #dmxNumInputs. The * number returned should be the same as that returned by * XListInputDevices. */ int dmxGetInputCount(void) { int i, total; for (total = i = 0; i < dmxNumScreens; i++) total += dmxScreens[i].input.numDevs; return total; } /** Return information about the device with id = \a deviceId. This * information is primarily for the #ProcDMXGetInputAttributes() * function, which does not have access to the appropriate data * structure. */ int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr) { int i, j; DMXInputInfo *dmxInput; if (deviceId < 0) return -1; for (i = 0; i < dmxNumScreens; i++) { dmxInput = &dmxScreens[i].input; for (j = 0; j < dmxInput->numDevs; j++) { if (deviceId != dmxInput->devs[i]->id) continue; attr->isCore = FALSE; attr->sendsCore = TRUE; attr->detached = FALSE; attr->inputType = 2; attr->physicalScreen = i; attr->name = dmxInput->devs[i]->name; attr->physicalId = deviceId; return 0; /* Success */ } } return -1; /* Failure */ } /** Add an input with the specified attributes. If the input is added, * the physical id is returned in \a deviceId. */ int dmxAddInput(DMXInputAttributesPtr attr, int *id) { if (attr->physicalScreen < 0 || attr->physicalScreen >= dmxNumScreens) return BadValue; if (attr->inputType == 2) { DMXScreenInfo *dmxScreen = &dmxScreens[attr->physicalScreen]; int ret; if (dmxScreen->beDisplay) { ret = dmxInputAttach (&dmxScreen->input); if (ret != Success) return ret; dmxInputEnable (&dmxScreen->input); } else { dmxScreen->beDisplay = dmxScreen->beAttachedDisplay; ret = dmxInputAttach (&dmxScreen->input); dmxScreen->beDisplay = NULL; if (ret != Success) return ret; } *id = attr->physicalScreen; return ret; } return BadValue; } /** Remove the input with physical id \a id. */ int dmxRemoveInput(int id) { int ret; if (id < 0 || id >= dmxNumScreens) return BadValue; if (dmxScreens[id].beDisplay) { dmxInputDisable (&dmxScreens[id].input); ret = dmxInputDetach (&dmxScreens[id].input); } else { dmxScreens[id].beDisplay = dmxScreens[id].beAttachedDisplay; ret = dmxInputDetach (&dmxScreens[id].input); dmxScreens[id].beDisplay = NULL; } return ret; } /** Return the value of #dmxNumScreens -- the total number of backend * screens in use (these are logical screens and may be larger than the * number of backend displays). */ unsigned long dmxGetNumScreens(void) { return dmxNumScreens; } /** Make sure that #dmxCreateAndRealizeWindow has been called for \a * pWindow. */ void dmxForceWindowCreation(WindowPtr pWindow) { dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow); if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE); } /** Flush pending syncs for all screens. */ void dmxFlushPendingSyncs(void) { dmxSync(NULL, TRUE); } /** Update DMX's screen resources to match those of the newly moved * and/or resized "root" window. */ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h) { DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; WindowPtr pRoot = WindowTable[pScreen->myNum]; WindowPtr pChild; Bool anyMarked = FALSE; /* Handle special case where width and/or height are zero */ if (w == 0 || h == 0) { w = 1; h = 1; } /* Change screen size */ pScreen->width = w; pScreen->height = h; /* Reset the root window's drawable's size */ pRoot->drawable.width = w; pRoot->drawable.height = h; /* Set the root window's new winSize and borderSize */ pRoot->winSize.extents.x1 = 0; pRoot->winSize.extents.y1 = 0; pRoot->winSize.extents.x2 = w; pRoot->winSize.extents.y2 = h; pRoot->borderSize.extents.x1 = 0; pRoot->borderSize.extents.y1 = 0; pRoot->borderSize.extents.x2 = w; pRoot->borderSize.extents.y2 = h; /* Recompute this screen's mmWidth & mmHeight */ pScreen->mmWidth = (w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10); pScreen->mmHeight = (h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10); /* Recompute this screen's window's clip rects as follows: */ /* 1. Mark all of root's children's windows */ for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib) anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild, (WindowPtr *)NULL); /* 2. Set the root window's borderClip */ pRoot->borderClip.extents.x1 = 0; pRoot->borderClip.extents.y1 = 0; pRoot->borderClip.extents.x2 = w; pRoot->borderClip.extents.y2 = h; /* 3. Set the root window's clipList */ if (anyMarked) { /* If any windows have been marked, set the root window's * clipList to be broken since it will be recalculated in * ValidateTree() */ REGION_BREAK(pScreen, &pRoot->clipList); } else { /* Otherwise, we just set it directly since there are no * windows visible on this screen */ pRoot->clipList.extents.x1 = 0; pRoot->clipList.extents.y1 = 0; pRoot->clipList.extents.x2 = w; pRoot->clipList.extents.y2 = h; } /* 4. Revalidate all clip rects and generate expose events */ if (anyMarked) { pScreen->ValidateTree(pRoot, NULL, VTBroken); pScreen->HandleExposures(pRoot); if (pScreen->PostValidateTree) pScreen->PostValidateTree(pRoot, NULL, VTBroken); } } /** Create the scratch GCs per depth. */ static void dmxBECreateScratchGCs(int scrnNum) { ScreenPtr pScreen = screenInfo.screens[scrnNum]; GCPtr *ppGC = pScreen->GCperDepth; int i; for (i = 0; i <= pScreen->numDepths; i++) dmxBECreateGC(pScreen, ppGC[i]); } #ifdef PANORAMIX static Bool FoundPixImage; extern unsigned long XRT_PICTURE; /** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs * to have its image restored. When it is found, see if there is * another screen with the same image. If so, copy the pixmap image * from the existing screen to the newly created pixmap. */ static void dmxBERestorePixmapImage(pointer value, XID id, RESTYPE type, pointer p) { PixmapPtr pSrc = NULL; PixmapPtr pDst = (PixmapPtr) p; int idx = pDst->drawable.pScreen->myNum; int i; if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) { int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinPix = (PanoramiXRes *)value; PixmapPtr pPix; pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP); if (pPix != pDst) return; /* Not a match.... Next! */ for (i = 0; i < PanoramiXNumScreens; i++) { if (i == idx) continue; /* Self replication is bad */ pSrc = (PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP); break; } } #ifdef RENDER else if ((type & TypeMask) == (XRT_PICTURE & TypeMask)) { int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinPic = (PanoramiXRes *) value; PicturePtr pPic; pPic = (PicturePtr) LookupIDByType (pXinPic->info[idx].id, PictureType); /* Not a match.... Next! */ if (!pPic || !pPic->pDrawable) return; if (pPic->pDrawable->type != DRAWABLE_PIXMAP) return; if (pPic->pDrawable != (DrawablePtr) pDst) return; for (i = 0; i < PanoramiXNumScreens; i++) { if (i == idx) continue; /* Self replication is bad */ pPic = (PicturePtr) LookupIDByType (pXinPic->info[i].id, PictureType); pSrc = (PixmapPtr) pPic->pDrawable; break; } } #endif else if ((type & TypeMask) == (XRT_WINDOW & TypeMask)) { PixmapPtr pDst = (PixmapPtr)p; int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinWin = (PanoramiXRes *) value; Bool border; WindowPtr pWin; pWin = (WindowPtr) LookupIDByType (pXinWin->info[idx].id, RT_WINDOW); if (!pWin) return; if (!pWin->borderIsPixel && pWin->border.pixmap == pDst) { border = TRUE; } else if (pWin->backgroundState == BackgroundPixmap && pWin->background.pixmap == pDst) { border = FALSE; } else { return; } for (i = 0; i < PanoramiXNumScreens; i++) { if (i == idx) continue; /* Self replication is bad */ pWin = (WindowPtr) LookupIDByType (pXinWin->info[i].id, RT_WINDOW); if (border) pSrc = pWin->border.pixmap; else pSrc = pWin->background.pixmap; break; } } if (pSrc) { dmxPixPrivPtr pSrcPriv = DMX_GET_PIXMAP_PRIV (pSrc); if (pSrcPriv->pixmap) { DMXScreenInfo *dmxSrcScreen = &dmxScreens[i]; DMXScreenInfo *dmxDstScreen = &dmxScreens[idx]; dmxPixPrivPtr pDstPriv = DMX_GET_PIXMAP_PRIV(pDst); XImage *img = NULL; int j; XlibGC gc = NULL; /* This should never happen, but just in case.... */ if (pSrc->drawable.width != pDst->drawable.width || pSrc->drawable.height != pDst->drawable.height) return; XLIB_PROLOGUE (dmxSrcScreen); /* Copy from src pixmap to dst pixmap */ img = XGetImage(dmxSrcScreen->beDisplay, pSrcPriv->pixmap, 0, 0, pSrc->drawable.width, pSrc->drawable.height, -1, ZPixmap); XLIB_EPILOGUE (dmxSrcScreen); if (img) { for (j = 0; j < dmxDstScreen->beNumPixmapFormats; j++) { if (dmxDstScreen->bePixmapFormats[j].depth == img->depth) { unsigned long m; XGCValues v; m = GCFunction | GCPlaneMask | GCClipMask; v.function = GXcopy; v.plane_mask = AllPlanes; v.clip_mask = None; XLIB_PROLOGUE (dmxDstScreen); gc = XCreateGC(dmxDstScreen->beDisplay, dmxDstScreen->scrnDefDrawables[j], m, &v); XLIB_EPILOGUE (dmxDstScreen); break; } } if (gc) { XLIB_PROLOGUE (dmxDstScreen); XPutImage(dmxDstScreen->beDisplay, pDstPriv->pixmap, gc, img, 0, 0, 0, 0, pDst->drawable.width, pDst->drawable.height); XFreeGC(dmxDstScreen->beDisplay, gc); XLIB_EPILOGUE (dmxDstScreen); FoundPixImage = True; } else { dmxLog(dmxWarning, "Could not create GC\n"); } XDestroyImage(img); } else { dmxLog(dmxWarning, "Could not create image\n"); } } } } #endif /** Restore the pixmap image either from another screen or from an image * that was saved when the screen was previously detached. */ static void dmxBERestorePixmap(PixmapPtr pPixmap) { #ifdef PANORAMIX int i; /* If Xinerama is not active, there's nothing we can do (see comment * in #else below for more info). */ if (noPanoramiXExtension) { dmxLog(dmxWarning, "Cannot restore pixmap image\n"); return; } FoundPixImage = False; for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindAllClientResources(clients[i], dmxBERestorePixmapImage, (pointer)pPixmap); /* No corresponding pixmap image was found on other screens, so we * need to copy it from the saved image when the screen was detached * (if available). */ if (!FoundPixImage) { dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap); if (pPixPriv->detachedImage) { ScreenPtr pScreen = pPixmap->drawable.pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; XlibGC gc = NULL; for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) { if (dmxScreen->bePixmapFormats[i].depth == pPixPriv->detachedImage->depth) { unsigned long m; XGCValues v; m = GCFunction | GCPlaneMask | GCClipMask; v.function = GXcopy; v.plane_mask = AllPlanes; v.clip_mask = None; XLIB_PROLOGUE (dmxScreen); gc = XCreateGC(dmxScreen->beDisplay, dmxScreen->scrnDefDrawables[i], m, &v); XLIB_EPILOGUE (dmxScreen); break; } } if (gc) { XLIB_PROLOGUE (dmxScreen); XPutImage(dmxScreen->beDisplay, pPixPriv->pixmap, gc, pPixPriv->detachedImage, 0, 0, 0, 0, pPixmap->drawable.width, pPixmap->drawable.height); XFreeGC(dmxScreen->beDisplay, gc); XLIB_EPILOGUE (dmxScreen); } else { dmxLog(dmxWarning, "Cannot restore pixmap image\n"); } XDestroyImage(pPixPriv->detachedImage); pPixPriv->detachedImage = NULL; } else { dmxLog(dmxWarning, "Cannot restore pixmap image: %dx%d - %d\n", pPixmap->drawable.width, pPixmap->drawable.height, pPixmap->drawable.depth); } } #else /* If Xinerama is not enabled, then there is no other copy of the * pixmap image that we can restore. Saving all pixmap data is not * a feasible option since there is no mechanism for updating pixmap * data when a screen is detached, which means that the data that * was previously saved would most likely be out of date. */ dmxLog(dmxWarning, "Cannot restore pixmap image\n"); return; #endif } /** Create resources on the back-end server. This function is called * from #dmxAttachScreen() via the dix layer's FindAllResources * function. It walks all resources, compares them to the screen * number passed in as \a n and calls the appropriate DMX function to * create the associated resource on the back-end server. */ static void dmxBECreateResources(pointer value, XID id, RESTYPE type, pointer n) { int scrnNum = (int)n; ScreenPtr pScreen = screenInfo.screens[scrnNum]; if ((type & TypeMask) == (RT_WINDOW & TypeMask)) { /* Window resources are created below in dmxBECreateWindowTree */ } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) { PixmapPtr pPix = value; if (pPix->drawable.pScreen->myNum == scrnNum) { dmxBECreatePixmap(pPix); dmxBERestorePixmap(pPix); } } else if ((type & TypeMask) == (RT_GC & TypeMask)) { GCPtr pGC = value; if (pGC->pScreen->myNum == scrnNum) { /* Create the GC on the back-end server */ dmxBECreateGC(pScreen, pGC); /* Create any pixmaps associated with this GC */ if (!pGC->tileIsPixel) { dmxBECreatePixmap(pGC->tile.pixmap); dmxBERestorePixmap(pGC->tile.pixmap); } if (pGC->stipple != pScreen->PixmapPerDepth[0]) { dmxBECreatePixmap(pGC->stipple); dmxBERestorePixmap(pGC->stipple); } if (pGC->font != defaultFont) { (void)dmxBELoadFont(pScreen, pGC->font); } /* Update the GC on the back-end server */ dmxChangeGC(pGC, -1L); } } else if ((type & TypeMask) == (RT_FONT & TypeMask)) { (void)dmxBELoadFont(pScreen, (FontPtr)value); } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) { dmxBECreateCursor (pScreen, (CursorPtr) value); } else if ((type & TypeMask) == (RT_PASSIVEGRAB & TypeMask)) { GrabPtr grab = value; if (grab->cursor) dmxBECreateCursor (pScreen, grab->cursor); } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) { ColormapPtr pCmap = value; if (pCmap->pScreen->myNum == scrnNum) (void)dmxBECreateColormap((ColormapPtr)value); } else if ((type & TypeMask) == (DMX_SHMSEG & TypeMask)) { dmxBEAttachShmSeg (&dmxScreens[scrnNum], (dmxShmSegInfoPtr) value); #if 0 #ifdef RENDER /* TODO: Recreate Picture and GlyphSet resources */ } else if ((type & TypeMask) == (PictureType & TypeMask)) { /* Picture resources are created when windows are created */ } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) { dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value); #endif #endif } else { /* Other resource types??? */ } } /** Create window hierachy on back-end server. The window tree is * created in a special order (bottom most subwindow first) so that the * #dmxCreateNonRootWindow() function does not need to recursively call * itself to create each window's parents. This is required so that we * have the opportunity to create each window's border and background * pixmaps (where appropriate) before the window is created. */ static void dmxBECreateWindowTree(int idx) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; WindowPtr pRoot = WindowTable[idx]; dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pRoot); WindowPtr pWin; /* Create the pixmaps associated with the root window */ if (!pRoot->borderIsPixel) { dmxBECreatePixmap(pRoot->border.pixmap); dmxBERestorePixmap(pRoot->border.pixmap); } if (pRoot->backgroundState == BackgroundPixmap) { dmxBECreatePixmap(pRoot->background.pixmap); dmxBERestorePixmap(pRoot->background.pixmap); } dmxBECreateCursor (screenInfo.screens[idx], pRoot->optional->cursor); /* Create root window first */ dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot); #ifdef RENDER if (pWinPriv->hasPict) dmxCreatePictureList (pRoot); #endif pWin = pRoot->lastChild; while (pWin) { pWinPriv = DMX_GET_WINDOW_PRIV(pWin); /* Create the pixmaps regardless of whether or not the * window is created or not due to lazy window creation. */ if (!pWin->borderIsPixel) { dmxBECreatePixmap(pWin->border.pixmap); dmxBERestorePixmap(pWin->border.pixmap); } if (pWin->backgroundState == BackgroundPixmap) { dmxBECreatePixmap(pWin->background.pixmap); dmxBERestorePixmap(pWin->background.pixmap); } if (wUseDefault(pWin, cursor, 0)) dmxBECreateCursor (screenInfo.screens[idx], pWin->optional->cursor); /* Reset the window attributes */ dmxGetDefaultWindowAttributes(pWin, &pWinPriv->cmap, &pWinPriv->visual); /* Create the window */ dmxCreateAndRealizeWindow(pWin, TRUE); /* Next, create the bottom-most child */ if (pWin->lastChild) { pWin = pWin->lastChild; continue; } /* If the window has no children, move on to the next higher window */ while (!pWin->prevSib && (pWin != pRoot)) pWin = pWin->parent; if (pWin->prevSib) { pWin = pWin->prevSib; continue; } /* When we reach the root window, we are finished */ if (pWin == pRoot) break; } } static void dmxBEMapRootWindow(int idx) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; XLIB_PROLOGUE (dmxScreen); XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin); XLIB_EPILOGUE (dmxScreen); } static void dmxBECreateWindowProperties (int idx) { WindowPtr pRoot = WindowTable[idx]; WindowPtr pRoot0 = pRoot; WindowPtr pWin; WindowPtr pWin0; PropertyPtr pProp, pLast; #ifdef PANORAMIX if (!noPanoramiXExtension) pRoot0 = WindowTable[0]; #endif pWin = pRoot; pWin0 = pRoot0; while (pWin) { pLast = NULL; do { for (pProp = wUserProps (pWin0); pProp; pProp = pProp->next) if (pProp->next == pLast) break; if (pProp) dmxBESetWindowProperty (pWin, (pLast = pProp)); } while (pLast != wUserProps (pWin0)); /* Next, create the bottom-most child */ if (pWin->lastChild) { pWin = pWin->lastChild; pWin0 = pWin0->lastChild; continue; } /* If the window has no children, move on to the next higher window */ while (!pWin->prevSib && (pWin != pRoot)) { pWin = pWin->parent; pWin0 = pWin0->parent; } if (pWin->prevSib) { pWin = pWin->prevSib; pWin0 = pWin0->prevSib; continue; } /* When we reach the root window, we are finished */ if (pWin == pRoot) break; } } /** Compare the new and old screens to see if they are compatible. */ static Bool dmxCompareScreens(DMXScreenInfo *new, DMXScreenInfo *old, dmxErrorSetProcPtr errorSet, void *error, const char *errorName) { int i; #ifdef PANORAMIX if (!noPanoramiXExtension) { ScreenPtr pScreen = screenInfo.screens[0]; int j; old = dmxScreens; /* each new screen must match the first screen */ if (new->beDepth != old->beDepth) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen depth is not %d", old->beDepth); return FALSE; } if (new->beBPP != old->beBPP) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen BPP is not %d", old->beBPP); return FALSE; } for (i = 0; i < old->beNumDepths; i++) { for (j = 0; j < new->beNumDepths; j++) if (new->beDepths[j] == old->beDepths[i]) break; if (j == new->beNumDepths) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen doesn't support depth %d", old->beDepths[i]); return FALSE; } } for (i = 0; i < old->beNumPixmapFormats; i++) { for (j = 0; j < new->beNumPixmapFormats; j++) if (new->bePixmapFormats[j].depth == old->bePixmapFormats[i].depth && new->bePixmapFormats[j].bits_per_pixel == old->bePixmapFormats[i].bits_per_pixel && new->bePixmapFormats[j].scanline_pad == old->bePixmapFormats[i].scanline_pad) break; if (j == new->beNumPixmapFormats) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen doesn't support pixmap format " "depth=%d,bits_per_pixel=%d,scanline_pad=%d\n", old->bePixmapFormats[i].depth, old->bePixmapFormats[i].bits_per_pixel, old->bePixmapFormats[i].scanline_pad); return FALSE; } } for (i = 0; i < pScreen->numVisuals; i++) { int k; for (k = 0; k < old->beNumVisuals; k++) if (pScreen->visuals[i].class == old->beVisuals[k].class && pScreen->visuals[i].bitsPerRGBValue == old->beVisuals[k].bits_per_rgb && pScreen->visuals[i].ColormapEntries == old->beVisuals[k].colormap_size && pScreen->visuals[i].nplanes == old->beVisuals[k].depth && pScreen->visuals[i].redMask == old->beVisuals[k].red_mask && pScreen->visuals[i].greenMask == old->beVisuals[k].green_mask && pScreen->visuals[i].blueMask == old->beVisuals[k].blue_mask) break; assert (k < old->beNumVisuals); for (j = 0; j < new->beNumVisuals; j++) if (new->beVisuals[j].depth == old->beVisuals[k].depth && new->beVisuals[j].class == old->beVisuals[k].class && new->beVisuals[j].red_mask == old->beVisuals[k].red_mask && new->beVisuals[j].green_mask == old->beVisuals[k].green_mask && new->beVisuals[j].blue_mask == old->beVisuals[k].blue_mask && new->beVisuals[j].bits_per_rgb >= old->beVisuals[k].bits_per_rgb && new->beVisuals[j].colormap_size >= old->beVisuals[k].colormap_size) break; if (j == new->beNumVisuals) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen doesn't support visual: " "class: %s, " "depth: %d planes, " "available colormap entries: %d%s, " "red/green/blue masks: 0x%lx/0x%lx/0x%lx, " "significant bits in color specification: " "%d bits", old->beVisuals[k].class == StaticGray ? "StaticGray" : old->beVisuals[k].class == GrayScale ? "GrayScale" : old->beVisuals[k].class == StaticColor ? "StaticColor" : old->beVisuals[k].class == PseudoColor ? "PseudoColor" : old->beVisuals[k].class == TrueColor ? "TrueColor" : old->beVisuals[k].class == DirectColor ? "DirectColor" : "Unknown Class", old->beVisuals[k].depth, old->beVisuals[k].colormap_size, (old->beVisuals[k].class == TrueColor || old->beVisuals[k].class == DirectColor) ? " per subfield" : "", old->beVisuals[k].red_mask, old->beVisuals[k].green_mask, old->beVisuals[k].blue_mask, old->beVisuals[k].bits_per_rgb); return FALSE; } } return TRUE; } #endif if (new->beWidth != old->beWidth || new->beHeight != old->beHeight) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen dimensions are not %dx%d", old->beWidth, old->beHeight); return FALSE; } if (new->beDepth != old->beDepth) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen depth is not %d", old->beDepth); return FALSE; } if (new->beBPP != old->beBPP) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen BPP is not %dx%d", old->beBPP); return FALSE; } if (new->beNumDepths != old->beNumDepths) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen number of depths is not %d", old->beNumDepths); return FALSE; } for (i = 0; i < old->beNumDepths; i++) if (new->beDepths[i] != old->beDepths[i]) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen depth index %d is not %d", i, old->beDepths[i]); return FALSE; } if (new->beNumPixmapFormats != old->beNumPixmapFormats) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen number of pixmap formats is not %d", old->beNumPixmapFormats); return FALSE; } for (i = 0; i < old->beNumPixmapFormats; i++) { if (new->bePixmapFormats[i].depth != old->bePixmapFormats[i].depth) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "depth of screen pixmap format index %d is not %d", i, old->bePixmapFormats[i].depth); return FALSE; } if (new->bePixmapFormats[i].bits_per_pixel != old->bePixmapFormats[i].bits_per_pixel) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "bits_per_pixel of screen pixmap format " "index %d is not %d", i, old->bePixmapFormats[i].bits_per_pixel); return FALSE; } if (new->bePixmapFormats[i].scanline_pad != old->bePixmapFormats[i].scanline_pad) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "scanline_pad of screen pixmap format " "index %d is not %d", i, old->bePixmapFormats[i].scanline_pad); return FALSE; } } if (new->beNumVisuals != old->beNumVisuals) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen number of visuals is not %d", old->beNumVisuals); return FALSE; } for (i = 0; i < old->beNumVisuals; i++) { if (new->beVisuals[i].visualid != old->beVisuals[i].visualid) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "visualid of screen visual " "index %d is not %d", i, old->beVisuals[i].visualid); return FALSE; } if (new->beVisuals[i].screen != old->beVisuals[i].screen) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "screen of screen visual " "index %d is not %d", i, old->beVisuals[i].screen); return FALSE; } if (new->beVisuals[i].depth != old->beVisuals[i].depth) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "depth of screen visual " "index %d is not %d", i, old->beVisuals[i].depth); return FALSE; } if (new->beVisuals[i].class != old->beVisuals[i].class) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "class of screen visual " "index %d is not %d", i, old->beVisuals[i].class); return FALSE; } if (new->beVisuals[i].red_mask != old->beVisuals[i].red_mask) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "red_mask of screen visual " "index %d is not %d", i, old->beVisuals[i].red_mask); return FALSE; } if (new->beVisuals[i].green_mask != old->beVisuals[i].green_mask) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "green_mask of screen visual " "index %d is not %d", i, old->beVisuals[i].green_mask); return FALSE; } if (new->beVisuals[i].blue_mask != old->beVisuals[i].blue_mask) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "blue_mask of screen visual " "index %d is not %d", i, old->beVisuals[i].blue_mask); return FALSE; } if (new->beVisuals[i].colormap_size != old->beVisuals[i].colormap_size) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "colormap_size of screen visual " "index %d is not %d", i, old->beVisuals[i].colormap_size); return FALSE; } if (new->beVisuals[i].bits_per_rgb != old->beVisuals[i].bits_per_rgb) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "bits_per_rgb of screen visual " "index %d is not %d", i, old->beVisuals[i].bits_per_rgb); return FALSE; } } if (new->beDefVisualIndex != old->beDefVisualIndex) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Screen default visual index is not %d", old->beDefVisualIndex); return FALSE; } return TRUE; } #ifdef RENDER /** Restore Render's picture */ static void dmxBERestoreRenderPict(pointer value, XID id, pointer n) { PicturePtr pPicture = value; /* The picture */ DrawablePtr pDraw = pPicture->pDrawable; /* The picture's drawable */ int scrnNum = (int)n; if (pDraw) { if (pDraw->pScreen->myNum != scrnNum) { /* Picture not on the screen we are restoring*/ return; } if (pDraw->type == DRAWABLE_PIXMAP) { PixmapPtr pPixmap = (PixmapPtr)pDraw; /* Create and restore the pixmap drawable */ dmxBECreatePixmap(pPixmap); dmxBERestorePixmap(pPixmap); } } dmxBECreatePicture(scrnNum, pPicture); } /** Restore Render's glyphs */ static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n) { GlyphSetPtr glyphSet = value; int scrnNum = (int)n; dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); DMXScreenInfo *dmxScreen = &dmxScreens[scrnNum]; GlyphRefPtr table; char *images; Glyph *gids; XGlyphInfo *glyphs; char *pos; int beret; int len_images = 0; int i, size; int ctr; if (glyphPriv->glyphSets[scrnNum]) { /* Only restore glyphs on the screen we are attaching */ return; } /* First we must create the glyph set on the backend. */ if ((beret = dmxBECreateGlyphSet(scrnNum, glyphSet)) != Success) { dmxLog(dmxWarning, "\tdmxBERestoreRenderGlyph failed to create glyphset!\n"); return; } /* Now for the complex part, restore the glyph data */ table = glyphSet->hash.table; /* We need to know how much memory to allocate for this part */ for (i = 0; i < glyphSet->hash.hashSet->size; i++) { GlyphRefPtr gr = &table[i]; GlyphPtr gl = gr->glyph; if (!gl || gl == DeletedGlyph) continue; size = gl->info.height * PixmapBytePad (gl->info.width, glyphSet->format->depth); if (size & 3) size += 4 - (size & 3); len_images += size; } if (!len_images) return; /* Now allocate the memory we need */ images = calloc(len_images, sizeof(char)); gids = xalloc(glyphSet->hash.tableEntries*sizeof(Glyph)); glyphs = xalloc(glyphSet->hash.tableEntries*sizeof(XGlyphInfo)); pos = images; ctr = 0; /* Fill the allocated memory with the proper data */ for (i = 0; i < glyphSet->hash.hashSet->size; i++) { GlyphRefPtr gr = &table[i]; GlyphPtr gl = gr->glyph; char *data; if (!gl || gl == DeletedGlyph) continue; /* First lets put the data into gids */ gids[ctr] = gr->signature; /* Next do the glyphs data structures */ glyphs[ctr].width = gl->info.width; glyphs[ctr].height = gl->info.height; glyphs[ctr].x = gl->info.x; glyphs[ctr].y = gl->info.y; glyphs[ctr].xOff = gl->info.xOff; glyphs[ctr].yOff = gl->info.yOff; size = gl->info.height * PixmapBytePad (gl->info.width, glyphSet->format->depth); if (size & 3) size += 4 - (size & 3); data = dixLookupPrivate (&(gl)->devPrivates, dmxGlyphPrivateKey); if (data) { memcpy (pos, data, size); } else { dmxLog (dmxWarning, "Cannot restore glyph image: %dx%d %d\n", gl->info.width, gl->info.height, glyphSet->format->depth); memset (pos, 0xff, size); } pos += size; ctr++; } /* Now restore the glyph data */ XLIB_PROLOGUE (dmxScreen); XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum], gids, glyphs, ctr, images, len_images); XLIB_EPILOGUE (dmxScreen); /* Clean up */ xfree(images); xfree(gids); xfree(glyphs); } #endif /** Reattach previously detached back-end screen. */ int dmxAttachScreen (int idx, DMXScreenAttributesPtr attr, unsigned int window, const char *authType, int authTypeLen, const char *authData, int authDataLen, dmxErrorSetProcPtr errorSet, void *error, const char *errorName) { ScreenPtr pScreen; DMXScreenInfo *dmxScreen; DMXScreenInfo oldDMXScreen; Bool beShape = FALSE; int errorBase; /* Return failure if dynamic addition/removal of screens is disabled */ if (!dmxAddRemoveScreens) { dmxLog(dmxWarning, "Attempting to add a screen, but the AddRemoveScreen\n"); dmxLog(dmxWarning, "extension has not been enabled. To enable this extension\n"); dmxLog(dmxWarning, "add the \"-addremovescreens\" option either to the command\n"); dmxLog(dmxWarning, "line or in the configuration file.\n"); dmxErrorSet (errorSet, error, errorName, "Screen attach extension has not been enabled"); return 1; } /* Cannot add a screen that does not exist */ if (idx < 0 || idx >= dmxNumScreens) { dmxErrorSet (errorSet, error, errorName, "Screen %d does not exist", idx); return 1; } pScreen = screenInfo.screens[idx]; dmxScreen = &dmxScreens[idx]; /* Cannot attach to a screen that is already opened */ if (dmxScreen->name && *dmxScreen->name) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Attempting to attach back-end server to screen #%d " "but back-end server is already attached to this " "screen", idx); return 1; } dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx); /* Save old info */ oldDMXScreen = *dmxScreen; dmxScreen->scrnWin = window; dmxScreen->virtualFb = FALSE; /* Open display and get all of the screen info */ if (!dmxOpenDisplay(dmxScreen, attr->displayName, authType, authTypeLen, authData, authDataLen)) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Can't open display: %s", attr->displayName); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } XLIB_PROLOGUE (dmxScreen); beShape = XShapeQueryExtension (dmxScreen->beDisplay, &dmxScreen->beShapeEventBase, &errorBase); XLIB_EPILOGUE (dmxScreen); if (!beShape) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "SHAPE extension missing on back-end server"); dmxCloseDisplay (dmxScreen); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } #ifdef COMPOSITE if (!noCompositeExtension) { Bool beComposite = FALSE; int eventBase; XLIB_PROLOGUE (dmxScreen); beComposite = XCompositeQueryExtension (dmxScreen->beDisplay, &eventBase, &errorBase); XLIB_EPILOGUE (dmxScreen); if (!beComposite) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "Composite extension missing on back-end server"); dmxCloseDisplay (dmxScreen); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } } #endif if (!dmxScreen->scrnWin) dmxScreen->scrnWin = DefaultRootWindow (dmxScreen->beDisplay); XLIB_PROLOGUE (dmxScreen); XSelectInput (dmxScreen->beDisplay, dmxScreen->scrnWin, StructureNotifyMask); XLIB_EPILOGUE (dmxScreen); dmxSetErrorHandler(dmxScreen); dmxGetScreenAttribs(dmxScreen); if (!dmxGetVisualInfo(dmxScreen)) { dmxLogErrorSet (dmxWarning, errorSet, error, errorName, "No matching visuals found"); XFree(dmxScreen->beVisuals); dmxCloseDisplay (dmxScreen); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } dmxGetColormaps(dmxScreen); dmxGetPixmapFormats(dmxScreen); /* Verify that the screen to be added has the same info as the * previously added screen. */ if (!dmxCompareScreens(dmxScreen, &oldDMXScreen, errorSet, error, errorName)) { dmxLog(dmxWarning, "New screen data (%s) does not match previously\n", dmxScreen->name); dmxLog(dmxWarning, "attached screen data\n"); dmxLog(dmxWarning, "All data must match in order to attach to screen #%d\n", idx); XFree(dmxScreen->beVisuals); XFree(dmxScreen->beDepths); XFree(dmxScreen->bePixmapFormats); dmxCloseDisplay (dmxScreen); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } /* Create the default font */ if (!dmxBELoadFont(pScreen, defaultFont)) { dmxErrorSet (errorSet, error, errorName, "Failed to load default font"); XFree(dmxScreen->beVisuals); XFree(dmxScreen->beDepths); XFree(dmxScreen->bePixmapFormats); dmxCloseDisplay (dmxScreen); /* Restore the old screen */ *dmxScreen = oldDMXScreen; return 1; } /* We used these to compare the old and new screens. They are no * longer needed since we have a newly attached screen, so we can * now free the old screen's resources. */ if (oldDMXScreen.beVisuals) XFree(oldDMXScreen.beVisuals); if (oldDMXScreen.beDepths) XFree(oldDMXScreen.beDepths); if (oldDMXScreen.bePixmapFormats) XFree(oldDMXScreen.bePixmapFormats); if (attr->name) dmxScreen->name = strdup(attr->name); else dmxScreen->name = strdup(attr->displayName); dmxScreen->beAttachedDisplay = dmxScreen->beDisplay; dmxScreen->beDisplay = NULL; dmxScreen->rootX = attr->rootWindowXoffset; dmxScreen->rootY = attr->rootWindowYoffset; return 0; /* Success */ } void dmxEnableScreen (int idx) { ScreenPtr pScreen; DMXScreenInfo *dmxScreen; int i; pScreen = screenInfo.screens[idx]; dmxScreen = &dmxScreens[idx]; dmxLogOutput(dmxScreen, "Enable screen #%d\n", idx); dmxScreen->beDisplay = dmxScreen->beAttachedDisplay; /* Initialize the BE screen resources */ dmxBEScreenInit(screenInfo.screens[idx]); /* TODO: Handle GLX visual initialization. GLXProxy needs to be * updated to handle dynamic addition/removal of screens. */ /* Create default stipple */ dmxBECreatePixmap(pScreen->PixmapPerDepth[0]); dmxBERestorePixmap(pScreen->PixmapPerDepth[0]); /* Create the scratch GCs */ dmxBECreateScratchGCs(idx); /* Create the scratch pixmap */ if (pScreen->pScratchPixmap) dmxBECreatePixmap(pScreen->pScratchPixmap); /* Create all resources that don't depend on windows */ for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindAllClientResources(clients[i], dmxBECreateResources, (pointer)idx); /* Create window hierarchy (top down) */ dmxBECreateWindowTree(idx); dmxBECreateWindowProperties(idx); #ifdef RENDER /* Restore the picture state for RENDER */ for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindClientResourcesByType(clients[i],PictureType, dmxBERestoreRenderPict,(pointer)idx); /* Restore the glyph state for RENDER */ for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindClientResourcesByType(clients[i],GlyphSetType, dmxBERestoreRenderGlyph,(pointer)idx); #endif dmxBEMapRootWindow(idx); #ifdef RANDR RRGetInfo (screenInfo.screens[0]); #endif dmxInputEnable (&dmxScreen->input); } /* * Resources that may have state on the BE server and need to be freed: * * RT_NONE * RT_WINDOW * RT_PIXMAP * RT_GC * RT_FONT * RT_CURSOR * RT_COLORMAP * RT_CMAPENTRY * RT_OTHERCLIENT * RT_PASSIVEGRAB * XRT_WINDOW * XRT_PIXMAP * XRT_GC * XRT_COLORMAP * XRT_PICTURE * PictureType * PictFormatType * GlyphSetType * ClientType * EventType * RT_INPUTCLIENT * XETrapType * RTCounter * RTAwait * RTAlarmClient * RT_XKBCLIENT * RTContext * TagResType * StalledResType * SecurityAuthorizationResType * RTEventClient * __glXContextRes * __glXClientRes * __glXPixmapRes * __glXWindowRes * __glXPbufferRes */ #ifdef PANORAMIX /** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs * to have its image saved. */ static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type, pointer p) { if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) { PixmapPtr pDst = (PixmapPtr)p; int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinPix = (PanoramiXRes *)value; PixmapPtr pPix; int i; pPix = (PixmapPtr)LookupIDByType(pXinPix->info[idx].id, RT_PIXMAP); if (pPix != pDst) return; /* Not a match.... Next! */ for (i = 0; i < PanoramiXNumScreens; i++) { PixmapPtr pSrc; dmxPixPrivPtr pSrcPriv = NULL; if (i == idx) continue; /* Self replication is bad */ pSrc = (PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP); pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc); if (pSrcPriv->pixmap) { FoundPixImage = True; return; } } } #ifdef RENDER else if ((type & TypeMask) == (XRT_PICTURE & TypeMask)) { PixmapPtr pDst = (PixmapPtr) p; int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinPic = (PanoramiXRes *) value; PicturePtr pPic; int i; pPic = (PicturePtr) LookupIDByType (pXinPic->info[idx].id, PictureType); /* Not a match.... Next! */ if (!pPic || !pPic->pDrawable) return; if (pPic->pDrawable->type != DRAWABLE_PIXMAP) return; if (pPic->pDrawable != (DrawablePtr) pDst) return; for (i = 0; i < PanoramiXNumScreens; i++) { dmxPixPrivPtr pSrcPriv = NULL; if (i == idx) continue; /* Self replication is bad */ pPic = (PicturePtr) LookupIDByType (pXinPic->info[i].id, PictureType); pSrcPriv = DMX_GET_PIXMAP_PRIV ((PixmapPtr) pPic->pDrawable); if (pSrcPriv->pixmap) { FoundPixImage = True; return; } } } #endif else if ((type & TypeMask) == (XRT_WINDOW & TypeMask)) { PixmapPtr pDst = (PixmapPtr)p; int idx = pDst->drawable.pScreen->myNum; PanoramiXRes *pXinWin = (PanoramiXRes *) value; Bool border; WindowPtr pWin; int i; pWin = (WindowPtr) LookupIDByType (pXinWin->info[idx].id, RT_WINDOW); if (!pWin) return; if (!pWin->borderIsPixel && pWin->border.pixmap == pDst) { border = TRUE; } else if (pWin->backgroundState == BackgroundPixmap && pWin->background.pixmap == pDst) { border = FALSE; } else { return; } for (i = 0; i < PanoramiXNumScreens; i++) { dmxPixPrivPtr pSrcPriv = NULL; if (i == idx) continue; /* Self replication is bad */ pWin = (WindowPtr) LookupIDByType (pXinWin->info[i].id, RT_WINDOW); if (border) pSrcPriv = DMX_GET_PIXMAP_PRIV (pWin->border.pixmap); else pSrcPriv = DMX_GET_PIXMAP_PRIV (pWin->background.pixmap); if (pSrcPriv->pixmap) { FoundPixImage = True; return; } } } } #endif /** Save the pixmap image only when there is not another screen with * that pixmap from which the image can be read when the screen is * reattached. To do this, we first try to find a pixmap on another * screen corresponding to the one we are trying to save. If we find * one, then we do not need to save the image data since during * reattachment, the image data can be read from that other pixmap. * However, if we do not find one, then we need to save the image data. * The common case for these are for the default stipple and root * tile. */ static void dmxBESavePixmap(PixmapPtr pPixmap) { #ifdef PANORAMIX int i; /* If Xinerama is not active, there's nothing we can do (see comment * in #else below for more info). */ if (noPanoramiXExtension) return; FoundPixImage = False; for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindAllClientResources(clients[i], dmxBEFindPixmapImage, (pointer)pPixmap); /* Save the image only if there is no other screens that have a * pixmap that corresponds to the one we are trying to save. */ if (!FoundPixImage) { dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap); if (!pPixPriv->detachedImage) { ScreenPtr pScreen = pPixmap->drawable.pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; XLIB_PROLOGUE (dmxScreen); pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay, pPixPriv->pixmap, 0, 0, pPixmap->drawable.width, pPixmap->drawable.height, -1, ZPixmap); XLIB_EPILOGUE (dmxScreen); if (!pPixPriv->detachedImage) { dmxLog(dmxWarning, "Cannot save pixmap image: %p - %dx%d %d\n", pPixmap, pPixmap->drawable.width, pPixmap->drawable.height, pPixmap->drawable.depth); } } } #else /* NOTE: The only time there is a pixmap on another screen that * corresponds to the one we are trying to save is when Xinerama is * active. Otherwise, the pixmap image data is only stored on a * single screen, which means that once it is detached, that data is * lost. We could save the data here, but then that would require * us to implement the ability for Xdmx to keep the pixmap up to * date while the screen is detached, which is beyond the scope of * the current project. */ return; #endif } /** Destroy resources on the back-end server. This function is called * from #dmxDetachScreen() via the dix layer's FindAllResources * function. It walks all resources, compares them to the screen * number passed in as \a n and calls the appropriate DMX function to * free the associated resource on the back-end server. */ static void dmxBEDestroyResources(pointer value, XID id, RESTYPE type, pointer n) { int scrnNum = (int)n; ScreenPtr pScreen = screenInfo.screens[scrnNum]; if ((type & TypeMask) == (RT_WINDOW & TypeMask)) { /* Window resources are destroyed below in dmxBEDestroyWindowTree */ } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) { PixmapPtr pPix = value; if (pPix->drawable.pScreen->myNum == scrnNum) { dmxBESavePixmap(pPix); dmxBEFreePixmap(pPix); } } else if ((type & TypeMask) == (RT_GC & TypeMask)) { GCPtr pGC = value; if (pGC->pScreen->myNum == scrnNum) dmxBEFreeGC(pGC); } else if ((type & TypeMask) == (RT_FONT & TypeMask)) { dmxBEFreeFont(pScreen, (FontPtr)value); } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) { dmxBEFreeCursor (pScreen, (CursorPtr) value); } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) { ColormapPtr pCmap = value; if (pCmap->pScreen->myNum == scrnNum) dmxBEFreeColormap((ColormapPtr)value); } else if ((type & TypeMask) == (DMX_SHMSEG & TypeMask)) { dmxBEDetachShmSeg (&dmxScreens[scrnNum], (dmxShmSegInfoPtr) value); #ifdef RENDER } else if ((type & TypeMask) == (PictureType & TypeMask)) { PicturePtr pPict = value; if (pPict->pDrawable) { if (pPict->pDrawable->pScreen->myNum == scrnNum) { /* Free the pixmaps on the backend if needed */ if (pPict->pDrawable->type == DRAWABLE_PIXMAP) { PixmapPtr pPixmap = (PixmapPtr)(pPict->pDrawable); dmxBESavePixmap(pPixmap); dmxBEFreePixmap(pPixmap); } dmxBEFreePicture(pScreen, (PicturePtr)value); } } else { dmxBEFreePicture(pScreen, (PicturePtr)value); } } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) { dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value); #endif } else { /* Other resource types??? */ } } /** Destroy the scratch GCs that are created per depth. */ static void dmxBEDestroyScratchGCs(int scrnNum) { ScreenPtr pScreen = screenInfo.screens[scrnNum]; GCPtr *ppGC = pScreen->GCperDepth; int i; for (i = 0; i <= pScreen->numDepths; i++) dmxBEFreeGC(ppGC[i]); } /** Destroy window hierachy on back-end server. To ensure that all * XDestroyWindow() calls succeed, they must be performed in a bottom * up order so that windows are not destroyed before their children. * XDestroyWindow(), which is called from #dmxBEDestrowWindow(), will * destroy a window as well as all of it's children. */ static void dmxBEDestroyWindowTree(int idx) { WindowPtr pWin = WindowTable[idx]; WindowPtr pChild = pWin; while (1) { if (pChild->firstChild) { pChild = pChild->firstChild; continue; } /* Destroy the window */ dmxBEDestroyWindow(pChild); if (wUseDefault(pChild, cursor, 0)) dmxBEFreeCursor (screenInfo.screens[idx], pChild->optional->cursor); /* Make sure we destroy the window's border and background * pixmaps if they exist */ if (!pChild->borderIsPixel) { dmxBESavePixmap(pChild->border.pixmap); dmxBEFreePixmap(pChild->border.pixmap); } if (pChild->backgroundState == BackgroundPixmap) { dmxBESavePixmap(pChild->background.pixmap); dmxBEFreePixmap(pChild->background.pixmap); } while (!pChild->nextSib && (pChild != pWin)) { pChild = pChild->parent; dmxBEDestroyWindow(pChild); if (wUseDefault(pChild, cursor, 0)) dmxBEFreeCursor (screenInfo.screens[idx], pChild->optional->cursor); if (!pChild->borderIsPixel) { dmxBESavePixmap(pChild->border.pixmap); dmxBEFreePixmap(pChild->border.pixmap); } if (pChild->backgroundState == BackgroundPixmap) { dmxBESavePixmap(pChild->background.pixmap); dmxBEFreePixmap(pChild->background.pixmap); } } if (pChild == pWin) break; pChild = pChild->nextSib; } } void dmxDisableScreen (int idx) { ScreenPtr pScreen; DMXScreenInfo *dmxScreen; int i; pScreen = screenInfo.screens[idx]; dmxScreen = &dmxScreens[idx]; dmxLogOutput(dmxScreen, "Disable screen #%d\n", idx); dmxInputDisable (&dmxScreen->input); #ifdef XV dmxBEXvScreenFini (pScreen); #endif #ifdef RANDR dmxBERRScreenFini (pScreen); #endif /* Save all relevant state (TODO) */ /* Free all non-window resources related to this screen */ for (i = currentMaxClients; --i >= 0; ) if (clients[i]) FindAllClientResources(clients[i], dmxBEDestroyResources, (pointer)idx); /* Free scratch GCs */ dmxBEDestroyScratchGCs(idx); /* Free window resources related to this screen */ dmxBEDestroyWindowTree(idx); /* Free default stipple */ dmxBESavePixmap(pScreen->PixmapPerDepth[0]); dmxBEFreePixmap(pScreen->PixmapPerDepth[0]); if (pScreen->pScratchPixmap) dmxBEFreePixmap(pScreen->pScratchPixmap); /* Free the remaining screen resources and close the screen */ dmxBECloseScreen(pScreen); /* Screen is now disabled */ dmxScreen->beDisplay = NULL; /* Make sure we don't have any pending sync replies */ dmxScreenSyncReply (pScreen, 0, NULL, NULL, 0); #ifdef RANDR RRGetInfo (screenInfo.screens[0]); #endif } /** Detach back-end screen. */ int dmxDetachScreen(int idx) { DMXScreenInfo *dmxScreen; /* Return failure if dynamic addition/removal of screens is disabled */ if (!dmxAddRemoveScreens) { dmxLog(dmxWarning, "Attempting to remove a screen, but the AddRemoveScreen\n"); dmxLog(dmxWarning, "extension has not been enabled. To enable this extension\n"); dmxLog(dmxWarning, "add the \"-addremovescreens\" option either to the command\n"); dmxLog(dmxWarning, "line or in the configuration file.\n"); return 1; } /* Cannot remove a screen that does not exist */ if (idx < 0 || idx >= dmxNumScreens) return 1; dmxScreen = &dmxScreens[idx]; if (idx == 0) { dmxLog(dmxWarning, "Attempting to remove screen #%d\n", idx); return 1; } /* Cannot detach from a screen that is not opened */ if (!dmxScreen->beAttachedDisplay && !dmxScreen->beDisplay) { dmxLog(dmxWarning, "Attempting to remove screen #%d but it has not been opened\n", idx); return 1; } dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx); if (dmxScreen->beDisplay) dmxDisableScreen (idx); /* Detach input */ dmxInputDetach (&dmxScreen->input); dmxScreen->beDisplay = dmxScreen->beAttachedDisplay; dmxCloseDisplay (dmxScreen); dmxScreen->beAttachedDisplay = NULL; dmxScreen->beDisplay = NULL; dmxScreen->scrnWidth = 1; dmxScreen->scrnHeight = 1; dmxScreen->rootX = 0; dmxScreen->rootY = 0; dmxScreen->beWidth = 1; dmxScreen->beHeight = 1; dmxScreen->beXDPI = 75; dmxScreen->beYDPI = 75; dmxScreen->beDepth = 24; dmxScreen->beBPP = 32; if (dmxScreen->name) { free (dmxScreen->name); dmxScreen->name = NULL; } if (dmxScreen->display) { free (dmxScreen->display); dmxScreen->display = NULL; } if (dmxScreen->authType) { free (dmxScreen->authType); dmxScreen->authType = NULL; } dmxScreen->authTypeLen = 0; if (dmxScreen->authData) { free (dmxScreen->authData); dmxScreen->authData = NULL; } dmxScreen->authDataLen = 0; #ifdef RANDR RRGetInfo (screenInfo.screens[0]); #endif return 0; /* Success */ }