windows/defwnd.c

   1 /*
   2  * Default window procedure
   3  *
   4  * Copyright 1993, 1996 Alexandre Julliard
   5  *           1995 Alex Korobka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winnls.h"
  32 #include "imm.h"
  33 #include "win.h"
  34 #include "user_private.h"
  35 #include "controls.h"
  36 #include "nonclient.h"
  37 #include "winpos.h"
  38 #include "dce.h"
  39 #include "message.h"
  40 #include "wine/unicode.h"
  41 #include "wine/winuser16.h"
  42 #include "wine/server.h"
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(win);
  46
  47   /* bits in the dwKeyData */
  48 #define KEYDATA_ALT             0x2000
  49 #define KEYDATA_PREVSTATE       0x4000
  50
  51 static short iF10Key = 0;
  52 static short iMenuSysKey = 0;
  53 static const WCHAR imm32W[] = { 'i','m','m','3','2','\0' };
  54
  55 /***********************************************************************
  56  *           DEFWND_HandleWindowPosChanged
  57  *
  58  * Handle the WM_WINDOWPOSCHANGED message.
  59  */
  60 static void DEFWND_HandleWindowPosChanged( HWND hwnd, UINT flags )
  61 {
  62     RECT rect;
  63     WND *wndPtr = WIN_GetPtr( hwnd );
  64
  65     rect = wndPtr->rectClient;
  66     WIN_ReleasePtr( wndPtr );
  67
  68     if (!(flags & SWP_NOCLIENTMOVE))
  69         SendMessageW( hwnd, WM_MOVE, 0, MAKELONG(rect.left, rect.top));
  70
  71     if (!(flags & SWP_NOCLIENTSIZE))
  72     {
  73         WPARAM wp = SIZE_RESTORED;
  74         if (IsZoomed(hwnd)) wp = SIZE_MAXIMIZED;
  75         else if (IsIconic(hwnd)) wp = SIZE_MINIMIZED;
  76
  77         SendMessageW( hwnd, WM_SIZE, wp, MAKELONG(rect.right-rect.left, rect.bottom-rect.top) );
  78     }
  79 }
  80
  81
  82 /***********************************************************************
  83  *           DEFWND_SetTextA
  84  *
  85  * Set the window text.
  86  */
  87 static void DEFWND_SetTextA( HWND hwnd, LPCSTR text )
  88 {
  89     int count;
  90     WCHAR *textW;
  91     WND *wndPtr;
  92
  93     if (!text) text = "";
  94     count = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 );
  95
  96     if (!(wndPtr = WIN_GetPtr( hwnd ))) return;
  97     if ((textW = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
  98     {
  99         if (wndPtr->text) HeapFree(GetProcessHeap(), 0, wndPtr->text);
 100         wndPtr->text = textW;
 101         MultiByteToWideChar( CP_ACP, 0, text, -1, textW, count );
 102         SERVER_START_REQ( set_window_text )
 103         {
 104             req->handle = hwnd;
 105             wine_server_add_data( req, textW, (count-1) * sizeof(WCHAR) );
 106             wine_server_call( req );
 107         }
 108         SERVER_END_REQ;
 109     }
 110     else
 111         ERR("Not enough memory for window text\n");
 112     WIN_ReleasePtr( wndPtr );
 113
 114     if (USER_Driver.pSetWindowText) USER_Driver.pSetWindowText( hwnd, textW );
 115 }
 116
 117 /***********************************************************************
 118  *           DEFWND_SetTextW
 119  *
 120  * Set the window text.
 121  */
 122 static void DEFWND_SetTextW( HWND hwnd, LPCWSTR text )
 123 {
 124     static const WCHAR empty_string[] = {0};
 125     WND *wndPtr;
 126     int count;
 127
 128     if (!text) text = empty_string;
 129     count = strlenW(text) + 1;
 130
 131     if (!(wndPtr = WIN_GetPtr( hwnd ))) return;
 132     if (wndPtr->text) HeapFree(GetProcessHeap(), 0, wndPtr->text);
 133     if ((wndPtr->text = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
 134     {
 135         strcpyW( wndPtr->text, text );
 136         SERVER_START_REQ( set_window_text )
 137         {
 138             req->handle = hwnd;
 139             wine_server_add_data( req, wndPtr->text, (count-1) * sizeof(WCHAR) );
 140             wine_server_call( req );
 141         }
 142         SERVER_END_REQ;
 143     }
 144     else
 145         ERR("Not enough memory for window text\n");
 146     text = wndPtr->text;
 147     WIN_ReleasePtr( wndPtr );
 148
 149     if (USER_Driver.pSetWindowText) USER_Driver.pSetWindowText( hwnd, text );
 150 }
 151
 152 /***********************************************************************
 153  *           DEFWND_ControlColor
 154  *
 155  * Default colors for control painting.
 156  */
 157 HBRUSH DEFWND_ControlColor( HDC hDC, UINT ctlType )
 158 {
 159     if( ctlType == CTLCOLOR_SCROLLBAR)
 160     {
 161         HBRUSH hb = GetSysColorBrush(COLOR_SCROLLBAR);
 162         COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
 163         SetTextColor( hDC, GetSysColor(COLOR_3DFACE));
 164         SetBkColor( hDC, bk);
 165
 166         /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
 167          * we better use 0x55aa bitmap brush to make scrollbar's background
 168          * look different from the window background.
 169          */
 170         if (bk == GetSysColor(COLOR_WINDOW))
 171             return UITOOLS_GetPattern55AABrush();
 172
 173         UnrealizeObject( hb );
 174         return hb;
 175     }
 176
 177     SetTextColor( hDC, GetSysColor(COLOR_WINDOWTEXT));
 178
 179     if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
 180         SetBkColor( hDC, GetSysColor(COLOR_WINDOW) );
 181     else {
 182         SetBkColor( hDC, GetSysColor(COLOR_3DFACE) );
 183         return GetSysColorBrush(COLOR_3DFACE);
 184     }
 185     return GetSysColorBrush(COLOR_WINDOW);
 186 }
 187
 188
 189 /***********************************************************************
 190  *           DEFWND_SetRedraw
 191  */
 192 static void DEFWND_SetRedraw( HWND hwnd, WPARAM wParam )
 193 {
 194     WND *wndPtr = WIN_FindWndPtr( hwnd );
 195     BOOL bVisible = wndPtr->dwStyle & WS_VISIBLE;
 196
 197     TRACE("%p %i\n", hwnd, (wParam!=0) );
 198
 199     if( wParam )
 200     {
 201         if( !bVisible )
 202         {
 203             WIN_SetStyle( hwnd, wndPtr->dwStyle | WS_VISIBLE );
 204             DCE_InvalidateDCE( hwnd, &wndPtr->rectWindow );
 205         }
 206     }
 207     else if( bVisible )
 208     {
 209         if( wndPtr->dwStyle & WS_MINIMIZE ) wParam = RDW_VALIDATE;
 210         else wParam = RDW_ALLCHILDREN | RDW_VALIDATE;
 211
 212         RedrawWindow( hwnd, NULL, 0, wParam );
 213         DCE_InvalidateDCE( hwnd, &wndPtr->rectWindow );
 214         WIN_SetStyle( hwnd, wndPtr->dwStyle & ~WS_VISIBLE );
 215     }
 216     WIN_ReleaseWndPtr( wndPtr );
 217 }
 218
 219 /***********************************************************************
 220  *           DEFWND_Print
 221  *
 222  * This method handles the default behavior for the WM_PRINT message.
 223  */
 224 static void DEFWND_Print( HWND hwnd, HDC hdc, ULONG uFlags)
 225 {
 226   /*
 227    * Visibility flag.
 228    */
 229   if ( (uFlags & PRF_CHECKVISIBLE) &&
 230        !IsWindowVisible(hwnd) )
 231       return;
 232
 233   /*
 234    * Unimplemented flags.
 235    */
 236   if ( (uFlags & PRF_CHILDREN) ||
 237        (uFlags & PRF_OWNED)    ||
 238        (uFlags & PRF_NONCLIENT) )
 239   {
 240     WARN("WM_PRINT message with unsupported flags\n");
 241   }
 242
 243   /*
 244    * Background
 245    */
 246   if ( uFlags & PRF_ERASEBKGND)
 247     SendMessageW(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
 248
 249   /*
 250    * Client area
 251    */
 252   if ( uFlags & PRF_CLIENT)
 253     SendMessageW(hwnd, WM_PRINTCLIENT, (WPARAM)hdc, PRF_CLIENT);
 254 }
 255
 256
 257 /*
 258  * helpers for calling IMM32
 259  *
 260  * WM_IME_* messages are generated only by IMM32,
 261  * so I assume imm32 is already LoadLibrary-ed.
 262  */
 263 static HWND DEFWND_ImmGetDefaultIMEWnd( HWND hwnd )
 264 {
 265     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 266     HWND (WINAPI *pFunc)(HWND);
 267     HWND hwndRet = 0;
 268
 269     if (!hInstIMM)
 270     {
 271         ERR( "cannot get IMM32 handle\n" );
 272         return 0;
 273     }
 274
 275     pFunc = (void*)GetProcAddress(hInstIMM,"ImmGetDefaultIMEWnd");
 276     if ( pFunc != NULL )
 277         hwndRet = (*pFunc)( hwnd );
 278
 279     return hwndRet;
 280 }
 281
 282 static BOOL DEFWND_ImmIsUIMessageA( HWND hwndIME, UINT msg, WPARAM wParam, LPARAM lParam )
 283 {
 284     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 285     BOOL (WINAPI *pFunc)(HWND,UINT,WPARAM,LPARAM);
 286     BOOL fRet = FALSE;
 287
 288     if (!hInstIMM)
 289     {
 290         ERR( "cannot get IMM32 handle\n" );
 291         return FALSE;
 292     }
 293
 294     pFunc = (void*)GetProcAddress(hInstIMM,"ImmIsUIMessageA");
 295     if ( pFunc != NULL )
 296         fRet = (*pFunc)( hwndIME, msg, wParam, lParam );
 297
 298     return fRet;
 299 }
 300
 301 static BOOL DEFWND_ImmIsUIMessageW( HWND hwndIME, UINT msg, WPARAM wParam, LPARAM lParam )
 302 {
 303     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 304     BOOL (WINAPI *pFunc)(HWND,UINT,WPARAM,LPARAM);
 305     BOOL fRet = FALSE;
 306
 307     if (!hInstIMM)
 308     {
 309         ERR( "cannot get IMM32 handle\n" );
 310         return FALSE;
 311     }
 312
 313     pFunc = (void*)GetProcAddress(hInstIMM,"ImmIsUIMessageW");
 314     if ( pFunc != NULL )
 315         fRet = (*pFunc)( hwndIME, msg, wParam, lParam );
 316
 317     return fRet;
 318 }
 319
 320
 321
 322 /***********************************************************************
 323  *           DEFWND_DefWinProc
 324  *
 325  * Default window procedure for messages that are the same in Win16 and Win32.
 326  */
 327 static LRESULT DEFWND_DefWinProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 328 {
 329     switch(msg)
 330     {
 331     case WM_NCPAINT:
 332         return NC_HandleNCPaint( hwnd, (HRGN)wParam );
 333
 334     case WM_NCHITTEST:
 335         {
 336             POINT pt;
 337             pt.x = (short)LOWORD(lParam);
 338             pt.y = (short)HIWORD(lParam);
 339             return NC_HandleNCHitTest( hwnd, pt );
 340         }
 341
 342     case WM_NCLBUTTONDOWN:
 343         return NC_HandleNCLButtonDown( hwnd, wParam, lParam );
 344
 345     case WM_LBUTTONDBLCLK:
 346     case WM_NCLBUTTONDBLCLK:
 347         return NC_HandleNCLButtonDblClk( hwnd, wParam, lParam );
 348
 349     case WM_NCRBUTTONDOWN:
 350         /* in Windows, capture is taken when right-clicking on the caption bar */
 351         if (wParam==HTCAPTION)
 352         {
 353             SetCapture(hwnd);
 354         }
 355         break;
 356
 357     case WM_RBUTTONUP:
 358         {
 359             POINT pt;
 360
 361             if (hwnd == GetCapture())
 362                 /* release capture if we took it on WM_NCRBUTTONDOWN */
 363                 ReleaseCapture();
 364
 365             pt.x = (short)LOWORD(lParam);
 366             pt.y = (short)HIWORD(lParam);
 367             ClientToScreen(hwnd, &pt);
 368             SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM)hwnd, MAKELPARAM(pt.x, pt.y) );
 369         }
 370         break;
 371
 372     case WM_NCRBUTTONUP:
 373         /*
 374          * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
 375          * in Windows), but what _should_ we do? According to MSDN :
 376          * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
 377          * message to the window". When is it appropriate?
 378          */
 379         break;
 380
 381     case WM_CONTEXTMENU:
 382         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 383             SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 384         else
 385         {
 386             LONG hitcode;
 387             POINT pt;
 388             WND *wndPtr = WIN_GetPtr( hwnd );
 389             HMENU hMenu = wndPtr->hSysMenu;
 390             WIN_ReleasePtr( wndPtr );
 391             if (!hMenu) return 0;
 392             pt.x = (short)LOWORD(lParam);
 393             pt.y = (short)HIWORD(lParam);
 394             hitcode = NC_HandleNCHitTest(hwnd, pt);
 395
 396             /* Track system popup if click was in the caption area. */
 397             if (hitcode==HTCAPTION || hitcode==HTSYSMENU)
 398                TrackPopupMenu(GetSystemMenu(hwnd, FALSE),
 399                                TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
 400                                pt.x, pt.y, 0, hwnd, NULL);
 401         }
 402         break;
 403
 404     case WM_NCACTIVATE:
 405         return NC_HandleNCActivate( hwnd, wParam );
 406
 407     case WM_NCDESTROY:
 408         {
 409             WND *wndPtr = WIN_GetPtr( hwnd );
 410             if (!wndPtr) return 0;
 411             if (wndPtr->text) HeapFree( GetProcessHeap(), 0, wndPtr->text );
 412             wndPtr->text = NULL;
 413             if (wndPtr->pVScroll) HeapFree( GetProcessHeap(), 0, wndPtr->pVScroll );
 414             if (wndPtr->pHScroll) HeapFree( GetProcessHeap(), 0, wndPtr->pHScroll );
 415             wndPtr->pVScroll = wndPtr->pHScroll = NULL;
 416             WIN_ReleasePtr( wndPtr );
 417             return 0;
 418         }
 419
 420     case WM_PRINT:
 421         DEFWND_Print(hwnd, (HDC)wParam, lParam);
 422         return 0;
 423
 424     case WM_PAINTICON:
 425     case WM_PAINT:
 426         {
 427             PAINTSTRUCT ps;
 428             HDC hdc = BeginPaint( hwnd, &ps );
 429             if( hdc )
 430             {
 431               HICON hIcon;
 432               if (IsIconic(hwnd) && ((hIcon = (HICON)GetClassLongW( hwnd, GCL_HICON))) )
 433               {
 434                   RECT rc;
 435                   int x, y;
 436
 437                   GetClientRect( hwnd, &rc );
 438                   x = (rc.right - rc.left - GetSystemMetrics(SM_CXICON))/2;
 439                   y = (rc.bottom - rc.top - GetSystemMetrics(SM_CYICON))/2;
 440                   TRACE("Painting class icon: vis rect=(%ld,%ld - %ld,%ld)\n",
 441                         ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom );
 442                   DrawIcon( hdc, x, y, hIcon );
 443               }
 444               EndPaint( hwnd, &ps );
 445             }
 446             return 0;
 447         }
 448
 449     case WM_SYNCPAINT:
 450         RedrawWindow ( hwnd, NULL, 0, RDW_ERASENOW | RDW_ERASE | RDW_ALLCHILDREN );
 451         return 0;
 452
 453     case WM_SETREDRAW:
 454         DEFWND_SetRedraw( hwnd, wParam );
 455         return 0;
 456
 457     case WM_CLOSE:
 458         DestroyWindow( hwnd );
 459         return 0;
 460
 461     case WM_MOUSEACTIVATE:
 462         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 463         {
 464             LONG ret = SendMessageW( GetParent(hwnd), WM_MOUSEACTIVATE, wParam, lParam );
 465             if (ret) return ret;
 466         }
 467
 468         /* Caption clicks are handled by the NC_HandleNCLButtonDown() */
 469         return (LOWORD(lParam) >= HTCLIENT) ? MA_ACTIVATE : MA_NOACTIVATE;
 470
 471     case WM_ACTIVATE:
 472         /* The default action in Windows is to set the keyboard focus to
 473          * the window, if it's being activated and not minimized */
 474         if (LOWORD(wParam) != WA_INACTIVE) {
 475             if (!IsIconic(hwnd)) SetFocus(hwnd);
 476         }
 477         break;
 478
 479     case WM_MOUSEWHEEL:
 480         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 481             return SendMessageW( GetParent(hwnd), WM_MOUSEWHEEL, wParam, lParam );
 482         break;
 483
 484     case WM_ERASEBKGND:
 485     case WM_ICONERASEBKGND:
 486         {
 487             RECT rect;
 488             HDC hdc = (HDC)wParam;
 489             HBRUSH hbr = (HBRUSH)GetClassLongW( hwnd, GCL_HBRBACKGROUND );
 490             if (!hbr) return 0;
 491
 492             if (GetClassLongW( hwnd, GCL_STYLE ) & CS_PARENTDC)
 493             {
 494                 /* can't use GetClipBox with a parent DC or we fill the whole parent */
 495                 GetClientRect( hwnd, &rect );
 496                 DPtoLP( hdc, (LPPOINT)&rect, 2 );
 497             }
 498             else GetClipBox( hdc, &rect );
 499             FillRect( hdc, &rect, hbr );
 500             return 1;
 501         }
 502
 503     case WM_GETDLGCODE:
 504         return 0;
 505
 506     case WM_CTLCOLORMSGBOX:
 507     case WM_CTLCOLOREDIT:
 508     case WM_CTLCOLORLISTBOX:
 509     case WM_CTLCOLORBTN:
 510     case WM_CTLCOLORDLG:
 511     case WM_CTLCOLORSTATIC:
 512     case WM_CTLCOLORSCROLLBAR:
 513         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, msg - WM_CTLCOLORMSGBOX );
 514
 515     case WM_CTLCOLOR:
 516         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, HIWORD(lParam) );
 517
 518     case WM_SETCURSOR:
 519         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 520         {
 521             /* with the exception of the border around a resizable wnd,
 522              * give the parent first chance to set the cursor */
 523             if ((LOWORD(lParam) < HTSIZEFIRST) || (LOWORD(lParam) > HTSIZELAST))
 524             {
 525                 if (SendMessageW(GetParent(hwnd), WM_SETCURSOR, wParam, lParam)) return TRUE;
 526             }
 527         }
 528         NC_HandleSetCursor( hwnd, wParam, lParam );
 529         break;
 530
 531     case WM_SYSCOMMAND:
 532         return NC_HandleSysCommand( hwnd, wParam, lParam );
 533
 534     case WM_KEYDOWN:
 535         if(wParam == VK_F10) iF10Key = VK_F10;
 536         break;
 537
 538     case WM_SYSKEYDOWN:
 539         if( HIWORD(lParam) & KEYDATA_ALT )
 540         {
 541             /* if( HIWORD(lParam) & ~KEYDATA_PREVSTATE ) */
 542               if( wParam == VK_MENU && !iMenuSysKey )
 543                 iMenuSysKey = 1;
 544               else
 545                 iMenuSysKey = 0;
 546
 547             iF10Key = 0;
 548
 549             if( wParam == VK_F4 )       /* try to close the window */
 550             {
 551                 HWND top = GetAncestor( hwnd, GA_ROOT );
 552                 if (!(GetClassLongW( top, GCL_STYLE ) & CS_NOCLOSE))
 553                     PostMessageW( top, WM_SYSCOMMAND, SC_CLOSE, 0 );
 554             }
 555         }
 556         else if( wParam == VK_F10 )
 557             iF10Key = 1;
 558         else if( wParam == VK_ESCAPE && (GetKeyState(VK_SHIFT) & 0x8000))
 559             SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, ' ' );
 560         break;
 561
 562     case WM_KEYUP:
 563     case WM_SYSKEYUP:
 564         /* Press and release F10 or ALT */
 565         if (((wParam == VK_MENU) && iMenuSysKey) ||
 566             ((wParam == VK_F10) && iF10Key))
 567               SendMessageW( GetAncestor( hwnd, GA_ROOT ), WM_SYSCOMMAND, SC_KEYMENU, 0L );
 568         iMenuSysKey = iF10Key = 0;
 569         break;
 570
 571     case WM_SYSCHAR:
 572     {
 573         iMenuSysKey = 0;
 574         if (wParam == '\r' && IsIconic(hwnd))
 575         {
 576             PostMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, 0L );
 577             break;
 578         }
 579         if ((HIWORD(lParam) & KEYDATA_ALT) && wParam)
 580         {
 581             if (wParam == '\t' || wParam == '\x1b') break;
 582             if (wParam == ' ' && (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD))
 583                 SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 584             else
 585                 SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, wParam );
 586         }
 587         else /* check for Ctrl-Esc */
 588             if (wParam != '\x1b') MessageBeep(0);
 589         break;
 590     }
 591
 592     case WM_SHOWWINDOW:
 593         {
 594             LONG style = GetWindowLongW( hwnd, GWL_STYLE );
 595             if (!lParam) return 0; /* sent from ShowWindow */
 596             if (!(style & WS_POPUP)) return 0;
 597             if ((style & WS_VISIBLE) && wParam) return 0;
 598             if (!(style & WS_VISIBLE) && !wParam) return 0;
 599             if (!GetWindow( hwnd, GW_OWNER )) return 0;
 600             ShowWindow( hwnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE );
 601             break;
 602         }
 603
 604     case WM_CANCELMODE:
 605         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)) EndMenu();
 606         if (GetCapture() == hwnd) ReleaseCapture();
 607         break;
 608
 609     case WM_VKEYTOITEM:
 610     case WM_CHARTOITEM:
 611         return -1;
 612
 613     case WM_DROPOBJECT:
 614         return DRAG_FILE;
 615
 616     case WM_QUERYDROPOBJECT:
 617         return (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES) != 0;
 618
 619     case WM_QUERYDRAGICON:
 620         {
 621             UINT len;
 622
 623             HICON hIcon = (HICON)GetClassLongW( hwnd, GCL_HICON );
 624             HINSTANCE instance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 625             if (hIcon) return (LRESULT)hIcon;
 626             for(len=1; len<64; len++)
 627                 if((hIcon = LoadIconW(instance, MAKEINTRESOURCEW(len))))
 628                     return (LRESULT)hIcon;
 629             return (LRESULT)LoadIconW(0, (LPWSTR)IDI_APPLICATION);
 630         }
 631         break;
 632
 633     case WM_ISACTIVEICON:
 634         {
 635             WND *wndPtr = WIN_GetPtr( hwnd );
 636             BOOL ret = (wndPtr->flags & WIN_NCACTIVATED) != 0;
 637             WIN_ReleasePtr( wndPtr );
 638             return ret;
 639         }
 640
 641     case WM_NOTIFYFORMAT:
 642       if (IsWindowUnicode(hwnd)) return NFR_UNICODE;
 643       else return NFR_ANSI;
 644
 645     case WM_QUERYOPEN:
 646     case WM_QUERYENDSESSION:
 647         return 1;
 648
 649     case WM_SETICON:
 650         {
 651             HICON ret;
 652             WND *wndPtr = WIN_GetPtr( hwnd );
 653
 654             switch(wParam)
 655             {
 656             case ICON_SMALL:
 657                 ret = wndPtr->hIconSmall;
 658                 wndPtr->hIconSmall = (HICON)lParam;
 659                 break;
 660             case ICON_BIG:
 661                 ret = wndPtr->hIcon;
 662                 wndPtr->hIcon = (HICON)lParam;
 663                 break;
 664             default:
 665                 ret = 0;
 666                 break;
 667             }
 668             WIN_ReleasePtr( wndPtr );
 669
 670             if (USER_Driver.pSetWindowIcon)
 671                 USER_Driver.pSetWindowIcon( hwnd, wParam, (HICON)lParam );
 672
 673             SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE |
 674                          SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
 675
 676             return (LRESULT)ret;
 677         }
 678
 679     case WM_GETICON:
 680         {
 681             HICON ret;
 682             WND *wndPtr = WIN_GetPtr( hwnd );
 683
 684             switch(wParam)
 685             {
 686             case ICON_SMALL:
 687                 ret = wndPtr->hIconSmall;
 688                 break;
 689             case ICON_BIG:
 690                 ret = wndPtr->hIcon;
 691                 break;
 692             case ICON_SMALL2:
 693                 ret = wndPtr->hIconSmall;
 694                 if (!ret) ret = (HICON)GetClassLongA( hwnd, GCL_HICONSM );
 695                 /* FIXME: should have a default here if class icon is null */
 696                 break;
 697             default:
 698                 ret = 0;
 699                 break;
 700             }
 701             WIN_ReleasePtr( wndPtr );
 702             return (LRESULT)ret;
 703         }
 704
 705     case WM_HELP:
 706         SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 707         break;
 708     }
 709
 710     return 0;
 711 }
 712
 713
 714
 715 /***********************************************************************
 716  *              DefWindowProc (USER.107)
 717  */
 718 LRESULT WINAPI DefWindowProc16( HWND16 hwnd16, UINT16 msg, WPARAM16 wParam,
 719                                 LPARAM lParam )
 720 {
 721     LRESULT result = 0;
 722     HWND hwnd = WIN_Handle32( hwnd16 );
 723
 724     if (!WIN_IsCurrentProcess( hwnd ))
 725     {
 726         if (!IsWindow( hwnd )) return 0;
 727         ERR( "called for other process window %p\n", hwnd );
 728         return 0;
 729     }
 730     SPY_EnterMessage( SPY_DEFWNDPROC16, hwnd, msg, wParam, lParam );
 731
 732     switch(msg)
 733     {
 734     case WM_NCCREATE:
 735         {
 736             CREATESTRUCT16 *cs = MapSL(lParam);
 737             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 738              * may have child window IDs instead of window name */
 739             if (HIWORD(cs->lpszName))
 740                 DEFWND_SetTextA( hwnd, MapSL(cs->lpszName) );
 741             result = 1;
 742         }
 743         break;
 744
 745     case WM_NCCALCSIZE:
 746         {
 747             RECT rect32;
 748             RECT16 *rect16 = MapSL(lParam);
 749
 750             rect32.left   = rect16->left;
 751             rect32.top    = rect16->top;
 752             rect32.right  = rect16->right;
 753             rect32.bottom = rect16->bottom;
 754             result = NC_HandleNCCalcSize( hwnd, &rect32 );
 755             rect16->left   = rect32.left;
 756             rect16->top    = rect32.top;
 757             rect16->right  = rect32.right;
 758             rect16->bottom = rect32.bottom;
 759         }
 760         break;
 761
 762     case WM_WINDOWPOSCHANGING:
 763         result = WINPOS_HandleWindowPosChanging16( hwnd, MapSL(lParam) );
 764         break;
 765
 766     case WM_WINDOWPOSCHANGED:
 767         {
 768             WINDOWPOS16 * winPos = MapSL(lParam);
 769             DEFWND_HandleWindowPosChanged( hwnd, winPos->flags );
 770         }
 771         break;
 772
 773     case WM_GETTEXT:
 774     case WM_SETTEXT:
 775         result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)MapSL(lParam) );
 776         break;
 777
 778     default:
 779         result = DefWindowProcA( hwnd, msg, wParam, lParam );
 780         break;
 781     }
 782
 783     SPY_ExitMessage( SPY_RESULT_DEFWND16, hwnd, msg, result, wParam, lParam );
 784     return result;
 785 }
 786
 787
 788 /***********************************************************************
 789  *              DefWindowProcA (USER32.@)
 790  *
 791  */
 792 LRESULT WINAPI DefWindowProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 793 {
 794     LRESULT result = 0;
 795     HWND full_handle;
 796
 797     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 798     {
 799         if (!IsWindow( hwnd )) return 0;
 800         ERR( "called for other process window %p\n", hwnd );
 801         return 0;
 802     }
 803     hwnd = full_handle;
 804
 805     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 806
 807     switch(msg)
 808     {
 809     case WM_NCCREATE:
 810         {
 811             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
 812             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 813              * may have child window IDs instead of window name */
 814             if (HIWORD(cs->lpszName))
 815                 DEFWND_SetTextA( hwnd, cs->lpszName );
 816             result = 1;
 817         }
 818         break;
 819
 820     case WM_NCCALCSIZE:
 821         result = NC_HandleNCCalcSize( hwnd, (RECT *)lParam );
 822         break;
 823
 824     case WM_WINDOWPOSCHANGING:
 825         result = WINPOS_HandleWindowPosChanging( hwnd, (WINDOWPOS *)lParam );
 826         break;
 827
 828     case WM_WINDOWPOSCHANGED:
 829         {
 830             WINDOWPOS * winPos = (WINDOWPOS *)lParam;
 831             DEFWND_HandleWindowPosChanged( hwnd, winPos->flags );
 832         }
 833         break;
 834
 835     case WM_GETTEXTLENGTH:
 836         {
 837             WND *wndPtr = WIN_GetPtr( hwnd );
 838             if (wndPtr && wndPtr->text)
 839                 result = WideCharToMultiByte( CP_ACP, 0, wndPtr->text, strlenW(wndPtr->text),
 840                                               NULL, 0, NULL, NULL );
 841             WIN_ReleasePtr( wndPtr );
 842         }
 843         break;
 844
 845     case WM_GETTEXT:
 846         if (wParam)
 847         {
 848             LPSTR dest = (LPSTR)lParam;
 849             WND *wndPtr = WIN_GetPtr( hwnd );
 850
 851             if (!wndPtr) break;
 852             if (wndPtr->text)
 853             {
 854                 if (!WideCharToMultiByte( CP_ACP, 0, wndPtr->text, -1,
 855                                           dest, wParam, NULL, NULL )) dest[wParam-1] = 0;
 856                 result = strlen( dest );
 857             }
 858             else dest[0] = '\0';
 859             WIN_ReleasePtr( wndPtr );
 860         }
 861         break;
 862
 863     case WM_SETTEXT:
 864         DEFWND_SetTextA( hwnd, (LPCSTR)lParam );
 865         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 866             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 867         result = 1; /* success. FIXME: check text length */
 868         break;
 869
 870     /* for far east users (IMM32) - <hidenori@a2.ctktv.ne.jp> */
 871     case WM_IME_CHAR:
 872         {
 873             CHAR    chChar1 = (CHAR)( (wParam>>8) & 0xff );
 874             CHAR    chChar2 = (CHAR)( wParam & 0xff );
 875
 876             if (chChar1)
 877                 SendMessageA( hwnd, WM_CHAR, (WPARAM)chChar1, lParam );
 878             SendMessageA( hwnd, WM_CHAR, (WPARAM)chChar2, lParam );
 879         }
 880         break;
 881     case WM_IME_KEYDOWN:
 882         result = SendMessageA( hwnd, WM_KEYDOWN, wParam, lParam );
 883         break;
 884     case WM_IME_KEYUP:
 885         result = SendMessageA( hwnd, WM_KEYUP, wParam, lParam );
 886         break;
 887
 888     case WM_IME_STARTCOMPOSITION:
 889     case WM_IME_COMPOSITION:
 890     case WM_IME_ENDCOMPOSITION:
 891     case WM_IME_SELECT:
 892         {
 893             HWND hwndIME;
 894
 895             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
 896             if (hwndIME)
 897                 result = SendMessageA( hwndIME, msg, wParam, lParam );
 898         }
 899         break;
 900     case WM_IME_SETCONTEXT:
 901         {
 902             HWND hwndIME;
 903
 904             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
 905             if (hwndIME)
 906                 result = DEFWND_ImmIsUIMessageA( hwndIME, msg, wParam, lParam );
 907         }
 908         break;
 909
 910     case WM_INPUTLANGCHANGEREQUEST:
 911         /* notify about the switch only if it's really our current layout */
 912         if ((HKL)lParam == GetKeyboardLayout(0))
 913             result = SendMessageA( hwnd, WM_INPUTLANGCHANGE, wParam, lParam );
 914         else
 915             result = 0;
 916         break;
 917
 918     case WM_SYSCHAR:
 919     {
 920         BYTE ch = LOWORD(wParam);
 921         WCHAR wch;
 922         MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
 923         wParam = MAKEWPARAM( wch, HIWORD(wParam) );
 924     }
 925     /* fall through */
 926     default:
 927         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
 928         break;
 929     }
 930
 931     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
 932     return result;
 933 }
 934
 935
 936 /***********************************************************************
 937  *              DefWindowProcW (USER32.@) Calls default window message handler
 938  *
 939  * Calls default window procedure for messages not processed
 940  *  by application.
 941  *
 942  *  RETURNS
 943  *     Return value is dependent upon the message.
 944 */
 945 LRESULT WINAPI DefWindowProcW(
 946     HWND hwnd,      /* [in] window procedure receiving message */
 947     UINT msg,       /* [in] message identifier */
 948     WPARAM wParam,  /* [in] first message parameter */
 949     LPARAM lParam )   /* [in] second message parameter */
 950 {
 951     LRESULT result = 0;
 952     HWND full_handle;
 953
 954     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 955     {
 956         if (!IsWindow( hwnd )) return 0;
 957         ERR( "called for other process window %p\n", hwnd );
 958         return 0;
 959     }
 960     hwnd = full_handle;
 961     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 962
 963     switch(msg)
 964     {
 965     case WM_NCCREATE:
 966         {
 967             CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
 968             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 969              * may have child window IDs instead of window name */
 970             if (HIWORD(cs->lpszName))
 971                 DEFWND_SetTextW( hwnd, cs->lpszName );
 972             result = 1;
 973         }
 974         break;
 975
 976     case WM_NCCALCSIZE:
 977         result = NC_HandleNCCalcSize( hwnd, (RECT *)lParam );
 978         break;
 979
 980     case WM_WINDOWPOSCHANGING:
 981         result = WINPOS_HandleWindowPosChanging( hwnd, (WINDOWPOS *)lParam );
 982         break;
 983
 984     case WM_WINDOWPOSCHANGED:
 985         {
 986             WINDOWPOS * winPos = (WINDOWPOS *)lParam;
 987             DEFWND_HandleWindowPosChanged( hwnd, winPos->flags );
 988         }
 989         break;
 990
 991     case WM_GETTEXTLENGTH:
 992         {
 993             WND *wndPtr = WIN_GetPtr( hwnd );
 994             if (wndPtr && wndPtr->text) result = (LRESULT)strlenW(wndPtr->text);
 995             WIN_ReleasePtr( wndPtr );
 996         }
 997         break;
 998
 999     case WM_GETTEXT:
1000         if (wParam)
1001         {
1002             LPWSTR dest = (LPWSTR)lParam;
1003             WND *wndPtr = WIN_GetPtr( hwnd );
1004
1005             if (!wndPtr) break;
1006             if (wndPtr->text)
1007             {
1008                 lstrcpynW( dest, wndPtr->text, wParam );
1009                 result = strlenW( dest );
1010             }
1011             else dest[0] = '\0';
1012             WIN_ReleasePtr( wndPtr );
1013         }
1014         break;
1015
1016     case WM_SETTEXT:
1017         DEFWND_SetTextW( hwnd, (LPCWSTR)lParam );
1018         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
1019             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
1020         result = 1; /* success. FIXME: check text length */
1021         break;
1022
1023     /* for far east users (IMM32) - <hidenori@a2.ctktv.ne.jp> */
1024     case WM_IME_CHAR:
1025         SendMessageW( hwnd, WM_CHAR, wParam, lParam );
1026         break;
1027     case WM_IME_SETCONTEXT:
1028         {
1029             HWND hwndIME;
1030
1031             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
1032             if (hwndIME)
1033                 result = DEFWND_ImmIsUIMessageW( hwndIME, msg, wParam, lParam );
1034         }
1035         break;
1036
1037     case WM_INPUTLANGCHANGEREQUEST:
1038         /* notify about the switch only if it's really our current layout */
1039         if ((HKL)lParam == GetKeyboardLayout(0))
1040             result = SendMessageW( hwnd, WM_INPUTLANGCHANGE, wParam, lParam );
1041         else
1042             result = 0;
1043         break;
1044
1045     default:
1046         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
1047         break;
1048     }
1049     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
1050     return result;
1051 }