git.oblomov.eu Git - wine/blob - dlls/comctl32/commctrl.c

   1 /*
   2  * Common controls functions
   3  *
   4  * Copyright 1997 Dimitrie O. Paun
   5  * Copyright 1998,2000 Eric Kohl
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES
  22  *
  23  * This code was audited for completeness against the documented features
  24  * of Comctl32.dll version 6.0 on Oct. 21, 2002, by Christian Neumair.
  25  *
  26  * Unless otherwise noted, we believe this code to be complete, as per
  27  * the specification mentioned above.
  28  * If you discover missing features, or bugs, please note them below.
  29  *
  30  * TODO
  31  *   -- implement GetMUILanguage + InitMUILanguage
  32  *   -- finish NOTES for MenuHelp, GetEffectiveClientRect and GetStatusTextW
  33  *   -- FIXMEs + BUGS (search for them)
  34  *
  35  * Control Classes
  36  *   -- ICC_ANIMATE_CLASS
  37  *   -- ICC_BAR_CLASSES
  38  *   -- ICC_COOL_CLASSES
  39  *   -- ICC_DATE_CLASSES
  40  *   -- ICC_HOTKEY_CLASS
  41  *   -- ICC_INTERNET_CLASSES
  42  *   -- ICC_LINK_CLASS
  43  *   -- ICC_LISTVIEW_CLASSES
  44  *   -- ICC_NATIVEFNTCTL_CLASS
  45  *   -- ICC_PAGESCROLLER_CLASS
  46  *   -- ICC_PROGRESS_CLASS
  47  *   -- ICC_STANDARD_CLASSES (not yet implemented)
  48  *   -- ICC_TAB_CLASSES
  49  *   -- ICC_TREEVIEW_CLASSES
  50  *   -- ICC_UPDOWN_CLASS
  51  *   -- ICC_USEREX_CLASSES
  52  *   -- ICC_WIN95_CLASSES
  53  */
  54
  55 #include <stdarg.h>
  56 #include <string.h>
  57 #include <stdlib.h>
  58
  59 #include "windef.h"
  60 #include "winbase.h"
  61 #include "wingdi.h"
  62 #include "winuser.h"
  63 #include "winnls.h"
  64 #include "commctrl.h"
  65 #include "winerror.h"
  66 #include "winreg.h"
  67 #define NO_SHLWAPI_STREAM
  68 #include "shlwapi.h"
  69 #include "comctl32.h"
  70 #include "wine/debug.h"
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
  73
  74
  75 #define NAME       "microsoft.windows.common-controls"
  76 #define FILE       "comctl32.dll"
  77 #define VERSION    "6.0.2600.2982"
  78 #define PUBLIC_KEY "6595b64144ccf1df"
  79
  80 #ifdef __i386__
  81 #define ARCH "x86"
  82 #elif defined __x86_64__
  83 #define ARCH "amd64"
  84 #else
  85 #define ARCH "none"
  86 #endif
  87
  88 static const char manifest[] =
  89     "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
  90     "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n"
  91     "  <assemblyIdentity type=\"win32\" name=\"" NAME "\" version=\"" VERSION "\" processorArchitecture=\"" ARCH "\" publicKeyToken=\"" PUBLIC_KEY "\"/>\n"
  92     "  <file name=\"" FILE "\">\n"
  93     "    <windowClass>Button</windowClass>\n"
  94     "    <windowClass>ButtonListBox</windowClass>\n"
  95     "    <windowClass>ComboBoxEx32</windowClass>\n"
  96     "    <windowClass>ComboLBox</windowClass>\n"
  97     "    <windowClass>Combobox</windowClass>\n"
  98     "    <windowClass>Edit</windowClass>\n"
  99     "    <windowClass>Listbox</windowClass>\n"
 100     "    <windowClass>NativeFontCtl</windowClass>\n"
 101     "    <windowClass>ReBarWindow32</windowClass>\n"
 102     "    <windowClass>ScrollBar</windowClass>\n"
 103     "    <windowClass>Static</windowClass>\n"
 104     "    <windowClass>SysAnimate32</windowClass>\n"
 105     "    <windowClass>SysDateTimePick32</windowClass>\n"
 106     "    <windowClass>SysHeader32</windowClass>\n"
 107     "    <windowClass>SysIPAddress32</windowClass>\n"
 108     "    <windowClass>SysLink</windowClass>\n"
 109     "    <windowClass>SysListView32</windowClass>\n"
 110     "    <windowClass>SysMonthCal32</windowClass>\n"
 111     "    <windowClass>SysPager</windowClass>\n"
 112     "    <windowClass>SysTabControl32</windowClass>\n"
 113     "    <windowClass>SysTreeView32</windowClass>\n"
 114     "    <windowClass>ToolbarWindow32</windowClass>\n"
 115     "    <windowClass>msctls_hotkey32</windowClass>\n"
 116     "    <windowClass>msctls_progress32</windowClass>\n"
 117     "    <windowClass>msctls_statusbar32</windowClass>\n"
 118     "    <windowClass>msctls_trackbar32</windowClass>\n"
 119     "    <windowClass>msctls_updown32</windowClass>\n"
 120     "    <windowClass>tooltips_class32</windowClass>\n"
 121     "  </file>\n"
 122     "</assembly>\n";
 123
 124 static const char manifest_filename[] = ARCH "_" NAME "_" PUBLIC_KEY "_" VERSION "_none_deadbeef.manifest";
 125
 126 static LRESULT WINAPI COMCTL32_SubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 127
 128 static LPWSTR COMCTL32_wSubclass = NULL;
 129 HMODULE COMCTL32_hModule = 0;
 130 static LANGID COMCTL32_uiLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
 131 HBRUSH  COMCTL32_hPattern55AABrush = NULL;
 132 COMCTL32_SysColor  comctl32_color;
 133
 134 static HBITMAP COMCTL32_hPattern55AABitmap = NULL;
 135
 136 static const WORD wPattern55AA[] =
 137 {
 138     0x5555, 0xaaaa, 0x5555, 0xaaaa,
 139     0x5555, 0xaaaa, 0x5555, 0xaaaa
 140 };
 141
 142 static const WCHAR strCC32SubclassInfo[] = {
 143     'C','C','3','2','S','u','b','c','l','a','s','s','I','n','f','o',0
 144 };
 145
 146 static BOOL create_manifest( BOOL install )
 147 {
 148     static const WCHAR winsxsW[] = {'\\','w','i','n','s','x','s',0};
 149     static const WCHAR manifestsW[] = {'\\','m','a','n','i','f','e','s','t','s','\\',0};
 150
 151     DWORD len, written;
 152     WCHAR *buffer;
 153     HANDLE file;
 154     BOOL ret = FALSE;
 155
 156     len = MultiByteToWideChar( CP_UTF8, 0, manifest_filename, sizeof(manifest_filename), NULL, 0 );
 157     len += GetWindowsDirectoryW( NULL, 0 );
 158     len += lstrlenW(winsxsW);
 159     len += lstrlenW(manifestsW);
 160     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
 161     GetWindowsDirectoryW( buffer, len );
 162     lstrcatW( buffer, winsxsW );
 163     CreateDirectoryW( buffer, NULL );
 164     lstrcatW( buffer, manifestsW );
 165     CreateDirectoryW( buffer, NULL );
 166     MultiByteToWideChar( CP_UTF8, 0, manifest_filename, sizeof(manifest_filename),
 167                          buffer + lstrlenW(buffer), len );
 168     if (install)
 169     {
 170         file = CreateFileW( buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
 171         if (file != INVALID_HANDLE_VALUE)
 172         {
 173             ret = (WriteFile( file, manifest, sizeof(manifest)-1, &written, NULL ) &&
 174                    written == sizeof(manifest)-1);
 175             CloseHandle( file );
 176             if (!ret) DeleteFileW( buffer );
 177             else TRACE("created %s\n", debugstr_w(buffer));
 178         }
 179     }
 180     else ret = DeleteFileW( buffer );
 181
 182     HeapFree( GetProcessHeap(), 0, buffer );
 183     return ret;
 184 }
 185
 186
 187 /***********************************************************************
 188  * DllMain [Internal]
 189  *
 190  * Initializes the internal 'COMCTL32.DLL'.
 191  *
 192  * PARAMS
 193  *     hinstDLL    [I] handle to the 'dlls' instance
 194  *     fdwReason   [I]
 195  *     lpvReserved [I] reserverd, must be NULL
 196  *
 197  * RETURNS
 198  *     Success: TRUE
 199  *     Failure: FALSE
 200  */
 201
 202 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 203 {
 204     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
 205
 206     switch (fdwReason) {
 207         case DLL_PROCESS_ATTACH:
 208             DisableThreadLibraryCalls(hinstDLL);
 209
 210             COMCTL32_hModule = hinstDLL;
 211
 212             /* add global subclassing atom (used by 'tooltip' and 'updown') */
 213             COMCTL32_wSubclass = (LPWSTR)(DWORD_PTR)GlobalAddAtomW (strCC32SubclassInfo);
 214             TRACE("Subclassing atom added: %p\n", COMCTL32_wSubclass);
 215
 216             /* create local pattern brush */
 217             COMCTL32_hPattern55AABitmap = CreateBitmap (8, 8, 1, 1, wPattern55AA);
 218             COMCTL32_hPattern55AABrush = CreatePatternBrush (COMCTL32_hPattern55AABitmap);
 219
 220             /* Get all the colors at DLL load */
 221             COMCTL32_RefreshSysColors();
 222
 223             /* like comctl32 5.82+ register all the common control classes */
 224             ANIMATE_Register ();
 225             COMBOEX_Register ();
 226             DATETIME_Register ();
 227             FLATSB_Register ();
 228             HEADER_Register ();
 229             HOTKEY_Register ();
 230             IPADDRESS_Register ();
 231             LISTVIEW_Register ();
 232             MONTHCAL_Register ();
 233             NATIVEFONT_Register ();
 234             PAGER_Register ();
 235             PROGRESS_Register ();
 236             REBAR_Register ();
 237             STATUS_Register ();
 238             SYSLINK_Register ();
 239             TAB_Register ();
 240             TOOLBAR_Register ();
 241             TOOLTIPS_Register ();
 242             TRACKBAR_Register ();
 243             TREEVIEW_Register ();
 244             UPDOWN_Register ();
 245
 246             /* subclass user32 controls */
 247             THEMING_Initialize ();
 248             break;
 249
 250         case DLL_PROCESS_DETACH:
 251             /* clean up subclassing */
 252             THEMING_Uninitialize();
 253
 254             /* unregister all common control classes */
 255             ANIMATE_Unregister ();
 256             COMBOEX_Unregister ();
 257             DATETIME_Unregister ();
 258             FLATSB_Unregister ();
 259             HEADER_Unregister ();
 260             HOTKEY_Unregister ();
 261             IPADDRESS_Unregister ();
 262             LISTVIEW_Unregister ();
 263             MONTHCAL_Unregister ();
 264             NATIVEFONT_Unregister ();
 265             PAGER_Unregister ();
 266             PROGRESS_Unregister ();
 267             REBAR_Unregister ();
 268             STATUS_Unregister ();
 269             SYSLINK_Unregister ();
 270             TAB_Unregister ();
 271             TOOLBAR_Unregister ();
 272             TOOLTIPS_Unregister ();
 273             TRACKBAR_Unregister ();
 274             TREEVIEW_Unregister ();
 275             UPDOWN_Unregister ();
 276
 277             /* delete local pattern brush */
 278             DeleteObject (COMCTL32_hPattern55AABrush);
 279             COMCTL32_hPattern55AABrush = NULL;
 280             DeleteObject (COMCTL32_hPattern55AABitmap);
 281             COMCTL32_hPattern55AABitmap = NULL;
 282
 283             /* delete global subclassing atom */
 284             GlobalDeleteAtom (LOWORD(COMCTL32_wSubclass));
 285             TRACE("Subclassing atom deleted: %p\n", COMCTL32_wSubclass);
 286             COMCTL32_wSubclass = NULL;
 287             break;
 288     }
 289
 290     return TRUE;
 291 }
 292
 293
 294 /***********************************************************************
 295  * MenuHelp [COMCTL32.2]
 296  *
 297  * Handles the setting of status bar help messages when the user
 298  * selects menu items.
 299  *
 300  * PARAMS
 301  *     uMsg       [I] message (WM_MENUSELECT) (see NOTES)
 302  *     wParam     [I] wParam of the message uMsg
 303  *     lParam     [I] lParam of the message uMsg
 304  *     hMainMenu  [I] handle to the application's main menu
 305  *     hInst      [I] handle to the module that contains string resources
 306  *     hwndStatus [I] handle to the status bar window
 307  *     lpwIDs     [I] pointer to an array of integers (see NOTES)
 308  *
 309  * RETURNS
 310  *     No return value
 311  *
 312  * NOTES
 313  *     The official documentation is incomplete!
 314  *     This is the correct documentation:
 315  *
 316  *     uMsg:
 317  *     MenuHelp() does NOT handle WM_COMMAND messages! It only handles
 318  *     WM_MENUSELECT messages.
 319  *
 320  *     lpwIDs:
 321  *     (will be written ...)
 322  */
 323
 324 VOID WINAPI
 325 MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
 326           HINSTANCE hInst, HWND hwndStatus, UINT* lpwIDs)
 327 {
 328     UINT uMenuID = 0;
 329
 330     if (!IsWindow (hwndStatus))
 331         return;
 332
 333     switch (uMsg) {
 334         case WM_MENUSELECT:
 335             TRACE("WM_MENUSELECT wParam=0x%lX lParam=0x%lX\n",
 336                    wParam, lParam);
 337
 338             if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
 339                 /* menu was closed */
 340                 TRACE("menu was closed!\n");
 341                 SendMessageW (hwndStatus, SB_SIMPLE, FALSE, 0);
 342             }
 343             else {
 344                 /* menu item was selected */
 345                 if (HIWORD(wParam) & MF_POPUP)
 346                     uMenuID = *(lpwIDs+1);
 347                 else
 348                     uMenuID = (UINT)LOWORD(wParam);
 349                 TRACE("uMenuID = %u\n", uMenuID);
 350
 351                 if (uMenuID) {
 352                     WCHAR szText[256];
 353
 354                     if (!LoadStringW (hInst, uMenuID, szText, sizeof(szText)/sizeof(szText[0])))
 355                         szText[0] = '\0';
 356
 357                     SendMessageW (hwndStatus, SB_SETTEXTW,
 358                                     255 | SBT_NOBORDERS, (LPARAM)szText);
 359                     SendMessageW (hwndStatus, SB_SIMPLE, TRUE, 0);
 360                 }
 361             }
 362             break;
 363
 364         case WM_COMMAND :
 365             TRACE("WM_COMMAND wParam=0x%lX lParam=0x%lX\n",
 366                    wParam, lParam);
 367             /* WM_COMMAND is not invalid since it is documented
 368              * in the windows api reference. So don't output
 369              * any FIXME for WM_COMMAND
 370              */
 371             WARN("We don't care about the WM_COMMAND\n");
 372             break;
 373
 374         default:
 375             FIXME("Invalid Message 0x%x!\n", uMsg);
 376             break;
 377     }
 378 }
 379
 380
 381 /***********************************************************************
 382  * ShowHideMenuCtl [COMCTL32.3]
 383  *
 384  * Shows or hides controls and updates the corresponding menu item.
 385  *
 386  * PARAMS
 387  *     hwnd   [I] handle to the client window.
 388  *     uFlags [I] menu command id.
 389  *     lpInfo [I] pointer to an array of integers. (See NOTES.)
 390  *
 391  * RETURNS
 392  *     Success: TRUE
 393  *     Failure: FALSE
 394  *
 395  * NOTES
 396  *     The official documentation is incomplete!
 397  *     This is the correct documentation:
 398  *
 399  *     hwnd
 400  *     Handle to the window that contains the menu and controls.
 401  *
 402  *     uFlags
 403  *     Identifier of the menu item to receive or lose a check mark.
 404  *
 405  *     lpInfo
 406  *     The array of integers contains pairs of values. BOTH values of
 407  *     the first pair must be the handles to the application's main menu.
 408  *     Each subsequent pair consists of a menu id and control id.
 409  */
 410
 411 BOOL WINAPI
 412 ShowHideMenuCtl (HWND hwnd, UINT_PTR uFlags, LPINT lpInfo)
 413 {
 414     LPINT lpMenuId;
 415
 416     TRACE("%p, %lx, %p\n", hwnd, uFlags, lpInfo);
 417
 418     if (lpInfo == NULL)
 419         return FALSE;
 420
 421     if (!(lpInfo[0]) || !(lpInfo[1]))
 422         return FALSE;
 423
 424     /* search for control */
 425     lpMenuId = &lpInfo[2];
 426     while (*lpMenuId != uFlags)
 427         lpMenuId += 2;
 428
 429     if (GetMenuState ((HMENU)(DWORD_PTR)lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
 430         /* uncheck menu item */
 431         CheckMenuItem ((HMENU)(DWORD_PTR)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
 432
 433         /* hide control */
 434         lpMenuId++;
 435         SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
 436                         SWP_HIDEWINDOW);
 437     }
 438     else {
 439         /* check menu item */
 440         CheckMenuItem ((HMENU)(DWORD_PTR)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
 441
 442         /* show control */
 443         lpMenuId++;
 444         SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
 445                         SWP_SHOWWINDOW);
 446     }
 447
 448     return TRUE;
 449 }
 450
 451
 452 /***********************************************************************
 453  * GetEffectiveClientRect [COMCTL32.4]
 454  *
 455  * Calculates the coordinates of a rectangle in the client area.
 456  *
 457  * PARAMS
 458  *     hwnd   [I] handle to the client window.
 459  *     lpRect [O] pointer to the rectangle of the client window
 460  *     lpInfo [I] pointer to an array of integers (see NOTES)
 461  *
 462  * RETURNS
 463  *     No return value.
 464  *
 465  * NOTES
 466  *     The official documentation is incomplete!
 467  *     This is the correct documentation:
 468  *
 469  *     lpInfo
 470  *     (will be written ...)
 471  */
 472
 473 VOID WINAPI
 474 GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, const INT *lpInfo)
 475 {
 476     RECT rcCtrl;
 477     const INT *lpRun;
 478     HWND hwndCtrl;
 479
 480     TRACE("(%p %p %p)\n",
 481            hwnd, lpRect, lpInfo);
 482
 483     GetClientRect (hwnd, lpRect);
 484     lpRun = lpInfo;
 485
 486     do {
 487         lpRun += 2;
 488         if (*lpRun == 0)
 489             return;
 490         lpRun++;
 491         hwndCtrl = GetDlgItem (hwnd, *lpRun);
 492         if (GetWindowLongW (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
 493             TRACE("control id 0x%x\n", *lpRun);
 494             GetWindowRect (hwndCtrl, &rcCtrl);
 495             MapWindowPoints (NULL, hwnd, (LPPOINT)&rcCtrl, 2);
 496             SubtractRect (lpRect, lpRect, &rcCtrl);
 497         }
 498         lpRun++;
 499     } while (*lpRun);
 500 }
 501
 502
 503 /***********************************************************************
 504  * DrawStatusTextW [COMCTL32.@]
 505  *
 506  * Draws text with borders, like in a status bar.
 507  *
 508  * PARAMS
 509  *     hdc   [I] handle to the window's display context
 510  *     lprc  [I] pointer to a rectangle
 511  *     text  [I] pointer to the text
 512  *     style [I] drawing style
 513  *
 514  * RETURNS
 515  *     No return value.
 516  *
 517  * NOTES
 518  *     The style variable can have one of the following values:
 519  *     (will be written ...)
 520  */
 521
 522 void WINAPI DrawStatusTextW (HDC hdc, LPCRECT lprc, LPCWSTR text, UINT style)
 523 {
 524     RECT r = *lprc;
 525     UINT border = BDR_SUNKENOUTER;
 526
 527     if (style & SBT_POPOUT)
 528         border = BDR_RAISEDOUTER;
 529     else if (style & SBT_NOBORDERS)
 530         border = 0;
 531
 532     DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST);
 533
 534     /* now draw text */
 535     if (text) {
 536         int oldbkmode = SetBkMode (hdc, TRANSPARENT);
 537         UINT align = DT_LEFT;
 538         int strCnt = 0;
 539
 540         if (style & SBT_RTLREADING)
 541             FIXME("Unsupported RTL style!\n");
 542         r.left += 3;
 543         do {
 544             if (*text == '\t') {
 545                 if (strCnt) {
 546                     DrawTextW (hdc, text - strCnt, strCnt, &r, align|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX);
 547                     strCnt = 0;
 548                 }
 549                 if (align==DT_RIGHT) {
 550                     break;
 551                 }
 552                 align = (align==DT_LEFT ? DT_CENTER : DT_RIGHT);
 553             } else {
 554                 strCnt++;
 555             }
 556         } while(*text++);
 557
 558         if (strCnt) DrawTextW (hdc, text - strCnt, -1, &r, align|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX);
 559         SetBkMode(hdc, oldbkmode);
 560     }
 561 }
 562
 563
 564 /***********************************************************************
 565  * DrawStatusText  [COMCTL32.@]
 566  * DrawStatusTextA [COMCTL32.5]
 567  *
 568  * Draws text with borders, like in a status bar.
 569  *
 570  * PARAMS
 571  *     hdc   [I] handle to the window's display context
 572  *     lprc  [I] pointer to a rectangle
 573  *     text  [I] pointer to the text
 574  *     style [I] drawing style
 575  *
 576  * RETURNS
 577  *     No return value.
 578  */
 579
 580 void WINAPI DrawStatusTextA (HDC hdc, LPCRECT lprc, LPCSTR text, UINT style)
 581 {
 582     INT len;
 583     LPWSTR textW = NULL;
 584
 585     if ( text ) {
 586         if ( (len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 )) ) {
 587             if ( (textW = Alloc( len * sizeof(WCHAR) )) )
 588                 MultiByteToWideChar( CP_ACP, 0, text, -1, textW, len );
 589         }
 590     }
 591     DrawStatusTextW( hdc, lprc, textW, style );
 592     Free( textW );
 593 }
 594
 595
 596 /***********************************************************************
 597  * CreateStatusWindow  [COMCTL32.@]
 598  * CreateStatusWindowA [COMCTL32.6]
 599  *
 600  * Creates a status bar
 601  *
 602  * PARAMS
 603  *     style  [I] window style
 604  *     text   [I] pointer to the window text
 605  *     parent [I] handle to the parent window
 606  *     wid    [I] control id of the status bar
 607  *
 608  * RETURNS
 609  *     Success: handle to the status window
 610  *     Failure: 0
 611  */
 612
 613 HWND WINAPI
 614 CreateStatusWindowA (LONG style, LPCSTR text, HWND parent, UINT wid)
 615 {
 616     return CreateWindowA(STATUSCLASSNAMEA, text, style,
 617                            CW_USEDEFAULT, CW_USEDEFAULT,
 618                            CW_USEDEFAULT, CW_USEDEFAULT,
 619                            parent, (HMENU)(DWORD_PTR)wid, 0, 0);
 620 }
 621
 622
 623 /***********************************************************************
 624  * CreateStatusWindowW [COMCTL32.@]
 625  *
 626  * Creates a status bar control
 627  *
 628  * PARAMS
 629  *     style  [I] window style
 630  *     text   [I] pointer to the window text
 631  *     parent [I] handle to the parent window
 632  *     wid    [I] control id of the status bar
 633  *
 634  * RETURNS
 635  *     Success: handle to the status window
 636  *     Failure: 0
 637  */
 638
 639 HWND WINAPI
 640 CreateStatusWindowW (LONG style, LPCWSTR text, HWND parent, UINT wid)
 641 {
 642     return CreateWindowW(STATUSCLASSNAMEW, text, style,
 643                            CW_USEDEFAULT, CW_USEDEFAULT,
 644                            CW_USEDEFAULT, CW_USEDEFAULT,
 645                            parent, (HMENU)(DWORD_PTR)wid, 0, 0);
 646 }
 647
 648
 649 /***********************************************************************
 650  * CreateUpDownControl [COMCTL32.16]
 651  *
 652  * Creates an up-down control
 653  *
 654  * PARAMS
 655  *     style  [I] window styles
 656  *     x      [I] horizontal position of the control
 657  *     y      [I] vertical position of the control
 658  *     cx     [I] with of the control
 659  *     cy     [I] height of the control
 660  *     parent [I] handle to the parent window
 661  *     id     [I] the control's identifier
 662  *     inst   [I] handle to the application's module instance
 663  *     buddy  [I] handle to the buddy window, can be NULL
 664  *     maxVal [I] upper limit of the control
 665  *     minVal [I] lower limit of the control
 666  *     curVal [I] current value of the control
 667  *
 668  * RETURNS
 669  *     Success: handle to the updown control
 670  *     Failure: 0
 671  */
 672
 673 HWND WINAPI
 674 CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
 675                      HWND parent, INT id, HINSTANCE inst,
 676                      HWND buddy, INT maxVal, INT minVal, INT curVal)
 677 {
 678     HWND hUD =
 679         CreateWindowW (UPDOWN_CLASSW, 0, style, x, y, cx, cy,
 680                          parent, (HMENU)(DWORD_PTR)id, inst, 0);
 681     if (hUD) {
 682         SendMessageW (hUD, UDM_SETBUDDY, (WPARAM)buddy, 0);
 683         SendMessageW (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
 684         SendMessageW (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
 685     }
 686
 687     return hUD;
 688 }
 689
 690
 691 /***********************************************************************
 692  * InitCommonControls [COMCTL32.17]
 693  *
 694  * Registers the common controls.
 695  *
 696  * PARAMS
 697  *     No parameters.
 698  *
 699  * RETURNS
 700  *     No return values.
 701  *
 702  * NOTES
 703  *     This function is just a dummy - all the controls are registered at
 704  *     the DLL's initialization. See InitCommonContolsEx for details.
 705  */
 706
 707 VOID WINAPI
 708 InitCommonControls (void)
 709 {
 710 }
 711
 712
 713 /***********************************************************************
 714  * InitCommonControlsEx [COMCTL32.@]
 715  *
 716  * Registers the common controls.
 717  *
 718  * PARAMS
 719  *     lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
 720  *
 721  * RETURNS
 722  *     Success: TRUE
 723  *     Failure: FALSE
 724  *
 725  * NOTES
 726  *     Probably all versions of comctl32 initializes the Win95 controls in DllMain
 727  *     during DLL initialization. Starting from comctl32 v5.82 all the controls
 728  *     are initialized there. We follow this behaviour and this function is just
 729  *     a dummy.
 730  *
 731  *     Note: when writing programs under Windows, if you don't call any function
 732  *     from comctl32 the linker may not link this DLL. If InitCommonControlsEx
 733  *     was the only comctl32 function you were calling and you remove it you may
 734  *     have a false impression that InitCommonControlsEx actually did something.
 735  */
 736
 737 BOOL WINAPI
 738 InitCommonControlsEx (const INITCOMMONCONTROLSEX *lpInitCtrls)
 739 {
 740     if (!lpInitCtrls || lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
 741         return FALSE;
 742
 743     TRACE("(0x%08x)\n", lpInitCtrls->dwICC);
 744     return TRUE;
 745 }
 746
 747
 748 /***********************************************************************
 749  * CreateToolbarEx [COMCTL32.@]
 750  *
 751  * Creates a toolbar window.
 752  *
 753  * PARAMS
 754  *     hwnd
 755  *     style
 756  *     wID
 757  *     nBitmaps
 758  *     hBMInst
 759  *     wBMID
 760  *     lpButtons
 761  *     iNumButtons
 762  *     dxButton
 763  *     dyButton
 764  *     dxBitmap
 765  *     dyBitmap
 766  *     uStructSize
 767  *
 768  * RETURNS
 769  *     Success: handle to the tool bar control
 770  *     Failure: 0
 771  */
 772
 773 HWND WINAPI
 774 CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
 775                  HINSTANCE hBMInst, UINT_PTR wBMID, LPCTBBUTTON lpButtons,
 776                  INT iNumButtons, INT dxButton, INT dyButton,
 777                  INT dxBitmap, INT dyBitmap, UINT uStructSize)
 778 {
 779     HWND hwndTB;
 780
 781     hwndTB =
 782         CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL, style|WS_CHILD, 0,0,100,30,
 783                         hwnd, (HMENU)(DWORD_PTR)wID, COMCTL32_hModule, NULL);
 784     if(hwndTB) {
 785         TBADDBITMAP tbab;
 786
 787         SendMessageW (hwndTB, TB_BUTTONSTRUCTSIZE, uStructSize, 0);
 788
 789        /* set bitmap and button size */
 790        /*If CreateToolbarEx receives 0, windows sets default values*/
 791        if (dxBitmap < 0)
 792            dxBitmap = 16;
 793        if (dyBitmap < 0)
 794            dyBitmap = 16;
 795        if (dxBitmap == 0 || dyBitmap == 0)
 796            dxBitmap = dyBitmap = 16;
 797        SendMessageW(hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(dxBitmap, dyBitmap));
 798
 799        if (dxButton < 0)
 800            dxButton = dxBitmap;
 801        if (dyButton < 0)
 802            dyButton = dyBitmap;
 803        /* TB_SETBUTTONSIZE -> TB_SETBITMAPSIZE bug introduced for Windows compatibility */
 804        if (dxButton != 0 && dyButton != 0)
 805             SendMessageW(hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(dxButton, dyButton));
 806
 807
 808         /* add bitmaps */
 809         if (nBitmaps > 0 || hBMInst == HINST_COMMCTRL)
 810         {
 811             tbab.hInst = hBMInst;
 812             tbab.nID   = wBMID;
 813
 814             SendMessageW (hwndTB, TB_ADDBITMAP, nBitmaps, (LPARAM)&tbab);
 815         }
 816         /* add buttons */
 817         if(iNumButtons > 0)
 818         SendMessageW (hwndTB, TB_ADDBUTTONSW, iNumButtons, (LPARAM)lpButtons);
 819     }
 820
 821     return hwndTB;
 822 }
 823
 824
 825 /***********************************************************************
 826  * CreateMappedBitmap [COMCTL32.8]
 827  *
 828  * Loads a bitmap resource using a colour map.
 829  *
 830  * PARAMS
 831  *     hInstance  [I] Handle to the module containing the bitmap.
 832  *     idBitmap   [I] The bitmap resource ID.
 833  *     wFlags     [I] CMB_MASKED for using bitmap as a mask or 0 for normal.
 834  *     lpColorMap [I] Colour information needed for the bitmap or NULL (uses system colours).
 835  *     iNumMaps   [I] Number of COLORMAP's pointed to by lpColorMap.
 836  *
 837  * RETURNS
 838  *     Success: handle to the new bitmap
 839  *     Failure: 0
 840  */
 841
 842 HBITMAP WINAPI
 843 CreateMappedBitmap (HINSTANCE hInstance, INT_PTR idBitmap, UINT wFlags,
 844                     LPCOLORMAP lpColorMap, INT iNumMaps)
 845 {
 846     HGLOBAL hglb;
 847     HRSRC hRsrc;
 848     const BITMAPINFOHEADER *lpBitmap;
 849     LPBITMAPINFOHEADER lpBitmapInfo;
 850     UINT nSize, nColorTableSize, iColor;
 851     RGBQUAD *pColorTable;
 852     INT i, iMaps, nWidth, nHeight;
 853     HDC hdcScreen;
 854     HBITMAP hbm;
 855     LPCOLORMAP sysColorMap;
 856     COLORREF cRef;
 857     COLORMAP internalColorMap[4] =
 858         {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
 859
 860     /* initialize pointer to colortable and default color table */
 861     if (lpColorMap) {
 862         iMaps = iNumMaps;
 863         sysColorMap = lpColorMap;
 864     }
 865     else {
 866         internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
 867         internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
 868         internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
 869         internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
 870         iMaps = 4;
 871         sysColorMap = internalColorMap;
 872     }
 873
 874     hRsrc = FindResourceW (hInstance, (LPWSTR)idBitmap, (LPWSTR)RT_BITMAP);
 875     if (hRsrc == 0)
 876         return 0;
 877     hglb = LoadResource (hInstance, hRsrc);
 878     if (hglb == 0)
 879         return 0;
 880     lpBitmap = LockResource (hglb);
 881     if (lpBitmap == NULL)
 882         return 0;
 883
 884     if (lpBitmap->biSize >= sizeof(BITMAPINFOHEADER) && lpBitmap->biClrUsed)
 885         nColorTableSize = lpBitmap->biClrUsed;
 886     else if (lpBitmap->biBitCount <= 8)
 887         nColorTableSize = (1 << lpBitmap->biBitCount);
 888     else
 889         nColorTableSize = 0;
 890     nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
 891     lpBitmapInfo = GlobalAlloc (GMEM_FIXED, nSize);
 892     if (lpBitmapInfo == NULL)
 893         return 0;
 894     RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
 895
 896     pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo) + lpBitmapInfo->biSize);
 897
 898     for (iColor = 0; iColor < nColorTableSize; iColor++) {
 899         for (i = 0; i < iMaps; i++) {
 900             cRef = RGB(pColorTable[iColor].rgbRed,
 901                        pColorTable[iColor].rgbGreen,
 902                        pColorTable[iColor].rgbBlue);
 903             if ( cRef  == sysColorMap[i].from) {
 904 #if 0
 905                 if (wFlags & CBS_MASKED) {
 906                     if (sysColorMap[i].to != COLOR_BTNTEXT)
 907                         pColorTable[iColor] = RGB(255, 255, 255);
 908                 }
 909                 else
 910 #endif
 911                     pColorTable[iColor].rgbBlue  = GetBValue(sysColorMap[i].to);
 912                     pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
 913                     pColorTable[iColor].rgbRed   = GetRValue(sysColorMap[i].to);
 914                 break;
 915             }
 916         }
 917     }
 918     nWidth  = lpBitmapInfo->biWidth;
 919     nHeight = lpBitmapInfo->biHeight;
 920     hdcScreen = GetDC (NULL);
 921     hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
 922     if (hbm) {
 923         HDC hdcDst = CreateCompatibleDC (hdcScreen);
 924         HBITMAP hbmOld = SelectObject (hdcDst, hbm);
 925         const BYTE *lpBits = (const BYTE *)(lpBitmap + 1);
 926         lpBits += nColorTableSize * sizeof(RGBQUAD);
 927         StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
 928                          lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
 929                          SRCCOPY);
 930         SelectObject (hdcDst, hbmOld);
 931         DeleteDC (hdcDst);
 932     }
 933     ReleaseDC (NULL, hdcScreen);
 934     GlobalFree (lpBitmapInfo);
 935     FreeResource (hglb);
 936
 937     return hbm;
 938 }
 939
 940
 941 /***********************************************************************
 942  * CreateToolbar [COMCTL32.7]
 943  *
 944  * Creates a toolbar control.
 945  *
 946  * PARAMS
 947  *     hwnd
 948  *     style
 949  *     wID
 950  *     nBitmaps
 951  *     hBMInst
 952  *     wBMID
 953  *     lpButtons
 954  *     iNumButtons
 955  *
 956  * RETURNS
 957  *     Success: handle to the tool bar control
 958  *     Failure: 0
 959  *
 960  * NOTES
 961  *     Do not use this functions anymore. Use CreateToolbarEx instead.
 962  */
 963
 964 HWND WINAPI
 965 CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
 966                HINSTANCE hBMInst, UINT wBMID,
 967                LPCTBBUTTON lpButtons,INT iNumButtons)
 968 {
 969     return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
 970                             hBMInst, wBMID, lpButtons,
 971                             iNumButtons, 0, 0, 0, 0, CCSIZEOF_STRUCT(TBBUTTON, dwData));
 972 }
 973
 974
 975 /***********************************************************************
 976  * DllGetVersion [COMCTL32.@]
 977  *
 978  * Retrieves version information of the 'COMCTL32.DLL'
 979  *
 980  * PARAMS
 981  *     pdvi [O] pointer to version information structure.
 982  *
 983  * RETURNS
 984  *     Success: S_OK
 985  *     Failure: E_INVALIDARG
 986  *
 987  * NOTES
 988  *     Returns version of a comctl32.dll from IE4.01 SP1.
 989  */
 990
 991 HRESULT WINAPI DllGetVersion (DLLVERSIONINFO *pdvi)
 992 {
 993     if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
 994         WARN("wrong DLLVERSIONINFO size from app\n");
 995         return E_INVALIDARG;
 996     }
 997
 998     pdvi->dwMajorVersion = COMCTL32_VERSION;
 999     pdvi->dwMinorVersion = COMCTL32_VERSION_MINOR;
