wine/dlls/user32/win.c

Version: ~ [ wine-1.5.4 ] ~ [ wine-1.5.3 ] ~ [ wine-1.5.2 ] ~ [ wine-1.5.1 ] ~ [ wine-1.5.0 ] ~ [ wine-1.4 ] ~ [ wine-1.4-rc6 ] ~ [ wine-1.4-rc5 ] ~ [ wine-1.4-rc4 ] ~ [ wine-1.4-rc3 ] ~ [ wine-1.4-rc2 ] ~ [ wine-1.4-rc1 ] ~ [ wine-1.3.37 ] ~ [ wine-1.3.36 ] ~ [ wine-1.3.35 ] ~ [ wine-1.3.34 ] ~ [ wine-1.3.33 ] ~ [ wine-1.3.32 ] ~ [ wine-1.3.31 ] ~ [ wine-1.3.30 ] ~ [ wine-1.3.29 ] ~ [ wine-1.3.28 ] ~ [ wine-1.3.27 ] ~ [ wine-1.3.26 ] ~ [ wine-1.3.25 ] ~ [ wine-1.3.24 ] ~ [ wine-1.3.23 ] ~ [ wine-1.3.22 ] ~ [ wine-1.3.21 ] ~ [ wine-1.3.20 ] ~ [ wine-1.3.19 ] ~ [ wine-1.3.18 ] ~ [ wine-1.2.3 ] ~ [ wine-1.3.17 ] ~ [ wine-1.3.16 ] ~ [ wine-1.3.15 ] ~ [ wine-1.3.14 ] ~ [ wine-1.3.13 ] ~ [ wine-1.3.12 ] ~ [ wine-1.3.11 ] ~ [ wine-1.3.10 ] ~ [ wine-1.3.9 ] ~ [ wine-1.2.2 ] ~ [ wine-1.3.8 ] ~ [ wine-1.3.7 ] ~ [ wine-1.3.6 ] ~ [ wine-1.3.5 ] ~ [ wine-1.2.1 ] ~ [ wine-1.3.4 ] ~ [ wine-1.3.3 ] ~ [ wine-1.3.2 ] ~ [ wine-1.3.1 ] ~ [ wine-1.3.0 ] ~ [ wine-1.2 ] ~ [ wine-1.2-rc7 ] ~ [ wine-1.2-rc6 ] ~ [ wine-1.2-rc5 ] ~ [ wine-1.2-rc4 ] ~ [ wine-1.2-rc3 ] ~ [ wine-1.2-rc2 ] ~ [ wine-1.2-rc1 ] ~ [ wine-1.1.44 ] ~ [ wine-1.1.43 ] ~ [ wine-1.1.42 ] ~ [ wine-1.1.41 ] ~ [ wine-1.1.40 ] ~ [ wine-1.1.39 ] ~ [ wine-1.1.38 ] ~ [ wine-1.1.37 ] ~ [ wine-1.1.36 ] ~ [ wine-1.1.35 ] ~ [ wine-1.1.34 ] ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~

