?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Use local declarations of r_debug and link_map structs.
[wine.git] / dlls / winemac.drv / window.c
blob066eb553f7631f8b7b6ab01d7688b24f4f115f52
1 /*
2 * MACDRV windowing driver
3 *
4 * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard
5 * Copyright 1993 David Metcalfe
6 * Copyright 1995, 1996 Alex Korobka
7 * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25
26 #include <IOKit/pwr_mgt/IOPMLib.h>
27 #define GetCurrentThread Mac_GetCurrentThread
28 #define LoadResource Mac_LoadResource
29 #include <CoreServices/CoreServices.h>
30 #undef GetCurrentThread
31 #undef LoadResource
32
33 #include "macdrv.h"
34 #include "winuser.h"
35 #include "wine/unicode.h"
36 #include "wine/server.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(macdrv);
39
40
41 static CRITICAL_SECTION win_data_section;
42 static CRITICAL_SECTION_DEBUG critsect_debug =
43 {
44 0, 0, &win_data_section,
45 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
46 0, 0, { (DWORD_PTR)(__FILE__ ": win_data_section") }
47 };
48 static CRITICAL_SECTION win_data_section = { &critsect_debug, -1, 0, 0, 0, 0 };
49
50 static CFMutableDictionaryRef win_datas;
51
52 static DWORD activate_on_focus_time;
53
54
55 /***********************************************************************
56 * get_cocoa_window_features
57 */
58 static void get_cocoa_window_features(struct macdrv_win_data *data,
59 DWORD style, DWORD ex_style,
60 struct macdrv_window_features* wf,
61 const RECT *window_rect,
62 const RECT *client_rect)
63 {
64 memset(wf, 0, sizeof(*wf));
65
66 if (disable_window_decorations) return;
67 if (IsRectEmpty(window_rect)) return;
68 if (EqualRect(window_rect, client_rect)) return;
69
70 if ((style & WS_CAPTION) == WS_CAPTION && !(ex_style & WS_EX_LAYERED))
71 {
72 wf->shadow = TRUE;
73 if (!data->shaped)
74 {
75 wf->title_bar = TRUE;
76 if (style & WS_SYSMENU) wf->close_button = TRUE;
77 if (style & WS_MINIMIZEBOX) wf->minimize_button = TRUE;
78 if (style & WS_MAXIMIZEBOX) wf->maximize_button = TRUE;
79 if (ex_style & WS_EX_TOOLWINDOW) wf->utility = TRUE;
80 }
81 }
82 if (style & WS_THICKFRAME)
83 {
84 wf->shadow = TRUE;
85 if (!data->shaped) wf->resizable = TRUE;
86 }
87 else if (ex_style & WS_EX_DLGMODALFRAME) wf->shadow = TRUE;
88 else if ((style & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME) wf->shadow = TRUE;
89 }
90
91
92 /*******************************************************************
93 * can_activate_window
94 *
95 * Check if we can activate the specified window.
96 */
97 static inline BOOL can_activate_window(HWND hwnd)
98 {
99 LONG style = GetWindowLongW(hwnd, GWL_STYLE);
100
101 if (!(style & WS_VISIBLE)) return FALSE;
102 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
103 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_NOACTIVATE) return FALSE;
104 if (hwnd == GetDesktopWindow()) return FALSE;
105 return !(style & WS_DISABLED);
106 }
107
108
109 /***********************************************************************
110 * get_cocoa_window_state
111 */
112 static void get_cocoa_window_state(struct macdrv_win_data *data,
113 DWORD style, DWORD ex_style,
114 struct macdrv_window_state* state)
115 {
116 memset(state, 0, sizeof(*state));
117 state->disabled = (style & WS_DISABLED) != 0;
118 state->no_activate = !can_activate_window(data->hwnd);
119 state->floating = (ex_style & WS_EX_TOPMOST) != 0;
120 state->excluded_by_expose = state->excluded_by_cycle =
121 (!(ex_style & WS_EX_APPWINDOW) &&
122 (GetWindow(data->hwnd, GW_OWNER) || (ex_style & (WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE))));
123 if (IsRectEmpty(&data->window_rect))
124 state->excluded_by_expose = TRUE;
125 state->minimized = (style & WS_MINIMIZE) != 0;
126 state->minimized_valid = state->minimized != data->minimized;
127 state->maximized = (style & WS_MAXIMIZE) != 0;
128 }
129
130
131 /***********************************************************************
132 * get_mac_rect_offset
133 *
134 * Helper for macdrv_window_to_mac_rect and macdrv_mac_to_window_rect.
135 */
136 static void get_mac_rect_offset(struct macdrv_win_data *data, DWORD style, RECT *rect,
137 const RECT *window_rect, const RECT *client_rect)
138 {
139 DWORD ex_style, style_mask = 0, ex_style_mask = 0;
140
141 rect->top = rect->bottom = rect->left = rect->right = 0;
142
143 ex_style = GetWindowLongW(data->hwnd, GWL_EXSTYLE);
144
145 if (!data->shaped)
146 {
147 struct macdrv_window_features wf;
148 get_cocoa_window_features(data, style, ex_style, &wf, window_rect, client_rect);
149
150 if (wf.title_bar)
151 {
152 style_mask |= WS_CAPTION;
153 ex_style_mask |= WS_EX_TOOLWINDOW;
154 }
155 if (wf.shadow)
156 {
157 style_mask |= WS_DLGFRAME | WS_THICKFRAME;
158 ex_style_mask |= WS_EX_DLGMODALFRAME;
159 }
160 }
161
162 AdjustWindowRectEx(rect, style & style_mask, FALSE, ex_style & ex_style_mask);
163
164 TRACE("%p/%p style %08x ex_style %08x shaped %d -> %s\n", data->hwnd, data->cocoa_window,
165 style, ex_style, data->shaped, wine_dbgstr_rect(rect));
166 }
167
168
169 /***********************************************************************
170 * macdrv_window_to_mac_rect
171 *
172 * Convert a rect from client to Mac window coordinates
173 */
174 static void macdrv_window_to_mac_rect(struct macdrv_win_data *data, DWORD style, RECT *rect,
175 const RECT *window_rect, const RECT *client_rect)
176 {
177 RECT rc;
178
179 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return;
180 if (IsRectEmpty(rect)) return;
181
182 get_mac_rect_offset(data, style, &rc, window_rect, client_rect);
183
184 rect->left -= rc.left;
185 rect->right -= rc.right;
186 rect->top -= rc.top;
187 rect->bottom -= rc.bottom;
188 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
189 if (rect->left >= rect->right) rect->right = rect->left + 1;
190 }
191
192
193 /***********************************************************************
194 * macdrv_mac_to_window_rect
195 *
196 * Opposite of macdrv_window_to_mac_rect
197 */
198 static void macdrv_mac_to_window_rect(struct macdrv_win_data *data, RECT *rect)
199 {
200 RECT rc;
201 DWORD style = GetWindowLongW(data->hwnd, GWL_STYLE);
202
203 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return;
204 if (IsRectEmpty(rect)) return;
205
206 get_mac_rect_offset(data, style, &rc, &data->window_rect, &data->client_rect);
207
208 rect->left += rc.left;
209 rect->right += rc.right;
210 rect->top += rc.top;
211 rect->bottom += rc.bottom;
212 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
213 if (rect->left >= rect->right) rect->right = rect->left + 1;
214 }
215
216
217 /***********************************************************************
218 * constrain_window_frame
219 *
220 * Alter a window frame rectangle to fit within a) Cocoa's documented
221 * limits, and b) sane sizes, like twice the desktop rect.
222 */
223 static void constrain_window_frame(CGRect* frame)
224 {
225 CGRect desktop_rect = macdrv_get_desktop_rect();
226 int max_width, max_height;
227
228 max_width = min(32000, 2 * CGRectGetWidth(desktop_rect));
229 max_height = min(32000, 2 * CGRectGetHeight(desktop_rect));
230
231 if (frame->origin.x < -16000) frame->origin.x = -16000;
232 if (frame->origin.y < -16000) frame->origin.y = -16000;
233 if (frame->origin.x > 16000) frame->origin.x = 16000;
234 if (frame->origin.y > 16000) frame->origin.y = 16000;
235 if (frame->size.width > max_width) frame->size.width = max_width;
236 if (frame->size.height > max_height) frame->size.height = max_height;
237 }
238
239
240 /***********************************************************************
241 * alloc_win_data
242 */
243 static struct macdrv_win_data *alloc_win_data(HWND hwnd)
244 {
245 struct macdrv_win_data *data;
246
247 if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
248 {
249 data->hwnd = hwnd;
250 data->color_key = CLR_INVALID;
251 data->swap_interval = 1;
252 EnterCriticalSection(&win_data_section);
253 if (!win_datas)
254 win_datas = CFDictionaryCreateMutable(NULL, 0, NULL, NULL);
255 CFDictionarySetValue(win_datas, hwnd, data);
256 }
257 return data;
258 }
259
260
261 /***********************************************************************
262 * get_win_data
263 *
264 * Lock and return the data structure associated with a window.
265 */
266 struct macdrv_win_data *get_win_data(HWND hwnd)
267 {
268 struct macdrv_win_data *data;
269
270 if (!hwnd) return NULL;
271 EnterCriticalSection(&win_data_section);
272 if (win_datas && (data = (struct macdrv_win_data*)CFDictionaryGetValue(win_datas, hwnd)))
273 return data;
274 LeaveCriticalSection(&win_data_section);
275 return NULL;
276 }
277
278
279 /***********************************************************************
280 * release_win_data
281 *
282 * Release the data returned by get_win_data.
283 */
284 void release_win_data(struct macdrv_win_data *data)
285 {
286 if (data) LeaveCriticalSection(&win_data_section);
287 }
288
289
290 /***********************************************************************
291 * macdrv_get_cocoa_window
292 *
293 * Return the Mac window associated with the full area of a window
294 */
295 macdrv_window macdrv_get_cocoa_window(HWND hwnd, BOOL require_on_screen)
296 {
297 struct macdrv_win_data *data = get_win_data(hwnd);
298 macdrv_window ret = NULL;
299 if (data && (data->on_screen || !require_on_screen))
300 ret = data->cocoa_window;
301 release_win_data(data);
302 return ret;
303 }
304
305
306 /***********************************************************************
307 * macdrv_get_cocoa_view
308 *
309 * Return the Cocoa view associated with a window
310 */
311 macdrv_view macdrv_get_cocoa_view(HWND hwnd)
312 {
313 struct macdrv_win_data *data = get_win_data(hwnd);
314 macdrv_view ret = data ? data->cocoa_view : NULL;
315
316 release_win_data(data);
317 return ret;
318 }
319
320
321 /***********************************************************************
322 * macdrv_get_client_cocoa_view
323 *
324 * Return the Cocoa view associated with a window's client area
325 */
326 macdrv_view macdrv_get_client_cocoa_view(HWND hwnd)
327 {
328 struct macdrv_win_data *data = get_win_data(hwnd);
329 macdrv_view ret = data ? data->client_cocoa_view : NULL;
330
331 release_win_data(data);
332 return ret;
333 }
334
335
336 /***********************************************************************
337 * set_cocoa_window_properties
338 *
339 * Set the window properties for a Cocoa window based on its Windows
340 * properties.
341 */
342 static void set_cocoa_window_properties(struct macdrv_win_data *data)
343 {
344 DWORD style, ex_style;
345 HWND owner;
346 macdrv_window owner_win;
347 struct macdrv_window_features wf;
348 struct macdrv_window_state state;
349
350 style = GetWindowLongW(data->hwnd, GWL_STYLE);
351 ex_style = GetWindowLongW(data->hwnd, GWL_EXSTYLE);
352
353 owner = GetWindow(data->hwnd, GW_OWNER);
354 if (owner)
355 owner = GetAncestor(owner, GA_ROOT);
356 owner_win = macdrv_get_cocoa_window(owner, TRUE);
357 macdrv_set_cocoa_parent_window(data->cocoa_window, owner_win);
358
359 get_cocoa_window_features(data, style, ex_style, &wf, &data->window_rect, &data->client_rect);
360 macdrv_set_cocoa_window_features(data->cocoa_window, &wf);
361
362 get_cocoa_window_state(data, style, ex_style, &state);
363 macdrv_set_cocoa_window_state(data->cocoa_window, &state);
364 if (state.minimized_valid)
365 data->minimized = state.minimized;
366 }
367
368
369 /***********************************************************************
370 * sync_window_region
371 *
372 * Update the window region.
373 */
374 static void sync_window_region(struct macdrv_win_data *data, HRGN win_region)
375 {
376 HRGN hrgn = win_region;
377 RGNDATA *region_data;
378 const CGRect* rects;
379 int count;
380
381 if (!data->cocoa_window) return;
382 data->shaped = FALSE;
383
384 if (IsRectEmpty(&data->window_rect)) /* set an empty shape */
385 {
386 TRACE("win %p/%p setting empty shape for zero-sized window\n", data->hwnd, data->cocoa_window);
387 macdrv_set_window_shape(data->cocoa_window, &CGRectZero, 1);
388 return;
389 }
390
391 if (hrgn == (HRGN)1) /* hack: win_region == 1 means retrieve region from server */
392 {
393 if (!(hrgn = CreateRectRgn(0, 0, 0, 0))) return;
394 if (GetWindowRgn(data->hwnd, hrgn) == ERROR)
395 {
396 DeleteObject(hrgn);
397 hrgn = 0;
398 }
399 }
400
401 if (hrgn && GetWindowLongW(data->hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
402 MirrorRgn(data->hwnd, hrgn);
403 if (hrgn)
404 {
405 OffsetRgn(hrgn, data->window_rect.left - data->whole_rect.left,
406 data->window_rect.top - data->whole_rect.top);
407 }
408 region_data = get_region_data(hrgn, 0);
409 if (region_data)
410 {
411 rects = (CGRect*)region_data->Buffer;
412 count = region_data->rdh.nCount;
413 /* Special case optimization. If the region entirely encloses the Cocoa
414 window, it's the same as there being no region. It's potentially
415 hard/slow to test this for arbitrary regions, so we just check for
416 very simple regions. */
417 if (count == 1 && CGRectContainsRect(rects[0],
418 CGRectOffset(cgrect_from_rect(data->whole_rect), -data->whole_rect.left, -data->whole_rect.top)))
419 {
420 TRACE("optimizing for simple region that contains Cocoa content rect\n");
421 rects = NULL;
422 count = 0;
423 }
424 }
425 else
426 {
427 rects = NULL;
428 count = 0;
429 }
430
431 TRACE("win %p/%p win_region %p rects %p count %d\n", data->hwnd, data->cocoa_window, win_region, rects, count);
432 macdrv_set_window_shape(data->cocoa_window, rects, count);
433
434 HeapFree(GetProcessHeap(), 0, region_data);
435 data->shaped = (region_data != NULL);
436
437 if (hrgn && hrgn != win_region) DeleteObject(hrgn);
438 }
439
440
441 /***********************************************************************
442 * add_bounds_rect
443 */
444 static inline void add_bounds_rect(RECT *bounds, const RECT *rect)
445 {
446 if (rect->left >= rect->right || rect->top >= rect->bottom) return;
447 bounds->left = min(bounds->left, rect->left);
448 bounds->top = min(bounds->top, rect->top);
449 bounds->right = max(bounds->right, rect->right);
450 bounds->bottom = max(bounds->bottom, rect->bottom);
451 }
452
453
454 /***********************************************************************
455 * sync_window_opacity
456 */
457 static void sync_window_opacity(struct macdrv_win_data *data, COLORREF key, BYTE alpha,
458 BOOL per_pixel_alpha, DWORD flags)
459 {
460 CGFloat opacity = 1.0;
461 BOOL needs_flush = FALSE;
462
463 if (flags & LWA_ALPHA) opacity = alpha / 255.0;
464
465 TRACE("setting window %p/%p alpha to %g\n", data->hwnd, data->cocoa_window, opacity);
466 macdrv_set_window_alpha(data->cocoa_window, opacity);
467
468 if (flags & LWA_COLORKEY)
469 {
470 /* FIXME: treat PALETTEINDEX and DIBINDEX as black */
471 if ((key & (1 << 24)) || key >> 16 == 0x10ff)
472 key = RGB(0, 0, 0);
473 }
474 else
475 key = CLR_INVALID;
476
477 if (data->color_key != key)
478 {
479 if (key == CLR_INVALID)
480 {
481 TRACE("clearing color-key for window %p/%p\n", data->hwnd, data->cocoa_window);
482 macdrv_clear_window_color_key(data->cocoa_window);
483 }
484 else
485 {
486 TRACE("setting color-key for window %p/%p to RGB %d,%d,%d\n", data->hwnd, data->cocoa_window,
487 GetRValue(key), GetGValue(key), GetBValue(key));
488 macdrv_set_window_color_key(data->cocoa_window, GetRValue(key), GetGValue(key), GetBValue(key));
489 }
490
491 data->color_key = key;
492 needs_flush = TRUE;
493 }
494
495 if (!data->per_pixel_alpha != !per_pixel_alpha)
496 {
497 TRACE("setting window %p/%p per-pixel-alpha to %d\n", data->hwnd, data->cocoa_window, per_pixel_alpha);
498 macdrv_window_use_per_pixel_alpha(data->cocoa_window, per_pixel_alpha);
499 data->per_pixel_alpha = per_pixel_alpha;
500 needs_flush = TRUE;
501 }
502
503 if (needs_flush && data->surface)
504 {
505 RECT *bounds;
506 RECT rect;
507
508 rect = data->whole_rect;
509 OffsetRect(&rect, -data->whole_rect.left, -data->whole_rect.top);
510 data->surface->funcs->lock(data->surface);
511 bounds = data->surface->funcs->get_bounds(data->surface);
512 add_bounds_rect(bounds, &rect);
513 data->surface->funcs->unlock(data->surface);
514 }
515 }
516
517
518 /***********************************************************************
519 * sync_window_min_max_info
520 */
521 static void sync_window_min_max_info(HWND hwnd)
522 {
523 LONG style = GetWindowLongW(hwnd, GWL_STYLE);
524 LONG exstyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
525 RECT win_rect, primary_monitor_rect;
526 MINMAXINFO minmax;
527 LONG adjustedStyle;
528 INT xinc, yinc;
529 WINDOWPLACEMENT wpl;
530 HMONITOR monitor;
531 struct macdrv_win_data *data;
532
533 TRACE("win %p\n", hwnd);
534
535 if (!macdrv_get_cocoa_window(hwnd, FALSE)) return;
536
537 GetWindowRect(hwnd, &win_rect);
538 minmax.ptReserved.x = win_rect.left;
539 minmax.ptReserved.y = win_rect.top;
540
541 if ((style & WS_CAPTION) == WS_CAPTION)
542 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
543 else
544 adjustedStyle = style;
545
546 primary_monitor_rect.left = primary_monitor_rect.top = 0;
547 primary_monitor_rect.right = GetSystemMetrics(SM_CXSCREEN);
548 primary_monitor_rect.bottom = GetSystemMetrics(SM_CYSCREEN);
549 AdjustWindowRectEx(&primary_monitor_rect, adjustedStyle, ((style & WS_POPUP) && GetMenu(hwnd)), exstyle);
550
551 xinc = -primary_monitor_rect.left;
552 yinc = -primary_monitor_rect.top;
553
554 minmax.ptMaxSize.x = primary_monitor_rect.right - primary_monitor_rect.left;
555 minmax.ptMaxSize.y = primary_monitor_rect.bottom - primary_monitor_rect.top;
556 minmax.ptMaxPosition.x = -xinc;
557 minmax.ptMaxPosition.y = -yinc;
558 if (style & (WS_DLGFRAME | WS_BORDER))
559 {
560 minmax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
561 minmax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
562 }
563 else
564 {
565 minmax.ptMinTrackSize.x = 2 * xinc;
566 minmax.ptMinTrackSize.y = 2 * yinc;
567 }
568 minmax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXMAXTRACK);
569 minmax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYMAXTRACK);
570
571 wpl.length = sizeof(wpl);
572 if (GetWindowPlacement(hwnd, &wpl) && (wpl.ptMaxPosition.x != -1 || wpl.ptMaxPosition.y != -1))
573 {
574 minmax.ptMaxPosition = wpl.ptMaxPosition;
575
576 /* Convert from GetWindowPlacement's workspace coordinates to screen coordinates. */
577 minmax.ptMaxPosition.x -= wpl.rcNormalPosition.left - win_rect.left;
578 minmax.ptMaxPosition.y -= wpl.rcNormalPosition.top - win_rect.top;
579 }
580
581 TRACE("initial ptMaxSize %s ptMaxPosition %s ptMinTrackSize %s ptMaxTrackSize %s\n", wine_dbgstr_point(&minmax.ptMaxSize),
582 wine_dbgstr_point(&minmax.ptMaxPosition), wine_dbgstr_point(&minmax.ptMinTrackSize), wine_dbgstr_point(&minmax.ptMaxTrackSize));
583
584 SendMessageW(hwnd, WM_GETMINMAXINFO, 0, (LPARAM)&minmax);
585
586 TRACE("app's ptMaxSize %s ptMaxPosition %s ptMinTrackSize %s ptMaxTrackSize %s\n", wine_dbgstr_point(&minmax.ptMaxSize),
587 wine_dbgstr_point(&minmax.ptMaxPosition), wine_dbgstr_point(&minmax.ptMinTrackSize), wine_dbgstr_point(&minmax.ptMaxTrackSize));
588
589 /* if the app didn't change the values, adapt them for the window's monitor */
590 if ((monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY)))
591 {
592 MONITORINFO mon_info;
593 RECT monitor_rect;
594
595 mon_info.cbSize = sizeof(mon_info);
596 GetMonitorInfoW(monitor, &mon_info);
597
598 if ((style & WS_MAXIMIZEBOX) && ((style & WS_CAPTION) == WS_CAPTION || !(style & WS_POPUP)))
599 monitor_rect = mon_info.rcWork;
600 else
601 monitor_rect = mon_info.rcMonitor;
602
603 if (minmax.ptMaxSize.x == primary_monitor_rect.right - primary_monitor_rect.left &&
604 minmax.ptMaxSize.y == primary_monitor_rect.bottom - primary_monitor_rect.top)
605 {
606 minmax.ptMaxSize.x = (monitor_rect.right - monitor_rect.left) + 2 * xinc;
607 minmax.ptMaxSize.y = (monitor_rect.bottom - monitor_rect.top) + 2 * yinc;
608 }
609 if (minmax.ptMaxPosition.x == -xinc && minmax.ptMaxPosition.y == -yinc)
610 {
611 minmax.ptMaxPosition.x = monitor_rect.left - xinc;
612 minmax.ptMaxPosition.y = monitor_rect.top - yinc;
613 }
614 }
615
616 minmax.ptMaxTrackSize.x = max(minmax.ptMaxTrackSize.x, minmax.ptMinTrackSize.x);
617 minmax.ptMaxTrackSize.y = max(minmax.ptMaxTrackSize.y, minmax.ptMinTrackSize.y);
618
619 TRACE("adjusted ptMaxSize %s ptMaxPosition %s ptMinTrackSize %s ptMaxTrackSize %s\n", wine_dbgstr_point(&minmax.ptMaxSize),
620 wine_dbgstr_point(&minmax.ptMaxPosition), wine_dbgstr_point(&minmax.ptMinTrackSize), wine_dbgstr_point(&minmax.ptMaxTrackSize));
621
622 if ((data = get_win_data(hwnd)) && data->cocoa_window)
623 {
624 RECT min_rect, max_rect;
625 CGSize min_size, max_size;
626
627 SetRect(&min_rect, 0, 0, minmax.ptMinTrackSize.x, minmax.ptMinTrackSize.y);
628 macdrv_window_to_mac_rect(data, style, &min_rect, &data->window_rect, &data->client_rect);
629 min_size = CGSizeMake(min_rect.right - min_rect.left, min_rect.bottom - min_rect.top);
630
631 if (minmax.ptMaxTrackSize.x == GetSystemMetrics(SM_CXMAXTRACK) &&
632 minmax.ptMaxTrackSize.y == GetSystemMetrics(SM_CYMAXTRACK))
633 max_size = CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX);
634 else
635 {
636 SetRect(&max_rect, 0, 0, minmax.ptMaxTrackSize.x, minmax.ptMaxTrackSize.y);
637 macdrv_window_to_mac_rect(data, style, &max_rect, &data->window_rect, &data->client_rect);
638 max_size = CGSizeMake(max_rect.right - max_rect.left, max_rect.bottom - max_rect.top);
639 }
640
641 TRACE("min_size (%g,%g) max_size (%g,%g)\n", min_size.width, min_size.height, max_size.width, max_size.height);
642 macdrv_set_window_min_max_sizes(data->cocoa_window, min_size, max_size);
643 }
644
645 release_win_data(data);
646 }
647
648
649 /**********************************************************************
650 * create_client_cocoa_view
651 *
652 * Create the Cocoa view for a window's client area
653 */
654 static void create_client_cocoa_view(struct macdrv_win_data *data)
655 {
656 RECT rect = data->client_rect;
657 OffsetRect(&rect, -data->whole_rect.left, -data->whole_rect.top);
658
659 if (data->client_cocoa_view)
660 macdrv_set_view_frame(data->client_cocoa_view, cgrect_from_rect(rect));
661 else
662 {
663 data->client_cocoa_view = macdrv_create_view(cgrect_from_rect(rect));
664 macdrv_set_view_hidden(data->client_cocoa_view, FALSE);
665 }
666 macdrv_set_view_superview(data->client_cocoa_view, data->cocoa_view, data->cocoa_window, NULL, NULL);
667 }
668
669
670 /**********************************************************************
671 * create_cocoa_window
672 *
673 * Create the whole Mac window for a given window
674 */
675 static void create_cocoa_window(struct macdrv_win_data *data)
676 {
677 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
678 WCHAR text[1024];
679 struct macdrv_window_features wf;
680 CGRect frame;
681 DWORD style, ex_style;
682 HRGN win_rgn;
683 COLORREF key;
684 BYTE alpha;
685 DWORD layered_flags;
686
687 if ((win_rgn = CreateRectRgn(0, 0, 0, 0)) &&
688 GetWindowRgn(data->hwnd, win_rgn) == ERROR)
689 {
690 DeleteObject(win_rgn);
691 win_rgn = 0;
692 }
693 data->shaped = (win_rgn != 0);
694
695 style = GetWindowLongW(data->hwnd, GWL_STYLE);
696 ex_style = GetWindowLongW(data->hwnd, GWL_EXSTYLE);
697
698 data->whole_rect = data->window_rect;
699 macdrv_window_to_mac_rect(data, style, &data->whole_rect, &data->window_rect, &data->client_rect);
700
701 get_cocoa_window_features(data, style, ex_style, &wf, &data->window_rect, &data->client_rect);
702
703 frame = cgrect_from_rect(data->whole_rect);
704 constrain_window_frame(&frame);
705 if (frame.size.width < 1 || frame.size.height < 1)
706 frame.size.width = frame.size.height = 1;
707
708 TRACE("creating %p window %s whole %s client %s\n", data->hwnd, wine_dbgstr_rect(&data->window_rect),
709 wine_dbgstr_rect(&data->whole_rect), wine_dbgstr_rect(&data->client_rect));
710
711 data->cocoa_window = macdrv_create_cocoa_window(&wf, frame, data->hwnd, thread_data->queue);
712 if (!data->cocoa_window) goto done;
713 create_client_cocoa_view(data);
714
715 set_cocoa_window_properties(data);
716
717 /* set the window text */
718 if (!InternalGetWindowText(data->hwnd, text, ARRAY_SIZE(text))) text[0] = 0;
719 macdrv_set_cocoa_window_title(data->cocoa_window, text, strlenW(text));
720
721 /* set the window region */
722 if (win_rgn || IsRectEmpty(&data->window_rect)) sync_window_region(data, win_rgn);
723
724 /* set the window opacity */
725 if (!GetLayeredWindowAttributes(data->hwnd, &key, &alpha, &layered_flags)) layered_flags = 0;
726 sync_window_opacity(data, key, alpha, FALSE, layered_flags);
727
728 done:
729 if (win_rgn) DeleteObject(win_rgn);
730 }
731
732
733 /**********************************************************************
734 * destroy_cocoa_window
735 *
736 * Destroy the whole Mac window for a given window.
737 */
738 static void destroy_cocoa_window(struct macdrv_win_data *data)
739 {
740 if (!data->cocoa_window) return;
741
742 TRACE("win %p Cocoa win %p\n", data->hwnd, data->cocoa_window);
743
744 macdrv_destroy_cocoa_window(data->cocoa_window);
745 data->cocoa_window = 0;
746 data->on_screen = FALSE;
747 data->color_key = CLR_INVALID;
748 if (data->surface) window_surface_release(data->surface);
749 data->surface = NULL;
750 if (data->unminimized_surface) window_surface_release(data->unminimized_surface);
751 data->unminimized_surface = NULL;
752 }
753
754
755 /**********************************************************************
756 * create_cocoa_view
757 *
758 * Create the Cocoa view for a given Windows child window
759 */
760 static void create_cocoa_view(struct macdrv_win_data *data)
761 {
762 BOOL equal = EqualRect(&data->window_rect, &data->client_rect);
763 CGRect frame = cgrect_from_rect(data->window_rect);
764
765 data->shaped = FALSE;
766 data->whole_rect = data->window_rect;
767
768 TRACE("creating %p window %s whole %s client %s\n", data->hwnd, wine_dbgstr_rect(&data->window_rect),
769 wine_dbgstr_rect(&data->whole_rect), wine_dbgstr_rect(&data->client_rect));
770
771 if (!equal)
772 data->cocoa_view = macdrv_create_view(frame);
773 create_client_cocoa_view(data);
774 if (equal)
775 {
776 data->cocoa_view = data->client_cocoa_view;
777 macdrv_set_view_hidden(data->cocoa_view, TRUE);
778 macdrv_set_view_frame(data->cocoa_view, frame);
779 }
780 }
781
782
783 /**********************************************************************
784 * destroy_cocoa_view
785 *
786 * Destroy the Cocoa view for a given window.
787 */
788 static void destroy_cocoa_view(struct macdrv_win_data *data)
789 {
790 if (!data->cocoa_view) return;
791
792 TRACE("win %p Cocoa view %p\n", data->hwnd, data->cocoa_view);
793
794 if (data->cocoa_view != data->client_cocoa_view)
795 macdrv_dispose_view(data->cocoa_view);
796 data->cocoa_view = NULL;
797 data->on_screen = FALSE;
798 }
799
800
801 /***********************************************************************
802 * set_cocoa_view_parent
803 */
804 static void set_cocoa_view_parent(struct macdrv_win_data *data, HWND parent)
805 {
806 struct macdrv_win_data *parent_data = get_win_data(parent);
807 macdrv_window cocoa_window = parent_data ? parent_data->cocoa_window : NULL;
808 macdrv_view superview = parent_data ? parent_data->client_cocoa_view : NULL;
809
810 TRACE("win %p/%p parent %p/%p\n", data->hwnd, data->cocoa_view, parent, cocoa_window ? (void*)cocoa_window : (void*)superview);
811
812 if (!cocoa_window && !superview)
813 WARN("hwnd %p new parent %p has no Cocoa window or view in this process\n", data->hwnd, parent);
814
815 macdrv_set_view_superview(data->cocoa_view, superview, cocoa_window, NULL, NULL);
816 release_win_data(parent_data);
817 }
818
819
820 /***********************************************************************
821 * macdrv_create_win_data
822 *
823 * Create a Mac data window structure for an existing window.
824 */
825 static struct macdrv_win_data *macdrv_create_win_data(HWND hwnd, const RECT *window_rect,
826 const RECT *client_rect)
827 {
828 struct macdrv_win_data *data;
829 HWND parent;
830
831 if (GetWindowThreadProcessId(hwnd, NULL) != GetCurrentThreadId()) return NULL;
832
833 if (!(parent = GetAncestor(hwnd, GA_PARENT))) /* desktop */
834 {
835 macdrv_init_thread_data();
836 return NULL;
837 }
838
839 /* don't create win data for HWND_MESSAGE windows */
840 if (parent != GetDesktopWindow() && !GetAncestor(parent, GA_PARENT)) return NULL;
841
842 if (!(data = alloc_win_data(hwnd))) return NULL;
843
844 data->whole_rect = data->window_rect = *window_rect;
845 data->client_rect = *client_rect;
846
847 if (parent == GetDesktopWindow())
848 {
849 create_cocoa_window(data);
850 TRACE("win %p/%p window %s whole %s client %s\n",
851 hwnd, data->cocoa_window, wine_dbgstr_rect(&data->window_rect),
852 wine_dbgstr_rect(&data->whole_rect), wine_dbgstr_rect(&data->client_rect));
853 }
854 else
855 {
856 create_cocoa_view(data);
857 TRACE("win %p/%p window %s whole %s client %s\n",
858 hwnd, data->cocoa_view, wine_dbgstr_rect(&data->window_rect),
859 wine_dbgstr_rect(&data->whole_rect), wine_dbgstr_rect(&data->client_rect));
860
861 set_cocoa_view_parent(data, parent);
862 }
863
864 return data;
865 }
866
867
868 /**********************************************************************
869 * is_owned_by
870 */
871 static BOOL is_owned_by(HWND hwnd, HWND maybe_owner)
872 {
873 while (1)
874 {
875 HWND hwnd2 = GetWindow(hwnd, GW_OWNER);
876 if (!hwnd2)
877 hwnd2 = GetAncestor(hwnd, GA_ROOT);
878 if (!hwnd2 || hwnd2 == hwnd)
879 break;
880 if (hwnd2 == maybe_owner)
881 return TRUE;
882 hwnd = hwnd2;
883 }
884
885 return FALSE;
886 }
887
888
889 /**********************************************************************
890 * is_all_the_way_front
891 */
892 static BOOL is_all_the_way_front(HWND hwnd)
893 {
894 BOOL topmost = (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0;
895 HWND prev = hwnd;
896
897 while ((prev = GetWindow(prev, GW_HWNDPREV)))
898 {
899 if (!topmost && (GetWindowLongW(prev, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0)
900 return TRUE;
901 if (!is_owned_by(prev, hwnd))
902 return FALSE;
903 }
904
905 return TRUE;
906 }
907
908
909 /***********************************************************************
910 * set_focus
911 */
912 static void set_focus(HWND hwnd, BOOL raise)
913 {
914 struct macdrv_win_data *data;
915
916 if (!(hwnd = GetAncestor(hwnd, GA_ROOT))) return;
917
918 if (raise && hwnd == GetForegroundWindow() && hwnd != GetDesktopWindow() && !is_all_the_way_front(hwnd))
919 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
920
921 if (!(data = get_win_data(hwnd))) return;
922
923 if (data->cocoa_window && data->on_screen)
924 {
925 BOOL activate = activate_on_focus_time && (GetTickCount() - activate_on_focus_time < 2000);
926 /* Set Mac focus */
927 macdrv_give_cocoa_window_focus(data->cocoa_window, activate);
928 activate_on_focus_time = 0;
929 }
930
931 release_win_data(data);
932 }
933
934 /***********************************************************************
935 * show_window
936 */
937 static void show_window(struct macdrv_win_data *data)
938 {
939 if (data->cocoa_window)
940 {
941 HWND prev = NULL;
942 HWND next = NULL;
943 macdrv_window prev_window = NULL;
944 macdrv_window next_window = NULL;
945 BOOL activate = FALSE;
946 GUITHREADINFO info;
947
948 /* find window that this one must be after */
949 prev = GetWindow(data->hwnd, GW_HWNDPREV);
950 while (prev && !((GetWindowLongW(prev, GWL_STYLE) & (WS_VISIBLE | WS_MINIMIZE)) == WS_VISIBLE &&
951 (prev_window = macdrv_get_cocoa_window(prev, TRUE))))
952 prev = GetWindow(prev, GW_HWNDPREV);
953 if (!prev_window)
954 {
955 /* find window that this one must be before */
956 next = GetWindow(data->hwnd, GW_HWNDNEXT);
957 while (next && !((GetWindowLongW(next, GWL_STYLE) & (WS_VISIBLE | WS_MINIMIZE)) == WS_VISIBLE &&
958 (next_window = macdrv_get_cocoa_window(next, TRUE))))
959 next = GetWindow(next, GW_HWNDNEXT);
960 }
961
962 TRACE("win %p/%p below %p/%p above %p/%p\n",
963 data->hwnd, data->cocoa_window, prev, prev_window, next, next_window);
964
965 if (!prev_window)
966 activate = activate_on_focus_time && (GetTickCount() - activate_on_focus_time < 2000);
967 macdrv_order_cocoa_window(data->cocoa_window, prev_window, next_window, activate);
968 data->on_screen = TRUE;
969
970 info.cbSize = sizeof(info);
971 if (GetGUIThreadInfo(GetWindowThreadProcessId(data->hwnd, NULL), &info) && info.hwndFocus &&
972 (data->hwnd == info.hwndFocus || IsChild(data->hwnd, info.hwndFocus)))
973 set_focus(info.hwndFocus, FALSE);
974 if (activate)
975 activate_on_focus_time = 0;
976 }
977 else
978 {
979 TRACE("win %p/%p showing view\n", data->hwnd, data->cocoa_view);
980
981 macdrv_set_view_hidden(data->cocoa_view, FALSE);
982 data->on_screen = TRUE;
983 }
984 }
985
986
987 /***********************************************************************
988 * hide_window
989 */
990 static void hide_window(struct macdrv_win_data *data)
991 {
992 TRACE("win %p/%p\n", data->hwnd, data->cocoa_window);
993
994 if (data->cocoa_window)
995 macdrv_hide_cocoa_window(data->cocoa_window);
996 else
997 macdrv_set_view_hidden(data->cocoa_view, TRUE);
998 data->on_screen = FALSE;
999 }
1000
1001
1002 /***********************************************************************
1003 * sync_window_z_order
1004 */
1005 static void sync_window_z_order(struct macdrv_win_data *data)
1006 {
1007 if (data->cocoa_view)
1008 {
1009 HWND parent = GetAncestor(data->hwnd, GA_PARENT);
1010 macdrv_view superview = macdrv_get_client_cocoa_view(parent);
1011 macdrv_window window = NULL;
1012 HWND prev;
1013 HWND next = NULL;
1014 macdrv_view prev_view = NULL;
1015 macdrv_view next_view = NULL;
1016
1017 if (!superview)
1018 {
1019 window = macdrv_get_cocoa_window(parent, FALSE);
1020 if (!window)
1021 WARN("hwnd %p/%p parent %p has no Cocoa window or view in this process\n", data->hwnd, data->cocoa_view, parent);
1022 }
1023
1024 /* find window that this one must be after */
1025 prev = GetWindow(data->hwnd, GW_HWNDPREV);
1026 while (prev && !(prev_view = macdrv_get_cocoa_view(prev)))
1027 prev = GetWindow(prev, GW_HWNDPREV);
1028 if (!prev_view)
1029 {
1030 /* find window that this one must be before */
1031 next = GetWindow(data->hwnd, GW_HWNDNEXT);
1032 while (next && !(next_view = macdrv_get_cocoa_view(next)))
1033 next = GetWindow(next, GW_HWNDNEXT);
1034 }
1035
1036 TRACE("win %p/%p below %p/%p above %p/%p\n",
1037 data->hwnd, data->cocoa_view, prev, prev_view, next, next_view);
1038
1039 macdrv_set_view_superview(data->cocoa_view, superview, window, prev_view, next_view);
1040 }
1041 else if (data->on_screen)
1042 show_window(data);
1043 }
1044
1045
1046 /***********************************************************************
1047 * get_region_data
1048 *
1049 * Calls GetRegionData on the given region and converts the rectangle
1050 * array to CGRect format. The returned buffer must be freed by
1051 * caller using HeapFree(GetProcessHeap(),...).
1052 * If hdc_lptodp is not 0, the rectangles are converted through LPtoDP.
1053 */
1054 RGNDATA *get_region_data(HRGN hrgn, HDC hdc_lptodp)
1055 {
1056 RGNDATA *data;
1057 DWORD size;
1058 int i;
1059 RECT *rect;
1060 CGRect *cgrect;
1061
1062 if (!hrgn || !(size = GetRegionData(hrgn, 0, NULL))) return NULL;
1063 if (sizeof(CGRect) > sizeof(RECT))
1064 {
1065 /* add extra size for CGRect array */
1066 int count = (size - sizeof(RGNDATAHEADER)) / sizeof(RECT);
1067 size += count * (sizeof(CGRect) - sizeof(RECT));
1068 }
1069 if (!(data = HeapAlloc(GetProcessHeap(), 0, size))) return NULL;
1070 if (!GetRegionData(hrgn, size, data))
1071 {
1072 HeapFree(GetProcessHeap(), 0, data);
1073 return NULL;
1074 }
1075
1076 rect = (RECT *)data->Buffer;
1077 cgrect = (CGRect *)data->Buffer;
1078 if (hdc_lptodp) /* map to device coordinates */
1079 {
1080 LPtoDP(hdc_lptodp, (POINT *)rect, data->rdh.nCount * 2);
1081 for (i = 0; i < data->rdh.nCount; i++)
1082 {
1083 if (rect[i].right < rect[i].left)
1084 {
1085 INT tmp = rect[i].right;
1086 rect[i].right = rect[i].left;
1087 rect[i].left = tmp;
1088 }
1089 if (rect[i].bottom < rect[i].top)
1090 {
1091 INT tmp = rect[i].bottom;
1092 rect[i].bottom = rect[i].top;
1093 rect[i].top = tmp;
1094 }
1095 }
1096 }
1097
1098 if (sizeof(CGRect) > sizeof(RECT))
1099 {
1100 /* need to start from the end */
1101 for (i = data->rdh.nCount-1; i >= 0; i--)
1102 cgrect[i] = cgrect_from_rect(rect[i]);
1103 }
1104 else
1105 {
1106 for (i = 0; i < data->rdh.nCount; i++)
1107 cgrect[i] = cgrect_from_rect(rect[i]);
1108 }
1109 return data;
1110 }
1111
1112
1113 /***********************************************************************
1114 * sync_client_view_position
1115 */
1116 static void sync_client_view_position(struct macdrv_win_data *data)
1117 {
1118 if (data->cocoa_view != data->client_cocoa_view)
1119 {
1120 RECT rect = data->client_rect;
1121 OffsetRect(&rect, -data->whole_rect.left, -data->whole_rect.top);
1122 macdrv_set_view_frame(data->client_cocoa_view, cgrect_from_rect(rect));
1123 TRACE("win %p/%p client %s\n", data->hwnd, data->client_cocoa_view, wine_dbgstr_rect(&rect));
1124 }
1125 }
1126
1127
1128 /***********************************************************************
1129 * sync_window_position
1130 *
1131 * Synchronize the Mac window position with the Windows one
1132 */
1133 static void sync_window_position(struct macdrv_win_data *data, UINT swp_flags, const RECT *old_window_rect,
1134 const RECT *old_whole_rect)
1135 {
1136 CGRect frame = cgrect_from_rect(data->whole_rect);
1137 BOOL force_z_order = FALSE;
1138
1139 if (data->cocoa_window)
1140 {
1141 if (data->minimized) return;
1142
1143 constrain_window_frame(&frame);
1144 if (frame.size.width < 1 || frame.size.height < 1)
1145 frame.size.width = frame.size.height = 1;
1146
1147 macdrv_set_cocoa_window_frame(data->cocoa_window, &frame);
1148 }
1149 else
1150 {
1151 BOOL were_equal = (data->cocoa_view == data->client_cocoa_view);
1152 BOOL now_equal = EqualRect(&data->whole_rect, &data->client_rect);
1153
1154 if (were_equal && !now_equal)
1155 {
1156 data->cocoa_view = macdrv_create_view(frame);
1157 macdrv_set_view_hidden(data->cocoa_view, !data->on_screen);
1158 macdrv_set_view_superview(data->client_cocoa_view, data->cocoa_view, NULL, NULL, NULL);
1159 macdrv_set_view_hidden(data->client_cocoa_view, FALSE);
1160 force_z_order = TRUE;
1161 }
1162 else if (!were_equal && now_equal)
1163 {
1164 macdrv_dispose_view(data->cocoa_view);
1165 data->cocoa_view = data->client_cocoa_view;
1166 macdrv_set_view_hidden(data->cocoa_view, !data->on_screen);
1167 macdrv_set_view_frame(data->cocoa_view, frame);
1168 force_z_order = TRUE;
1169 }
1170 else if (!EqualRect(&data->whole_rect, old_whole_rect))
1171 macdrv_set_view_frame(data->cocoa_view, frame);
1172 }
1173
1174 sync_client_view_position(data);
1175
1176 if (old_window_rect && old_whole_rect &&
1177 (IsRectEmpty(old_window_rect) != IsRectEmpty(&data->window_rect) ||
1178 old_window_rect->left - old_whole_rect->left != data->window_rect.left - data->whole_rect.left ||
1179 old_window_rect->top - old_whole_rect->top != data->window_rect.top - data->whole_rect.top))
1180 sync_window_region(data, (HRGN)1);
1181
1182 TRACE("win %p/%p whole_rect %s frame %s\n", data->hwnd,
1183 data->cocoa_window ? (void*)data->cocoa_window : (void*)data->cocoa_view,
1184 wine_dbgstr_rect(&data->whole_rect), wine_dbgstr_cgrect(frame));
1185
1186 if (force_z_order || !(swp_flags & SWP_NOZORDER) || (swp_flags & SWP_SHOWWINDOW))
1187 sync_window_z_order(data);
1188 }
1189
1190
1191 /***********************************************************************
1192 * move_window_bits
1193 *
1194 * Move the window bits when a window is moved.
1195 */
1196 static void move_window_bits(HWND hwnd, macdrv_window window, const RECT *old_rect, const RECT *new_rect,
1197 const RECT *old_client_rect, const RECT *new_client_rect,
1198 const RECT *new_window_rect)
1199 {
1200 RECT src_rect = *old_rect;
1201 RECT dst_rect = *new_rect;
1202 HDC hdc_src, hdc_dst;
1203 HRGN rgn;
1204 HWND parent = 0;
1205
1206 if (!window)
1207 {
1208 OffsetRect(&dst_rect, -new_window_rect->left, -new_window_rect->top);
1209 parent = GetAncestor(hwnd, GA_PARENT);
1210 hdc_src = GetDCEx(parent, 0, DCX_CACHE);
1211 hdc_dst = GetDCEx(hwnd, 0, DCX_CACHE | DCX_WINDOW);
1212 }
1213 else
1214 {
1215 OffsetRect(&dst_rect, -new_client_rect->left, -new_client_rect->top);
1216 /* make src rect relative to the old position of the window */
1217 OffsetRect(&src_rect, -old_client_rect->left, -old_client_rect->top);
1218 if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
1219 hdc_src = hdc_dst = GetDCEx(hwnd, 0, DCX_CACHE);
1220 }
1221
1222 rgn = CreateRectRgnIndirect(&dst_rect);
1223 SelectClipRgn(hdc_dst, rgn);
1224 DeleteObject(rgn);
1225 ExcludeUpdateRgn(hdc_dst, hwnd);
1226
1227 TRACE("copying bits for win %p/%p %s -> %s\n", hwnd, window,
1228 wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect));
1229 BitBlt(hdc_dst, dst_rect.left, dst_rect.top,
1230 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
1231 hdc_src, src_rect.left, src_rect.top, SRCCOPY);
1232
1233 ReleaseDC(hwnd, hdc_dst);
1234 if (hdc_src != hdc_dst) ReleaseDC(parent, hdc_src);
1235 }
1236
1237
1238 /**********************************************************************
1239 * activate_on_following_focus
1240 */
1241 void activate_on_following_focus(void)
1242 {
1243 activate_on_focus_time = GetTickCount();
1244 if (!activate_on_focus_time) activate_on_focus_time = 1;
1245 }
1246
1247
1248 /***********************************************************************
1249 * set_app_icon
1250 */
1251 static void set_app_icon(void)
1252 {
1253 CFArrayRef images = create_app_icon_images();
1254 if (images)
1255 {
1256 macdrv_set_application_icon(images);
1257 CFRelease(images);
1258 }
1259 }
1260
1261
1262 /**********************************************************************
1263 * set_capture_window_for_move
1264 */
1265 static BOOL set_capture_window_for_move(HWND hwnd)
1266 {
1267 HWND previous = 0;
1268 BOOL ret;
1269
1270 SERVER_START_REQ(set_capture_window)
1271 {
1272 req->handle = wine_server_user_handle(hwnd);
1273 req->flags = CAPTURE_MOVESIZE;
1274 if ((ret = !wine_server_call_err(req)))
1275 {
1276 previous = wine_server_ptr_handle(reply->previous);
1277 hwnd = wine_server_ptr_handle(reply->full_handle);
1278 }
1279 }
1280 SERVER_END_REQ;
1281
1282 if (ret)
1283 {
1284 macdrv_SetCapture(hwnd, GUI_INMOVESIZE);
1285
1286 if (previous && previous != hwnd)
1287 SendMessageW(previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd);
1288 }
1289 return ret;
1290 }
1291
1292
1293 /***********************************************************************
1294 * move_window
1295 *
1296 * Based on user32's WINPOS_SysCommandSizeMove() specialized just for
1297 * moving top-level windows and enforcing Mac-style constraints like
1298 * keeping the top of the window within the work area.
1299 */
1300 static LRESULT move_window(HWND hwnd, WPARAM wparam)
1301 {
1302 MSG msg;
1303 RECT origRect, movedRect, desktopRect;
1304 LONG hittest = (LONG)(wparam & 0x0f);
1305 POINT capturePoint;
1306 LONG style = GetWindowLongW(hwnd, GWL_STYLE);
1307 BOOL moved = FALSE;
1308 DWORD dwPoint = GetMessagePos();
1309 INT captionHeight;
1310 HMONITOR mon = 0;
1311 MONITORINFO info;
1312
1313 if ((style & (WS_MINIMIZE | WS_MAXIMIZE)) || !IsWindowVisible(hwnd)) return -1;
1314 if (hittest && hittest != HTCAPTION) return -1;
1315
1316 capturePoint.x = (short)LOWORD(dwPoint);
1317 capturePoint.y = (short)HIWORD(dwPoint);
1318 ClipCursor(NULL);
1319
1320 TRACE("hwnd %p hittest %d, pos %d,%d\n", hwnd, hittest, capturePoint.x, capturePoint.y);
1321
1322 origRect.left = origRect.right = origRect.top = origRect.bottom = 0;
1323 if (AdjustWindowRectEx(&origRect, style, FALSE, GetWindowLongW(hwnd, GWL_EXSTYLE)))
1324 captionHeight = -origRect.top;
1325 else
1326 captionHeight = 0;
1327
1328 GetWindowRect(hwnd, &origRect);
1329 movedRect = origRect;
1330
1331 if (!hittest)
1332 {
1333 /* Move pointer to the center of the caption */
1334 RECT rect = origRect;
1335
1336 /* Note: to be exactly centered we should take the different types
1337 * of border into account, but it shouldn't make more than a few pixels
1338 * of difference so let's not bother with that */
1339 rect.top += GetSystemMetrics(SM_CYBORDER);
1340 if (style & WS_SYSMENU)
1341 rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
1342 if (style & WS_MINIMIZEBOX)
1343 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1344 if (style & WS_MAXIMIZEBOX)
1345 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1346 capturePoint.x = (rect.right + rect.left) / 2;
1347 capturePoint.y = rect.top + GetSystemMetrics(SM_CYSIZE)/2;
1348
1349 SetCursorPos(capturePoint.x, capturePoint.y);
1350 SendMessageW(hwnd, WM_SETCURSOR, (WPARAM)hwnd, MAKELONG(HTCAPTION, WM_MOUSEMOVE));
1351 }
1352
1353 desktopRect = rect_from_cgrect(macdrv_get_desktop_rect());
1354 mon = MonitorFromPoint(capturePoint, MONITOR_DEFAULTTONEAREST);
1355 info.cbSize = sizeof(info);
1356 if (mon && !GetMonitorInfoW(mon, &info))
1357 mon = 0;
1358
1359 /* repaint the window before moving it around */
1360 RedrawWindow(hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
1361
1362 SendMessageW(hwnd, WM_ENTERSIZEMOVE, 0, 0);
1363 set_capture_window_for_move(hwnd);
1364
1365 while(1)
1366 {
1367 POINT pt;
1368 int dx = 0, dy = 0;
1369 HMONITOR newmon;
1370
1371 if (!GetMessageW(&msg, 0, 0, 0)) break;
1372 if (CallMsgFilterW(&msg, MSGF_SIZE)) continue;
1373
1374 /* Exit on button-up, Return, or Esc */
1375 if (msg.message == WM_LBUTTONUP ||
1376 (msg.message == WM_KEYDOWN && (msg.wParam == VK_RETURN || msg.wParam == VK_ESCAPE)))
1377 break;
1378
1379 if (msg.message != WM_KEYDOWN && msg.message != WM_MOUSEMOVE)
1380 {
1381 TranslateMessage(&msg);
1382 DispatchMessageW(&msg);
1383 continue; /* We are not interested in other messages */
1384 }
1385
1386 pt = msg.pt;
1387
1388 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
1389 {
1390 case VK_UP: pt.y -= 8; break;
1391 case VK_DOWN: pt.y += 8; break;
1392 case VK_LEFT: pt.x -= 8; break;
1393 case VK_RIGHT: pt.x += 8; break;
1394 }
1395
1396 pt.x = max(pt.x, desktopRect.left);
1397 pt.x = min(pt.x, desktopRect.right - 1);
1398 pt.y = max(pt.y, desktopRect.top);
1399 pt.y = min(pt.y, desktopRect.bottom - 1);
1400
1401 if ((newmon = MonitorFromPoint(pt, MONITOR_DEFAULTTONULL)) && newmon != mon)
1402 {
1403 if (GetMonitorInfoW(newmon, &info))
1404 mon = newmon;
1405 else
1406 mon = 0;
1407 }
1408
1409 if (mon)
1410 {
1411 /* wineserver clips the cursor position to the virtual desktop rect but,
1412 if the display configuration is non-rectangular, that could still
1413 leave the logical cursor position outside of any display. The window
1414 could keep moving as you push the cursor against a display edge, even
1415 though the visible cursor doesn't keep moving. The following keeps
1416 the window movement in sync with the visible cursor. */
1417 pt.x = max(pt.x, info.rcMonitor.left);
1418 pt.x = min(pt.x, info.rcMonitor.right - 1);
1419 pt.y = max(pt.y, info.rcMonitor.top);
1420 pt.y = min(pt.y, info.rcMonitor.bottom - 1);
1421
1422 /* Assuming that dx will be calculated below as pt.x - capturePoint.x,
1423 dy will be pt.y - capturePoint.y, and movedRect will be offset by those,
1424 we want to enforce these constraints:
1425 movedRect.left + dx < info.rcWork.right
1426 movedRect.right + dx > info.rcWork.left
1427 movedRect.top + captionHeight + dy < info.rcWork.bottom
1428 movedRect.bottom + dy > info.rcWork.top
1429 movedRect.top + dy >= info.rcWork.top
1430 The first four keep at least one edge barely in the work area.
1431 The last keeps the top (i.e. the title bar) in the work area.
1432 The fourth is redundant with the last, so can be ignored.
1433
1434 Substituting for dx and dy and rearranging gives us...
1435 */
1436 pt.x = min(pt.x, info.rcWork.right - 1 + capturePoint.x - movedRect.left);
1437 pt.x = max(pt.x, info.rcWork.left + 1 + capturePoint.x - movedRect.right);
1438 pt.y = min(pt.y, info.rcWork.bottom - 1 + capturePoint.y - movedRect.top - captionHeight);
1439 pt.y = max(pt.y, info.rcWork.top + capturePoint.y - movedRect.top);
1440 }
1441
1442 dx = pt.x - capturePoint.x;
1443 dy = pt.y - capturePoint.y;
1444
1445 if (dx || dy)
1446 {
1447 moved = TRUE;
1448
1449 if (msg.message == WM_KEYDOWN) SetCursorPos(pt.x, pt.y);
1450 else
1451 {
1452 OffsetRect(&movedRect, dx, dy);
1453 capturePoint = pt;
1454
1455 SendMessageW(hwnd, WM_MOVING, 0, (LPARAM)&movedRect);
1456 SetWindowPos(hwnd, 0, movedRect.left, movedRect.top, 0, 0,
1457 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
1458 }
1459 }
1460 }
1461
1462 set_capture_window_for_move(0);
1463
1464 SendMessageW(hwnd, WM_EXITSIZEMOVE, 0, 0);
1465 SendMessageW(hwnd, WM_SETVISIBLE, TRUE, 0L);
1466
1467 /* if the move is canceled, restore the previous position */
1468 if (moved && msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE)
1469 {
1470 SetWindowPos(hwnd, 0, origRect.left, origRect.top, 0, 0,
1471 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
1472 }
1473
1474 return 0;
1475 }
1476
1477
1478 /***********************************************************************
1479 * perform_window_command
1480 */
1481 static void perform_window_command(HWND hwnd, DWORD style_any, DWORD style_none, WORD command, WORD hittest)
1482 {
1483 DWORD style;
1484
1485 TRACE("win %p style_any 0x%08x style_none 0x%08x command 0x%04x hittest 0x%04x\n",
1486 hwnd, style_any, style_none, command, hittest);
1487
1488 style = GetWindowLongW(hwnd, GWL_STYLE);
1489 if ((style_any && !(style & style_any)) || (style & (WS_DISABLED | style_none)))
1490 {
1491 TRACE("not changing win %p style 0x%08x\n", hwnd, style);
1492 return;
1493 }
1494
1495 if (GetActiveWindow() != hwnd)
1496 {
1497 LRESULT ma = SendMessageW(hwnd, WM_MOUSEACTIVATE, (WPARAM)GetAncestor(hwnd, GA_ROOT),
1498 MAKELPARAM(hittest, WM_NCLBUTTONDOWN));
1499 switch (ma)
1500 {
1501 case MA_NOACTIVATEANDEAT:
1502 case MA_ACTIVATEANDEAT:
1503 TRACE("not changing win %p mouse-activate result %ld\n", hwnd, ma);
1504 return;
1505 case MA_NOACTIVATE:
1506 break;
1507 case MA_ACTIVATE:
1508 case 0:
1509 SetActiveWindow(hwnd);
1510 break;
1511 default:
1512 WARN("unknown WM_MOUSEACTIVATE code %ld\n", ma);
1513 break;
1514 }
1515 }
1516
1517 TRACE("changing win %p\n", hwnd);
1518 PostMessageW(hwnd, WM_SYSCOMMAND, command, 0);
1519 }
1520
1521
1522 /**********************************************************************
1523 * CreateDesktopWindow (MACDRV.@)
1524 */
1525 BOOL CDECL macdrv_CreateDesktopWindow(HWND hwnd)
1526 {
1527 unsigned int width, height;
1528
1529 TRACE("%p\n", hwnd);
1530
1531 /* retrieve the real size of the desktop */
1532 SERVER_START_REQ(get_window_rectangles)
1533 {
1534 req->handle = wine_server_user_handle(hwnd);
1535 req->relative = COORDS_CLIENT;
1536 wine_server_call(req);
1537 width = reply->window.right;
1538 height = reply->window.bottom;
1539 }
1540 SERVER_END_REQ;
1541
1542 if (!width && !height) /* not initialized yet */
1543 {
1544 CGRect rect = macdrv_get_desktop_rect();
1545
1546 SERVER_START_REQ(set_window_pos)
1547 {
1548 req->handle = wine_server_user_handle(hwnd);
1549 req->previous = 0;
1550 req->swp_flags = SWP_NOZORDER;
1551 req->window.left = CGRectGetMinX(rect);
1552 req->window.top = CGRectGetMinY(rect);
1553 req->window.right = CGRectGetMaxX(rect);
1554 req->window.bottom = CGRectGetMaxY(rect);
1555 req->client = req->window;
1556 wine_server_call(req);
1557 }
1558 SERVER_END_REQ;
1559 }
1560
1561 set_app_icon();
1562 return TRUE;
1563 }
1564
1565
1566 static WNDPROC desktop_orig_wndproc;
1567
1568 #define WM_WINE_NOTIFY_ACTIVITY WM_USER
1569
1570 static LRESULT CALLBACK desktop_wndproc_wrapper( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
1571 {
1572 switch (msg)
1573 {
1574 case WM_WINE_NOTIFY_ACTIVITY:
1575 {
1576 /* This wakes from display sleep, but doesn't affect the screen saver. */
1577 static IOPMAssertionID assertion;
1578 IOPMAssertionDeclareUserActivity(CFSTR("Wine user input"), kIOPMUserActiveLocal, &assertion);
1579
1580 /* This prevents the screen saver, but doesn't wake from display sleep. */
1581 /* It's deprecated, but there's no better alternative. */
1582 #pragma clang diagnostic push
1583 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1584 UpdateSystemActivity(UsrActivity);
1585 #pragma clang diagnostic pop
1586 break;
1587 }
1588 }
1589 return desktop_orig_wndproc( hwnd, msg, wp, lp );
1590 }
1591
1592 /**********************************************************************
1593 * CreateWindow (MACDRV.@)
1594 */
1595 BOOL CDECL macdrv_CreateWindow(HWND hwnd)
1596 {
1597 if (hwnd == GetDesktopWindow())
1598 {
1599 desktop_orig_wndproc = (WNDPROC)SetWindowLongPtrW( GetDesktopWindow(),
1600 GWLP_WNDPROC, (LONG_PTR)desktop_wndproc_wrapper );
1601
1602 macdrv_init_clipboard();
1603 }
1604 return TRUE;
1605 }
1606
1607
1608 /***********************************************************************
1609 * DestroyWindow (MACDRV.@)
1610 */
1611 void CDECL macdrv_DestroyWindow(HWND hwnd)
1612 {
1613 struct macdrv_win_data *data;
1614
1615 TRACE("%p\n", hwnd);
1616
1617 if (!(data = get_win_data(hwnd))) return;
1618
1619 if (hwnd == GetCapture()) macdrv_SetCapture(0, 0);
1620 if (data->drag_event) SetEvent(data->drag_event);
1621
1622 destroy_cocoa_window(data);
1623 destroy_cocoa_view(data);
1624 if (data->client_cocoa_view) macdrv_dispose_view(data->client_cocoa_view);
1625
1626 CFDictionaryRemoveValue(win_datas, hwnd);
1627 release_win_data(data);
1628 HeapFree(GetProcessHeap(), 0, data);
1629 }
1630
1631
1632 /*****************************************************************
1633 * SetFocus (MACDRV.@)
1634 *
1635 * Set the Mac focus.
1636 */
1637 void CDECL macdrv_SetFocus(HWND hwnd)
1638 {
1639 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1640
1641 TRACE("%p\n", hwnd);
1642
1643 if (!thread_data) return;
1644 thread_data->dead_key_state = 0;
1645 set_focus(hwnd, TRUE);
1646 }
1647
1648
1649 /***********************************************************************
1650 * SetLayeredWindowAttributes (MACDRV.@)
1651 *
1652 * Set transparency attributes for a layered window.
1653 */
1654 void CDECL macdrv_SetLayeredWindowAttributes(HWND hwnd, COLORREF key, BYTE alpha, DWORD flags)
1655 {
1656 struct macdrv_win_data *data = get_win_data(hwnd);
1657
1658 TRACE("hwnd %p key %#08x alpha %#02x flags %x\n", hwnd, key, alpha, flags);
1659
1660 if (data)
1661 {
1662 data->layered = TRUE;
1663 data->ulw_layered = FALSE;
1664 if (data->surface) set_surface_use_alpha(data->surface, FALSE);
1665 if (data->cocoa_window)
1666 {
1667 sync_window_opacity(data, key, alpha, FALSE, flags);
1668 /* since layered attributes are now set, can now show the window */
1669 if ((GetWindowLongW(hwnd, GWL_STYLE) & WS_VISIBLE) && !data->on_screen)
1670 show_window(data);
1671 }
1672 release_win_data(data);
1673 }
1674 else
1675 FIXME("setting layered attributes on window %p of other process not supported\n", hwnd);
1676 }
1677
1678
1679 /*****************************************************************
1680 * SetParent (MACDRV.@)
1681 */
1682 void CDECL macdrv_SetParent(HWND hwnd, HWND parent, HWND old_parent)
1683 {
1684 struct macdrv_win_data *data;
1685
1686 TRACE("%p, %p, %p\n", hwnd, parent, old_parent);
1687
1688 if (parent == old_parent) return;
1689 if (!(data = get_win_data(hwnd))) return;
1690
1691 if (parent != GetDesktopWindow()) /* a child window */
1692 {
1693 if (old_parent == GetDesktopWindow())
1694 {
1695 /* destroy the old Mac window */
1696 destroy_cocoa_window(data);
1697 create_cocoa_view(data);
1698 }
1699
1700 set_cocoa_view_parent(data, parent);
1701 }
1702 else /* new top level window */
1703 {
1704 destroy_cocoa_view(data);
1705 create_cocoa_window(data);
1706 }
1707 release_win_data(data);
1708 }
1709
1710
1711 /***********************************************************************
1712 * SetWindowRgn (MACDRV.@)
1713 *
1714 * Assign specified region to window (for non-rectangular windows)
1715 */
1716 void CDECL macdrv_SetWindowRgn(HWND hwnd, HRGN hrgn, BOOL redraw)
1717 {
1718 struct macdrv_win_data *data;
1719
1720 TRACE("%p, %p, %d\n", hwnd, hrgn, redraw);
1721
1722 if ((data = get_win_data(hwnd)))
1723 {
1724 sync_window_region(data, hrgn);
1725 release_win_data(data);
1726 }
1727 else
1728 {
1729 DWORD procid;
1730
1731 GetWindowThreadProcessId(hwnd, &procid);
1732 if (procid != GetCurrentProcessId())
1733 SendMessageW(hwnd, WM_MACDRV_SET_WIN_REGION, 0, 0);
1734 }
1735 }
1736
1737
1738 /***********************************************************************
1739 * SetWindowStyle (MACDRV.@)
1740 *
1741 * Update the state of the Cocoa window to reflect a style change
1742 */
1743 void CDECL macdrv_SetWindowStyle(HWND hwnd, INT offset, STYLESTRUCT *style)
1744 {
1745 struct macdrv_win_data *data;
1746
1747 TRACE("hwnd %p offset %d styleOld 0x%08x styleNew 0x%08x\n", hwnd, offset, style->styleOld, style->styleNew);
1748
1749 if (hwnd == GetDesktopWindow()) return;
1750 if (!(data = get_win_data(hwnd))) return;
1751
1752 if (data->cocoa_window)
1753 {
1754 DWORD changed = style->styleNew ^ style->styleOld;
1755
1756 set_cocoa_window_properties(data);
1757
1758 if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYERED)) /* changing WS_EX_LAYERED resets attributes */
1759 {
1760 data->layered = FALSE;
1761 data->ulw_layered = FALSE;
1762 sync_window_opacity(data, 0, 0, FALSE, 0);
1763 if (data->surface) set_surface_use_alpha(data->surface, FALSE);
1764 }
1765
1766 if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYOUTRTL))
1767 sync_window_region(data, (HRGN)1);
1768 }
1769
1770 release_win_data(data);
1771 }
1772
1773
1774 /*****************************************************************
1775 * SetWindowText (MACDRV.@)
1776 */
1777 void CDECL macdrv_SetWindowText(HWND hwnd, LPCWSTR text)
1778 {
1779 macdrv_window win;
1780
1781 TRACE("%p, %s\n", hwnd, debugstr_w(text));
1782
1783 if ((win = macdrv_get_cocoa_window(hwnd, FALSE)))
1784 macdrv_set_cocoa_window_title(win, text, strlenW(text));
1785 }
1786
1787
1788 /***********************************************************************
1789 * ShowWindow (MACDRV.@)
1790 */
1791 UINT CDECL macdrv_ShowWindow(HWND hwnd, INT cmd, RECT *rect, UINT swp)
1792 {
1793 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1794 struct macdrv_win_data *data = get_win_data(hwnd);
1795 CGRect frame;
1796
1797 TRACE("win %p/%p cmd %d at %s flags %08x\n",
1798 hwnd, data ? data->cocoa_window : NULL, cmd, wine_dbgstr_rect(rect), swp);
1799
1800 if (!data || !data->cocoa_window) goto done;
1801 if (IsRectEmpty(rect)) goto done;
1802 if (GetWindowLongW(hwnd, GWL_STYLE) & WS_MINIMIZE)
1803 {
1804 if (rect->left != -32000 || rect->top != -32000)
1805 {
1806 OffsetRect(rect, -32000 - rect->left, -32000 - rect->top);
1807 swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE);
1808 }
1809 goto done;
1810 }
1811 if (!data->on_screen) goto done;
1812
1813 /* only fetch the new rectangle if the ShowWindow was a result of an external event */
1814
1815 if (!thread_data->current_event || thread_data->current_event->window != data->cocoa_window)
1816 goto done;
1817
1818 if (thread_data->current_event->type != WINDOW_FRAME_CHANGED &&
1819 thread_data->current_event->type != WINDOW_DID_UNMINIMIZE)
1820 goto done;
1821
1822 macdrv_get_cocoa_window_frame(data->cocoa_window, &frame);
1823 *rect = rect_from_cgrect(frame);
1824 macdrv_mac_to_window_rect(data, rect);
1825 TRACE("rect %s -> %s\n", wine_dbgstr_cgrect(frame), wine_dbgstr_rect(rect));
1826 swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE | SWP_NOSIZE | SWP_NOCLIENTSIZE);
1827
1828 done:
1829 release_win_data(data);
1830 return swp;
1831 }
1832
1833
1834 /***********************************************************************
1835 * SysCommand (MACDRV.@)
1836 *
1837 * Perform WM_SYSCOMMAND handling.
1838 */
1839 LRESULT CDECL macdrv_SysCommand(HWND hwnd, WPARAM wparam, LPARAM lparam)
1840 {
1841 struct macdrv_win_data *data;
1842 LRESULT ret = -1;
1843 WPARAM command = wparam & 0xfff0;
1844
1845 TRACE("%p, %x, %lx\n", hwnd, (unsigned)wparam, lparam);
1846
1847 if (!(data = get_win_data(hwnd))) goto done;
1848 if (!data->cocoa_window || !data->on_screen) goto done;
1849
1850 /* prevent a simple ALT press+release from activating the system menu,
1851 as that can get confusing */
1852 if (command == SC_KEYMENU && !(WCHAR)lparam && !GetMenu(hwnd) &&
1853 (GetWindowLongW(hwnd, GWL_STYLE) & WS_SYSMENU))
1854 {
1855 TRACE("ignoring SC_KEYMENU wp %lx lp %lx\n", wparam, lparam);
1856 ret = 0;
1857 }
1858
1859 if (command == SC_MOVE)
1860 {
1861 release_win_data(data);
1862 return move_window(hwnd, wparam);
1863 }
1864
1865 done:
1866 release_win_data(data);
1867 return ret;
1868 }
1869
1870
1871 /***********************************************************************
1872 * UpdateLayeredWindow (MACDRV.@)
1873 */
1874 BOOL CDECL macdrv_UpdateLayeredWindow(HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
1875 const RECT *window_rect)
1876 {
1877 struct window_surface *surface;
1878 struct macdrv_win_data *data;
1879 BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
1880 BYTE alpha;
1881 char buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
1882 BITMAPINFO *bmi = (BITMAPINFO *)buffer;
1883 void *src_bits, *dst_bits;
1884 RECT rect, src_rect;
1885 HDC hdc = 0;
1886 HBITMAP dib;
1887 BOOL ret = FALSE;
1888
1889 if (!(data = get_win_data(hwnd))) return FALSE;
1890
1891 data->layered = TRUE;
1892 data->ulw_layered = TRUE;
1893
1894 rect = *window_rect;
1895 OffsetRect(&rect, -window_rect->left, -window_rect->top);
1896
1897 surface = data->surface;
1898 if (!surface || !EqualRect(&surface->rect, &rect))
1899 {
1900 data->surface = create_surface(data->cocoa_window, &rect, NULL, TRUE);
1901 set_window_surface(data->cocoa_window, data->surface);
1902 if (surface) window_surface_release(surface);
1903 surface = data->surface;
1904 if (data->unminimized_surface)
1905 {
1906 window_surface_release(data->unminimized_surface);
1907 data->unminimized_surface = NULL;
1908 }
1909 }
1910 else set_surface_use_alpha(surface, TRUE);
1911
1912 if (surface) window_surface_add_ref(surface);
1913 release_win_data(data);
1914
1915 if (!surface) return FALSE;
1916 if (!info->hdcSrc)
1917 {
1918 window_surface_release(surface);
1919 return TRUE;
1920 }
1921
1922 if (info->dwFlags & ULW_ALPHA)
1923 {
1924 /* Apply SourceConstantAlpha via window alpha, not blend. */
1925 alpha = info->pblend->SourceConstantAlpha;
1926 blend = *info->pblend;
1927 blend.SourceConstantAlpha = 0xff;
1928 }
1929 else
1930 alpha = 0xff;
1931
1932 dst_bits = surface->funcs->get_info(surface, bmi);
1933
1934 if (!(dib = CreateDIBSection(info->hdcDst, bmi, DIB_RGB_COLORS, &src_bits, NULL, 0))) goto done;
1935 if (!(hdc = CreateCompatibleDC(0))) goto done;
1936
1937 SelectObject(hdc, dib);
1938 if (info->prcDirty)
1939 {
1940 IntersectRect(&rect, &rect, info->prcDirty);
1941 surface->funcs->lock(surface);
1942 memcpy(src_bits, dst_bits, bmi->bmiHeader.biSizeImage);
1943 surface->funcs->unlock(surface);
1944 PatBlt(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, BLACKNESS);
1945 }
1946 src_rect = rect;
1947 if (info->pptSrc) OffsetRect( &src_rect, info->pptSrc->x, info->pptSrc->y );
1948 DPtoLP( info->hdcSrc, (POINT *)&src_rect, 2 );
1949
1950 if (!(ret = GdiAlphaBlend(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
1951 info->hdcSrc, src_rect.left, src_rect.top,
1952 src_rect.right - src_rect.left, src_rect.bottom - src_rect.top,
1953 blend)))
1954 goto done;
1955
1956 if ((data = get_win_data(hwnd)))
1957 {
1958 if (surface == data->surface)
1959 {
1960 surface->funcs->lock(surface);
1961 memcpy(dst_bits, src_bits, bmi->bmiHeader.biSizeImage);
1962 add_bounds_rect(surface->funcs->get_bounds(surface), &rect);
1963 surface->funcs->unlock(surface);
1964 surface->funcs->flush(surface);
1965 }
1966
1967 /* The ULW flags are a superset of the LWA flags. */
1968 sync_window_opacity(data, info->crKey, alpha, TRUE, info->dwFlags);
1969
1970 release_win_data(data);
1971 }
1972
1973 done:
1974 window_surface_release(surface);
1975 if (hdc) DeleteDC(hdc);
1976 if (dib) DeleteObject(dib);
1977 return ret;
1978 }
1979
1980
1981 /**********************************************************************
1982 * WindowMessage (MACDRV.@)
1983 */
1984 LRESULT CDECL macdrv_WindowMessage(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
1985 {
1986 struct macdrv_win_data *data;
1987
1988 TRACE("%p, %u, %u, %lu\n", hwnd, msg, (unsigned)wp, lp);
1989
1990 switch(msg)
1991 {
1992 case WM_MACDRV_SET_WIN_REGION:
1993 if ((data = get_win_data(hwnd)))
1994 {
1995 sync_window_region(data, (HRGN)1);
1996 release_win_data(data);
1997 }
1998 return 0;
1999 case WM_MACDRV_UPDATE_DESKTOP_RECT:
2000 if (hwnd == GetDesktopWindow())
2001 {
2002 CGRect new_desktop_rect;
2003 RECT current_desktop_rect;
2004
2005 macdrv_reset_device_metrics();
2006 new_desktop_rect = macdrv_get_desktop_rect();
2007 if (!GetWindowRect(hwnd, &current_desktop_rect) ||
2008 !CGRectEqualToRect(cgrect_from_rect(current_desktop_rect), new_desktop_rect))
2009 {
2010 SendMessageTimeoutW(HWND_BROADCAST, WM_MACDRV_RESET_DEVICE_METRICS, 0, 0,
2011 SMTO_ABORTIFHUNG, 2000, NULL);
2012 SetWindowPos(hwnd, 0, CGRectGetMinX(new_desktop_rect), CGRectGetMinY(new_desktop_rect),
2013 CGRectGetWidth(new_desktop_rect), CGRectGetHeight(new_desktop_rect),
2014 SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE);
2015 SendMessageTimeoutW(HWND_BROADCAST, WM_MACDRV_DISPLAYCHANGE, wp, lp,
2016 SMTO_ABORTIFHUNG, 2000, NULL);
2017 }
2018 }
2019 return 0;
2020 case WM_MACDRV_RESET_DEVICE_METRICS:
2021 macdrv_reset_device_metrics();
2022 return 0;
2023 case WM_MACDRV_DISPLAYCHANGE:
2024 macdrv_reassert_window_position(hwnd);
2025 SendMessageW(hwnd, WM_DISPLAYCHANGE, wp, lp);
2026 return 0;
2027 case WM_MACDRV_ACTIVATE_ON_FOLLOWING_FOCUS:
2028 activate_on_following_focus();
2029 TRACE("WM_MACDRV_ACTIVATE_ON_FOLLOWING_FOCUS time %u\n", activate_on_focus_time);
2030 return 0;
2031 }
2032
2033 FIXME("unrecognized window msg %x hwnd %p wp %lx lp %lx\n", msg, hwnd, wp, lp);
2034 return 0;
2035 }
2036
2037
2038 static inline RECT get_surface_rect(const RECT *visible_rect)
2039 {
2040 RECT rect;
2041 RECT desktop_rect = rect_from_cgrect(macdrv_get_desktop_rect());
2042
2043 IntersectRect(&rect, visible_rect, &desktop_rect);
2044 OffsetRect(&rect, -visible_rect->left, -visible_rect->top);
2045 rect.left &= ~127;
2046 rect.top &= ~127;
2047 rect.right = max(rect.left + 128, (rect.right + 127) & ~127);
2048 rect.bottom = max(rect.top + 128, (rect.bottom + 127) & ~127);
2049 return rect;
2050 }
2051
2052
2053 /***********************************************************************
2054 * WindowPosChanging (MACDRV.@)
2055 */
2056 void CDECL macdrv_WindowPosChanging(HWND hwnd, HWND insert_after, UINT swp_flags,
2057 const RECT *window_rect, const RECT *client_rect,
2058 RECT *visible_rect, struct window_surface **surface)
2059 {
2060 struct macdrv_win_data *data = get_win_data(hwnd);
2061 DWORD style = GetWindowLongW(hwnd, GWL_STYLE);
2062 RECT surface_rect;
2063
2064 TRACE("%p after %p swp %04x window %s client %s visible %s surface %p\n", hwnd, insert_after,
2065 swp_flags, wine_dbgstr_rect(window_rect), wine_dbgstr_rect(client_rect),
2066 wine_dbgstr_rect(visible_rect), surface);
2067
2068 if (!data && !(data = macdrv_create_win_data(hwnd, window_rect, client_rect))) return;
2069
2070 *visible_rect = *window_rect;
2071 macdrv_window_to_mac_rect(data, style, visible_rect, window_rect, client_rect);
2072 TRACE("visible_rect %s -> %s\n", wine_dbgstr_rect(window_rect),
2073 wine_dbgstr_rect(visible_rect));
2074
2075 /* create the window surface if necessary */
2076 if (!data->cocoa_window) goto done;
2077 if (swp_flags & SWP_HIDEWINDOW) goto done;
2078 if (data->ulw_layered) goto done;
2079
2080 if (*surface) window_surface_release(*surface);
2081 *surface = NULL;
2082
2083 surface_rect = get_surface_rect(visible_rect);
2084 if (data->surface)
2085 {
2086 if (EqualRect(&data->surface->rect, &surface_rect))
2087 {
2088 /* existing surface is good enough */
2089 surface_clip_to_visible_rect(data->surface, visible_rect);
2090 window_surface_add_ref(data->surface);
2091 *surface = data->surface;
2092 goto done;
2093 }
2094 }
2095 else if (!(swp_flags & SWP_SHOWWINDOW) && !(style & WS_VISIBLE)) goto done;
2096
2097 *surface = create_surface(data->cocoa_window, &surface_rect, data->surface, FALSE);
2098
2099 done:
2100 release_win_data(data);
2101 }
2102
2103
2104 /***********************************************************************
2105 * WindowPosChanged (MACDRV.@)
2106 */
2107 void CDECL macdrv_WindowPosChanged(HWND hwnd, HWND insert_after, UINT swp_flags,
2108 const RECT *window_rect, const RECT *client_rect,
2109 const RECT *visible_rect, const RECT *valid_rects,
2110 struct window_surface *surface)
2111 {
2112 struct macdrv_thread_data *thread_data;
2113 struct macdrv_win_data *data;
2114 DWORD new_style = GetWindowLongW(hwnd, GWL_STYLE);
2115 RECT old_window_rect, old_whole_rect, old_client_rect;
2116
2117 if (!(data = get_win_data(hwnd))) return;
2118
2119 thread_data = macdrv_thread_data();
2120
2121 old_window_rect = data->window_rect;
2122 old_whole_rect = data->whole_rect;
2123 old_client_rect = data->client_rect;
2124 data->window_rect = *window_rect;
2125 data->whole_rect = *visible_rect;
2126 data->client_rect = *client_rect;
2127 if (data->cocoa_window && !data->ulw_layered)
2128 {
2129 if (surface) window_surface_add_ref(surface);
2130 if (new_style & WS_MINIMIZE)
2131 {
2132 if (!data->unminimized_surface && data->surface)
2133 {
2134 data->unminimized_surface = data->surface;
2135 window_surface_add_ref(data->unminimized_surface);
2136 }
2137 }
2138 else
2139 {
2140 set_window_surface(data->cocoa_window, surface);
2141 if (data->unminimized_surface)
2142 {
2143 window_surface_release(data->unminimized_surface);
2144 data->unminimized_surface = NULL;
2145 }
2146 }
2147 if (data->surface) window_surface_release(data->surface);
2148 data->surface = surface;
2149 }
2150
2151 TRACE("win %p/%p window %s whole %s client %s style %08x flags %08x surface %p\n",
2152 hwnd, data->cocoa_window, wine_dbgstr_rect(window_rect),
2153 wine_dbgstr_rect(visible_rect), wine_dbgstr_rect(client_rect),
2154 new_style, swp_flags, surface);
2155
2156 if (!IsRectEmpty(&valid_rects[0]))
2157 {
2158 macdrv_window window = data->cocoa_window;
2159 int x_offset = old_whole_rect.left - data->whole_rect.left;
2160 int y_offset = old_whole_rect.top - data->whole_rect.top;
2161
2162 /* if all that happened is that the whole window moved, copy everything */
2163 if (!(swp_flags & SWP_FRAMECHANGED) &&
2164 old_whole_rect.right - data->whole_rect.right == x_offset &&
2165 old_whole_rect.bottom - data->whole_rect.bottom == y_offset &&
2166 old_client_rect.left - data->client_rect.left == x_offset &&
2167 old_client_rect.right - data->client_rect.right == x_offset &&
2168 old_client_rect.top - data->client_rect.top == y_offset &&
2169 old_client_rect.bottom - data->client_rect.bottom == y_offset &&
2170 EqualRect(&valid_rects[0], &data->client_rect))
2171 {
2172 /* A Cocoa window's bits are moved automatically */
2173 if (!window && (x_offset != 0 || y_offset != 0))
2174 {
2175 release_win_data(data);
2176 move_window_bits(hwnd, window, &old_whole_rect, visible_rect,
2177 &old_client_rect, client_rect, window_rect);
2178 if (!(data = get_win_data(hwnd))) return;
2179 }
2180 }
2181 else
2182 {
2183 release_win_data(data);
2184 move_window_bits(hwnd, window, &valid_rects[1], &valid_rects[0],
2185 &old_client_rect, client_rect, window_rect);
2186 if (!(data = get_win_data(hwnd))) return;
2187 }
2188 }
2189
2190 sync_gl_view(data, &old_whole_rect, &old_client_rect);
2191
2192 if (!data->cocoa_window && !data->cocoa_view) goto done;
2193
2194 if (data->on_screen)
2195 {
2196 if ((swp_flags & SWP_HIDEWINDOW) && !(new_style & WS_VISIBLE))
2197 hide_window(data);
2198 }
2199
2200 /* check if we are currently processing an event relevant to this window */
2201 if (thread_data && thread_data->current_event &&
2202 data->cocoa_window && thread_data->current_event->window == data->cocoa_window &&
2203 (thread_data->current_event->type == WINDOW_FRAME_CHANGED ||
2204 thread_data->current_event->type == WINDOW_DID_UNMINIMIZE))
2205 {
2206 if (thread_data->current_event->type == WINDOW_FRAME_CHANGED)
2207 sync_client_view_position(data);
2208 }
2209 else
2210 {
2211 sync_window_position(data, swp_flags, &old_window_rect, &old_whole_rect);
2212 if (data->cocoa_window)
2213 set_cocoa_window_properties(data);
2214 }
2215
2216 if (new_style & WS_VISIBLE)
2217 {
2218 if (data->cocoa_window)
2219 {
2220 if (!data->on_screen || (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)))
2221 set_cocoa_window_properties(data);
2222
2223 /* layered windows are not shown until their attributes are set */
2224 if (!data->on_screen &&
2225 (data->layered || !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED)))
2226 show_window(data);
2227 }
2228 else if (!data->on_screen)
2229 show_window(data);
2230 }
2231
2232 done:
2233 release_win_data(data);
2234 }
2235
2236
2237 /***********************************************************************
2238 * macdrv_window_close_requested
2239 *
2240 * Handler for WINDOW_CLOSE_REQUESTED events.
2241 */
2242 void macdrv_window_close_requested(HWND hwnd)
2243 {
2244 HMENU sysmenu;
2245
2246 if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE)
2247 {
2248 TRACE("not closing win %p class style CS_NOCLOSE\n", hwnd);
2249 return;
2250 }
2251
2252 sysmenu = GetSystemMenu(hwnd, FALSE);
2253 if (sysmenu)
2254 {
2255 UINT state = GetMenuState(sysmenu, SC_CLOSE, MF_BYCOMMAND);
2256 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
2257 {
2258 TRACE("not closing win %p menu state 0x%08x\n", hwnd, state);
2259 return;
2260 }
2261 }
2262
2263 perform_window_command(hwnd, 0, 0, SC_CLOSE, HTCLOSE);
2264 }
2265
2266
2267 /***********************************************************************
2268 * macdrv_window_frame_changed
2269 *
2270 * Handler for WINDOW_FRAME_CHANGED events.
2271 */
2272 void macdrv_window_frame_changed(HWND hwnd, const macdrv_event *event)
2273 {
2274 struct macdrv_win_data *data;
2275 RECT rect;
2276 HWND parent;
2277 UINT flags = SWP_NOACTIVATE | SWP_NOZORDER;
2278 int width, height;
2279 BOOL being_dragged;
2280
2281 if (!hwnd) return;
2282 if (!(data = get_win_data(hwnd))) return;
2283 if (!data->on_screen || data->minimized)
2284 {
2285 release_win_data(data);
2286 return;
2287 }
2288
2289 /* Get geometry */
2290
2291 parent = GetAncestor(hwnd, GA_PARENT);
2292
2293 TRACE("win %p/%p new Cocoa frame %s fullscreen %d in_resize %d\n", hwnd, data->cocoa_window,
2294 wine_dbgstr_cgrect(event->window_frame_changed.frame),
2295 event->window_frame_changed.fullscreen, event->window_frame_changed.in_resize);
2296
2297 rect = rect_from_cgrect(event->window_frame_changed.frame);
2298 macdrv_mac_to_window_rect(data, &rect);
2299 MapWindowPoints(0, parent, (POINT *)&rect, 2);
2300
2301 width = rect.right - rect.left;
2302 height = rect.bottom - rect.top;
2303
2304 if (data->window_rect.left == rect.left && data->window_rect.top == rect.top)
2305 flags |= SWP_NOMOVE;
2306 else
2307 TRACE("%p moving from (%d,%d) to (%d,%d)\n", hwnd, data->window_rect.left,
2308 data->window_rect.top, rect.left, rect.top);
2309
2310 if ((data->window_rect.right - data->window_rect.left == width &&
2311 data->window_rect.bottom - data->window_rect.top == height) ||
2312 (IsRectEmpty(&data->window_rect) && width == 1 && height == 1))
2313 flags |= SWP_NOSIZE;
2314 else
2315 TRACE("%p resizing from (%dx%d) to (%dx%d)\n", hwnd, data->window_rect.right - data->window_rect.left,
2316 data->window_rect.bottom - data->window_rect.top, width, height);
2317
2318 being_dragged = data->drag_event != NULL;
2319 release_win_data(data);
2320
2321 if (event->window_frame_changed.fullscreen)
2322 flags |= SWP_NOSENDCHANGING;
2323 if (!(flags & SWP_NOSIZE) || !(flags & SWP_NOMOVE))
2324 {
2325 if (!event->window_frame_changed.in_resize && !being_dragged)
2326 SendMessageW(hwnd, WM_ENTERSIZEMOVE, 0, 0);
2327 SetWindowPos(hwnd, 0, rect.left, rect.top, width, height, flags);
2328 if (!event->window_frame_changed.in_resize && !being_dragged)
2329 SendMessageW(hwnd, WM_EXITSIZEMOVE, 0, 0);
2330 }
2331 }
2332
2333
2334 /***********************************************************************
2335 * macdrv_window_got_focus
2336 *
2337 * Handler for WINDOW_GOT_FOCUS events.
2338 */
2339 void macdrv_window_got_focus(HWND hwnd, const macdrv_event *event)
2340 {
2341 LONG style = GetWindowLongW(hwnd, GWL_STYLE);
2342
2343 if (!hwnd) return;
2344
2345 TRACE("win %p/%p serial %lu enabled %d visible %d style %08x focus %p active %p fg %p\n",
2346 hwnd, event->window, event->window_got_focus.serial, IsWindowEnabled(hwnd),
2347 IsWindowVisible(hwnd), style, GetFocus(), GetActiveWindow(), GetForegroundWindow());
2348
2349 if (can_activate_window(hwnd) && !(style & WS_MINIMIZE))
2350 {
2351 /* simulate a mouse click on the caption to find out
2352 * whether the window wants to be activated */
2353 LRESULT ma = SendMessageW(hwnd, WM_MOUSEACTIVATE,
2354 (WPARAM)GetAncestor(hwnd, GA_ROOT),
2355 MAKELONG(HTCAPTION,WM_LBUTTONDOWN));
2356 if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
2357 {
2358 TRACE("setting foreground window to %p\n", hwnd);
2359 SetForegroundWindow(hwnd);
2360 return;
2361 }
2362 }
2363
2364 TRACE("win %p/%p rejecting focus\n", hwnd, event->window);
2365 macdrv_window_rejected_focus(event);
2366 }
2367
2368
2369 /***********************************************************************
2370 * macdrv_window_lost_focus
2371 *
2372 * Handler for WINDOW_LOST_FOCUS events.
2373 */
2374 void macdrv_window_lost_focus(HWND hwnd, const macdrv_event *event)
2375 {
2376 if (!hwnd) return;
2377
2378 TRACE("win %p/%p fg %p\n", hwnd, event->window, GetForegroundWindow());
2379
2380 if (hwnd == GetForegroundWindow())
2381 {
2382 SendMessageW(hwnd, WM_CANCELMODE, 0, 0);
2383 if (hwnd == GetForegroundWindow())
2384 SetForegroundWindow(GetDesktopWindow());
2385 }
2386 }
2387
2388
2389 /***********************************************************************
2390 * macdrv_app_activated
2391 *
2392 * Handler for APP_ACTIVATED events.
2393 */
2394 void macdrv_app_activated(void)
2395 {
2396 TRACE("\n");
2397 macdrv_UpdateClipboard();
2398 }
2399
2400
2401 /***********************************************************************
2402 * macdrv_app_deactivated
2403 *
2404 * Handler for APP_DEACTIVATED events.
2405 */
2406 void macdrv_app_deactivated(void)
2407 {
2408 if (GetActiveWindow() == GetForegroundWindow())
2409 {
2410 TRACE("setting fg to desktop\n");
2411 SetForegroundWindow(GetDesktopWindow());
2412 }
2413 }
2414
2415
2416 /***********************************************************************
2417 * macdrv_window_maximize_requested
2418 *
2419 * Handler for WINDOW_MAXIMIZE_REQUESTED events.
2420 */
2421 void macdrv_window_maximize_requested(HWND hwnd)
2422 {
2423 perform_window_command(hwnd, WS_MAXIMIZEBOX, WS_MAXIMIZE, SC_MAXIMIZE, HTMAXBUTTON);
2424 }
2425
2426
2427 /***********************************************************************
2428 * macdrv_window_minimize_requested
2429 *
2430 * Handler for WINDOW_MINIMIZE_REQUESTED events.
2431 */
2432 void macdrv_window_minimize_requested(HWND hwnd)
2433 {
2434 perform_window_command(hwnd, WS_MINIMIZEBOX, WS_MINIMIZE, SC_MINIMIZE, HTMINBUTTON);
2435 }
2436
2437
2438 /***********************************************************************
2439 * macdrv_window_did_unminimize
2440 *
2441 * Handler for WINDOW_DID_UNMINIMIZE events.
2442 */
2443 void macdrv_window_did_unminimize(HWND hwnd)
2444 {
2445 struct macdrv_win_data *data;
2446 DWORD style;
2447
2448 TRACE("win %p\n", hwnd);
2449
2450 if (!(data = get_win_data(hwnd))) return;
2451 if (!data->minimized) goto done;
2452
2453 style = GetWindowLongW(hwnd, GWL_STYLE);
2454
2455 data->minimized = FALSE;
2456 if ((style & (WS_MINIMIZE | WS_VISIBLE)) == (WS_MINIMIZE | WS_VISIBLE))
2457 {
2458 TRACE("restoring win %p/%p\n", hwnd, data->cocoa_window);
2459 release_win_data(data);
2460 SetActiveWindow(hwnd);
2461 SendMessageW(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
2462 return;
2463 }
2464
2465 TRACE("not restoring win %p/%p style %08x\n", hwnd, data->cocoa_window, style);
2466
2467 done:
2468 release_win_data(data);
2469 }
2470
2471
2472 /***********************************************************************
2473 * macdrv_window_brought_forward
2474 *
2475 * Handler for WINDOW_BROUGHT_FORWARD events.
2476 */
2477 void macdrv_window_brought_forward(HWND hwnd)
2478 {
2479 TRACE("win %p\n", hwnd);
2480 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
2481 }
2482
2483
2484 /***********************************************************************
2485 * macdrv_window_resize_ended
2486 *
2487 * Handler for WINDOW_RESIZE_ENDED events.
2488 */
2489 void macdrv_window_resize_ended(HWND hwnd)
2490 {
2491 TRACE("hwnd %p\n", hwnd);
2492 SendMessageW(hwnd, WM_EXITSIZEMOVE, 0, 0);
2493 }
2494
2495
2496 /***********************************************************************
2497 * macdrv_window_restore_requested
2498 *
2499 * Handler for WINDOW_RESTORE_REQUESTED events. This is specifically
2500 * for restoring from maximized, not from minimized.
2501 */
2502 void macdrv_window_restore_requested(HWND hwnd, const macdrv_event *event)
2503 {
2504 if (event->window_restore_requested.keep_frame && hwnd)
2505 {
2506 DWORD style = GetWindowLongW(hwnd, GWL_STYLE);
2507 struct macdrv_win_data *data;
2508
2509 if ((style & WS_MAXIMIZE) && (style & WS_VISIBLE) && (data = get_win_data(hwnd)))
2510 {
2511 RECT rect;
2512 HWND parent = GetAncestor(hwnd, GA_PARENT);
2513
2514 rect = rect_from_cgrect(event->window_restore_requested.frame);
2515 macdrv_mac_to_window_rect(data, &rect);
2516 MapWindowPoints(0, parent, (POINT *)&rect, 2);
2517
2518 release_win_data(data);
2519
2520 SetInternalWindowPos(hwnd, SW_SHOW, &rect, NULL);
2521 }
2522 }
2523
2524 perform_window_command(hwnd, WS_MAXIMIZE, 0, SC_RESTORE, HTMAXBUTTON);
2525 }
2526
2527
2528 /***********************************************************************
2529 * macdrv_window_drag_begin
2530 *
2531 * Handler for WINDOW_DRAG_BEGIN events.
2532 */
2533 void macdrv_window_drag_begin(HWND hwnd, const macdrv_event *event)
2534 {
2535 DWORD style = GetWindowLongW(hwnd, GWL_STYLE);
2536 struct macdrv_win_data *data;
2537 HANDLE drag_event = NULL;
2538 BOOL loop = TRUE;
2539 MSG msg;
2540
2541 TRACE("win %p\n", hwnd);
2542
2543 if (style & (WS_DISABLED | WS_MAXIMIZE | WS_MINIMIZE)) return;
2544 if (!(style & WS_VISIBLE)) return;
2545
2546 if (!(data = get_win_data(hwnd))) return;
2547 if (data->drag_event) goto done;
2548
2549 drag_event = CreateEventW(NULL, TRUE, FALSE, NULL);
2550 if (!drag_event) goto done;
2551
2552 data->drag_event = drag_event;
2553 release_win_data(data);
2554
2555 if (!event->window_drag_begin.no_activate && can_activate_window(hwnd) && GetForegroundWindow() != hwnd)
2556 {
2557 /* ask whether the window wants to be activated */
2558 LRESULT ma = SendMessageW(hwnd, WM_MOUSEACTIVATE, (WPARAM)GetAncestor(hwnd, GA_ROOT),
2559 MAKELONG(HTCAPTION, WM_LBUTTONDOWN));
2560 if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
2561 {
2562 TRACE("setting foreground window to %p\n", hwnd);
2563 SetForegroundWindow(hwnd);
2564 }
2565 }
2566
2567 ClipCursor(NULL);
2568 SendMessageW(hwnd, WM_ENTERSIZEMOVE, 0, 0);
2569 ReleaseCapture();
2570
2571 while (loop)
2572 {
2573 while (!PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
2574 {
2575 DWORD result = MsgWaitForMultipleObjectsEx(1, &drag_event, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE);
2576 if (result == WAIT_OBJECT_0)
2577 {
2578 loop = FALSE;
2579 break;
2580 }
2581 }
2582 if (!loop)
2583 break;
2584
2585 if (msg.message == WM_QUIT)
2586 break;
2587
2588 if (!CallMsgFilterW(&msg, MSGF_SIZE) && msg.message != WM_KEYDOWN &&
2589 msg.message != WM_MOUSEMOVE && msg.message != WM_LBUTTONDOWN && msg.message != WM_LBUTTONUP)
2590 {
2591 TranslateMessage(&msg);
2592 DispatchMessageW(&msg);
2593 }
2594 }
2595
2596 SendMessageW(hwnd, WM_EXITSIZEMOVE, 0, 0);
2597
2598 TRACE("done\n");
2599
2600 if ((data = get_win_data(hwnd)))
2601 data->drag_event = NULL;
2602
2603 done:
2604 release_win_data(data);
2605 if (drag_event) CloseHandle(drag_event);
2606 }
2607
2608
2609 /***********************************************************************
2610 * macdrv_window_drag_end
2611 *
2612 * Handler for WINDOW_DRAG_END events.
2613 */
2614 void macdrv_window_drag_end(HWND hwnd)
2615 {
2616 struct macdrv_win_data *data;
2617
2618 TRACE("win %p\n", hwnd);
2619
2620 if (!(data = get_win_data(hwnd))) return;
2621 if (data->drag_event)
2622 SetEvent(data->drag_event);
2623 release_win_data(data);
2624 }
2625
2626
2627 /***********************************************************************
2628 * macdrv_reassert_window_position
2629 *
2630 * Handler for REASSERT_WINDOW_POSITION events.
2631 */
2632 void macdrv_reassert_window_position(HWND hwnd)
2633 {
2634 struct macdrv_win_data *data = get_win_data(hwnd);
2635 if (data)
2636 {
2637 if (data->cocoa_window && data->on_screen)
2638 sync_window_position(data, SWP_NOZORDER | SWP_NOACTIVATE, NULL, NULL);
2639 release_win_data(data);
2640 }
2641 }
2642
2643
2644 struct quit_info {
2645 HWND *wins;
2646 UINT capacity;
2647 UINT count;
2648 UINT done;
2649 DWORD flags;
2650 BOOL result;
2651 BOOL replied;
2652 };
2653
2654
2655 static BOOL CALLBACK get_process_windows(HWND hwnd, LPARAM lp)
2656 {
2657 struct quit_info *qi = (struct quit_info*)lp;
2658 DWORD pid;
2659
2660 GetWindowThreadProcessId(hwnd, &pid);
2661 if (pid == GetCurrentProcessId())
2662 {
2663 if (qi->count >= qi->capacity)
2664 {
2665 UINT new_cap = qi->capacity * 2;
2666 HWND *new_wins = HeapReAlloc(GetProcessHeap(), 0, qi->wins,
2667 new_cap * sizeof(*qi->wins));
2668 if (!new_wins) return FALSE;
2669 qi->wins = new_wins;
2670 qi->capacity = new_cap;
2671 }
2672
2673 qi->wins[qi->count++] = hwnd;
2674 }
2675
2676 return TRUE;
2677 }
2678
2679
2680 static void CALLBACK quit_callback(HWND hwnd, UINT msg, ULONG_PTR data, LRESULT result)
2681 {
2682 struct quit_info *qi = (struct quit_info*)data;
2683
2684 qi->done++;
2685
2686 if (msg == WM_QUERYENDSESSION)
2687 {
2688 TRACE("got WM_QUERYENDSESSION result %ld from win %p (%u of %u done)\n", result,
2689 hwnd, qi->done, qi->count);
2690
2691 if (!result && !IsWindow(hwnd))
2692 {
2693 TRACE("win %p no longer exists; ignoring apparent refusal\n", hwnd);
2694 result = TRUE;
2695 }
2696
2697 if (!result && qi->result)
2698 {
2699 qi->result = FALSE;
2700
2701 /* On the first FALSE from WM_QUERYENDSESSION, we already know the
2702 ultimate reply. Might as well tell Cocoa now. */
2703 if (!qi->replied)
2704 {
2705 qi->replied = TRUE;
2706 TRACE("giving quit reply %d\n", qi->result);
2707 macdrv_quit_reply(qi->result);
2708 }
2709 }
2710
2711 if (qi->done >= qi->count)
2712 {
2713 UINT i;
2714
2715 qi->done = 0;
2716 for (i = 0; i < qi->count; i++)
2717 {
2718 TRACE("sending WM_ENDSESSION to win %p result %d flags 0x%08x\n", qi->wins[i],
2719 qi->result, qi->flags);
2720 if (!SendMessageCallbackW(qi->wins[i], WM_ENDSESSION, qi->result, qi->flags,
2721 quit_callback, (ULONG_PTR)qi))
2722 {
2723 WARN("failed to send WM_ENDSESSION to win %p; error 0x%08x\n",
2724 qi->wins[i], GetLastError());
2725 quit_callback(qi->wins[i], WM_ENDSESSION, (ULONG_PTR)qi, 0);
2726 }
2727 }
2728 }
2729 }
2730 else /* WM_ENDSESSION */
2731 {
2732 TRACE("finished WM_ENDSESSION for win %p (%u of %u done)\n", hwnd, qi->done, qi->count);
2733
2734 if (qi->done >= qi->count)
2735 {
2736 if (!qi->replied)
2737 {
2738 TRACE("giving quit reply %d\n", qi->result);
2739 macdrv_quit_reply(qi->result);
2740 }
2741
2742 TRACE("%sterminating process\n", qi->result ? "" : "not ");
2743 if (qi->result)
2744 TerminateProcess(GetCurrentProcess(), 0);
2745
2746 HeapFree(GetProcessHeap(), 0, qi->wins);
2747 HeapFree(GetProcessHeap(), 0, qi);
2748 }
2749 }
2750 }
2751
2752
2753 /***********************************************************************
2754 * macdrv_app_quit_requested
2755 *
2756 * Handler for APP_QUIT_REQUESTED events.
2757 */
2758 void macdrv_app_quit_requested(const macdrv_event *event)
2759 {
2760 struct quit_info *qi;
2761 UINT i;
2762
2763 TRACE("reason %d\n", event->app_quit_requested.reason);
2764
2765 qi = HeapAlloc(GetProcessHeap(), 0, sizeof(*qi));
2766 if (!qi)
2767 goto fail;
2768
2769 qi->capacity = 32;
2770 qi->wins = HeapAlloc(GetProcessHeap(), 0, qi->capacity * sizeof(*qi->wins));
2771 qi->count = qi->done = 0;
2772
2773 if (!qi->wins || !EnumWindows(get_process_windows, (LPARAM)qi))
2774 goto fail;
2775
2776 switch (event->app_quit_requested.reason)
2777 {
2778 case QUIT_REASON_LOGOUT:
2779 default:
2780 qi->flags = ENDSESSION_LOGOFF;
2781 break;
2782 case QUIT_REASON_RESTART:
2783 case QUIT_REASON_SHUTDOWN:
2784 qi->flags = 0;
2785 break;
2786 }
2787
2788 qi->result = TRUE;
2789 qi->replied = FALSE;
2790
2791 for (i = 0; i < qi->count; i++)
2792 {
2793 TRACE("sending WM_QUERYENDSESSION to win %p\n", qi->wins[i]);
2794 if (!SendMessageCallbackW(qi->wins[i], WM_QUERYENDSESSION, 0, qi->flags,
2795 quit_callback, (ULONG_PTR)qi))
2796 {
2797 DWORD error = GetLastError();
2798 BOOL invalid = (error == ERROR_INVALID_WINDOW_HANDLE);
2799 if (invalid)
2800 TRACE("failed to send WM_QUERYENDSESSION to win %p because it's invalid; assuming success\n",
2801 qi->wins[i]);
2802 else
2803 WARN("failed to send WM_QUERYENDSESSION to win %p; error 0x%08x; assuming refusal\n",
2804 qi->wins[i], error);
2805 quit_callback(qi->wins[i], WM_QUERYENDSESSION, (ULONG_PTR)qi, invalid);
2806 }
2807 }
2808
2809 /* quit_callback() will clean up qi */
2810 return;
2811
2812 fail:
2813 WARN("failed to allocate window list\n");
2814 if (qi)
2815 {
2816 HeapFree(GetProcessHeap(), 0, qi->wins);
2817 HeapFree(GetProcessHeap(), 0, qi);
2818 }
2819 macdrv_quit_reply(FALSE);
2820 }
2821
2822
2823 /***********************************************************************
2824 * query_resize_size
2825 *
2826 * Handler for QUERY_RESIZE_SIZE query.
2827 */
2828 BOOL query_resize_size(HWND hwnd, macdrv_query *query)
2829 {
2830 struct macdrv_win_data *data = get_win_data(hwnd);
2831 RECT rect = rect_from_cgrect(query->resize_size.rect);
2832 int corner;
2833 BOOL ret = FALSE;
2834
2835 if (!data) return FALSE;
2836
2837 macdrv_mac_to_window_rect(data, &rect);
2838
2839 if (query->resize_size.from_left)
2840 {
2841 if (query->resize_size.from_top)
2842 corner = WMSZ_TOPLEFT;
2843 else
2844 corner = WMSZ_BOTTOMLEFT;
2845 }
2846 else if (query->resize_size.from_top)
2847 corner = WMSZ_TOPRIGHT;
2848 else
2849 corner = WMSZ_BOTTOMRIGHT;
2850
2851 if (SendMessageW(hwnd, WM_SIZING, corner, (LPARAM)&rect))
2852 {
2853 macdrv_window_to_mac_rect(data, GetWindowLongW(hwnd, GWL_STYLE), &rect,
2854 &data->window_rect, &data->client_rect);
2855 query->resize_size.rect = cgrect_from_rect(rect);
2856 ret = TRUE;
2857 }
2858
2859 release_win_data(data);
2860 return ret;
2861 }
2862
2863
2864 /***********************************************************************
2865 * query_resize_start
2866 *
2867 * Handler for QUERY_RESIZE_START query.
2868 */
2869 BOOL query_resize_start(HWND hwnd)
2870 {
2871 TRACE("hwnd %p\n", hwnd);
2872
2873 sync_window_min_max_info(hwnd);
2874 SendMessageW(hwnd, WM_ENTERSIZEMOVE, 0, 0);
2875
2876 return TRUE;
2877 }
2878
2879
2880 /***********************************************************************
2881 * query_min_max_info
2882 *
2883 * Handler for QUERY_MIN_MAX_INFO query.
2884 */
2885 BOOL query_min_max_info(HWND hwnd)
2886 {
2887 TRACE("hwnd %p\n", hwnd);
2888 sync_window_min_max_info(hwnd);
2889 return TRUE;
2890 }
Windows API implementation