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