sdk/include/reactos/rosctrls.h

   1
   2 #pragma once
   3
   4 class CListView: public CWindow
   5 {
   6 public:
   7
   8     HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0,
   9                     DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
  10     {
  11         m_hWnd = ::CreateWindowEx(dwExStyle,
  12                                   WC_LISTVIEW,
  13                                   szWindowName,
  14                                   dwStyle,
  15                                   rect.m_lpRect->left,
  16                                   rect.m_lpRect->top,
  17                                   rect.m_lpRect->right - rect.m_lpRect->left,
  18                                   rect.m_lpRect->bottom - rect.m_lpRect->top,
  19                                   hWndParent,
  20                                   MenuOrID.m_hMenu,
  21                                   _AtlBaseModule.GetModuleInstance(),
  22                                   lpCreateParam);
  23
  24         return m_hWnd;
  25     }
  26
  27     void SetRedraw(BOOL redraw)
  28     {
  29         SendMessage(WM_SETREDRAW, redraw);
  30     }
  31
  32     BOOL SetTextBkColor(COLORREF cr)
  33     {
  34         return (BOOL)SendMessage(LVM_SETTEXTBKCOLOR, 0, cr);
  35     }
  36
  37     BOOL SetBkColor(COLORREF cr)
  38     {
  39         return (BOOL)SendMessage(LVM_SETBKCOLOR, 0, cr);
  40     }
  41
  42     BOOL SetTextColor(COLORREF cr)
  43     {
  44         return (BOOL)SendMessage(LVM_SETTEXTCOLOR, 0, cr);
  45     }
  46
  47     DWORD SetExtendedListViewStyle(DWORD dw, DWORD dwMask = 0)
  48     {
  49         return (DWORD)SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, dwMask, dw);
  50     }
  51
  52     int InsertColumn(int iCol, LV_COLUMN* pcol)
  53     {
  54         return (int)SendMessage(LVM_INSERTCOLUMN, iCol, reinterpret_cast<LPARAM>(pcol));
  55     }
  56
  57     int InsertColumn(int iCol, LPWSTR pszText, int fmt, int width = -1, int iSubItem = -1, int iImage = -1, int iOrder = -1)
  58     {
  59         LV_COLUMN column = {0};
  60         column.mask = LVCF_TEXT|LVCF_FMT;
  61         column.pszText = pszText;
  62         column.fmt = fmt;
  63         if(width != -1)
  64         {
  65             column.mask |= LVCF_WIDTH;
  66             column.cx = width;
  67         }
  68         if(iSubItem != -1)
  69         {
  70             column.mask |= LVCF_SUBITEM;
  71             column.iSubItem = iSubItem;
  72         }
  73         if(iImage != -1)
  74         {
  75             column.mask |= LVCF_IMAGE;
  76             column.iImage = iImage;
  77         }
  78         if(iOrder != -1)
  79         {
  80             column.mask |= LVCF_ORDER;
  81             column.iOrder = iOrder;
  82         }
  83         return InsertColumn(iCol, &column);
  84     }
  85
  86     int GetColumnWidth(int iCol)
  87     {
  88         return (int)SendMessage(LVM_GETCOLUMNWIDTH, iCol);
  89     }
  90
  91     HIMAGELIST SetImageList(HIMAGELIST himl, int iImageList)
  92     {
  93         return (HIMAGELIST)SendMessage(LVM_SETIMAGELIST, iImageList, reinterpret_cast<LPARAM>(himl));
  94     }
  95
  96     int InsertItem(const LV_ITEM * pitem)
  97     {
  98         return (int)SendMessage(LVM_INSERTITEM, 0, reinterpret_cast<LPARAM>(pitem));
  99     }
 100
 101     BOOL DeleteItem(int i)
 102     {
 103         return (BOOL)SendMessage(LVM_DELETEITEM, i, 0);
 104     }
 105
 106     BOOL GetItem(LV_ITEM* pitem)
 107     {
 108         return (BOOL)SendMessage(LVM_GETITEM, 0, reinterpret_cast<LPARAM>(pitem));
 109     }
 110
 111     BOOL SetItem(const LV_ITEM * pitem)
 112     {
 113         return (BOOL)SendMessage(LVM_SETITEM, 0, reinterpret_cast<LPARAM>(pitem));
 114     }
 115
 116     BOOL FindItem(int iStart, const LV_FINDINFO * plvfi)
 117     {
 118         return (BOOL)SendMessage(LVM_FINDITEM, iStart, (LPARAM) plvfi);
 119     }
 120
 121     int GetItemCount()
 122     {
 123         return SendMessage(LVM_GETITEMCOUNT);
 124     }
 125
 126     BOOL DeleteAllItems()
 127     {
 128         return (BOOL)SendMessage(LVM_DELETEALLITEMS);
 129     }
 130
 131     BOOL Update(int i)
 132     {
 133         return (BOOL)SendMessage(LVM_UPDATE, i, 0);
 134     }
 135
 136     UINT GetSelectedCount()
 137     {
 138         return (UINT)SendMessage(LVM_GETSELECTEDCOUNT);
 139     }
 140
 141     BOOL SortItems(PFNLVCOMPARE pfnCompare, PVOID lParam)
 142     {
 143         return (BOOL)SendMessage(LVM_SORTITEMS, (WPARAM)lParam, (LPARAM) pfnCompare);
 144     }
 145
 146     BOOL EnsureVisible(int i, BOOL fPartialOK)
 147     {
 148         return (BOOL)SendMessage(LVM_ENSUREVISIBLE, i, MAKELPARAM((fPartialOK),0));
 149     }
 150
 151     HWND EditLabel(int i)
 152     {
 153         return (HWND)SendMessage(LVM_EDITLABEL, i, 0);
 154     }
 155
 156     int GetSelectionMark()
 157     {
 158         return (int)SendMessage(LVM_GETSELECTIONMARK);
 159     }
 160
 161     int GetNextItem(int i, WORD flags)
 162     {
 163         return (int)SendMessage(LVM_GETNEXTITEM, i, MAKELPARAM((flags),0));
 164     }
 165
 166     void GetItemSpacing(SIZE& spacing, BOOL bSmallIconView = FALSE)
 167     {
 168         DWORD ret = SendMessage(LVM_GETITEMSPACING, bSmallIconView);
 169         spacing.cx = LOWORD(ret);
 170         spacing.cy = HIWORD(ret);
 171     }
 172
 173     UINT GetItemState(int i, UINT mask)
 174     {
 175         return SendMessage(LVM_GETITEMSTATE, i, (LPARAM)mask);
 176     }
 177
 178     void SetItemState(int i, UINT state, UINT mask)
 179     {
 180         LV_ITEM item;
 181         item.stateMask = mask;
 182         item.state = state;
 183         SendMessage(LVM_SETITEMSTATE, i, reinterpret_cast<LPARAM>(&item));
 184     }
 185
 186     int HitTest(LV_HITTESTINFO * phtInfo)
 187     {
 188         return (int)SendMessage(LVM_HITTEST, 0, reinterpret_cast<LPARAM>(phtInfo));
 189     }
 190
 191     DWORD_PTR GetItemData(int i)
 192     {
 193         LVITEMW lvItem = { 0 };
 194         lvItem.mask = LVIF_PARAM;
 195         lvItem.iItem = i;
 196         BOOL ret = GetItem(&lvItem);
 197         return (DWORD_PTR)(ret ? lvItem.lParam : NULL);
 198     }
 199
 200     BOOL GetSelectedItem(LV_ITEM* pItem)
 201     {
 202         pItem->iItem = GetNextItem(-1, LVNI_ALL | LVNI_SELECTED);
 203         if (pItem->iItem == -1)
 204             return FALSE;
 205         return GetItem(pItem);
 206     }
 207
 208     void GetItemText(int iItem, int iSubItem, LPTSTR pszText, int cchTextMax)
 209     {
 210         LV_ITEM itemInfo;
 211         itemInfo.iSubItem = iSubItem;
 212         itemInfo.pszText = pszText;
 213         itemInfo.cchTextMax = cchTextMax;
 214
 215         SendMessage(LVM_GETITEMTEXT, iItem, (LPARAM) &itemInfo);
 216     }
 217
 218     BOOL GetItemPosition(int nItem, POINT* pPoint)
 219     {
 220         return (BOOL)SendMessage(LVM_GETITEMPOSITION, nItem, (LPARAM)pPoint);
 221     }
 222
 223     BOOL SetItemPosition(int nItem, POINT* pPoint)
 224     {
 225         return (BOOL)SendMessage(LVM_SETITEMPOSITION, nItem, MAKELPARAM(pPoint->x, pPoint->y));
 226     }
 227
 228     BOOL Arrange(UINT nCode)
 229     {
 230         return (BOOL)SendMessage(LVM_ARRANGE, nCode, 0);
 231     }
 232
 233 };
 234
 235 template<typename TItemData = DWORD_PTR>
 236 class CToolbar :
 237     public CWindow
 238 {
 239 public: // Configuration methods
 240
 241     HWND Create(HWND hWndParent, DWORD dwStyles = 0, DWORD dwExStyles = 0)
 242     {
 243         if (!dwStyles)
 244         {
 245             dwStyles = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN;
 246         }
 247
 248         if (!dwExStyles)
 249         {
 250             dwExStyles = WS_EX_TOOLWINDOW;
 251         }
 252
 253         m_hWnd = CreateWindowExW(dwExStyles,
 254                                 TOOLBARCLASSNAME,
 255                                 NULL,
 256                                 dwStyles,
 257                                 0, 0, 0, 0, hWndParent,
 258                                 NULL,
 259                                 _AtlBaseModule.GetModuleInstance(),
 260                                 NULL);
 261
 262         if (!m_hWnd)
 263             return NULL;
 264
 265         /* Identify the version we're using */
 266         SetButtonStructSize();
 267
 268         return m_hWnd;
 269     }
 270
 271     DWORD SetButtonStructSize()
 272     {
 273         return SendMessageW(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 274     }
 275
 276     HWND GetTooltip()
 277     {
 278         return (HWND)SendMessageW(TB_GETTOOLTIPS);
 279     }
 280
 281     DWORD SetTooltip(HWND hWndTooltip)
 282     {
 283         return SendMessageW(TB_SETTOOLTIPS, hWndTooltip, 0);
 284     }
 285
 286     INT GetHotItem()
 287     {
 288         return SendMessageW(TB_GETHOTITEM);
 289     }
 290
 291     DWORD SetHotItem(INT item)
 292     {
 293         return SendMessageW(TB_SETHOTITEM, item);
 294     }
 295
 296 public: // Button list management methods
 297     int GetButtonCount()
 298     {
 299         return SendMessageW(TB_BUTTONCOUNT);
 300     }
 301
 302     DWORD GetButton(int index, TBBUTTON * btn)
 303     {
 304         return SendMessageW(TB_GETBUTTON, index, reinterpret_cast<LPARAM>(btn));
 305     }
 306
 307     DWORD AddButton(TBBUTTON * btn)
 308     {
 309         return SendMessageW(TB_ADDBUTTONS, 1, reinterpret_cast<LPARAM>(btn));
 310     }
 311
 312     DWORD AddButtons(int count, TBBUTTON * buttons)
 313     {
 314         return SendMessageW(TB_ADDBUTTONS, count, reinterpret_cast<LPARAM>(buttons));
 315     }
 316
 317     DWORD InsertButton(int insertAt, TBBUTTON * btn)
 318     {
 319         return SendMessageW(TB_INSERTBUTTON, insertAt, reinterpret_cast<LPARAM>(btn));
 320     }
 321
 322     DWORD MoveButton(int oldIndex, int newIndex)
 323     {
 324         return SendMessageW(TB_MOVEBUTTON, oldIndex, newIndex);
 325     }
 326
 327     DWORD DeleteButton(int index)
 328     {
 329         return SendMessageW(TB_DELETEBUTTON, index, 0);
 330     }
 331
 332     DWORD GetButtonInfo(int cmdId, TBBUTTONINFO * info)
 333     {
 334         return SendMessageW(TB_GETBUTTONINFO, cmdId, reinterpret_cast<LPARAM>(info));
 335     }
 336
 337     DWORD SetButtonInfo(int cmdId, TBBUTTONINFO * info)
 338     {
 339         return SendMessageW(TB_SETBUTTONINFO, cmdId, reinterpret_cast<LPARAM>(info));
 340     }
 341
 342     DWORD CheckButton(int cmdId, BOOL bCheck)
 343     {
 344         return SendMessageW(TB_CHECKBUTTON, cmdId, MAKELPARAM(bCheck, 0));
 345     }
 346
 347 public: // Layout management methods
 348     DWORD GetButtonSize()
 349     {
 350         return SendMessageW(TB_GETBUTTONSIZE);
 351     }
 352
 353     DWORD SetButtonSize(int w, int h)
 354     {
 355         return SendMessageW(TB_SETBUTTONSIZE, 0, MAKELPARAM(w, h));
 356     }
 357
 358     DWORD AutoSize()
 359     {
 360         return SendMessageW(TB_AUTOSIZE);
 361     }
 362
 363     DWORD GetMaxSize(LPSIZE size)
 364     {
 365         return SendMessageW(TB_GETMAXSIZE, 0, reinterpret_cast<LPARAM>(size));
 366     }
 367
 368     DWORD GetIdealSize(BOOL useHeight, LPSIZE size)
 369     {
 370         return SendMessageW(TB_GETIDEALSIZE, useHeight, reinterpret_cast<LPARAM>(size));
 371     }
 372
 373     DWORD GetMetrics(TBMETRICS * tbm)
 374     {
 375         return SendMessageW(TB_GETMETRICS, 0, reinterpret_cast<LPARAM>(tbm));
 376     }
 377
 378     DWORD SetMetrics(TBMETRICS * tbm)
 379     {
 380         return SendMessageW(TB_SETMETRICS, 0, reinterpret_cast<LPARAM>(tbm));
 381     }
 382
 383     DWORD GetItemRect(int index, LPRECT prcItem)
 384     {
 385         return SendMessageW(TB_GETITEMRECT, index, reinterpret_cast<LPARAM>(prcItem));
 386     }
 387
 388     DWORD SetRedraw(BOOL bEnable)
 389     {
 390         return SendMessageW(WM_SETREDRAW, bEnable);
 391     }
 392
 393     DWORD GetPadding()
 394     {
 395         return SendMessageW(TB_GETPADDING);
 396     }
 397
 398     DWORD SetPadding(int x, int y)
 399     {
 400         return SendMessageW(TB_SETPADDING, 0, MAKELPARAM(x, y));
 401     }
 402
 403 public: // Image list management methods
 404     HIMAGELIST SetImageList(HIMAGELIST himl)
 405     {
 406         return (HIMAGELIST)SendMessageW(TB_SETIMAGELIST, 0, reinterpret_cast<LPARAM>(himl));
 407     }
 408
 409 public: // Other methods
 410     INT HitTest(PPOINT ppt)
 411     {
 412         return (INT) SendMessageW(TB_HITTEST, 0, reinterpret_cast<LPARAM>(ppt));
 413     }
 414
 415 public: // Utility methods
 416     TItemData * GetItemData(int index)
 417     {
 418         TBBUTTON btn;
 419         GetButton(index, &btn);
 420         return (TItemData*) btn.dwData;
 421     }
 422
 423     DWORD SetItemData(int index, TItemData * data)
 424     {
 425         TBBUTTONINFOW info = { 0 };
 426         info.cbSize = sizeof(info);
 427         info.dwMask = TBIF_BYINDEX | TBIF_LPARAM;
 428         info.lParam = (DWORD_PTR) data;
 429         return SetButtonInfo(index, &info);
 430     }
 431 };
 432
 433 class CStatusBar :
 434     public CWindow
 435 {
 436 public:
 437     VOID SetText(LPCWSTR lpszText)
 438     {
 439         SendMessage(SB_SETTEXT, SBT_NOBORDERS, (LPARAM) lpszText);
 440     }
 441
 442     HWND Create(HWND hwndParent, HMENU hMenu)
 443     {
 444         m_hWnd = CreateWindowExW(0,
 445             STATUSCLASSNAMEW,
 446             NULL,
 447             WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
 448             0, 0, 0, 0,
 449             hwndParent,
 450             hMenu,
 451             _AtlBaseModule.GetModuleInstance(),
 452             NULL);
 453
 454         return m_hWnd;
 455     }
 456
 457 };
 458
 459 class CTreeView :
 460     public CWindow
 461 {
 462 public:
 463     HWND Create(HWND hwndParent)
 464     {
 465         m_hWnd = CreateWindowExW(WS_EX_CLIENTEDGE,
 466             WC_TREEVIEWW,
 467             L"",
 468             WS_CHILD | WS_VISIBLE | TVS_HASLINES | TVS_SHOWSELALWAYS,
 469             0, 28, 200, 350,
 470             hwndParent,
 471             NULL,
 472             _AtlBaseModule.GetModuleInstance(),
 473             NULL);
 474
 475         return m_hWnd;
 476     }
 477
 478     HTREEITEM AddItem(HTREEITEM hParent, LPWSTR lpText, INT Image, INT SelectedImage, LPARAM lParam)
 479     {
 480         TVINSERTSTRUCTW Insert;
 481
 482         ZeroMemory(&Insert, sizeof(TV_INSERTSTRUCT));
 483
 484         Insert.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
 485         Insert.hInsertAfter = TVI_LAST;
 486         Insert.hParent = hParent;
 487         Insert.item.iSelectedImage = SelectedImage;
 488         Insert.item.iImage = Image;
 489         Insert.item.lParam = lParam;
 490         Insert.item.pszText = lpText;
 491
 492         return InsertItem(&Insert);
 493     }
 494
 495     void SetRedraw(BOOL redraw)
 496     {
 497         SendMessage(WM_SETREDRAW, redraw);
 498     }
 499
 500     BOOL SetBkColor(COLORREF cr)
 501     {
 502         return (BOOL) SendMessage(TVM_SETBKCOLOR, 0, cr);
 503     }
 504
 505     BOOL SetTextColor(COLORREF cr)
 506     {
 507         return (BOOL) SendMessage(TVM_SETTEXTCOLOR, 0, cr);
 508     }
 509
 510     HIMAGELIST SetImageList(HIMAGELIST himl, int iImageList)
 511     {
 512         return (HIMAGELIST) SendMessage(TVM_SETIMAGELIST, iImageList, reinterpret_cast<LPARAM>(himl));
 513     }
 514
 515     HTREEITEM InsertItem(const TVINSERTSTRUCTW * pitem)
 516     {
 517         return (HTREEITEM) SendMessage(TVM_INSERTITEM, 0, reinterpret_cast<LPARAM>(pitem));
 518     }
 519
 520     BOOL DeleteItem(HTREEITEM i)
 521     {
 522         return (BOOL) SendMessage(TVM_DELETEITEM, 0, (LPARAM)i);
 523     }
 524
 525     BOOL GetItem(TV_ITEM* pitem)
 526     {
 527         return (BOOL) SendMessage(TVM_GETITEM, 0, reinterpret_cast<LPARAM>(pitem));
 528     }
 529
 530     BOOL SetItem(const TV_ITEM * pitem)
 531     {
 532         return (BOOL) SendMessage(TVM_SETITEM, 0, reinterpret_cast<LPARAM>(pitem));
 533     }
 534
 535     int GetItemCount()
 536     {
 537         return SendMessage(TVM_GETCOUNT);
 538     }
 539
 540     BOOL EnsureVisible(HTREEITEM i)
 541     {
 542         return (BOOL) SendMessage(TVM_ENSUREVISIBLE, 0, (LPARAM)i);
 543     }
 544
 545     HWND EditLabel(HTREEITEM i)
 546     {
 547         return (HWND) SendMessage(TVM_EDITLABEL, 0, (LPARAM)i);
 548     }
 549
 550     HTREEITEM GetNextItem(HTREEITEM i, WORD flags)
 551     {
 552         return (HTREEITEM)SendMessage(TVM_GETNEXTITEM, flags, (LPARAM)i);
 553     }
 554
 555     UINT GetItemState(int i, UINT mask)
 556     {
 557         return SendMessage(TVM_GETITEMSTATE, i, (LPARAM) mask);
 558     }
 559
 560     HTREEITEM HitTest(TVHITTESTINFO * phtInfo)
 561     {
 562         return (HTREEITEM) SendMessage(TVM_HITTEST, 0, reinterpret_cast<LPARAM>(phtInfo));
 563     }
 564
 565     DWORD_PTR GetItemData(HTREEITEM item)
 566     {
 567         TVITEMW lvItem;
 568         lvItem.hItem = item;
 569         lvItem.mask = TVIF_PARAM;
 570         BOOL ret = GetItem(&lvItem);
 571         return (DWORD_PTR) (ret ? lvItem.lParam : NULL);
 572     }
 573
 574     HTREEITEM GetSelection()
 575     {
 576         return GetNextItem(NULL, TVGN_CARET);
 577     }
 578
 579     BOOL Expand(HTREEITEM item, DWORD action)
 580     {
 581         return SendMessage(TVM_EXPAND, action, (LPARAM)item);
 582     }
 583
 584     BOOL SelectItem(HTREEITEM item, DWORD action = TVGN_CARET)
 585     {
 586         return SendMessage(TVM_SELECTITEM, action, (LPARAM) item);
 587     }
 588
 589 };
 590
 591 class CTooltips :
 592     public CWindow
 593 {
 594 public: // Configuration methods
 595
 596     HWND Create(HWND hWndParent, DWORD dwStyles = WS_POPUP | TTS_NOPREFIX, DWORD dwExStyles = WS_EX_TOPMOST)
 597     {
 598         RECT r = { 0 };
 599         return CWindow::Create(TOOLTIPS_CLASS, hWndParent, r, L"", dwStyles, dwExStyles);
 600     }
 601
 602 public: // Relay event
 603
 604     // Win7+: Can use GetMessageExtraInfo to provide the WPARAM value.
 605     VOID RelayEvent(MSG * pMsg, WPARAM extraInfo = 0)
 606     {
 607         SendMessageW(TTM_RELAYEVENT, extraInfo, reinterpret_cast<LPARAM>(pMsg));
 608     }
 609
 610 public: // Helpers
 611
 612     INT GetToolCount()
 613     {
 614         return SendMessageW(TTM_GETTOOLCOUNT, 0, 0);
 615     }
 616
 617     BOOL AddTool(IN CONST TTTOOLINFOW * pInfo)
 618     {
 619         return SendMessageW(TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(pInfo));
 620     }
 621
 622     VOID DelTool(IN HWND hwndToolOwner, IN UINT uId)
 623     {
 624         TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
 625         info.hwnd = hwndToolOwner;
 626         info.uId = uId;
 627         SendMessageW(TTM_DELTOOL, 0, reinterpret_cast<LPARAM>(&info));
 628     }
 629
 630     VOID NewToolRect(IN HWND hwndToolOwner, IN UINT uId, IN RECT rect)
 631     {
 632         TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
 633         info.hwnd = hwndToolOwner;
 634         info.uId = uId;
 635         info.rect = rect;
 636         SendMessageW(TTM_NEWTOOLRECT, 0, reinterpret_cast<LPARAM>(&info));
 637     }
 638
 639     BOOL GetToolInfo(IN HWND hwndToolOwner, IN UINT uId, IN OUT TTTOOLINFOW * pInfo)
 640     {
 641         pInfo->hwnd = hwndToolOwner;
 642         pInfo->uId = uId;
 643         return SendMessageW(TTM_GETTOOLINFO, 0, reinterpret_cast<LPARAM>(pInfo));
 644     }
 645
 646     VOID SetToolInfo(IN CONST TTTOOLINFOW * pInfo)
 647     {
 648         SendMessageW(TTM_SETTOOLINFO, 0, reinterpret_cast<LPARAM>(pInfo));
 649     }
 650
 651     BOOL HitTest(IN CONST TTHITTESTINFOW * pInfo)
 652     {
 653         return SendMessageW(TTM_HITTEST, 0, reinterpret_cast<LPARAM>(pInfo));
 654     }
 655
 656     VOID GetText(IN HWND hwndToolOwner, IN UINT uId, OUT PWSTR pBuffer, IN DWORD cchBuffer)
 657     {
 658         TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
 659         info.hwnd = hwndToolOwner;
 660         info.uId = uId;
 661         info.lpszText = pBuffer;
 662         SendMessageW(TTM_GETTEXT, cchBuffer, reinterpret_cast<LPARAM>(&info));
 663     }
 664
 665     VOID UpdateTipText(IN HWND hwndToolOwner, IN UINT uId, IN PCWSTR szText, IN HINSTANCE hinstResourceOwner = NULL)
 666     {
 667         TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
 668         info.hwnd = hwndToolOwner;
 669         info.uId = uId;
 670         info.lpszText = const_cast<PWSTR>(szText);
 671         info.hinst = hinstResourceOwner;
 672         SendMessageW(TTM_UPDATETIPTEXT, 0, reinterpret_cast<LPARAM>(&info));
 673     }
 674
 675     BOOL EnumTools(IN CONST TTTOOLINFOW * pInfo)
 676     {
 677         return SendMessageW(TTM_ENUMTOOLS, 0, reinterpret_cast<LPARAM>(pInfo));
 678     }
 679
 680     BOOL GetCurrentTool(OUT OPTIONAL TTTOOLINFOW * pInfo = NULL)
 681     {
 682         return SendMessageW(TTM_GETCURRENTTOOL, 0, reinterpret_cast<LPARAM>(pInfo));
 683     }
 684
 685     VOID GetTitle(TTGETTITLE * pTitleInfo)
 686     {
 687         SendMessageW(TTM_GETTITLE, 0, reinterpret_cast<LPARAM>(pTitleInfo));
 688     }
 689
 690     BOOL SetTitle(PCWSTR szTitleText, WPARAM icon = 0)
 691     {
 692         return SendMessageW(TTM_SETTITLE, icon, reinterpret_cast<LPARAM>(szTitleText));
 693     }
 694
 695     VOID TrackActivate(IN HWND hwndToolOwner, IN UINT uId)
 696     {
 697         TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
 698         info.hwnd = hwndToolOwner;
 699         info.uId = uId;
 700         SendMessageW(TTM_TRACKACTIVATE, TRUE, reinterpret_cast<LPARAM>(&info));
 701     }
 702
 703     VOID TrackDeactivate()
 704     {
 705         SendMessageW(TTM_TRACKACTIVATE, FALSE, NULL);
 706     }
 707
 708     VOID TrackPosition(IN WORD x, IN WORD y)
 709     {
 710         SendMessageW(TTM_TRACKPOSITION, 0, MAKELPARAM(x, y));
 711     }
 712
 713     // Opens the tooltip
 714     VOID Popup()
 715     {
 716         SendMessageW(TTM_POPUP);
 717     }
 718
 719     // Closes the tooltip - Pressing the [X] for a TTF_CLOSE balloon is equivalent to calling this
 720     VOID Pop()
 721     {
 722         SendMessageW(TTM_POP);
 723     }
 724
 725     // Delay times for AUTOMATIC tooltips (they don't affect balloons)
 726     INT GetDelayTime(UINT which)
 727     {
 728         return SendMessageW(TTM_GETDELAYTIME, which);
 729     }
 730
 731     VOID SetDelayTime(UINT which, WORD time)
 732     {
 733         SendMessageW(TTM_SETDELAYTIME, which, MAKELPARAM(time, 0));
 734     }
 735
 736     // Activates or deactivates the automatic tooltip display when hovering a control
 737     VOID Activate(IN BOOL bActivate = TRUE)
 738     {
 739         SendMessageW(TTM_ACTIVATE, bActivate);
 740     }
 741
 742     // Adjusts the position of a tooltip when used to display trimmed text
 743     VOID AdjustRect(IN BOOL bTextToWindow, IN OUT RECT * pRect)
 744     {
 745         SendMessageW(TTM_ADJUSTRECT, bTextToWindow, reinterpret_cast<LPARAM>(pRect));
 746     }
 747
 748     // Useful for TTF_ABSOLUTE|TTF_TRACK tooltip positioning
 749     SIZE GetBubbleSize(IN TTTOOLINFOW * pInfo)
 750     {
 751         DWORD ret = SendMessageW(TTM_GETBUBBLESIZE, 0, reinterpret_cast<LPARAM>(pInfo));
 752         const SIZE sz = { LOWORD(ret), HIWORD(ret) };
 753         return sz;
 754     }
 755
 756     // Fills the RECT with the margin size previously set. Default is 0 margins.
 757     VOID GetMargin(OUT RECT * pRect)
 758     {
 759         SendMessageW(TTM_GETMARGIN, 0, reinterpret_cast<LPARAM>(pRect));
 760     }
 761
 762     VOID SetMargin(IN RECT * pRect)
 763     {
 764         SendMessageW(TTM_SETMARGIN, 0, reinterpret_cast<LPARAM>(pRect));
 765     }
 766
 767     // Gets a previously established max width. Returns -1 if no limit is set
 768     INT GetMaxTipWidth()
 769     {
 770         return SendMessageW(TTM_GETMAXTIPWIDTH);
 771     }
 772
 773     INT SetMaxTipWidth(IN OPTIONAL INT width = -1)
 774     {
 775         return SendMessageW(TTM_SETMAXTIPWIDTH, 0, width);
 776     }
 777
 778     // Get the color of the tooltip text
 779     COLORREF GetTipTextColor()
 780     {
 781         return SendMessageW(TTM_GETTIPTEXTCOLOR);
 782     }
 783
 784     VOID SetTipTextColor(IN COLORREF textColor)
 785     {
 786         SendMessageW(TTM_SETTIPTEXTCOLOR, textColor);
 787     }
 788
 789     COLORREF GetTipBkColor()
 790     {
 791         return SendMessageW(TTM_GETTIPBKCOLOR);
 792     }
 793
 794     VOID SetTipBkColor(IN COLORREF textColor)
 795     {
 796         SendMessageW(TTM_SETTIPBKCOLOR, textColor);
 797     }
 798
 799     VOID SetWindowTheme(IN PCWSTR szThemeName)
 800     {
 801         SendMessageW(TTM_SETWINDOWTHEME, 0, reinterpret_cast<LPARAM>(szThemeName));
 802     }
 803
 804     // Forces redraw
 805     VOID Update()
 806     {
 807         SendMessageW(TTM_UPDATE);
 808     }
 809
 810     HWND WindowFromPoint(IN POINT * pPoint)
 811     {
 812         return reinterpret_cast<HWND>(SendMessageW(TTM_WINDOWFROMPOINT, 0, reinterpret_cast<LPARAM>(pPoint)));
 813     }
 814 };