1 /* 2 * Window related functions 3 * 4 * Copyright 1993, 1994 Alexandre Julliard 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 19 */ 20 21 #include "config.h" 22 #include "wine/port.h" 23 24 #include <assert.h> 25 #include <stdarg.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include "windef.h" 29 #include "winbase.h" 30 #include "winver.h" 31 #include "wine/server.h" 32 #include "wine/unicode.h" 33 #include "win.h" 34 #include "user_private.h" 35 #include "controls.h" 36 #include "winerror.h" 37 #include "wine/debug.h" 38 39 WINE_DEFAULT_DEBUG_CHANNEL(win); 40 41 #define NB_USER_HANDLES ((LAST_USER_HANDLE - FIRST_USER_HANDLE + 1) >> 1) 42 #define USER_HANDLE_TO_INDEX(hwnd) ((LOWORD(hwnd) - FIRST_USER_HANDLE) >> 1) 43 44 static DWORD process_layout = ~0u; 45 46 /**********************************************************************/ 47 48 /* helper for Get/SetWindowLong */ 49 static inline LONG_PTR get_win_data( const void *ptr, UINT size ) 50 { 51 if (size == sizeof(WORD)) 52 { 53 WORD ret; 54 memcpy( &ret, ptr, sizeof(ret) ); 55 return ret; 56 } 57 else if (size == sizeof(DWORD)) 58 { 59 DWORD ret; 60 memcpy( &ret, ptr, sizeof(ret) ); 61 return ret; 62 } 63 else 64 { 65 LONG_PTR ret; 66 memcpy( &ret, ptr, sizeof(ret) ); 67 return ret; 68 } 69 } 70 71 /* helper for Get/SetWindowLong */ 72 static inline void set_win_data( void *ptr, LONG_PTR val, UINT size ) 73 { 74 if (size == sizeof(WORD)) 75 { 76 WORD newval = val; 77 memcpy( ptr, &newval, sizeof(newval) ); 78 } 79 else if (size == sizeof(DWORD)) 80 { 81 DWORD newval = val; 82 memcpy( ptr, &newval, sizeof(newval) ); 83 } 84 else 85 { 86 memcpy( ptr, &val, sizeof(val) ); 87 } 88 } 89 90 91 static void *user_handles[NB_USER_HANDLES]; 92 93 /*********************************************************************** 94 * alloc_user_handle 95 */ 96 HANDLE alloc_user_handle( struct user_object *ptr, enum user_obj_type type ) 97 { 98 HANDLE handle = 0; 99 100 SERVER_START_REQ( alloc_user_handle ) 101 { 102 if (!wine_server_call_err( req )) handle = wine_server_ptr_handle( reply->handle ); 103 } 104 SERVER_END_REQ; 105 106 if (handle) 107 { 108 UINT index = USER_HANDLE_TO_INDEX( handle ); 109 110 assert( index < NB_USER_HANDLES ); 111 ptr->handle = handle; 112 ptr->type = type; 113 InterlockedExchangePointer( &user_handles[index], ptr ); 114 } 115 return handle; 116 } 117 118 119 /*********************************************************************** 120 * get_user_handle_ptr 121 */ 122 void *get_user_handle_ptr( HANDLE handle, enum user_obj_type type ) 123 { 124 struct user_object *ptr; 125 WORD index = USER_HANDLE_TO_INDEX( handle ); 126 127 if (index >= NB_USER_HANDLES) return NULL; 128 129 USER_Lock(); 130 if ((ptr = user_handles[index])) 131 { 132 if (ptr->type == type && 133 ((UINT)(UINT_PTR)ptr->handle == (UINT)(UINT_PTR)handle || 134 !HIWORD(handle) || HIWORD(handle) == 0xffff)) 135 return ptr; 136 ptr = NULL; 137 } 138 else ptr = OBJ_OTHER_PROCESS; 139 USER_Unlock(); 140 return ptr; 141 } 142 143 144 /*********************************************************************** 145 * release_user_handle_ptr 146 */ 147 void release_user_handle_ptr( void *ptr ) 148 { 149 assert( ptr && ptr != OBJ_OTHER_PROCESS ); 150 USER_Unlock(); 151 } 152 153 154 /*********************************************************************** 155 * free_user_handle 156 */ 157 void *free_user_handle( HANDLE handle, enum user_obj_type type ) 158 { 159 struct user_object *ptr; 160 WORD index = USER_HANDLE_TO_INDEX( handle ); 161 162 if ((ptr = get_user_handle_ptr( handle, type )) && ptr != OBJ_OTHER_PROCESS) 163 { 164 SERVER_START_REQ( free_user_handle ) 165 { 166 req->handle = wine_server_user_handle( handle ); 167 if (wine_server_call( req )) ptr = NULL; 168 else InterlockedCompareExchangePointer( &user_handles[index], NULL, ptr ); 169 } 170 SERVER_END_REQ; 171 release_user_handle_ptr( ptr ); 172 } 173 return ptr; 174 } 175 176 177 /*********************************************************************** 178 * create_window_handle 179 * 180 * Create a window handle with the server. 181 */ 182 static WND *create_window_handle( HWND parent, HWND owner, LPCWSTR name, 183 HINSTANCE instance, BOOL unicode ) 184 { 185 WORD index; 186 WND *win; 187 HWND handle = 0, full_parent = 0, full_owner = 0; 188 struct tagCLASS *class = NULL; 189 int extra_bytes = 0; 190 191 SERVER_START_REQ( create_window ) 192 { 193 req->parent = wine_server_user_handle( parent ); 194 req->owner = wine_server_user_handle( owner ); 195 req->instance = wine_server_client_ptr( instance ); 196 if (!(req->atom = get_int_atom_value( name )) && name) 197 wine_server_add_data( req, name, strlenW(name)*sizeof(WCHAR) ); 198 if (!wine_server_call_err( req )) 199 { 200 handle = wine_server_ptr_handle( reply->handle ); 201 full_parent = wine_server_ptr_handle( reply->parent ); 202 full_owner = wine_server_ptr_handle( reply->owner ); 203 extra_bytes = reply->extra; 204 class = wine_server_get_ptr( reply->class_ptr ); 205 } 206 } 207 SERVER_END_REQ; 208 209 if (!handle) 210 { 211 WARN( "error %d creating window\n", GetLastError() ); 212 return NULL; 213 } 214 215 if (!(win = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 216 sizeof(WND) + extra_bytes - sizeof(win->wExtra) ))) 217 { 218 SERVER_START_REQ( destroy_window ) 219 { 220 req->handle = wine_server_user_handle( handle ); 221 wine_server_call( req ); 222 } 223 SERVER_END_REQ; 224 SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 225 return NULL; 226 } 227 228 if (!parent) /* if parent is 0 we don't have a desktop window yet */ 229 { 230 struct user_thread_info *thread_info = get_user_thread_info(); 231 232 if (name == (LPCWSTR)DESKTOP_CLASS_ATOM) 233 { 234 if (!thread_info->top_window) thread_info->top_window = full_parent ? full_parent : handle; 235 else assert( full_parent == thread_info->top_window ); 236 if (full_parent && !USER_Driver->pCreateDesktopWindow( thread_info->top_window )) 237 ERR( "failed to create desktop window\n" ); 238 } 239 else /* HWND_MESSAGE parent */ 240 { 241 if (!thread_info->msg_window && !full_parent) thread_info->msg_window = handle; 242 } 243 } 244 245 USER_Lock(); 246 247 index = USER_HANDLE_TO_INDEX(handle); 248 assert( index < NB_USER_HANDLES ); 249 win->obj.handle = handle; 250 win->obj.type = USER_WINDOW; 251 win->parent = full_parent; 252 win->owner = full_owner; 253 win->class = class; 254 win->winproc = get_class_winproc( class ); 255 win->cbWndExtra = extra_bytes; 256 InterlockedExchangePointer( &user_handles[index], win ); 257 if (WINPROC_IsUnicode( win->winproc, unicode )) win->flags |= WIN_ISUNICODE; 258 return win; 259 } 260 261 262 /*********************************************************************** 263 * free_window_handle 264 * 265 * Free a window handle. 266 */ 267 static void free_window_handle( HWND hwnd ) 268 { 269 struct user_object *ptr; 270 WORD index = USER_HANDLE_TO_INDEX(hwnd); 271 272 if ((ptr = get_user_handle_ptr( hwnd, USER_WINDOW )) && ptr != OBJ_OTHER_PROCESS) 273 { 274 SERVER_START_REQ( destroy_window ) 275 { 276 req->handle = wine_server_user_handle( hwnd ); 277 if (wine_server_call_err( req )) ptr = NULL; 278 else InterlockedCompareExchangePointer( &user_handles[index], NULL, ptr ); 279 } 280 SERVER_END_REQ; 281 release_user_handle_ptr( ptr ); 282 HeapFree( GetProcessHeap(), 0, ptr ); 283 } 284 } 285 286 287 /******************************************************************* 288 * list_window_children 289 * 290 * Build an array of the children of a given window. The array must be 291 * freed with HeapFree. Returns NULL when no windows are found. 292 */ 293 static HWND *list_window_children( HDESK desktop, HWND hwnd, LPCWSTR class, DWORD tid ) 294 { 295 HWND *list; 296 int i, size = 128; 297 ATOM atom = get_int_atom_value( class ); 298 299 /* empty class is not the same as NULL class */ 300 if (!atom && class && !class[0]) return NULL; 301 302 for (;;) 303 { 304 int count = 0; 305 306 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break; 307 308 SERVER_START_REQ( get_window_children ) 309 { 310 req->desktop = wine_server_obj_handle( desktop ); 311 req->parent = wine_server_user_handle( hwnd ); 312 req->tid = tid; 313 req->atom = atom; 314 if (!atom && class) wine_server_add_data( req, class, strlenW(class)*sizeof(WCHAR) ); 315 wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) ); 316 if (!wine_server_call( req )) count = reply->count; 317 } 318 SERVER_END_REQ; 319 if (count && count < size) 320 { 321 /* start from the end since HWND is potentially larger than user_handle_t */ 322 for (i = count - 1; i >= 0; i--) 323 list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] ); 324 list[count] = 0; 325 return list; 326 } 327 HeapFree( GetProcessHeap(), 0, list ); 328 if (!count) break; 329 size = count + 1; /* restart with a large enough buffer */ 330 } 331 return NULL; 332 } 333 334 335 /******************************************************************* 336 * list_window_parents 337 * 338 * Build an array of all parents of a given window, starting with 339 * the immediate parent. The array must be freed with HeapFree. 340 */ 341 static HWND *list_window_parents( HWND hwnd ) 342 { 343 WND *win; 344 HWND current, *list; 345 int i, pos = 0, size = 16, count = 0; 346 347 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL; 348 349 current = hwnd; 350 for (;;) 351 { 352 if (!(win = WIN_GetPtr( current ))) goto empty; 353 if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */ 354 if (win == WND_DESKTOP) 355 { 356 if (!pos) goto empty; 357 list[pos] = 0; 358 return list; 359 } 360 list[pos] = current = win->parent; 361 WIN_ReleasePtr( win ); 362 if (!current) return list; 363 if (++pos == size - 1) 364 { 365 /* need to grow the list */ 366 HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) ); 367 if (!new_list) goto empty; 368 list = new_list; 369 size += 16; 370 } 371 } 372 373 /* at least one parent belongs to another process, have to query the server */ 374 375 for (;;) 376 { 377 count = 0; 378 SERVER_START_REQ( get_window_parents ) 379 { 380 req->handle = wine_server_user_handle( hwnd ); 381 wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) ); 382 if (!wine_server_call( req )) count = reply->count; 383 } 384 SERVER_END_REQ; 385 if (!count) goto empty; 386 if (size > count) 387 { 388 /* start from the end since HWND is potentially larger than user_handle_t */ 389 for (i = count - 1; i >= 0; i--) 390 list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] ); 391 list[count] = 0; 392 return list; 393 } 394 HeapFree( GetProcessHeap(), 0, list ); 395 size = count + 1; 396 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL; 397 } 398 399 empty: 400 HeapFree( GetProcessHeap(), 0, list ); 401 return NULL; 402 } 403 404 405 /******************************************************************* 406 * send_parent_notify 407 */ 408 static void send_parent_notify( HWND hwnd, UINT msg ) 409 { 410 if ((GetWindowLongW( hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD && 411 !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY)) 412 { 413 HWND parent = GetParent(hwnd); 414 if (parent && parent != GetDesktopWindow()) 415 SendMessageW( parent, WM_PARENTNOTIFY, 416 MAKEWPARAM( msg, GetWindowLongPtrW( hwnd, GWLP_ID )), (LPARAM)hwnd ); 417 } 418 } 419 420 421 /******************************************************************* 422 * get_server_window_text 423 * 424 * Retrieve the window text from the server. 425 */ 426 static void get_server_window_text( HWND hwnd, LPWSTR text, INT count ) 427 { 428 size_t len = 0; 429 430 SERVER_START_REQ( get_window_text ) 431 { 432 req->handle = wine_server_user_handle( hwnd ); 433 wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) ); 434 if (!wine_server_call_err( req )) len = wine_server_reply_size(reply); 435 } 436 SERVER_END_REQ; 437 text[len / sizeof(WCHAR)] = 0; 438 } 439 440 441 /******************************************************************* 442 * get_hwnd_message_parent 443 * 444 * Return the parent for HWND_MESSAGE windows. 445 */ 446 HWND get_hwnd_message_parent(void) 447 { 448 struct user_thread_info *thread_info = get_user_thread_info(); 449 450 if (!thread_info->msg_window) GetDesktopWindow(); /* trigger creation */ 451 return thread_info->msg_window; 452 } 453 454 455 /******************************************************************* 456 * is_desktop_window 457 * 458 * Check if window is the desktop or the HWND_MESSAGE top parent. 459 */ 460 BOOL is_desktop_window( HWND hwnd ) 461 { 462 struct user_thread_info *thread_info = get_user_thread_info(); 463 464 if (!hwnd) return FALSE; 465 if (hwnd == thread_info->top_window) return TRUE; 466 if (hwnd == thread_info->msg_window) return TRUE; 467 468 if (!HIWORD(hwnd) || HIWORD(hwnd) == 0xffff) 469 { 470 if (LOWORD(thread_info->top_window) == LOWORD(hwnd)) return TRUE; 471 if (LOWORD(thread_info->msg_window) == LOWORD(hwnd)) return TRUE; 472 } 473 return FALSE; 474 } 475 476 477 /*********************************************************************** 478 * WIN_GetPtr 479 * 480 * Return a pointer to the WND structure if local to the process, 481 * or WND_OTHER_PROCESS if handle may be valid in other process. 482 * If ret value is a valid pointer, it must be released with WIN_ReleasePtr. 483 */ 484 WND *WIN_GetPtr( HWND hwnd ) 485 { 486 WND *ptr; 487 488 if ((ptr = get_user_handle_ptr( hwnd, USER_WINDOW )) == WND_OTHER_PROCESS) 489 { 490 if (is_desktop_window( hwnd )) ptr = WND_DESKTOP; 491 } 492 return ptr; 493 } 494 495 496 /*********************************************************************** 497 * WIN_IsCurrentProcess 498 * 499 * Check whether a given window belongs to the current process (and return the full handle). 500 */ 501 HWND WIN_IsCurrentProcess( HWND hwnd ) 502 { 503 WND *ptr; 504 HWND ret; 505 506 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0; 507 ret = ptr->obj.handle; 508 WIN_ReleasePtr( ptr ); 509 return ret; 510 } 511 512 513 /*********************************************************************** 514 * WIN_IsCurrentThread 515 * 516 * Check whether a given window belongs to the current thread (and return the full handle). 517 */ 518 HWND WIN_IsCurrentThread( HWND hwnd ) 519 { 520 WND *ptr; 521 HWND ret = 0; 522 523 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0; 524 if (ptr->tid == GetCurrentThreadId()) ret = ptr->obj.handle; 525 WIN_ReleasePtr( ptr ); 526 return ret; 527 } 528 529 530 /*********************************************************************** 531 * WIN_GetFullHandle 532 * 533 * Convert a possibly truncated window handle to a full 32-bit handle. 534 */ 535 HWND WIN_GetFullHandle( HWND hwnd ) 536 { 537 WND *ptr; 538 539 if (!hwnd || (ULONG_PTR)hwnd >> 16) return hwnd; 540 if (LOWORD(hwnd) <= 1 || LOWORD(hwnd) == 0xffff) return hwnd; 541 /* do sign extension for -2 and -3 */ 542 if (LOWORD(hwnd) >= (WORD)-3) return (HWND)(LONG_PTR)(INT16)LOWORD(hwnd); 543 544 if (!(ptr = WIN_GetPtr( hwnd ))) return hwnd; 545 546 if (ptr == WND_DESKTOP) 547 { 548 if (LOWORD(hwnd) == LOWORD(GetDesktopWindow())) return GetDesktopWindow(); 549 else return get_hwnd_message_parent(); 550 } 551 552 if (ptr != WND_OTHER_PROCESS) 553 { 554 hwnd = ptr->obj.handle; 555 WIN_ReleasePtr( ptr ); 556 } 557 else /* may belong to another process */ 558 { 559 SERVER_START_REQ( get_window_info ) 560 { 561 req->handle = wine_server_user_handle( hwnd ); 562 if (!wine_server_call_err( req )) hwnd = wine_server_ptr_handle( reply->full_handle ); 563 } 564 SERVER_END_REQ; 565 } 566 return hwnd; 567 } 568 569 570 /*********************************************************************** 571 * WIN_SetOwner 572 * 573 * Change the owner of a window. 574 */ 575 HWND WIN_SetOwner( HWND hwnd, HWND owner ) 576 { 577 WND *win = WIN_GetPtr( hwnd ); 578 HWND ret = 0; 579 580 if (!win || win == WND_DESKTOP) return 0; 581 if (win == WND_OTHER_PROCESS) 582 { 583 if (IsWindow(hwnd)) ERR( "cannot set owner %p on other process window %p\n", owner, hwnd ); 584 return 0; 585 } 586 SERVER_START_REQ( set_window_owner ) 587 { 588 req->handle = wine_server_user_handle( hwnd ); 589 req->owner = wine_server_user_handle( owner ); 590 if (!wine_server_call( req )) 591 { 592 win->owner = wine_server_ptr_handle( reply->full_owner ); 593 ret = wine_server_ptr_handle( reply->prev_owner ); 594 } 595 } 596 SERVER_END_REQ; 597 WIN_ReleasePtr( win ); 598 return ret; 599 } 600 601 602 /*********************************************************************** 603 * WIN_SetStyle 604 * 605 * Change the style of a window. 606 */ 607 ULONG WIN_SetStyle( HWND hwnd, ULONG set_bits, ULONG clear_bits ) 608 { 609 BOOL ok; 610 STYLESTRUCT style; 611 WND *win = WIN_GetPtr( hwnd ); 612 613 if (!win || win == WND_DESKTOP) return 0; 614 if (win == WND_OTHER_PROCESS) 615 { 616 if (IsWindow(hwnd)) 617 ERR( "cannot set style %x/%x on other process window %p\n", 618 set_bits, clear_bits, hwnd ); 619 return 0; 620 } 621 style.styleOld = win->dwStyle; 622 style.styleNew = (win->dwStyle | set_bits) & ~clear_bits; 623 if (style.styleNew == style.styleOld) 624 { 625 WIN_ReleasePtr( win ); 626 return style.styleNew; 627 } 628 SERVER_START_REQ( set_window_info ) 629 { 630 req->handle = wine_server_user_handle( hwnd ); 631 req->flags = SET_WIN_STYLE; 632 req->style = style.styleNew; 633 req->extra_offset = -1; 634 if ((ok = !wine_server_call( req ))) 635 { 636 style.styleOld = reply->old_style; 637 win->dwStyle = style.styleNew; 638 } 639 } 640 SERVER_END_REQ; 641 WIN_ReleasePtr( win ); 642 if (ok) 643 { 644 USER_Driver->pSetWindowStyle( hwnd, GWL_STYLE, &style ); 645 if ((style.styleOld ^ style.styleNew) & WS_VISIBLE) invalidate_dce( hwnd, NULL ); 646 } 647 return style.styleOld; 648 } 649 650 651 /*********************************************************************** 652 * WIN_GetRectangles 653 * 654 * Get the window and client rectangles. 655 */ 656 BOOL WIN_GetRectangles( HWND hwnd, enum coords_relative relative, RECT *rectWindow, RECT *rectClient ) 657 { 658 WND *win = WIN_GetPtr( hwnd ); 659 BOOL ret = TRUE; 660 661 if (!win) 662 { 663 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 664 return FALSE; 665 } 666 if (win == WND_DESKTOP) 667 { 668 RECT rect; 669 rect.left = rect.top = 0; 670 if (hwnd == get_hwnd_message_parent()) 671 { 672 rect.right = 100; 673 rect.bottom = 100; 674 } 675 else 676 { 677 rect.right = GetSystemMetrics(SM_CXSCREEN); 678 rect.bottom = GetSystemMetrics(SM_CYSCREEN); 679 } 680 if (rectWindow) *rectWindow = rect; 681 if (rectClient) *rectClient = rect; 682 return TRUE; 683 } 684 if (win != WND_OTHER_PROCESS) 685 { 686 RECT window_rect = win->rectWindow, client_rect = win->rectClient; 687 688 switch (relative) 689 { 690 case COORDS_CLIENT: 691 OffsetRect( &window_rect, -win->rectClient.left, -win->rectClient.top ); 692 OffsetRect( &client_rect, -win->rectClient.left, -win->rectClient.top ); 693 if (win->dwExStyle & WS_EX_LAYOUTRTL) 694 mirror_rect( &win->rectClient, &window_rect ); 695 break; 696 case COORDS_WINDOW: 697 OffsetRect( &window_rect, -win->rectWindow.left, -win->rectWindow.top ); 698 OffsetRect( &client_rect, -win->rectWindow.left, -win->rectWindow.top ); 699 if (win->dwExStyle & WS_EX_LAYOUTRTL) 700 mirror_rect( &win->rectWindow, &client_rect ); 701 break; 702 case COORDS_PARENT: 703 if (win->parent) 704 { 705 WND *parent = WIN_GetPtr( win->parent ); 706 if (parent == WND_DESKTOP) break; 707 if (!parent || parent == WND_OTHER_PROCESS) 708 { 709 WIN_ReleasePtr( win ); 710 goto other_process; 711 } 712 if (parent->flags & WIN_CHILDREN_MOVED) 713 { 714 WIN_ReleasePtr( parent ); 715 WIN_ReleasePtr( win ); 716 goto other_process; 717 } 718 if (parent->dwExStyle & WS_EX_LAYOUTRTL) 719 { 720 mirror_rect( &parent->rectClient, &window_rect ); 721 mirror_rect( &parent->rectClient, &client_rect ); 722 } 723 WIN_ReleasePtr( parent ); 724 } 725 break; 726 case COORDS_SCREEN: 727 while (win->parent) 728 { 729 WND *parent = WIN_GetPtr( win->parent ); 730 if (parent == WND_DESKTOP) break; 731 if (!parent || parent == WND_OTHER_PROCESS) 732 { 733 WIN_ReleasePtr( win ); 734 goto other_process; 735 } 736 WIN_ReleasePtr( win ); 737 if (parent->flags & WIN_CHILDREN_MOVED) 738 { 739 WIN_ReleasePtr( parent ); 740 goto other_process; 741 } 742 win = parent; 743 if (win->parent) 744 { 745 OffsetRect( &window_rect, win->rectClient.left, win->rectClient.top ); 746 OffsetRect( &client_rect, win->rectClient.left, win->rectClient.top ); 747 } 748 } 749 break; 750 } 751 if (rectWindow) *rectWindow = window_rect; 752 if (rectClient) *rectClient = client_rect; 753 WIN_ReleasePtr( win ); 754 return TRUE; 755 } 756 757 other_process: 758 SERVER_START_REQ( get_window_rectangles ) 759 { 760 req->handle = wine_server_user_handle( hwnd ); 761 req->relative = relative; 762 if ((ret = !wine_server_call_err( req ))) 763 { 764 if (rectWindow) 765 { 766 rectWindow->left = reply->window.left; 767 rectWindow->top = reply->window.top; 768 rectWindow->right = reply->window.right; 769 rectWindow->bottom = reply->window.bottom; 770 } 771 if (rectClient) 772 { 773 rectClient->left = reply->client.left; 774 rectClient->top = reply->client.top; 775 rectClient->right = reply->client.right; 776 rectClient->bottom = reply->client.bottom; 777 } 778 } 779 } 780 SERVER_END_REQ; 781 return ret; 782 } 783 784 785 /*********************************************************************** 786 * WIN_DestroyWindow 787 * 788 * Destroy storage associated to a window. "Internals" p.358 789 */ 790 LRESULT WIN_DestroyWindow( HWND hwnd ) 791 { 792 WND *wndPtr; 793 HWND *list; 794 HMENU menu = 0, sys_menu; 795 HWND icon_title; 796 797 TRACE("%p\n", hwnd ); 798 799 /* free child windows */ 800 if ((list = WIN_ListChildren( hwnd ))) 801 { 802 int i; 803 for (i = 0; list[i]; i++) 804 { 805 if (WIN_IsCurrentThread( list[i] )) WIN_DestroyWindow( list[i] ); 806 else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 ); 807 } 808 HeapFree( GetProcessHeap(), 0, list ); 809 } 810 811 /* Unlink now so we won't bother with the children later on */ 812 SERVER_START_REQ( set_parent ) 813 { 814 req->handle = wine_server_user_handle( hwnd ); 815 req->parent = 0; 816 wine_server_call( req ); 817 } 818 SERVER_END_REQ; 819 820 /* 821 * Send the WM_NCDESTROY to the window being destroyed. 822 */ 823 SendMessageW( hwnd, WM_NCDESTROY, 0, 0 ); 824 825 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */ 826 827 /* free resources associated with the window */ 828 829 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0; 830 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) 831 menu = (HMENU)wndPtr->wIDmenu; 832 sys_menu = wndPtr->hSysMenu; 833 free_dce( wndPtr->dce, hwnd ); 834 wndPtr->dce = NULL; 835 icon_title = wndPtr->icon_title; 836 HeapFree( GetProcessHeap(), 0, wndPtr->text ); 837 wndPtr->text = NULL; 838 HeapFree( GetProcessHeap(), 0, wndPtr->pScroll ); 839 wndPtr->pScroll = NULL; 840 WIN_ReleasePtr( wndPtr ); 841 842 if (icon_title) DestroyWindow( icon_title ); 843 if (menu) DestroyMenu( menu ); 844 if (sys_menu) DestroyMenu( sys_menu ); 845 846 USER_Driver->pDestroyWindow( hwnd ); 847 848 free_window_handle( hwnd ); 849 return 0; 850 } 851 852 853 /*********************************************************************** 854 * destroy_thread_window 855 * 856 * Destroy a window upon exit of its thread. 857 */ 858 static void destroy_thread_window( HWND hwnd ) 859 { 860 WND *wndPtr; 861 HWND *list; 862 HMENU menu = 0, sys_menu = 0; 863 WORD index; 864 865 /* free child windows */ 866 867 if ((list = WIN_ListChildren( hwnd ))) 868 { 869 int i; 870 for (i = 0; list[i]; i++) 871 { 872 if (WIN_IsCurrentThread( list[i] )) destroy_thread_window( list[i] ); 873 else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 ); 874 } 875 HeapFree( GetProcessHeap(), 0, list ); 876 } 877 878 /* destroy the client-side storage */ 879 880 index = USER_HANDLE_TO_INDEX(hwnd); 881 if (index >= NB_USER_HANDLES) return; 882 USER_Lock(); 883 if ((wndPtr = user_handles[index])) 884 { 885 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) menu = (HMENU)wndPtr->wIDmenu; 886 sys_menu = wndPtr->hSysMenu; 887 free_dce( wndPtr->dce, hwnd ); 888 InterlockedCompareExchangePointer( &user_handles[index], NULL, wndPtr ); 889 } 890 USER_Unlock(); 891 892 HeapFree( GetProcessHeap(), 0, wndPtr ); 893 if (menu) DestroyMenu( menu ); 894 if (sys_menu) DestroyMenu( sys_menu ); 895 } 896 897 898 /*********************************************************************** 899 * destroy_thread_child_windows 900 * 901 * Destroy child windows upon exit of its thread. 902 */ 903 static void destroy_thread_child_windows( HWND hwnd ) 904 { 905 HWND *list; 906 int i; 907 908 if (WIN_IsCurrentThread( hwnd )) 909 { 910 destroy_thread_window( hwnd ); 911 } 912 else if ((list = WIN_ListChildren( hwnd ))) 913 { 914 for (i = 0; list[i]; i++) destroy_thread_child_windows( list[i] ); 915 HeapFree( GetProcessHeap(), 0, list ); 916 } 917 } 918 919 920 /*********************************************************************** 921 * WIN_DestroyThreadWindows 922 * 923 * Destroy all children of 'wnd' owned by the current thread. 924 */ 925 void WIN_DestroyThreadWindows( HWND hwnd ) 926 { 927 HWND *list; 928 int i; 929 930 if (!(list = WIN_ListChildren( hwnd ))) return; 931 932 /* reset owners of top-level windows */ 933 for (i = 0; list[i]; i++) 934 { 935 if (!WIN_IsCurrentThread( list[i] )) 936 { 937 HWND owner = GetWindow( list[i], GW_OWNER ); 938 if (owner && WIN_IsCurrentThread( owner )) WIN_SetOwner( list[i], 0 ); 939 } 940 } 941 942 for (i = 0; list[i]; i++) destroy_thread_child_windows( list[i] ); 943 HeapFree( GetProcessHeap(), 0, list ); 944 } 945 946 947 /*********************************************************************** 948 * WIN_FixCoordinates 949 * 950 * Fix the coordinates - Helper for WIN_CreateWindowEx. 951 * returns default show mode in sw. 952 */ 953 static void WIN_FixCoordinates( CREATESTRUCTW *cs, INT *sw) 954 { 955 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == (SHORT)0x8000) 956 POINT pos[2]; 957 958 if (cs->dwExStyle & WS_EX_MDICHILD) 959 { 960 UINT id = 0; 961 962 MDI_CalcDefaultChildPos(cs->hwndParent, -1, pos, 0, &id); 963 if (!(cs->style & WS_POPUP)) cs->hMenu = ULongToHandle(id); 964 965 TRACE("MDI child id %04x\n", id); 966 } 967 968 if (cs->style & (WS_CHILD | WS_POPUP)) 969 { 970 if (cs->dwExStyle & WS_EX_MDICHILD) 971 { 972 if (IS_DEFAULT(cs->x)) 973 { 974 cs->x = pos[0].x; 975 cs->y = pos[0].y; 976 } 977 if (IS_DEFAULT(cs->cx) || !cs->cx) cs->cx = pos[1].x; 978 if (IS_DEFAULT(cs->cy) || !cs->cy) cs->cy = pos[1].y; 979 } 980 else 981 { 982 if (IS_DEFAULT(cs->x)) cs->x = cs->y = 0; 983 if (IS_DEFAULT(cs->cx)) cs->cx = cs->cy = 0; 984 } 985 } 986 else /* overlapped window */ 987 { 988 HMONITOR monitor; 989 MONITORINFO mon_info; 990 STARTUPINFOW info; 991 992 if (!IS_DEFAULT(cs->x) && !IS_DEFAULT(cs->cx) && !IS_DEFAULT(cs->cy)) return; 993 994 monitor = MonitorFromWindow( cs->hwndParent, MONITOR_DEFAULTTOPRIMARY ); 995 mon_info.cbSize = sizeof(mon_info); 996 GetMonitorInfoW( monitor, &mon_info ); 997 GetStartupInfoW( &info ); 998 999 if (IS_DEFAULT(cs->x)) 1000 { 1001 if (!IS_DEFAULT(cs->y)) *sw = cs->y; 1002 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : mon_info.rcWork.left; 1003 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : mon_info.rcWork.top; 1004 } 1005 1006 if (IS_DEFAULT(cs->cx)) 1007 { 1008 if (info.dwFlags & STARTF_USESIZE) 1009 { 1010 cs->cx = info.dwXSize; 1011 cs->cy = info.dwYSize; 1012 } 1013 else 1014 { 1015 cs->cx = (mon_info.rcWork.right - mon_info.rcWork.left) * 3 / 4 - cs->x; 1016 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y; 1017 } 1018 } 1019 /* neither x nor cx are default. Check the y values . 1020 * In the trace we see Outlook and Outlook Express using 1021 * cy set to CW_USEDEFAULT when opening the address book. 1022 */ 1023 else if (IS_DEFAULT(cs->cy)) 1024 { 1025 FIXME("Strange use of CW_USEDEFAULT in nHeight\n"); 1026 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y; 1027 } 1028 } 1029 #undef IS_DEFAULT 1030 } 1031 1032 /*********************************************************************** 1033 * dump_window_styles 1034 */ 1035 static void dump_window_styles( DWORD style, DWORD exstyle ) 1036 { 1037 TRACE( "style:" ); 1038 if(style & WS_POPUP) TRACE(" WS_POPUP"); 1039 if(style & WS_CHILD) TRACE(" WS_CHILD"); 1040 if(style & WS_MINIMIZE) TRACE(" WS_MINIMIZE"); 1041 if(style & WS_VISIBLE) TRACE(" WS_VISIBLE"); 1042 if(style & WS_DISABLED) TRACE(" WS_DISABLED"); 1043 if(style & WS_CLIPSIBLINGS) TRACE(" WS_CLIPSIBLINGS"); 1044 if(style & WS_CLIPCHILDREN) TRACE(" WS_CLIPCHILDREN"); 1045 if(style & WS_MAXIMIZE) TRACE(" WS_MAXIMIZE"); 1046 if((style & WS_CAPTION) == WS_CAPTION) TRACE(" WS_CAPTION"); 1047 else 1048 { 1049 if(style & WS_BORDER) TRACE(" WS_BORDER"); 1050 if(style & WS_DLGFRAME) TRACE(" WS_DLGFRAME"); 1051 } 1052 if(style & WS_VSCROLL) TRACE(" WS_VSCROLL"); 1053 if(style & WS_HSCROLL) TRACE(" WS_HSCROLL"); 1054 if(style & WS_SYSMENU) TRACE(" WS_SYSMENU"); 1055 if(style & WS_THICKFRAME) TRACE(" WS_THICKFRAME"); 1056 if (style & WS_CHILD) 1057 { 1058 if(style & WS_GROUP) TRACE(" WS_GROUP"); 1059 if(style & WS_TABSTOP) TRACE(" WS_TABSTOP"); 1060 } 1061 else 1062 { 1063 if(style & WS_MINIMIZEBOX) TRACE(" WS_MINIMIZEBOX"); 1064 if(style & WS_MAXIMIZEBOX) TRACE(" WS_MAXIMIZEBOX"); 1065 } 1066 1067 /* FIXME: Add dumping of BS_/ES_/SBS_/LBS_/CBS_/DS_/etc. styles */ 1068 #define DUMPED_STYLES \ 1069 ((DWORD)(WS_POPUP | \ 1070 WS_CHILD | \ 1071 WS_MINIMIZE | \ 1072 WS_VISIBLE | \ 1073 WS_DISABLED | \ 1074 WS_CLIPSIBLINGS | \ 1075 WS_CLIPCHILDREN | \ 1076 WS_MAXIMIZE | \ 1077 WS_BORDER | \ 1078 WS_DLGFRAME | \ 1079 WS_VSCROLL | \ 1080 WS_HSCROLL | \ 1081 WS_SYSMENU | \ 1082 WS_THICKFRAME | \ 1083 WS_GROUP | \ 1084 WS_TABSTOP | \ 1085 WS_MINIMIZEBOX | \ 1086 WS_MAXIMIZEBOX)) 1087 1088 if(style & ~DUMPED_STYLES) TRACE(" %08x", style & ~DUMPED_STYLES); 1089 TRACE("\n"); 1090 #undef DUMPED_STYLES 1091 1092 TRACE( "exstyle:" ); 1093 if(exstyle & WS_EX_DLGMODALFRAME) TRACE(" WS_EX_DLGMODALFRAME"); 1094 if(exstyle & WS_EX_DRAGDETECT) TRACE(" WS_EX_DRAGDETECT"); 1095 if(exstyle & WS_EX_NOPARENTNOTIFY) TRACE(" WS_EX_NOPARENTNOTIFY"); 1096 if(exstyle & WS_EX_TOPMOST) TRACE(" WS_EX_TOPMOST"); 1097 if(exstyle & WS_EX_ACCEPTFILES) TRACE(" WS_EX_ACCEPTFILES"); 1098 if(exstyle & WS_EX_TRANSPARENT) TRACE(" WS_EX_TRANSPARENT"); 1099 if(exstyle & WS_EX_MDICHILD) TRACE(" WS_EX_MDICHILD"); 1100 if(exstyle & WS_EX_TOOLWINDOW) TRACE(" WS_EX_TOOLWINDOW"); 1101 if(exstyle & WS_EX_WINDOWEDGE) TRACE(" WS_EX_WINDOWEDGE"); 1102 if(exstyle & WS_EX_CLIENTEDGE) TRACE(" WS_EX_CLIENTEDGE"); 1103 if(exstyle & WS_EX_CONTEXTHELP) TRACE(" WS_EX_CONTEXTHELP"); 1104 if(exstyle & WS_EX_RIGHT) TRACE(" WS_EX_RIGHT"); 1105 if(exstyle & WS_EX_RTLREADING) TRACE(" WS_EX_RTLREADING"); 1106 if(exstyle & WS_EX_LEFTSCROLLBAR) TRACE(" WS_EX_LEFTSCROLLBAR"); 1107 if(exstyle & WS_EX_CONTROLPARENT) TRACE(" WS_EX_CONTROLPARENT"); 1108 if(exstyle & WS_EX_STATICEDGE) TRACE(" WS_EX_STATICEDGE"); 1109 if(exstyle & WS_EX_APPWINDOW) TRACE(" WS_EX_APPWINDOW"); 1110 if(exstyle & WS_EX_LAYERED) TRACE(" WS_EX_LAYERED"); 1111 if(exstyle & WS_EX_LAYOUTRTL) TRACE(" WS_EX_LAYOUTRTL"); 1112 1113 #define DUMPED_EX_STYLES \ 1114 ((DWORD)(WS_EX_DLGMODALFRAME | \ 1115 WS_EX_DRAGDETECT | \ 1116 WS_EX_NOPARENTNOTIFY | \ 1117 WS_EX_TOPMOST | \ 1118 WS_EX_ACCEPTFILES | \ 1119 WS_EX_TRANSPARENT | \ 1120 WS_EX_MDICHILD | \ 1121 WS_EX_TOOLWINDOW | \ 1122 WS_EX_WINDOWEDGE | \ 1123 WS_EX_CLIENTEDGE | \ 1124 WS_EX_CONTEXTHELP | \ 1125 WS_EX_RIGHT | \ 1126 WS_EX_RTLREADING | \ 1127 WS_EX_LEFTSCROLLBAR | \ 1128 WS_EX_CONTROLPARENT | \ 1129 WS_EX_STATICEDGE | \ 1130 WS_EX_APPWINDOW | \ 1131 WS_EX_LAYERED | \ 1132 WS_EX_LAYOUTRTL)) 1133 1134 if(exstyle & ~DUMPED_EX_STYLES) TRACE(" %08x", exstyle & ~DUMPED_EX_STYLES); 1135 TRACE("\n"); 1136 #undef DUMPED_EX_STYLES 1137 } 1138 1139 1140 /*********************************************************************** 1141 * WIN_CreateWindowEx 1142 * 1143 * Implementation of CreateWindowEx(). 1144 */ 1145 HWND WIN_CreateWindowEx( CREATESTRUCTW *cs, LPCWSTR className, HINSTANCE module, BOOL unicode ) 1146 { 1147 INT cx, cy, style, sw = SW_SHOW; 1148 LRESULT result; 1149 RECT rect; 1150 WND *wndPtr; 1151 HWND hwnd, parent, owner, top_child = 0; 1152 MDICREATESTRUCTW mdi_cs; 1153 CBT_CREATEWNDW cbtc; 1154 CREATESTRUCTW cbcs; 1155 1156 TRACE("%s %s ex=%08x style=%08x %d,%d %dx%d parent=%p menu=%p inst=%p params=%p\n", 1157 unicode ? debugstr_w(cs->lpszName) : debugstr_a((LPCSTR)cs->lpszName), 1158 debugstr_w(className), 1159 cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy, 1160 cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams ); 1161 if(TRACE_ON(win)) dump_window_styles( cs->style, cs->dwExStyle ); 1162 1163 /* Fix the styles for MDI children */ 1164 if (cs->dwExStyle & WS_EX_MDICHILD) 1165 { 1166 UINT flags = 0; 1167 1168 wndPtr = WIN_GetPtr(cs->hwndParent); 1169 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP) 1170 { 1171 flags = wndPtr->flags; 1172 WIN_ReleasePtr(wndPtr); 1173 } 1174 1175 if (!(flags & WIN_ISMDICLIENT)) 1176 { 1177 WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", cs->hwndParent); 1178 return 0; 1179 } 1180 1181 /* cs->lpCreateParams of WM_[NC]CREATE is different for MDI children. 1182 * MDICREATESTRUCT members have the originally passed values. 1183 * 1184 * Note: we rely on the fact that MDICREATESTRUCTA and MDICREATESTRUCTW 1185 * have the same layout. 1186 */ 1187 mdi_cs.szClass = cs->lpszClass; 1188 mdi_cs.szTitle = cs->lpszName; 1189 mdi_cs.hOwner = cs->hInstance; 1190 mdi_cs.x = cs->x; 1191 mdi_cs.y = cs->y; 1192 mdi_cs.cx = cs->cx; 1193 mdi_cs.cy = cs->cy; 1194 mdi_cs.style = cs->style; 1195 mdi_cs.lParam = (LPARAM)cs->lpCreateParams; 1196 1197 cs->lpCreateParams = &mdi_cs; 1198 1199 if (GetWindowLongW(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES) 1200 { 1201 if (cs->style & WS_POPUP) 1202 { 1203 TRACE("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n"); 1204 return 0; 1205 } 1206 cs->style |= WS_CHILD | WS_CLIPSIBLINGS; 1207 } 1208 else 1209 { 1210 cs->style &= ~WS_POPUP; 1211 cs->style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION | 1212 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX; 1213 } 1214 1215 top_child = GetWindow(cs->hwndParent, GW_CHILD); 1216 1217 if (top_child) 1218 { 1219 /* Restore current maximized child */ 1220 if((cs->style & WS_VISIBLE) && IsZoomed(top_child)) 1221 { 1222 TRACE("Restoring current maximized child %p\n", top_child); 1223 if (cs->style & WS_MAXIMIZE) 1224 { 1225 /* if the new window is maximized don't bother repainting */ 1226 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 ); 1227 ShowWindow( top_child, SW_SHOWNORMAL ); 1228 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 ); 1229 } 1230 else ShowWindow( top_child, SW_SHOWNORMAL ); 1231 } 1232 } 1233 } 1234 1235 /* Find the parent window */ 1236 1237 parent = cs->hwndParent; 1238 owner = 0; 1239 1240 if (cs->hwndParent == HWND_MESSAGE) 1241 { 1242 cs->hwndParent = parent = get_hwnd_message_parent(); 1243 } 1244 else if (cs->hwndParent) 1245 { 1246 if ((cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD) 1247 { 1248 parent = GetDesktopWindow(); 1249 owner = cs->hwndParent; 1250 } 1251 else 1252 { 1253 DWORD parent_style = GetWindowLongW( parent, GWL_EXSTYLE ); 1254 if ((parent_style & WS_EX_LAYOUTRTL) && !(parent_style & WS_EX_NOINHERITLAYOUT)) 1255 cs->dwExStyle |= WS_EX_LAYOUTRTL; 1256 } 1257 } 1258 else 1259 { 1260 static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0}; 1261 1262 if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) 1263 { 1264 WARN("No parent for child window\n" ); 1265 SetLastError(ERROR_TLW_WITH_WSCHILD); 1266 return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */ 1267 } 1268 /* are we creating the desktop or HWND_MESSAGE parent itself? */ 1269 if (className != (LPCWSTR)DESKTOP_CLASS_ATOM && 1270 (IS_INTRESOURCE(className) || strcmpiW( className, messageW ))) 1271 { 1272 DWORD layout; 1273 GetProcessDefaultLayout( &layout ); 1274 if (layout & LAYOUT_RTL) cs->dwExStyle |= WS_EX_LAYOUTRTL; 1275 parent = GetDesktopWindow(); 1276 } 1277 } 1278 1279 WIN_FixCoordinates(cs, &sw); /* fix default coordinates */ 1280 1281 if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) || 1282 ((!(cs->dwExStyle & WS_EX_STATICEDGE)) && 1283 (cs->style & (WS_DLGFRAME | WS_THICKFRAME)))) 1284 cs->dwExStyle |= WS_EX_WINDOWEDGE; 1285 else 1286 cs->dwExStyle &= ~WS_EX_WINDOWEDGE; 1287 1288 /* Create the window structure */ 1289 1290 if (!(wndPtr = create_window_handle( parent, owner, className, module, unicode ))) 1291 return 0; 1292 hwnd = wndPtr->obj.handle; 1293 1294 /* Fill the window structure */ 1295 1296 wndPtr->tid = GetCurrentThreadId(); 1297 wndPtr->hInstance = cs->hInstance; 1298 wndPtr->text = NULL; 1299 wndPtr->dwStyle = cs->style & ~WS_VISIBLE; 1300 wndPtr->dwExStyle = cs->dwExStyle; 1301 wndPtr->wIDmenu = 0; 1302 wndPtr->helpContext = 0; 1303 wndPtr->pScroll = NULL; 1304 wndPtr->userdata = 0; 1305 wndPtr->hIcon = 0; 1306 wndPtr->hIconSmall = 0; 1307 wndPtr->hSysMenu = 0; 1308 1309 wndPtr->min_pos.x = wndPtr->min_pos.y = -1; 1310 wndPtr->max_pos.x = wndPtr->max_pos.y = -1; 1311 1312 if (wndPtr->dwStyle & WS_SYSMENU) SetSystemMenu( hwnd, 0 ); 1313 1314 /* 1315 * Correct the window styles. 1316 * 1317 * It affects only the style loaded into the WIN structure. 1318 */ 1319 1320 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) 1321 { 1322 wndPtr->dwStyle |= WS_CLIPSIBLINGS; 1323 if (!(wndPtr->dwStyle & WS_POPUP)) 1324 wndPtr->dwStyle |= WS_CAPTION; 1325 } 1326 1327 /* WS_EX_WINDOWEDGE depends on some other styles */ 1328 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) 1329 wndPtr->dwExStyle |= WS_EX_WINDOWEDGE; 1330 else if (wndPtr->dwStyle & (WS_DLGFRAME | WS_THICKFRAME)) 1331 { 1332 if (!((wndPtr->dwExStyle & WS_EX_STATICEDGE) && 1333 (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)))) 1334 wndPtr->dwExStyle |= WS_EX_WINDOWEDGE; 1335 } 1336 else 1337 wndPtr->dwExStyle &= ~WS_EX_WINDOWEDGE; 1338 1339 if (!(wndPtr->dwStyle & (WS_CHILD | WS_POPUP))) 1340 wndPtr->flags |= WIN_NEED_SIZE; 1341 1342 SERVER_START_REQ( set_window_info ) 1343 { 1344 req->handle = wine_server_user_handle( hwnd ); 1345 req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE | SET_WIN_UNICODE; 1346 req->style = wndPtr->dwStyle; 1347 req->ex_style = wndPtr->dwExStyle; 1348 req->instance = wine_server_client_ptr( wndPtr->hInstance ); 1349 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0; 1350 req->extra_offset = -1; 1351 wine_server_call( req ); 1352 } 1353 SERVER_END_REQ; 1354 1355 /* Set the window menu */ 1356 1357 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) 1358 { 1359 if (cs->hMenu) 1360 { 1361 if (!MENU_SetMenu(hwnd, cs->hMenu)) 1362 { 1363 WIN_ReleasePtr( wndPtr ); 1364 free_window_handle( hwnd ); 1365 return 0; 1366 } 1367 } 1368 else 1369 { 1370 LPCWSTR menuName = (LPCWSTR)GetClassLongPtrW( hwnd, GCLP_MENUNAME ); 1371 if (menuName) 1372 { 1373 cs->hMenu = LoadMenuW( cs->hInstance, menuName ); 1374 if (cs->hMenu) MENU_SetMenu( hwnd, cs->hMenu ); 1375 } 1376 } 1377 } 1378 else SetWindowLongPtrW( hwnd, GWLP_ID, (ULONG_PTR)cs->hMenu ); 1379 1380 /* call the WH_CBT hook */ 1381 1382 /* the window style passed to the hook must be the real window style, 1383 * rather than just the window style that the caller to CreateWindowEx 1384 * passed in, so we have to copy the original CREATESTRUCT and get the 1385 * the real style. */ 1386 cbcs = *cs; 1387 cbcs.style = wndPtr->dwStyle; 1388 cbtc.lpcs = &cbcs; 1389 cbtc.hwndInsertAfter = HWND_TOP; 1390 WIN_ReleasePtr( wndPtr ); 1391 if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode )) goto failed; 1392 1393 /* send the WM_GETMINMAXINFO message and fix the size if needed */ 1394 1395 cx = cs->cx; 1396 cy = cs->cy; 1397 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD))) 1398 { 1399 POINT maxSize, maxPos, minTrack, maxTrack; 1400 WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack); 1401 if (maxTrack.x < cx) cx = maxTrack.x; 1402 if (maxTrack.y < cy) cy = maxTrack.y; 1403 if (minTrack.x > cx) cx = minTrack.x; 1404 if (minTrack.y > cy) cy = minTrack.y; 1405 } 1406 1407 if (cx < 0) cx = 0; 1408 if (cy < 0) cy = 0; 1409 SetRect( &rect, cs->x, cs->y, cs->x + cx, cs->y + cy ); 1410 /* check for wraparound */ 1411 if (cs->x + cx < cs->x) rect.right = 0x7fffffff; 1412 if (cs->y + cy < cs->y) rect.bottom = 0x7fffffff; 1413 if (!set_window_pos( hwnd, 0, SWP_NOZORDER | SWP_NOACTIVATE, &rect, &rect, NULL )) goto failed; 1414 1415 /* send WM_NCCREATE */ 1416 1417 TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cx, cy ); 1418 if (unicode) 1419 result = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs ); 1420 else 1421 result = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs ); 1422 if (!result) 1423 { 1424 WARN( "%p: aborted by WM_NCCREATE\n", hwnd ); 1425 goto failed; 1426 } 1427 1428 /* send WM_NCCALCSIZE */ 1429 1430 if (WIN_GetRectangles( hwnd, COORDS_PARENT, &rect, NULL )) 1431 { 1432 /* yes, even if the CBT hook was called with HWND_TOP */ 1433 HWND insert_after = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) ? HWND_BOTTOM : HWND_TOP; 1434 RECT client_rect = rect; 1435 1436 /* the rectangle is in screen coords for WM_NCCALCSIZE when wparam is FALSE */ 1437 MapWindowPoints( parent, 0, (POINT *)&client_rect, 2 ); 1438 SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&client_rect ); 1439 MapWindowPoints( 0, parent, (POINT *)&client_rect, 2 ); 1440 set_window_pos( hwnd, insert_after, SWP_NOACTIVATE, &rect, &client_rect, NULL ); 1441 } 1442 else return 0; 1443 1444 /* send WM_CREATE */ 1445 1446 if (unicode) 1447 result = SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs ); 1448 else 1449 result = SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs ); 1450 if (result == -1) goto failed; 1451 1452 /* call the driver */ 1453 1454 if (!USER_Driver->pCreateWindow( hwnd )) goto failed; 1455 1456 NotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_WINDOW, 0); 1457 1458 /* send the size messages */ 1459 1460 if (!(wndPtr = WIN_GetPtr( hwnd )) || 1461 wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0; 1462 if (!(wndPtr->flags & WIN_NEED_SIZE)) 1463 { 1464 WIN_ReleasePtr( wndPtr ); 1465 WIN_GetRectangles( hwnd, COORDS_PARENT, NULL, &rect ); 1466 SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED, 1467 MAKELONG(rect.right-rect.left, rect.bottom-rect.top)); 1468 SendMessageW( hwnd, WM_MOVE, 0, MAKELONG( rect.left, rect.top ) ); 1469 } 1470 else WIN_ReleasePtr( wndPtr ); 1471 1472 /* Show the window, maximizing or minimizing if needed */ 1473 1474 style = WIN_SetStyle( hwnd, 0, WS_MAXIMIZE | WS_MINIMIZE ); 1475 if (style & (WS_MINIMIZE | WS_MAXIMIZE)) 1476 { 1477 RECT newPos; 1478 UINT swFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE; 1479 1480 swFlag = WINPOS_MinMaximize( hwnd, swFlag, &newPos ); 1481 swFlag |= SWP_FRAMECHANGED; /* Frame always gets changed */ 1482 if (!(style & WS_VISIBLE) || (style & WS_CHILD) || GetActiveWindow()) swFlag |= SWP_NOACTIVATE; 1483 SetWindowPos( hwnd, 0, newPos.left, newPos.top, newPos.right - newPos.left, 1484 newPos.bottom - newPos.top, swFlag ); 1485 } 1486 1487 /* Notify the parent window only */ 1488 1489 send_parent_notify( hwnd, WM_CREATE ); 1490 if (!IsWindow( hwnd )) return 0; 1491 1492 if (cs->style & WS_VISIBLE) 1493 { 1494 if (cs->style & WS_MAXIMIZE) 1495 sw = SW_SHOW; 1496 else if (cs->style & WS_MINIMIZE) 1497 sw = SW_SHOWMINIMIZED; 1498 1499 ShowWindow( hwnd, sw ); 1500 if (cs->dwExStyle & WS_EX_MDICHILD) 1501 { 1502 SendMessageW(cs->hwndParent, WM_MDIREFRESHMENU, 0, 0); 1503 /* ShowWindow won't activate child windows */ 1504 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE ); 1505 } 1506 } 1507 1508 /* Call WH_SHELL hook */ 1509 1510 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER )) 1511 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE ); 1512 1513 TRACE("created window %p\n", hwnd); 1514 return hwnd; 1515 1516 failed: 1517 WIN_DestroyWindow( hwnd ); 1518 return 0; 1519 } 1520 1521 1522 /*********************************************************************** 1523 * CreateWindowExA (USER32.@) 1524 */ 1525 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className, 1526 LPCSTR windowName, DWORD style, INT x, 1527 INT y, INT width, INT height, 1528 HWND parent, HMENU menu, 1529 HINSTANCE instance, LPVOID data ) 1530 { 1531 CREATESTRUCTA cs; 1532 1533 cs.lpCreateParams = data; 1534 cs.hInstance = instance; 1535 cs.hMenu = menu; 1536 cs.hwndParent = parent; 1537 cs.x = x; 1538 cs.y = y; 1539 cs.cx = width; 1540 cs.cy = height; 1541 cs.style = style; 1542 cs.lpszName = windowName; 1543 cs.lpszClass = className; 1544 cs.dwExStyle = exStyle; 1545 1546 if (!IS_INTRESOURCE(className)) 1547 { 1548 WCHAR bufferW[256]; 1549 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) )) 1550 return 0; 1551 return wow_handlers.create_window( (CREATESTRUCTW *)&cs, bufferW, instance, FALSE ); 1552 } 1553 /* Note: we rely on the fact that CREATESTRUCTA and */ 1554 /* CREATESTRUCTW have the same layout. */ 1555 return wow_handlers.create_window( (CREATESTRUCTW *)&cs, (LPCWSTR)className, instance, FALSE ); 1556 } 1557 1558 1559 /*********************************************************************** 1560 * CreateWindowExW (USER32.@) 1561 */ 1562 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className, 1563 LPCWSTR windowName, DWORD style, INT x, 1564 INT y, INT width, INT height, 1565 HWND parent, HMENU menu, 1566 HINSTANCE instance, LPVOID data ) 1567 { 1568 CREATESTRUCTW cs; 1569 1570 cs.lpCreateParams = data; 1571 cs.hInstance = instance; 1572 cs.hMenu = menu; 1573 cs.hwndParent = parent; 1574 cs.x = x; 1575 cs.y = y; 1576 cs.cx = width; 1577 cs.cy = height; 1578 cs.style = style; 1579 cs.lpszName = windowName; 1580 cs.lpszClass = className; 1581 cs.dwExStyle = exStyle; 1582 1583 return wow_handlers.create_window( &cs, className, instance, TRUE ); 1584 } 1585 1586 1587 /*********************************************************************** 1588 * WIN_SendDestroyMsg 1589 */ 1590 static void WIN_SendDestroyMsg( HWND hwnd ) 1591 { 1592 GUITHREADINFO info; 1593 1594 info.cbSize = sizeof(info); 1595 if (GetGUIThreadInfo( GetCurrentThreadId(), &info )) 1596 { 1597 if (hwnd == info.hwndCaret) DestroyCaret(); 1598 if (hwnd == info.hwndActive) WINPOS_ActivateOtherWindow( hwnd ); 1599 } 1600 1601 /* 1602 * Send the WM_DESTROY to the window. 1603 */ 1604 SendMessageW( hwnd, WM_DESTROY, 0, 0); 1605 1606 /* 1607 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow 1608 * make sure that the window still exists when we come back. 1609 */ 1610 if (IsWindow(hwnd)) 1611 { 1612 HWND* pWndArray; 1613 int i; 1614 1615 if (!(pWndArray = WIN_ListChildren( hwnd ))) return; 1616 1617 for (i = 0; pWndArray[i]; i++) 1618 { 1619 if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] ); 1620 } 1621 HeapFree( GetProcessHeap(), 0, pWndArray ); 1622 } 1623 else 1624 WARN("\tdestroyed itself while in WM_DESTROY!\n"); 1625 } 1626 1627 1628 /*********************************************************************** 1629 * DestroyWindow (USER32.@) 1630 */ 1631 BOOL WINAPI DestroyWindow( HWND hwnd ) 1632 { 1633 BOOL is_child; 1634 1635 if (!(hwnd = WIN_IsCurrentThread( hwnd )) || is_desktop_window( hwnd )) 1636 { 1637 SetLastError( ERROR_ACCESS_DENIED ); 1638 return FALSE; 1639 } 1640 1641 TRACE("(%p)\n", hwnd); 1642 1643 /* Call hooks */ 1644 1645 if (HOOK_CallHooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE; 1646 1647 if (MENU_IsMenuActive() == hwnd) 1648 EndMenu(); 1649 1650 is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0; 1651 1652 if (is_child) 1653 { 1654 if (!USER_IsExitingThread( GetCurrentThreadId() )) 1655 send_parent_notify( hwnd, WM_DESTROY ); 1656 } 1657 else if (!GetWindow( hwnd, GW_OWNER )) 1658 { 1659 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE ); 1660 /* FIXME: clean up palette - see "Internals" p.352 */ 1661 } 1662 1663 if (!IsWindow(hwnd)) return TRUE; 1664 1665 /* Hide the window */ 1666 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE) 1667 { 1668 /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */ 1669 if (is_child) 1670 ShowWindow( hwnd, SW_HIDE ); 1671 else 1672 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | 1673 SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW ); 1674 } 1675 1676 if (!IsWindow(hwnd)) return TRUE; 1677 1678 /* Recursively destroy owned windows */ 1679 1680 if (!is_child) 1681 { 1682 for (;;) 1683 { 1684 int i, got_one = 0; 1685 HWND *list = WIN_ListChildren( GetDesktopWindow() ); 1686 if (list) 1687 { 1688 for (i = 0; list[i]; i++) 1689 { 1690 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue; 1691 if (WIN_IsCurrentThread( list[i] )) 1692 { 1693 DestroyWindow( list[i] ); 1694 got_one = 1; 1695 continue; 1696 } 1697 WIN_SetOwner( list[i], 0 ); 1698 } 1699 HeapFree( GetProcessHeap(), 0, list ); 1700 } 1701 if (!got_one) break; 1702 } 1703 } 1704 1705 /* Send destroy messages */ 1706 1707 WIN_SendDestroyMsg( hwnd ); 1708 if (!IsWindow( hwnd )) return TRUE; 1709 1710 if (GetClipboardOwner() == hwnd) 1711 CLIPBOARD_ReleaseOwner(); 1712 1713 /* Destroy the window storage */ 1714 1715 WIN_DestroyWindow( hwnd ); 1716 return TRUE; 1717 } 1718 1719 1720 /*********************************************************************** 1721 * CloseWindow (USER32.@) 1722 */ 1723 BOOL WINAPI CloseWindow( HWND hwnd ) 1724 { 1725 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE; 1726 ShowWindow( hwnd, SW_MINIMIZE ); 1727 return TRUE; 1728 } 1729 1730 1731 /*********************************************************************** 1732 * OpenIcon (USER32.@) 1733 */ 1734 BOOL WINAPI OpenIcon( HWND hwnd ) 1735 { 1736 if (!IsIconic( hwnd )) return FALSE; 1737 ShowWindow( hwnd, SW_SHOWNORMAL ); 1738 return TRUE; 1739 } 1740 1741 1742 /*********************************************************************** 1743 * FindWindowExW (USER32.@) 1744 */ 1745 HWND WINAPI FindWindowExW( HWND parent, HWND child, LPCWSTR className, LPCWSTR title ) 1746 { 1747 HWND *list = NULL; 1748 HWND retvalue = 0; 1749 int i = 0, len = 0; 1750 WCHAR *buffer = NULL; 1751 1752 if (!parent && child) parent = GetDesktopWindow(); 1753 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent(); 1754 1755 if (title) 1756 { 1757 len = strlenW(title) + 1; /* one extra char to check for chars beyond the end */ 1758 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0; 1759 } 1760 1761 if (!(list = list_window_children( 0, parent, className, 0 ))) goto done; 1762 1763 if (child) 1764 { 1765 child = WIN_GetFullHandle( child ); 1766 while (list[i] && list[i] != child) i++; 1767 if (!list[i]) goto done; 1768 i++; /* start from next window */ 1769 } 1770 1771 if (title) 1772 { 1773 while (list[i]) 1774 { 1775 if (GetWindowTextW( list[i], buffer, len + 1 )) 1776 { 1777 if (!strcmpiW( buffer, title )) break; 1778 } 1779 else 1780 { 1781 if (!title[0]) break; 1782 } 1783 i++; 1784 } 1785 } 1786 retvalue = list[i]; 1787 1788 done: 1789 HeapFree( GetProcessHeap(), 0, list ); 1790 HeapFree( GetProcessHeap(), 0, buffer ); 1791 return retvalue; 1792 } 1793 1794 1795 1796 /*********************************************************************** 1797 * FindWindowA (USER32.@) 1798 */ 1799 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title ) 1800 { 1801 HWND ret = FindWindowExA( 0, 0, className, title ); 1802 if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS); 1803 return ret; 1804 } 1805 1806 1807 /*********************************************************************** 1808 * FindWindowExA (USER32.@) 1809 */ 1810 HWND WINAPI FindWindowExA( HWND parent, HWND child, LPCSTR className, LPCSTR title ) 1811 { 1812 LPWSTR titleW = NULL; 1813 HWND hwnd = 0; 1814 1815 if (title) 1816 { 1817 DWORD len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 ); 1818 if (!(titleW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0; 1819 MultiByteToWideChar( CP_ACP, 0, title, -1, titleW, len ); 1820 } 1821 1822 if (!IS_INTRESOURCE(className)) 1823 { 1824 WCHAR classW[256]; 1825 if (MultiByteToWideChar( CP_ACP, 0, className, -1, classW, sizeof(classW)/sizeof(WCHAR) )) 1826 hwnd = FindWindowExW( parent, child, classW, titleW ); 1827 } 1828 else 1829 { 1830 hwnd = FindWindowExW( parent, child, (LPCWSTR)className, titleW ); 1831 } 1832 1833 HeapFree( GetProcessHeap(), 0, titleW ); 1834 return hwnd; 1835 } 1836 1837 1838 /*********************************************************************** 1839 * FindWindowW (USER32.@) 1840 */ 1841 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title ) 1842 { 1843 return FindWindowExW( 0, 0, className, title ); 1844 } 1845 1846 1847 /********************************************************************** 1848 * GetDesktopWindow (USER32.@) 1849 */ 1850 HWND WINAPI GetDesktopWindow(void) 1851 { 1852 struct user_thread_info *thread_info = get_user_thread_info(); 1853 1854 if (thread_info->top_window) return thread_info->top_window; 1855 1856 SERVER_START_REQ( get_desktop_window ) 1857 { 1858 req->force = 0; 1859 if (!wine_server_call( req )) 1860 { 1861 thread_info->top_window = wine_server_ptr_handle( reply->top_window ); 1862 thread_info->msg_window = wine_server_ptr_handle( reply->msg_window ); 1863 } 1864 } 1865 SERVER_END_REQ; 1866 1867 if (!thread_info->top_window) 1868 { 1869 USEROBJECTFLAGS flags; 1870 if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_FLAGS, &flags, 1871 sizeof(flags), NULL ) || (flags.dwFlags & WSF_VISIBLE)) 1872 { 1873 static const WCHAR explorer[] = {'\\','e','x','p','l','o','r','e','r','.','e','x','e',0}; 1874 static const WCHAR args[] = {' ','/','d','e','s','k','t','o','p',0}; 1875 STARTUPINFOW si; 1876 PROCESS_INFORMATION pi; 1877 WCHAR windir[MAX_PATH]; 1878 WCHAR app[MAX_PATH + sizeof(explorer)/sizeof(WCHAR)]; 1879 WCHAR cmdline[MAX_PATH + (sizeof(explorer) + sizeof(args))/sizeof(WCHAR)]; 1880 void *redir; 1881 1882 memset( &si, 0, sizeof(si) ); 1883 si.cb = sizeof(si); 1884 si.dwFlags = STARTF_USESTDHANDLES; 1885 si.hStdInput = 0; 1886 si.hStdOutput = 0; 1887 si.hStdError = GetStdHandle( STD_ERROR_HANDLE ); 1888 1889 GetSystemDirectoryW( windir, MAX_PATH ); 1890 strcpyW( app, windir ); 1891 strcatW( app, explorer ); 1892 strcpyW( cmdline, app ); 1893 strcatW( cmdline, args ); 1894 1895 Wow64DisableWow64FsRedirection( &redir ); 1896 if (CreateProcessW( app, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS, 1897 NULL, windir, &si, &pi )) 1898 { 1899 TRACE( "started explorer pid %04x tid %04x\n", pi.dwProcessId, pi.dwThreadId ); 1900 WaitForInputIdle( pi.hProcess, 10000 ); 1901 CloseHandle( pi.hThread ); 1902 CloseHandle( pi.hProcess ); 1903 } 1904 else WARN( "failed to start explorer, err %d\n", GetLastError() ); 1905 Wow64RevertWow64FsRedirection( redir ); 1906 } 1907 else TRACE( "not starting explorer since winstation is not visible\n" ); 1908 1909 SERVER_START_REQ( get_desktop_window ) 1910 { 1911 req->force = 1; 1912 if (!wine_server_call( req )) 1913 { 1914 thread_info->top_window = wine_server_ptr_handle( reply->top_window ); 1915 thread_info->msg_window = wine_server_ptr_handle( reply->msg_window ); 1916 } 1917 } 1918 SERVER_END_REQ; 1919 } 1920 1921 if (!thread_info->top_window || !USER_Driver->pCreateDesktopWindow( thread_info->top_window )) 1922 ERR( "failed to create desktop window\n" ); 1923 1924 return thread_info->top_window; 1925 } 1926 1927 1928 /******************************************************************* 1929 * EnableWindow (USER32.@) 1930 */ 1931 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable ) 1932 { 1933 BOOL retvalue; 1934 HWND full_handle; 1935 1936 if (is_broadcast(hwnd)) 1937 { 1938 SetLastError( ERROR_INVALID_PARAMETER ); 1939 return FALSE; 1940 } 1941 1942 if (!(full_handle = WIN_IsCurrentThread( hwnd ))) 1943 return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 ); 1944 1945 hwnd = full_handle; 1946 1947 TRACE("( %p, %d )\n", hwnd, enable); 1948 1949 retvalue = !IsWindowEnabled( hwnd ); 1950 1951 if (enable && retvalue) 1952 { 1953 WIN_SetStyle( hwnd, 0, WS_DISABLED ); 1954 SendMessageW( hwnd, WM_ENABLE, TRUE, 0 ); 1955 } 1956 else if (!enable && !retvalue) 1957 { 1958 HWND capture_wnd; 1959 1960 SendMessageW( hwnd, WM_CANCELMODE, 0, 0); 1961 1962 WIN_SetStyle( hwnd, WS_DISABLED, 0 ); 1963 1964 if (hwnd == GetFocus()) 1965 SetFocus( 0 ); /* A disabled window can't have the focus */ 1966 1967 capture_wnd = GetCapture(); 1968 if (hwnd == capture_wnd || IsChild(hwnd, capture_wnd)) 1969 ReleaseCapture(); /* A disabled window can't capture the mouse */ 1970 1971 SendMessageW( hwnd, WM_ENABLE, FALSE, 0 ); 1972 } 1973 return retvalue; 1974 } 1975 1976 1977 /*********************************************************************** 1978 * IsWindowEnabled (USER32.@) 1979 */ 1980 BOOL WINAPI IsWindowEnabled(HWND hWnd) 1981 { 1982 return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED); 1983 } 1984 1985 1986 /*********************************************************************** 1987 * IsWindowUnicode (USER32.@) 1988 */ 1989 BOOL WINAPI IsWindowUnicode( HWND hwnd ) 1990 { 1991 WND * wndPtr; 1992 BOOL retvalue = FALSE; 1993 1994 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE; 1995 1996 if (wndPtr == WND_DESKTOP) return TRUE; 1997 1998 if (wndPtr != WND_OTHER_PROCESS) 1999 { 2000 retvalue = (wndPtr->flags & WIN_ISUNICODE) != 0; 2001 WIN_ReleasePtr( wndPtr ); 2002 } 2003 else 2004 { 2005 SERVER_START_REQ( get_window_info ) 2006 { 2007 req->handle = wine_server_user_handle( hwnd ); 2008 if (!wine_server_call_err( req )) retvalue = reply->is_unicode; 2009 } 2010 SERVER_END_REQ; 2011 } 2012 return retvalue; 2013 } 2014 2015 2016 /********************************************************************** 2017 * WIN_GetWindowLong 2018 * 2019 * Helper function for GetWindowLong(). 2020 */ 2021 static LONG_PTR WIN_GetWindowLong( HWND hwnd, INT offset, UINT size, BOOL unicode ) 2022 { 2023 LONG_PTR retvalue = 0; 2024 WND *wndPtr; 2025 2026 if (offset == GWLP_HWNDPARENT) 2027 { 2028 HWND parent = GetAncestor( hwnd, GA_PARENT ); 2029 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER ); 2030 return (ULONG_PTR)parent; 2031 } 2032 2033 if (!(wndPtr = WIN_GetPtr( hwnd ))) 2034 { 2035 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 2036 return 0; 2037 } 2038 2039 if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) 2040 { 2041 if (offset == GWLP_WNDPROC) 2042 { 2043 SetLastError( ERROR_ACCESS_DENIED ); 2044 return 0; 2045 } 2046 SERVER_START_REQ( set_window_info ) 2047 { 2048 req->handle = wine_server_user_handle( hwnd ); 2049 req->flags = 0; /* don't set anything, just retrieve */ 2050 req->extra_offset = (offset >= 0) ? offset : -1; 2051 req->extra_size = (offset >= 0) ? size : 0; 2052 if (!wine_server_call_err( req )) 2053 { 2054 switch(offset) 2055 { 2056 case GWL_STYLE: retvalue = reply->old_style; break; 2057 case GWL_EXSTYLE: retvalue = reply->old_ex_style; break; 2058 case GWLP_ID: retvalue = reply->old_id; break; 2059 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wine_server_get_ptr( reply->old_instance ); break; 2060 case GWLP_USERDATA: retvalue = reply->old_user_data; break; 2061 default: 2062 if (offset >= 0) retvalue = get_win_data( &reply->old_extra_value, size ); 2063 else SetLastError( ERROR_INVALID_INDEX ); 2064 break; 2065 } 2066 } 2067 } 2068 SERVER_END_REQ; 2069 return retvalue; 2070 } 2071 2072 /* now we have a valid wndPtr */ 2073 2074 if (offset >= 0) 2075 { 2076 if (offset > (int)(wndPtr->cbWndExtra - size)) 2077 { 2078 WARN("Invalid offset %d\n", offset ); 2079 WIN_ReleasePtr( wndPtr ); 2080 SetLastError( ERROR_INVALID_INDEX ); 2081 return 0; 2082 } 2083 retvalue = get_win_data( (char *)wndPtr->wExtra + offset, size ); 2084 2085 /* Special case for dialog window procedure */ 2086 if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && wndPtr->dlgInfo) 2087 retvalue = (LONG_PTR)WINPROC_GetProc( (WNDPROC)retvalue, unicode ); 2088 WIN_ReleasePtr( wndPtr ); 2089 return retvalue; 2090 } 2091 2092 switch(offset) 2093 { 2094 case GWLP_USERDATA: retvalue = wndPtr->userdata; break; 2095 case GWL_STYLE: retvalue = wndPtr->dwStyle; break; 2096 case GWL_EXSTYLE: retvalue = wndPtr->dwExStyle; break; 2097 case GWLP_ID: retvalue = wndPtr->wIDmenu; break; 2098 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hInstance; break; 2099 case GWLP_WNDPROC: 2100 /* This looks like a hack only for the edit control (see tests). This makes these controls 2101 * more tolerant to A/W mismatches. The lack of W->A->W conversion for such a mismatch suggests 2102 * that the hack is in GetWindowLongPtr[AW], not in winprocs. 2103 */ 2104 if (wndPtr->winproc == BUILTIN_WINPROC(WINPROC_EDIT) && (!unicode != !(wndPtr->flags & WIN_ISUNICODE))) 2105 retvalue = (ULONG_PTR)wndPtr->winproc; 2106 else 2107 retvalue = (ULONG_PTR)WINPROC_GetProc( wndPtr->winproc, unicode ); 2108 break; 2109 default: 2110 WARN("Unknown offset %d\n", offset ); 2111 SetLastError( ERROR_INVALID_INDEX ); 2112 break; 2113 } 2114 WIN_ReleasePtr(wndPtr); 2115 return retvalue; 2116 } 2117 2118 2119 /********************************************************************** 2120 * WIN_SetWindowLong 2121 * 2122 * Helper function for SetWindowLong(). 2123 * 2124 * 0 is the failure code. However, in the case of failure SetLastError 2125 * must be set to distinguish between a 0 return value and a failure. 2126 */ 2127 LONG_PTR WIN_SetWindowLong( HWND hwnd, INT offset, UINT size, LONG_PTR newval, BOOL unicode ) 2128 { 2129 STYLESTRUCT style; 2130 BOOL ok; 2131 LONG_PTR retval = 0; 2132 WND *wndPtr; 2133 2134 TRACE( "%p %d %lx %c\n", hwnd, offset, newval, unicode ? 'W' : 'A' ); 2135 2136 if (is_broadcast(hwnd)) 2137 { 2138 SetLastError( ERROR_INVALID_PARAMETER ); 2139 return FALSE; 2140 } 2141 2142 if (!(wndPtr = WIN_GetPtr( hwnd ))) 2143 { 2144 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 2145 return 0; 2146 } 2147 if (wndPtr == WND_DESKTOP) 2148 { 2149 /* can't change anything on the desktop window */ 2150 SetLastError( ERROR_ACCESS_DENIED ); 2151 return 0; 2152 } 2153 if (wndPtr == WND_OTHER_PROCESS) 2154 { 2155 if (offset == GWLP_WNDPROC) 2156 { 2157 SetLastError( ERROR_ACCESS_DENIED ); 2158 return 0; 2159 } 2160 if (offset > 32767 || offset < -32767) 2161 { 2162 SetLastError( ERROR_INVALID_INDEX ); 2163 return 0; 2164 } 2165 return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, MAKEWPARAM( offset, size ), newval ); 2166 } 2167 2168 /* first some special cases */ 2169 switch( offset ) 2170 { 2171 case GWL_STYLE: 2172 style.styleOld = wndPtr->dwStyle; 2173 style.styleNew = newval; 2174 WIN_ReleasePtr( wndPtr ); 2175 SendMessageW( hwnd, WM_STYLECHANGING, GWL_STYLE, (LPARAM)&style ); 2176 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0; 2177 newval = style.styleNew; 2178 /* WS_CLIPSIBLINGS can't be reset on top-level windows */ 2179 if (wndPtr->parent == GetDesktopWindow()) newval |= WS_CLIPSIBLINGS; 2180 /* FIXME: changing WS_DLGFRAME | WS_THICKFRAME is supposed to change 2181 WS_EX_WINDOWEDGE too */ 2182 break; 2183 case GWL_EXSTYLE: 2184 style.styleOld = wndPtr->dwExStyle; 2185 style.styleNew = newval; 2186 WIN_ReleasePtr( wndPtr ); 2187 SendMessageW( hwnd, WM_STYLECHANGING, GWL_EXSTYLE, (LPARAM)&style ); 2188 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0; 2189 /* WS_EX_TOPMOST can only be changed through SetWindowPos */ 2190 newval = (style.styleNew & ~WS_EX_TOPMOST) | (wndPtr->dwExStyle & WS_EX_TOPMOST); 2191 /* WS_EX_WINDOWEDGE depends on some other styles */ 2192 if (newval & WS_EX_DLGMODALFRAME) 2193 newval |= WS_EX_WINDOWEDGE; 2194 else if (!(newval & WS_EX_STATICEDGE) && (wndPtr->dwStyle & (WS_DLGFRAME | WS_THICKFRAME))) 2195 newval |= WS_EX_WINDOWEDGE; 2196 else 2197 newval &= ~WS_EX_WINDOWEDGE; 2198 break; 2199 case GWLP_HWNDPARENT: 2200 if (wndPtr->parent == GetDesktopWindow()) 2201 { 2202 WIN_ReleasePtr( wndPtr ); 2203 return (ULONG_PTR)WIN_SetOwner( hwnd, (HWND)newval ); 2204 } 2205 else 2206 { 2207 WIN_ReleasePtr( wndPtr ); 2208 return (ULONG_PTR)SetParent( hwnd, (HWND)newval ); 2209 } 2210 case GWLP_WNDPROC: 2211 { 2212 WNDPROC proc; 2213 UINT old_flags = wndPtr->flags; 2214 retval = WIN_GetWindowLong( hwnd, offset, size, unicode ); 2215 proc = WINPROC_AllocProc( (WNDPROC)newval, unicode ); 2216 if (proc) wndPtr->winproc = proc; 2217 if (WINPROC_IsUnicode( proc, unicode )) wndPtr->flags |= WIN_ISUNICODE; 2218 else wndPtr->flags &= ~WIN_ISUNICODE; 2219 if (!((old_flags ^ wndPtr->flags) & WIN_ISUNICODE)) 2220 { 2221 WIN_ReleasePtr( wndPtr ); 2222 return retval; 2223 } 2224 /* update is_unicode flag on the server side */ 2225 break; 2226 } 2227 case GWLP_ID: 2228 case GWLP_HINSTANCE: 2229 case GWLP_USERDATA: 2230 break; 2231 case DWLP_DLGPROC: 2232 if ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) && 2233 (size == sizeof(LONG_PTR)) && wndPtr->dlgInfo) 2234 { 2235 WNDPROC *ptr = (WNDPROC *)((char *)wndPtr->wExtra + DWLP_DLGPROC); 2236 retval = (ULONG_PTR)WINPROC_GetProc( *ptr, unicode ); 2237 *ptr = WINPROC_AllocProc( (WNDPROC)newval, unicode ); 2238 WIN_ReleasePtr( wndPtr ); 2239 return retval; 2240 } 2241 /* fall through */ 2242 default: 2243 if (offset < 0 || offset > (int)(wndPtr->cbWndExtra - size)) 2244 { 2245 WARN("Invalid offset %d\n", offset ); 2246 WIN_ReleasePtr( wndPtr ); 2247 SetLastError( ERROR_INVALID_INDEX ); 2248 return 0; 2249 } 2250 else if (get_win_data( (char *)wndPtr->wExtra + offset, size ) == newval) 2251 { 2252 /* already set to the same value */ 2253 WIN_ReleasePtr( wndPtr ); 2254 return newval; 2255 } 2256 break; 2257 } 2258 2259 SERVER_START_REQ( set_window_info ) 2260 { 2261 req->handle = wine_server_user_handle( hwnd ); 2262 req->extra_offset = -1; 2263 switch(offset) 2264 { 2265 case GWL_STYLE: 2266 req->flags = SET_WIN_STYLE; 2267 req->style = newval; 2268 break; 2269 case GWL_EXSTYLE: 2270 req->flags = SET_WIN_EXSTYLE; 2271 req->ex_style = newval; 2272 break; 2273 case GWLP_ID: 2274 req->flags = SET_WIN_ID; 2275 req->id = newval; 2276 break; 2277 case GWLP_HINSTANCE: 2278 req->flags = SET_WIN_INSTANCE; 2279 req->instance = wine_server_client_ptr( (void *)newval ); 2280 break; 2281 case GWLP_WNDPROC: 2282 req->flags = SET_WIN_UNICODE; 2283 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0; 2284 break; 2285 case GWLP_USERDATA: 2286 req->flags = SET_WIN_USERDATA; 2287 req->user_data = newval; 2288 break; 2289 default: 2290 req->flags = SET_WIN_EXTRA; 2291 req->extra_offset = offset; 2292 req->extra_size = size; 2293 set_win_data( &req->extra_value, newval, size ); 2294 } 2295 if ((ok = !wine_server_call_err( req ))) 2296 { 2297 switch(offset) 2298 { 2299 case GWL_STYLE: 2300 wndPtr->dwStyle = newval; 2301 retval = reply->old_style; 2302 break; 2303 case GWL_EXSTYLE: 2304 wndPtr->dwExStyle = newval; 2305 retval = reply->old_ex_style; 2306 break; 2307 case GWLP_ID: 2308 wndPtr->wIDmenu = newval; 2309 retval = reply->old_id; 2310 break; 2311 case GWLP_HINSTANCE: 2312 wndPtr->hInstance = (HINSTANCE)newval; 2313 retval = (ULONG_PTR)wine_server_get_ptr( reply->old_instance ); 2314 break; 2315 case GWLP_WNDPROC: 2316 break; 2317 case GWLP_USERDATA: 2318 wndPtr->userdata = newval; 2319 retval = reply->old_user_data; 2320 break; 2321 default: 2322 retval = get_win_data( (char *)wndPtr->wExtra + offset, size ); 2323 set_win_data( (char *)wndPtr->wExtra + offset, newval, size ); 2324 break; 2325 } 2326 } 2327 } 2328 SERVER_END_REQ; 2329 WIN_ReleasePtr( wndPtr ); 2330 2331 if (!ok) return 0; 2332 2333 if (offset == GWL_STYLE || offset == GWL_EXSTYLE) 2334 { 2335 style.styleOld = retval; 2336 style.styleNew = newval; 2337 USER_Driver->pSetWindowStyle( hwnd, offset, &style ); 2338 SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style ); 2339 } 2340 2341 return retval; 2342 } 2343 2344 2345 /********************************************************************** 2346 * GetWindowWord (USER32.@) 2347 */ 2348 WORD WINAPI GetWindowWord( HWND hwnd, INT offset ) 2349 { 2350 switch(offset) 2351 { 2352 case GWLP_ID: 2353 case GWLP_HINSTANCE: 2354 case GWLP_HWNDPARENT: 2355 break; 2356 default: 2357 if (offset < 0) 2358 { 2359 WARN("Invalid offset %d\n", offset ); 2360 SetLastError( ERROR_INVALID_INDEX ); 2361 return 0; 2362 } 2363 break; 2364 } 2365 return WIN_GetWindowLong( hwnd, offset, sizeof(WORD), FALSE ); 2366 } 2367 2368 2369 /********************************************************************** 2370 * GetWindowLongA (USER32.@) 2371 */ 2372 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset ) 2373 { 2374 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), FALSE ); 2375 } 2376 2377 2378 /********************************************************************** 2379 * GetWindowLongW (USER32.@) 2380 */ 2381 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset ) 2382 { 2383 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), TRUE ); 2384 } 2385 2386 2387 /********************************************************************** 2388 * SetWindowWord (USER32.@) 2389 */ 2390 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval ) 2391 { 2392 switch(offset) 2393 { 2394 case GWLP_ID: 2395 case GWLP_HINSTANCE: 2396 case GWLP_HWNDPARENT: 2397 break; 2398 default: 2399 if (offset < 0) 2400 { 2401 WARN("Invalid offset %d\n", offset ); 2402 SetLastError( ERROR_INVALID_INDEX ); 2403 return 0; 2404 } 2405 break; 2406 } 2407 return WIN_SetWindowLong( hwnd, offset, sizeof(WORD), newval, FALSE ); 2408 } 2409 2410 2411 /********************************************************************** 2412 * SetWindowLongA (USER32.@) 2413 * 2414 * See SetWindowLongW. 2415 */ 2416 LONG WINAPI DECLSPEC_HOTPATCH SetWindowLongA( HWND hwnd, INT offset, LONG newval ) 2417 { 2418 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, FALSE ); 2419 } 2420 2421 2422 /********************************************************************** 2423 * SetWindowLongW (USER32.@) Set window attribute 2424 * 2425 * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long) 2426 * value in a window's extra memory. 2427 * 2428 * The _hwnd_ parameter specifies the window. is the handle to a 2429 * window that has extra memory. The _newval_ parameter contains the 2430 * new attribute or extra memory value. If positive, the _offset_ 2431 * parameter is the byte-addressed location in the window's extra 2432 * memory to set. If negative, _offset_ specifies the window 2433 * attribute to set, and should be one of the following values: 2434 * 2435 * GWL_EXSTYLE The window's extended window style 2436 * 2437 * GWL_STYLE The window's window style. 2438 * 2439 * GWLP_WNDPROC Pointer to the window's window procedure. 2440 * 2441 * GWLP_HINSTANCE The window's pplication instance handle. 2442 * 2443 * GWLP_ID The window's identifier. 2444 * 2445 * GWLP_USERDATA The window's user-specified data. 2446 * 2447 * If the window is a dialog box, the _offset_ parameter can be one of 2448 * the following values: 2449 * 2450 * DWLP_DLGPROC The address of the window's dialog box procedure. 2451 * 2452 * DWLP_MSGRESULT The return value of a message 2453 * that the dialog box procedure processed. 2454 * 2455 * DWLP_USER Application specific information. 2456 * 2457 * RETURNS 2458 * 2459 * If successful, returns the previous value located at _offset_. Otherwise, 2460 * returns 0. 2461 * 2462 * NOTES 2463 * 2464 * Extra memory for a window class is specified by a nonzero cbWndExtra 2465 * parameter of the WNDCLASS structure passed to RegisterClass() at the 2466 * time of class creation. 2467 * 2468 * Using GWL_WNDPROC to set a new window procedure effectively creates 2469 * a window subclass. Use CallWindowProc() in the new windows procedure 2470 * to pass messages to the superclass's window procedure. 2471 * 2472 * The user data is reserved for use by the application which created 2473 * the window. 2474 * 2475 * Do not use GWL_STYLE to change the window's WS_DISABLED style; 2476 * instead, call the EnableWindow() function to change the window's 2477 * disabled state. 2478 * 2479 * Do not use GWL_HWNDPARENT to reset the window's parent, use 2480 * SetParent() instead. 2481 * 2482 * Win95: 2483 * When offset is GWL_STYLE and the calling app's ver is 4.0, 2484 * it sends WM_STYLECHANGING before changing the settings 2485 * and WM_STYLECHANGED afterwards. 2486 * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST. 2487 */ 2488 LONG WINAPI SetWindowLongW( 2489 HWND hwnd, /* [in] window to alter */ 2490 INT offset, /* [in] offset, in bytes, of location to alter */ 2491 LONG newval /* [in] new value of location */ 2492 ) { 2493 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, TRUE ); 2494 } 2495 2496 2497 /******************************************************************* 2498 * GetWindowTextA (USER32.@) 2499 */ 2500 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount ) 2501 { 2502 WCHAR *buffer; 2503 2504 if (!lpString) return 0; 2505 2506 if (WIN_IsCurrentProcess( hwnd )) 2507 return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString ); 2508 2509 /* when window belongs to other process, don't send a message */ 2510 if (nMaxCount <= 0) return 0; 2511 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0; 2512 get_server_window_text( hwnd, buffer, nMaxCount ); 2513 if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL )) 2514 lpString[nMaxCount-1] = 0; 2515 HeapFree( GetProcessHeap(), 0, buffer ); 2516 return strlen(lpString); 2517 } 2518 2519 2520 /******************************************************************* 2521 * InternalGetWindowText (USER32.@) 2522 */ 2523 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount ) 2524 { 2525 WND *win; 2526 2527 if (nMaxCount <= 0) return 0; 2528 if (!(win = WIN_GetPtr( hwnd ))) return 0; 2529 if (win == WND_DESKTOP) lpString[0] = 0; 2530 else if (win != WND_OTHER_PROCESS) 2531 { 2532 if (win->text) lstrcpynW( lpString, win->text, nMaxCount ); 2533 else lpString[0] = 0; 2534 WIN_ReleasePtr( win ); 2535 } 2536 else 2537 { 2538 get_server_window_text( hwnd, lpString, nMaxCount ); 2539 } 2540 return strlenW(lpString); 2541 } 2542 2543 2544 /******************************************************************* 2545 * GetWindowTextW (USER32.@) 2546 */ 2547 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount ) 2548 { 2549 if (!lpString) return 0; 2550 2551 if (WIN_IsCurrentProcess( hwnd )) 2552 return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString ); 2553 2554 /* when window belongs to other process, don't send a message */ 2555 if (nMaxCount <= 0) return 0; 2556 get_server_window_text( hwnd, lpString, nMaxCount ); 2557 return strlenW(lpString); 2558 } 2559 2560 2561 /******************************************************************* 2562 * SetWindowTextA (USER32.@) 2563 * SetWindowText (USER32.@) 2564 */ 2565 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString ) 2566 { 2567 if (is_broadcast(hwnd)) 2568 { 2569 SetLastError( ERROR_INVALID_PARAMETER ); 2570 return FALSE; 2571 } 2572 if (!WIN_IsCurrentProcess( hwnd )) 2573 WARN( "setting text %s of other process window %p should not use SendMessage\n", 2574 debugstr_a(lpString), hwnd ); 2575 return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString ); 2576 } 2577 2578 2579 /******************************************************************* 2580 * SetWindowTextW (USER32.@) 2581 */ 2582 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString ) 2583 { 2584 if (is_broadcast(hwnd)) 2585 { 2586 SetLastError( ERROR_INVALID_PARAMETER ); 2587 return FALSE; 2588 } 2589 if (!WIN_IsCurrentProcess( hwnd )) 2590 WARN( "setting text %s of other process window %p should not use SendMessage\n", 2591 debugstr_w(lpString), hwnd ); 2592 return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString ); 2593 } 2594 2595 2596 /******************************************************************* 2597 * GetWindowTextLengthA (USER32.@) 2598 */ 2599 INT WINAPI GetWindowTextLengthA( HWND hwnd ) 2600 { 2601 return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 ); 2602 } 2603 2604 /******************************************************************* 2605 * GetWindowTextLengthW (USER32.@) 2606 */ 2607 INT WINAPI GetWindowTextLengthW( HWND hwnd ) 2608 { 2609 return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 ); 2610 } 2611 2612 2613 /******************************************************************* 2614 * IsWindow (USER32.@) 2615 */ 2616 BOOL WINAPI IsWindow( HWND hwnd ) 2617 { 2618 WND *ptr; 2619 BOOL ret; 2620 2621 if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE; 2622 if (ptr == WND_DESKTOP) return TRUE; 2623 2624 if (ptr != WND_OTHER_PROCESS) 2625 { 2626 WIN_ReleasePtr( ptr ); 2627 return TRUE; 2628 } 2629 2630 /* check other processes */ 2631 SERVER_START_REQ( get_window_info ) 2632 { 2633 req->handle = wine_server_user_handle( hwnd ); 2634 ret = !wine_server_call_err( req ); 2635 } 2636 SERVER_END_REQ; 2637 return ret; 2638 } 2639 2640 2641 /*********************************************************************** 2642 * GetWindowThreadProcessId (USER32.@) 2643 */ 2644 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process ) 2645 { 2646 WND *ptr; 2647 DWORD tid = 0; 2648 2649 if (!(ptr = WIN_GetPtr( hwnd ))) 2650 { 2651 SetLastError( ERROR_INVALID_WINDOW_HANDLE); 2652 return 0; 2653 } 2654 2655 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP) 2656 { 2657 /* got a valid window */ 2658 tid = ptr->tid; 2659 if (process) *process = GetCurrentProcessId(); 2660 WIN_ReleasePtr( ptr ); 2661 return tid; 2662 } 2663 2664 /* check other processes */ 2665 SERVER_START_REQ( get_window_info ) 2666 { 2667 req->handle = wine_server_user_handle( hwnd ); 2668 if (!wine_server_call_err( req )) 2669 { 2670 tid = (DWORD)reply->tid; 2671 if (process) *process = (DWORD)reply->pid; 2672 } 2673 } 2674 SERVER_END_REQ; 2675 return tid; 2676 } 2677 2678 2679 /***************************************************************** 2680 * GetParent (USER32.@) 2681 */ 2682 HWND WINAPI GetParent( HWND hwnd ) 2683 { 2684 WND *wndPtr; 2685 HWND retvalue = 0; 2686 2687 if (!(wndPtr = WIN_GetPtr( hwnd ))) 2688 { 2689 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 2690 return 0; 2691 } 2692 if (wndPtr == WND_DESKTOP) return 0; 2693 if (wndPtr == WND_OTHER_PROCESS) 2694 { 2695 LONG style = GetWindowLongW( hwnd, GWL_STYLE ); 2696 if (style & (WS_POPUP | WS_CHILD)) 2697 { 2698 SERVER_START_REQ( get_window_tree ) 2699 { 2700 req->handle = wine_server_user_handle( hwnd ); 2701 if (!wine_server_call_err( req )) 2702 { 2703 if (style & WS_POPUP) retvalue = wine_server_ptr_handle( reply->owner ); 2704 else if (style & WS_CHILD) retvalue = wine_server_ptr_handle( reply->parent ); 2705 } 2706 } 2707 SERVER_END_REQ; 2708 } 2709 } 2710 else 2711 { 2712 if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner; 2713 else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent; 2714 WIN_ReleasePtr( wndPtr ); 2715 } 2716 return retvalue; 2717 } 2718 2719 2720 /***************************************************************** 2721 * GetAncestor (USER32.@) 2722 */ 2723 HWND WINAPI GetAncestor( HWND hwnd, UINT type ) 2724 { 2725 WND *win; 2726 HWND *list, ret = 0; 2727 2728 switch(type) 2729 { 2730 case GA_PARENT: 2731 if (!(win = WIN_GetPtr( hwnd ))) 2732 { 2733 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 2734 return 0; 2735 } 2736 if (win == WND_DESKTOP) return 0; 2737 if (win != WND_OTHER_PROCESS) 2738 { 2739 ret = win->parent; 2740 WIN_ReleasePtr( win ); 2741 } 2742 else /* need to query the server */ 2743 { 2744 SERVER_START_REQ( get_window_tree ) 2745 { 2746 req->handle = wine_server_user_handle( hwnd ); 2747 if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->parent ); 2748 } 2749 SERVER_END_REQ; 2750 } 2751 break; 2752 2753 case GA_ROOT: 2754 if (!(list = list_window_parents( hwnd ))) return 0; 2755 2756 if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd ); /* top-level window */ 2757 else 2758 { 2759 int count = 2; 2760 while (list[count]) count++; 2761 ret = list[count - 2]; /* get the one before the desktop */ 2762 } 2763 HeapFree( GetProcessHeap(), 0, list ); 2764 break; 2765 2766 case GA_ROOTOWNER: 2767 if (is_desktop_window( hwnd )) return 0; 2768 ret = WIN_GetFullHandle( hwnd ); 2769 for (;;) 2770 { 2771 HWND parent = GetParent( ret ); 2772 if (!parent) break; 2773 ret = parent; 2774 } 2775 break; 2776 } 2777 return ret; 2778 } 2779 2780 2781 /***************************************************************** 2782 * SetParent (USER32.@) 2783 */ 2784 HWND WINAPI SetParent( HWND hwnd, HWND parent ) 2785 { 2786 HWND full_handle; 2787 HWND old_parent = 0; 2788 BOOL was_visible; 2789 WND *wndPtr; 2790 POINT pt; 2791 BOOL ret; 2792 2793 if (is_broadcast(hwnd) || is_broadcast(parent)) 2794 { 2795 SetLastError(ERROR_INVALID_PARAMETER); 2796 return 0; 2797 } 2798 2799 if (!parent) parent = GetDesktopWindow(); 2800 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent(); 2801 else parent = WIN_GetFullHandle( parent ); 2802 2803 if (!IsWindow( parent )) 2804 { 2805 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 2806 return 0; 2807 } 2808 2809 /* Some applications try to set a child as a parent */ 2810 if (IsChild(hwnd, parent)) 2811 { 2812 SetLastError( ERROR_INVALID_PARAMETER ); 2813 return 0; 2814 } 2815 2816 if (!(full_handle = WIN_IsCurrentThread( hwnd ))) 2817 return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 ); 2818 2819 if (full_handle == parent) 2820 { 2821 SetLastError( ERROR_INVALID_PARAMETER ); 2822 return 0; 2823 } 2824 2825 /* Windows hides the window first, then shows it again 2826 * including the WM_SHOWWINDOW messages and all */ 2827 was_visible = ShowWindow( hwnd, SW_HIDE ); 2828 2829 wndPtr = WIN_GetPtr( hwnd ); 2830 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0; 2831 2832 pt.x = wndPtr->rectWindow.left; 2833 pt.y = wndPtr->rectWindow.top; 2834 2835 SERVER_START_REQ( set_parent ) 2836 { 2837 req->handle = wine_server_user_handle( hwnd ); 2838 req->parent = wine_server_user_handle( parent ); 2839 if ((ret = !wine_server_call( req ))) 2840 { 2841 old_parent = wine_server_ptr_handle( reply->old_parent ); 2842 wndPtr->parent = parent = wine_server_ptr_handle( reply->full_parent ); 2843 } 2844 2845 } 2846 SERVER_END_REQ; 2847 WIN_ReleasePtr( wndPtr ); 2848 if (!ret) return 0; 2849 2850 USER_Driver->pSetParent( full_handle, parent, old_parent ); 2851 2852 /* SetParent additionally needs to make hwnd the topmost window 2853 in the x-order and send the expected WM_WINDOWPOSCHANGING and 2854 WM_WINDOWPOSCHANGED notification messages. 2855 */ 2856 SetWindowPos( hwnd, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE ); 2857 2858 if (was_visible) ShowWindow( hwnd, SW_SHOW ); 2859 2860 return old_parent; 2861 } 2862 2863 2864 /******************************************************************* 2865 * IsChild (USER32.@) 2866 */ 2867 BOOL WINAPI IsChild( HWND parent, HWND child ) 2868 { 2869 HWND *list = list_window_parents( child ); 2870 int i; 2871 BOOL ret; 2872 2873 if (!list) return FALSE; 2874 parent = WIN_GetFullHandle( parent ); 2875 for (i = 0; list[i]; i++) if (list[i] == parent) break; 2876 ret = list[i] && list[i+1]; 2877 HeapFree( GetProcessHeap(), 0, list ); 2878 return ret; 2879 } 2880 2881 2882 /*********************************************************************** 2883 * IsWindowVisible (USER32.@) 2884 */ 2885 BOOL WINAPI IsWindowVisible( HWND hwnd ) 2886 { 2887 HWND *list; 2888 BOOL retval = TRUE; 2889 int i; 2890 2891 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE; 2892 if (!(list = list_window_parents( hwnd ))) return TRUE; 2893 if (list[0]) 2894 { 2895 for (i = 0; list[i+1]; i++) 2896 if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break; 2897 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */ 2898 } 2899 HeapFree( GetProcessHeap(), 0, list ); 2900 return retval; 2901 } 2902 2903 2904 /*********************************************************************** 2905 * WIN_IsWindowDrawable 2906 * 2907 * hwnd is drawable when it is visible, all parents are not 2908 * minimized, and it is itself not minimized unless we are 2909 * trying to draw its default class icon. 2910 */ 2911 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon ) 2912 { 2913 HWND *list; 2914 BOOL retval = TRUE; 2915 int i; 2916 LONG style = GetWindowLongW( hwnd, GWL_STYLE ); 2917 2918 if (!(style & WS_VISIBLE)) return FALSE; 2919 if ((style & WS_MINIMIZE) && icon && GetClassLongPtrW( hwnd, GCLP_HICON )) return FALSE; 2920 2921 if (!(list = list_window_parents( hwnd ))) return TRUE; 2922 if (list[0]) 2923 { 2924 for (i = 0; list[i+1]; i++) 2925 if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE) 2926 break; 2927 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */ 2928 } 2929 HeapFree( GetProcessHeap(), 0, list ); 2930 return retval; 2931 } 2932 2933 2934 /******************************************************************* 2935 * GetTopWindow (USER32.@) 2936 */ 2937 HWND WINAPI GetTopWindow( HWND hwnd ) 2938 { 2939 if (!hwnd) hwnd = GetDesktopWindow(); 2940 return GetWindow( hwnd, GW_CHILD ); 2941 } 2942 2943 2944 /******************************************************************* 2945 * GetWindow (USER32.@) 2946 */ 2947 HWND WINAPI GetWindow( HWND hwnd, UINT rel ) 2948 { 2949 HWND retval = 0; 2950 2951 if (rel == GW_OWNER) /* this one may be available locally */ 2952 { 2953 WND *wndPtr = WIN_GetPtr( hwnd ); 2954 if (!wndPtr) 2955 { 2956 SetLastError( ERROR_INVALID_HANDLE ); 2957 return 0; 2958 } 2959 if (wndPtr == WND_DESKTOP) return 0; 2960 if (wndPtr != WND_OTHER_PROCESS) 2961 { 2962 retval = wndPtr->owner; 2963 WIN_ReleasePtr( wndPtr ); 2964 return retval; 2965 } 2966 /* else fall through to server call */ 2967 } 2968 2969 SERVER_START_REQ( get_window_tree ) 2970 { 2971 req->handle = wine_server_user_handle( hwnd ); 2972 if (!wine_server_call_err( req )) 2973 { 2974 switch(rel) 2975 { 2976 case GW_HWNDFIRST: 2977 retval = wine_server_ptr_handle( reply->first_sibling ); 2978 break; 2979 case GW_HWNDLAST: 2980 retval = wine_server_ptr_handle( reply->last_sibling ); 2981 break; 2982 case GW_HWNDNEXT: 2983 retval = wine_server_ptr_handle( reply->next_sibling ); 2984 break; 2985 case GW_HWNDPREV: 2986 retval = wine_server_ptr_handle( reply->prev_sibling ); 2987 break; 2988 case GW_OWNER: 2989 retval = wine_server_ptr_handle( reply->owner ); 2990 break; 2991 case GW_CHILD: 2992 retval = wine_server_ptr_handle( reply->first_child ); 2993 break; 2994 } 2995 } 2996 } 2997 SERVER_END_REQ; 2998 return retval; 2999 } 3000 3001 3002 /******************************************************************* 3003 * ShowOwnedPopups (USER32.@) 3004 */ 3005 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow ) 3006 { 3007 int count = 0; 3008 WND *pWnd; 3009 HWND *win_array = WIN_ListChildren( GetDesktopWindow() ); 3010 3011 if (!win_array) return TRUE; 3012 3013 while (win_array[count]) count++; 3014 while (--count >= 0) 3015 { 3016 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue; 3017 if (!(pWnd = WIN_GetPtr( win_array[count] ))) continue; 3018 if (pWnd == WND_OTHER_PROCESS) continue; 3019 if (fShow) 3020 { 3021 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP) 3022 { 3023 WIN_ReleasePtr( pWnd ); 3024 /* In Windows, ShowOwnedPopups(TRUE) generates 3025 * WM_SHOWWINDOW messages with SW_PARENTOPENING, 3026 * regardless of the state of the owner 3027 */ 3028 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING); 3029 continue; 3030 } 3031 } 3032 else 3033 { 3034 if (pWnd->dwStyle & WS_VISIBLE) 3035 { 3036 WIN_ReleasePtr( pWnd ); 3037 /* In Windows, ShowOwnedPopups(FALSE) generates 3038 * WM_SHOWWINDOW messages with SW_PARENTCLOSING, 3039 * regardless of the state of the owner 3040 */ 3041 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING); 3042 continue; 3043 } 3044 } 3045 WIN_ReleasePtr( pWnd ); 3046 } 3047 HeapFree( GetProcessHeap(), 0, win_array ); 3048 return TRUE; 3049 } 3050 3051 3052 /******************************************************************* 3053 * GetLastActivePopup (USER32.@) 3054 */ 3055 HWND WINAPI GetLastActivePopup( HWND hwnd ) 3056 { 3057 HWND retval = hwnd; 3058 3059 SERVER_START_REQ( get_window_info ) 3060 { 3061 req->handle = wine_server_user_handle( hwnd ); 3062 if (!wine_server_call_err( req )) retval = wine_server_ptr_handle( reply->last_active ); 3063 } 3064 SERVER_END_REQ; 3065 return retval; 3066 } 3067 3068 3069 /******************************************************************* 3070 * WIN_ListChildren 3071 * 3072 * Build an array of the children of a given window. The array must be 3073 * freed with HeapFree. Returns NULL when no windows are found. 3074 */ 3075 HWND *WIN_ListChildren( HWND hwnd ) 3076 { 3077 if (!hwnd) 3078 { 3079 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 3080 return NULL; 3081 } 3082 return list_window_children( 0, hwnd, NULL, 0 ); 3083 } 3084 3085 3086 /******************************************************************* 3087 * EnumWindows (USER32.@) 3088 */ 3089 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam ) 3090 { 3091 HWND *list; 3092 BOOL ret = TRUE; 3093 int i; 3094 3095 USER_CheckNotLock(); 3096 3097 /* We have to build a list of all windows first, to avoid */ 3098 /* unpleasant side-effects, for instance if the callback */ 3099 /* function changes the Z-order of the windows. */ 3100 3101 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE; 3102 3103 /* Now call the callback function for every window */ 3104 3105 for (i = 0; list[i]; i++) 3106 { 3107 /* Make sure that the window still exists */ 3108 if (!IsWindow( list[i] )) continue; 3109 if (!(ret = lpEnumFunc( list[i], lParam ))) break; 3110 } 3111 HeapFree( GetProcessHeap(), 0, list ); 3112 return ret; 3113 } 3114 3115 3116 /********************************************************************** 3117 * EnumThreadWindows (USER32.@) 3118 */ 3119 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam ) 3120 { 3121 HWND *list; 3122 int i; 3123 BOOL ret = TRUE; 3124 3125 USER_CheckNotLock(); 3126 3127 if (!(list = list_window_children( 0, GetDesktopWindow(), NULL, id ))) return TRUE; 3128 3129 /* Now call the callback function for every window */ 3130 3131 for (i = 0; list[i]; i++) 3132 if (!(ret = func( list[i], lParam ))) break; 3133 HeapFree( GetProcessHeap(), 0, list ); 3134 return ret; 3135 } 3136 3137 3138 /*********************************************************************** 3139 * EnumDesktopWindows (USER32.@) 3140 */ 3141 BOOL WINAPI EnumDesktopWindows( HDESK desktop, WNDENUMPROC func, LPARAM lparam ) 3142 { 3143 HWND *list; 3144 int i; 3145 3146 USER_CheckNotLock(); 3147 3148 if (!(list = list_window_children( desktop, 0, NULL, 0 ))) return TRUE; 3149 3150 for (i = 0; list[i]; i++) 3151 if (!func( list[i], lparam )) break; 3152 HeapFree( GetProcessHeap(), 0, list ); 3153 return TRUE; 3154 } 3155 3156 3157 /********************************************************************** 3158 * WIN_EnumChildWindows 3159 * 3160 * Helper function for EnumChildWindows(). 3161 */ 3162 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam ) 3163 { 3164 HWND *childList; 3165 BOOL ret = FALSE; 3166 3167 for ( ; *list; list++) 3168 { 3169 /* Make sure that the window still exists */ 3170 if (!IsWindow( *list )) continue; 3171 /* Build children list first */ 3172 childList = WIN_ListChildren( *list ); 3173 3174 ret = func( *list, lParam ); 3175 3176 if (childList) 3177 { 3178 if (ret) ret = WIN_EnumChildWindows( childList, func, lParam ); 3179 HeapFree( GetProcessHeap(), 0, childList ); 3180 } 3181 if (!ret) return FALSE; 3182 } 3183 return TRUE; 3184 } 3185 3186 3187 /********************************************************************** 3188 * EnumChildWindows (USER32.@) 3189 */ 3190 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam ) 3191 { 3192 HWND *list; 3193 BOOL ret; 3194 3195 USER_CheckNotLock(); 3196 3197 if (!(list = WIN_ListChildren( parent ))) return FALSE; 3198 ret = WIN_EnumChildWindows( list, func, lParam ); 3199 HeapFree( GetProcessHeap(), 0, list ); 3200 return ret; 3201 } 3202 3203 3204 /******************************************************************* 3205 * AnyPopup (USER32.@) 3206 */ 3207 BOOL WINAPI AnyPopup(void) 3208 { 3209 int i; 3210 BOOL retvalue; 3211 HWND *list = WIN_ListChildren( GetDesktopWindow() ); 3212 3213 if (!list) return FALSE; 3214 for (i = 0; list[i]; i++) 3215 { 3216 if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break; 3217 } 3218 retvalue = (list[i] != 0); 3219 HeapFree( GetProcessHeap(), 0, list ); 3220 return retvalue; 3221 } 3222 3223 3224 /******************************************************************* 3225 * FlashWindow (USER32.@) 3226 */ 3227 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert ) 3228 { 3229 WND *wndPtr; 3230 3231 TRACE("%p\n", hWnd); 3232 3233 if (IsIconic( hWnd )) 3234 { 3235 RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME ); 3236 3237 wndPtr = WIN_GetPtr(hWnd); 3238 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE; 3239 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED)) 3240 { 3241 wndPtr->flags |= WIN_NCACTIVATED; 3242 } 3243 else 3244 { 3245 wndPtr->flags &= ~WIN_NCACTIVATED; 3246 } 3247 WIN_ReleasePtr( wndPtr ); 3248 return TRUE; 3249 } 3250 else 3251 { 3252 WPARAM wparam; 3253 3254 wndPtr = WIN_GetPtr(hWnd); 3255 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE; 3256 hWnd = wndPtr->obj.handle; /* make it a full handle */ 3257 3258 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED); 3259 else wparam = (hWnd == GetForegroundWindow()); 3260 3261 WIN_ReleasePtr( wndPtr ); 3262 SendMessageW( hWnd, WM_NCACTIVATE, wparam, 0 ); 3263 return wparam; 3264 } 3265 } 3266 3267 /******************************************************************* 3268 * FlashWindowEx (USER32.@) 3269 */ 3270 BOOL WINAPI FlashWindowEx( PFLASHWINFO pfwi ) 3271 { 3272 FIXME("%p\n", pfwi); 3273 return TRUE; 3274 } 3275 3276 /******************************************************************* 3277 * GetWindowContextHelpId (USER32.@) 3278 */ 3279 DWORD WINAPI GetWindowContextHelpId( HWND hwnd ) 3280 { 3281 DWORD retval; 3282 WND *wnd = WIN_GetPtr( hwnd ); 3283 if (!wnd || wnd == WND_DESKTOP) return 0; 3284 if (wnd == WND_OTHER_PROCESS) 3285 { 3286 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd ); 3287 return 0; 3288 } 3289 retval = wnd->helpContext; 3290 WIN_ReleasePtr( wnd ); 3291 return retval; 3292 } 3293 3294 3295 /******************************************************************* 3296 * SetWindowContextHelpId (USER32.@) 3297 */ 3298 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id ) 3299 { 3300 WND *wnd = WIN_GetPtr( hwnd ); 3301 if (!wnd || wnd == WND_DESKTOP) return FALSE; 3302 if (wnd == WND_OTHER_PROCESS) 3303 { 3304 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd ); 3305 return 0; 3306 } 3307 wnd->helpContext = id; 3308 WIN_ReleasePtr( wnd ); 3309 return TRUE; 3310 } 3311 3312 3313 /******************************************************************* 3314 * DragDetect (USER32.@) 3315 */ 3316 BOOL WINAPI DragDetect( HWND hWnd, POINT pt ) 3317 { 3318 MSG msg; 3319 RECT rect; 3320 WORD wDragWidth = GetSystemMetrics(SM_CXDRAG); 3321 WORD wDragHeight= GetSystemMetrics(SM_CYDRAG); 3322 3323 rect.left = pt.x - wDragWidth; 3324 rect.right = pt.x + wDragWidth; 3325 3326 rect.top = pt.y - wDragHeight; 3327 rect.bottom = pt.y + wDragHeight; 3328 3329 SetCapture(hWnd); 3330 3331 while(1) 3332 { 3333 while (PeekMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE )) 3334 { 3335 if( msg.message == WM_LBUTTONUP ) 3336 { 3337 ReleaseCapture(); 3338 return 0; 3339 } 3340 if( msg.message == WM_MOUSEMOVE ) 3341 { 3342 POINT tmp; 3343 tmp.x = (short)LOWORD(msg.lParam); 3344 tmp.y = (short)HIWORD(msg.lParam); 3345 if( !PtInRect( &rect, tmp )) 3346 { 3347 ReleaseCapture(); 3348 return 1; 3349 } 3350 } 3351 } 3352 WaitMessage(); 3353 } 3354 return 0; 3355 } 3356 3357 /****************************************************************************** 3358 * GetWindowModuleFileNameA (USER32.@) 3359 */ 3360 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR module, UINT size ) 3361 { 3362 WND *win; 3363 HINSTANCE hinst; 3364 3365 TRACE( "%p, %p, %u\n", hwnd, module, size ); 3366 3367 win = WIN_GetPtr( hwnd ); 3368 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) 3369 { 3370 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 3371 return 0; 3372 } 3373 hinst = win->hInstance; 3374 WIN_ReleasePtr( win ); 3375 3376 return GetModuleFileNameA( hinst, module, size ); 3377 } 3378 3379 /****************************************************************************** 3380 * GetWindowModuleFileNameW (USER32.@) 3381 */ 3382 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPWSTR module, UINT size ) 3383 { 3384 WND *win; 3385 HINSTANCE hinst; 3386 3387 TRACE( "%p, %p, %u\n", hwnd, module, size ); 3388 3389 win = WIN_GetPtr( hwnd ); 3390 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) 3391 { 3392 SetLastError( ERROR_INVALID_WINDOW_HANDLE ); 3393 return 0; 3394 } 3395 hinst = win->hInstance; 3396 WIN_ReleasePtr( win ); 3397 3398 return GetModuleFileNameW( hinst, module, size ); 3399 } 3400 3401 /****************************************************************************** 3402 * GetWindowInfo (USER32.@) 3403 * 3404 * Note: tests show that Windows doesn't check cbSize of the structure. 3405 */ 3406 BOOL WINAPI DECLSPEC_HOTPATCH GetWindowInfo( HWND hwnd, PWINDOWINFO pwi) 3407 { 3408 if (!pwi) return FALSE; 3409 if (!WIN_GetRectangles( hwnd, COORDS_SCREEN, &pwi->rcWindow, &pwi->rcClient )) return FALSE; 3410 3411 pwi->dwStyle = GetWindowLongW(hwnd, GWL_STYLE); 3412 pwi->dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE); 3413 pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0); 3414 3415 pwi->cxWindowBorders = pwi->rcClient.left - pwi->rcWindow.left; 3416 pwi->cyWindowBorders = pwi->rcWindow.bottom - pwi->rcClient.bottom; 3417 3418 pwi->atomWindowType = GetClassLongW( hwnd, GCW_ATOM ); 3419 pwi->wCreatorVersion = 0x0400; 3420 3421 return TRUE; 3422 } 3423 3424 /****************************************************************************** 3425 * SwitchDesktop (USER32.@) 3426 * 3427 * NOTES: Sets the current input or interactive desktop. 3428 */ 3429 BOOL WINAPI SwitchDesktop( HDESK hDesktop) 3430 { 3431 FIXME("(hwnd %p) stub!\n", hDesktop); 3432 return TRUE; 3433 } 3434 3435 /***************************************************************************** 3436 * SetLayeredWindowAttributes (USER32.@) 3437 */ 3438 BOOL WINAPI SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags ) 3439 { 3440 BOOL ret; 3441 3442 TRACE("(%p,%08x,%d,%x): stub!\n", hwnd, key, alpha, flags); 3443 3444 SERVER_START_REQ( set_window_layered_info ) 3445 { 3446 req->handle = wine_server_user_handle( hwnd ); 3447 req->color_key = key; 3448 req->alpha = alpha; 3449 req->flags = flags; 3450 ret = !wine_server_call_err( req ); 3451 } 3452 SERVER_END_REQ; 3453 3454 if (ret) USER_Driver->pSetLayeredWindowAttributes( hwnd, key, alpha, flags ); 3455 3456 return ret; 3457 } 3458 3459 3460 /***************************************************************************** 3461 * GetLayeredWindowAttributes (USER32.@) 3462 */ 3463 BOOL WINAPI GetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags ) 3464 { 3465 BOOL ret; 3466 3467 SERVER_START_REQ( get_window_layered_info ) 3468 { 3469 req->handle = wine_server_user_handle( hwnd ); 3470 if ((ret = !wine_server_call_err( req ))) 3471 { 3472 if (key) *key = reply->color_key; 3473 if (alpha) *alpha = reply->alpha; 3474 if (flags) *flags = reply->flags; 3475 } 3476 } 3477 SERVER_END_REQ; 3478 3479 return ret; 3480 } 3481 3482 3483 /***************************************************************************** 3484 * UpdateLayeredWindowIndirect (USER32.@) 3485 */ 3486 BOOL WINAPI UpdateLayeredWindowIndirect( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info ) 3487 { 3488 BYTE alpha = 0xff; 3489 3490 if (!(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED) || 3491 GetLayeredWindowAttributes( hwnd, NULL, NULL, NULL )) 3492 { 3493 SetLastError( ERROR_INVALID_PARAMETER ); 3494 return FALSE; 3495 } 3496 3497 if (!(info->dwFlags & ULW_EX_NORESIZE) && (info->pptDst || info->psize)) 3498 { 3499 int x = 0, y = 0, cx = 0, cy = 0; 3500 DWORD flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOSENDCHANGING; 3501 3502 if (info->pptDst) 3503 { 3504 x = info->pptDst->x; 3505 y = info->pptDst->y; 3506 flags &= ~SWP_NOMOVE; 3507 } 3508 if (info->psize) 3509 { 3510 cx = info->psize->cx; 3511 cy = info->psize->cy; 3512 flags &= ~SWP_NOSIZE; 3513 } 3514 TRACE( "moving window %p pos %d,%d %dx%d\n", hwnd, x, y, cx, cy ); 3515 SetWindowPos( hwnd, 0, x, y, cx, cy, flags ); 3516 } 3517 3518 if (info->hdcSrc) 3519 { 3520 HDC hdc = GetWindowDC( hwnd ); 3521 3522 if (hdc) 3523 { 3524 int x = 0, y = 0; 3525 RECT rect; 3526 3527 GetWindowRect( hwnd, &rect ); 3528 OffsetRect( &rect, -rect.left, -rect.top); 3529 if (info->pptSrc) 3530 { 3531 x = info->pptSrc->x; 3532 y = info->pptSrc->y; 3533 } 3534 3535 if (!info->prcDirty || (info->prcDirty && IntersectRect(&rect, &rect, info->prcDirty))) 3536 { 3537 TRACE( "copying window %p pos %d,%d\n", hwnd, x, y ); 3538 BitBlt( hdc, rect.left, rect.top, rect.right, rect.bottom, 3539 info->hdcSrc, rect.left + x, rect.top + y, SRCCOPY ); 3540 } 3541 ReleaseDC( hwnd, hdc ); 3542 } 3543 } 3544 3545 if (info->pblend && !(info->dwFlags & ULW_OPAQUE)) alpha = info->pblend->SourceConstantAlpha; 3546 TRACE( "setting window %p alpha %u\n", hwnd, alpha ); 3547 USER_Driver->pSetLayeredWindowAttributes( hwnd, info->crKey, alpha, 3548 info->dwFlags & (LWA_ALPHA | LWA_COLORKEY) ); 3549 return TRUE; 3550 } 3551 3552 3553 /***************************************************************************** 3554 * UpdateLayeredWindow (USER32.@) 3555 */ 3556 BOOL WINAPI UpdateLayeredWindow( HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize, 3557 HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend, 3558 DWORD dwFlags) 3559 { 3560 UPDATELAYEREDWINDOWINFO info; 3561 3562 info.cbSize = sizeof(info); 3563 info.hdcDst = hdcDst; 3564 info.pptDst = pptDst; 3565 info.psize = psize; 3566 info.hdcSrc = hdcSrc; 3567 info.pptSrc = pptSrc; 3568 info.crKey = crKey; 3569 info.pblend = pblend; 3570 info.dwFlags = dwFlags; 3571 info.prcDirty = NULL; 3572 return UpdateLayeredWindowIndirect( hwnd, &info ); 3573 } 3574 3575 3576 /****************************************************************************** 3577 * GetProcessDefaultLayout [USER32.@] 3578 * 3579 * Gets the default layout for parentless windows. 3580 */ 3581 BOOL WINAPI GetProcessDefaultLayout( DWORD *layout ) 3582 { 3583 if (!layout) 3584 { 3585 SetLastError( ERROR_NOACCESS ); 3586 return FALSE; 3587 } 3588 if (process_layout == ~0u) 3589 { 3590 static const WCHAR translationW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o', 3591 '\\','T','r','a','n','s','l','a','t','i','o','n', 0 }; 3592 static const WCHAR filedescW[] = { '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o', 3593 '\\','%','','4','x','%','','4','x', 3594 '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n',0 }; 3595 WCHAR *str, buffer[MAX_PATH]; 3596 DWORD i, len, version_layout = 0; 3597 DWORD user_lang = GetUserDefaultLangID(); 3598 DWORD *languages; 3599 void *data = NULL; 3600 3601 GetModuleFileNameW( 0, buffer, MAX_PATH ); 3602 if (!(len = GetFileVersionInfoSizeW( buffer, NULL ))) goto done; 3603 if (!(data = HeapAlloc( GetProcessHeap(), 0, len ))) goto done; 3604 if (!GetFileVersionInfoW( buffer, 0, len, data )) goto done; 3605 if (!VerQueryValueW( data, translationW, (void **)&languages, &len ) || !len) goto done; 3606 3607 len /= sizeof(DWORD); 3608 for (i = 0; i < len; i++) if (LOWORD(languages[i]) == user_lang) break; 3609 if (i == len) /* try neutral language */ 3610 for (i = 0; i < len; i++) 3611 if (LOWORD(languages[i]) == MAKELANGID( PRIMARYLANGID(user_lang), SUBLANG_NEUTRAL )) break; 3612 if (i == len) i = 0; /* default to the first one */ 3613 3614 sprintfW( buffer, filedescW, LOWORD(languages[i]), HIWORD(languages[i]) ); 3615 if (!VerQueryValueW( data, buffer, (void **)&str, &len )) goto done; 3616 TRACE( "found description %s\n", debugstr_w( str )); 3617 if (str[0] == 0x200e && str[1] == 0x200e) version_layout = LAYOUT_RTL; 3618 3619 done: 3620 HeapFree( GetProcessHeap(), 0, data ); 3621 process_layout = version_layout; 3622 } 3623 *layout = process_layout; 3624 return TRUE; 3625 } 3626 3627 3628 /****************************************************************************** 3629 * SetProcessDefaultLayout [USER32.@] 3630 * 3631 * Sets the default layout for parentless windows. 3632 */ 3633 BOOL WINAPI SetProcessDefaultLayout( DWORD layout ) 3634 { 3635 process_layout = layout; 3636 return TRUE; 3637 } 3638 3639 3640 /* 64bit versions */ 3641 3642 #ifdef GetWindowLongPtrW 3643 #undef GetWindowLongPtrW 3644 #endif 3645 3646 #ifdef GetWindowLongPtrA 3647 #undef GetWindowLongPtrA 3648 #endif 3649 3650 #ifdef SetWindowLongPtrW 3651 #undef SetWindowLongPtrW 3652 #endif 3653 3654 #ifdef SetWindowLongPtrA 3655 #undef SetWindowLongPtrA 3656 #endif 3657 3658 /***************************************************************************** 3659 * GetWindowLongPtrW (USER32.@) 3660 */ 3661 LONG_PTR WINAPI GetWindowLongPtrW( HWND hwnd, INT offset ) 3662 { 3663 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), TRUE ); 3664 } 3665 3666 /***************************************************************************** 3667 * GetWindowLongPtrA (USER32.@) 3668 */ 3669 LONG_PTR WINAPI GetWindowLongPtrA( HWND hwnd, INT offset ) 3670 { 3671 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), FALSE ); 3672 } 3673 3674 /***************************************************************************** 3675 * SetWindowLongPtrW (USER32.@) 3676 */ 3677 LONG_PTR WINAPI SetWindowLongPtrW( HWND hwnd, INT offset, LONG_PTR newval ) 3678 { 3679 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, TRUE ); 3680 } 3681 3682 /***************************************************************************** 3683 * SetWindowLongPtrA (USER32.@) 3684 */ 3685 LONG_PTR WINAPI SetWindowLongPtrA( HWND hwnd, INT offset, LONG_PTR newval ) 3686 { 3687 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, FALSE ); 3688 } 3689

Wine Cross Reference wine/dlls/user32/win.c

Wine Cross Reference
wine/dlls/user32/win.c