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