www.pudn.com > VCдµÄMP3²¥·ÅÆ÷Ô´´úÂë.zip > OXToolTipCtrl.h
// ==========================================================================
// Class Specification : COXToolTipCtrl
// ==========================================================================
// //////////////////////////////////////////////////////////////////////////
// Header file : OXToolTipCtrl.h
//
//
//////////////////////////////////////////////////////////////////////////
#if !defined(_OXTOOLTIPCTRL_H__)
#define _OXTOOLTIPCTRL_H__
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "OXDllExt.h"
class COXToolTipInfo;
struct OXTOOLINFO : public TOOLINFO
{
#if (_WIN32_IE < 0x0300)
// Application defined value that is associated with the tool
LPARAM lParam;
#endif
// Width of box, or 0 for default
int nWidth;
// text color
COLORREF clrTextColor;
// background color
COLORREF clrBackColor;
OXTOOLINFO::OXTOOLINFO()
{
cbSize = sizeof(OXTOOLINFO);
}
void operator=(COXToolTipInfo& RHS);
};
// this structure holds all the tooltip information internall
class OX_CLASS_DECL COXToolTipInfo : public CObject
{
public:
UINT uFlags; // Not used
HWND hWnd; // Window handle of the control
UINT nIDTool; // ID of tool
CRect rectBounds; // Bounding rect for toolinfo to be displayed
LPCTSTR szText; // Either LPSTR_TEXTCALLBACK or NULL
CString strText; // Tooltip text if szText is NULL, or empty.
int nWidth; // Width of box, or 0 for default
COLORREF clrTextColor; // text color
COLORREF clrBackColor; // background color
LPARAM lParam; // Application defined value that is associated
// with the tool
void operator=(OXTOOLINFO& RHS)
{
uFlags = RHS.uFlags;
hWnd = RHS.hwnd;
nIDTool = RHS.uId;
rectBounds = RHS.rect;
if (RHS.lpszText == LPSTR_TEXTCALLBACK)
{
szText = RHS.lpszText;
strText.Empty();
}
else
{
szText = NULL;
strText = RHS.lpszText;
}
nWidth = RHS.nWidth;
clrTextColor = RHS.clrTextColor;
clrBackColor = RHS.clrBackColor;
lParam = RHS.lParam;
}
void operator=(COXToolTipInfo& RHS)
{
uFlags = RHS.uFlags;
hWnd = RHS.hWnd;
nIDTool = RHS.nIDTool;
rectBounds = RHS.rectBounds;
strText = RHS.strText;
nWidth = RHS.nWidth;
clrTextColor = RHS.clrTextColor;
clrBackColor = RHS.clrBackColor;
lParam = RHS.lParam;
}
};
inline void OXTOOLINFO::operator=(COXToolTipInfo& RHS)
{
cbSize = sizeof(OXTOOLINFO);
uFlags = RHS.uFlags;
hwnd = RHS.hWnd;
uId = RHS.nIDTool;
rect = RHS.rectBounds;
hinst = AfxGetResourceHandle();
if (RHS.szText == LPSTR_TEXTCALLBACK)
lpszText = LPSTR_TEXTCALLBACK;
else
lpszText = (LPTSTR)(LPCTSTR) RHS.strText;
lParam = RHS.lParam;
nWidth = RHS.nWidth;
clrTextColor = RHS.clrTextColor;
clrBackColor = RHS.clrBackColor;
}
/////////////////////////////////////////////////////////////////////////////
// COXToolTipCtrl window
class OX_CLASS_DECL COXToolTipCtrl : public CWnd
{
// Construction
public:
// --- In :
// --- Out :
// --- Returns:
// --- Effect : The constructor - all relevant variables initialized
COXToolTipCtrl();
// Attributes
public:
// --- In: ToolInfo - Reference to a TOOLINFO object that receives the
// tool’s text.
// pWnd - Pointer to the window that contains the tool.
// nIDTool - ID of the tool.
// --- Out :
// --- Returns: TRUE on success, FALSE otherwise
// --- Effect : Call this function to retrieve the information that a tool tip
// control maintains about a tool. If the control has information
// on the tool identified by the window and ID, then the
// COXToolTipInfo structure is filled with that information.
BOOL GetToolInfo(OXTOOLINFO& ToolInfo, CWnd* pWnd, UINT nIDTool = 0);
// --- In: pToolInfo - A pointer to a OXTOOLINFO structure that
// specifies the information to set.
// --- Out :
// --- Returns:
// --- Effect: Sets the information that a tool tip maintains for a tool
void SetToolInfo(OXTOOLINFO* pToolInfo);
// --- In:
// --- Out: lprc - Address of a RECT structure that will receive the
// margin information
// --- Returns:
// --- Effect: Retrieves the margins used for drawing the text in the tooltip.
// The rectangle does not specify a bounding rect, but rather the
// top, bottom, left and right distances (in pixels) between the
// text and the the edge of the toltip window.
void GetMargin(LPRECT lprc) const;
// --- In: pWnd - Pointer to the window that contains the tool.
// nIDTool - ID of the tool.
// --- Out: str - Reference to a CString object that receives the
// tool’s text
// --- Returns :
// --- Effect : Retrieves the text that a tool tip control maintains for a tool.
// If pWnd and nIDTool specify a valid tool that has been previously
// registered, then str is filled with the tooltip's text.
void GetText(CString& str, CWnd* pWnd, UINT nIDTool = 0);
// --- In: nTime - Specifies the new delay time, in milliseconds
// dwDuration - Flag that specifies which duration value will
// be set. This is either:
//
// TTDT_AUTOPOP - The length of time the tool tip window
// remains visible if the pointer is
// stationary within a tool's bounding
// rectangle.
// TTDT_INITIAL - The length of time the pointer must
// remain stationary within a tool's
// bounding rectangle before the tool tip
// window appears.
// nDelay - Specifies the new delay time, in milliseconds
// --- Out :
// --- Returns:
// --- Effect: Sets the delay times for the tooltip in milliseconds
void SetDelayTime(DWORD dwDuration, int nTime);
inline void SetDelayTime(UINT nDelay) { m_nDisplayDelay = nDelay; }
// --- In: dwDuration - Flag that specifies which duration value will
// be retrieved. This is either:
//
// TTDT_AUTOPOP - The length of time the tool tip window
// remains visible if the pointer is
// stationary within a tool's bounding
// rectangle.
// TTDT_INITIAL - The length of time the pointer must
// remain stationary within a tool's
// bounding rectangle before the tool tip
// window appears.
// --- Out :
// --- Returns: The delay times for the tooltip in milliseconds
// --- Effect: Retrieves the initial, pop-up, and reshow durations currently
// set for a tooltip control
int GetDelayTime(DWORD dwDuration) const;
// --- In :
// --- Out :
// --- Returns: The maximum width for a tool tip window, or 0 if this width is
// calculated automatically
// --- Effect: Retrieves the maximum width of the tool tip window
int GetMaxTipWidth() const;
// --- In: nWidth - The maximum width for a tool tip window, or 0 if this
// width is calculated automatically. The maximum
// tooltip width value does not indicate a tooltip
// window's actual width. Rather, if a tooltip string
// exceeds the maximum width, the control breaks the
// text into multiple lines, using spaces to determine
// line breaks. If the text cannot be segmented into
// multiple lines, it will be displayed on a single line.
// The length of this line may exceed the maximum
// tooltip width.
// --- Out :
// --- Returns: The previous maximum tool tip window width.
// --- Effect: Sets the maximum tool tip window width
int SetMaxTipWidth(int nWidth);
// --- In :
// --- Out :
// --- Returns: A COLORREF value that represents the background color of the
// tool tip window
// --- Effect: Retrieves the background color
COLORREF GetTipBkColor() const;
// --- In: clr - The new background color
// --- Out :
// --- Returns:
// --- Effect: Sets the background colour for all tools maintained by this
// control. If the value is CLR_DEFAULT then the default system
// colour is used
void SetTipBkColor(COLORREF clr);
// --- In :
// --- Out :
// --- Returns: A COLORREF value that represents the text color
// --- Effect: Retrieves the text color
COLORREF GetTipTextColor() const;
// --- In: clr - The new text color
// --- Out :
// --- Returns:
// --- Effect: Sets the text colour for all tools maintained by this control.
// If the value is CLR_DEFAULT then the default system colour is
// used
void SetTipTextColor(COLORREF clr);
// Attributes - inline
public:
// --- In: bActivate - Specifies whether the tool tip control is to be
// activated or deactivated.
// --- Out :
// --- Returns:
// --- Effect: Call this function to activate or deactivate a tool tip control.
// If bActivate is TRUE, the control is activated; if FALSE, it is
// deactivated. When a tool tip control is active, the tool tip
// information appears when the cursor is on a tool that is
// registered with the control; when it is inactive, the tool tip
// information does not appear, even when the cursor is on a tool.
inline void Activate(BOOL bActivate) { m_bActivated = bActivate; }
// --- In :
// --- Out :
// --- Returns: A count of tools registered with the tool tip control
// --- Effect: Retrieves a count of the tools registered with the
// tool tip control
inline int GetToolCount() const { return m_arrTools.GetSize(); }
// --- In : lprc - Address of a RECT structure that contains the margin
// information to be set. The members of the RECT
// structure do not define a bounding rectangle,
// but rather the top, bottom, left and right distances
// (in pixels) between the text and the the edge of the
// toltip window.
// --- Out :
// --- Returns:
// --- Effect: Sets the top, left, bottom, and right margins for a tooltip
// window. A margin is the distance, in pixels, between the tooltip
// window border and the text contained within the tooltip window.
inline void SetMargin(LPRECT lprc) { m_rectMargin = lprc; }
// Operations
public:
// --- In: pParentWnd - A pointer to the tool tip control parent
// --- Out :
// --- Returns: TRUE on success, FALSE otherwise
// --- Effect: Creates the tooltip window, initially invisible
BOOL Create(CWnd* pParentWnd);
// --- In : pWnd - Pointer to the window that contains the tool.
// nIDText - ID of the string resource that contains the text
// for the tool. If the text contains a '\r'
// character, then all text before the \r is the
// standard tooltip text, and all text after the \r
// will be displayed as extended test if the use
// clicks on the tooltip
// lpszText - Pointer to the text for the tool. If the text
// contains a '\r' character, then all text before
// the \r is the standard tooltip text, and all text
// after the \r will be displayed as extended test if
// the use clicks on the tooltip. If the text is
// LPSTR_TEXTCALLBACK then the control will send the
// TTN_NEEDTEXT notification message to the parent
// window to retrieve the text.
// lpRectTool - Pointer to a RECT structure containing coordinates
// of the tool's bounding rectangle, using client
// coordinates relative to the window identified
// by pWnd.
// nIDTool - ID of the tool.
// --- Out :
// --- Returns: TRUE on success, FALSE otherwise
// --- Effect : Registers a tool with the tool tip control, so that the
// information stored in the tool tip is displayed when the cursor
// is on the tool.
BOOL AddTool(CWnd* pWnd, UINT nIDText,
LPCRECT lpRectTool = NULL, UINT nIDTool = 0);
BOOL AddTool(CWnd* pWnd, LPCTSTR lpszText,
LPCRECT lpRectTool = NULL, UINT nIDTool = 0);
// --- In: pWnd - Pointer to the window that contains the tool
// nIDTool - ID of the tool
// --- Out :
// --- Returns:
// --- Effect: Removes the tool specified by pWnd and nIDTool from the
// collection of tools supported by a tool tip control.
void DelTool(CWnd* pWnd, UINT nIDTool = 0);
// --- In: pMsg - Pointer to a MSG structure that contains the
// message to relay
// --- Out :
// --- Returns:
// --- Effect: Call this function to pass a mouse message to a tool tip
// control for processing.
void RelayEvent(MSG* pMsg);
// --- In: pWnd - Pointer to the window that contains the tool.
// pt - Pointer to a CPoint object containing the
// coordinates of the point to be tested.
// lpToolInfo - Pointer to a OXTOOLINFO structure that contains
// information about the tool.
// --- Out :
// --- Returns: TRUE if the point specified by the hit-test information is
// within the tool’s bounding rectangle; otherwise FALSE.
// --- Effect: Returns TRUE if the given pt is in the windows toolinfo bounding
// rectangle (pt is in client coords relative to the parent window).
// If this function returns a TRUE, the structure pointed to by
// pToolInfo is filled with information on the corresponding tool.
BOOL HitTest(CWnd* pWnd, POINT pt, OXTOOLINFO* pToolInfo) const;
// --- In :
// --- Out :
// --- Returns:
// --- Effect: Hides the tooltip.
void Pop();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(COXToolTipCtrl)
//}}AFX_VIRTUAL
protected:
// --- In: pt - the topleft corner of the region
// pToolTip - information on the tooltip
// rectTextBounds - the minimum rectangle needed to contain the
// text
// --- Out :
// --- Returns: A rectangle containing the bounds of the tooltip
// --- Effect: Given the bounding rect of some text, this returns the rectangle
// (in screen coords) that is best suited to displaying the tooltip
// info (uses current mouse position)
virtual CRect CalculateInfoBoxRect(CPoint& pt, COXToolTipInfo* pToolTip,
CRect& rectTextBounds) const;
// --- In: strText - the text to be displayed (may be multiline)
// nWidth - the desired width. If this is 0, then the width
// will be calculated
// --- Out :
// --- Returns: The bounding rect for the text (with topleft at 0,0)
// --- Effect : Returns the smallest possible rectangle that will contain
// the text (inc. margins)
virtual CRect GetBoundsRect(CString strText, int nWidth) const;
// Implementation
public:
// --- In :
// --- Out :
// --- Returns:
// --- Effect: The destructor - cleanup and memory release
virtual ~COXToolTipCtrl();
protected:
inline BOOL IsVisible() const { return ((GetStyle() & WS_VISIBLE) == WS_VISIBLE); }
// --- In: pToolTip - A pointer to a COXToolTipInfo structure
// describing the tooltip
// --- Out :
// --- Returns: A CString containing the tooltip text
// --- Effect: Returns the tooltip text for the tool. If the tooltip is
// currently displaying extended text, then the extended
// text, if available, will be returned. Otherwise the standard
// tooltip text will be returned.
CString GetTooltipText(COXToolTipInfo *pToolTip);
// --- In: pWnd - a window containing a tool
// nIDTool - the ID of the tool
// --- Out :
// --- Returns: A pointer to the internal storage of the tooltip for the given
// window and ID
// --- Effect: Retrieves the internal info about a tool
COXToolTipInfo* GetToolInfoPtr(CWnd* pWnd, UINT nIDTool /*=0*/);
// --- In: point - a point (in parent window client coords) to test.
// --- Out :
// --- Returns: The child window (of the parent window) from the supplied point.
// --- Effect : Retrieves to a child window of the tool tip control parent
// window that contains the specified point
CWnd* GetChildWindowFromPoint(POINT& point) const;
// --- In: pToolInfo - a tooltip
// --- Out:
// --- Returns:
// --- Effect: Initiates the display of a tooltip. The tip will not actually
// be displayed until the preset delay (m_nDisplayDelay) is up.
void StartNewTool(COXToolTipInfo* pToolInfo);
// --- In: pt - the topleft corner where the tooltip should be
// displayed
// bExtended - if TRUE, then the extended text is displayed.
// --- Out :
// --- Returns :
// --- Effect : Displays the current tooltip, either as a normal tooltip or as an
// extended tooltip
void DisplayToolTip(CPoint& pt, BOOL bExtended = FALSE);
// --- In: pt - a point (in parent window client coords) to test
// --- Out :
// --- Returns: Eeither a pointer to the COXToolTipInfo, or NULL if failed
// --- Effect : Searches through the list of tools looking for the first tool
// whose bounding rect contains pt.
COXToolTipInfo* FindToolFromPoint(POINT& pt);
// --- In: pToolInfo - a tool tip info
// --- Out :
// --- Returns: Returns TRUE if the cursor is in the tool given by pToolInfo
// --- Effect: Retrieves the flag that specifies if cursor is over the
// specified tool
BOOL IsCursorInTool(COXToolTipInfo* pToolInfo) const;
// --- In :
// --- Out :
// --- Returns: Returns TRUE if the cursor is in the current tooltip window
// --- Effect: Retrieves the flag that specifies if cursor is over the
// current tooltip window
BOOL IsCursorInToolTip() const;
// --- In: ref - the string to parse
// nIndex - the field number to return (0 based)
// ch - the separator character
// --- Out :
// --- Returns: The substring of ref delimted by ch
// --- Effect: This routine breaks a supplied string into substrings,
// each delimited by 'ch', and returns the substring number given
// by nIndex
CString GetFieldFromString(CString ref, int nIndex, TCHAR ch) const;
// --- In: lpLogFont - A pointer to a LOGFONT structure (the new font)
// bRedraw - If TRUE then the tooltip should be immediately
// redrawn
// --- Out :
// --- Returns: TRUE on success, FALSE otherwise
// --- Effect: Sets the font to be used in the tooltip
BOOL SetLogFont(LPLOGFONT lpLogFont, BOOL bRedraw = TRUE);
// --- In :
// --- Out :
// --- Returns: A pointer to a LOGFONT structure that contains default font
// used in tool tips
// --- Effect : Returns the system tool tip font
LPLOGFONT GetSystemToolTipFont() const;
protected:
CWnd* m_pParentWnd; // Parent window of all the tools
CRect m_rectMargin; // Margin between text and tooltip window edge
int m_nMaxWidth; // Max tooltip width
CPoint m_ptOffset; // offset from the cursor to the topleft of
CFont m_Font;
LOGFONT m_LogFont; // Current font in use
DWORD m_dwTextStyle; // The style in which to draw the text
BOOL m_bUsingSystemFont; // Use system tooltip font?
COXToolTipInfo *m_pCurrentToolTip; // Current tooltip information
UINT m_nCheckInterval; // Time in ms between check of the tip
UINT m_nDisplayTime; // Time in ms to display the tip
UINT m_nElapsedTime; // Elapsed display time of the tip
UINT m_nDisplayDelay; // Delay in ms before the tip is displayed
BOOL m_bActivated; // Are tips activated?
BOOL m_bTipCancelled; // Has the current tooltip been cancelled?
BOOL m_bHasExtendedText; // TRUE if the tooltip contains extended text
BOOL m_bExtended; // Is the tip displaying extended info?
COLORREF m_crBackColor; // Default background color of tips
COLORREF m_crTextColor; // Default foreground color of tips
HWND m_hOldFocusWnd; // window that had focus before the tooltip
// was clicked on
static LPCTSTR m_szArrowSpace; // Spaces (' ') added to allow room for arrow in text
protected:
enum { eIDDisplayToolEvent = 1, eIDCheckToolEvent = 2};
private:
CObArray m_arrTools; // Collection of all tools
// Generated message map functions
protected:
//{{AFX_MSG(COXToolTipCtrl)
afx_msg void OnPaint();
afx_msg void OnTimer(UINT nIDEvent);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnSetFocus(CWnd* pOldWnd);
afx_msg void OnDestroy();
afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection);
afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
//}}AFX_MSG
afx_msg LRESULT OnSetFont(WPARAM hFont, LPARAM lParam);
afx_msg LRESULT OnGetFont(WPARAM hFont, LPARAM lParam);
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(_OXTOOLTIPCTRL_H__)