1 /*
2 *Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
3 *Copyright (C) Colin Harrison 2005-2008
4 *
5 *Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 *"Software"), to deal in the Software without restriction, including
8 *without limitation the rights to use, copy, modify, merge, publish,
9 *distribute, sublicense, and/or sell copies of the Software, and to
10 *permit persons to whom the Software is furnished to do so, subject to
11 *the following conditions:
12 *
13 *The above copyright notice and this permission notice shall be
14 *included in all copies or substantial portions of the Software.
15 *
16 *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 *NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
20 *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
21 *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 *Except as contained in this notice, the name of the XFree86 Project
25 *shall not be used in advertising or otherwise to promote the sale, use
26 *or other dealings in this Software without prior written authorization
27 *from the XFree86 Project.
28 *
29 * Authors: Kensuke Matsuzaki
30 * Earle F. Philhower, III
31 * Harold L Hunt II
32 * Colin Harrison
33 */
34
35 #ifdef HAVE_XWIN_CONFIG_H
36 #include <xwin-config.h>
37 #endif
38
39 #include "win.h"
40 #include "dixevents.h"
41 #include "winmultiwindowclass.h"
42 #include "winmultiwindowicons.h"
43
44 /*
45 * Prototypes for local functions
46 */
47
48 void
49 winCreateWindowsWindow(WindowPtr pWin);
50
51 static void
52 winDestroyWindowsWindow(WindowPtr pWin);
53
54 static void
55 winUpdateWindowsWindow(WindowPtr pWin);
56
57 static void
58 winFindWindow(void *value, XID id, void *cdata);
59
60 static
61 void
winInitMultiWindowClass(void)62 winInitMultiWindowClass(void)
63 {
64 static wATOM atomXWinClass = 0;
65 WNDCLASSEX wcx;
66
67 if (atomXWinClass == 0) {
68 HICON hIcon, hIconSmall;
69
70 /* Load the default icons */
71 winSelectIcons(&hIcon, &hIconSmall);
72
73 /* Setup our window class */
74 wcx.cbSize = sizeof(WNDCLASSEX);
75 wcx.style = CS_HREDRAW | CS_VREDRAW | (g_fNativeGl ? CS_OWNDC : 0);
76 wcx.lpfnWndProc = winTopLevelWindowProc;
77 wcx.cbClsExtra = 0;
78 wcx.cbWndExtra = 0;
79 wcx.hInstance = g_hInstance;
80 wcx.hIcon = hIcon;
81 wcx.hCursor = 0;
82 wcx.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
83 wcx.lpszMenuName = NULL;
84 wcx.lpszClassName = WINDOW_CLASS_X;
85 wcx.hIconSm = hIconSmall;
86
87 #if CYGMULTIWINDOW_DEBUG
88 ErrorF("winCreateWindowsWindow - Creating class: %s\n", WINDOW_CLASS_X);
89 #endif
90
91 atomXWinClass = RegisterClassEx(&wcx);
92 }
93 }
94
95 /*
96 * CreateWindow - See Porting Layer Definition - p. 37
97 */
98
99 Bool
winCreateWindowMultiWindow(WindowPtr pWin)100 winCreateWindowMultiWindow(WindowPtr pWin)
101 {
102 Bool fResult = TRUE;
103 ScreenPtr pScreen = pWin->drawable.pScreen;
104
105 winWindowPriv(pWin);
106 winScreenPriv(pScreen);
107
108 #if CYGMULTIWINDOW_DEBUG
109 winTrace("winCreateWindowMultiWindow - pWin: %p\n", pWin);
110 #endif
111
112 WIN_UNWRAP(CreateWindow);
113 fResult = (*pScreen->CreateWindow) (pWin);
114 WIN_WRAP(CreateWindow, winCreateWindowMultiWindow);
115
116 /* Initialize some privates values */
117 pWinPriv->hRgn = NULL;
118 pWinPriv->hWnd = NULL;
119 pWinPriv->pScreenPriv = winGetScreenPriv(pWin->drawable.pScreen);
120 pWinPriv->fXKilled = FALSE;
121 #ifdef XWIN_GLX_WINDOWS
122 pWinPriv->fWglUsed = FALSE;
123 #endif
124
125 return fResult;
126 }
127
128 /*
129 * DestroyWindow - See Porting Layer Definition - p. 37
130 */
131
132 Bool
winDestroyWindowMultiWindow(WindowPtr pWin)133 winDestroyWindowMultiWindow(WindowPtr pWin)
134 {
135 Bool fResult = TRUE;
136 ScreenPtr pScreen = pWin->drawable.pScreen;
137
138 winWindowPriv(pWin);
139 winScreenPriv(pScreen);
140
141 #if CYGMULTIWINDOW_DEBUG
142 ErrorF("winDestroyWindowMultiWindow - pWin: %p\n", pWin);
143 #endif
144
145 WIN_UNWRAP(DestroyWindow);
146 fResult = (*pScreen->DestroyWindow) (pWin);
147 WIN_WRAP(DestroyWindow, winDestroyWindowMultiWindow);
148
149 /* Flag that the window has been destroyed */
150 pWinPriv->fXKilled = TRUE;
151
152 /* Kill the MS Windows window associated with this window */
153 winDestroyWindowsWindow(pWin);
154
155 return fResult;
156 }
157
158 /*
159 * PositionWindow - See Porting Layer Definition - p. 37
160 *
161 * This function adjusts the position and size of Windows window
162 * with respect to the underlying X window. This is the inverse
163 * of winAdjustXWindow, which adjusts X window to Windows window.
164 */
165
166 Bool
winPositionWindowMultiWindow(WindowPtr pWin,int x,int y)167 winPositionWindowMultiWindow(WindowPtr pWin, int x, int y)
168 {
169 Bool fResult = TRUE;
170 int iX, iY, iWidth, iHeight;
171 ScreenPtr pScreen = pWin->drawable.pScreen;
172
173 winWindowPriv(pWin);
174 winScreenPriv(pScreen);
175
176 HWND hWnd = pWinPriv->hWnd;
177 RECT rcNew;
178 RECT rcOld;
179
180 #if CYGMULTIWINDOW_DEBUG
181 RECT rcClient;
182 RECT *lpRc;
183 #endif
184 DWORD dwExStyle;
185 DWORD dwStyle;
186
187 #if CYGMULTIWINDOW_DEBUG
188 winTrace("winPositionWindowMultiWindow - pWin: %p\n", pWin);
189 #endif
190
191 WIN_UNWRAP(PositionWindow);
192 fResult = (*pScreen->PositionWindow) (pWin, x, y);
193 WIN_WRAP(PositionWindow, winPositionWindowMultiWindow);
194
195 #if CYGWINDOWING_DEBUG
196 ErrorF("winPositionWindowMultiWindow: (x, y) = (%d, %d)\n", x, y);
197 #endif
198
199 /* Bail out if the Windows window handle is bad */
200 if (!hWnd) {
201 #if CYGWINDOWING_DEBUG
202 ErrorF("\timmediately return since hWnd is NULL\n");
203 #endif
204 return fResult;
205 }
206
207 /* Get the Windows window style and extended style */
208 dwExStyle = GetWindowLongPtr(hWnd, GWL_EXSTYLE);
209 dwStyle = GetWindowLongPtr(hWnd, GWL_STYLE);
210
211 /* Get the X and Y location of the X window */
212 iX = pWin->drawable.x + GetSystemMetrics(SM_XVIRTUALSCREEN);
213 iY = pWin->drawable.y + GetSystemMetrics(SM_YVIRTUALSCREEN);
214
215 /* Get the height and width of the X window */
216 iWidth = pWin->drawable.width;
217 iHeight = pWin->drawable.height;
218
219 /* Store the origin, height, and width in a rectangle structure */
220 SetRect(&rcNew, iX, iY, iX + iWidth, iY + iHeight);
221
222 #if CYGMULTIWINDOW_DEBUG
223 lpRc = &rcNew;
224 ErrorF("winPositionWindowMultiWindow - drawable (%d, %d)-(%d, %d)\n",
225 (int)lpRc->left, (int)lpRc->top, (int)lpRc->right, (int)lpRc->bottom);
226 #endif
227
228 /*
229 * Calculate the required size of the Windows window rectangle,
230 * given the size of the Windows window client area.
231 */
232 AdjustWindowRectEx(&rcNew, dwStyle, FALSE, dwExStyle);
233
234 /* Get a rectangle describing the old Windows window */
235 GetWindowRect(hWnd, &rcOld);
236
237 #if CYGMULTIWINDOW_DEBUG
238 /* Get a rectangle describing the Windows window client area */
239 GetClientRect(hWnd, &rcClient);
240
241 lpRc = &rcNew;
242 ErrorF("winPositionWindowMultiWindow - rcNew (%d, %d)-(%d, %d)\n",
243 (int)lpRc->left, (int)lpRc->top, (int)lpRc->right, (int)lpRc->bottom);
244
245 lpRc = &rcOld;
246 ErrorF("winPositionWindowMultiWindow - rcOld (%d, %d)-(%d, %d)\n",
247 (int)lpRc->left, (int)lpRc->top, (int)lpRc->right, (int)lpRc->bottom);
248
249 lpRc = &rcClient;
250 ErrorF("rcClient (%d, %d)-(%d, %d)\n",
251 (int)lpRc->left, (int)lpRc->top, (int)lpRc->right, (int)lpRc->bottom);
252 #endif
253
254 /* Check if the old rectangle and new rectangle are the same */
255 if (!EqualRect(&rcNew, &rcOld)) {
256 #if CYGMULTIWINDOW_DEBUG
257 ErrorF("winPositionWindowMultiWindow - Need to move\n");
258 #endif
259
260 #if CYGWINDOWING_DEBUG
261 ErrorF("\tMoveWindow to (%d, %d) - %dx%d\n", (int)rcNew.left, (int)rcNew.top,
262 (int)(rcNew.right - rcNew.left), (int)(rcNew.bottom - rcNew.top));
263 #endif
264 /* Change the position and dimensions of the Windows window */
265 MoveWindow(hWnd,
266 rcNew.left, rcNew.top,
267 rcNew.right - rcNew.left, rcNew.bottom - rcNew.top, TRUE);
268 }
269 else {
270 #if CYGMULTIWINDOW_DEBUG
271 ErrorF("winPositionWindowMultiWindow - Not need to move\n");
272 #endif
273 }
274
275 return fResult;
276 }
277
278 /*
279 * ChangeWindowAttributes - See Porting Layer Definition - p. 37
280 */
281
282 Bool
winChangeWindowAttributesMultiWindow(WindowPtr pWin,unsigned long mask)283 winChangeWindowAttributesMultiWindow(WindowPtr pWin, unsigned long mask)
284 {
285 Bool fResult = TRUE;
286 ScreenPtr pScreen = pWin->drawable.pScreen;
287
288 winScreenPriv(pScreen);
289
290 #if CYGMULTIWINDOW_DEBUG
291 ErrorF("winChangeWindowAttributesMultiWindow - pWin: %p\n", pWin);
292 #endif
293
294 WIN_UNWRAP(ChangeWindowAttributes);
295 fResult = (*pScreen->ChangeWindowAttributes) (pWin, mask);
296 WIN_WRAP(ChangeWindowAttributes, winChangeWindowAttributesMultiWindow);
297
298 /*
299 * NOTE: We do not currently need to do anything here.
300 */
301
302 return fResult;
303 }
304
305 /*
306 * UnmapWindow - See Porting Layer Definition - p. 37
307 * Also referred to as UnrealizeWindow
308 */
309
310 Bool
winUnmapWindowMultiWindow(WindowPtr pWin)311 winUnmapWindowMultiWindow(WindowPtr pWin)
312 {
313 Bool fResult = TRUE;
314 ScreenPtr pScreen = pWin->drawable.pScreen;
315
316 winWindowPriv(pWin);
317 winScreenPriv(pScreen);
318
319 #if CYGMULTIWINDOW_DEBUG
320 ErrorF("winUnmapWindowMultiWindow - pWin: %p\n", pWin);
321 #endif
322
323 WIN_UNWRAP(UnrealizeWindow);
324 fResult = (*pScreen->UnrealizeWindow) (pWin);
325 WIN_WRAP(UnrealizeWindow, winUnmapWindowMultiWindow);
326
327 /* Flag that the window has been killed */
328 pWinPriv->fXKilled = TRUE;
329
330 /* Destroy the Windows window associated with this X window */
331 winDestroyWindowsWindow(pWin);
332
333 return fResult;
334 }
335
336 /*
337 * MapWindow - See Porting Layer Definition - p. 37
338 * Also referred to as RealizeWindow
339 */
340
341 Bool
winMapWindowMultiWindow(WindowPtr pWin)342 winMapWindowMultiWindow(WindowPtr pWin)
343 {
344 Bool fResult = TRUE;
345 ScreenPtr pScreen = pWin->drawable.pScreen;
346
347 winWindowPriv(pWin);
348 winScreenPriv(pScreen);
349
350 #if CYGMULTIWINDOW_DEBUG
351 ErrorF("winMapWindowMultiWindow - pWin: %p\n", pWin);
352 #endif
353
354 WIN_UNWRAP(RealizeWindow);
355 fResult = (*pScreen->RealizeWindow) (pWin);
356 WIN_WRAP(RealizeWindow, winMapWindowMultiWindow);
357
358 /* Flag that this window has not been destroyed */
359 pWinPriv->fXKilled = FALSE;
360
361 /* Refresh/redisplay the Windows window associated with this X window */
362 winUpdateWindowsWindow(pWin);
363
364 /* Update the Windows window's shape */
365 winReshapeMultiWindow(pWin);
366 winUpdateRgnMultiWindow(pWin);
367
368 return fResult;
369 }
370
371 /*
372 * ReparentWindow - See Porting Layer Definition - p. 42
373 */
374
375 void
winReparentWindowMultiWindow(WindowPtr pWin,WindowPtr pPriorParent)376 winReparentWindowMultiWindow(WindowPtr pWin, WindowPtr pPriorParent)
377 {
378 ScreenPtr pScreen = pWin->drawable.pScreen;
379
380 winScreenPriv(pScreen);
381
382 winDebug
383 ("winReparentMultiWindow - pWin:%p XID:0x%x, reparent from pWin:%p XID:0x%x to pWin:%p XID:0x%x\n",
384 pWin, (unsigned int)pWin->drawable.id,
385 pPriorParent, (unsigned int)pPriorParent->drawable.id,
386 pWin->parent, (unsigned int)pWin->parent->drawable.id);
387
388 WIN_UNWRAP(ReparentWindow);
389 if (pScreen->ReparentWindow)
390 (*pScreen->ReparentWindow) (pWin, pPriorParent);
391 WIN_WRAP(ReparentWindow, winReparentWindowMultiWindow);
392
393 /* Update the Windows window associated with this X window */
394 winUpdateWindowsWindow(pWin);
395 }
396
397 /*
398 * RestackWindow - Shuffle the z-order of a window
399 */
400
401 void
winRestackWindowMultiWindow(WindowPtr pWin,WindowPtr pOldNextSib)402 winRestackWindowMultiWindow(WindowPtr pWin, WindowPtr pOldNextSib)
403 {
404 #if 0
405 WindowPtr pPrevWin;
406 UINT uFlags;
407 HWND hInsertAfter;
408 HWND hWnd = NULL;
409 #endif
410 ScreenPtr pScreen = pWin->drawable.pScreen;
411
412 winScreenPriv(pScreen);
413
414 #if CYGMULTIWINDOW_DEBUG || CYGWINDOWING_DEBUG
415 winTrace("winRestackMultiWindow - %p\n", pWin);
416 #endif
417
418 WIN_UNWRAP(RestackWindow);
419 if (pScreen->RestackWindow)
420 (*pScreen->RestackWindow) (pWin, pOldNextSib);
421 WIN_WRAP(RestackWindow, winRestackWindowMultiWindow);
422
423 #if 1
424 /*
425 * Calling winReorderWindowsMultiWindow here means our window manager
426 * (i.e. Windows Explorer) has initiative to determine Z order.
427 */
428 if (pWin->nextSib != pOldNextSib)
429 winReorderWindowsMultiWindow();
430 #else
431 /* Bail out if no window privates or window handle is invalid */
432 if (!pWinPriv || !pWinPriv->hWnd)
433 return;
434
435 /* Get a pointer to our previous sibling window */
436 pPrevWin = pWin->prevSib;
437
438 /*
439 * Look for a sibling window with
440 * valid privates and window handle
441 */
442 while (pPrevWin && !winGetWindowPriv(pPrevWin)
443 && !winGetWindowPriv(pPrevWin)->hWnd)
444 pPrevWin = pPrevWin->prevSib;
445
446 /* Check if we found a valid sibling */
447 if (pPrevWin) {
448 /* Valid sibling - get handle to insert window after */
449 hInsertAfter = winGetWindowPriv(pPrevWin)->hWnd;
450 uFlags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE;
451
452 hWnd = GetNextWindow(pWinPriv->hWnd, GW_HWNDPREV);
453
454 do {
455 if (GetProp(hWnd, WIN_WINDOW_PROP)) {
456 if (hWnd == winGetWindowPriv(pPrevWin)->hWnd) {
457 uFlags |= SWP_NOZORDER;
458 }
459 break;
460 }
461 hWnd = GetNextWindow(hWnd, GW_HWNDPREV);
462 }
463 while (hWnd);
464 }
465 else {
466 /* No valid sibling - make this window the top window */
467 hInsertAfter = HWND_TOP;
468 uFlags = SWP_NOMOVE | SWP_NOSIZE;
469 }
470
471 /* Perform the restacking operation in Windows */
472 SetWindowPos(pWinPriv->hWnd, hInsertAfter, 0, 0, 0, 0, uFlags);
473 #endif
474 }
475
476 /*
477 * winCreateWindowsWindow - Create a Windows window associated with an X window
478 */
479
480 void
winCreateWindowsWindow(WindowPtr pWin)481 winCreateWindowsWindow(WindowPtr pWin)
482 {
483 int iX, iY;
484 int iWidth;
485 int iHeight;
486 HWND hWnd;
487 HWND hFore = NULL;
488
489 winWindowPriv(pWin);
490 WinXSizeHints hints;
491 Window daddyId;
492 DWORD dwStyle, dwExStyle;
493 RECT rc;
494
495 winInitMultiWindowClass();
496
497 winDebug("winCreateWindowsTopLevelWindow - pWin:%p XID:0x%x \n", pWin,
498 (unsigned int)pWin->drawable.id);
499
500 iX = pWin->drawable.x + GetSystemMetrics(SM_XVIRTUALSCREEN);
501 iY = pWin->drawable.y + GetSystemMetrics(SM_YVIRTUALSCREEN);
502
503 iWidth = pWin->drawable.width;
504 iHeight = pWin->drawable.height;
505
506 /* If it's an InputOutput window, and so is going to end up being made visible,
507 make sure the window actually ends up somewhere where it will be visible
508
509 To handle arrangements of monitors which form a non-rectangular virtual
510 desktop, check if the window will end up with its top-left corner on any
511 monitor
512 */
513 if (pWin->drawable.class != InputOnly) {
514 POINT pt = { iX, iY };
515 if (MonitorFromPoint(pt, MONITOR_DEFAULTTONULL) == NULL)
516 {
517 iX = CW_USEDEFAULT;
518 iY = CW_USEDEFAULT;
519 }
520 }
521
522 winDebug("winCreateWindowsWindow - %dx%d @ %dx%d\n", iWidth, iHeight, iX,
523 iY);
524
525 if (winMultiWindowGetTransientFor(pWin, &daddyId)) {
526 if (daddyId) {
527 WindowPtr pParent;
528 int res = dixLookupWindow(&pParent, daddyId, serverClient, DixReadAccess);
529 if (res == Success)
530 {
531 winPrivWinPtr pParentPriv = winGetWindowPriv(pParent);
532 hFore = pParentPriv->hWnd;
533 }
534 }
535 }
536 else {
537 /* Default positions if none specified */
538 if (!winMultiWindowGetWMNormalHints(pWin, &hints))
539 hints.flags = 0;
540 if (!(hints.flags & (USPosition | PPosition)) &&
541 !pWin->overrideRedirect) {
542 iX = CW_USEDEFAULT;
543 iY = CW_USEDEFAULT;
544 }
545 }
546
547 /* Make it WS_OVERLAPPED in create call since WS_POPUP doesn't support */
548 /* CW_USEDEFAULT, change back to popup after creation */
549 dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
550 dwExStyle = WS_EX_TOOLWINDOW;
551
552 /*
553 Calculate the window coordinates containing the requested client area,
554 being careful to preserve CW_USEDEFAULT
555 */
556 rc.top = (iY != CW_USEDEFAULT) ? iY : 0;
557 rc.left = (iX != CW_USEDEFAULT) ? iX : 0;
558 rc.bottom = rc.top + iHeight;
559 rc.right = rc.left + iWidth;
560 AdjustWindowRectEx(&rc, dwStyle, FALSE, dwExStyle);
561 if (iY != CW_USEDEFAULT)
562 iY = rc.top;
563 if (iX != CW_USEDEFAULT)
564 iX = rc.left;
565 iHeight = rc.bottom - rc.top;
566 iWidth = rc.right - rc.left;
567
568 winDebug("winCreateWindowsWindow - %dx%d @ %dx%d\n", iWidth, iHeight, iX,
569 iY);
570
571 /* Create the window */
572 hWnd = CreateWindowExA(dwExStyle, /* Extended styles */
573 WINDOW_CLASS_X, /* Class name */
574 WINDOW_TITLE_X, /* Window name */
575 dwStyle, /* Styles */
576 iX, /* Horizontal position */
577 iY, /* Vertical position */
578 iWidth, /* Right edge */
579 iHeight, /* Bottom edge */
580 hFore, /* Null or Parent window if transient */
581 (HMENU) NULL, /* No menu */
582 GetModuleHandle(NULL), /* Instance handle */
583 pWin); /* ScreenPrivates */
584 if (hWnd == NULL) {
585 ErrorF("winCreateWindowsWindow - CreateWindowExA () failed: %d\n",
586 (int) GetLastError());
587 }
588 pWinPriv->hWnd = hWnd;
589
590 /* Change style back to popup, already placed... */
591 SetWindowLongPtr(hWnd, GWL_STYLE,
592 WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
593 SetWindowPos(hWnd, 0, 0, 0, 0, 0,
594 SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE |
595 SWP_NOACTIVATE);
596
597 /* Adjust the X window to match the window placement we actually got... */
598 winAdjustXWindow(pWin, hWnd);
599
600 /* Make sure it gets the proper system menu for a WS_POPUP, too */
601 GetSystemMenu(hWnd, TRUE);
602
603 /* Cause any .XWinrc menus to be added in main WNDPROC */
604 PostMessage(hWnd, WM_INIT_SYS_MENU, 0, 0);
605
606 SetProp(hWnd, WIN_WID_PROP, (HANDLE) (INT_PTR) winGetWindowID(pWin));
607
608 /* Flag that this Windows window handles its own activation */
609 SetProp(hWnd, WIN_NEEDMANAGE_PROP, (HANDLE) 0);
610 }
611
612 Bool winInDestroyWindowsWindow = FALSE;
613
614 /*
615 * winDestroyWindowsWindow - Destroy a Windows window associated
616 * with an X window
617 */
618 static void
winDestroyWindowsWindow(WindowPtr pWin)619 winDestroyWindowsWindow(WindowPtr pWin)
620 {
621 MSG msg;
622
623 winWindowPriv(pWin);
624 BOOL oldstate = winInDestroyWindowsWindow;
625 HICON hIcon;
626 HICON hIconSm;
627
628 winDebug("winDestroyWindowsWindow - pWin:%p XID:0x%x \n", pWin,
629 (unsigned int)pWin->drawable.id);
630
631 /* Bail out if the Windows window handle is invalid */
632 if (pWinPriv->hWnd == NULL)
633 return;
634
635 winInDestroyWindowsWindow = TRUE;
636
637 /* Store the info we need to destroy after this window is gone */
638 hIcon = (HICON) SendMessage(pWinPriv->hWnd, WM_GETICON, ICON_BIG, 0);
639 hIconSm = (HICON) SendMessage(pWinPriv->hWnd, WM_GETICON, ICON_SMALL, 0);
640
641 /* Destroy the Windows window */
642 DestroyWindow(pWinPriv->hWnd);
643
644 /* Null our handle to the Window so referencing it will cause an error */
645 pWinPriv->hWnd = NULL;
646
647 /* Destroy any icons we created for this window */
648 winDestroyIcon(hIcon);
649 winDestroyIcon(hIconSm);
650
651 #ifdef XWIN_GLX_WINDOWS
652 /* No longer note WGL used on this window */
653 pWinPriv->fWglUsed = FALSE;
654 #endif
655
656 /* Process all messages on our queue */
657 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
658 if (g_hDlgDepthChange == 0 || !IsDialogMessage(g_hDlgDepthChange, &msg)) {
659 DispatchMessage(&msg);
660 }
661 }
662
663 winInDestroyWindowsWindow = oldstate;
664
665 winDebug("winDestroyWindowsWindow - done\n");
666 }
667
668 /*
669 * winUpdateWindowsWindow - Redisplay/redraw a Windows window
670 * associated with an X window
671 */
672
673 static void
winUpdateWindowsWindow(WindowPtr pWin)674 winUpdateWindowsWindow(WindowPtr pWin)
675 {
676 winWindowPriv(pWin);
677 HWND hWnd = pWinPriv->hWnd;
678
679 #if CYGMULTIWINDOW_DEBUG
680 ErrorF("winUpdateWindowsWindow\n");
681 #endif
682
683 /* Check if the Windows window's parents have been destroyed */
684 if (pWin->parent != NULL && pWin->parent->parent == NULL && pWin->mapped) {
685 /* Create the Windows window if it has been destroyed */
686 if (hWnd == NULL) {
687 winCreateWindowsWindow(pWin);
688 assert(pWinPriv->hWnd != NULL);
689 }
690
691 /* Display the window without activating it */
692 if (pWin->drawable.class != InputOnly)
693 ShowWindow(pWinPriv->hWnd, SW_SHOWNOACTIVATE);
694
695 /* Send first paint message */
696 UpdateWindow(pWinPriv->hWnd);
697 }
698 else if (hWnd != NULL) {
699 /* Destroy the Windows window if its parents are destroyed */
700 winDestroyWindowsWindow(pWin);
701 assert(pWinPriv->hWnd == NULL);
702 }
703
704 #if CYGMULTIWINDOW_DEBUG
705 ErrorF("-winUpdateWindowsWindow\n");
706 #endif
707 }
708
709 /*
710 * winGetWindowID -
711 */
712
713 XID
winGetWindowID(WindowPtr pWin)714 winGetWindowID(WindowPtr pWin)
715 {
716 WindowIDPairRec wi = { pWin, 0 };
717 ClientPtr c = wClient(pWin);
718
719 /* */
720 FindClientResourcesByType(c, RT_WINDOW, winFindWindow, &wi);
721
722 #if CYGMULTIWINDOW_DEBUG
723 ErrorF("winGetWindowID - Window ID: %u\n", (unsigned int)wi.id);
724 #endif
725
726 return wi.id;
727 }
728
729 /*
730 * winFindWindow -
731 */
732
733 static void
winFindWindow(void * value,XID id,void * cdata)734 winFindWindow(void *value, XID id, void *cdata)
735 {
736 WindowIDPairPtr wi = (WindowIDPairPtr) cdata;
737
738 if (value == wi->value) {
739 wi->id = id;
740 }
741 }
742
743 /*
744 * winReorderWindowsMultiWindow -
745 */
746
747 void
winReorderWindowsMultiWindow(void)748 winReorderWindowsMultiWindow(void)
749 {
750 HWND hwnd = NULL;
751 WindowPtr pWin = NULL;
752 WindowPtr pWinSib = NULL;
753 XID vlist[2];
754 static Bool fRestacking = FALSE; /* Avoid recursive calls to this function */
755 DWORD dwCurrentProcessID = GetCurrentProcessId();
756 DWORD dwWindowProcessID = 0;
757
758 #if CYGMULTIWINDOW_DEBUG || CYGWINDOWING_DEBUG
759 winTrace("winReorderWindowsMultiWindow\n");
760 #endif
761
762 if (fRestacking) {
763 /* It is a recursive call so immediately exit */
764 #if CYGWINDOWING_DEBUG
765 ErrorF("winReorderWindowsMultiWindow - "
766 "exit because fRestacking == TRUE\n");
767 #endif
768 return;
769 }
770 fRestacking = TRUE;
771
772 /* Loop through top level Window windows, descending in Z order */
773 for (hwnd = GetTopWindow(NULL);
774 hwnd; hwnd = GetNextWindow(hwnd, GW_HWNDNEXT)) {
775 /* Don't take care of other Cygwin/X process's windows */
776 GetWindowThreadProcessId(hwnd, &dwWindowProcessID);
777
778 if (GetProp(hwnd, WIN_WINDOW_PROP)
779 && (dwWindowProcessID == dwCurrentProcessID)
780 && !IsIconic(hwnd)) { /* ignore minimized windows */
781 pWinSib = pWin;
782 pWin = GetProp(hwnd, WIN_WINDOW_PROP);
783
784 if (!pWinSib) { /* 1st window - raise to the top */
785 vlist[0] = Above;
786
787 ConfigureWindow(pWin, CWStackMode, vlist, wClient(pWin));
788 }
789 else { /* 2nd or deeper windows - just below the previous one */
790 vlist[0] = winGetWindowID(pWinSib);
791 vlist[1] = Below;
792
793 ConfigureWindow(pWin, CWSibling | CWStackMode,
794 vlist, wClient(pWin));
795 }
796 }
797 }
798
799 fRestacking = FALSE;
800 }
801
802 /*
803 * CopyWindow - See Porting Layer Definition - p. 39
804 */
805 void
winCopyWindowMultiWindow(WindowPtr pWin,DDXPointRec oldpt,RegionPtr oldRegion)806 winCopyWindowMultiWindow(WindowPtr pWin, DDXPointRec oldpt, RegionPtr oldRegion)
807 {
808 ScreenPtr pScreen = pWin->drawable.pScreen;
809
810 winScreenPriv(pScreen);
811
812 #if CYGWINDOWING_DEBUG
813 ErrorF("CopyWindowMultiWindow\n");
814 #endif
815 WIN_UNWRAP(CopyWindow);
816 (*pScreen->CopyWindow) (pWin, oldpt, oldRegion);
817 WIN_WRAP(CopyWindow, winCopyWindowMultiWindow);
818 }
819
820 /*
821 * MoveWindow - See Porting Layer Definition - p. 42
822 */
823 void
winMoveWindowMultiWindow(WindowPtr pWin,int x,int y,WindowPtr pSib,VTKind kind)824 winMoveWindowMultiWindow(WindowPtr pWin, int x, int y,
825 WindowPtr pSib, VTKind kind)
826 {
827 ScreenPtr pScreen = pWin->drawable.pScreen;
828
829 winScreenPriv(pScreen);
830
831 #if CYGWINDOWING_DEBUG
832 ErrorF("MoveWindowMultiWindow to (%d, %d)\n", x, y);
833 #endif
834
835 WIN_UNWRAP(MoveWindow);
836 (*pScreen->MoveWindow) (pWin, x, y, pSib, kind);
837 WIN_WRAP(MoveWindow, winMoveWindowMultiWindow);
838 }
839
840 /*
841 * ResizeWindow - See Porting Layer Definition - p. 42
842 */
843 void
winResizeWindowMultiWindow(WindowPtr pWin,int x,int y,unsigned int w,unsigned int h,WindowPtr pSib)844 winResizeWindowMultiWindow(WindowPtr pWin, int x, int y, unsigned int w,
845 unsigned int h, WindowPtr pSib)
846 {
847 ScreenPtr pScreen = pWin->drawable.pScreen;
848
849 winScreenPriv(pScreen);
850
851 #if CYGWINDOWING_DEBUG
852 ErrorF("ResizeWindowMultiWindow to (%d, %d) - %dx%d\n", x, y, w, h);
853 #endif
854 WIN_UNWRAP(ResizeWindow);
855 (*pScreen->ResizeWindow) (pWin, x, y, w, h, pSib);
856 WIN_WRAP(ResizeWindow, winResizeWindowMultiWindow);
857 }
858
859 /*
860 * winAdjustXWindow
861 *
862 * Move and resize X window with respect to corresponding Windows window.
863 * This is called from WM_MOVE/WM_SIZE handlers when the user performs
864 * any windowing operation (move, resize, minimize, maximize, restore).
865 *
866 * The functionality is the inverse of winPositionWindowMultiWindow, which
867 * adjusts Windows window with respect to X window.
868 */
869 int
winAdjustXWindow(WindowPtr pWin,HWND hwnd)870 winAdjustXWindow(WindowPtr pWin, HWND hwnd)
871 {
872 RECT rcDraw; /* Rect made from pWin->drawable to be adjusted */
873 RECT rcWin; /* The source: WindowRect from hwnd */
874 DrawablePtr pDraw;
875 XID vlist[4];
876 LONG dX, dY, dW, dH, x, y;
877 DWORD dwStyle, dwExStyle;
878
879 #define WIDTH(rc) (rc.right - rc.left)
880 #define HEIGHT(rc) (rc.bottom - rc.top)
881
882 #if CYGWINDOWING_DEBUG
883 ErrorF("winAdjustXWindow\n");
884 #endif
885
886 if (IsIconic(hwnd)) {
887 #if CYGWINDOWING_DEBUG
888 ErrorF("\timmediately return because the window is iconized\n");
889 #endif
890 /*
891 * If the Windows window is minimized, its WindowRect has
892 * meaningless values so we don't adjust X window to it.
893 */
894 vlist[0] = 0;
895 vlist[1] = 0;
896 return ConfigureWindow(pWin, CWX | CWY, vlist, wClient(pWin));
897 }
898
899 pDraw = &pWin->drawable;
900
901 /* Calculate the window rect from the drawable */
902 x = pDraw->x + GetSystemMetrics(SM_XVIRTUALSCREEN);
903 y = pDraw->y + GetSystemMetrics(SM_YVIRTUALSCREEN);
904 SetRect(&rcDraw, x, y, x + pDraw->width, y + pDraw->height);
905 #ifdef CYGMULTIWINDOW_DEBUG
906 winDebug("\tDrawable extend {%d, %d, %d, %d}, {%d, %d}\n",
907 (int)rcDraw.left, (int)rcDraw.top, (int)rcDraw.right, (int)rcDraw.bottom,
908 (int)(rcDraw.right - rcDraw.left), (int)(rcDraw.bottom - rcDraw.top));
909 #endif
910 dwExStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
911 dwStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
912 #ifdef CYGMULTIWINDOW_DEBUG
913 winDebug("\tWindowStyle: %08x %08x\n", (unsigned int)dwStyle, (unsigned int)dwExStyle);
914 #endif
915 AdjustWindowRectEx(&rcDraw, dwStyle, FALSE, dwExStyle);
916
917 /* The source of adjust */
918 GetWindowRect(hwnd, &rcWin);
919 #ifdef CYGMULTIWINDOW_DEBUG
920 winDebug("\tWindow extend {%d, %d, %d, %d}, {%d, %d}\n",
921 (int)rcWin.left, (int)rcWin.top, (int)rcWin.right, (int)rcWin.bottom,
922 (int)(rcWin.right - rcWin.left), (int)(rcWin.bottom - rcWin.top));
923 winDebug("\tDraw extend {%d, %d, %d, %d}, {%d, %d}\n",
924 (int)rcDraw.left, (int)rcDraw.top, (int)rcDraw.right, (int)rcDraw.bottom,
925 (int)(rcDraw.right - rcDraw.left), (int)(rcDraw.bottom - rcDraw.top));
926 #endif
927
928 if (EqualRect(&rcDraw, &rcWin)) {
929 /* Bail if no adjust is needed */
930 #if CYGWINDOWING_DEBUG
931 ErrorF("\treturn because already adjusted\n");
932 #endif
933 return 0;
934 }
935
936 /* Calculate delta values */
937 dX = rcWin.left - rcDraw.left;
938 dY = rcWin.top - rcDraw.top;
939 dW = WIDTH(rcWin) - WIDTH(rcDraw);
940 dH = HEIGHT(rcWin) - HEIGHT(rcDraw);
941
942 /*
943 * Adjust.
944 * We may only need to move (vlist[0] and [1]), or only resize
945 * ([2] and [3]) but currently we set all the parameters and leave
946 * the decision to ConfigureWindow. The reason is code simplicity.
947 */
948 vlist[0] = pDraw->x + dX - wBorderWidth(pWin);
949 vlist[1] = pDraw->y + dY - wBorderWidth(pWin);
950 vlist[2] = pDraw->width + dW;
951 vlist[3] = pDraw->height + dH;
952 #if CYGWINDOWING_DEBUG
953 ErrorF("\tConfigureWindow to (%u, %u) - %ux%u\n",
954 (unsigned int)vlist[0], (unsigned int)vlist[1],
955 (unsigned int)vlist[2], (unsigned int)vlist[3]);
956 #endif
957 return ConfigureWindow(pWin, CWX | CWY | CWWidth | CWHeight,
958 vlist, wClient(pWin));
959
960 #undef WIDTH
961 #undef HEIGHT
962 }
963
964 /*
965 Helper function for creating a DIB to back a pixmap
966 */
winCreateDIB(ScreenPtr pScreen,int width,int height,int bpp,void ** ppvBits,BITMAPINFOHEADER ** ppbmih)967 static HBITMAP winCreateDIB(ScreenPtr pScreen, int width, int height, int bpp, void **ppvBits, BITMAPINFOHEADER **ppbmih)
968 {
969 winScreenPriv(pScreen);
970 BITMAPV4HEADER *pbmih = NULL;
971 HBITMAP hBitmap = NULL;
972
973 /* Allocate bitmap info header */
974 pbmih = malloc(sizeof(BITMAPV4HEADER) + 256 * sizeof(RGBQUAD));
975 if (pbmih == NULL) {
976 ErrorF("winCreateDIB: malloc() failed\n");
977 return NULL;
978 }
979 memset(pbmih, 0, sizeof(BITMAPV4HEADER) + 256 * sizeof(RGBQUAD));
980
981 /* Describe bitmap to be created */
982 pbmih->bV4Size = sizeof(BITMAPV4HEADER);
983 pbmih->bV4Width = width;
984 pbmih->bV4Height = -height; /* top-down bitmap */
985 pbmih->bV4Planes = 1;
986 pbmih->bV4BitCount = bpp;
987 if (bpp == 1) {
988 RGBQUAD *bmiColors = (RGBQUAD *)((char *)pbmih + sizeof(BITMAPV4HEADER));
989 pbmih->bV4V4Compression = BI_RGB;
990 bmiColors[1].rgbBlue = 255;
991 bmiColors[1].rgbGreen = 255;
992 bmiColors[1].rgbRed = 255;
993 }
994 else if (bpp == 8) {
995 pbmih->bV4V4Compression = BI_RGB;
996 pbmih->bV4ClrUsed = 0;
997 }
998 else if (bpp == 16) {
999 pbmih->bV4V4Compression = BI_RGB;
1000 pbmih->bV4ClrUsed = 0;
1001 }
1002 else if (bpp == 32) {
1003 pbmih->bV4V4Compression = BI_BITFIELDS;
1004 pbmih->bV4RedMask = pScreenPriv->dwRedMask;
1005 pbmih->bV4GreenMask = pScreenPriv->dwGreenMask;
1006 pbmih->bV4BlueMask = pScreenPriv->dwBlueMask;
1007 pbmih->bV4AlphaMask = 0;
1008 }
1009 else {
1010 ErrorF("winCreateDIB: %d bpp unhandled\n", bpp);
1011 }
1012
1013 /* Create a DIB with a bit pointer */
1014 hBitmap = CreateDIBSection(NULL,
1015 (BITMAPINFO *) pbmih,
1016 DIB_RGB_COLORS, ppvBits, NULL, 0);
1017 if (hBitmap == NULL) {
1018 ErrorF("winCreateDIB: CreateDIBSection() failed\n");
1019 return NULL;
1020 }
1021
1022 /* Store the address of the BMIH in the ppbmih parameter */
1023 *ppbmih = (BITMAPINFOHEADER *)pbmih;
1024
1025 winDebug("winCreateDIB: HBITMAP %p pBMIH %p pBits %p\n", hBitmap, pbmih, *ppvBits);
1026
1027 return hBitmap;
1028 }
1029
1030
1031 /*
1032 * CreatePixmap - See Porting Layer Definition
1033 */
1034 PixmapPtr
winCreatePixmapMultiwindow(ScreenPtr pScreen,int width,int height,int depth,unsigned usage_hint)1035 winCreatePixmapMultiwindow(ScreenPtr pScreen, int width, int height, int depth,
1036 unsigned usage_hint)
1037 {
1038 winPrivPixmapPtr pPixmapPriv = NULL;
1039 PixmapPtr pPixmap = NULL;
1040 int bpp, paddedwidth;
1041
1042 /* allocate Pixmap header and privates */
1043 pPixmap = AllocatePixmap(pScreen, 0);
1044 if (!pPixmap)
1045 return NullPixmap;
1046
1047 bpp = BitsPerPixel(depth);
1048 /*
1049 DIBs have 4-byte aligned rows
1050
1051 paddedwidth is the width in bytes, padded to align
1052
1053 i.e. round up the number of bits used by a row so it is a multiple of 32,
1054 then convert to bytes
1055 */
1056 paddedwidth = (((bpp * width) + 31) & ~31)/8;
1057
1058 /* setup Pixmap header */
1059 pPixmap->drawable.type = DRAWABLE_PIXMAP;
1060 pPixmap->drawable.class = 0;
1061 pPixmap->drawable.pScreen = pScreen;
1062 pPixmap->drawable.depth = depth;
1063 pPixmap->drawable.bitsPerPixel = bpp;
1064 pPixmap->drawable.id = 0;
1065 pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
1066 pPixmap->drawable.x = 0;
1067 pPixmap->drawable.y = 0;
1068 pPixmap->drawable.width = width;
1069 pPixmap->drawable.height = height;
1070 pPixmap->devKind = paddedwidth;
1071 pPixmap->refcnt = 1;
1072 pPixmap->devPrivate.ptr = NULL; // later set to pbBits
1073 pPixmap->primary_pixmap = NULL;
1074 #ifdef COMPOSITE
1075 pPixmap->screen_x = 0;
1076 pPixmap->screen_y = 0;
1077 #endif
1078 pPixmap->usage_hint = usage_hint;
1079
1080 /* Check for zero width or height pixmaps */
1081 if (width == 0 || height == 0) {
1082 /* DIBs with a dimension of 0 aren't permitted, so don't try to allocate
1083 a DIB, just set fields and return */
1084 return pPixmap;
1085 }
1086
1087 /* Initialize pixmap privates */
1088 pPixmapPriv = winGetPixmapPriv(pPixmap);
1089 pPixmapPriv->hBitmap = NULL;
1090 pPixmapPriv->pbBits = NULL;
1091 pPixmapPriv->pbmih = NULL;
1092
1093 /* Create a DIB for the pixmap */
1094 pPixmapPriv->hBitmap = winCreateDIB(pScreen, width, height, bpp, &pPixmapPriv->pbBits, &pPixmapPriv->pbmih);
1095 pPixmapPriv->owned = TRUE;
1096
1097 winDebug("winCreatePixmap: pPixmap %p HBITMAP %p pBMIH %p pBits %p\n", pPixmap, pPixmapPriv->hBitmap, pPixmapPriv->pbmih, pPixmapPriv->pbBits);
1098 /* XXX: so why do we need this in privates ??? */
1099 pPixmap->devPrivate.ptr = pPixmapPriv->pbBits;
1100
1101 return pPixmap;
1102 }
1103
1104 /*
1105 * DestroyPixmap - See Porting Layer Definition
1106 */
1107 Bool
winDestroyPixmapMultiwindow(PixmapPtr pPixmap)1108 winDestroyPixmapMultiwindow(PixmapPtr pPixmap)
1109 {
1110 winPrivPixmapPtr pPixmapPriv = NULL;
1111
1112 /* Bail early if there is not a pixmap to destroy */
1113 if (pPixmap == NULL) {
1114 return TRUE;
1115 }
1116
1117 /* Decrement reference count, return if nonzero */
1118 --pPixmap->refcnt;
1119 if (pPixmap->refcnt != 0)
1120 return TRUE;
1121
1122 winDebug("winDestroyPixmap: pPixmap %p\n", pPixmap);
1123
1124 /* Get a handle to the pixmap privates */
1125 pPixmapPriv = winGetPixmapPriv(pPixmap);
1126
1127 /* Nothing to do if we don't own the DIB */
1128 if (!pPixmapPriv->owned)
1129 return TRUE;
1130
1131 /* Free GDI bitmap */
1132 if (pPixmapPriv->hBitmap)
1133 DeleteObject(pPixmapPriv->hBitmap);
1134
1135 /* Free the bitmap info header memory */
1136 free(pPixmapPriv->pbmih);
1137 pPixmapPriv->pbmih = NULL;
1138
1139 /* Free the pixmap memory */
1140 free(pPixmap);
1141 pPixmap = NULL;
1142
1143 return TRUE;
1144 }
1145
1146 /*
1147 * ModifyPixmapHeader - See Porting Layer Definition
1148 */
1149 Bool
winModifyPixmapHeaderMultiwindow(PixmapPtr pPixmap,int width,int height,int depth,int bitsPerPixel,int devKind,void * pPixData)1150 winModifyPixmapHeaderMultiwindow(PixmapPtr pPixmap,
1151 int width,
1152 int height,
1153 int depth,
1154 int bitsPerPixel, int devKind, void *pPixData)
1155 {
1156 int i;
1157 winPrivPixmapPtr pPixmapPriv = winGetPixmapPriv(pPixmap);
1158 Bool fResult;
1159
1160 /* reinitialize everything */
1161 pPixmap->drawable.depth = depth;
1162 pPixmap->drawable.bitsPerPixel = bitsPerPixel;
1163 pPixmap->drawable.id = 0;
1164 pPixmap->drawable.x = 0;
1165 pPixmap->drawable.y = 0;
1166 pPixmap->drawable.width = width;
1167 pPixmap->drawable.height = height;
1168 pPixmap->devKind = devKind;
1169 pPixmap->refcnt = 1;
1170 pPixmap->devPrivate.ptr = pPixData;
1171 pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
1172
1173 /*
1174 This can be used for some out-of-order initialization on the screen
1175 pixmap, which is the only case we can properly support.
1176 */
1177
1178 /* Look for which screen this pixmap corresponds to */
1179 for (i = 0; i < screenInfo.numScreens; i++) {
1180 ScreenPtr pScreen = screenInfo.screens[i];
1181 winScreenPriv(pScreen);
1182 winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
1183
1184 if (pScreenInfo->pfb == pPixData)
1185 {
1186 /* and initialize pixmap privates from screen privates */
1187 pPixmapPriv->hBitmap = pScreenPriv->hbmpShadow;
1188 pPixmapPriv->pbBits = pScreenInfo->pfb;
1189 pPixmapPriv->pbmih = pScreenPriv->pbmih;
1190
1191 /* mark these not to get released by DestroyPixmap */
1192 pPixmapPriv->owned = FALSE;
1193
1194 return TRUE;
1195 }
1196 }
1197
1198 /* Otherwise, since creating a DIBSection from arbitrary memory is not
1199 * possible, fallback to normal. If needed, we can create a DIBSection with
1200 * a copy of the bits later (see comment about a potential slow-path in
1201 * winBltExposedWindowRegionShadowGDI()). */
1202 pPixmapPriv->hBitmap = 0;
1203 pPixmapPriv->pbBits = 0;
1204 pPixmapPriv->pbmih = 0;
1205 pPixmapPriv->owned = FALSE;
1206
1207 winDebug("winModifyPixmapHeaderMultiwindow: falling back\n");
1208
1209 {
1210 ScreenPtr pScreen = pPixmap->drawable.pScreen;
1211 winScreenPriv(pScreen);
1212 WIN_UNWRAP(ModifyPixmapHeader);
1213 fResult = (*pScreen->ModifyPixmapHeader) (pPixmap, width, height, depth, bitsPerPixel, devKind, pPixData);
1214 WIN_WRAP(ModifyPixmapHeader, winModifyPixmapHeaderMultiwindow);
1215 }
1216
1217 return fResult;
1218 }
1219