1000     pdvi->dwBuildNumber = 2919;
1001     pdvi->dwPlatformID = 6304;
1002
1003     TRACE("%u.%u.%u.%u\n",
1004            pdvi->dwMajorVersion, pdvi->dwMinorVersion,
1005            pdvi->dwBuildNumber, pdvi->dwPlatformID);
1006
1007     return S_OK;
1008 }
1009
1010 /***********************************************************************
1011  *              DllInstall (COMCTL32.@)
1012  *
1013  * Installs the ComCtl32 DLL.
1014  *
1015  * RETURNS
1016  *     Success: S_OK
1017  *     Failure: A HRESULT error
1018  */
1019 HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
1020 {
1021     TRACE("(%u, %s): stub\n", bInstall, debugstr_w(cmdline));
1022     if (!create_manifest( bInstall )) return HRESULT_FROM_WIN32(GetLastError());
1023     return S_OK;
1024 }
1025
1026 /***********************************************************************
1027  * _TrackMouseEvent [COMCTL32.@]
1028  *
1029  * Requests notification of mouse events
1030  *
1031  * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
1032  * to the hwnd specified in the ptme structure.  After the event message
1033  * is posted to the hwnd, the entry in the queue is removed.
1034  *
1035  * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
1036  * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
1037  * immediately and the TME_LEAVE flag being ignored.
1038  *
1039  * PARAMS
1040  *     ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
1041  *
1042  * RETURNS
1043  *     Success: non-zero
1044  *     Failure: zero
1045  *
1046  * IMPLEMENTATION moved to USER32.TrackMouseEvent
1047  *
1048  */
1049
1050 BOOL WINAPI
1051 _TrackMouseEvent (TRACKMOUSEEVENT *ptme)
1052 {
1053     return TrackMouseEvent (ptme);
1054 }
1055
1056 /*************************************************************************
1057  * GetMUILanguage [COMCTL32.@]
1058  *
1059  * Returns the user interface language in use by the current process.
1060  *
1061  * RETURNS
1062  *      Language ID in use by the current process.
1063  */
1064 LANGID WINAPI GetMUILanguage (VOID)
1065 {
1066     return COMCTL32_uiLang;
1067 }
1068
1069
1070 /*************************************************************************
1071  * InitMUILanguage [COMCTL32.@]
1072  *
1073  * Sets the user interface language to be used by the current process.
1074  *
1075  * RETURNS
1076  *      Nothing.
1077  */
1078 VOID WINAPI InitMUILanguage (LANGID uiLang)
1079 {
1080    COMCTL32_uiLang = uiLang;
1081 }
1082
1083
1084 /***********************************************************************
1085  * SetWindowSubclass [COMCTL32.410]
1086  *
1087  * Starts a window subclass
1088  *
1089  * PARAMS
1090  *     hWnd [in] handle to window subclass.
1091  *     pfnSubclass [in] Pointer to new window procedure.
1092  *     uIDSubclass [in] Unique identifier of sublass together with pfnSubclass.
1093  *     dwRef [in] Reference data to pass to window procedure.
1094  *
1095  * RETURNS
1096  *     Success: non-zero
1097  *     Failure: zero
1098  *
1099  * BUGS
1100  *     If an application manually subclasses a window after subclassing it with
1101  *     this API and then with this API again, then none of the previous
1102  *     subclasses get called or the original window procedure.
1103  */
1104
1105 BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1106                         UINT_PTR uIDSubclass, DWORD_PTR dwRef)
1107 {
1108    LPSUBCLASS_INFO stack;
1109    LPSUBCLASSPROCS proc;
1110
1111    TRACE ("(%p, %p, %lx, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
1112
1113    /* Since the window procedure that we set here has two additional arguments,
1114     * we can't simply set it as the new window procedure of the window. So we
1115     * set our own window procedure and then calculate the other two arguments
1116     * from there. */
1117
1118    /* See if we have been called for this window */
1119    stack = GetPropW (hWnd, COMCTL32_wSubclass);
1120    if (!stack) {
1121       /* allocate stack */
1122       stack = Alloc (sizeof(SUBCLASS_INFO));
1123       if (!stack) {
1124          ERR ("Failed to allocate our Subclassing stack\n");
1125          return FALSE;
1126       }
1127       SetPropW (hWnd, COMCTL32_wSubclass, stack);
1128
1129       /* set window procedure to our own and save the current one */
1130       if (IsWindowUnicode (hWnd))
1131          stack->origproc = (WNDPROC)SetWindowLongPtrW (hWnd, GWLP_WNDPROC,
1132                                                    (DWORD_PTR)COMCTL32_SubclassProc);
1133       else
1134          stack->origproc = (WNDPROC)SetWindowLongPtrA (hWnd, GWLP_WNDPROC,
1135                                                    (DWORD_PTR)COMCTL32_SubclassProc);
1136    }
1137    else {
1138       /* Check to see if we have called this function with the same uIDSubClass
1139        * and pfnSubclass */
1140       proc = stack->SubclassProcs;
1141       while (proc) {
1142          if ((proc->id == uIDSubclass) &&
1143             (proc->subproc == pfnSubclass)) {
1144             proc->ref = dwRef;
1145             return TRUE;
1146          }
1147          proc = proc->next;
1148       }
1149    }
1150
1151    proc = Alloc(sizeof(SUBCLASSPROCS));
1152    if (!proc) {
1153       ERR ("Failed to allocate subclass entry in stack\n");
1154       if (IsWindowUnicode (hWnd))
1155          SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1156       else
1157          SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1158       Free (stack);
1159       RemovePropW( hWnd, COMCTL32_wSubclass );
1160       return FALSE;
1161    }
1162
1163    proc->subproc = pfnSubclass;
1164    proc->ref = dwRef;
1165    proc->id = uIDSubclass;
1166    proc->next = stack->SubclassProcs;
1167    stack->SubclassProcs = proc;
1168
1169    return TRUE;
1170 }
1171
1172
1173 /***********************************************************************
1174  * GetWindowSubclass [COMCTL32.411]
1175  *
1176  * Gets the Reference data from a subclass.
1177  *
1178  * PARAMS
1179  *     hWnd [in] Handle to window which were subclassing
1180  *     pfnSubclass [in] Pointer to the subclass procedure
1181  *     uID [in] Unique indentifier of the subclassing procedure
1182  *     pdwRef [out] Pointer to the reference data
1183  *
1184  * RETURNS
1185  *     Success: Non-zero
1186  *     Failure: 0
1187  */
1188
1189 BOOL WINAPI GetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1190                               UINT_PTR uID, DWORD_PTR *pdwRef)
1191 {
1192    const SUBCLASS_INFO *stack;
1193    const SUBCLASSPROCS *proc;
1194
1195    TRACE ("(%p, %p, %lx, %p)\n", hWnd, pfnSubclass, uID, pdwRef);
1196
1197    /* See if we have been called for this window */
1198    stack = GetPropW (hWnd, COMCTL32_wSubclass);
1199    if (!stack)
1200       return FALSE;
1201
1202    proc = stack->SubclassProcs;
1203    while (proc) {
1204       if ((proc->id == uID) &&
1205          (proc->subproc == pfnSubclass)) {
1206          *pdwRef = proc->ref;
1207          return TRUE;
1208       }
1209       proc = proc->next;
1210    }
1211
1212    return FALSE;
1213 }
1214
1215
1216 /***********************************************************************
1217  * RemoveWindowSubclass [COMCTL32.412]
1218  *
1219  * Removes a window subclass.
1220  *
1221  * PARAMS
1222  *     hWnd [in] Handle to the window were subclassing
1223  *     pfnSubclass [in] Pointer to the subclass procedure
1224  *     uID [in] Unique identifier of this subclass
1225  *
1226  * RETURNS
1227  *     Success: non-zero
1228  *     Failure: zero
1229  */
1230
1231 BOOL WINAPI RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uID)
1232 {
1233    LPSUBCLASS_INFO stack;
1234    LPSUBCLASSPROCS prevproc = NULL;
1235    LPSUBCLASSPROCS proc;
1236    BOOL ret = FALSE;
1237
1238    TRACE ("(%p, %p, %lx)\n", hWnd, pfnSubclass, uID);
1239
1240    /* Find the Subclass to remove */
1241    stack = GetPropW (hWnd, COMCTL32_wSubclass);
1242    if (!stack)
1243       return FALSE;
1244
1245    proc = stack->SubclassProcs;
1246    while (proc) {
1247       if ((proc->id == uID) &&
1248          (proc->subproc == pfnSubclass)) {
1249
1250          if (!prevproc)
1251             stack->SubclassProcs = proc->next;
1252          else
1253             prevproc->next = proc->next;
1254
1255          if (stack->stackpos == proc)
1256             stack->stackpos = stack->stackpos->next;
1257
1258          Free (proc);
1259          ret = TRUE;
1260          break;
1261       }
1262       prevproc = proc;
1263       proc = proc->next;
1264    }
1265
1266    if (!stack->SubclassProcs && !stack->running) {
1267       TRACE("Last Subclass removed, cleaning up\n");
1268       /* clean up our heap and reset the original window procedure */
1269       if (IsWindowUnicode (hWnd))
1270          SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1271       else
1272          SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1273       Free (stack);
1274       RemovePropW( hWnd, COMCTL32_wSubclass );
1275    }
1276
1277    return ret;
1278 }
1279
1280 /***********************************************************************
1281  * COMCTL32_SubclassProc (internal)
1282  *
1283  * Window procedure for all subclassed windows.
1284  * Saves the current subclassing stack position to support nested messages
1285  */
1286 static LRESULT WINAPI COMCTL32_SubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1287 {
1288    LPSUBCLASS_INFO stack;
1289    LPSUBCLASSPROCS proc;
1290    LRESULT ret;
1291
1292    TRACE ("(%p, 0x%08x, 0x%08lx, 0x%08lx)\n", hWnd, uMsg, wParam, lParam);
1293
1294    stack = GetPropW (hWnd, COMCTL32_wSubclass);
1295    if (!stack) {
1296       ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
1297       return 0;
1298    }
1299
1300    /* Save our old stackpos to properly handle nested messages */
1301    proc = stack->stackpos;
1302    stack->stackpos = stack->SubclassProcs;
1303    stack->running++;
1304    ret = DefSubclassProc(hWnd, uMsg, wParam, lParam);
1305    stack->running--;
1306    stack->stackpos = proc;
1307
1308    if (!stack->SubclassProcs && !stack->running) {
1309       TRACE("Last Subclass removed, cleaning up\n");
1310       /* clean up our heap and reset the original window procedure */
1311       if (IsWindowUnicode (hWnd))
1312          SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1313       else
1314          SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1315       Free (stack);
1316       RemovePropW( hWnd, COMCTL32_wSubclass );
1317    }
1318    return ret;
1319 }
1320
1321 /***********************************************************************
1322  * DefSubclassProc [COMCTL32.413]
1323  *
1324  * Calls the next window procedure (ie. the one before this subclass)
1325  *
1326  * PARAMS
1327  *     hWnd [in] The window that we're subclassing
1328  *     uMsg [in] Message
1329  *     wParam [in] WPARAM
1330  *     lParam [in] LPARAM
1331  *
1332  * RETURNS
1333  *     Success: non-zero
1334  *     Failure: zero
1335  */
1336
1337 LRESULT WINAPI DefSubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1338 {
1339    LPSUBCLASS_INFO stack;
1340    LRESULT ret;
1341
1342    TRACE ("(%p, 0x%08x, 0x%08lx, 0x%08lx)\n", hWnd, uMsg, wParam, lParam);
1343
1344    /* retrieve our little stack from the Properties */
1345    stack = GetPropW (hWnd, COMCTL32_wSubclass);
1346    if (!stack) {
1347       ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
1348       return 0;
1349    }
1350
1351    /* If we are at the end of stack then we have to call the original
1352     * window procedure */
1353    if (!stack->stackpos) {
1354       if (IsWindowUnicode (hWnd))
1355          ret = CallWindowProcW (stack->origproc, hWnd, uMsg, wParam, lParam);
1356       else
1357          ret = CallWindowProcA (stack->origproc, hWnd, uMsg, wParam, lParam);
1358    } else {
1359       const SUBCLASSPROCS *proc = stack->stackpos;
1360       stack->stackpos = stack->stackpos->next;
1361       /* call the Subclass procedure from the stack */
1362       ret = proc->subproc (hWnd, uMsg, wParam, lParam,
1363             proc->id, proc->ref);
1364    }
1365
1366    return ret;
1367 }
1368
1369
1370 /***********************************************************************
1371  * COMCTL32_CreateToolTip [NOT AN API]
1372  *
1373  * Creates a tooltip for the control specified in hwnd and does all
1374  * necessary setup and notifications.
1375  *
1376  * PARAMS
1377  *     hwndOwner [I] Handle to the window that will own the tool tip.
1378  *
1379  * RETURNS
1380  *     Success: Handle of tool tip window.
1381  *     Failure: NULL
1382  */
1383
1384 HWND
1385 COMCTL32_CreateToolTip(HWND hwndOwner)
1386 {
1387     HWND hwndToolTip;
1388
1389     hwndToolTip = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
1390                                   CW_USEDEFAULT, CW_USEDEFAULT,
1391                                   CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
1392                                   0, 0, 0);
1393
1394     /* Send NM_TOOLTIPSCREATED notification */
1395     if (hwndToolTip)
1396     {
1397         NMTOOLTIPSCREATED nmttc;
1398         /* true owner can be different if hwndOwner is a child window */
1399         HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER);
1400         nmttc.hdr.hwndFrom = hwndTrueOwner;
1401         nmttc.hdr.idFrom = GetWindowLongPtrW(hwndTrueOwner, GWLP_ID);
1402         nmttc.hdr.code = NM_TOOLTIPSCREATED;
1403         nmttc.hwndToolTips = hwndToolTip;
1404
1405         SendMessageW(GetParent(hwndTrueOwner), WM_NOTIFY,
1406                      GetWindowLongPtrW(hwndTrueOwner, GWLP_ID), (LPARAM)&nmttc);
1407     }
1408
1409     return hwndToolTip;
1410 }
1411
1412
1413 /***********************************************************************
1414  * COMCTL32_RefreshSysColors [NOT AN API]
1415  *
1416  * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to
1417  * refresh the color values in the color structure
1418  *
1419  * PARAMS
1420  *     none
1421  *
1422  * RETURNS
1423  *     none
1424  */
1425
1426 VOID
1427 COMCTL32_RefreshSysColors(void)
1428 {
1429     comctl32_color.clrBtnHighlight = GetSysColor (COLOR_BTNHIGHLIGHT);
1430     comctl32_color.clrBtnShadow = GetSysColor (COLOR_BTNSHADOW);
1431     comctl32_color.clrBtnText = GetSysColor (COLOR_BTNTEXT);
1432     comctl32_color.clrBtnFace = GetSysColor (COLOR_BTNFACE);
1433     comctl32_color.clrHighlight = GetSysColor (COLOR_HIGHLIGHT);
1434     comctl32_color.clrHighlightText = GetSysColor (COLOR_HIGHLIGHTTEXT);
1435     comctl32_color.clrHotTrackingColor = GetSysColor (COLOR_HOTLIGHT);
1436     comctl32_color.clr3dHilight = GetSysColor (COLOR_3DHILIGHT);
1437     comctl32_color.clr3dShadow = GetSysColor (COLOR_3DSHADOW);
1438     comctl32_color.clr3dDkShadow = GetSysColor (COLOR_3DDKSHADOW);
1439     comctl32_color.clr3dFace = GetSysColor (COLOR_3DFACE);
1440     comctl32_color.clrWindow = GetSysColor (COLOR_WINDOW);
1441     comctl32_color.clrWindowText = GetSysColor (COLOR_WINDOWTEXT);
1442     comctl32_color.clrGrayText = GetSysColor (COLOR_GRAYTEXT);
1443     comctl32_color.clrActiveCaption = GetSysColor (COLOR_ACTIVECAPTION);
1444     comctl32_color.clrInfoBk = GetSysColor (COLOR_INFOBK);
1445     comctl32_color.clrInfoText = GetSysColor (COLOR_INFOTEXT);
1446 }
1447
1448 /***********************************************************************
1449  * COMCTL32_DrawInsertMark [NOT AN API]
1450  *
1451  * Draws an insertion mark (which looks similar to an 'I').
1452  *
1453  * PARAMS
1454  *     hDC           [I] Device context to draw onto.
1455  *     lpRect        [I] Co-ordinates of insertion mark.
1456  *     clrInsertMark [I] Colour of the insertion mark.
1457  *     bHorizontal   [I] True if insert mark should be drawn horizontally,
1458  *                       vertical otherwise.
1459  *
1460  * RETURNS
1461  *     none
1462  *
1463  * NOTES
1464  *     Draws up to but not including the bottom co-ordinate when drawing
1465  *     vertically or the right co-ordinate when horizontal.
1466  */
1467 void COMCTL32_DrawInsertMark(HDC hDC, const RECT *lpRect, COLORREF clrInsertMark, BOOL bHorizontal)
1468 {
1469     HPEN hPen = CreatePen(PS_SOLID, 1, clrInsertMark);
1470     HPEN hOldPen;
1471     static const DWORD adwPolyPoints[] = {4,4,4};
1472     LONG lCentre = (bHorizontal ?
1473         lpRect->top + (lpRect->bottom - lpRect->top)/2 :
1474         lpRect->left + (lpRect->right - lpRect->left)/2);
1475     LONG l1 = (bHorizontal ? lpRect->left : lpRect->top);
1476     LONG l2 = (bHorizontal ? lpRect->right : lpRect->bottom);
1477     const POINT aptInsertMark[] =
1478     {
1479         /* top (V) or left (H) arrow */
1480         {lCentre    , l1 + 2},
1481         {lCentre - 2, l1    },
1482         {lCentre + 3, l1    },
1483         {lCentre + 1, l1 + 2},
1484         /* middle line */
1485         {lCentre    , l2 - 2},
1486         {lCentre    , l1 - 1},
1487         {lCentre + 1, l1 - 1},
1488         {lCentre + 1, l2 - 2},
1489         /* bottom (V) or right (H) arrow */
1490         {lCentre    , l2 - 3},
1491         {lCentre - 2, l2 - 1},
1492         {lCentre + 3, l2 - 1},
1493         {lCentre + 1, l2 - 3},
1494     };
1495     hOldPen = SelectObject(hDC, hPen);
1496     PolyPolyline(hDC, aptInsertMark, adwPolyPoints, sizeof(adwPolyPoints)/sizeof(adwPolyPoints[0]));
1497     SelectObject(hDC, hOldPen);
1498     DeleteObject(hPen);
1499 }
1500
1501 /***********************************************************************
1502  * COMCTL32_EnsureBitmapSize [internal]
1503  *
1504  * If needed, enlarge the bitmap so that the width is at least cxMinWidth and
1505  * the height is at least cyMinHeight. If the bitmap already has these
1506  * dimensions nothing changes.
1507  *
1508  * PARAMS
1509  *     hBitmap       [I/O] Bitmap to modify. The handle may change
1510  *     cxMinWidth    [I]   If the width of the bitmap is smaller, then it will
1511  *                         be enlarged to this value
1512  *     cyMinHeight   [I]   If the height of the bitmap is smaller, then it will
1513  *                         be enlarged to this value
1514  *     cyBackground  [I]   The color with which the new area will be filled
1515  *
1516  * RETURNS
1517  *     none
1518  */
1519 void COMCTL32_EnsureBitmapSize(HBITMAP *pBitmap, int cxMinWidth, int cyMinHeight, COLORREF crBackground)
1520 {
1521     int cxNew, cyNew;
1522     BITMAP bmp;
1523     HBITMAP hNewBitmap;
1524     HBITMAP hNewDCBitmap, hOldDCBitmap;
1525     HBRUSH hNewDCBrush;
1526     HDC hdcNew, hdcOld;
1527
1528     if (!GetObjectW(*pBitmap, sizeof(BITMAP), &bmp))
1529         return;
1530     cxNew = (cxMinWidth > bmp.bmWidth ? cxMinWidth : bmp.bmWidth);
1531     cyNew = (cyMinHeight > bmp.bmHeight ? cyMinHeight : bmp.bmHeight);
1532     if (cxNew == bmp.bmWidth && cyNew == bmp.bmHeight)
1533         return;
1534
1535     hdcNew = CreateCompatibleDC(NULL);
1536     hNewBitmap = CreateBitmap(cxNew, cyNew, bmp.bmPlanes, bmp.bmBitsPixel, NULL);
1537     hNewDCBitmap = SelectObject(hdcNew, hNewBitmap);
1538     hNewDCBrush = SelectObject(hdcNew, CreateSolidBrush(crBackground));
1539
1540     hdcOld = CreateCompatibleDC(NULL);
1541     hOldDCBitmap = SelectObject(hdcOld, *pBitmap);
1542
1543     BitBlt(hdcNew, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcOld, 0, 0, SRCCOPY);
1544     if (bmp.bmWidth < cxMinWidth)
1545         PatBlt(hdcNew, bmp.bmWidth, 0, cxNew, bmp.bmHeight, PATCOPY);
1546     if (bmp.bmHeight < cyMinHeight)
1547         PatBlt(hdcNew, 0, bmp.bmHeight, bmp.bmWidth, cyNew, PATCOPY);
1548     if (bmp.bmWidth < cxMinWidth && bmp.bmHeight < cyMinHeight)
1549         PatBlt(hdcNew, bmp.bmWidth, bmp.bmHeight, cxNew, cyNew, PATCOPY);
1550
1551     SelectObject(hdcNew, hNewDCBitmap);
1552     DeleteObject(SelectObject(hdcNew, hNewDCBrush));
1553     DeleteDC(hdcNew);
1554     SelectObject(hdcOld, hOldDCBitmap);
1555     DeleteDC(hdcOld);
1556
1557     DeleteObject(*pBitmap);
1558     *pBitmap = hNewBitmap;
1559     return;
1560 }
1561
1562 void COMCTL32_GetFontMetrics(HFONT hFont, TEXTMETRICW *ptm)
1563 {
1564     HDC hdc = GetDC(NULL);
1565     HFONT hOldFont;
1566
1567     hOldFont = SelectObject(hdc, hFont);
1568     GetTextMetricsW(hdc, ptm);
1569     SelectObject(hdc, hOldFont);
1570     ReleaseDC(NULL, hdc);
1571 }
1572
1573 #ifndef OCM__BASE      /* avoid including olectl.h */
1574 #define OCM__BASE (WM_USER+0x1c00)
1575 #endif
1576
1577 /***********************************************************************
1578  * COMCTL32_IsReflectedMessage [internal]
1579  *
1580  * Some parents reflect notify messages - for some messages sent by the child,
1581  * they send it back with the message code increased by OCM__BASE (0x2000).
1582  * This allows better subclassing of controls. We don't need to handle such
1583  * messages but we don't want to print ERRs for them, so this helper function
1584  * identifies them.
1585  *
1586  * Some of the codes are in the CCM_FIRST..CCM_LAST range, but there is no
1587  * colision with defined CCM_ codes.
1588  */
1589 BOOL COMCTL32_IsReflectedMessage(UINT uMsg)
1590 {
1591     switch (uMsg)
1592     {
1593         case OCM__BASE + WM_COMMAND:
1594         case OCM__BASE + WM_CTLCOLORBTN:
1595         case OCM__BASE + WM_CTLCOLOREDIT:
1596         case OCM__BASE + WM_CTLCOLORDLG:
1597         case OCM__BASE + WM_CTLCOLORLISTBOX:
1598         case OCM__BASE + WM_CTLCOLORMSGBOX:
1599         case OCM__BASE + WM_CTLCOLORSCROLLBAR:
1600         case OCM__BASE + WM_CTLCOLORSTATIC:
1601         case OCM__BASE + WM_DRAWITEM:
1602         case OCM__BASE + WM_MEASUREITEM:
1603         case OCM__BASE + WM_DELETEITEM:
1604         case OCM__BASE + WM_VKEYTOITEM:
1605         case OCM__BASE + WM_CHARTOITEM:
1606         case OCM__BASE + WM_COMPAREITEM:
1607         case OCM__BASE + WM_HSCROLL:
1608         case OCM__BASE + WM_VSCROLL:
1609         case OCM__BASE + WM_PARENTNOTIFY:
1610         case OCM__BASE + WM_NOTIFY:
1611             return TRUE;
1612         default:
1613             return FALSE;
1614     }
1615 }
1616
1617 /***********************************************************************
1618  * MirrorIcon [COMCTL32.414]
1619  *
1620  * Mirrors an icon so that it will appear correctly on a mirrored DC.
1621  *
1622  * PARAMS
1623  *     phicon1 [I/O] Icon.
1624  *     phicon2 [I/O] Icon.
1625  *
1626  * RETURNS
1627  *     Success: TRUE.
1628  *     Failure: FALSE.
1629  */
1630 BOOL WINAPI MirrorIcon(HICON *phicon1, HICON *phicon2)
1631 {
1632     FIXME("(%p, %p): stub\n", phicon1, phicon2);
1633     return FALSE;
1634 }
1635
1636 static inline int IsDelimiter(WCHAR c)
1637 {
1638     switch(c)
1639     {
1640         case '/':
1641         case '\\':
1642         case '.':
1643         case ' ':
1644             return TRUE;
1645     }
1646     return FALSE;
1647 }
1648
1649 static int CALLBACK PathWordBreakProc(LPCWSTR lpch, int ichCurrent, int cch, int code)
1650 {
1651     if (code == WB_ISDELIMITER)
1652         return IsDelimiter(lpch[ichCurrent]);
1653     else
1654     {
1655         int dir = (code == WB_LEFT) ? -1 : 1;
1656         for(; 0 <= ichCurrent && ichCurrent < cch; ichCurrent += dir)
1657             if (IsDelimiter(lpch[ichCurrent])) return ichCurrent;
1658     }
1659     return ichCurrent;
1660 }
1661
1662 /***********************************************************************
1663  * SetPathWordBreakProc [COMCTL32.384]
1664  *
1665  * Sets the word break procedure for an edit control to one that understands
1666  * paths so that the user can jump over directories.
1667  *
1668  * PARAMS
1669  *     hwnd [I] Handle to edit control.
1670  *     bSet [I] If this is TRUE then the word break proc is set, otherwise it is removed.
1671  *
1672  * RETURNS
1673  *     Result from EM_SETWORDBREAKPROC message.
1674  */
1675 LRESULT WINAPI SetPathWordBreakProc(HWND hwnd, BOOL bSet)
1676 {
1677     return SendMessageW(hwnd, EM_SETWORDBREAKPROC, 0,
1678         (LPARAM)(bSet ? PathWordBreakProc : NULL));
1679 }
1680
1681 /***********************************************************************
1682  * DrawShadowText [COMCTL32.@]
1683  *
1684  * Draw text with shadow.
1685  */
1686 int WINAPI DrawShadowText(HDC hdc, LPCWSTR pszText, UINT cch, RECT *rect, DWORD dwFlags,
1687                           COLORREF crText, COLORREF crShadow, int ixOffset, int iyOffset)
1688 {
1689     FIXME("(%p, %s, %d, %p, %d, 0x%08x, 0x%08x, %d, %d): stub\n", hdc, debugstr_w(pszText), cch, rect, dwFlags,
1690                                                                   crText, crShadow, ixOffset, iyOffset);
1691     return DrawTextW(hdc, pszText, cch, rect, DT_LEFT);
1692 }