?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Implement onprogress for XMLHttpRequest.
[wine.git] / dlls / wineandroid.drv / window.c
blob6b019445805e57d3bcc397649d779799f9b9e85e
1 /*
2 * Window related functions
3 *
4 * Copyright 1993, 1994, 1995, 1996, 2001, 2013-2017 Alexandre Julliard
5 * Copyright 1993 David Metcalfe
6 * Copyright 1995, 1996 Alex Korobka
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #define NONAMELESSUNION
24 #define NONAMELESSSTRUCT
25
26 #include "config.h"
27
28 #include <assert.h>
29 #include <fcntl.h>
30 #include <poll.h>
31 #include <errno.h>
32 #include <stdarg.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <unistd.h>
36
37 #define OEMRESOURCE
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wingdi.h"
41 #include "winuser.h"
42
43 #include "android.h"
44 #include "wine/server.h"
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(android);
48
49 /* private window data */
50 struct android_win_data
51 {
52 HWND hwnd; /* hwnd that this private data belongs to */
53 HWND parent; /* parent hwnd for child windows */
54 RECT window_rect; /* USER window rectangle relative to parent */
55 RECT whole_rect; /* X window rectangle for the whole window relative to parent */
56 RECT client_rect; /* client area relative to parent */
57 ANativeWindow *window; /* native window wrapper that forwards calls to the desktop process */
58 struct window_surface *surface;
59 };
60
61 #define SWP_AGG_NOPOSCHANGE (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
62
63 static CRITICAL_SECTION win_data_section;
64 static CRITICAL_SECTION_DEBUG critsect_debug =
65 {
66 0, 0, &win_data_section,
67 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
68 0, 0, { (DWORD_PTR)(__FILE__ ": win_data_section") }
69 };
70 static CRITICAL_SECTION win_data_section = { &critsect_debug, -1, 0, 0, 0, 0 };
71
72 static struct android_win_data *win_data_context[32768];
73
74 static inline int context_idx( HWND hwnd )
75 {
76 return LOWORD( hwnd ) >> 1;
77 }
78
79 static void set_surface_region( struct window_surface *window_surface, HRGN win_region );
80
81 /* only for use on sanitized BITMAPINFO structures */
82 static inline int get_dib_info_size( const BITMAPINFO *info, UINT coloruse )
83 {
84 if (info->bmiHeader.biCompression == BI_BITFIELDS)
85 return sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD);
86 if (coloruse == DIB_PAL_COLORS)
87 return sizeof(BITMAPINFOHEADER) + info->bmiHeader.biClrUsed * sizeof(WORD);
88 return FIELD_OFFSET( BITMAPINFO, bmiColors[info->bmiHeader.biClrUsed] );
89 }
90
91 static inline int get_dib_stride( int width, int bpp )
92 {
93 return ((width * bpp + 31) >> 3) & ~3;
94 }
95
96 static inline int get_dib_image_size( const BITMAPINFO *info )
97 {
98 return get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount )
99 * abs( info->bmiHeader.biHeight );
100 }
101
102 static BOOL intersect_rect( RECT *dst, const RECT *src1, const RECT *src2 )
103 {
104 dst->left = max(src1->left, src2->left);
105 dst->top = max(src1->top, src2->top);
106 dst->right = min(src1->right, src2->right);
107 dst->bottom = min(src1->bottom, src2->bottom);
108 return !IsRectEmpty( dst );
109 }
110
111
112 /**********************************************************************
113 * get_win_monitor_dpi
114 */
115 static UINT get_win_monitor_dpi( HWND hwnd )
116 {
117 return NtUserGetSystemDpiForProcess( NULL ); /* FIXME: get monitor dpi */
118 }
119
120
121 /***********************************************************************
122 * alloc_win_data
123 */
124 static struct android_win_data *alloc_win_data( HWND hwnd )
125 {
126 struct android_win_data *data;
127
128 if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
129 {
130 data->hwnd = hwnd;
131 data->window = create_ioctl_window( hwnd, FALSE,
132 (float)get_win_monitor_dpi( hwnd ) / NtUserGetDpiForWindow( hwnd ));
133 EnterCriticalSection( &win_data_section );
134 win_data_context[context_idx(hwnd)] = data;
135 }
136 return data;
137 }
138
139
140 /***********************************************************************
141 * free_win_data
142 */
143 static void free_win_data( struct android_win_data *data )
144 {
145 win_data_context[context_idx( data->hwnd )] = NULL;
146 LeaveCriticalSection( &win_data_section );
147 if (data->window) release_ioctl_window( data->window );
148 HeapFree( GetProcessHeap(), 0, data );
149 }
150
151
152 /***********************************************************************
153 * get_win_data
154 *
155 * Lock and return the data structure associated with a window.
156 */
157 static struct android_win_data *get_win_data( HWND hwnd )
158 {
159 struct android_win_data *data;
160
161 if (!hwnd) return NULL;
162 EnterCriticalSection( &win_data_section );
163 if ((data = win_data_context[context_idx(hwnd)]) && data->hwnd == hwnd) return data;
164 LeaveCriticalSection( &win_data_section );
165 return NULL;
166 }
167
168
169 /***********************************************************************
170 * release_win_data
171 *
172 * Release the data returned by get_win_data.
173 */
174 static void release_win_data( struct android_win_data *data )
175 {
176 if (data) LeaveCriticalSection( &win_data_section );
177 }
178
179
180 /***********************************************************************
181 * get_ioctl_window
182 */
183 static struct ANativeWindow *get_ioctl_window( HWND hwnd )
184 {
185 struct ANativeWindow *ret;
186 struct android_win_data *data = get_win_data( hwnd );
187
188 if (!data || !data->window) return NULL;
189 ret = grab_ioctl_window( data->window );
190 release_win_data( data );
191 return ret;
192 }
193
194
195 /* Handling of events coming from the Java side */
196
197 struct java_event
198 {
199 struct list entry;
200 union event_data data;
201 };
202
203 static struct list event_queue = LIST_INIT( event_queue );
204 static struct java_event *current_event;
205 static int event_pipe[2];
206 static DWORD desktop_tid;
207
208 /***********************************************************************
209 * send_event
210 */
211 int send_event( const union event_data *data )
212 {
213 int res;
214
215 if ((res = write( event_pipe[1], data, sizeof(*data) )) != sizeof(*data))
216 {
217 p__android_log_print( ANDROID_LOG_ERROR, "wine", "failed to send event" );
218 return -1;
219 }
220 return 0;
221 }
222
223
224 /***********************************************************************
225 * desktop_changed
226 *
227 * JNI callback, runs in the context of the Java thread.
228 */
229 void desktop_changed( JNIEnv *env, jobject obj, jint width, jint height )
230 {
231 union event_data data;
232
233 memset( &data, 0, sizeof(data) );
234 data.type = DESKTOP_CHANGED;
235 data.desktop.width = width;
236 data.desktop.height = height;
237 p__android_log_print( ANDROID_LOG_INFO, "wine", "desktop_changed: %ux%u", width, height );
238 send_event( &data );
239 }
240
241
242 /***********************************************************************
243 * config_changed
244 *
245 * JNI callback, runs in the context of the Java thread.
246 */
247 void config_changed( JNIEnv *env, jobject obj, jint dpi )
248 {
249 union event_data data;
250
251 memset( &data, 0, sizeof(data) );
252 data.type = CONFIG_CHANGED;
253 data.cfg.dpi = dpi;
254 p__android_log_print( ANDROID_LOG_INFO, "wine", "config_changed: %u dpi", dpi );
255 send_event( &data );
256 }
257
258
259 /***********************************************************************
260 * surface_changed
261 *
262 * JNI callback, runs in the context of the Java thread.
263 */
264 void surface_changed( JNIEnv *env, jobject obj, jint win, jobject surface, jboolean client )
265 {
266 union event_data data;
267
268 memset( &data, 0, sizeof(data) );
269 data.surface.hwnd = LongToHandle( win );
270 data.surface.client = client;
271 if (surface)
272 {
273 int width, height;
274 ANativeWindow *win = pANativeWindow_fromSurface( env, surface );
275
276 if (win->query( win, NATIVE_WINDOW_WIDTH, &width ) < 0) width = 0;
277 if (win->query( win, NATIVE_WINDOW_HEIGHT, &height ) < 0) height = 0;
278 data.surface.window = win;
279 data.surface.width = width;
280 data.surface.height = height;
281 p__android_log_print( ANDROID_LOG_INFO, "wine", "surface_changed: %p %s %ux%u",
282 data.surface.hwnd, client ? "client" : "whole", width, height );
283 }
284 data.type = SURFACE_CHANGED;
285 send_event( &data );
286 }
287
288
289 /***********************************************************************
290 * motion_event
291 *
292 * JNI callback, runs in the context of the Java thread.
293 */
294 jboolean motion_event( JNIEnv *env, jobject obj, jint win, jint action, jint x, jint y, jint state, jint vscroll )
295 {
296 static LONG button_state;
297 union event_data data;
298 int prev_state;
299
300 int mask = action & AMOTION_EVENT_ACTION_MASK;
301
302 if (!( mask == AMOTION_EVENT_ACTION_DOWN ||
303 mask == AMOTION_EVENT_ACTION_UP ||
304 mask == AMOTION_EVENT_ACTION_CANCEL ||
305 mask == AMOTION_EVENT_ACTION_SCROLL ||
306 mask == AMOTION_EVENT_ACTION_MOVE ||
307 mask == AMOTION_EVENT_ACTION_HOVER_MOVE ||
308 mask == AMOTION_EVENT_ACTION_BUTTON_PRESS ||
309 mask == AMOTION_EVENT_ACTION_BUTTON_RELEASE ))
310 return JNI_FALSE;
311
312 /* make sure a subsequent AMOTION_EVENT_ACTION_UP is not treated as a touch event */
313 if (mask == AMOTION_EVENT_ACTION_BUTTON_RELEASE) state |= 0x80000000;
314
315 prev_state = InterlockedExchange( &button_state, state );
316
317 data.type = MOTION_EVENT;
318 data.motion.hwnd = LongToHandle( win );
319 data.motion.input.type = INPUT_MOUSE;
320 data.motion.input.u.mi.dx = x;
321 data.motion.input.u.mi.dy = y;
322 data.motion.input.u.mi.mouseData = 0;
323 data.motion.input.u.mi.time = 0;
324 data.motion.input.u.mi.dwExtraInfo = 0;
325 data.motion.input.u.mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
326 switch (action & AMOTION_EVENT_ACTION_MASK)
327 {
328 case AMOTION_EVENT_ACTION_DOWN:
329 case AMOTION_EVENT_ACTION_BUTTON_PRESS:
330 if ((state & ~prev_state) & AMOTION_EVENT_BUTTON_PRIMARY)
331 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
332 if ((state & ~prev_state) & AMOTION_EVENT_BUTTON_SECONDARY)
333 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
334 if ((state & ~prev_state) & AMOTION_EVENT_BUTTON_TERTIARY)
335 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
336 if (!(state & ~prev_state)) /* touch event */
337 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
338 break;
339 case AMOTION_EVENT_ACTION_UP:
340 case AMOTION_EVENT_ACTION_CANCEL:
341 case AMOTION_EVENT_ACTION_BUTTON_RELEASE:
342 if ((prev_state & ~state) & AMOTION_EVENT_BUTTON_PRIMARY)
343 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
344 if ((prev_state & ~state) & AMOTION_EVENT_BUTTON_SECONDARY)
345 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
346 if ((prev_state & ~state) & AMOTION_EVENT_BUTTON_TERTIARY)
347 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
348 if (!(prev_state & ~state)) /* touch event */
349 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
350 break;
351 case AMOTION_EVENT_ACTION_SCROLL:
352 data.motion.input.u.mi.dwFlags |= MOUSEEVENTF_WHEEL;
353 data.motion.input.u.mi.mouseData = vscroll < 0 ? -WHEEL_DELTA : WHEEL_DELTA;
354 break;
355 case AMOTION_EVENT_ACTION_MOVE:
356 case AMOTION_EVENT_ACTION_HOVER_MOVE:
357 break;
358 default:
359 return JNI_FALSE;
360 }
361 send_event( &data );
362 return JNI_TRUE;
363 }
364
365
366 /***********************************************************************
367 * init_event_queue
368 */
369 static void init_event_queue(void)
370 {
371 HANDLE handle;
372 int ret;
373
374 if (pipe2( event_pipe, O_CLOEXEC | O_NONBLOCK ) == -1)
375 {
376 ERR( "could not create data\n" );
377 ExitProcess(1);
378 }
379 if (wine_server_fd_to_handle( event_pipe[0], GENERIC_READ | SYNCHRONIZE, 0, &handle ))
380 {
381 ERR( "Can't allocate handle for event fd\n" );
382 ExitProcess(1);
383 }
384 SERVER_START_REQ( set_queue_fd )
385 {
386 req->handle = wine_server_obj_handle( handle );
387 ret = wine_server_call( req );
388 }
389 SERVER_END_REQ;
390 if (ret)
391 {
392 ERR( "Can't store handle for event fd %x\n", ret );
393 ExitProcess(1);
394 }
395 CloseHandle( handle );
396 desktop_tid = GetCurrentThreadId();
397 }
398
399
400 /***********************************************************************
401 * pull_events
402 *
403 * Pull events from the event pipe and add them to the queue
404 */
405 static void pull_events(void)
406 {
407 struct java_event *event;
408 int res;
409
410 for (;;)
411 {
412 if (!(event = HeapAlloc( GetProcessHeap(), 0, sizeof(*event) ))) break;
413
414 res = read( event_pipe[0], &event->data, sizeof(event->data) );
415 if (res != sizeof(event->data)) break;
416 list_add_tail( &event_queue, &event->entry );
417 }
418 HeapFree( GetProcessHeap(), 0, event );
419 }
420
421
422 /***********************************************************************
423 * process_events
424 */
425 static int process_events( DWORD mask )
426 {
427 DPI_AWARENESS_CONTEXT context;
428 struct java_event *event, *next, *previous;
429 unsigned int count = 0;
430
431 assert( GetCurrentThreadId() == desktop_tid );
432
433 pull_events();
434
435 previous = current_event;
436
437 LIST_FOR_EACH_ENTRY_SAFE( event, next, &event_queue, struct java_event, entry )
438 {
439 switch (event->data.type)
440 {
441 case SURFACE_CHANGED:
442 break; /* always process it to unblock other threads */
443 case MOTION_EVENT:
444 if (event->data.motion.input.u.mi.dwFlags & (MOUSEEVENTF_LEFTDOWN|MOUSEEVENTF_RIGHTDOWN|
445 MOUSEEVENTF_MIDDLEDOWN|MOUSEEVENTF_LEFTUP|
446 MOUSEEVENTF_RIGHTUP|MOUSEEVENTF_MIDDLEUP))
447 {
448 if (mask & QS_MOUSEBUTTON) break;
449 }
450 else if (mask & QS_MOUSEMOVE) break;
451 continue; /* skip it */
452 case KEYBOARD_EVENT:
453 if (mask & QS_KEY) break;
454 continue; /* skip it */
455 default:
456 if (mask & QS_SENDMESSAGE) break;
457 continue; /* skip it */
458 }
459
460 /* remove it first, in case we process events recursively */
461 list_remove( &event->entry );
462 current_event = event;
463
464 switch (event->data.type)
465 {
466 case DESKTOP_CHANGED:
467 TRACE( "DESKTOP_CHANGED %ux%u\n", event->data.desktop.width, event->data.desktop.height );
468 context = SetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE );
469 screen_width = event->data.desktop.width;
470 screen_height = event->data.desktop.height;
471 init_monitors( screen_width, screen_height );
472 NtUserSetWindowPos( NtUserGetDesktopWindow(), 0, 0, 0, screen_width, screen_height,
473 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW );
474 SetThreadDpiAwarenessContext( context );
475 break;
476
477 case CONFIG_CHANGED:
478 TRACE( "CONFIG_CHANGED dpi %u\n", event->data.cfg.dpi );
479 set_screen_dpi( event->data.cfg.dpi );
480 break;
481
482 case SURFACE_CHANGED:
483 TRACE("SURFACE_CHANGED %p %p %s size %ux%u\n", event->data.surface.hwnd,
484 event->data.surface.window, event->data.surface.client ? "client" : "whole",
485 event->data.surface.width, event->data.surface.height );
486
487 register_native_window( event->data.surface.hwnd, event->data.surface.window, event->data.surface.client );
488 break;
489
490 case MOTION_EVENT:
491 {
492 HWND capture = get_capture_window();
493
494 if (event->data.motion.input.u.mi.dwFlags & (MOUSEEVENTF_LEFTDOWN|MOUSEEVENTF_RIGHTDOWN|MOUSEEVENTF_MIDDLEDOWN))
495 TRACE( "BUTTONDOWN pos %d,%d hwnd %p flags %x\n",
496 event->data.motion.input.u.mi.dx, event->data.motion.input.u.mi.dy,
497 event->data.motion.hwnd, event->data.motion.input.u.mi.dwFlags );
498 else if (event->data.motion.input.u.mi.dwFlags & (MOUSEEVENTF_LEFTUP|MOUSEEVENTF_RIGHTUP|MOUSEEVENTF_MIDDLEUP))
499 TRACE( "BUTTONUP pos %d,%d hwnd %p flags %x\n",
500 event->data.motion.input.u.mi.dx, event->data.motion.input.u.mi.dy,
501 event->data.motion.hwnd, event->data.motion.input.u.mi.dwFlags );
502 else
503 TRACE( "MOUSEMOVE pos %d,%d hwnd %p flags %x\n",
504 event->data.motion.input.u.mi.dx, event->data.motion.input.u.mi.dy,
505 event->data.motion.hwnd, event->data.motion.input.u.mi.dwFlags );
506 if (!capture && (event->data.motion.input.u.mi.dwFlags & MOUSEEVENTF_ABSOLUTE))
507 {
508 RECT rect;
509 SetRect( &rect, event->data.motion.input.u.mi.dx, event->data.motion.input.u.mi.dy,
510 event->data.motion.input.u.mi.dx + 1, event->data.motion.input.u.mi.dy + 1 );
511
512 SERVER_START_REQ( update_window_zorder )
513 {
514 req->window = wine_server_user_handle( event->data.motion.hwnd );
515 req->rect.left = rect.left;
516 req->rect.top = rect.top;
517 req->rect.right = rect.right;
518 req->rect.bottom = rect.bottom;
519 wine_server_call( req );
520 }
521 SERVER_END_REQ;
522 }
523 __wine_send_input( capture ? capture : event->data.motion.hwnd, &event->data.motion.input, NULL );
524 }
525 break;
526
527 case KEYBOARD_EVENT:
528 if (event->data.kbd.input.u.ki.dwFlags & KEYEVENTF_KEYUP)
529 TRACE("KEYUP hwnd %p vkey %x '%c' scancode %x\n", event->data.kbd.hwnd,
530 event->data.kbd.input.u.ki.wVk, event->data.kbd.input.u.ki.wVk,
531 event->data.kbd.input.u.ki.wScan );
532 else
533 TRACE("KEYDOWN hwnd %p vkey %x '%c' scancode %x\n", event->data.kbd.hwnd,
534 event->data.kbd.input.u.ki.wVk, event->data.kbd.input.u.ki.wVk,
535 event->data.kbd.input.u.ki.wScan );
536 update_keyboard_lock_state( event->data.kbd.input.u.ki.wVk, event->data.kbd.lock_state );
537 __wine_send_input( 0, &event->data.kbd.input, NULL );
538 break;
539
540 default:
541 FIXME( "got event %u\n", event->data.type );
542 }
543 HeapFree( GetProcessHeap(), 0, event );
544 count++;
545 /* next may have been removed by a recursive call, so reset it to the beginning of the list */
546 next = LIST_ENTRY( event_queue.next, struct java_event, entry );
547 }
548 current_event = previous;
549 return count;
550 }
551
552
553 /***********************************************************************
554 * wait_events
555 */
556 static int wait_events( int timeout )
557 {
558 assert( GetCurrentThreadId() == desktop_tid );
559
560 for (;;)
561 {
562 struct pollfd pollfd;
563 int ret;
564
565 pollfd.fd = event_pipe[0];
566 pollfd.events = POLLIN | POLLHUP;
567 ret = poll( &pollfd, 1, timeout );
568 if (ret == -1 && errno == EINTR) continue;
569 if (ret && (pollfd.revents & (POLLHUP | POLLERR))) ret = -1;
570 return ret;
571 }
572 }
573
574
575 /* Window surface support */
576
577 struct android_window_surface
578 {
579 struct window_surface header;
580 HWND hwnd;
581 ANativeWindow *window;
582 RECT bounds;
583 BOOL byteswap;
584 RGNDATA *region_data;
585 HRGN region;
586 BYTE alpha;
587 COLORREF color_key;
588 void *bits;
589 CRITICAL_SECTION crit;
590 BITMAPINFO info; /* variable size, must be last */
591 };
592
593 static struct android_window_surface *get_android_surface( struct window_surface *surface )
594 {
595 return (struct android_window_surface *)surface;
596 }
597
598 static inline void reset_bounds( RECT *bounds )
599 {
600 bounds->left = bounds->top = INT_MAX;
601 bounds->right = bounds->bottom = INT_MIN;
602 }
603
604 static inline void add_bounds_rect( RECT *bounds, const RECT *rect )
605 {
606 if (rect->left >= rect->right || rect->top >= rect->bottom) return;
607 bounds->left = min( bounds->left, rect->left );
608 bounds->top = min( bounds->top, rect->top );
609 bounds->right = max( bounds->right, rect->right );
610 bounds->bottom = max( bounds->bottom, rect->bottom );
611 }
612
613 /* store the palette or color mask data in the bitmap info structure */
614 static void set_color_info( BITMAPINFO *info, BOOL has_alpha )
615 {
616 DWORD *colors = (DWORD *)info->bmiColors;
617
618 info->bmiHeader.biSize = sizeof(info->bmiHeader);
619 info->bmiHeader.biClrUsed = 0;
620 info->bmiHeader.biBitCount = 32;
621 if (has_alpha)
622 {
623 info->bmiHeader.biCompression = BI_RGB;
624 return;
625 }
626 info->bmiHeader.biCompression = BI_BITFIELDS;
627 colors[0] = 0xff0000;
628 colors[1] = 0x00ff00;
629 colors[2] = 0x0000ff;
630 }
631
632 /* apply the window region to a single line of the destination image. */
633 static void apply_line_region( DWORD *dst, int width, int x, int y, const RECT *rect, const RECT *end )
634 {
635 while (rect < end && rect->top <= y && width > 0)
636 {
637 if (rect->left > x)
638 {
639 memset( dst, 0, min( rect->left - x, width ) * sizeof(*dst) );
640 dst += rect->left - x;
641 width -= rect->left - x;
642 x = rect->left;
643 }
644 if (rect->right > x)
645 {
646 dst += rect->right - x;
647 width -= rect->right - x;
648 x = rect->right;
649 }
650 rect++;
651 }
652 if (width > 0) memset( dst, 0, width * sizeof(*dst) );
653 }
654
655 /***********************************************************************
656 * android_surface_lock
657 */
658 static void android_surface_lock( struct window_surface *window_surface )
659 {
660 struct android_window_surface *surface = get_android_surface( window_surface );
661
662 EnterCriticalSection( &surface->crit );
663 }
664
665 /***********************************************************************
666 * android_surface_unlock
667 */
668 static void android_surface_unlock( struct window_surface *window_surface )
669 {
670 struct android_window_surface *surface = get_android_surface( window_surface );
671
672 LeaveCriticalSection( &surface->crit );
673 }
674
675 /***********************************************************************
676 * android_surface_get_bitmap_info
677 */
678 static void *android_surface_get_bitmap_info( struct window_surface *window_surface, BITMAPINFO *info )
679 {
680 struct android_window_surface *surface = get_android_surface( window_surface );
681
682 memcpy( info, &surface->info, get_dib_info_size( &surface->info, DIB_RGB_COLORS ));
683 return surface->bits;
684 }
685
686 /***********************************************************************
687 * android_surface_get_bounds
688 */
689 static RECT *android_surface_get_bounds( struct window_surface *window_surface )
690 {
691 struct android_window_surface *surface = get_android_surface( window_surface );
692
693 return &surface->bounds;
694 }
695
696 /***********************************************************************
697 * android_surface_set_region
698 */
699 static void android_surface_set_region( struct window_surface *window_surface, HRGN region )
700 {
701 struct android_window_surface *surface = get_android_surface( window_surface );
702
703 TRACE( "updating surface %p hwnd %p with %p\n", surface, surface->hwnd, region );
704
705 window_surface->funcs->lock( window_surface );
706 if (!region)
707 {
708 if (surface->region) NtGdiDeleteObjectApp( surface->region );
709 surface->region = 0;
710 }
711 else
712 {
713 if (!surface->region) surface->region = NtGdiCreateRectRgn( 0, 0, 0, 0 );
714 NtGdiCombineRgn( surface->region, region, 0, RGN_COPY );
715 }
716 window_surface->funcs->unlock( window_surface );
717 set_surface_region( &surface->header, (HRGN)1 );
718 }
719
720 /***********************************************************************
721 * android_surface_flush
722 */
723 static void android_surface_flush( struct window_surface *window_surface )
724 {
725 struct android_window_surface *surface = get_android_surface( window_surface );
726 ANativeWindow_Buffer buffer;
727 ARect rc;
728 RECT rect;
729 BOOL needs_flush;
730
731 window_surface->funcs->lock( window_surface );
732 SetRect( &rect, 0, 0, surface->header.rect.right - surface->header.rect.left,
733 surface->header.rect.bottom - surface->header.rect.top );
734 needs_flush = intersect_rect( &rect, &rect, &surface->bounds );
735 reset_bounds( &surface->bounds );
736 window_surface->funcs->unlock( window_surface );
737 if (!needs_flush) return;
738
739 TRACE( "flushing %p hwnd %p surface %s rect %s bits %p alpha %02x key %08x region %u rects\n",
740 surface, surface->hwnd, wine_dbgstr_rect( &surface->header.rect ),
741 wine_dbgstr_rect( &rect ), surface->bits, surface->alpha, surface->color_key,
742 surface->region_data ? surface->region_data->rdh.nCount : 0 );
743
744 rc.left = rect.left;
745 rc.top = rect.top;
746 rc.right = rect.right;
747 rc.bottom = rect.bottom;
748
749 if (!surface->window->perform( surface->window, NATIVE_WINDOW_LOCK, &buffer, &rc ))
750 {
751 const RECT *rgn_rect = NULL, *end = NULL;
752 unsigned int *src, *dst;
753 int x, y, width;
754
755 rect.left = rc.left;
756 rect.top = rc.top;
757 rect.right = rc.right;
758 rect.bottom = rc.bottom;
759 intersect_rect( &rect, &rect, &surface->header.rect );
760
761 if (surface->region_data)
762 {
763 rgn_rect = (RECT *)surface->region_data->Buffer;
764 end = rgn_rect + surface->region_data->rdh.nCount;
765 }
766 src = (unsigned int *)surface->bits
767 + (rect.top - surface->header.rect.top) * surface->info.bmiHeader.biWidth
768 + (rect.left - surface->header.rect.left);
769 dst = (unsigned int *)buffer.bits + rect.top * buffer.stride + rect.left;
770 width = min( rect.right - rect.left, buffer.stride );
771
772 for (y = rect.top; y < min( buffer.height, rect.bottom); y++)
773 {
774 if (surface->info.bmiHeader.biCompression == BI_RGB)
775 memcpy( dst, src, width * sizeof(*dst) );
776 else if (surface->alpha == 255)
777 for (x = 0; x < width; x++) dst[x] = src[x] | 0xff000000;
778 else
779 for (x = 0; x < width; x++)
780 dst[x] = ((surface->alpha << 24) |
781 (((BYTE)(src[x] >> 16) * surface->alpha / 255) << 16) |
782 (((BYTE)(src[x] >> 8) * surface->alpha / 255) << 8) |
783 (((BYTE)src[x] * surface->alpha / 255)));
784
785 if (surface->color_key != CLR_INVALID)
786 for (x = 0; x < width; x++) if ((src[x] & 0xffffff) == surface->color_key) dst[x] = 0;
787
788 if (rgn_rect)
789 {
790 while (rgn_rect < end && rgn_rect->bottom <= y) rgn_rect++;
791 apply_line_region( dst, width, rect.left, y, rgn_rect, end );
792 }
793
794 src += surface->info.bmiHeader.biWidth;
795 dst += buffer.stride;
796 }
797 surface->window->perform( surface->window, NATIVE_WINDOW_UNLOCK_AND_POST );
798 }
799 else TRACE( "Unable to lock surface %p window %p buffer %p\n",
800 surface, surface->hwnd, surface->window );
801 }
802
803 /***********************************************************************
804 * android_surface_destroy
805 */
806 static void android_surface_destroy( struct window_surface *window_surface )
807 {
808 struct android_window_surface *surface = get_android_surface( window_surface );
809
810 TRACE( "freeing %p bits %p\n", surface, surface->bits );
811
812 surface->crit.DebugInfo->Spare[0] = 0;
813 DeleteCriticalSection( &surface->crit );
814 HeapFree( GetProcessHeap(), 0, surface->region_data );
815 if (surface->region) NtGdiDeleteObjectApp( surface->region );
816 release_ioctl_window( surface->window );
817 HeapFree( GetProcessHeap(), 0, surface->bits );
818 HeapFree( GetProcessHeap(), 0, surface );
819 }
820
821 static const struct window_surface_funcs android_surface_funcs =
822 {
823 android_surface_lock,
824 android_surface_unlock,
825 android_surface_get_bitmap_info,
826 android_surface_get_bounds,
827 android_surface_set_region,
828 android_surface_flush,
829 android_surface_destroy
830 };
831
832 static BOOL is_argb_surface( struct window_surface *surface )
833 {
834 return surface && surface->funcs == &android_surface_funcs &&
835 get_android_surface( surface )->info.bmiHeader.biCompression == BI_RGB;
836 }
837
838 /***********************************************************************
839 * set_color_key
840 */
841 static void set_color_key( struct android_window_surface *surface, COLORREF key )
842 {
843 if (key == CLR_INVALID)
844 surface->color_key = CLR_INVALID;
845 else if (surface->info.bmiHeader.biBitCount <= 8)
846 surface->color_key = CLR_INVALID;
847 else if (key & (1 << 24)) /* PALETTEINDEX */
848 surface->color_key = 0;
849 else if (key >> 16 == 0x10ff) /* DIBINDEX */
850 surface->color_key = 0;
851 else if (surface->info.bmiHeader.biBitCount == 24)
852 surface->color_key = key;
853 else
854 surface->color_key = (GetRValue(key) << 16) | (GetGValue(key) << 8) | GetBValue(key);
855 }
856
857 /***********************************************************************
858 * set_surface_region
859 */
860 static void set_surface_region( struct window_surface *window_surface, HRGN win_region )
861 {
862 struct android_window_surface *surface = get_android_surface( window_surface );
863 struct android_win_data *win_data;
864 HRGN region = win_region;
865 RGNDATA *data = NULL;
866 DWORD size;
867 int offset_x, offset_y;
868
869 if (window_surface->funcs != &android_surface_funcs) return; /* we may get the null surface */
870
871 if (!(win_data = get_win_data( surface->hwnd ))) return;
872 offset_x = win_data->window_rect.left - win_data->whole_rect.left;
873 offset_y = win_data->window_rect.top - win_data->whole_rect.top;
874 release_win_data( win_data );
875
876 if (win_region == (HRGN)1) /* hack: win_region == 1 means retrieve region from server */
877 {
878 region = NtGdiCreateRectRgn( 0, 0, win_data->window_rect.right - win_data->window_rect.left,
879 win_data->window_rect.bottom - win_data->window_rect.top );
880 if (NtUserGetWindowRgnEx( surface->hwnd, region, 0 ) == ERROR && !surface->region) goto done;
881 }
882
883 NtGdiOffsetRgn( region, offset_x, offset_y );
884 if (surface->region) NtGdiCombineRgn( region, region, surface->region, RGN_AND );
885
886 if (!(size = NtGdiGetRegionData( region, 0, NULL ))) goto done;
887 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) goto done;
888
889 if (!NtGdiGetRegionData( region, size, data ))
890 {
891 HeapFree( GetProcessHeap(), 0, data );
892 data = NULL;
893 }
894
895 done:
896 window_surface->funcs->lock( window_surface );
897 HeapFree( GetProcessHeap(), 0, surface->region_data );
898 surface->region_data = data;
899 *window_surface->funcs->get_bounds( window_surface ) = surface->header.rect;
900 window_surface->funcs->unlock( window_surface );
901 if (region != win_region) NtGdiDeleteObjectApp( region );
902 }
903
904 /***********************************************************************
905 * create_surface
906 */
907 static struct window_surface *create_surface( HWND hwnd, const RECT *rect,
908 BYTE alpha, COLORREF color_key, BOOL src_alpha )
909 {
910 struct android_window_surface *surface;
911 int width = rect->right - rect->left, height = rect->bottom - rect->top;
912
913 surface = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
914 FIELD_OFFSET( struct android_window_surface, info.bmiColors[3] ));
915 if (!surface) return NULL;
916 set_color_info( &surface->info, src_alpha );
917 surface->info.bmiHeader.biWidth = width;
918 surface->info.bmiHeader.biHeight = -height; /* top-down */
919 surface->info.bmiHeader.biPlanes = 1;
920 surface->info.bmiHeader.biSizeImage = get_dib_image_size( &surface->info );
921
922 InitializeCriticalSection( &surface->crit );
923 surface->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": surface");
924
925 surface->header.funcs = &android_surface_funcs;
926 surface->header.rect = *rect;
927 surface->header.ref = 1;
928 surface->hwnd = hwnd;
929 surface->window = get_ioctl_window( hwnd );
930 surface->alpha = alpha;
931 set_color_key( surface, color_key );
932 set_surface_region( &surface->header, (HRGN)1 );
933 reset_bounds( &surface->bounds );
934
935 if (!(surface->bits = HeapAlloc( GetProcessHeap(), 0, surface->info.bmiHeader.biSizeImage )))
936 goto failed;
937
938 TRACE( "created %p hwnd %p %s bits %p-%p\n", surface, hwnd, wine_dbgstr_rect(rect),
939 surface->bits, (char *)surface->bits + surface->info.bmiHeader.biSizeImage );
940
941 return &surface->header;
942
943 failed:
944 android_surface_destroy( &surface->header );
945 return NULL;
946 }
947
948 /***********************************************************************
949 * set_surface_layered
950 */
951 static void set_surface_layered( struct window_surface *window_surface, BYTE alpha, COLORREF color_key )
952 {
953 struct android_window_surface *surface = get_android_surface( window_surface );
954 COLORREF prev_key;
955 BYTE prev_alpha;
956
957 if (window_surface->funcs != &android_surface_funcs) return; /* we may get the null surface */
958
959 window_surface->funcs->lock( window_surface );
960 prev_key = surface->color_key;
961 prev_alpha = surface->alpha;
962 surface->alpha = alpha;
963 set_color_key( surface, color_key );
964 if (alpha != prev_alpha || surface->color_key != prev_key) /* refresh */
965 *window_surface->funcs->get_bounds( window_surface ) = surface->header.rect;
966 window_surface->funcs->unlock( window_surface );
967 }
968
969 /***********************************************************************
970 * get_mono_icon_argb
971 *
972 * Return a monochrome icon/cursor bitmap bits in ARGB format.
973 */
974 static unsigned int *get_mono_icon_argb( HDC hdc, HBITMAP bmp, unsigned int *width, unsigned int *height )
975 {
976 BITMAP bm;
977 char *mask;
978 unsigned int i, j, stride, mask_size, bits_size, *bits = NULL, *ptr;
979
980 if (!NtGdiExtGetObjectW( bmp, sizeof(bm), &bm )) return NULL;
981 stride = ((bm.bmWidth + 15) >> 3) & ~1;
982 mask_size = stride * bm.bmHeight;
983 if (!(mask = HeapAlloc( GetProcessHeap(), 0, mask_size ))) return NULL;
984 if (!NtGdiGetBitmapBits( bmp, mask_size, mask )) goto done;
985
986 bm.bmHeight /= 2;
987 bits_size = bm.bmWidth * bm.bmHeight * sizeof(*bits);
988 if (!(bits = HeapAlloc( GetProcessHeap(), 0, bits_size ))) goto done;
989
990 ptr = bits;
991 for (i = 0; i < bm.bmHeight; i++)
992 for (j = 0; j < bm.bmWidth; j++, ptr++)
993 {
994 int and = ((mask[i * stride + j / 8] << (j % 8)) & 0x80);
995 int xor = ((mask[(i + bm.bmHeight) * stride + j / 8] << (j % 8)) & 0x80);
996 if (!xor && and)
997 *ptr = 0;
998 else if (xor && !and)
999 *ptr = 0xffffffff;
1000 else
1001 /* we can't draw "invert" pixels, so render them as black instead */
1002 *ptr = 0xff000000;
1003 }
1004
1005 *width = bm.bmWidth;
1006 *height = bm.bmHeight;
1007
1008 done:
1009 HeapFree( GetProcessHeap(), 0, mask );
1010 return bits;
1011 }
1012
1013 /***********************************************************************
1014 * get_bitmap_argb
1015 *
1016 * Return the bitmap bits in ARGB format. Helper for setting icons and cursors.
1017 */
1018 static unsigned int *get_bitmap_argb( HDC hdc, HBITMAP color, HBITMAP mask, unsigned int *width,
1019 unsigned int *height )
1020 {
1021 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1022 BITMAPINFO *info = (BITMAPINFO *)buffer;
1023 BITMAP bm;
1024 unsigned int *ptr, *bits = NULL;
1025 unsigned char *mask_bits = NULL;
1026 int i, j;
1027 BOOL has_alpha = FALSE;
1028
1029 if (!color) return get_mono_icon_argb( hdc, mask, width, height );
1030
1031 if (!NtGdiExtGetObjectW( color, sizeof(bm), &bm )) return NULL;
1032 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1033 info->bmiHeader.biWidth = bm.bmWidth;
1034 info->bmiHeader.biHeight = -bm.bmHeight;
1035 info->bmiHeader.biPlanes = 1;
1036 info->bmiHeader.biBitCount = 32;
1037 info->bmiHeader.biCompression = BI_RGB;
1038 info->bmiHeader.biSizeImage = bm.bmWidth * bm.bmHeight * 4;
1039 info->bmiHeader.biXPelsPerMeter = 0;
1040 info->bmiHeader.biYPelsPerMeter = 0;
1041 info->bmiHeader.biClrUsed = 0;
1042 info->bmiHeader.biClrImportant = 0;
1043 if (!(bits = HeapAlloc( GetProcessHeap(), 0, bm.bmWidth * bm.bmHeight * sizeof(unsigned int) )))
1044 goto failed;
1045 if (!NtGdiGetDIBitsInternal( hdc, color, 0, bm.bmHeight, bits, info, DIB_RGB_COLORS, 0, 0 ))
1046 goto failed;
1047
1048 *width = bm.bmWidth;
1049 *height = bm.bmHeight;
1050
1051 for (i = 0; i < bm.bmWidth * bm.bmHeight; i++)
1052 if ((has_alpha = (bits[i] & 0xff000000) != 0)) break;
1053
1054 if (!has_alpha)
1055 {
1056 unsigned int width_bytes = (bm.bmWidth + 31) / 32 * 4;
1057 /* generate alpha channel from the mask */
1058 info->bmiHeader.biBitCount = 1;
1059 info->bmiHeader.biSizeImage = width_bytes * bm.bmHeight;
1060 if (!(mask_bits = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto failed;
1061 if (!NtGdiGetDIBitsInternal( hdc, mask, 0, bm.bmHeight, mask_bits, info, DIB_RGB_COLORS, 0, 0 ))
1062 goto failed;
1063 ptr = bits;
1064 for (i = 0; i < bm.bmHeight; i++)
1065 for (j = 0; j < bm.bmWidth; j++, ptr++)
1066 if (!((mask_bits[i * width_bytes + j / 8] << (j % 8)) & 0x80)) *ptr |= 0xff000000;
1067 HeapFree( GetProcessHeap(), 0, mask_bits );
1068 }
1069
1070 return bits;
1071
1072 failed:
1073 HeapFree( GetProcessHeap(), 0, bits );
1074 HeapFree( GetProcessHeap(), 0, mask_bits );
1075 *width = *height = 0;
1076 return NULL;
1077 }
1078
1079
1080 enum android_system_cursors
1081 {
1082 TYPE_ARROW = 1000,
1083 TYPE_CONTEXT_MENU = 1001,
1084 TYPE_HAND = 1002,
1085 TYPE_HELP = 1003,
1086 TYPE_WAIT = 1004,
1087 TYPE_CELL = 1006,
1088 TYPE_CROSSHAIR = 1007,
1089 TYPE_TEXT = 1008,
1090 TYPE_VERTICAL_TEXT = 1009,
1091 TYPE_ALIAS = 1010,
1092 TYPE_COPY = 1011,
1093 TYPE_NO_DROP = 1012,
1094 TYPE_ALL_SCROLL = 1013,
1095 TYPE_HORIZONTAL_DOUBLE_ARROW = 1014,
1096 TYPE_VERTICAL_DOUBLE_ARROW = 1015,
1097 TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW = 1016,
1098 TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW = 1017,
1099 TYPE_ZOOM_IN = 1018,
1100 TYPE_ZOOM_OUT = 1019,
1101 TYPE_GRAB = 1020,
1102 TYPE_GRABBING = 1021,
1103 };
1104
1105 struct system_cursors
1106 {
1107 WORD id;
1108 enum android_system_cursors android_id;
1109 };
1110
1111 static const struct system_cursors user32_cursors[] =
1112 {
1113 { OCR_NORMAL, TYPE_ARROW },
1114 { OCR_IBEAM, TYPE_TEXT },
1115 { OCR_WAIT, TYPE_WAIT },
1116 { OCR_CROSS, TYPE_CROSSHAIR },
1117 { OCR_SIZE, TYPE_ALL_SCROLL },
1118 { OCR_SIZEALL, TYPE_ALL_SCROLL },
1119 { OCR_SIZENWSE, TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW },
1120 { OCR_SIZENESW, TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW },
1121 { OCR_SIZEWE, TYPE_HORIZONTAL_DOUBLE_ARROW },
1122 { OCR_SIZENS, TYPE_VERTICAL_DOUBLE_ARROW },
1123 { OCR_NO, TYPE_NO_DROP },
1124 { OCR_HAND, TYPE_HAND },
1125 { OCR_HELP, TYPE_HELP },
1126 { 0 }
1127 };
1128
1129 static const struct system_cursors comctl32_cursors[] =
1130 {
1131 /* 102 TYPE_MOVE doesn't exist */
1132 { 104, TYPE_COPY },
1133 { 105, TYPE_ARROW },
1134 { 106, TYPE_HORIZONTAL_DOUBLE_ARROW },
1135 { 107, TYPE_HORIZONTAL_DOUBLE_ARROW },
1136 { 108, TYPE_GRABBING },
1137 { 135, TYPE_VERTICAL_DOUBLE_ARROW },
1138 { 0 }
1139 };
1140
1141 static const struct system_cursors ole32_cursors[] =
1142 {
1143 { 1, TYPE_NO_DROP },
1144 /* 2 TYPE_MOVE doesn't exist */
1145 { 3, TYPE_COPY },
1146 { 4, TYPE_ALIAS },
1147 { 0 }
1148 };
1149
1150 static const struct system_cursors riched20_cursors[] =
1151 {
1152 { 105, TYPE_GRABBING },
1153 { 109, TYPE_COPY },
1154 /* 110 TYPE_MOVE doesn't exist */
1155 { 111, TYPE_NO_DROP },
1156 { 0 }
1157 };
1158
1159 static const struct
1160 {
1161 const struct system_cursors *cursors;
1162 WCHAR name[16];
1163 } module_cursors[] =
1164 {
1165 { user32_cursors, {'u','s','e','r','3','2','.','d','l','l',0} },
1166 { comctl32_cursors, {'c','o','m','c','t','l','3','2','.','d','l','l',0} },
1167 { ole32_cursors, {'o','l','e','3','2','.','d','l','l',0} },
1168 { riched20_cursors, {'r','i','c','h','e','d','2','0','.','d','l','l',0} }
1169 };
1170
1171 static int get_cursor_system_id( const ICONINFOEXW *info )
1172 {
1173 const struct system_cursors *cursors;
1174 unsigned int i;
1175 HMODULE module;
1176
1177 if (info->szResName[0]) return 0; /* only integer resources are supported here */
1178 if (!(module = GetModuleHandleW( info->szModName ))) return 0;
1179
1180 for (i = 0; i < ARRAY_SIZE( module_cursors ); i++)
1181 if (GetModuleHandleW( module_cursors[i].name ) == module) break;
1182 if (i == ARRAY_SIZE( module_cursors )) return 0;
1183
1184 cursors = module_cursors[i].cursors;
1185 for (i = 0; cursors[i].id; i++)
1186 if (cursors[i].id == info->wResID) return cursors[i].android_id;
1187
1188 return 0;
1189 }
1190
1191
1192 LRESULT ANDROID_DesktopWindowProc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
1193 {
1194 switch (msg)
1195 {
1196 case WM_PARENTNOTIFY:
1197 if (LOWORD(wp) == WM_DESTROY) destroy_ioctl_window( (HWND)lp, FALSE );
1198 break;
1199 }
1200 return NtUserMessageCall( hwnd, msg, wp, lp, 0, NtUserDefWindowProc, FALSE );
1201 }
1202
1203
1204 /***********************************************************************
1205 * ANDROID_MsgWaitForMultipleObjectsEx
1206 */
1207 NTSTATUS ANDROID_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
1208 const LARGE_INTEGER *timeout,
1209 DWORD mask, DWORD flags )
1210 {
1211 if (GetCurrentThreadId() == desktop_tid)
1212 {
1213 /* don't process nested events */
1214 if (current_event) mask = 0;
1215 if (process_events( mask )) return count - 1;
1216 }
1217 return NtWaitForMultipleObjects( count, handles, !(flags & MWMO_WAITALL),
1218 !!(flags & MWMO_ALERTABLE), timeout );
1219 }
1220
1221 /**********************************************************************
1222 * ANDROID_CreateWindow
1223 */
1224 BOOL ANDROID_CreateWindow( HWND hwnd )
1225 {
1226 TRACE( "%p\n", hwnd );
1227
1228 if (hwnd == NtUserGetDesktopWindow())
1229 {
1230 struct android_win_data *data;
1231
1232 init_event_queue();
1233 start_android_device();
1234 if (!(data = alloc_win_data( hwnd ))) return FALSE;
1235 release_win_data( data );
1236 }
1237 return TRUE;
1238 }
1239
1240
1241 /***********************************************************************
1242 * ANDROID_DestroyWindow
1243 */
1244 void ANDROID_DestroyWindow( HWND hwnd )
1245 {
1246 struct android_win_data *data;
1247
1248 if (!(data = get_win_data( hwnd ))) return;
1249
1250 if (data->surface) window_surface_release( data->surface );
1251 data->surface = NULL;
1252 destroy_gl_drawable( hwnd );
1253 free_win_data( data );
1254 }
1255
1256
1257 /***********************************************************************
1258 * create_win_data
1259 *
1260 * Create a data window structure for an existing window.
1261 */
1262 static struct android_win_data *create_win_data( HWND hwnd, const RECT *window_rect,
1263 const RECT *client_rect )
1264 {
1265 struct android_win_data *data;
1266 HWND parent;
1267
1268 if (!(parent = NtUserGetAncestor( hwnd, GA_PARENT ))) return NULL; /* desktop or HWND_MESSAGE */
1269
1270 if (!(data = alloc_win_data( hwnd ))) return NULL;
1271
1272 data->parent = (parent == NtUserGetDesktopWindow()) ? 0 : parent;
1273 data->whole_rect = data->window_rect = *window_rect;
1274 data->client_rect = *client_rect;
1275 return data;
1276 }
1277
1278
1279 static inline BOOL get_surface_rect( const RECT *visible_rect, RECT *surface_rect )
1280 {
1281 if (!intersect_rect( surface_rect, visible_rect, &virtual_screen_rect )) return FALSE;
1282 OffsetRect( surface_rect, -visible_rect->left, -visible_rect->top );
1283 surface_rect->left &= ~31;
1284 surface_rect->top &= ~31;
1285 surface_rect->right = max( surface_rect->left + 32, (surface_rect->right + 31) & ~31 );
1286 surface_rect->bottom = max( surface_rect->top + 32, (surface_rect->bottom + 31) & ~31 );
1287 return TRUE;
1288 }
1289
1290
1291 /***********************************************************************
1292 * ANDROID_WindowPosChanging
1293 */
1294 BOOL ANDROID_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
1295 const RECT *window_rect, const RECT *client_rect, RECT *visible_rect,
1296 struct window_surface **surface )
1297 {
1298 struct android_win_data *data = get_win_data( hwnd );
1299 RECT surface_rect;
1300 DWORD flags;
1301 COLORREF key;
1302 BYTE alpha;
1303 BOOL layered = NtUserGetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED;
1304
1305 TRACE( "win %p window %s client %s style %08x flags %08x\n",
1306 hwnd, wine_dbgstr_rect(window_rect), wine_dbgstr_rect(client_rect),
1307 NtUserGetWindowLongW( hwnd, GWL_STYLE ), swp_flags );
1308
1309 if (!data && !(data = create_win_data( hwnd, window_rect, client_rect ))) return TRUE;
1310
1311 *visible_rect = *window_rect;
1312
1313 /* create the window surface if necessary */
1314
1315 if (data->parent) goto done;
1316 if (swp_flags & SWP_HIDEWINDOW) goto done;
1317 if (is_argb_surface( data->surface )) goto done;
1318 if (!get_surface_rect( visible_rect, &surface_rect )) goto done;
1319
1320 if (data->surface)
1321 {
1322 if (!memcmp( &data->surface->rect, &surface_rect, sizeof(surface_rect) ))
1323 {
1324 /* existing surface is good enough */
1325 window_surface_add_ref( data->surface );
1326 if (*surface) window_surface_release( *surface );
1327 *surface = data->surface;
1328 goto done;
1329 }
1330 }
1331 if (!(swp_flags & SWP_SHOWWINDOW) && !(NtUserGetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE))
1332 goto done;
1333
1334 if (!layered || !NtUserGetLayeredWindowAttributes( hwnd, &key, &alpha, &flags )) flags = 0;
1335 if (!(flags & LWA_ALPHA)) alpha = 255;
1336 if (!(flags & LWA_COLORKEY)) key = CLR_INVALID;
1337
1338 if (*surface) window_surface_release( *surface );
1339 *surface = create_surface( data->hwnd, &surface_rect, alpha, key, FALSE );
1340
1341 done:
1342 release_win_data( data );
1343 return TRUE;
1344 }
1345
1346
1347 /***********************************************************************
1348 * ANDROID_WindowPosChanged
1349 */
1350 void ANDROID_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
1351 const RECT *window_rect, const RECT *client_rect,
1352 const RECT *visible_rect, const RECT *valid_rects,
1353 struct window_surface *surface )
1354 {
1355 struct android_win_data *data;
1356 DWORD new_style = NtUserGetWindowLongW( hwnd, GWL_STYLE );
1357 HWND owner = 0;
1358
1359 if (!(data = get_win_data( hwnd ))) return;
1360
1361 data->window_rect = *window_rect;
1362 data->whole_rect = *visible_rect;
1363 data->client_rect = *client_rect;
1364
1365 if (!is_argb_surface( data->surface ))
1366 {
1367 if (surface) window_surface_add_ref( surface );
1368 if (data->surface) window_surface_release( data->surface );
1369 data->surface = surface;
1370 }
1371 if (!data->parent) owner = NtUserGetWindowRelative( hwnd, GW_OWNER );
1372 release_win_data( data );
1373
1374 if (!(swp_flags & SWP_NOZORDER)) insert_after = NtUserGetWindowRelative( hwnd, GW_HWNDPREV );
1375
1376 TRACE( "win %p window %s client %s style %08x owner %p after %p flags %08x\n", hwnd,
1377 wine_dbgstr_rect(window_rect), wine_dbgstr_rect(client_rect),
1378 new_style, owner, insert_after, swp_flags );
1379
1380 ioctl_window_pos_changed( hwnd, window_rect, client_rect, visible_rect,
1381 new_style, swp_flags, insert_after, owner );
1382 }
1383
1384
1385 /***********************************************************************
1386 * ANDROID_ShowWindow
1387 */
1388 UINT ANDROID_ShowWindow( HWND hwnd, INT cmd, RECT *rect, UINT swp )
1389 {
1390 if (!(NtUserGetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)) return swp;
1391 /* always hide icons off-screen */
1392 if (rect->left != -32000 || rect->top != -32000)
1393 {
1394 OffsetRect( rect, -32000 - rect->left, -32000 - rect->top );
1395 swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE);
1396 }
1397 return swp;
1398 }
1399
1400
1401 /*****************************************************************
1402 * ANDROID_SetParent
1403 */
1404 void ANDROID_SetParent( HWND hwnd, HWND parent, HWND old_parent )
1405 {
1406 struct android_win_data *data;
1407
1408 if (parent == old_parent) return;
1409 if (!(data = get_win_data( hwnd ))) return;
1410
1411 TRACE( "win %p parent %p -> %p\n", hwnd, old_parent, parent );
1412
1413 data->parent = (parent == NtUserGetDesktopWindow()) ? 0 : parent;
1414 ioctl_set_window_parent( hwnd, parent, (float)get_win_monitor_dpi( hwnd ) / NtUserGetDpiForWindow( hwnd ));
1415 release_win_data( data );
1416 }
1417
1418
1419 /***********************************************************************
1420 * ANDROID_SetCapture
1421 */
1422 void ANDROID_SetCapture( HWND hwnd, UINT flags )
1423 {
1424 if (!(flags & (GUI_INMOVESIZE | GUI_INMENUMODE))) return;
1425 ioctl_set_capture( hwnd );
1426 }
1427
1428
1429 static BOOL get_icon_info( HICON handle, ICONINFOEXW *ret )
1430 {
1431 UNICODE_STRING module, res_name;
1432 ICONINFO info;
1433
1434 module.Buffer = ret->szModName;
1435 module.MaximumLength = sizeof(ret->szModName) - sizeof(WCHAR);
1436 res_name.Buffer = ret->szResName;
1437 res_name.MaximumLength = sizeof(ret->szResName) - sizeof(WCHAR);
1438 if (!NtUserGetIconInfo( handle, &info, &module, &res_name, NULL, 0 )) return FALSE;
1439 ret->fIcon = info.fIcon;
1440 ret->xHotspot = info.xHotspot;
1441 ret->yHotspot = info.yHotspot;
1442 ret->hbmColor = info.hbmColor;
1443 ret->hbmMask = info.hbmMask;
1444 ret->wResID = res_name.Length ? 0 : LOWORD(res_name.Buffer);
1445 ret->szModName[module.Length] = 0;
1446 ret->szResName[res_name.Length] = 0;
1447 return TRUE;
1448 }
1449
1450
1451 /***********************************************************************
1452 * ANDROID_SetCursor
1453 */
1454 void ANDROID_SetCursor( HCURSOR handle )
1455 {
1456 static HCURSOR last_cursor;
1457 static DWORD last_cursor_change;
1458
1459 if (InterlockedExchangePointer( (void **)&last_cursor, handle ) != handle ||
1460 GetTickCount() - last_cursor_change > 100)
1461 {
1462 last_cursor_change = GetTickCount();
1463
1464 if (handle)
1465 {
1466 unsigned int width = 0, height = 0, *bits = NULL;
1467 ICONINFOEXW info;
1468 int id;
1469
1470 if (!get_icon_info( handle, &info )) return;
1471
1472 if (!(id = get_cursor_system_id( &info )))
1473 {
1474 HDC hdc = NtGdiCreateCompatibleDC( 0 );
1475 bits = get_bitmap_argb( hdc, info.hbmColor, info.hbmMask, &width, &height );
1476 NtGdiDeleteObjectApp( hdc );
1477
1478 /* make sure hotspot is valid */
1479 if (info.xHotspot >= width || info.yHotspot >= height)
1480 {
1481 info.xHotspot = width / 2;
1482 info.yHotspot = height / 2;
1483 }
1484 }
1485 ioctl_set_cursor( id, width, height, info.xHotspot, info.yHotspot, bits );
1486 HeapFree( GetProcessHeap(), 0, bits );
1487 NtGdiDeleteObjectApp( info.hbmColor );
1488 NtGdiDeleteObjectApp( info.hbmMask );
1489 }
1490 else ioctl_set_cursor( 0, 0, 0, 0, 0, NULL );
1491 }
1492 }
1493
1494
1495 /***********************************************************************
1496 * ANDROID_SetWindowStyle
1497 */
1498 void ANDROID_SetWindowStyle( HWND hwnd, INT offset, STYLESTRUCT *style )
1499 {
1500 struct android_win_data *data;
1501 DWORD changed = style->styleNew ^ style->styleOld;
1502
1503 if (hwnd == NtUserGetDesktopWindow()) return;
1504 if (!(data = get_win_data( hwnd ))) return;
1505
1506 if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYERED)) /* changing WS_EX_LAYERED resets attributes */
1507 {
1508 if (is_argb_surface( data->surface ))
1509 {
1510 if (data->surface) window_surface_release( data->surface );
1511 data->surface = NULL;
1512 }
1513 else if (data->surface) set_surface_layered( data->surface, 255, CLR_INVALID );
1514 }
1515 release_win_data( data );
1516 }
1517
1518
1519 /***********************************************************************
1520 * ANDROID_SetWindowRgn
1521 */
1522 void ANDROID_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
1523 {
1524 struct android_win_data *data;
1525
1526 if ((data = get_win_data( hwnd )))
1527 {
1528 if (data->surface) set_surface_region( data->surface, hrgn );
1529 release_win_data( data );
1530 }
1531 else FIXME( "not supported on other process window %p\n", hwnd );
1532 }
1533
1534
1535 /***********************************************************************
1536 * ANDROID_SetLayeredWindowAttributes
1537 */
1538 void ANDROID_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
1539 {
1540 struct android_win_data *data;
1541
1542 if (!(flags & LWA_ALPHA)) alpha = 255;
1543 if (!(flags & LWA_COLORKEY)) key = CLR_INVALID;
1544
1545 if ((data = get_win_data( hwnd )))
1546 {
1547 if (data->surface) set_surface_layered( data->surface, alpha, key );
1548 release_win_data( data );
1549 }
1550 }
1551
1552
1553 /*****************************************************************************
1554 * ANDROID_UpdateLayeredWindow
1555 */
1556 BOOL ANDROID_UpdateLayeredWindow( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
1557 const RECT *window_rect )
1558 {
1559 struct window_surface *surface;
1560 struct android_win_data *data;
1561 BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
1562 COLORREF color_key = (info->dwFlags & ULW_COLORKEY) ? info->crKey : CLR_INVALID;
1563 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1564 BITMAPINFO *bmi = (BITMAPINFO *)buffer;
1565 void *src_bits, *dst_bits;
1566 RECT rect, src_rect;
1567 HDC hdc = 0;
1568 HBITMAP dib;
1569 BOOL ret = FALSE;
1570
1571 if (!(data = get_win_data( hwnd ))) return FALSE;
1572
1573 rect = *window_rect;
1574 OffsetRect( &rect, -window_rect->left, -window_rect->top );
1575
1576 surface = data->surface;
1577 if (!is_argb_surface( surface ))
1578 {
1579 if (surface) window_surface_release( surface );
1580 surface = NULL;
1581 }
1582
1583 if (!surface || !EqualRect( &surface->rect, &rect ))
1584 {
1585 data->surface = create_surface( data->hwnd, &rect, 255, color_key, TRUE );
1586 if (surface) window_surface_release( surface );
1587 surface = data->surface;
1588 }
1589 else set_surface_layered( surface, 255, color_key );
1590
1591 if (surface) window_surface_add_ref( surface );
1592 release_win_data( data );
1593
1594 if (!surface) return FALSE;
1595 if (!info->hdcSrc)
1596 {
1597 window_surface_release( surface );
1598 return TRUE;
1599 }
1600
1601 dst_bits = surface->funcs->get_info( surface, bmi );
1602
1603 if (!(dib = NtGdiCreateDIBSection( info->hdcDst, NULL, 0, bmi, DIB_RGB_COLORS, 0, 0, 0, &src_bits )))
1604 goto done;
1605 if (!(hdc = NtGdiCreateCompatibleDC( 0 ))) goto done;
1606
1607 NtGdiSelectBitmap( hdc, dib );
1608
1609 surface->funcs->lock( surface );
1610
1611 if (info->prcDirty)
1612 {
1613 intersect_rect( &rect, &rect, info->prcDirty );
1614 memcpy( src_bits, dst_bits, bmi->bmiHeader.biSizeImage );
1615 NtGdiPatBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, BLACKNESS );
1616 }
1617 src_rect = rect;
1618 if (info->pptSrc) OffsetRect( &src_rect, info->pptSrc->x, info->pptSrc->y );
1619 NtGdiTransformPoints( info->hdcSrc, (POINT *)&src_rect, (POINT *)&src_rect, 2, NtGdiDPtoLP );
1620
1621 ret = NtGdiAlphaBlend( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
1622 info->hdcSrc, src_rect.left, src_rect.top,
1623 src_rect.right - src_rect.left, src_rect.bottom - src_rect.top,
1624 (info->dwFlags & ULW_ALPHA) ? *info->pblend : blend, 0 );
1625 if (ret)
1626 {
1627 memcpy( dst_bits, src_bits, bmi->bmiHeader.biSizeImage );
1628 add_bounds_rect( surface->funcs->get_bounds( surface ), &rect );
1629 }
1630
1631 surface->funcs->unlock( surface );
1632 surface->funcs->flush( surface );
1633
1634 done:
1635 window_surface_release( surface );
1636 if (hdc) NtGdiDeleteObjectApp( hdc );
1637 if (dib) NtGdiDeleteObjectApp( dib );
1638 return ret;
1639 }
1640
1641
1642 /**********************************************************************
1643 * ANDROID_WindowMessage
1644 */
1645 LRESULT ANDROID_WindowMessage( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
1646 {
1647 struct android_win_data *data;
1648
1649 switch (msg)
1650 {
1651 case WM_ANDROID_REFRESH:
1652 if (wp) /* opengl client window */
1653 {
1654 update_gl_drawable( hwnd );
1655 }
1656 else if ((data = get_win_data( hwnd )))
1657 {
1658 struct window_surface *surface = data->surface;
1659 if (surface)
1660 {
1661 surface->funcs->lock( surface );
1662 *surface->funcs->get_bounds( surface ) = surface->rect;
1663 surface->funcs->unlock( surface );
1664 if (is_argb_surface( surface )) surface->funcs->flush( surface );
1665 }
1666 release_win_data( data );
1667 }
1668 return 0;
1669 default:
1670 FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg, hwnd, wp, lp );
1671 return 0;
1672 }
1673 }
1674
1675
1676 /***********************************************************************
1677 * ANDROID_create_desktop
1678 */
1679 BOOL CDECL ANDROID_create_desktop( UINT width, UINT height )
1680 {
1681 /* wait until we receive the surface changed event */
1682 while (!screen_width)
1683 {
1684 if (wait_events( 2000 ) != 1)
1685 {
1686 ERR( "wait timed out\n" );
1687 break;
1688 }
1689 process_events( QS_ALLINPUT );
1690 }
1691 return TRUE;
1692 }
Windows API implementation