mirror of
https://github.com/reactos/reactos.git
synced 2024-06-29 17:31:31 +00:00
835 lines
21 KiB
C++
835 lines
21 KiB
C++
|
|
#pragma once
|
|
|
|
class CListView: public CWindow
|
|
{
|
|
public:
|
|
|
|
HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0,
|
|
DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
|
|
{
|
|
m_hWnd = ::CreateWindowEx(dwExStyle,
|
|
WC_LISTVIEW,
|
|
szWindowName,
|
|
dwStyle,
|
|
rect.m_lpRect->left,
|
|
rect.m_lpRect->top,
|
|
rect.m_lpRect->right - rect.m_lpRect->left,
|
|
rect.m_lpRect->bottom - rect.m_lpRect->top,
|
|
hWndParent,
|
|
MenuOrID.m_hMenu,
|
|
_AtlBaseModule.GetModuleInstance(),
|
|
lpCreateParam);
|
|
|
|
return m_hWnd;
|
|
}
|
|
|
|
void SetRedraw(BOOL redraw)
|
|
{
|
|
SendMessage(WM_SETREDRAW, redraw);
|
|
}
|
|
|
|
BOOL SetTextBkColor(COLORREF cr)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SETTEXTBKCOLOR, 0, cr);
|
|
}
|
|
|
|
BOOL SetBkColor(COLORREF cr)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SETBKCOLOR, 0, cr);
|
|
}
|
|
|
|
BOOL SetTextColor(COLORREF cr)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SETTEXTCOLOR, 0, cr);
|
|
}
|
|
|
|
DWORD SetExtendedListViewStyle(DWORD dw, DWORD dwMask = 0)
|
|
{
|
|
return (DWORD)SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, dwMask, dw);
|
|
}
|
|
|
|
int InsertColumn(int iCol, LV_COLUMN* pcol)
|
|
{
|
|
return (int)SendMessage(LVM_INSERTCOLUMN, iCol, reinterpret_cast<LPARAM>(pcol));
|
|
}
|
|
|
|
int InsertColumn(int iCol, LPWSTR pszText, int fmt, int width = -1, int iSubItem = -1, int iImage = -1, int iOrder = -1)
|
|
{
|
|
LV_COLUMN column = {0};
|
|
column.mask = LVCF_TEXT|LVCF_FMT;
|
|
column.pszText = pszText;
|
|
column.fmt = fmt;
|
|
if(width != -1)
|
|
{
|
|
column.mask |= LVCF_WIDTH;
|
|
column.cx = width;
|
|
}
|
|
if(iSubItem != -1)
|
|
{
|
|
column.mask |= LVCF_SUBITEM;
|
|
column.iSubItem = iSubItem;
|
|
}
|
|
if(iImage != -1)
|
|
{
|
|
column.mask |= LVCF_IMAGE;
|
|
column.iImage = iImage;
|
|
}
|
|
if(iOrder != -1)
|
|
{
|
|
column.mask |= LVCF_ORDER;
|
|
column.iOrder = iOrder;
|
|
}
|
|
return InsertColumn(iCol, &column);
|
|
}
|
|
|
|
int GetColumnWidth(int iCol)
|
|
{
|
|
return (int)SendMessage(LVM_GETCOLUMNWIDTH, iCol);
|
|
}
|
|
|
|
HIMAGELIST SetImageList(HIMAGELIST himl, int iImageList)
|
|
{
|
|
return (HIMAGELIST)SendMessage(LVM_SETIMAGELIST, iImageList, reinterpret_cast<LPARAM>(himl));
|
|
}
|
|
|
|
int InsertItem(const LV_ITEM * pitem)
|
|
{
|
|
return (int)SendMessage(LVM_INSERTITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
BOOL DeleteItem(int i)
|
|
{
|
|
return (BOOL)SendMessage(LVM_DELETEITEM, i, 0);
|
|
}
|
|
|
|
BOOL GetItem(LV_ITEM* pitem)
|
|
{
|
|
return (BOOL)SendMessage(LVM_GETITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
BOOL SetItem(const LV_ITEM * pitem)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SETITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
BOOL FindItem(int iStart, const LV_FINDINFO * plvfi)
|
|
{
|
|
return (BOOL)SendMessage(LVM_FINDITEM, iStart, (LPARAM) plvfi);
|
|
}
|
|
|
|
int GetItemCount()
|
|
{
|
|
return SendMessage(LVM_GETITEMCOUNT);
|
|
}
|
|
|
|
BOOL DeleteAllItems()
|
|
{
|
|
return (BOOL)SendMessage(LVM_DELETEALLITEMS);
|
|
}
|
|
|
|
BOOL Update(int i)
|
|
{
|
|
return (BOOL)SendMessage(LVM_UPDATE, i, 0);
|
|
}
|
|
|
|
UINT GetSelectedCount()
|
|
{
|
|
return (UINT)SendMessage(LVM_GETSELECTEDCOUNT);
|
|
}
|
|
|
|
BOOL SortItems(PFNLVCOMPARE pfnCompare, PVOID lParam)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SORTITEMS, (WPARAM)lParam, (LPARAM) pfnCompare);
|
|
}
|
|
|
|
BOOL EnsureVisible(int i, BOOL fPartialOK)
|
|
{
|
|
return (BOOL)SendMessage(LVM_ENSUREVISIBLE, i, MAKELPARAM((fPartialOK),0));
|
|
}
|
|
|
|
HWND EditLabel(int i)
|
|
{
|
|
return (HWND)SendMessage(LVM_EDITLABEL, i, 0);
|
|
}
|
|
|
|
int GetSelectionMark()
|
|
{
|
|
return (int)SendMessage(LVM_GETSELECTIONMARK);
|
|
}
|
|
|
|
int GetNextItem(int i, WORD flags)
|
|
{
|
|
return (int)SendMessage(LVM_GETNEXTITEM, i, MAKELPARAM((flags),0));
|
|
}
|
|
|
|
void GetItemSpacing(SIZE& spacing, BOOL bSmallIconView = FALSE)
|
|
{
|
|
DWORD ret = SendMessage(LVM_GETITEMSPACING, bSmallIconView);
|
|
spacing.cx = LOWORD(ret);
|
|
spacing.cy = HIWORD(ret);
|
|
}
|
|
|
|
UINT GetItemState(int i, UINT mask)
|
|
{
|
|
return SendMessage(LVM_GETITEMSTATE, i, (LPARAM)mask);
|
|
}
|
|
|
|
void SetItemState(int i, UINT state, UINT mask)
|
|
{
|
|
LV_ITEM item;
|
|
item.stateMask = mask;
|
|
item.state = state;
|
|
SendMessage(LVM_SETITEMSTATE, i, reinterpret_cast<LPARAM>(&item));
|
|
}
|
|
|
|
BOOL SetItemText(int i, int subItem, LPCWSTR text)
|
|
{
|
|
LVITEMW item;
|
|
item.iSubItem = subItem;
|
|
item.pszText = (LPWSTR)text;
|
|
return SendMessage(LVM_SETITEMTEXT, i, (LPARAM)&item);
|
|
}
|
|
|
|
void SetCheckState(int i, BOOL check)
|
|
{
|
|
SetItemState(i, INDEXTOSTATEIMAGEMASK((check)?2:1), LVIS_STATEIMAGEMASK);
|
|
}
|
|
|
|
int HitTest(LV_HITTESTINFO * phtInfo)
|
|
{
|
|
return (int)SendMessage(LVM_HITTEST, 0, reinterpret_cast<LPARAM>(phtInfo));
|
|
}
|
|
|
|
DWORD_PTR GetItemData(int i)
|
|
{
|
|
LVITEMW lvItem = { 0 };
|
|
lvItem.mask = LVIF_PARAM;
|
|
lvItem.iItem = i;
|
|
BOOL ret = GetItem(&lvItem);
|
|
return (DWORD_PTR)(ret ? lvItem.lParam : NULL);
|
|
}
|
|
|
|
BOOL GetSelectedItem(LV_ITEM* pItem)
|
|
{
|
|
pItem->iItem = GetNextItem(-1, LVNI_ALL | LVNI_SELECTED);
|
|
if (pItem->iItem == -1)
|
|
return FALSE;
|
|
return GetItem(pItem);
|
|
}
|
|
|
|
void GetItemText(int iItem, int iSubItem, LPTSTR pszText, int cchTextMax)
|
|
{
|
|
LV_ITEM itemInfo;
|
|
itemInfo.iSubItem = iSubItem;
|
|
itemInfo.pszText = pszText;
|
|
itemInfo.cchTextMax = cchTextMax;
|
|
|
|
SendMessage(LVM_GETITEMTEXT, iItem, (LPARAM) &itemInfo);
|
|
}
|
|
|
|
BOOL GetItemPosition(int nItem, POINT* pPoint)
|
|
{
|
|
return (BOOL)SendMessage(LVM_GETITEMPOSITION, nItem, (LPARAM)pPoint);
|
|
}
|
|
|
|
BOOL SetItemPosition(int nItem, POINT* pPoint)
|
|
{
|
|
return (BOOL)SendMessage(LVM_SETITEMPOSITION, nItem, MAKELPARAM(pPoint->x, pPoint->y));
|
|
}
|
|
|
|
BOOL Arrange(UINT nCode)
|
|
{
|
|
return (BOOL)SendMessage(LVM_ARRANGE, nCode, 0);
|
|
}
|
|
|
|
};
|
|
|
|
template<typename TItemData = DWORD_PTR>
|
|
class CToolbar :
|
|
public CWindow
|
|
{
|
|
public: // Configuration methods
|
|
|
|
// Hack:
|
|
// Use DECLARE_WND_SUPERCLASS instead!
|
|
HWND Create(HWND hWndParent, DWORD dwStyles = 0, DWORD dwExStyles = 0)
|
|
{
|
|
if (!dwStyles)
|
|
{
|
|
dwStyles = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN;
|
|
}
|
|
|
|
if (!dwExStyles)
|
|
{
|
|
dwExStyles = WS_EX_TOOLWINDOW;
|
|
}
|
|
|
|
m_hWnd = CreateWindowExW(dwExStyles,
|
|
TOOLBARCLASSNAME,
|
|
NULL,
|
|
dwStyles,
|
|
0, 0, 0, 0, hWndParent,
|
|
NULL,
|
|
_AtlBaseModule.GetModuleInstance(),
|
|
NULL);
|
|
|
|
if (!m_hWnd)
|
|
return NULL;
|
|
|
|
/* Identify the version we're using */
|
|
SetButtonStructSize();
|
|
|
|
return m_hWnd;
|
|
}
|
|
|
|
DWORD SetButtonStructSize()
|
|
{
|
|
return SendMessageW(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
|
|
}
|
|
|
|
HWND GetTooltip()
|
|
{
|
|
return (HWND)SendMessageW(TB_GETTOOLTIPS);
|
|
}
|
|
|
|
DWORD SetTooltip(HWND hWndTooltip)
|
|
{
|
|
return SendMessageW(TB_SETTOOLTIPS, reinterpret_cast<WPARAM>(hWndTooltip), 0);
|
|
}
|
|
|
|
INT GetHotItem()
|
|
{
|
|
return SendMessageW(TB_GETHOTITEM);
|
|
}
|
|
|
|
DWORD SetHotItem(INT item)
|
|
{
|
|
return SendMessageW(TB_SETHOTITEM, item);
|
|
}
|
|
|
|
DWORD SetDrawTextFlags(DWORD useBits, DWORD bitState)
|
|
{
|
|
return SendMessageW(TB_SETDRAWTEXTFLAGS, useBits, bitState);
|
|
}
|
|
|
|
public: // Button list management methods
|
|
int GetButtonCount()
|
|
{
|
|
return SendMessageW(TB_BUTTONCOUNT);
|
|
}
|
|
|
|
DWORD GetButton(int index, TBBUTTON * btn)
|
|
{
|
|
return SendMessageW(TB_GETBUTTON, index, reinterpret_cast<LPARAM>(btn));
|
|
}
|
|
|
|
DWORD AddButton(TBBUTTON * btn)
|
|
{
|
|
return SendMessageW(TB_ADDBUTTONS, 1, reinterpret_cast<LPARAM>(btn));
|
|
}
|
|
|
|
DWORD AddButtons(int count, TBBUTTON * buttons)
|
|
{
|
|
return SendMessageW(TB_ADDBUTTONS, count, reinterpret_cast<LPARAM>(buttons));
|
|
}
|
|
|
|
DWORD InsertButton(int insertAt, TBBUTTON * btn)
|
|
{
|
|
return SendMessageW(TB_INSERTBUTTON, insertAt, reinterpret_cast<LPARAM>(btn));
|
|
}
|
|
|
|
DWORD MoveButton(int oldIndex, int newIndex)
|
|
{
|
|
return SendMessageW(TB_MOVEBUTTON, oldIndex, newIndex);
|
|
}
|
|
|
|
DWORD DeleteButton(int index)
|
|
{
|
|
return SendMessageW(TB_DELETEBUTTON, index, 0);
|
|
}
|
|
|
|
DWORD GetButtonInfo(int cmdId, TBBUTTONINFO * info)
|
|
{
|
|
return SendMessageW(TB_GETBUTTONINFO, cmdId, reinterpret_cast<LPARAM>(info));
|
|
}
|
|
|
|
DWORD SetButtonInfo(int cmdId, TBBUTTONINFO * info)
|
|
{
|
|
return SendMessageW(TB_SETBUTTONINFO, cmdId, reinterpret_cast<LPARAM>(info));
|
|
}
|
|
|
|
DWORD CheckButton(int cmdId, BOOL bCheck)
|
|
{
|
|
return SendMessageW(TB_CHECKBUTTON, cmdId, MAKELPARAM(bCheck, 0));
|
|
}
|
|
|
|
public: // Layout management methods
|
|
DWORD GetButtonSize()
|
|
{
|
|
return SendMessageW(TB_GETBUTTONSIZE);
|
|
}
|
|
|
|
DWORD SetButtonSize(int w, int h)
|
|
{
|
|
return SendMessageW(TB_SETBUTTONSIZE, 0, MAKELPARAM(w, h));
|
|
}
|
|
|
|
DWORD AutoSize()
|
|
{
|
|
return SendMessageW(TB_AUTOSIZE);
|
|
}
|
|
|
|
DWORD GetMaxSize(LPSIZE size)
|
|
{
|
|
return SendMessageW(TB_GETMAXSIZE, 0, reinterpret_cast<LPARAM>(size));
|
|
}
|
|
|
|
DWORD GetIdealSize(BOOL useHeight, LPSIZE size)
|
|
{
|
|
return SendMessageW(TB_GETIDEALSIZE, useHeight, reinterpret_cast<LPARAM>(size));
|
|
}
|
|
|
|
DWORD GetMetrics(TBMETRICS * tbm)
|
|
{
|
|
return SendMessageW(TB_GETMETRICS, 0, reinterpret_cast<LPARAM>(tbm));
|
|
}
|
|
|
|
DWORD SetMetrics(TBMETRICS * tbm)
|
|
{
|
|
return SendMessageW(TB_SETMETRICS, 0, reinterpret_cast<LPARAM>(tbm));
|
|
}
|
|
|
|
DWORD GetItemRect(int index, LPRECT prcItem)
|
|
{
|
|
return SendMessageW(TB_GETITEMRECT, index, reinterpret_cast<LPARAM>(prcItem));
|
|
}
|
|
|
|
DWORD SetRedraw(BOOL bEnable)
|
|
{
|
|
return SendMessageW(WM_SETREDRAW, bEnable);
|
|
}
|
|
|
|
DWORD GetPadding()
|
|
{
|
|
return SendMessageW(TB_GETPADDING);
|
|
}
|
|
|
|
DWORD SetPadding(int x, int y)
|
|
{
|
|
return SendMessageW(TB_SETPADDING, 0, MAKELPARAM(x, y));
|
|
}
|
|
|
|
public: // Image list management methods
|
|
HIMAGELIST SetImageList(HIMAGELIST himl)
|
|
{
|
|
return (HIMAGELIST)SendMessageW(TB_SETIMAGELIST, 0, reinterpret_cast<LPARAM>(himl));
|
|
}
|
|
|
|
public: // Other methods
|
|
INT HitTest(PPOINT ppt)
|
|
{
|
|
return (INT) SendMessageW(TB_HITTEST, 0, reinterpret_cast<LPARAM>(ppt));
|
|
}
|
|
|
|
public: // Utility methods
|
|
TItemData * GetItemData(int index)
|
|
{
|
|
TBBUTTON btn;
|
|
GetButton(index, &btn);
|
|
return (TItemData*) btn.dwData;
|
|
}
|
|
|
|
DWORD SetItemData(int index, TItemData * data)
|
|
{
|
|
TBBUTTONINFOW info = { 0 };
|
|
info.cbSize = sizeof(info);
|
|
info.dwMask = TBIF_BYINDEX | TBIF_LPARAM;
|
|
info.lParam = (DWORD_PTR) data;
|
|
return SetButtonInfo(index, &info);
|
|
}
|
|
};
|
|
|
|
class CStatusBar :
|
|
public CWindow
|
|
{
|
|
public:
|
|
VOID SetText(LPCWSTR lpszText)
|
|
{
|
|
SendMessage(SB_SETTEXT, SBT_NOBORDERS, (LPARAM) lpszText);
|
|
}
|
|
|
|
HWND Create(HWND hwndParent, HMENU hMenu)
|
|
{
|
|
m_hWnd = CreateWindowExW(0,
|
|
STATUSCLASSNAMEW,
|
|
NULL,
|
|
WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
|
|
0, 0, 0, 0,
|
|
hwndParent,
|
|
hMenu,
|
|
_AtlBaseModule.GetModuleInstance(),
|
|
NULL);
|
|
|
|
return m_hWnd;
|
|
}
|
|
|
|
};
|
|
|
|
class CTreeView :
|
|
public CWindow
|
|
{
|
|
public:
|
|
HWND Create(HWND hwndParent)
|
|
{
|
|
m_hWnd = CreateWindowExW(WS_EX_CLIENTEDGE,
|
|
WC_TREEVIEWW,
|
|
L"",
|
|
WS_CHILD | WS_VISIBLE | TVS_HASLINES | TVS_SHOWSELALWAYS,
|
|
0, 28, 200, 350,
|
|
hwndParent,
|
|
NULL,
|
|
_AtlBaseModule.GetModuleInstance(),
|
|
NULL);
|
|
|
|
return m_hWnd;
|
|
}
|
|
|
|
HTREEITEM AddItem(HTREEITEM hParent, LPWSTR lpText, INT Image, INT SelectedImage, LPARAM lParam)
|
|
{
|
|
TVINSERTSTRUCTW Insert;
|
|
|
|
ZeroMemory(&Insert, sizeof(TV_INSERTSTRUCT));
|
|
|
|
Insert.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
Insert.hInsertAfter = TVI_LAST;
|
|
Insert.hParent = hParent;
|
|
Insert.item.iSelectedImage = SelectedImage;
|
|
Insert.item.iImage = Image;
|
|
Insert.item.lParam = lParam;
|
|
Insert.item.pszText = lpText;
|
|
|
|
return InsertItem(&Insert);
|
|
}
|
|
|
|
void SetRedraw(BOOL redraw)
|
|
{
|
|
SendMessage(WM_SETREDRAW, redraw);
|
|
}
|
|
|
|
BOOL SetBkColor(COLORREF cr)
|
|
{
|
|
return (BOOL) SendMessage(TVM_SETBKCOLOR, 0, cr);
|
|
}
|
|
|
|
BOOL SetTextColor(COLORREF cr)
|
|
{
|
|
return (BOOL) SendMessage(TVM_SETTEXTCOLOR, 0, cr);
|
|
}
|
|
|
|
HIMAGELIST SetImageList(HIMAGELIST himl, int iImageList)
|
|
{
|
|
return (HIMAGELIST) SendMessage(TVM_SETIMAGELIST, iImageList, reinterpret_cast<LPARAM>(himl));
|
|
}
|
|
|
|
HTREEITEM InsertItem(const TVINSERTSTRUCTW * pitem)
|
|
{
|
|
return (HTREEITEM) SendMessage(TVM_INSERTITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
BOOL DeleteItem(HTREEITEM i)
|
|
{
|
|
return (BOOL) SendMessage(TVM_DELETEITEM, 0, (LPARAM)i);
|
|
}
|
|
|
|
BOOL GetItem(TV_ITEM* pitem)
|
|
{
|
|
return (BOOL) SendMessage(TVM_GETITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
BOOL SetItem(const TV_ITEM * pitem)
|
|
{
|
|
return (BOOL) SendMessage(TVM_SETITEM, 0, reinterpret_cast<LPARAM>(pitem));
|
|
}
|
|
|
|
int GetItemCount()
|
|
{
|
|
return SendMessage(TVM_GETCOUNT);
|
|
}
|
|
|
|
BOOL EnsureVisible(HTREEITEM i)
|
|
{
|
|
return (BOOL) SendMessage(TVM_ENSUREVISIBLE, 0, (LPARAM)i);
|
|
}
|
|
|
|
HWND EditLabel(HTREEITEM i)
|
|
{
|
|
return (HWND) SendMessage(TVM_EDITLABEL, 0, (LPARAM)i);
|
|
}
|
|
|
|
HTREEITEM GetNextItem(HTREEITEM i, WORD flags)
|
|
{
|
|
return (HTREEITEM)SendMessage(TVM_GETNEXTITEM, flags, (LPARAM)i);
|
|
}
|
|
|
|
UINT GetItemState(int i, UINT mask)
|
|
{
|
|
return SendMessage(TVM_GETITEMSTATE, i, (LPARAM) mask);
|
|
}
|
|
|
|
HTREEITEM HitTest(TVHITTESTINFO * phtInfo)
|
|
{
|
|
return (HTREEITEM) SendMessage(TVM_HITTEST, 0, reinterpret_cast<LPARAM>(phtInfo));
|
|
}
|
|
|
|
DWORD_PTR GetItemData(HTREEITEM item)
|
|
{
|
|
TVITEMW lvItem;
|
|
lvItem.hItem = item;
|
|
lvItem.mask = TVIF_PARAM;
|
|
BOOL ret = GetItem(&lvItem);
|
|
return (DWORD_PTR) (ret ? lvItem.lParam : NULL);
|
|
}
|
|
|
|
HTREEITEM GetSelection()
|
|
{
|
|
return GetNextItem(NULL, TVGN_CARET);
|
|
}
|
|
|
|
BOOL Expand(HTREEITEM item, DWORD action)
|
|
{
|
|
return SendMessage(TVM_EXPAND, action, (LPARAM)item);
|
|
}
|
|
|
|
BOOL SelectItem(HTREEITEM item, DWORD action = TVGN_CARET)
|
|
{
|
|
return SendMessage(TVM_SELECTITEM, action, (LPARAM) item);
|
|
}
|
|
|
|
};
|
|
|
|
class CTooltips :
|
|
public CWindow
|
|
{
|
|
public: // Configuration methods
|
|
|
|
HWND Create(HWND hWndParent, DWORD dwStyles = WS_POPUP | TTS_NOPREFIX, DWORD dwExStyles = WS_EX_TOPMOST)
|
|
{
|
|
RECT r = { 0 };
|
|
return CWindow::Create(TOOLTIPS_CLASS, hWndParent, r, L"", dwStyles, dwExStyles);
|
|
}
|
|
|
|
public: // Relay event
|
|
|
|
// Win7+: Can use GetMessageExtraInfo to provide the WPARAM value.
|
|
VOID RelayEvent(MSG * pMsg, WPARAM extraInfo = 0)
|
|
{
|
|
SendMessageW(TTM_RELAYEVENT, extraInfo, reinterpret_cast<LPARAM>(pMsg));
|
|
}
|
|
|
|
public: // Helpers
|
|
|
|
INT GetToolCount()
|
|
{
|
|
return SendMessageW(TTM_GETTOOLCOUNT, 0, 0);
|
|
}
|
|
|
|
BOOL AddTool(IN CONST TTTOOLINFOW * pInfo)
|
|
{
|
|
return SendMessageW(TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
VOID DelTool(IN HWND hwndToolOwner, IN UINT uId)
|
|
{
|
|
TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
|
|
info.hwnd = hwndToolOwner;
|
|
info.uId = uId;
|
|
SendMessageW(TTM_DELTOOL, 0, reinterpret_cast<LPARAM>(&info));
|
|
}
|
|
|
|
VOID NewToolRect(IN HWND hwndToolOwner, IN UINT uId, IN RECT rect)
|
|
{
|
|
TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
|
|
info.hwnd = hwndToolOwner;
|
|
info.uId = uId;
|
|
info.rect = rect;
|
|
SendMessageW(TTM_NEWTOOLRECT, 0, reinterpret_cast<LPARAM>(&info));
|
|
}
|
|
|
|
BOOL GetToolInfo(IN HWND hwndToolOwner, IN UINT uId, IN OUT TTTOOLINFOW * pInfo)
|
|
{
|
|
pInfo->hwnd = hwndToolOwner;
|
|
pInfo->uId = uId;
|
|
return SendMessageW(TTM_GETTOOLINFO, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
VOID SetToolInfo(IN CONST TTTOOLINFOW * pInfo)
|
|
{
|
|
SendMessageW(TTM_SETTOOLINFO, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
BOOL HitTest(IN CONST TTHITTESTINFOW * pInfo)
|
|
{
|
|
return SendMessageW(TTM_HITTEST, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
VOID GetText(IN HWND hwndToolOwner, IN UINT uId, OUT PWSTR pBuffer, IN DWORD cchBuffer)
|
|
{
|
|
TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
|
|
info.hwnd = hwndToolOwner;
|
|
info.uId = uId;
|
|
info.lpszText = pBuffer;
|
|
SendMessageW(TTM_GETTEXT, cchBuffer, reinterpret_cast<LPARAM>(&info));
|
|
}
|
|
|
|
VOID UpdateTipText(IN HWND hwndToolOwner, IN UINT uId, IN PCWSTR szText, IN HINSTANCE hinstResourceOwner = NULL)
|
|
{
|
|
TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
|
|
info.hwnd = hwndToolOwner;
|
|
info.uId = uId;
|
|
info.lpszText = const_cast<PWSTR>(szText);
|
|
info.hinst = hinstResourceOwner;
|
|
SendMessageW(TTM_UPDATETIPTEXT, 0, reinterpret_cast<LPARAM>(&info));
|
|
}
|
|
|
|
BOOL EnumTools(IN CONST TTTOOLINFOW * pInfo)
|
|
{
|
|
return SendMessageW(TTM_ENUMTOOLS, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
BOOL GetCurrentTool(OUT OPTIONAL TTTOOLINFOW * pInfo = NULL)
|
|
{
|
|
return SendMessageW(TTM_GETCURRENTTOOL, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
}
|
|
|
|
VOID GetTitle(TTGETTITLE * pTitleInfo)
|
|
{
|
|
SendMessageW(TTM_GETTITLE, 0, reinterpret_cast<LPARAM>(pTitleInfo));
|
|
}
|
|
|
|
BOOL SetTitle(PCWSTR szTitleText, WPARAM icon = 0)
|
|
{
|
|
return SendMessageW(TTM_SETTITLE, icon, reinterpret_cast<LPARAM>(szTitleText));
|
|
}
|
|
|
|
VOID TrackActivate(IN HWND hwndToolOwner, IN UINT uId)
|
|
{
|
|
TTTOOLINFOW info = { sizeof(TTTOOLINFOW), 0 };
|
|
info.hwnd = hwndToolOwner;
|
|
info.uId = uId;
|
|
SendMessageW(TTM_TRACKACTIVATE, TRUE, reinterpret_cast<LPARAM>(&info));
|
|
}
|
|
|
|
VOID TrackDeactivate()
|
|
{
|
|
SendMessageW(TTM_TRACKACTIVATE, FALSE, NULL);
|
|
}
|
|
|
|
VOID TrackPosition(IN WORD x, IN WORD y)
|
|
{
|
|
SendMessageW(TTM_TRACKPOSITION, 0, MAKELPARAM(x, y));
|
|
}
|
|
|
|
// Opens the tooltip
|
|
VOID Popup()
|
|
{
|
|
SendMessageW(TTM_POPUP);
|
|
}
|
|
|
|
// Closes the tooltip - Pressing the [X] for a TTF_CLOSE balloon is equivalent to calling this
|
|
VOID Pop()
|
|
{
|
|
SendMessageW(TTM_POP);
|
|
}
|
|
|
|
// Delay times for AUTOMATIC tooltips (they don't affect balloons)
|
|
INT GetDelayTime(UINT which)
|
|
{
|
|
return SendMessageW(TTM_GETDELAYTIME, which);
|
|
}
|
|
|
|
VOID SetDelayTime(UINT which, WORD time)
|
|
{
|
|
SendMessageW(TTM_SETDELAYTIME, which, MAKELPARAM(time, 0));
|
|
}
|
|
|
|
// Activates or deactivates the automatic tooltip display when hovering a control
|
|
VOID Activate(IN BOOL bActivate = TRUE)
|
|
{
|
|
SendMessageW(TTM_ACTIVATE, bActivate);
|
|
}
|
|
|
|
// Adjusts the position of a tooltip when used to display trimmed text
|
|
VOID AdjustRect(IN BOOL bTextToWindow, IN OUT RECT * pRect)
|
|
{
|
|
SendMessageW(TTM_ADJUSTRECT, bTextToWindow, reinterpret_cast<LPARAM>(pRect));
|
|
}
|
|
|
|
// Useful for TTF_ABSOLUTE|TTF_TRACK tooltip positioning
|
|
SIZE GetBubbleSize(IN TTTOOLINFOW * pInfo)
|
|
{
|
|
DWORD ret = SendMessageW(TTM_GETBUBBLESIZE, 0, reinterpret_cast<LPARAM>(pInfo));
|
|
const SIZE sz = { LOWORD(ret), HIWORD(ret) };
|
|
return sz;
|
|
}
|
|
|
|
// Fills the RECT with the margin size previously set. Default is 0 margins.
|
|
VOID GetMargin(OUT RECT * pRect)
|
|
{
|
|
SendMessageW(TTM_GETMARGIN, 0, reinterpret_cast<LPARAM>(pRect));
|
|
}
|
|
|
|
VOID SetMargin(IN RECT * pRect)
|
|
{
|
|
SendMessageW(TTM_SETMARGIN, 0, reinterpret_cast<LPARAM>(pRect));
|
|
}
|
|
|
|
// Gets a previously established max width. Returns -1 if no limit is set
|
|
INT GetMaxTipWidth()
|
|
{
|
|
return SendMessageW(TTM_GETMAXTIPWIDTH);
|
|
}
|
|
|
|
INT SetMaxTipWidth(IN OPTIONAL INT width = -1)
|
|
{
|
|
return SendMessageW(TTM_SETMAXTIPWIDTH, 0, width);
|
|
}
|
|
|
|
// Get the color of the tooltip text
|
|
COLORREF GetTipTextColor()
|
|
{
|
|
return SendMessageW(TTM_GETTIPTEXTCOLOR);
|
|
}
|
|
|
|
VOID SetTipTextColor(IN COLORREF textColor)
|
|
{
|
|
SendMessageW(TTM_SETTIPTEXTCOLOR, textColor);
|
|
}
|
|
|
|
COLORREF GetTipBkColor()
|
|
{
|
|
return SendMessageW(TTM_GETTIPBKCOLOR);
|
|
}
|
|
|
|
VOID SetTipBkColor(IN COLORREF textColor)
|
|
{
|
|
SendMessageW(TTM_SETTIPBKCOLOR, textColor);
|
|
}
|
|
|
|
VOID SetWindowTheme(IN PCWSTR szThemeName)
|
|
{
|
|
SendMessageW(TTM_SETWINDOWTHEME, 0, reinterpret_cast<LPARAM>(szThemeName));
|
|
}
|
|
|
|
// Forces redraw
|
|
VOID Update()
|
|
{
|
|
SendMessageW(TTM_UPDATE);
|
|
}
|
|
|
|
HWND WindowFromPoint(IN POINT * pPoint)
|
|
{
|
|
return reinterpret_cast<HWND>(SendMessageW(TTM_WINDOWFROMPOINT, 0, reinterpret_cast<LPARAM>(pPoint)));
|
|
}
|
|
};
|