diff options
Diffstat (limited to 'xorg-server/hw/dmx/dmxextension.c')
| -rw-r--r-- | xorg-server/hw/dmx/dmxextension.c | 1770 |
1 files changed, 926 insertions, 844 deletions
diff --git a/xorg-server/hw/dmx/dmxextension.c b/xorg-server/hw/dmx/dmxextension.c index 80d11ee89..faa28a590 100644 --- a/xorg-server/hw/dmx/dmxextension.c +++ b/xorg-server/hw/dmx/dmxextension.c @@ -60,86 +60,89 @@ #include "input/dmxinputinit.h" #include "windowstr.h" -#include "inputstr.h" /* For DeviceIntRec */ -#include <X11/extensions/dmxproto.h> /* For DMX_BAD_* */ +#include "inputstr.h" /* For DeviceIntRec */ +#include <X11/extensions/dmxproto.h> /* For DMX_BAD_* */ #include "cursorstr.h" /* The default font is declared in dix/globals.c, but is not included in * _any_ header files. */ -extern FontPtr defaultFont; - +extern FontPtr defaultFont; + /** This routine provides information to the DMX protocol extension * about a particular screen. */ -Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr) +Bool +dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr) { DMXScreenInfo *dmxScreen; - if (physical < 0 || physical >= dmxNumScreens) return FALSE; + if (physical < 0 || physical >= dmxNumScreens) + return FALSE; dmxScreen = &dmxScreens[physical]; - attr->displayName = dmxScreen->name; + attr->displayName = dmxScreen->name; #ifdef PANORAMIX - attr->logicalScreen = noPanoramiXExtension ? dmxScreen->index : 0; + attr->logicalScreen = noPanoramiXExtension ? dmxScreen->index : 0; #else - attr->logicalScreen = dmxScreen->index; + attr->logicalScreen = dmxScreen->index; #endif - attr->screenWindowWidth = dmxScreen->scrnWidth; - attr->screenWindowHeight = dmxScreen->scrnHeight; + attr->screenWindowWidth = dmxScreen->scrnWidth; + attr->screenWindowHeight = dmxScreen->scrnHeight; attr->screenWindowXoffset = dmxScreen->scrnX; attr->screenWindowYoffset = dmxScreen->scrnY; - attr->rootWindowWidth = dmxScreen->rootWidth; - attr->rootWindowHeight = dmxScreen->rootHeight; - attr->rootWindowXoffset = dmxScreen->rootX; - attr->rootWindowYoffset = dmxScreen->rootY; + attr->rootWindowWidth = dmxScreen->rootWidth; + attr->rootWindowHeight = dmxScreen->rootHeight; + attr->rootWindowXoffset = dmxScreen->rootX; + attr->rootWindowYoffset = dmxScreen->rootY; - attr->rootWindowXorigin = dmxScreen->rootXOrigin; - attr->rootWindowYorigin = dmxScreen->rootYOrigin; + attr->rootWindowXorigin = dmxScreen->rootXOrigin; + attr->rootWindowYorigin = dmxScreen->rootYOrigin; return TRUE; } /** This routine provides information to the DMX protocol extension * about a particular window. */ -Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr) +Bool +dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr) { dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow); - attr->screen = pWindow->drawable.pScreen->myNum; - attr->window = pWinPriv->window; + 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; + 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.x = 0; + attr->vis.y = 0; attr->vis.height = 0; - attr->vis.width = 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; + /* 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; + 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; + attr->vis.width = pWindow->drawable.pScreen->width; else - attr->vis.width = pWindow->drawable.pScreen->width - attr->pos.x; + attr->vis.width = pWindow->drawable.pScreen->width - attr->pos.x; } if (attr->pos.y < 0) { - attr->vis.y -= attr->pos.y; + 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) { @@ -149,29 +152,32 @@ Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr) attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y; } - /* Convert to window-relative coordinates */ + /* Convert to window-relative coordinates */ attr->vis.x -= attr->pos.x; attr->vis.y -= attr->pos.y; return TRUE; } -void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr) +void +dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr) { - attr->width = dmxGlobalWidth; + 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>. */ + 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 +dmxGetInputCount(void) { int i, total; - - for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs; + + for (total = i = 0; i < dmxNumInputs; i++) + total += dmxInputs[i].numDevs; return total; } @@ -179,38 +185,42 @@ int dmxGetInputCount(void) * information is primarily for the #ProcDMXGetInputAttributes() * function, which does not have access to the appropriate data * structure. */ -int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr) +int +dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr) { - int i, j; + int i, j; DMXInputInfo *dmxInput; - if (deviceId < 0) return -1; + if (deviceId < 0) + return -1; for (i = 0; i < dmxNumInputs; i++) { dmxInput = &dmxInputs[i]; for (j = 0; j < dmxInput->numDevs; j++) { DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j]; - if (deviceId != dmxLocal->pDevice->id) continue; - attr->isCore = !!dmxLocal->isCore; - attr->sendsCore = !!dmxLocal->sendsCore; - attr->detached = !!dmxInput->detached; - attr->physicalScreen = -1; - attr->physicalId = -1; - attr->name = NULL; + + if (deviceId != dmxLocal->pDevice->id) + continue; + attr->isCore = ! !dmxLocal->isCore; + attr->sendsCore = ! !dmxLocal->sendsCore; + attr->detached = ! !dmxInput->detached; + attr->physicalScreen = -1; + attr->physicalId = -1; + attr->name = NULL; switch (dmxLocal->extType) { case DMX_LOCAL_TYPE_LOCAL: - attr->inputType = 0; + attr->inputType = 0; break; case DMX_LOCAL_TYPE_CONSOLE: - attr->inputType = 1; - attr->name = dmxInput->name; - attr->physicalId = dmxLocal->deviceId; + attr->inputType = 1; + attr->name = dmxInput->name; + attr->physicalId = dmxLocal->deviceId; break; case DMX_LOCAL_TYPE_BACKEND: case DMX_LOCAL_TYPE_COMMON: - attr->inputType = 2; + attr->inputType = 2; attr->physicalScreen = dmxInput->scrnIdx; - attr->name = dmxInput->name; - attr->physicalId = dmxLocal->deviceId; + attr->name = dmxInput->name; + attr->physicalId = dmxLocal->deviceId; break; } return 0; /* Success */ @@ -220,9 +230,10 @@ int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr) } /** Reinitialized the cursor boundaries. */ -static void dmxAdjustCursorBoundaries(void) +static void +dmxAdjustCursorBoundaries(void) { - int i; + int i; dmxReInitOrigins(); dmxInitOverlap(); @@ -230,28 +241,33 @@ static void dmxAdjustCursorBoundaries(void) dmxConnectionBlockCallback(); for (i = 0; i < dmxNumInputs; i++) { DMXInputInfo *dmxInput = &dmxInputs[i]; - if (!dmxInput->detached) dmxInputReInit(dmxInput); + + if (!dmxInput->detached) + dmxInputReInit(dmxInput); } dmxCheckCursor(); for (i = 0; i < dmxNumInputs; i++) { DMXInputInfo *dmxInput = &dmxInputs[i]; - if (!dmxInput->detached) dmxInputLateReInit(dmxInput); + + if (!dmxInput->detached) + dmxInputLateReInit(dmxInput); } } /** 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) +int +dmxAddInput(DMXInputAttributesPtr attr, int *id) { int retcode = BadValue; if (attr->inputType == 1) /* console */ retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id); - else if (attr->inputType == 2) /* backend */ + else if (attr->inputType == 2) /* backend */ retcode = dmxInputAttachBackend(attr->physicalScreen, - attr->sendsCore,id); + attr->sendsCore, id); if (retcode == Success) { /* Adjust the cursor boundaries */ @@ -265,7 +281,8 @@ int dmxAddInput(DMXInputAttributesPtr attr, int *id) } /** Remove the input with physical id \a id. */ -int dmxRemoveInput(int id) +int +dmxRemoveInput(int id) { return dmxInputDetachId(id); } @@ -273,46 +290,52 @@ int dmxRemoveInput(int id) /** 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) +unsigned long +dmxGetNumScreens(void) { return dmxNumScreens; } /** Make sure that #dmxCreateAndRealizeWindow has been called for \a * pWindow. */ -void dmxForceWindowCreation(WindowPtr pWindow) +void +dmxForceWindowCreation(WindowPtr pWindow) { dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow); - if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE); + + if (!pWinPriv->window) + dmxCreateAndRealizeWindow(pWindow, TRUE); } /** Flush pending syncs for all screens. */ -void dmxFlushPendingSyncs(void) +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) +void +dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h) { DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; - WindowPtr pRoot = pScreen->root; - WindowPtr pChild; - Bool anyMarked = FALSE; + WindowPtr pRoot = pScreen->root; + WindowPtr pChild; + Bool anyMarked = FALSE; /* Handle special case where width and/or height are zero */ if (w == 0 || h == 0) { - w = 1; - h = 1; + w = 1; + h = 1; } /* Change screen size */ - pScreen->width = w; + pScreen->width = w; pScreen->height = h; /* Reset the root window's drawable's size */ - pRoot->drawable.width = w; + pRoot->drawable.width = w; pRoot->drawable.height = h; /* Set the root window's new winSize and borderSize */ @@ -328,15 +351,15 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h) /* Recompute this screen's mmWidth & mmHeight */ pScreen->mmWidth = - (w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10); + (w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10); pScreen->mmHeight = - (h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10); + (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); + anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild, + (WindowPtr *) NULL); /* 2. Set the root window's borderClip */ pRoot->borderClip.extents.x1 = 0; @@ -346,27 +369,28 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int 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() - */ - RegionBreak(&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; + /* If any windows have been marked, set the root window's + * clipList to be broken since it will be recalculated in + * ValidateTree() + */ + RegionBreak(&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); + pScreen->ValidateTree(pRoot, NULL, VTBroken); + pScreen->HandleExposures(pRoot); + if (pScreen->PostValidateTree) + pScreen->PostValidateTree(pRoot, NULL, VTBroken); } } @@ -375,72 +399,71 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h) /** Change the "screen" window attributes by resizing the actual window * on the back-end display (if necessary). */ -static void dmxConfigureScreenWindow(int idx, - int x, int y, int w, int h) +static void +dmxConfigureScreenWindow(int idx, int x, int y, int w, int h) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - ScreenPtr pScreen = screenInfo.screens[idx]; + ScreenPtr pScreen = screenInfo.screens[idx]; /* Resize "screen" window */ - if (dmxScreen->scrnX != x || - dmxScreen->scrnY != y || - dmxScreen->scrnWidth != w || - dmxScreen->scrnHeight != h) { - dmxResizeScreenWindow(pScreen, x, y, w, h); + if (dmxScreen->scrnX != x || + dmxScreen->scrnY != y || + dmxScreen->scrnWidth != w || dmxScreen->scrnHeight != h) { + dmxResizeScreenWindow(pScreen, x, y, w, h); } /* Change "screen" window values */ - dmxScreen->scrnX = x; - dmxScreen->scrnY = y; - dmxScreen->scrnWidth = w; + dmxScreen->scrnX = x; + dmxScreen->scrnY = y; + dmxScreen->scrnWidth = w; dmxScreen->scrnHeight = h; } - + /** Change the "root" window position and size by resizing the actual * window on the back-end display (if necessary) and updating all of * DMX's resources by calling #dmxUpdateScreenResources. */ -static void dmxConfigureRootWindow(int idx, int x, int y, int w, int h) +static void +dmxConfigureRootWindow(int idx, int x, int y, int w, int h) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - WindowPtr pRoot = screenInfo.screens[idx]->root; + WindowPtr pRoot = screenInfo.screens[idx]->root; /* NOTE: Either this function or the ones that it calls must handle * the case where w == 0 || h == 0. Currently, the functions that * this one calls handle that case. */ /* 1. Resize "root" window */ - if (dmxScreen->rootX != x || - dmxScreen->rootY != y || - dmxScreen->rootWidth != w || - dmxScreen->rootHeight != h) { - dmxResizeRootWindow(pRoot, x, y, w, h); + if (dmxScreen->rootX != x || + dmxScreen->rootY != y || + dmxScreen->rootWidth != w || dmxScreen->rootHeight != h) { + dmxResizeRootWindow(pRoot, x, y, w, h); } /* 2. Update all of the screen's resources associated with this root * window */ - if (dmxScreen->rootWidth != w || - dmxScreen->rootHeight != h) { - dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h); + if (dmxScreen->rootWidth != w || dmxScreen->rootHeight != h) { + dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h); } /* Change "root" window values */ - dmxScreen->rootX = x; - dmxScreen->rootY = y; - dmxScreen->rootWidth = w; + dmxScreen->rootX = x; + dmxScreen->rootY = y; + dmxScreen->rootWidth = w; dmxScreen->rootHeight = h; } /** Change the "root" window's origin by updating DMX's internal data * structures (dix and Xinerama) to use the new origin and adjust the * positions of windows that overlap this "root" window. */ -static void dmxSetRootWindowOrigin(int idx, int x, int y) +static void +dmxSetRootWindowOrigin(int idx, int x, int y) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - ScreenPtr pScreen = screenInfo.screens[idx]; - WindowPtr pRoot = pScreen->root; - WindowPtr pChild; - int xoff; - int yoff; + ScreenPtr pScreen = screenInfo.screens[idx]; + WindowPtr pRoot = pScreen->root; + WindowPtr pChild; + int xoff; + int yoff; /* Change "root" window's origin */ dmxScreen->rootXOrigin = x; @@ -458,129 +481,131 @@ static void dmxSetRootWindowOrigin(int idx, int x, int y) XineramaReinitData(); /* Adjust each of the root window's children */ - if (!idx) ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff); + if (!idx) + ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff); pChild = pRoot->firstChild; while (pChild) { - /* Adjust child window's position */ - pScreen->MoveWindow(pChild, - pChild->origin.x - wBorderWidth(pChild) - xoff, - pChild->origin.y - wBorderWidth(pChild) - yoff, - pChild->nextSib, - VTMove); - - /* Note that the call to MoveWindow will eventually call - * dmxPositionWindow which will automatically create a - * window if it is now exposed on screen (for lazy window - * creation optimization) and it will properly set the - * offscreen flag. - */ - - pChild = pChild->nextSib; + /* Adjust child window's position */ + pScreen->MoveWindow(pChild, + pChild->origin.x - wBorderWidth(pChild) - xoff, + pChild->origin.y - wBorderWidth(pChild) - yoff, + pChild->nextSib, VTMove); + + /* Note that the call to MoveWindow will eventually call + * dmxPositionWindow which will automatically create a + * window if it is now exposed on screen (for lazy window + * creation optimization) and it will properly set the + * offscreen flag. + */ + + pChild = pChild->nextSib; } } /** Configure the attributes of each "screen" and "root" window. */ -int dmxConfigureScreenWindows(int nscreens, - CARD32 *screens, - DMXScreenAttributesPtr attribs, - int *errorScreen) +int +dmxConfigureScreenWindows(int nscreens, + CARD32 *screens, + DMXScreenAttributesPtr attribs, int *errorScreen) { - int i; + int i; for (i = 0; i < nscreens; i++) { - DMXScreenAttributesPtr attr = &attribs[i]; - int idx = screens[i]; - DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - - if (errorScreen) *errorScreen = i; - - if (!dmxScreen->beDisplay) return DMX_BAD_VALUE; - - /* Check for illegal values */ - if (idx < 0 || idx >= dmxNumScreens) return BadValue; - - /* The "screen" and "root" windows must have valid sizes */ - if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 || - attr->rootWindowWidth < 0 || attr->rootWindowHeight < 0) - return DMX_BAD_VALUE; - - /* The "screen" window must fit entirely within the BE display */ - if (attr->screenWindowXoffset < 0 || - attr->screenWindowYoffset < 0 || - attr->screenWindowXoffset - + attr->screenWindowWidth > (unsigned)dmxScreen->beWidth || - attr->screenWindowYoffset - + attr->screenWindowHeight > (unsigned)dmxScreen->beHeight) - return DMX_BAD_VALUE; - - /* The "root" window must fit entirely within the "screen" window */ - if (attr->rootWindowXoffset < 0 || - attr->rootWindowYoffset < 0 || - attr->rootWindowXoffset - + attr->rootWindowWidth > attr->screenWindowWidth || - attr->rootWindowYoffset - + attr->rootWindowHeight > attr->screenWindowHeight) - return DMX_BAD_VALUE; - - /* The "root" window must not expose unaddressable coordinates */ - if (attr->rootWindowXorigin < 0 || - attr->rootWindowYorigin < 0 || - attr->rootWindowXorigin + attr->rootWindowWidth > 32767 || - attr->rootWindowYorigin + attr->rootWindowHeight > 32767) - return DMX_BAD_VALUE; - - /* The "root" window must fit within the global bounding box */ - if (attr->rootWindowXorigin - + attr->rootWindowWidth > (unsigned)dmxGlobalWidth || - attr->rootWindowYorigin - + attr->rootWindowHeight > (unsigned)dmxGlobalHeight) - return DMX_BAD_VALUE; - - /* FIXME: Handle the rest of the illegal value checking */ + DMXScreenAttributesPtr attr = &attribs[i]; + int idx = screens[i]; + DMXScreenInfo *dmxScreen = &dmxScreens[idx]; + + if (errorScreen) + *errorScreen = i; + + if (!dmxScreen->beDisplay) + return DMX_BAD_VALUE; + + /* Check for illegal values */ + if (idx < 0 || idx >= dmxNumScreens) + return BadValue; + + /* The "screen" and "root" windows must have valid sizes */ + if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 || + attr->rootWindowWidth < 0 || attr->rootWindowHeight < 0) + return DMX_BAD_VALUE; + + /* The "screen" window must fit entirely within the BE display */ + if (attr->screenWindowXoffset < 0 || + attr->screenWindowYoffset < 0 || + attr->screenWindowXoffset + + attr->screenWindowWidth > (unsigned) dmxScreen->beWidth || + attr->screenWindowYoffset + + attr->screenWindowHeight > (unsigned) dmxScreen->beHeight) + return DMX_BAD_VALUE; + + /* The "root" window must fit entirely within the "screen" window */ + if (attr->rootWindowXoffset < 0 || + attr->rootWindowYoffset < 0 || + attr->rootWindowXoffset + + attr->rootWindowWidth > attr->screenWindowWidth || + attr->rootWindowYoffset + + attr->rootWindowHeight > attr->screenWindowHeight) + return DMX_BAD_VALUE; + + /* The "root" window must not expose unaddressable coordinates */ + if (attr->rootWindowXorigin < 0 || + attr->rootWindowYorigin < 0 || + attr->rootWindowXorigin + attr->rootWindowWidth > 32767 || + attr->rootWindowYorigin + attr->rootWindowHeight > 32767) + return DMX_BAD_VALUE; + + /* The "root" window must fit within the global bounding box */ + if (attr->rootWindowXorigin + + attr->rootWindowWidth > (unsigned) dmxGlobalWidth || + attr->rootWindowYorigin + + attr->rootWindowHeight > (unsigned) dmxGlobalHeight) + return DMX_BAD_VALUE; + + /* FIXME: Handle the rest of the illegal value checking */ } /* No illegal values found */ - if (errorScreen) *errorScreen = 0; + if (errorScreen) + *errorScreen = 0; for (i = 0; i < nscreens; i++) { - DMXScreenAttributesPtr attr = &attribs[i]; - int idx = screens[i]; - DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - - dmxLog(dmxInfo, "Changing screen #%d attributes " - "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d " - "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n", - idx, - dmxScreen->scrnWidth, dmxScreen->scrnHeight, - dmxScreen->scrnX, dmxScreen->scrnY, - dmxScreen->rootWidth, dmxScreen->rootHeight, - dmxScreen->rootX, dmxScreen->rootY, - dmxScreen->rootXOrigin, dmxScreen->rootYOrigin, - attr->screenWindowWidth, attr->screenWindowHeight, - attr->screenWindowXoffset, attr->screenWindowYoffset, - attr->rootWindowWidth, attr->rootWindowHeight, - attr->rootWindowXoffset, attr->rootWindowYoffset, - attr->rootWindowXorigin, attr->rootWindowYorigin); - - /* Configure "screen" window */ - dmxConfigureScreenWindow(idx, - attr->screenWindowXoffset, - attr->screenWindowYoffset, - attr->screenWindowWidth, - attr->screenWindowHeight); - - /* Configure "root" window */ - dmxConfigureRootWindow(idx, - attr->rootWindowXoffset, - attr->rootWindowYoffset, - attr->rootWindowWidth, - attr->rootWindowHeight); - - - /* Set "root" window's origin */ - dmxSetRootWindowOrigin(idx, - attr->rootWindowXorigin, - attr->rootWindowYorigin); + DMXScreenAttributesPtr attr = &attribs[i]; + int idx = screens[i]; + DMXScreenInfo *dmxScreen = &dmxScreens[idx]; + + dmxLog(dmxInfo, "Changing screen #%d attributes " + "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d " + "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n", + idx, + dmxScreen->scrnWidth, dmxScreen->scrnHeight, + dmxScreen->scrnX, dmxScreen->scrnY, + dmxScreen->rootWidth, dmxScreen->rootHeight, + dmxScreen->rootX, dmxScreen->rootY, + dmxScreen->rootXOrigin, dmxScreen->rootYOrigin, + attr->screenWindowWidth, attr->screenWindowHeight, + attr->screenWindowXoffset, attr->screenWindowYoffset, + attr->rootWindowWidth, attr->rootWindowHeight, + attr->rootWindowXoffset, attr->rootWindowYoffset, + attr->rootWindowXorigin, attr->rootWindowYorigin); + + /* Configure "screen" window */ + dmxConfigureScreenWindow(idx, + attr->screenWindowXoffset, + attr->screenWindowYoffset, + attr->screenWindowWidth, + attr->screenWindowHeight); + + /* Configure "root" window */ + dmxConfigureRootWindow(idx, + attr->rootWindowXoffset, + attr->rootWindowYoffset, + attr->rootWindowWidth, attr->rootWindowHeight); + + /* Set "root" window's origin */ + dmxSetRootWindowOrigin(idx, + attr->rootWindowXorigin, + attr->rootWindowYorigin); } /* Adjust the cursor boundaries */ @@ -593,37 +618,46 @@ int dmxConfigureScreenWindows(int nscreens, } /** Configure the attributes of the global desktop. */ -int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs) +int +dmxConfigureDesktop(DMXDesktopAttributesPtr attribs) { - if (attribs->width <= 0 || attribs->width >= 32767 || - attribs->height <= 0 || attribs->height >= 32767) - return DMX_BAD_VALUE; + if (attribs->width <= 0 || attribs->width >= 32767 || + attribs->height <= 0 || attribs->height >= 32767) + return DMX_BAD_VALUE; /* If the desktop is shrinking, adjust the "root" windows on each * "screen" window to only show the visible desktop. Also, handle * the special case where the desktop shrinks such that the it no * longer overlaps an portion of a "screen" window. */ if (attribs->width < dmxGlobalWidth || attribs->height < dmxGlobalHeight) { - int i; - for (i = 0; i < dmxNumScreens; i++) { - DMXScreenInfo *dmxScreen = &dmxScreens[i]; - if (dmxScreen->rootXOrigin - + dmxScreen->rootWidth > attribs->width || - dmxScreen->rootYOrigin - + dmxScreen->rootHeight > attribs->height) { - int w, h; - if ((w = attribs->width - dmxScreen->rootXOrigin) < 0) w = 0; - if ((h = attribs->height - dmxScreen->rootYOrigin) < 0) h = 0; - if (w > dmxScreen->scrnWidth) w = dmxScreen->scrnWidth; - if (h > dmxScreen->scrnHeight) h = dmxScreen->scrnHeight; - if (w > dmxScreen->rootWidth) w = dmxScreen->rootWidth; - if (h > dmxScreen->rootHeight) h = dmxScreen->rootHeight; - dmxConfigureRootWindow(i, - dmxScreen->rootX, - dmxScreen->rootY, - w, h); - } - } + int i; + + for (i = 0; i < dmxNumScreens; i++) { + DMXScreenInfo *dmxScreen = &dmxScreens[i]; + + if (dmxScreen->rootXOrigin + + dmxScreen->rootWidth > attribs->width || + dmxScreen->rootYOrigin + + dmxScreen->rootHeight > attribs->height) { + int w, h; + + if ((w = attribs->width - dmxScreen->rootXOrigin) < 0) + w = 0; + if ((h = attribs->height - dmxScreen->rootYOrigin) < 0) + h = 0; + if (w > dmxScreen->scrnWidth) + w = dmxScreen->scrnWidth; + if (h > dmxScreen->scrnHeight) + h = dmxScreen->scrnHeight; + if (w > dmxScreen->rootWidth) + w = dmxScreen->rootWidth; + if (h > dmxScreen->rootHeight) + h = dmxScreen->rootHeight; + dmxConfigureRootWindow(i, + dmxScreen->rootX, + dmxScreen->rootY, w, h); + } + } } /* Set the global width/height */ @@ -631,30 +665,30 @@ int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs) /* Handle shift[XY] changes */ if (attribs->shiftX || attribs->shiftY) { - int i; - for (i = 0; i < dmxNumScreens; i++) { - ScreenPtr pScreen = screenInfo.screens[i]; - WindowPtr pChild = pScreen->root->firstChild; - while (pChild) { - /* Adjust child window's position */ - pScreen->MoveWindow(pChild, - pChild->origin.x - wBorderWidth(pChild) - - attribs->shiftX, - pChild->origin.y - wBorderWidth(pChild) - - attribs->shiftY, - pChild->nextSib, - VTMove); - - /* Note that the call to MoveWindow will eventually call - * dmxPositionWindow which will automatically create a - * window if it is now exposed on screen (for lazy - * window creation optimization) and it will properly - * set the offscreen flag. - */ - - pChild = pChild->nextSib; - } - } + int i; + + for (i = 0; i < dmxNumScreens; i++) { + ScreenPtr pScreen = screenInfo.screens[i]; + WindowPtr pChild = pScreen->root->firstChild; + + while (pChild) { + /* Adjust child window's position */ + pScreen->MoveWindow(pChild, + pChild->origin.x - wBorderWidth(pChild) + - attribs->shiftX, + pChild->origin.y - wBorderWidth(pChild) + - attribs->shiftY, pChild->nextSib, VTMove); + + /* Note that the call to MoveWindow will eventually call + * dmxPositionWindow which will automatically create a + * window if it is now exposed on screen (for lazy + * window creation optimization) and it will properly + * set the offscreen flag. + */ + + pChild = pChild->nextSib; + } + } } /* Update connection block, Xinerama, etc. -- these appears to @@ -672,14 +706,15 @@ int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs) #endif /** Create the scratch GCs per depth. */ -static void dmxBECreateScratchGCs(int scrnNum) +static void +dmxBECreateScratchGCs(int scrnNum) { - ScreenPtr pScreen = screenInfo.screens[scrnNum]; - GCPtr *ppGC = pScreen->GCperDepth; - int i; + ScreenPtr pScreen = screenInfo.screens[scrnNum]; + GCPtr *ppGC = pScreen->GCperDepth; + int i; for (i = 0; i <= pScreen->numDepths; i++) - dmxBECreateGC(pScreen, ppGC[i]); + dmxBECreateGC(pScreen, ppGC[i]); } #ifdef PANORAMIX @@ -689,89 +724,92 @@ static Bool FoundPixImage; * 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) +static void +dmxBERestorePixmapImage(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; - - dixLookupResourceByType((pointer*) &pPix, pXinPix->info[idx].id, - RT_PIXMAP, NullClient, DixUnknownAccess); - if (pPix != pDst) return; /* Not a match.... Next! */ - - FOR_NSCREENS(i) { - PixmapPtr pSrc; - dmxPixPrivPtr pSrcPriv = NULL; - - if (i == idx) continue; /* Self replication is bad */ - - dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id, - RT_PIXMAP, NullClient, DixUnknownAccess); - 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; - 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; - - /* Copy from src pixmap to dst pixmap */ - img = XGetImage(dmxSrcScreen->beDisplay, - pSrcPriv->pixmap, - 0, 0, - pSrc->drawable.width, pSrc->drawable.height, - -1, - ZPixmap); - - 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; - - gc = XCreateGC(dmxDstScreen->beDisplay, - dmxDstScreen->scrnDefDrawables[j], - m, &v); - break; - } - } - - if (gc) { - XPutImage(dmxDstScreen->beDisplay, - pDstPriv->pixmap, - gc, img, 0, 0, 0, 0, - pDst->drawable.width, pDst->drawable.height); - XFreeGC(dmxDstScreen->beDisplay, gc); - FoundPixImage = True; - } else { - dmxLog(dmxWarning, "Could not create GC\n"); - } - - XDestroyImage(img); - return; - } - } + PixmapPtr pDst = (PixmapPtr) p; + int idx = pDst->drawable.pScreen->myNum; + PanoramiXRes *pXinPix = (PanoramiXRes *) value; + PixmapPtr pPix; + int i; + + dixLookupResourceByType((pointer *) &pPix, pXinPix->info[idx].id, + RT_PIXMAP, NullClient, DixUnknownAccess); + if (pPix != pDst) + return; /* Not a match.... Next! */ + + FOR_NSCREENS(i) { + PixmapPtr pSrc; + dmxPixPrivPtr pSrcPriv = NULL; + + if (i == idx) + continue; /* Self replication is bad */ + + dixLookupResourceByType((pointer *) &pSrc, pXinPix->info[i].id, + RT_PIXMAP, NullClient, DixUnknownAccess); + 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; + 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; + + /* Copy from src pixmap to dst pixmap */ + img = XGetImage(dmxSrcScreen->beDisplay, + pSrcPriv->pixmap, + 0, 0, + pSrc->drawable.width, pSrc->drawable.height, + -1, ZPixmap); + + 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; + + gc = XCreateGC(dmxDstScreen->beDisplay, + dmxDstScreen->scrnDefDrawables[j], + m, &v); + break; + } + } + + if (gc) { + XPutImage(dmxDstScreen->beDisplay, + pDstPriv->pixmap, + gc, img, 0, 0, 0, 0, + pDst->drawable.width, pDst->drawable.height); + XFreeGC(dmxDstScreen->beDisplay, gc); + FoundPixImage = True; + } + else { + dmxLog(dmxWarning, "Could not create GC\n"); + } + + XDestroyImage(img); + return; + } + } } } #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) +static void +dmxBERestorePixmap(PixmapPtr pPixmap) { #ifdef PANORAMIX int i; @@ -779,62 +817,63 @@ static void dmxBERestorePixmap(PixmapPtr pPixmap) /* 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; + dmxLog(dmxWarning, "Cannot restore pixmap image\n"); + return; } FoundPixImage = False; - for (i = currentMaxClients; --i >= 0; ) - if (clients[i]) - FindAllClientResources(clients[i], dmxBERestorePixmapImage, - (pointer)pPixmap); + 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; - - gc = XCreateGC(dmxScreen->beDisplay, - dmxScreen->scrnDefDrawables[i], - m, &v); - break; - } - } - - if (gc) { - XPutImage(dmxScreen->beDisplay, - pPixPriv->pixmap, - gc, - pPixPriv->detachedImage, - 0, 0, 0, 0, - pPixmap->drawable.width, pPixmap->drawable.height); - XFreeGC(dmxScreen->beDisplay, gc); - } else { - dmxLog(dmxWarning, "Cannot restore pixmap image\n"); - } - - XDestroyImage(pPixPriv->detachedImage); - pPixPriv->detachedImage = NULL; - } else { - dmxLog(dmxWarning, "Cannot restore pixmap image\n"); - } + 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; + + gc = XCreateGC(dmxScreen->beDisplay, + dmxScreen->scrnDefDrawables[i], m, &v); + break; + } + } + + if (gc) { + XPutImage(dmxScreen->beDisplay, + pPixPriv->pixmap, + gc, + pPixPriv->detachedImage, + 0, 0, 0, 0, + pPixmap->drawable.width, pPixmap->drawable.height); + XFreeGC(dmxScreen->beDisplay, gc); + } + else { + dmxLog(dmxWarning, "Cannot restore pixmap image\n"); + } + + XDestroyImage(pPixPriv->detachedImage); + pPixPriv->detachedImage = NULL; + } + else { + dmxLog(dmxWarning, "Cannot restore pixmap image\n"); + } } #else /* If Xinerama is not enabled, then there is no other copy of the @@ -852,57 +891,68 @@ static void dmxBERestorePixmap(PixmapPtr pPixmap) * 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) +static void +dmxBECreateResources(pointer value, XID id, RESTYPE type, pointer n) { - int scrnNum = (uintptr_t)n; - ScreenPtr pScreen = screenInfo.screens[scrnNum]; + int scrnNum = (uintptr_t) 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_COLORMAP & TypeMask)) { - ColormapPtr pCmap = value; - if (pCmap->pScreen->myNum == scrnNum) - (void)dmxBECreateColormap((ColormapPtr)value); + /* 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_COLORMAP & TypeMask)) { + ColormapPtr pCmap = value; + + if (pCmap->pScreen->myNum == scrnNum) + (void) dmxBECreateColormap((ColormapPtr) value); #if 0 - /* 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); + /* 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 - } else { - /* Other resource types??? */ + } + else { + /* Other resource types??? */ } } @@ -912,21 +962,22 @@ static void dmxBECreateResources(pointer value, XID id, RESTYPE type, * 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) +static void +dmxBECreateWindowTree(int idx) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - WindowPtr pRoot = screenInfo.screens[idx]->root; - dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pRoot); - WindowPtr pWin; + WindowPtr pRoot = screenInfo.screens[idx]->root; + 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); + dmxBECreatePixmap(pRoot->border.pixmap); + dmxBERestorePixmap(pRoot->border.pixmap); } if (pRoot->backgroundState == BackgroundPixmap) { - dmxBECreatePixmap(pRoot->background.pixmap); - dmxBERestorePixmap(pRoot->background.pixmap); + dmxBECreatePixmap(pRoot->background.pixmap); + dmxBERestorePixmap(pRoot->background.pixmap); } /* Create root window first */ @@ -935,175 +986,188 @@ static void dmxBECreateWindowTree(int idx) 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); - } - - /* Reset the window attributes */ - dmxGetDefaultWindowAttributes(pWin, - &pWinPriv->cmap, - &pWinPriv->visual); - - /* Create the window */ - if (pWinPriv->mapped && !pWinPriv->offscreen) - 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; + 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); + } + + /* Reset the window attributes */ + dmxGetDefaultWindowAttributes(pWin, &pWinPriv->cmap, &pWinPriv->visual); + + /* Create the window */ + if (pWinPriv->mapped && !pWinPriv->offscreen) + 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; } } /* Refresh screen by generating exposure events for all windows */ -static void dmxForceExposures(int idx) +static void +dmxForceExposures(int idx) { - ScreenPtr pScreen = screenInfo.screens[idx]; - WindowPtr pRoot = pScreen->root; - Bool anyMarked = FALSE; - WindowPtr pChild; + ScreenPtr pScreen = screenInfo.screens[idx]; + WindowPtr pRoot = pScreen->root; + Bool anyMarked = FALSE; + WindowPtr pChild; for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib) - anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild, - (WindowPtr *)NULL); + anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild, + (WindowPtr *) NULL); if (anyMarked) { - /* If any windows have been marked, set the root window's - * clipList to be broken since it will be recalculated in - * ValidateTree() - */ - RegionBreak(&pRoot->clipList); - pScreen->ValidateTree(pRoot, NULL, VTBroken); - pScreen->HandleExposures(pRoot); - if (pScreen->PostValidateTree) - pScreen->PostValidateTree(pRoot, NULL, VTBroken); + /* If any windows have been marked, set the root window's + * clipList to be broken since it will be recalculated in + * ValidateTree() + */ + RegionBreak(&pRoot->clipList); + pScreen->ValidateTree(pRoot, NULL, VTBroken); + pScreen->HandleExposures(pRoot); + if (pScreen->PostValidateTree) + pScreen->PostValidateTree(pRoot, NULL, VTBroken); } } /** Compare the new and old screens to see if they are compatible. */ -static Bool dmxCompareScreens(DMXScreenInfo *new, DMXScreenInfo *old) +static Bool +dmxCompareScreens(DMXScreenInfo * new, DMXScreenInfo * old) { int i; - if (new->beWidth != old->beWidth) return FALSE; - if (new->beHeight != old->beHeight) return FALSE; - if (new->beDepth != old->beDepth) return FALSE; - if (new->beBPP != old->beBPP) return FALSE; - - if (new->beNumDepths != old->beNumDepths) return FALSE; + if (new->beWidth != old->beWidth) + return FALSE; + if (new->beHeight != old->beHeight) + return FALSE; + if (new->beDepth != old->beDepth) + return FALSE; + if (new->beBPP != old->beBPP) + return FALSE; + + if (new->beNumDepths != old->beNumDepths) + return FALSE; for (i = 0; i < old->beNumDepths; i++) - if (new->beDepths[i] != old->beDepths[i]) return FALSE; + if (new->beDepths[i] != old->beDepths[i]) + return FALSE; - if (new->beNumPixmapFormats != old->beNumPixmapFormats) return FALSE; + if (new->beNumPixmapFormats != old->beNumPixmapFormats) + return FALSE; for (i = 0; i < old->beNumPixmapFormats; i++) { - if (new->bePixmapFormats[i].depth != - old->bePixmapFormats[i].depth) return FALSE; - if (new->bePixmapFormats[i].bits_per_pixel != - old->bePixmapFormats[i].bits_per_pixel) return FALSE; - if (new->bePixmapFormats[i].scanline_pad != - old->bePixmapFormats[i].scanline_pad) return FALSE; + if (new->bePixmapFormats[i].depth != old->bePixmapFormats[i].depth) + return FALSE; + if (new->bePixmapFormats[i].bits_per_pixel != + old->bePixmapFormats[i].bits_per_pixel) + return FALSE; + if (new->bePixmapFormats[i].scanline_pad != + old->bePixmapFormats[i].scanline_pad) + return FALSE; } - if (new->beNumVisuals != old->beNumVisuals) return FALSE; + if (new->beNumVisuals != old->beNumVisuals) + return FALSE; for (i = 0; i < old->beNumVisuals; i++) { - if (new->beVisuals[i].visualid != - old->beVisuals[i].visualid) return FALSE; - if (new->beVisuals[i].screen != - old->beVisuals[i].screen) return FALSE; - if (new->beVisuals[i].depth != - old->beVisuals[i].depth) return FALSE; - if (new->beVisuals[i].class != - old->beVisuals[i].class) return FALSE; - if (new->beVisuals[i].red_mask != - old->beVisuals[i].red_mask) return FALSE; - if (new->beVisuals[i].green_mask != - old->beVisuals[i].green_mask) return FALSE; - if (new->beVisuals[i].blue_mask != - old->beVisuals[i].blue_mask) return FALSE; - if (new->beVisuals[i].colormap_size != - old->beVisuals[i].colormap_size) return FALSE; - if (new->beVisuals[i].bits_per_rgb != - old->beVisuals[i].bits_per_rgb) return FALSE; - } - - if (new->beDefVisualIndex != old->beDefVisualIndex) return FALSE; + if (new->beVisuals[i].visualid != old->beVisuals[i].visualid) + return FALSE; + if (new->beVisuals[i].screen != old->beVisuals[i].screen) + return FALSE; + if (new->beVisuals[i].depth != old->beVisuals[i].depth) + return FALSE; + if (new->beVisuals[i].class != old->beVisuals[i].class) + return FALSE; + if (new->beVisuals[i].red_mask != old->beVisuals[i].red_mask) + return FALSE; + if (new->beVisuals[i].green_mask != old->beVisuals[i].green_mask) + return FALSE; + if (new->beVisuals[i].blue_mask != old->beVisuals[i].blue_mask) + return FALSE; + if (new->beVisuals[i].colormap_size != old->beVisuals[i].colormap_size) + return FALSE; + if (new->beVisuals[i].bits_per_rgb != old->beVisuals[i].bits_per_rgb) + return FALSE; + } + + if (new->beDefVisualIndex != old->beDefVisualIndex) + return FALSE; return TRUE; } /** Restore Render's picture */ -static void dmxBERestoreRenderPict(pointer value, XID id, pointer n) +static void +dmxBERestoreRenderPict(pointer value, XID id, pointer n) { - PicturePtr pPicture = value; /* The picture */ - DrawablePtr pDraw = pPicture->pDrawable; /* The picture's drawable */ - int scrnNum = (uintptr_t)n; + PicturePtr pPicture = value; /* The picture */ + DrawablePtr pDraw = pPicture->pDrawable; /* The picture's drawable */ + int scrnNum = (uintptr_t) n; if (pDraw->pScreen->myNum != scrnNum) { - /* Picture not on the screen we are restoring*/ - return; + /* 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); + PixmapPtr pPixmap = (PixmapPtr) pDraw; + + /* Create and restore the pixmap drawable */ + dmxBECreatePixmap(pPixmap); + dmxBERestorePixmap(pPixmap); } dmxBECreatePicture(pPicture); } /** Restore Render's glyphs */ -static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n) +static void +dmxBERestoreRenderGlyph(pointer value, XID id, pointer n) { - GlyphSetPtr glyphSet = value; - int scrnNum = (uintptr_t)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; - int ctr; + GlyphSetPtr glyphSet = value; + int scrnNum = (uintptr_t) 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; + int ctr; if (glyphPriv->glyphSets[scrnNum]) { - /* Only restore glyphs on the screen we are attaching */ - return; + /* 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; + dmxLog(dmxWarning, + "\tdmxBERestoreRenderGlyph failed to create glyphset!\n"); + return; } /* Now for the complex part, restore the glyph data */ @@ -1111,89 +1175,92 @@ static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n) /* 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; + GlyphRefPtr gr = &table[i]; + GlyphPtr gl = gr->glyph; - if (!gl || gl == DeletedGlyph) continue; - len_images += gl->size - sizeof(gl->info); + if (!gl || gl == DeletedGlyph) + continue; + len_images += gl->size - sizeof(gl->info); } /* Now allocate the memory we need */ images = calloc(len_images, sizeof(char)); - gids = malloc(glyphSet->hash.tableEntries*sizeof(Glyph)); - glyphs = malloc(glyphSet->hash.tableEntries*sizeof(XGlyphInfo)); + gids = malloc(glyphSet->hash.tableEntries * sizeof(Glyph)); + glyphs = malloc(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; - - 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; - - /* Copy the images from the DIX's data into the buffer */ - memcpy(pos, gl+1, gl->size - sizeof(gl->info)); - pos += gl->size - sizeof(gl->info); - ctr++; + GlyphRefPtr gr = &table[i]; + GlyphPtr gl = gr->glyph; + + 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; + + /* Copy the images from the DIX's data into the buffer */ + memcpy(pos, gl + 1, gl->size - sizeof(gl->info)); + pos += gl->size - sizeof(gl->info); + ctr++; } - + /* Now restore the glyph data */ XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum], - gids,glyphs, glyphSet->hash.tableEntries, images, - len_images); + gids, glyphs, glyphSet->hash.tableEntries, images, + len_images); /* Clean up */ free(images); free(gids); - free(glyphs); + free(glyphs); } /** Reattach previously detached back-end screen. */ -int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) +int +dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) { - ScreenPtr pScreen; + ScreenPtr pScreen; DMXScreenInfo *dmxScreen; - CARD32 scrnNum = idx; - DMXScreenInfo oldDMXScreen; - int i; + CARD32 scrnNum = idx; + DMXScreenInfo oldDMXScreen; + int i; /* 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"); - return 1; + 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"); + return 1; } /* Cannot add a screen that does not exist */ - if (idx < 0 || idx >= dmxNumScreens) return 1; + if (idx < 0 || idx >= dmxNumScreens) + return 1; pScreen = screenInfo.screens[idx]; dmxScreen = &dmxScreens[idx]; /* Cannot attach to a screen that is already opened */ if (dmxScreen->beDisplay) { - dmxLog(dmxWarning, - "Attempting to add screen #%d but a screen already exists\n", - idx); - return 1; + dmxLog(dmxWarning, + "Attempting to add screen #%d but a screen already exists\n", + idx); + return 1; } dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx); @@ -1206,13 +1273,12 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) /* Open display and get all of the screen info */ if (!dmxOpenDisplay(dmxScreen)) { - dmxLog(dmxWarning, - "dmxOpenDisplay: Unable to open display %s\n", - dmxScreen->name); + dmxLog(dmxWarning, + "dmxOpenDisplay: Unable to open display %s\n", dmxScreen->name); - /* Restore the old screen */ - *dmxScreen = oldDMXScreen; - return 1; + /* Restore the old screen */ + *dmxScreen = oldDMXScreen; + return 1; } dmxSetErrorHandler(dmxScreen); @@ -1220,13 +1286,13 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) dmxGetScreenAttribs(dmxScreen); if (!dmxGetVisualInfo(dmxScreen)) { - dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n"); - XFree(dmxScreen->beVisuals); - XCloseDisplay(dmxScreen->beDisplay); + dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n"); + XFree(dmxScreen->beVisuals); + XCloseDisplay(dmxScreen->beDisplay); - /* Restore the old screen */ - *dmxScreen = oldDMXScreen; - return 1; + /* Restore the old screen */ + *dmxScreen = oldDMXScreen; + return 1; } dmxGetColormaps(dmxScreen); @@ -1235,23 +1301,20 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) /* Verify that the screen to be added has the same info as the * previously added screen. */ if (!dmxCompareScreens(dmxScreen, &oldDMXScreen)) { - dmxLog(dmxWarning, - "New screen data (%s) does not match previously\n", - dmxScreen->name); - dmxLog(dmxWarning, - "attached screen data (%s)\n", - oldDMXScreen.name); - dmxLog(dmxWarning, - "All data must match in order to attach to screen #%d\n", - idx); - XFree(dmxScreen->beVisuals); - XFree(dmxScreen->beDepths); - XFree(dmxScreen->bePixmapFormats); - XCloseDisplay(dmxScreen->beDisplay); - - /* Restore the old screen */ - *dmxScreen = oldDMXScreen; - return 1; + dmxLog(dmxWarning, + "New screen data (%s) does not match previously\n", + dmxScreen->name); + dmxLog(dmxWarning, "attached screen data (%s)\n", oldDMXScreen.name); + dmxLog(dmxWarning, + "All data must match in order to attach to screen #%d\n", idx); + XFree(dmxScreen->beVisuals); + XFree(dmxScreen->beDepths); + XFree(dmxScreen->bePixmapFormats); + XCloseDisplay(dmxScreen->beDisplay); + + /* Restore the old screen */ + *dmxScreen = oldDMXScreen; + return 1; } /* Initialize the BE screen resources */ @@ -1268,30 +1331,30 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) dmxBECreateScratchGCs(idx); /* Create the default font */ - (void)dmxBELoadFont(pScreen, defaultFont); + (void) dmxBELoadFont(pScreen, defaultFont); /* Create all resources that don't depend on windows */ - for (i = currentMaxClients; --i >= 0; ) - if (clients[i]) - FindAllClientResources(clients[i], dmxBECreateResources, - (pointer)(uintptr_t)idx); + for (i = currentMaxClients; --i >= 0;) + if (clients[i]) + FindAllClientResources(clients[i], dmxBECreateResources, + (pointer) (uintptr_t) idx); /* Create window hierarchy (top down) */ dmxBECreateWindowTree(idx); /* Restore the picture state for RENDER */ - for (i = currentMaxClients; --i >= 0; ) - if (clients[i]) - FindClientResourcesByType(clients[i],PictureType, - dmxBERestoreRenderPict, - (pointer)(uintptr_t)idx); + for (i = currentMaxClients; --i >= 0;) + if (clients[i]) + FindClientResourcesByType(clients[i], PictureType, + dmxBERestoreRenderPict, + (pointer) (uintptr_t) idx); /* Restore the glyph state for RENDER */ - for (i = currentMaxClients; --i >= 0; ) - if (clients[i]) - FindClientResourcesByType(clients[i],GlyphSetType, - dmxBERestoreRenderGlyph, - (pointer)(uintptr_t)idx); + for (i = currentMaxClients; --i >= 0;) + if (clients[i]) + FindClientResourcesByType(clients[i], GlyphSetType, + dmxBERestoreRenderGlyph, + (pointer) (uintptr_t) idx); /* Refresh screen by generating exposure events for all windows */ dmxForceExposures(idx); @@ -1308,10 +1371,10 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) #ifdef PANORAMIX if (!noPanoramiXExtension) - return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL); + return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL); else #endif - return 0; /* Success */ + return 0; /* Success */ } /* @@ -1358,34 +1421,36 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr) #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) +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; - - dixLookupResourceByType((pointer*) &pPix, pXinPix->info[idx].id, - RT_PIXMAP, NullClient, DixUnknownAccess); - if (pPix != pDst) return; /* Not a match.... Next! */ - - FOR_NSCREENS(i) { - PixmapPtr pSrc; - dmxPixPrivPtr pSrcPriv = NULL; - - if (i == idx) continue; /* Self replication is bad */ - - dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id, - RT_PIXMAP, NullClient, DixUnknownAccess); - pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc); - if (pSrcPriv->pixmap) { - FoundPixImage = True; - return; - } - } + PixmapPtr pDst = (PixmapPtr) p; + int idx = pDst->drawable.pScreen->myNum; + PanoramiXRes *pXinPix = (PanoramiXRes *) value; + PixmapPtr pPix; + int i; + + dixLookupResourceByType((pointer *) &pPix, pXinPix->info[idx].id, + RT_PIXMAP, NullClient, DixUnknownAccess); + if (pPix != pDst) + return; /* Not a match.... Next! */ + + FOR_NSCREENS(i) { + PixmapPtr pSrc; + dmxPixPrivPtr pSrcPriv = NULL; + + if (i == idx) + continue; /* Self replication is bad */ + + dixLookupResourceByType((pointer *) &pSrc, pXinPix->info[i].id, + RT_PIXMAP, NullClient, DixUnknownAccess); + pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc); + if (pSrcPriv->pixmap) { + FoundPixImage = True; + return; + } + } } } #endif @@ -1399,40 +1464,41 @@ static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type, * 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) +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; + if (noPanoramiXExtension) + return; FoundPixImage = False; - for (i = currentMaxClients; --i >= 0; ) - if (clients[i]) - FindAllClientResources(clients[i], dmxBEFindPixmapImage, - (pointer)pPixmap); + 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]; - - pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay, - pPixPriv->pixmap, - 0, 0, - pPixmap->drawable.width, - pPixmap->drawable.height, - -1, - ZPixmap); - if (!pPixPriv->detachedImage) - dmxLog(dmxWarning, "Cannot save pixmap image\n"); - } + dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap); + + if (!pPixPriv->detachedImage) { + ScreenPtr pScreen = pPixmap->drawable.pScreen; + DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; + + pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay, + pPixPriv->pixmap, + 0, 0, + pPixmap->drawable.width, + pPixmap->drawable.height, + -1, ZPixmap); + if (!pPixPriv->detachedImage) + dmxLog(dmxWarning, "Cannot save pixmap image\n"); + } } #else /* NOTE: The only time there is a pixmap on another screen that @@ -1452,59 +1518,73 @@ static void dmxBESavePixmap(PixmapPtr pPixmap) * 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) +static void +dmxBEDestroyResources(pointer value, XID id, RESTYPE type, pointer n) { - int scrnNum = (uintptr_t)n; - ScreenPtr pScreen = screenInfo.screens[scrnNum]; + int scrnNum = (uintptr_t) 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) == (PictureType & TypeMask)) { - PicturePtr pPict = value; - 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((PicturePtr)value); - } - } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) { - dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value); - } else { - /* Other resource types??? */ + /* 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) == (PictureType & TypeMask)) { + PicturePtr pPict = value; + + 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((PicturePtr) value); + } + } + else if ((type & TypeMask) == (GlyphSetType & TypeMask)) { + dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr) value); + } + else { + /* Other resource types??? */ } } /** Destroy the scratch GCs that are created per depth. */ -static void dmxBEDestroyScratchGCs(int scrnNum) +static void +dmxBEDestroyScratchGCs(int scrnNum) { - ScreenPtr pScreen = screenInfo.screens[scrnNum]; - GCPtr *ppGC = pScreen->GCperDepth; - int i; + ScreenPtr pScreen = screenInfo.screens[scrnNum]; + GCPtr *ppGC = pScreen->GCperDepth; + int i; for (i = 0; i <= pScreen->numDepths; i++) - dmxBEFreeGC(ppGC[i]); + dmxBEFreeGC(ppGC[i]); } /** Destroy window hierachy on back-end server. To ensure that all @@ -1512,79 +1592,81 @@ static void dmxBEDestroyScratchGCs(int scrnNum) * up order so that windows are not destroyed before their children. * XDestroyWindow(), which is called from #dmxBEDestroyWindow(), will * destroy a window as well as all of it's children. */ -static void dmxBEDestroyWindowTree(int idx) +static void +dmxBEDestroyWindowTree(int idx) { - WindowPtr pWin = screenInfo.screens[idx]->root; - WindowPtr pChild = pWin; + WindowPtr pWin = screenInfo.screens[idx]->root; + WindowPtr pChild = pWin; while (1) { - if (pChild->firstChild) { - pChild = pChild->firstChild; - continue; - } - - /* Destroy the window */ - dmxBEDestroyWindow(pChild); - - /* 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 (!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; + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + + /* Destroy the window */ + dmxBEDestroyWindow(pChild); + + /* 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 (!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; } } /** Detach back-end screen. */ -int dmxDetachScreen(int idx) +int +dmxDetachScreen(int idx) { DMXScreenInfo *dmxScreen = &dmxScreens[idx]; - int i; + int i; /* 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; + 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; + if (idx < 0 || idx >= dmxNumScreens) + return 1; /* Cannot detach from a screen that is not opened */ if (!dmxScreen->beDisplay) { - dmxLog(dmxWarning, - "Attempting to remove screen #%d but it has not been opened\n", - idx); - return 1; + dmxLog(dmxWarning, + "Attempting to remove screen #%d but it has not been opened\n", + idx); + return 1; } dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx); @@ -1595,10 +1677,10 @@ int dmxDetachScreen(int idx) /* 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)(uintptr_t)idx); + for (i = currentMaxClients; --i >= 0;) + if (clients[i]) + FindAllClientResources(clients[i], dmxBEDestroyResources, + (pointer) (uintptr_t) idx); /* Free scratch GCs */ dmxBEDestroyScratchGCs(idx); @@ -1616,5 +1698,5 @@ int dmxDetachScreen(int idx) /* Adjust the cursor boundaries (paints detached console window) */ dmxAdjustCursorBoundaries(); - return 0; /* Success */ + return 0; /* Success */ } |