Bool
winMapWindowMultiWindow (WindowPtr pWin)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winMapWindowMultiWindow - pWin: %08x\n", pWin);
#endif
WIN_UNWRAP(RealizeWindow);
fResult = (*pScreen->RealizeWindow)(pWin);
WIN_WRAP(RealizeWindow, winMapWindowMultiWindow);
/* Flag that this window has not been destroyed */
pWinPriv->fXKilled = FALSE;
/* Refresh/redisplay the Windows window associated with this X window */
winUpdateWindowsWindow (pWin);
#ifdef SHAPE
/* Update the Windows window's shape */
winReshapeMultiWindow (pWin);
winUpdateRgnMultiWindow (pWin);
#endif
return fResult;
}
Bool
winUnmapWindowRootless (WindowPtr pWin)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winUnmapWindowRootless (%p)\n", pWin);
#endif
WIN_UNWRAP(UnrealizeWindow);
fResult = (*pScreen->UnrealizeWindow)(pWin);
WIN_WRAP(UnrealizeWindow, winUnmapWindowRootless);
if (pWinPriv->hRgn != NULL)
{
DeleteObject(pWinPriv->hRgn);
pWinPriv->hRgn = NULL;
}
winUpdateRgnRootless (pWin);
return fResult;
}
static
int
winAddRgn (WindowPtr pWin, pointer data)
{
int iX, iY, iWidth, iHeight, iBorder;
HRGN hRgn = *(HRGN*)data;
HRGN hRgnWin;
winWindowPriv(pWin);
/* If pWin is not Root */
if (pWin->parent != NULL)
{
#if CYGDEBUG
ErrorF ("winAddRgn ()\n");
#endif
if (pWin->mapped)
{
iBorder = wBorderWidth (pWin);
iX = pWin->drawable.x - iBorder;
iY = pWin->drawable.y - iBorder;
iWidth = pWin->drawable.width + iBorder * 2;
iHeight = pWin->drawable.height + iBorder * 2;
hRgnWin = CreateRectRgn (0, 0, iWidth, iHeight);
if (hRgnWin == NULL)
{
ErrorF ("winAddRgn - CreateRectRgn () failed\n");
ErrorF (" Rect %d %d %d %d\n",
iX, iY, iX + iWidth, iY + iHeight);
}
if (pWinPriv->hRgn)
{
if (CombineRgn (hRgnWin, hRgnWin, pWinPriv->hRgn, RGN_AND)
== ERROR)
{
ErrorF ("winAddRgn - CombineRgn () failed\n");
}
}
OffsetRgn (hRgnWin, iX, iY);
if (CombineRgn (hRgn, hRgn, hRgnWin, RGN_OR) == ERROR)
{
ErrorF ("winAddRgn - CombineRgn () failed\n");
}
DeleteObject (hRgnWin);
}
return WT_DONTWALKCHILDREN;
}
else
{
return WT_WALKCHILDREN;
}
}
/*
* ResizeWindow - See Porting Layer Definition - p. 42
*/
void
winResizeWindowMultiWindow (WindowPtr pWin, int x, int y, unsigned int w,
unsigned int h, WindowPtr pSib)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGWINDOWING_DEBUG
ErrorF ("ResizeWindowMultiWindow to (%d, %d) - %dx%d\n", x, y, w, h);
#endif
WIN_UNWRAP(ResizeWindow);
(*pScreen->ResizeWindow)(pWin, x, y, w, h, pSib);
WIN_WRAP(ResizeWindow, winResizeWindowMultiWindow);
}
/*
* CopyWindow - See Porting Layer Definition - p. 39
*/
void
winCopyWindowMultiWindow (WindowPtr pWin, DDXPointRec oldpt,
RegionPtr oldRegion)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGWINDOWING_DEBUG
ErrorF ("CopyWindowMultiWindow\n");
#endif
WIN_UNWRAP(CopyWindow);
(*pScreen->CopyWindow)(pWin, oldpt, oldRegion);
WIN_WRAP(CopyWindow, winCopyWindowMultiWindow);
}
/*
* MoveWindow - See Porting Layer Definition - p. 42
*/
void
winMoveWindowMultiWindow (WindowPtr pWin, int x, int y,
WindowPtr pSib, VTKind kind)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGWINDOWING_DEBUG
ErrorF ("MoveWindowMultiWindow to (%d, %d)\n", x, y);
#endif
WIN_UNWRAP(MoveWindow);
(*pScreen->MoveWindow)(pWin, x, y, pSib, kind);
WIN_WRAP(MoveWindow, winMoveWindowMultiWindow);
}
Bool
winCreateWindowPRootless (WindowPtr pWin)
{
Bool fResult = FALSE;
winWindowPriv(pWin);
#if CYGDEBUG
ErrorF ("winCreateWindowPRootless ()\n");
#endif
fResult = winGetScreenPriv(pWin->drawable.pScreen)->CreateWindow(pWin);
pWinPriv->hRgn = NULL;
return fResult;
}
Bool
winCreateWindowNativeGDI (WindowPtr pWin)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winCreateWindowNativeGDI (%p)\n", pWin);
#endif
WIN_UNWRAP(CreateWindow);
fResult = (*pScreen->CreateWindow) (pWin);
WIN_WRAP(CreateWindow, winCreateWindowNativeGDI);
return fResult;
}
Bool
winUnmapWindowNativeGDI (WindowPtr pWin)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winUnmapWindowNativeGDI (%p)\n", pWin);
#endif
WIN_UNWRAP(UnrealizeWindow);
fResult = (*pScreen->UnrealizeWindow)(pWin);
WIN_WRAP(UnrealizeWindow, winUnmapWindowNativeGDI);
return fResult;
}
Bool
winPositionWindowNativeGDI (WindowPtr pWin, int x, int y)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winPositionWindowNativeGDI (%p)\n", pWin);
#endif
WIN_UNWRAP(PositionWindow);
fResult = (*pScreen->PositionWindow)(pWin, x, y);
WIN_WRAP(PositionWindow, winPositionWindowNativeGDI);
return fResult;
}
Bool
winCreateWindowRootless(WindowPtr pWin)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
winDebug ("winCreateWindowRootless (%p)\n", pWin);
WIN_UNWRAP(CreateWindow);
fResult = (*pScreen->CreateWindow) (pWin);
WIN_WRAP(CreateWindow, winCreateWindowRootless);
pWinPriv->hRgn = NULL;
return fResult;
}
void
winReparentWindowMultiWindow (WindowPtr pWin, WindowPtr pPriorParent)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winReparentMultiWindow - pWin: %08x\n", pWin);
#endif
WIN_UNWRAP(ReparentWindow);
if (pScreen->ReparentWindow)
(*pScreen->ReparentWindow)(pWin, pPriorParent);
WIN_WRAP(ReparentWindow, winReparentWindowMultiWindow);
/* Update the Windows window associated with this X window */
winUpdateWindowsWindow (pWin);
}
Bool
winChangeWindowAttributesRootless (WindowPtr pWin, unsigned long mask)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winChangeWindowAttributesRootless (%p)\n", pWin);
#endif
WIN_UNWRAP(ChangeWindowAttributes);
fResult = (*pScreen->ChangeWindowAttributes)(pWin, mask);
WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesRootless);
winUpdateRgnRootless (pWin);
return fResult;
}
void
winSetShapeRootless (WindowPtr pWin)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winSetShapeRootless (%p)\n", pWin);
#endif
WIN_UNWRAP(SetShape);
(*pScreen->SetShape)(pWin);
WIN_WRAP(SetShape, winSetShapeRootless);
winReshapeRootless (pWin);
winUpdateRgnRootless (pWin);
return;
}
static
Bool
winFinishCreateWindowsWindowDDNL (WindowPtr pWin)
{
winWindowPriv(pWin);
winPrivScreenPtr pScreenPriv = pWinPriv->pScreenPriv;
HRESULT ddrval = DD_OK;
DDSURFACEDESC2 ddsd;
int iWidth, iHeight;
int iX, iY;
winDebug ("winFinishCreateWindowsWindowDDNL!\n\n");
iX = pWin->drawable.x + GetSystemMetrics (SM_XVIRTUALSCREEN);
iY = pWin->drawable.y + GetSystemMetrics (SM_YVIRTUALSCREEN);
iWidth = pWin->drawable.width;
iHeight = pWin->drawable.height;
/* Describe the primary surface */
ZeroMemory (&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
ddsd.dwHeight = iHeight;
ddsd.dwWidth = iWidth;
/* Create the primary surface */
ddrval = IDirectDraw4_CreateSurface (pScreenPriv->pdd4,
&ddsd,
&pWinPriv->pddsPrimary4,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winFinishCreateWindowsWindowDDNL - Could not create primary "
"surface: %08x\n",
(unsigned int)ddrval);
return FALSE;
}
return TRUE;
}
Bool
winPositionWindowRootless (WindowPtr pWin, int x, int y)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winPositionWindowRootless (%p)\n", pWin);
#endif
WIN_UNWRAP(PositionWindow);
fResult = (*pScreen->PositionWindow)(pWin, x, y);
WIN_WRAP(PositionWindow, winPositionWindowRootless);
winUpdateRgnRootless (pWin);
return fResult;
}
void
winSetShapeMultiWindow (WindowPtr pWin)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winSetShapeMultiWindow - pWin: %08x\n", pWin);
#endif
WIN_UNWRAP(SetShape);
(*pScreen->SetShape)(pWin);
WIN_WRAP(SetShape, winSetShapeMultiWindow);
/* Update the Windows window's shape */
winReshapeMultiWindow (pWin);
winUpdateRgnMultiWindow (pWin);
return;
}
Bool
winUnmapWindowPRootless (WindowPtr pWin)
{
Bool fResult = FALSE;
winWindowPriv(pWin);
#if CYGDEBUG
ErrorF ("winUnmapWindowPRootless ()\n");
#endif
fResult = winGetScreenPriv(pWin->drawable.pScreen)->UnrealizeWindow(pWin);
if (pWinPriv->hRgn != NULL)
{
DeleteObject(pWinPriv->hRgn);
pWinPriv->hRgn = NULL;
}
winUpdateRgnPRootless (pWin);
return fResult;
}
static void
winUpdateWindowsWindow (WindowPtr pWin)
{
winWindowPriv(pWin);
HWND hWnd = pWinPriv->hWnd;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winUpdateWindowsWindow\n");
#endif
/* Check if the Windows window's parents have been destroyed */
if (pWin->parent != NULL
&& pWin->parent->parent == NULL
&& pWin->mapped)
{
/* Create the Windows window if it has been destroyed */
if (hWnd == NULL)
{
winCreateWindowsWindow (pWin);
assert (pWinPriv->hWnd != NULL);
}
/* Display the window without activating it */
ShowWindow (pWinPriv->hWnd, SW_SHOWNOACTIVATE);
/* Send first paint message */
UpdateWindow (pWinPriv->hWnd);
}
else if (hWnd != NULL)
{
/* Destroy the Windows window if its parents are destroyed */
winDestroyWindowsWindow (pWin);
assert (pWinPriv->hWnd == NULL);
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("-winUpdateWindowsWindow\n");
#endif
}
Bool
winChangeWindowAttributesNativeGDI (WindowPtr pWin, unsigned long mask)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winChangeWindowAttributesNativeGDI (%p)\n", pWin);
#endif
WIN_UNWRAP(ChangeWindowAttributes);
fResult = (*pScreen->ChangeWindowAttributes)(pWin, mask);
WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesNativeGDI);
/*
* NOTE: We do not currently need to do anything here.
*/
return fResult;
}
Bool
winChangeWindowAttributesMultiWindow (WindowPtr pWin, unsigned long mask)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winChangeWindowAttributesMultiWindow - pWin: %08x\n", pWin);
#endif
WIN_UNWRAP(ChangeWindowAttributes);
fResult = (*pScreen->ChangeWindowAttributes)(pWin, mask);
WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesMultiWindow);
/*
* NOTE: We do not currently need to do anything here.
*/
return fResult;
}
Bool
winUnmapWindowMultiWindow (WindowPtr pWin)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winUnmapWindowMultiWindow - pWin: %08x\n", pWin);
#endif
WIN_UNWRAP(UnrealizeWindow);
fResult = (*pScreen->UnrealizeWindow)(pWin);
WIN_WRAP(UnrealizeWindow, winUnmapWindowMultiWindow);
/* Flag that the window has been killed */
pWinPriv->fXKilled = TRUE;
/* Destroy the Windows window associated with this X window */
winDestroyWindowsWindow (pWin);
return fResult;
}
Bool
winMapWindowRootless (WindowPtr pWin)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGDEBUG
winTrace ("winMapWindowRootless (%p)\n", pWin);
#endif
WIN_UNWRAP(RealizeWindow);
fResult = (*pScreen->RealizeWindow)(pWin);
WIN_WRAP(RealizeWindow, winMapWindowRootless);
#ifdef SHAPE
winReshapeRootless (pWin);
#endif
winUpdateRgnRootless (pWin);
return fResult;
}
Bool
winCreateWindowMultiWindow (WindowPtr pWin)
{
Bool fResult = TRUE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG
winTrace ("winCreateWindowMultiWindow - pWin: %p\n", pWin);
#endif
WIN_UNWRAP(CreateWindow);
fResult = (*pScreen->CreateWindow) (pWin);
WIN_WRAP(CreateWindow, winCreateWindowMultiWindow);
/* Initialize some privates values */
pWinPriv->hRgn = NULL;
pWinPriv->hWnd = NULL;
pWinPriv->pScreenPriv = winGetScreenPriv(pWin->drawable.pScreen);
pWinPriv->fXKilled = FALSE;
return fResult;
}
Bool
winDestroyWindowRootless(WindowPtr pWin)
{
Bool fResult = FALSE;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
winDebug ("winDestroyWindowRootless (%p)\n", pWin);
WIN_UNWRAP(DestroyWindow);
fResult = (*pScreen->DestroyWindow) (pWin);
WIN_WRAP(DestroyWindow, winDestroyWindowRootless);
if (pWinPriv->hRgn != NULL) {
DeleteObject(pWinPriv->hRgn);
pWinPriv->hRgn = NULL;
}
winUpdateRgnRootless(pWin);
return fResult;
}
static
void
winReshapePRootless (WindowPtr pWin)
{
int nRects;
ScreenPtr pScreen = pWin->drawable.pScreen;
RegionRec rrNewShape;
BoxPtr pShape, pRects, pEnd;
HRGN hRgn, hRgnRect;
winWindowPriv(pWin);
#if CYGDEBUG
ErrorF ("winReshapePRootless ()\n");
#endif
/* Bail if the window is the root window */
if (pWin->parent == NULL)
return;
/* Bail if the window is not top level */
if (pWin->parent->parent != NULL)
return;
/* Free any existing window region stored in the window privates */
if (pWinPriv->hRgn != NULL)
{
DeleteObject (pWinPriv->hRgn);
pWinPriv->hRgn = NULL;
}
/* Bail if the window has no bounding region defined */
if (!wBoundingShape (pWin))
return;
REGION_NULL(pScreen, &rrNewShape);
REGION_COPY(pScreen, &rrNewShape, wBoundingShape(pWin));
REGION_TRANSLATE(pScreen, &rrNewShape, pWin->borderWidth,
pWin->borderWidth);
nRects = REGION_NUM_RECTS(&rrNewShape);
pShape = REGION_RECTS(&rrNewShape);
if (nRects > 0)
{
/* Create initial empty Windows region */
hRgn = CreateRectRgn (0, 0, 0, 0);
/* Loop through all rectangles in the X region */
for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++)
{
/* Create a Windows region for the X rectangle */
hRgnRect = CreateRectRgn (pRects->x1, pRects->y1,
pRects->x2, pRects->y2);
if (hRgnRect == NULL)
{
ErrorF("winReshapePRootless - CreateRectRgn() failed\n");
}
/* Merge the Windows region with the accumulated region */
if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)
{
ErrorF("winReshapePRootless - CombineRgn() failed\n");
}
/* Delete the temporary Windows region */
DeleteObject (hRgnRect);
}
/* Save a handle to the composite region in the window privates */
pWinPriv->hRgn = hRgn;
}
REGION_UNINIT(pScreen, &rrNewShape);
return;
}
void
winRestackWindowMultiWindow (WindowPtr pWin, WindowPtr pOldNextSib)
{
WindowPtr pPrevWin;
UINT uFlags;
HWND hInsertAfter;
HWND hWnd = NULL;
ScreenPtr pScreen = pWin->drawable.pScreen;
winWindowPriv(pWin);
winScreenPriv(pScreen);
#if CYGMULTIWINDOW_DEBUG || CYGWINDOWING_DEBUG
winTrace ("winRestackMultiWindow - %08x\n", pWin);
#endif
WIN_UNWRAP(RestackWindow);
if (pScreen->RestackWindow)
(*pScreen->RestackWindow)(pWin, pOldNextSib);
WIN_WRAP(RestackWindow, winRestackWindowMultiWindow);
#if 1
/*
* Calling winReorderWindowsMultiWindow here means our window manager
* (i.e. Windows Explorer) has initiative to determine Z order.
*/
if (pWin->nextSib != pOldNextSib)
winReorderWindowsMultiWindow ();
#else
/* Bail out if no window privates or window handle is invalid */
if (!pWinPriv || !pWinPriv->hWnd)
return;
/* Get a pointer to our previous sibling window */
pPrevWin = pWin->prevSib;
/*
* Look for a sibling window with
* valid privates and window handle
*/
while (pPrevWin
&& !winGetWindowPriv(pPrevWin)
&& !winGetWindowPriv(pPrevWin)->hWnd)
pPrevWin = pPrevWin->prevSib;
/* Check if we found a valid sibling */
if (pPrevWin)
{
/* Valid sibling - get handle to insert window after */
hInsertAfter = winGetWindowPriv(pPrevWin)->hWnd;
uFlags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE;
hWnd = GetNextWindow (pWinPriv->hWnd, GW_HWNDPREV);
do
{
if (GetProp (hWnd, WIN_WINDOW_PROP))
{
if (hWnd == winGetWindowPriv(pPrevWin)->hWnd)
{
uFlags |= SWP_NOZORDER;
}
break;
}
hWnd = GetNextWindow (hWnd, GW_HWNDPREV);
}
while (hWnd);
}
else
{
/* No valid sibling - make this window the top window */
hInsertAfter = HWND_TOP;
uFlags = SWP_NOMOVE | SWP_NOSIZE;
}
/* Perform the restacking operation in Windows */
SetWindowPos (pWinPriv->hWnd,
hInsertAfter,
0, 0,
0, 0,
uFlags);
#endif
}
void
winReshapeMultiWindow(WindowPtr pWin)
{
int nRects;
RegionRec rrNewShape;
BoxPtr pShape, pRects, pEnd;
HRGN hRgn, hRgnRect;
winWindowPriv(pWin);
winDebug("winReshape ()\n");
/* Bail if the window is the root window */
if (pWin->parent == NULL)
return;
/* Bail if the window is not top level */
if (pWin->parent->parent != NULL)
return;
/* Bail if Windows window handle is invalid */
if (pWinPriv->hWnd == NULL)
return;
/* Free any existing window region stored in the window privates */
if (pWinPriv->hRgn != NULL) {
DeleteObject(pWinPriv->hRgn);
pWinPriv->hRgn = NULL;
}
/* Bail if the window has no bounding region defined */
if (!wBoundingShape(pWin))
return;
RegionNull(&rrNewShape);
RegionCopy(&rrNewShape, wBoundingShape(pWin));
RegionTranslate(&rrNewShape, pWin->borderWidth, pWin->borderWidth);
nRects = RegionNumRects(&rrNewShape);
pShape = RegionRects(&rrNewShape);
/* Don't do anything if there are no rectangles in the region */
if (nRects > 0) {
RECT rcClient;
RECT rcWindow;
int iOffsetX, iOffsetY;
/* Get client rectangle */
if (!GetClientRect(pWinPriv->hWnd, &rcClient)) {
ErrorF("winReshape - GetClientRect failed, bailing: %d\n",
(int) GetLastError());
return;
}
/* Translate client rectangle coords to screen coords */
/* NOTE: Only transforms top and left members */
ClientToScreen(pWinPriv->hWnd, (LPPOINT) &rcClient);
/* Get window rectangle */
if (!GetWindowRect(pWinPriv->hWnd, &rcWindow)) {
ErrorF("winReshape - GetWindowRect failed, bailing: %d\n",
(int) GetLastError());
return;
}
/* Calculate offset from window upper-left to client upper-left */
iOffsetX = rcClient.left - rcWindow.left;
iOffsetY = rcClient.top - rcWindow.top;
/* Create initial Windows region for title bar */
/* FIXME: Mean, nasty, ugly hack!!! */
hRgn = CreateRectRgn(0, 0, rcWindow.right, iOffsetY);
if (hRgn == NULL) {
ErrorF("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "
"failed: %d\n",
0, 0, (int) rcWindow.right, iOffsetY, (int) GetLastError());
}
/* Loop through all rectangles in the X region */
for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++) {
/* Create a Windows region for the X rectangle */
hRgnRect = CreateRectRgn(pRects->x1 + iOffsetX,
pRects->y1 + iOffsetY,
pRects->x2 + iOffsetX,
pRects->y2 + iOffsetY);
if (hRgnRect == NULL) {
ErrorF("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "
"failed: %d\n"
"\tx1: %d x2: %d xOff: %d y1: %d y2: %d yOff: %d\n",
pRects->x1 + iOffsetX,
pRects->y1 + iOffsetY,
pRects->x2 + iOffsetX,
pRects->y2 + iOffsetY,
(int) GetLastError(),
pRects->x1, pRects->x2, iOffsetX,
pRects->y1, pRects->y2, iOffsetY);
}
/* Merge the Windows region with the accumulated region */
if (CombineRgn(hRgn, hRgn, hRgnRect, RGN_OR) == ERROR) {
ErrorF("winReshape - CombineRgn () failed: %d\n",
(int) GetLastError());
}
/* Delete the temporary Windows region */
DeleteObject(hRgnRect);
}
/* Save a handle to the composite region in the window privates */
pWinPriv->hRgn = hRgn;
}
RegionUninit(&rrNewShape);
return;
}
void
winCreateWindowsWindow (WindowPtr pWin)
{
int iX, iY;
int iWidth;
int iHeight;
HWND hWnd;
WNDCLASSEX wc;
winWindowPriv(pWin);
HICON hIcon;
HICON hIconSmall;
#define CLASS_NAME_LENGTH 512
char pszClass[CLASS_NAME_LENGTH], pszWindowID[12];
char *res_name, *res_class, *res_role;
static int s_iWindowID = 0;
winPrivScreenPtr pScreenPriv = pWinPriv->pScreenPriv;
WinXSizeHints hints;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winCreateWindowsWindow - pWin: %08x\n", pWin);
#endif
iX = pWin->drawable.x + GetSystemMetrics (SM_XVIRTUALSCREEN);
iY = pWin->drawable.y + GetSystemMetrics (SM_YVIRTUALSCREEN);
/* Default positions if none specified */
if (!winMultiWindowGetWMNormalHints(pWin, &hints))
hints.flags = 0;
if ( !(hints.flags & (USPosition|PPosition)) &&
!winMultiWindowGetTransientFor (pWin, NULL) &&
!pWin->overrideRedirect )
{
iX = CW_USEDEFAULT;
iY = CW_USEDEFAULT;
}
iWidth = pWin->drawable.width;
iHeight = pWin->drawable.height;
winSelectIcons(pWin, &hIcon, &hIconSmall);
/* Set standard class name prefix so we can identify window easily */
strncpy (pszClass, WINDOW_CLASS_X, sizeof(pszClass));
if (winMultiWindowGetClassHint (pWin, &res_name, &res_class))
{
strncat (pszClass, "-", 1);
strncat (pszClass, res_name, CLASS_NAME_LENGTH - strlen (pszClass));
strncat (pszClass, "-", 1);
strncat (pszClass, res_class, CLASS_NAME_LENGTH - strlen (pszClass));
/* Check if a window class is provided by the WM_WINDOW_ROLE property,
* if not use the WM_CLASS information.
* For further information see:
* http://tronche.com/gui/x/icccm/sec-5.html
*/
if (winMultiWindowGetWindowRole (pWin, &res_role) )
{
strcat (pszClass, "-");
strcat (pszClass, res_role);
free (res_role);
}
free (res_name);
free (res_class);
}
/* Add incrementing window ID to make unique class name */
snprintf (pszWindowID, sizeof(pszWindowID), "-%x", s_iWindowID++);
pszWindowID[sizeof(pszWindowID)-1] = 0;
strcat (pszClass, pszWindowID);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winCreateWindowsWindow - Creating class: %s\n", pszClass);
#endif
/* Setup our window class */
wc.cbSize = sizeof(wc);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = winTopLevelWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_hInstance;
wc.hIcon = hIcon;
wc.hIconSm = hIconSmall;
wc.hCursor = 0;
wc.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = pszClass;
RegisterClassEx (&wc);
/* Create the window */
/* Make it OVERLAPPED in create call since WS_POPUP doesn't support */
/* CW_USEDEFAULT, change back to popup after creation */
hWnd = CreateWindowExA (WS_EX_TOOLWINDOW, /* Extended styles */
pszClass, /* Class name */
WINDOW_TITLE_X, /* Window name */
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
iX, /* Horizontal position */
iY, /* Vertical position */
iWidth, /* Right edge */
iHeight, /* Bottom edge */
(HWND) NULL, /* No parent or owner window */
(HMENU) NULL, /* No menu */
GetModuleHandle (NULL), /* Instance handle */
pWin); /* ScreenPrivates */
if (hWnd == NULL)
{
ErrorF ("winCreateWindowsWindow - CreateWindowExA () failed: %d\n",
(int) GetLastError ());
}
/* Change style back to popup, already placed... */
SetWindowLong (hWnd, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
SetWindowPos (hWnd, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
/* Make sure it gets the proper system menu for a WS_POPUP, too */
GetSystemMenu (hWnd, TRUE);
pWinPriv->hWnd = hWnd;
/* Cause any .XWinrc menus to be added in main WNDPROC */
PostMessage (hWnd, WM_INIT_SYS_MENU, 0, 0);
SetProp (pWinPriv->hWnd, WIN_WID_PROP, (HANDLE) winGetWindowID(pWin));
/* Flag that this Windows window handles its own activation */
SetProp (pWinPriv->hWnd, WIN_NEEDMANAGE_PROP, (HANDLE) 0);
/* Call engine-specific create window procedure */
(*pScreenPriv->pwinFinishCreateWindowsWindow) (pWin);
}
/*
* winDestroyWindowsWindow - Destroy a Windows window associated
* with an X window
*/
static void
winDestroyWindowsWindow (WindowPtr pWin)
{
MSG msg;
winWindowPriv(pWin);
HICON hiconClass;
HICON hiconSmClass;
HMODULE hInstance;
int iReturn;
char pszClass[512];
BOOL oldstate = winInDestroyWindowsWindow;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winDestroyWindowsWindow\n");
#endif
/* Bail out if the Windows window handle is invalid */
if (pWinPriv->hWnd == NULL)
return;
winInDestroyWindowsWindow = TRUE;
/* Store the info we need to destroy after this window is gone */
hInstance = (HINSTANCE) GetClassLong (pWinPriv->hWnd, GCL_HMODULE);
hiconClass = (HICON) GetClassLong (pWinPriv->hWnd, GCL_HICON);
hiconSmClass = (HICON) GetClassLong (pWinPriv->hWnd, GCL_HICONSM);
iReturn = GetClassName (pWinPriv->hWnd, pszClass, 512);
SetProp (pWinPriv->hWnd, WIN_WINDOW_PROP, NULL);
/* Destroy the Windows window */
DestroyWindow (pWinPriv->hWnd);
/* Null our handle to the Window so referencing it will cause an error */
pWinPriv->hWnd = NULL;
/* Process all messages on our queue */
while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
{
if (g_hDlgDepthChange == 0 || !IsDialogMessage (g_hDlgDepthChange, &msg))
{
DispatchMessage (&msg);
}
}
/* Only if we were able to get the name */
if (iReturn)
{
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winDestroyWindowsWindow - Unregistering %s: ", pszClass);
#endif
iReturn = UnregisterClass (pszClass, hInstance);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winDestroyWindowsWindow - %d Deleting Icon: ", iReturn);
#endif
winDestroyIcon(hiconClass);
winDestroyIcon(hiconSmClass);
}
winInDestroyWindowsWindow = oldstate;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("-winDestroyWindowsWindow\n");
#endif
}
