dlls/wineandroid.drv/window.c

   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 #include "wine/port.h"
  28
  29 #include <assert.h>
  30 #include <fcntl.h>
  31 #include <poll.h>
  32 #include <errno.h>
  33 #include <stdarg.h>
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #ifdef HAVE_UNISTD_H
  37 # include <unistd.h>
  38 #endif
  39
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "wingdi.h"
  43 #include "winuser.h"
  44 #include "wine/unicode.h"
  45
  46 #include "android.h"
  47 #include "wine/server.h"
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(android);
  51
  52 /* private window data */
  53 struct android_win_data
  54 {
  55     HWND           hwnd;           /* hwnd that this private data belongs to */
  56     HWND           parent;         /* parent hwnd for child windows */
  57     RECT           window_rect;    /* USER window rectangle relative to parent */
  58     RECT           whole_rect;     /* X window rectangle for the whole window relative to parent */
  59     RECT           client_rect;    /* client area relative to parent */
  60     ANativeWindow *window;         /* native window wrapper that forwards calls to the desktop process */
  61 };
  62
  63 #define SWP_AGG_NOPOSCHANGE (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
  64
  65 static CRITICAL_SECTION win_data_section;
  66 static CRITICAL_SECTION_DEBUG critsect_debug =
  67 {
  68     0, 0, &win_data_section,
  69     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  70       0, 0, { (DWORD_PTR)(__FILE__ ": win_data_section") }
  71 };
  72 static CRITICAL_SECTION win_data_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  73
  74 static struct android_win_data *win_data_context[32768];
  75
  76 static inline int context_idx( HWND hwnd )
  77 {
  78     return LOWORD( hwnd ) >> 1;
  79 }
  80
  81
  82 /***********************************************************************
  83  *           alloc_win_data
  84  */
  85 static struct android_win_data *alloc_win_data( HWND hwnd )
  86 {
  87     struct android_win_data *data;
  88
  89     if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
  90     {
  91         data->hwnd = hwnd;
  92         data->window = create_ioctl_window( hwnd );
  93         EnterCriticalSection( &win_data_section );
  94         win_data_context[context_idx(hwnd)] = data;
  95     }
  96     return data;
  97 }
  98
  99
 100 /***********************************************************************
 101  *           free_win_data
 102  */
 103 static void free_win_data( struct android_win_data *data )
 104 {
 105     win_data_context[context_idx( data->hwnd )] = NULL;
 106     LeaveCriticalSection( &win_data_section );
 107     if (data->window) release_ioctl_window( data->window );
 108     HeapFree( GetProcessHeap(), 0, data );
 109 }
 110
 111
 112 /***********************************************************************
 113  *           get_win_data
 114  *
 115  * Lock and return the data structure associated with a window.
 116  */
 117 static struct android_win_data *get_win_data( HWND hwnd )
 118 {
 119     struct android_win_data *data;
 120
 121     if (!hwnd) return NULL;
 122     EnterCriticalSection( &win_data_section );
 123     if ((data = win_data_context[context_idx(hwnd)]) && data->hwnd == hwnd) return data;
 124     LeaveCriticalSection( &win_data_section );
 125     return NULL;
 126 }
 127
 128
 129 /***********************************************************************
 130  *           release_win_data
 131  *
 132  * Release the data returned by get_win_data.
 133  */
 134 static void release_win_data( struct android_win_data *data )
 135 {
 136     if (data) LeaveCriticalSection( &win_data_section );
 137 }
 138
 139
 140 /* Handling of events coming from the Java side */
 141
 142 struct java_event
 143 {
 144     struct list      entry;
 145     union event_data data;
 146 };
 147
 148 static struct list event_queue = LIST_INIT( event_queue );
 149 static struct java_event *current_event;
 150 static int event_pipe[2];
 151 static DWORD desktop_tid;
 152
 153 /***********************************************************************
 154  *           send_event
 155  */
 156 int send_event( const union event_data *data )
 157 {
 158     int res;
 159
 160     if ((res = write( event_pipe[1], data, sizeof(*data) )) != sizeof(*data))
 161     {
 162         p__android_log_print( ANDROID_LOG_ERROR, "wine", "failed to send event" );
 163         return -1;
 164     }
 165     return 0;
 166 }
 167
 168
 169 /***********************************************************************
 170  *           desktop_changed
 171  *
 172  * JNI callback, runs in the context of the Java thread.
 173  */
 174 void desktop_changed( JNIEnv *env, jobject obj, jint width, jint height )
 175 {
 176     union event_data data;
 177
 178     memset( &data, 0, sizeof(data) );
 179     data.type = DESKTOP_CHANGED;
 180     data.desktop.width = width;
 181     data.desktop.height = height;
 182     p__android_log_print( ANDROID_LOG_INFO, "wine", "desktop_changed: %ux%u", width, height );
 183     send_event( &data );
 184 }
 185
 186
 187 /***********************************************************************
 188  *           surface_changed
 189  *
 190  * JNI callback, runs in the context of the Java thread.
 191  */
 192 void surface_changed( JNIEnv *env, jobject obj, jint win, jobject surface )
 193 {
 194     union event_data data;
 195
 196     memset( &data, 0, sizeof(data) );
 197     data.surface.hwnd = LongToHandle( win );
 198     if (surface)
 199     {
 200         int width, height;
 201         ANativeWindow *win = pANativeWindow_fromSurface( env, surface );
 202
 203         if (win->query( win, NATIVE_WINDOW_WIDTH, &width ) < 0) width = 0;
 204         if (win->query( win, NATIVE_WINDOW_HEIGHT, &height ) < 0) height = 0;
 205         data.surface.window = win;
 206         data.surface.width = width;
 207         data.surface.height = height;
 208         p__android_log_print( ANDROID_LOG_INFO, "wine", "surface_changed: %p %ux%u",
 209                               data.surface.hwnd, width, height );
 210     }
 211     data.type = SURFACE_CHANGED;
 212     send_event( &data );
 213 }
 214
 215
 216 /***********************************************************************
 217  *           init_event_queue
 218  */
 219 static void init_event_queue(void)
 220 {
 221     HANDLE handle;
 222     int ret;
 223
 224     if (pipe2( event_pipe, O_CLOEXEC | O_NONBLOCK ) == -1)
 225     {
 226         ERR( "could not create data\n" );
 227         ExitProcess(1);
 228     }
 229     if (wine_server_fd_to_handle( event_pipe[0], GENERIC_READ | SYNCHRONIZE, 0, &handle ))
 230     {
 231         ERR( "Can't allocate handle for event fd\n" );
 232         ExitProcess(1);
 233     }
 234     SERVER_START_REQ( set_queue_fd )
 235     {
 236         req->handle = wine_server_obj_handle( handle );
 237         ret = wine_server_call( req );
 238     }
 239     SERVER_END_REQ;
 240     if (ret)
 241     {
 242         ERR( "Can't store handle for event fd %x\n", ret );
 243         ExitProcess(1);
 244     }
 245     CloseHandle( handle );
 246     desktop_tid = GetCurrentThreadId();
 247 }
 248
 249
 250 /***********************************************************************
 251  *           pull_events
 252  *
 253  * Pull events from the event pipe and add them to the queue
 254  */
 255 static void pull_events(void)
 256 {
 257     struct java_event *event;
 258     int res;
 259
 260     for (;;)
 261     {
 262         if (!(event = HeapAlloc( GetProcessHeap(), 0, sizeof(*event) ))) break;
 263
 264         res = read( event_pipe[0], &event->data, sizeof(event->data) );
 265         if (res != sizeof(event->data)) break;
 266         list_add_tail( &event_queue, &event->entry );
 267     }
 268     HeapFree( GetProcessHeap(), 0, event );
 269 }
 270
 271
 272 /***********************************************************************
 273  *           process_events
 274  */
 275 static int process_events( DWORD mask )
 276 {
 277     struct java_event *event, *next, *previous;
 278     unsigned int count = 0;
 279
 280     assert( GetCurrentThreadId() == desktop_tid );
 281
 282     pull_events();
 283
 284     previous = current_event;
 285
 286     LIST_FOR_EACH_ENTRY_SAFE( event, next, &event_queue, struct java_event, entry )
 287     {
 288         switch (event->data.type)
 289         {
 290         case SURFACE_CHANGED:
 291             break;  /* always process it to unblock other threads */
 292         default:
 293             if (mask & QS_SENDMESSAGE) break;
 294             continue;  /* skip it */
 295         }
 296
 297         /* remove it first, in case we process events recursively */
 298         list_remove( &event->entry );
 299         current_event = event;
 300
 301         switch (event->data.type)
 302         {
 303         case DESKTOP_CHANGED:
 304             TRACE( "DESKTOP_CHANGED %ux%u\n", event->data.desktop.width, event->data.desktop.height );
 305             screen_width = event->data.desktop.width;
 306             screen_height = event->data.desktop.height;
 307             init_monitors( screen_width, screen_height );
 308             SetWindowPos( GetDesktopWindow(), 0, 0, 0, screen_width, screen_height,
 309                           SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW );
 310             break;
 311
 312         case SURFACE_CHANGED:
 313             TRACE("SURFACE_CHANGED %p %p size %ux%u\n", event->data.surface.hwnd,
 314                   event->data.surface.window, event->data.surface.width, event->data.surface.height );
 315
 316             register_native_window( event->data.surface.hwnd, event->data.surface.window );
 317             break;
 318
 319         default:
 320             FIXME( "got event %u\n", event->data.type );
 321         }
 322         HeapFree( GetProcessHeap(), 0, event );
 323         count++;
 324     }
 325     current_event = previous;
 326     return count;
 327 }
 328
 329
 330 /***********************************************************************
 331  *           wait_events
 332  */
 333 static int wait_events( int timeout )
 334 {
 335     assert( GetCurrentThreadId() == desktop_tid );
 336
 337     for (;;)
 338     {
 339         struct pollfd pollfd;
 340         int ret;
 341
 342         pollfd.fd = event_pipe[0];
 343         pollfd.events = POLLIN | POLLHUP;
 344         ret = poll( &pollfd, 1, timeout );
 345         if (ret == -1 && errno == EINTR) continue;
 346         if (ret && (pollfd.revents & (POLLHUP | POLLERR))) ret = -1;
 347         return ret;
 348     }
 349 }
 350
 351
 352 static WNDPROC desktop_orig_wndproc;
 353
 354 static LRESULT CALLBACK desktop_wndproc_wrapper( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
 355 {
 356     switch (msg)
 357     {
 358     case WM_PARENTNOTIFY:
 359         if (LOWORD(wp) == WM_DESTROY) destroy_ioctl_window( (HWND)lp );
 360         break;
 361     }
 362     return desktop_orig_wndproc( hwnd, msg, wp, lp );
 363 }
 364
 365
 366 /***********************************************************************
 367  *           ANDROID_MsgWaitForMultipleObjectsEx
 368  */
 369 DWORD CDECL ANDROID_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 370                                                  DWORD timeout, DWORD mask, DWORD flags )
 371 {
 372     if (GetCurrentThreadId() == desktop_tid)
 373     {
 374         /* don't process nested events */
 375         if (current_event) mask = 0;
 376         if (process_events( mask )) return count - 1;
 377     }
 378     return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
 379                                      timeout, flags & MWMO_ALERTABLE );
 380 }
 381
 382 /**********************************************************************
 383  *           ANDROID_CreateWindow
 384  */
 385 BOOL CDECL ANDROID_CreateWindow( HWND hwnd )
 386 {
 387     TRACE( "%p\n", hwnd );
 388
 389     if (hwnd == GetDesktopWindow())
 390     {
 391         struct android_win_data *data;
 392
 393         init_event_queue();
 394         start_android_device();
 395         desktop_orig_wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC,
 396                                                            (LONG_PTR)desktop_wndproc_wrapper );
 397         if (!(data = alloc_win_data( hwnd ))) return FALSE;
 398         release_win_data( data );
 399     }
 400     return TRUE;
 401 }
 402
 403
 404 /***********************************************************************
 405  *           ANDROID_DestroyWindow
 406  */
 407 void CDECL ANDROID_DestroyWindow( HWND hwnd )
 408 {
 409     struct android_win_data *data;
 410
 411     if (!(data = get_win_data( hwnd ))) return;
 412
 413     free_win_data( data );
 414 }
 415
 416
 417 /***********************************************************************
 418  *           create_win_data
 419  *
 420  * Create a data window structure for an existing window.
 421  */
 422 static struct android_win_data *create_win_data( HWND hwnd, const RECT *window_rect,
 423                                                  const RECT *client_rect )
 424 {
 425     struct android_win_data *data;
 426     HWND parent;
 427
 428     if (!(parent = GetAncestor( hwnd, GA_PARENT ))) return NULL;  /* desktop or HWND_MESSAGE */
 429
 430     if (parent != GetDesktopWindow())
 431     {
 432         if (!(data = get_win_data( parent )) &&
 433             !(data = create_win_data( parent, NULL, NULL )))
 434             return NULL;
 435         release_win_data( data );
 436     }
 437
 438     if (!(data = alloc_win_data( hwnd ))) return NULL;
 439
 440     data->parent = (parent == GetDesktopWindow()) ? 0 : parent;
 441
 442     if (window_rect)
 443     {
 444         data->whole_rect = data->window_rect = *window_rect;
 445         data->client_rect = *client_rect;
 446     }
 447     else
 448     {
 449         GetWindowRect( hwnd, &data->window_rect );
 450         MapWindowPoints( 0, parent, (POINT *)&data->window_rect, 2 );
 451         data->whole_rect = data->window_rect;
 452         GetClientRect( hwnd, &data->client_rect );
 453         MapWindowPoints( hwnd, parent, (POINT *)&data->client_rect, 2 );
 454         ioctl_window_pos_changed( hwnd, &data->window_rect, &data->client_rect, &data->whole_rect,
 455                                   GetWindowLongW( hwnd, GWL_STYLE ), SWP_NOACTIVATE,
 456                                   GetWindow( hwnd, GW_HWNDPREV ), GetWindow( hwnd, GW_OWNER ));
 457     }
 458     return data;
 459 }
 460
 461
 462 /***********************************************************************
 463  *           ANDROID_WindowPosChanging
 464  */
 465 void CDECL ANDROID_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
 466                                      const RECT *window_rect, const RECT *client_rect, RECT *visible_rect,
 467                                      struct window_surface **surface )
 468 {
 469     struct android_win_data *data = get_win_data( hwnd );
 470
 471     TRACE( "win %p window %s client %s style %08x flags %08x\n",
 472            hwnd, wine_dbgstr_rect(window_rect), wine_dbgstr_rect(client_rect),
 473            GetWindowLongW( hwnd, GWL_STYLE ), swp_flags );
 474
 475     if (!data && !(data = create_win_data( hwnd, window_rect, client_rect ))) return;
 476
 477     *visible_rect = *window_rect;
 478
 479     release_win_data( data );
 480 }
 481
 482
 483 /***********************************************************************
 484  *           ANDROID_WindowPosChanged
 485  */
 486 void CDECL ANDROID_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
 487                                     const RECT *window_rect, const RECT *client_rect,
 488                                     const RECT *visible_rect, const RECT *valid_rects,
 489                                     struct window_surface *surface )
 490 {
 491     struct android_win_data *data;
 492     DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
 493     HWND owner = 0;
 494
 495     if (!(data = get_win_data( hwnd ))) return;
 496
 497     data->window_rect = *window_rect;
 498     data->whole_rect  = *visible_rect;
 499     data->client_rect = *client_rect;
 500
 501     if (!data->parent) owner = GetWindow( hwnd, GW_OWNER );
 502     release_win_data( data );
 503
 504     TRACE( "win %p window %s client %s style %08x owner %p flags %08x\n", hwnd,
 505            wine_dbgstr_rect(window_rect), wine_dbgstr_rect(client_rect), new_style, owner, swp_flags );
 506
 507     ioctl_window_pos_changed( hwnd, window_rect, client_rect, visible_rect,
 508                               new_style, swp_flags, insert_after, owner );
 509 }
 510
 511
 512 /***********************************************************************
 513  *           ANDROID_create_desktop
 514  */
 515 BOOL CDECL ANDROID_create_desktop( UINT width, UINT height )
 516 {
 517     /* wait until we receive the surface changed event */
 518     while (!screen_width)
 519     {
 520         if (wait_events( 2000 ) != 1)
 521         {
 522             ERR( "wait timed out\n" );
 523             break;
 524         }
 525         process_events( QS_ALLINPUT );
 526     }
 527     return TRUE;
 528 }