Instead of getting the current msc value from the window crtc, which not exist take the last saved msc value saved in the window_priv struct Signed-off-by: Łukasz Spintzyk <lukasz.spintzyk@synaptics.com>
1703 lines
56 KiB
C
1703 lines
56 KiB
C
/*
|
|
* 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 <faith@redhat.com>
|
|
* Kevin E. Martin <kem@redhat.com>
|
|
*
|
|
*/
|
|
|
|
/** \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 <dmx-config.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#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 "dmxpict.h"
|
|
#include "dmxinput.h"
|
|
#include "dmxsync.h"
|
|
#include "dmxscrinit.h"
|
|
#include "input/dmxinputinit.h"
|
|
|
|
#include "windowstr.h"
|
|
#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;
|
|
|
|
/** 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->displayName = dmxScreen->name;
|
|
#ifdef PANORAMIX
|
|
attr->logicalScreen = noPanoramiXExtension ? dmxScreen->index : 0;
|
|
#else
|
|
attr->logicalScreen = dmxScreen->index;
|
|
#endif
|
|
|
|
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->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)
|
|
{
|
|
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;
|
|
}
|
|
|
|
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 < dmxNumInputs; i++)
|
|
total += dmxInputs[i].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 < 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;
|
|
switch (dmxLocal->extType) {
|
|
case DMX_LOCAL_TYPE_LOCAL:
|
|
attr->inputType = 0;
|
|
break;
|
|
case DMX_LOCAL_TYPE_CONSOLE:
|
|
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->physicalScreen = dmxInput->scrnIdx;
|
|
attr->name = dmxInput->name;
|
|
attr->physicalId = dmxLocal->deviceId;
|
|
break;
|
|
}
|
|
return 0; /* Success */
|
|
}
|
|
}
|
|
return -1; /* Failure */
|
|
}
|
|
|
|
/** Reinitialized the cursor boundaries. */
|
|
static void
|
|
dmxAdjustCursorBoundaries(void)
|
|
{
|
|
int i;
|
|
|
|
dmxReInitOrigins();
|
|
dmxInitOverlap();
|
|
dmxComputeWidthHeight(DMX_NO_RECOMPUTE_BOUNDING_BOX);
|
|
dmxConnectionBlockCallback();
|
|
for (i = 0; i < dmxNumInputs; i++) {
|
|
DMXInputInfo *dmxInput = &dmxInputs[i];
|
|
|
|
if (!dmxInput->detached)
|
|
dmxInputReInit(dmxInput);
|
|
}
|
|
|
|
dmxCheckCursor();
|
|
|
|
for (i = 0; i < dmxNumInputs; i++) {
|
|
DMXInputInfo *dmxInput = &dmxInputs[i];
|
|
|
|
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 retcode = BadValue;
|
|
|
|
if (attr->inputType == 1) /* console */
|
|
retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);
|
|
else if (attr->inputType == 2) /* backend */
|
|
retcode = dmxInputAttachBackend(attr->physicalScreen,
|
|
attr->sendsCore, id);
|
|
|
|
if (retcode == Success) {
|
|
/* Adjust the cursor boundaries */
|
|
dmxAdjustCursorBoundaries();
|
|
|
|
/* Force completion of the changes */
|
|
dmxSync(NULL, TRUE);
|
|
}
|
|
|
|
return retcode;
|
|
}
|
|
|
|
/** Remove the input with physical id \a id. */
|
|
int
|
|
dmxRemoveInput(int id)
|
|
{
|
|
return dmxInputDetachId(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)
|
|
{
|
|
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 = 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;
|
|
}
|
|
|
|
/* 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()
|
|
*/
|
|
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);
|
|
}
|
|
}
|
|
|
|
#ifdef PANORAMIX
|
|
#include "panoramiXsrv.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)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[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);
|
|
}
|
|
|
|
/* Change "screen" window values */
|
|
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)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
|
|
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);
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* Change "root" window values */
|
|
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)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
|
|
ScreenPtr pScreen = screenInfo.screens[idx];
|
|
WindowPtr pRoot = pScreen->root;
|
|
WindowPtr pChild;
|
|
int xoff;
|
|
int yoff;
|
|
|
|
/* Change "root" window's origin */
|
|
dmxScreen->rootXOrigin = x;
|
|
dmxScreen->rootYOrigin = y;
|
|
|
|
/* Compute offsets here in case <x,y> has been changed above */
|
|
xoff = x - pScreen->x;
|
|
yoff = y - pScreen->y;
|
|
|
|
/* Adjust the root window's position */
|
|
pScreen->x = dmxScreen->rootXOrigin;
|
|
pScreen->y = dmxScreen->rootYOrigin;
|
|
|
|
/* Recalculate the Xinerama regions and data structs */
|
|
XineramaReinitData();
|
|
|
|
/* Adjust each of the root window's children */
|
|
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;
|
|
}
|
|
}
|
|
|
|
/** Configure the attributes of each "screen" and "root" window. */
|
|
int
|
|
dmxConfigureScreenWindows(int nscreens,
|
|
CARD32 *screens,
|
|
DMXScreenAttributesPtr attribs, int *errorScreen)
|
|
{
|
|
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 */
|
|
}
|
|
|
|
/* No illegal values found */
|
|
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);
|
|
}
|
|
|
|
/* Adjust the cursor boundaries */
|
|
dmxAdjustCursorBoundaries();
|
|
|
|
/* Force completion of the changes */
|
|
dmxSync(NULL, TRUE);
|
|
|
|
return Success;
|
|
}
|
|
|
|
/** Configure the attributes of the global desktop. */
|
|
int
|
|
dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Set the global width/height */
|
|
dmxSetWidthHeight(attribs->width, attribs->height);
|
|
|
|
/* 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Update connection block, Xinerama, etc. -- these appears to
|
|
* already be handled in dmxConnectionBlockCallback(), which is
|
|
* called from dmxAdjustCursorBoundaries() [below]. */
|
|
|
|
/* Adjust the cursor boundaries */
|
|
dmxAdjustCursorBoundaries();
|
|
|
|
/* Force completion of the changes */
|
|
dmxSync(NULL, TRUE);
|
|
|
|
return Success;
|
|
}
|
|
#endif
|
|
|
|
/** 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;
|
|
|
|
/** 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(void *value, XID id, RESTYPE type, void *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((void **) &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((void **) &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)
|
|
{
|
|
#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,
|
|
(void *) 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");
|
|
}
|
|
}
|
|
#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(void *value, XID id, RESTYPE type, void *n)
|
|
{
|
|
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->defaultStipple) {
|
|
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);
|
|
#endif
|
|
}
|
|
else {
|
|
/* Other resource types??? */
|
|
}
|
|
}
|
|
|
|
/** Create window hierarchy 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 = 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);
|
|
}
|
|
if (pRoot->backgroundState == BackgroundPixmap) {
|
|
dmxBECreatePixmap(pRoot->background.pixmap);
|
|
dmxBERestorePixmap(pRoot->background.pixmap);
|
|
}
|
|
|
|
/* Create root window first */
|
|
dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot);
|
|
XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
/* Refresh screen by generating exposure events for all windows */
|
|
static void
|
|
dmxForceExposures(int idx)
|
|
{
|
|
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);
|
|
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);
|
|
}
|
|
}
|
|
|
|
/** Compare the new and old screens to see if they are compatible. */
|
|
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;
|
|
for (i = 0; i < old->beNumDepths; i++)
|
|
if (new->beDepths[i] != old->beDepths[i])
|
|
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->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;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/** Restore Render's picture */
|
|
static void
|
|
dmxBERestoreRenderPict(void *value, XID id, void *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;
|
|
}
|
|
|
|
if (pDraw->type == DRAWABLE_PIXMAP) {
|
|
PixmapPtr pPixmap = (PixmapPtr) pDraw;
|
|
|
|
/* Create and restore the pixmap drawable */
|
|
dmxBECreatePixmap(pPixmap);
|
|
dmxBERestorePixmap(pPixmap);
|
|
}
|
|
|
|
dmxBECreatePicture(pPicture);
|
|
}
|
|
|
|
/** Restore Render's glyphs */
|
|
static void
|
|
dmxBERestoreRenderGlyph(void *value, XID id, void *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;
|
|
|
|
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;
|
|
len_images += gl->size - sizeof(gl->info);
|
|
}
|
|
|
|
/* Now allocate the memory we need */
|
|
images = calloc(len_images, sizeof(char));
|
|
gids = xallocarray(glyphSet->hash.tableEntries, sizeof(Glyph));
|
|
glyphs = xallocarray(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++;
|
|
}
|
|
|
|
/* Now restore the glyph data */
|
|
XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],
|
|
gids, glyphs, glyphSet->hash.tableEntries, images,
|
|
len_images);
|
|
|
|
/* Clean up */
|
|
free(images);
|
|
free(gids);
|
|
free(glyphs);
|
|
}
|
|
|
|
/** Reattach previously detached back-end screen. */
|
|
int
|
|
dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
|
|
{
|
|
ScreenPtr pScreen;
|
|
DMXScreenInfo *dmxScreen;
|
|
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;
|
|
}
|
|
|
|
/* Cannot add a screen that does not exist */
|
|
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;
|
|
}
|
|
|
|
dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);
|
|
|
|
/* Save old info */
|
|
oldDMXScreen = *dmxScreen;
|
|
|
|
/* Copy the name to the new screen */
|
|
dmxScreen->name = strdup(attr->displayName);
|
|
|
|
/* Open display and get all of the screen info */
|
|
if (!dmxOpenDisplay(dmxScreen)) {
|
|
dmxLog(dmxWarning,
|
|
"dmxOpenDisplay: Unable to open display %s\n", dmxScreen->name);
|
|
|
|
/* Restore the old screen */
|
|
*dmxScreen = oldDMXScreen;
|
|
return 1;
|
|
}
|
|
|
|
dmxSetErrorHandler(dmxScreen);
|
|
dmxCheckForWM(dmxScreen);
|
|
dmxGetScreenAttribs(dmxScreen);
|
|
|
|
if (!dmxGetVisualInfo(dmxScreen)) {
|
|
dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
|
|
XFree(dmxScreen->beVisuals);
|
|
XCloseDisplay(dmxScreen->beDisplay);
|
|
|
|
/* 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)) {
|
|
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 */
|
|
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->defaultStipple);
|
|
dmxBERestorePixmap(pScreen->defaultStipple);
|
|
|
|
/* Create the scratch GCs */
|
|
dmxBECreateScratchGCs(idx);
|
|
|
|
/* Create the default font */
|
|
(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,
|
|
(void *) (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,
|
|
(void *) (uintptr_t) idx);
|
|
|
|
/* Restore the glyph state for RENDER */
|
|
for (i = currentMaxClients; --i >= 0;)
|
|
if (clients[i])
|
|
FindClientResourcesByType(clients[i], GlyphSetType,
|
|
dmxBERestoreRenderGlyph,
|
|
(void *) (uintptr_t) idx);
|
|
|
|
/* Refresh screen by generating exposure events for all windows */
|
|
dmxForceExposures(idx);
|
|
|
|
dmxSync(&dmxScreens[idx], TRUE);
|
|
|
|
/* 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. */
|
|
XFree(oldDMXScreen.beVisuals);
|
|
XFree(oldDMXScreen.beDepths);
|
|
XFree(oldDMXScreen.bePixmapFormats);
|
|
/* TODO: should oldDMXScreen.name be freed?? */
|
|
|
|
#ifdef PANORAMIX
|
|
if (!noPanoramiXExtension)
|
|
return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
|
|
else
|
|
#endif
|
|
return 0; /* Success */
|
|
}
|
|
|
|
/*
|
|
* 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(void *value, XID id, RESTYPE type, void *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((void **) &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((void **) &pSrc, pXinPix->info[i].id,
|
|
RT_PIXMAP, NullClient, DixUnknownAccess);
|
|
pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
|
|
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,
|
|
(void *) 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");
|
|
}
|
|
}
|
|
#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(void *value, XID id, RESTYPE type, void *n)
|
|
{
|
|
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??? */
|
|
}
|
|
}
|
|
|
|
/** 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 hierarchy 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 #dmxBEDestroyWindow(), will
|
|
* destroy a window as well as all of its children. */
|
|
static void
|
|
dmxBEDestroyWindowTree(int idx)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
/** Detach back-end screen. */
|
|
int
|
|
dmxDetachScreen(int idx)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
|
|
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;
|
|
}
|
|
|
|
/* Cannot remove a screen that does not exist */
|
|
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;
|
|
}
|
|
|
|
dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);
|
|
|
|
/* Detach input */
|
|
dmxInputDetachAll(dmxScreen);
|
|
|
|
/* 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,
|
|
(void *) (uintptr_t) idx);
|
|
|
|
/* Free scratch GCs */
|
|
dmxBEDestroyScratchGCs(idx);
|
|
|
|
/* Free window resources related to this screen */
|
|
dmxBEDestroyWindowTree(idx);
|
|
|
|
/* Free default stipple */
|
|
dmxBESavePixmap(screenInfo.screens[idx]->defaultStipple);
|
|
dmxBEFreePixmap(screenInfo.screens[idx]->defaultStipple);
|
|
|
|
/* Free the remaining screen resources and close the screen */
|
|
dmxBECloseScreen(screenInfo.screens[idx]);
|
|
|
|
/* Adjust the cursor boundaries (paints detached console window) */
|
|
dmxAdjustCursorBoundaries();
|
|
|
|
return 0; /* Success */
|
|
}
|