More Windows build fixes.

third_party/wtl/include/atlctrlx.h

+// Windows Template Library - WTL version 8.0
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//
+// This file is a part of the Windows Template Library.
+// The use and distribution terms for this software are covered by the
+// Microsoft Permissive License (Ms-PL) which can be found in the file
+// Ms-PL.txt at the root of this distribution.
+
+#ifndef __ATLCTRLX_H__
+#define __ATLCTRLX_H__
+
+#pragma once
+
+#ifndef __cplusplus
+        #error ATL requires C++ compilation (use a .cpp suffix)
+#endif
+
+#ifndef __ATLAPP_H__
+        #error atlctrlx.h requires atlapp.h to be included first
+#endif
+
+#ifndef __ATLCTRLS_H__
+        #error atlctrlx.h requires atlctrls.h to be included first
+#endif
+
+#ifndef WM_UPDATEUISTATE
+  #define WM_UPDATEUISTATE                0x0128
+#endif // !WM_UPDATEUISTATE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Classes in this file:
+//
+// CBitmapButtonImpl<T, TBase, TWinTraits>
+// CBitmapButton
+// CCheckListViewCtrlImpl<T, TBase, TWinTraits>
+// CCheckListViewCtrl
+// CHyperLinkImpl<T, TBase, TWinTraits>
+// CHyperLink
+// CWaitCursor
+// CCustomWaitCursor
+// CMultiPaneStatusBarCtrlImpl<T, TBase>
+// CMultiPaneStatusBarCtrl
+// CPaneContainerImpl<T, TBase, TWinTraits>
+// CPaneContainer
+// CSortListViewImpl<T>
+// CSortListViewCtrlImpl<T, TBase, TWinTraits>
+// CSortListViewCtrl
+// CTabViewImpl<T, TBase, TWinTraits>
+// CTabView
+
+namespace WTL
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// CBitmapButton - bitmap button implementation
+
+#ifndef _WIN32_WCE
+
+// bitmap button extended styles
+#define BMPBTN_HOVER            0x00000001
+#define BMPBTN_AUTO3D_SINGLE    0x00000002
+#define BMPBTN_AUTO3D_DOUBLE    0x00000004
+#define BMPBTN_AUTOSIZE         0x00000008
+#define BMPBTN_SHAREIMAGELISTS  0x00000010
+#define BMPBTN_AUTOFIRE         0x00000020
+
+template <class T, class TBase = CButton, class TWinTraits = ATL::CControlWinTraits>
+class ATL_NO_VTABLE CBitmapButtonImpl : public ATL::CWindowImpl< T, TBase, TWinTraits>
+{
+public:
+        DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
+
+        enum
+        {
+                _nImageNormal = 0,
+                _nImagePushed,
+                _nImageFocusOrHover,
+                _nImageDisabled,
+
+                _nImageCount = 4,
+        };
+
+        enum
+        {
+                ID_TIMER_FIRST = 1000,
+                ID_TIMER_REPEAT = 1001
+        };
+
+        // Bitmap button specific extended styles
+        DWORD m_dwExtendedStyle;
+
+        CImageList m_ImageList;
+        int m_nImage[_nImageCount];
+
+        CToolTipCtrl m_tip;
+        LPTSTR m_lpstrToolTipText;
+
+        // Internal states
+        unsigned m_fMouseOver:1;
+        unsigned m_fFocus:1;
+        unsigned m_fPressed:1;
+
+
+// Constructor/Destructor
+        CBitmapButtonImpl(DWORD dwExtendedStyle = BMPBTN_AUTOSIZE, HIMAGELIST hImageList = NULL) : 
+                        m_ImageList(hImageList), m_dwExtendedStyle(dwExtendedStyle), 
+                        m_lpstrToolTipText(NULL),
+                        m_fMouseOver(0), m_fFocus(0), m_fPressed(0)
+        {
+                m_nImage[_nImageNormal] = -1;
+                m_nImage[_nImagePushed] = -1;
+                m_nImage[_nImageFocusOrHover] = -1;
+                m_nImage[_nImageDisabled] = -1;
+        }
+
+        ~CBitmapButtonImpl()
+        {
+                if((m_dwExtendedStyle & BMPBTN_SHAREIMAGELISTS) == 0)
+                        m_ImageList.Destroy();
+                delete [] m_lpstrToolTipText;
+        }
+
+        // overridden to provide proper initialization
+        BOOL SubclassWindow(HWND hWnd)
+        {
+#if (_MSC_VER >= 1300)
+                BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits>::SubclassWindow(hWnd);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImpl< T, TBase, TWinTraits>   _baseClass;
+                BOOL bRet = _baseClass::SubclassWindow(hWnd);
+#endif // !(_MSC_VER >= 1300)
+                if(bRet)
+                        Init();
+                return bRet;
+        }
+
+// Attributes
+        DWORD GetBitmapButtonExtendedStyle() const
+        {
+                return m_dwExtendedStyle;
+        }
+
+        DWORD SetBitmapButtonExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
+        {
+                DWORD dwPrevStyle = m_dwExtendedStyle;
+                if(dwMask == 0)
+                        m_dwExtendedStyle = dwExtendedStyle;
+                else
+                        m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
+                return dwPrevStyle;
+        }
+
+        HIMAGELIST GetImageList() const
+        {
+                return m_ImageList;
+        }
+
+        HIMAGELIST SetImageList(HIMAGELIST hImageList)
+        {
+                HIMAGELIST hImageListPrev = m_ImageList;
+                m_ImageList = hImageList;
+                if((m_dwExtendedStyle & BMPBTN_AUTOSIZE) != 0 && ::IsWindow(m_hWnd))
+                        SizeToImage();
+                return hImageListPrev;
+        }
+
+        int GetToolTipTextLength() const
+        {
+                return (m_lpstrToolTipText == NULL) ? -1 : lstrlen(m_lpstrToolTipText);
+        }
+
+        bool GetToolTipText(LPTSTR lpstrText, int nLength) const
+        {
+                ATLASSERT(lpstrText != NULL);
+                if(m_lpstrToolTipText == NULL)
+                        return false;
+
+                errno_t nRet = SecureHelper::strncpy_x(lpstrText, nLength, m_lpstrToolTipText, _TRUNCATE);
+
+                return (nRet == 0 || nRet == STRUNCATE);
+        }
+
+        bool SetToolTipText(LPCTSTR lpstrText)
+        {
+                if(m_lpstrToolTipText != NULL)
+                {
+                        delete [] m_lpstrToolTipText;
+                        m_lpstrToolTipText = NULL;
+                }
+
+                if(lpstrText == NULL)
+                {
+                        if(m_tip.IsWindow())
+                                m_tip.Activate(FALSE);
+                        return true;
+                }
+
+                int cchLen = lstrlen(lpstrText) + 1;
+                ATLTRY(m_lpstrToolTipText = new TCHAR[cchLen]);
+                if(m_lpstrToolTipText == NULL)
+                        return false;
+
+                SecureHelper::strcpy_x(m_lpstrToolTipText, cchLen, lpstrText);
+                if(m_tip.IsWindow())
+                {
+                        m_tip.Activate(TRUE);
+                        m_tip.AddTool(m_hWnd, m_lpstrToolTipText);
+                }
+
+                return true;
+        }
+
+// Operations
+        void SetImages(int nNormal, int nPushed = -1, int nFocusOrHover = -1, int nDisabled = -1)
+        {
+                if(nNormal != -1)
+                        m_nImage[_nImageNormal] = nNormal;
+                if(nPushed != -1)
+                        m_nImage[_nImagePushed] = nPushed;
+                if(nFocusOrHover != -1)
+                        m_nImage[_nImageFocusOrHover] = nFocusOrHover;
+                if(nDisabled != -1)
+                        m_nImage[_nImageDisabled] = nDisabled;
+        }
+
+        BOOL SizeToImage()
+        {
+                ATLASSERT(::IsWindow(m_hWnd) && m_ImageList.m_hImageList != NULL);
+                int cx = 0;
+                int cy = 0;
+                if(!m_ImageList.GetIconSize(cx, cy))
+                        return FALSE;
+                return ResizeClient(cx, cy);
+        }
+
+// Overrideables
+        void DoPaint(CDCHandle dc)
+        {
+                ATLASSERT(m_ImageList.m_hImageList != NULL);   // image list must be set
+                ATLASSERT(m_nImage[0] != -1);                  // main bitmap must be set
+
+                // set bitmap according to the current button state
+                int nImage = -1;
+                bool bHover = IsHoverMode();
+                if(!IsWindowEnabled())
+                        nImage = m_nImage[_nImageDisabled];
+                else if(m_fPressed == 1)
+                        nImage = m_nImage[_nImagePushed];
+                else if((!bHover && m_fFocus == 1) || (bHover && m_fMouseOver == 1))
+                        nImage = m_nImage[_nImageFocusOrHover];
+                if(nImage == -1)   // not there, use default one
+                        nImage = m_nImage[_nImageNormal];
+
+                // draw the button image
+                int xyPos = 0;
+                if((m_fPressed == 1) && ((m_dwExtendedStyle & (BMPBTN_AUTO3D_SINGLE | BMPBTN_AUTO3D_DOUBLE)) != 0) && (m_nImage[_nImagePushed] == -1))
+                        xyPos = 1;
+                m_ImageList.Draw(dc, nImage, xyPos, xyPos, ILD_NORMAL);
+
+                // draw 3D border if required
+                if((m_dwExtendedStyle & (BMPBTN_AUTO3D_SINGLE | BMPBTN_AUTO3D_DOUBLE)) != 0)
+                {
+                        RECT rect;
+                        GetClientRect(&rect);
+
+                        if(m_fPressed == 1)
+                                dc.DrawEdge(&rect, ((m_dwExtendedStyle & BMPBTN_AUTO3D_SINGLE) != 0) ? BDR_SUNKENOUTER : EDGE_SUNKEN, BF_RECT);
+                        else if(!bHover || m_fMouseOver == 1)
+                                dc.DrawEdge(&rect, ((m_dwExtendedStyle & BMPBTN_AUTO3D_SINGLE) != 0) ? BDR_RAISEDINNER : EDGE_RAISED, BF_RECT);
+
+                        if(!bHover && m_fFocus == 1)
+                        {
+                                ::InflateRect(&rect, -2 * ::GetSystemMetrics(SM_CXEDGE), -2 * ::GetSystemMetrics(SM_CYEDGE));
+                                dc.DrawFocusRect(&rect);
+                        }
+                }
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CBitmapButtonImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+                MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+                MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseMessage)
+                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
+                MESSAGE_HANDLER(WM_PAINT, OnPaint)
+                MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
+                MESSAGE_HANDLER(WM_SETFOCUS, OnFocus)
+                MESSAGE_HANDLER(WM_KILLFOCUS, OnFocus)
+                MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
+                MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDblClk)
+                MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
+                MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
+                MESSAGE_HANDLER(WM_ENABLE, OnEnable)
+                MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
+                MESSAGE_HANDLER(WM_MOUSELEAVE, OnMouseLeave)
+                MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
+                MESSAGE_HANDLER(WM_KEYUP, OnKeyUp)
+                MESSAGE_HANDLER(WM_TIMER, OnTimer)
+                MESSAGE_HANDLER(WM_UPDATEUISTATE, OnUpdateUiState)
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                Init();
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(m_tip.IsWindow())
+                {
+                        m_tip.DestroyWindow();
+                        m_tip.m_hWnd = NULL;
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+        {
+                MSG msg = { m_hWnd, uMsg, wParam, lParam };
+                if(m_tip.IsWindow())
+                        m_tip.RelayEvent(&msg);
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return 1;   // no background needed
+        }
+
+        LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                if(wParam != NULL)
+                {
+                        pT->DoPaint((HDC)wParam);
+                }
+                else
+                {
+                        CPaintDC dc(m_hWnd);
+                        pT->DoPaint(dc.m_hDC);
+                }
+                return 0;
+        }
+
+        LRESULT OnFocus(UINT uMsg, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                m_fFocus = (uMsg == WM_SETFOCUS) ? 1 : 0;
+                Invalidate();
+                UpdateWindow();
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                LRESULT lRet = 0;
+                if(IsHoverMode())
+                        SetCapture();
+                else
+                        lRet = DefWindowProc(uMsg, wParam, lParam);
+                if(::GetCapture() == m_hWnd)
+                {
+                        m_fPressed = 1;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                if((m_dwExtendedStyle & BMPBTN_AUTOFIRE) != 0)
+                {
+                        int nElapse = 250;
+                        int nDelay = 0;
+                        if(::SystemParametersInfo(SPI_GETKEYBOARDDELAY, 0, &nDelay, 0))
+                                nElapse += nDelay * 250;   // all milli-seconds
+                        SetTimer(ID_TIMER_FIRST, nElapse);
+                }
+                return lRet;
+        }
+
+        LRESULT OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                LRESULT lRet = 0;
+                if(!IsHoverMode())
+                        lRet = DefWindowProc(uMsg, wParam, lParam);
+                if(::GetCapture() != m_hWnd)
+                        SetCapture();
+                if(m_fPressed == 0)
+                {
+                        m_fPressed = 1;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                return lRet;
+        }
+
+        LRESULT OnLButtonUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                LRESULT lRet = 0;
+                bool bHover = IsHoverMode();
+                if(!bHover)
+                        lRet = DefWindowProc(uMsg, wParam, lParam);
+                if(::GetCapture() == m_hWnd)
+                {
+                        if(bHover && m_fPressed == 1)
+                                ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
+                        ::ReleaseCapture();
+                }
+                return lRet;
+        }
+
+        LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(m_fPressed == 1)
+                {
+                        m_fPressed = 0;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnEnable(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                Invalidate();
+                UpdateWindow();
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                if(::GetCapture() == m_hWnd)
+                {
+                        POINT ptCursor = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                        ClientToScreen(&ptCursor);
+                        RECT rect = { 0 };
+                        GetWindowRect(&rect);
+                        unsigned int uPressed = ::PtInRect(&rect, ptCursor) ? 1 : 0;
+                        if(m_fPressed != uPressed)
+                        {
+                                m_fPressed = uPressed;
+                                Invalidate();
+                                UpdateWindow();
+                        }
+                }
+                else if(IsHoverMode() && m_fMouseOver == 0)
+                {
+                        m_fMouseOver = 1;
+                        Invalidate();
+                        UpdateWindow();
+                        StartTrackMouseLeave();
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnMouseLeave(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(m_fMouseOver == 1)
+                {
+                        m_fMouseOver = 0;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                return 0;
+        }
+
+        LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(wParam == VK_SPACE && IsHoverMode())
+                        return 0;   // ignore if in hover mode
+                if(wParam == VK_SPACE && m_fPressed == 0)
+                {
+                        m_fPressed = 1;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(wParam == VK_SPACE && IsHoverMode())
+                        return 0;   // ignore if in hover mode
+                if(wParam == VK_SPACE && m_fPressed == 1)
+                {
+                        m_fPressed = 0;
+                        Invalidate();
+                        UpdateWindow();
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnTimer(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                ATLASSERT((m_dwExtendedStyle & BMPBTN_AUTOFIRE) != 0);
+                switch(wParam)   // timer ID
+                {
+                case ID_TIMER_FIRST:
+                        KillTimer(ID_TIMER_FIRST);
+                        if(m_fPressed == 1)
+                        {
+                                ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
+                                int nElapse = 250;
+                                int nRepeat = 40;
+                                if(::SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &nRepeat, 0))
+                                        nElapse = 10000 / (10 * nRepeat + 25);   // milli-seconds, approximated
+                                SetTimer(ID_TIMER_REPEAT, nElapse);
+                        }
+                        break;
+                case ID_TIMER_REPEAT:
+                        if(m_fPressed == 1)
+                                ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
+                        else if(::GetCapture() != m_hWnd)
+                                KillTimer(ID_TIMER_REPEAT);
+                        break;
+                default:        // not our timer
+                        break;
+                }
+                return 0;
+        }
+
+        LRESULT OnUpdateUiState(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                // If the control is subclassed or superclassed, this message can cause
+                // repainting without WM_PAINT. We don't use this state, so just do nothing.
+                return 0;
+        }
+
+// Implementation
+        void Init()
+        {
+                // We need this style to prevent Windows from painting the button
+                ModifyStyle(0, BS_OWNERDRAW);
+
+                // create a tool tip
+                m_tip.Create(m_hWnd);
+                ATLASSERT(m_tip.IsWindow());
+                if(m_tip.IsWindow() && m_lpstrToolTipText != NULL)
+                {
+                        m_tip.Activate(TRUE);
+                        m_tip.AddTool(m_hWnd, m_lpstrToolTipText);
+                }
+
+                if(m_ImageList.m_hImageList != NULL && (m_dwExtendedStyle & BMPBTN_AUTOSIZE) != 0)
+                        SizeToImage();
+        }
+
+        BOOL StartTrackMouseLeave()
+        {
+                TRACKMOUSEEVENT tme = { 0 };
+                tme.cbSize = sizeof(tme);
+                tme.dwFlags = TME_LEAVE;
+                tme.hwndTrack = m_hWnd;
+                return _TrackMouseEvent(&tme);
+        }
+
+        bool IsHoverMode() const
+        {
+                return ((m_dwExtendedStyle & BMPBTN_HOVER) != 0);
+        }
+};
+
+
+class CBitmapButton : public CBitmapButtonImpl<CBitmapButton>
+{
+public:
+        DECLARE_WND_SUPERCLASS(_T("WTL_BitmapButton"), GetWndClassName())
+
+        CBitmapButton(DWORD dwExtendedStyle = BMPBTN_AUTOSIZE, HIMAGELIST hImageList = NULL) : 
+                CBitmapButtonImpl<CBitmapButton>(dwExtendedStyle, hImageList)
+        { }
+};
+
+#endif // !_WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CCheckListCtrlView - list view control with check boxes
+
+template <DWORD t_dwStyle, DWORD t_dwExStyle, DWORD t_dwExListViewStyle>
+class CCheckListViewCtrlImplTraits
+{
+public:
+        static DWORD GetWndStyle(DWORD dwStyle)
+        {
+                return (dwStyle == 0) ? t_dwStyle : dwStyle;
+        }
+
+        static DWORD GetWndExStyle(DWORD dwExStyle)
+        {
+                return (dwExStyle == 0) ? t_dwExStyle : dwExStyle;
+        }
+
+        static DWORD GetExtendedLVStyle()
+        {
+                return t_dwExListViewStyle;
+        }
+};
+
+typedef CCheckListViewCtrlImplTraits<WS_CHILD | WS_VISIBLE | LVS_REPORT | LVS_SHOWSELALWAYS, WS_EX_CLIENTEDGE, LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT>   CCheckListViewCtrlTraits;
+
+template <class T, class TBase = CListViewCtrl, class TWinTraits = CCheckListViewCtrlTraits>
+class ATL_NO_VTABLE CCheckListViewCtrlImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>
+{
+public:
+        DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
+
+// Attributes
+        static DWORD GetExtendedLVStyle()
+        {
+                return TWinTraits::GetExtendedLVStyle();
+        }
+
+// Operations
+        BOOL SubclassWindow(HWND hWnd)
+        {
+#if (_MSC_VER >= 1300)
+                BOOL bRet = ATL::CWindowImplBaseT< TBase, TWinTraits>::SubclassWindow(hWnd);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImplBaseT< TBase, TWinTraits>   _baseClass;
+                BOOL bRet = _baseClass::SubclassWindow(hWnd);
+#endif // !(_MSC_VER >= 1300)
+                if(bRet)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT;
+                        ATLASSERT((pT->GetExtendedLVStyle() & LVS_EX_CHECKBOXES) != 0);
+                        SetExtendedListViewStyle(pT->GetExtendedLVStyle());
+                }
+                return bRet;
+        }
+
+        void CheckSelectedItems(int nCurrItem)
+        {
+                // first check if this item is selected
+                LVITEM lvi = { 0 };
+                lvi.iItem = nCurrItem;
+                lvi.iSubItem = 0;
+                lvi.mask = LVIF_STATE;
+                lvi.stateMask = LVIS_SELECTED;
+                GetItem(&lvi);
+                // if item is not selected, don't do anything
+                if(!(lvi.state & LVIS_SELECTED))
+                        return;
+                // new check state will be reverse of the current state,
+                BOOL bCheck = !GetCheckState(nCurrItem);
+                int nItem = -1;
+                int nOldItem = -1;
+                while((nItem = GetNextItem(nOldItem, LVNI_SELECTED)) != -1)
+                {
+                        if(nItem != nCurrItem)
+                                SetCheckState(nItem, bCheck);
+                        nOldItem = nItem;
+                }
+        }
+
+// Implementation
+        BEGIN_MSG_MAP(CCheckListViewCtrlImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+                MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
+                MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDown)
+                MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                // first let list view control initialize everything
+                LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
+                T* pT = static_cast<T*>(this);
+                pT;
+                ATLASSERT((pT->GetExtendedLVStyle() & LVS_EX_CHECKBOXES) != 0);
+                SetExtendedListViewStyle(pT->GetExtendedLVStyle());
+                return lRet;
+        }
+
+        LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                POINT ptMsg = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                LVHITTESTINFO lvh = { 0 };
+                lvh.pt = ptMsg;
+                if(HitTest(&lvh) != -1 && lvh.flags == LVHT_ONITEMSTATEICON && ::GetKeyState(VK_CONTROL) >= 0)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->CheckSelectedItems(lvh.iItem);
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(wParam == VK_SPACE)
+                {
+                        int nCurrItem = GetNextItem(-1, LVNI_FOCUSED);
+                        if(nCurrItem != -1  && ::GetKeyState(VK_CONTROL) >= 0)
+                        {
+                                T* pT = static_cast<T*>(this);
+                                pT->CheckSelectedItems(nCurrItem);
+                        }
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+};
+
+class CCheckListViewCtrl : public CCheckListViewCtrlImpl<CCheckListViewCtrl>
+{
+public:
+        DECLARE_WND_SUPERCLASS(_T("WTL_CheckListView"), GetWndClassName())
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CHyperLink - hyper link control implementation
+
+#if (WINVER < 0x0500) && !defined(_WIN32_WCE)
+__declspec(selectany) struct
+{
+        enum { cxWidth = 32, cyHeight = 32 };
+        int xHotSpot;
+        int yHotSpot;
+        unsigned char arrANDPlane[cxWidth * cyHeight / 8];
+        unsigned char arrXORPlane[cxWidth * cyHeight / 8];
+} _AtlHyperLink_CursorData = 
+{
+        5, 0, 
+        {
+                0xF9, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 
+                0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0x3F, 0xFF, 0xFF, 0xF0, 0x07, 0xFF, 0xFF, 0xF0, 0x01, 0xFF, 0xFF, 
+                0xF0, 0x00, 0xFF, 0xFF, 0x10, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 
+                0x80, 0x00, 0x7F, 0xFF, 0xC0, 0x00, 0x7F, 0xFF, 0xC0, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x7F, 0xFF, 
+                0xE0, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0xF8, 0x01, 0xFF, 0xFF, 
+                0xF8, 0x01, 0xFF, 0xFF, 0xF8, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+        },
+        {
+                0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 
+                0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0xC0, 0x00, 0x00, 0x06, 0xD8, 0x00, 0x00, 
+                0x06, 0xDA, 0x00, 0x00, 0x06, 0xDB, 0x00, 0x00, 0x67, 0xFB, 0x00, 0x00, 0x77, 0xFF, 0x00, 0x00, 
+                0x37, 0xFF, 0x00, 0x00, 0x17, 0xFF, 0x00, 0x00, 0x1F, 0xFF, 0x00, 0x00, 0x0F, 0xFF, 0x00, 0x00, 
+                0x0F, 0xFE, 0x00, 0x00, 0x07, 0xFE, 0x00, 0x00, 0x07, 0xFE, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00, 
+                0x03, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+        }
+};
+#endif // (WINVER < 0x0500) && !defined(_WIN32_WCE)
+
+#define HLINK_UNDERLINED      0x00000000
+#define HLINK_NOTUNDERLINED   0x00000001
+#define HLINK_UNDERLINEHOVER  0x00000002
+#define HLINK_COMMANDBUTTON   0x00000004
+#define HLINK_NOTIFYBUTTON    0x0000000C
+#define HLINK_USETAGS         0x00000010
+#define HLINK_USETAGSBOLD     0x00000030
+#define HLINK_NOTOOLTIP       0x00000040
+
+// Notes:
+// - HLINK_USETAGS and HLINK_USETAGSBOLD are always left-aligned
+// - When HLINK_USETAGSBOLD is used, the underlined styles will be ignored
+
+template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
+class ATL_NO_VTABLE CHyperLinkImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >
+{
+public:
+        LPTSTR m_lpstrLabel;
+        LPTSTR m_lpstrHyperLink;
+
+        HCURSOR m_hCursor;
+        HFONT m_hFont;
+        HFONT m_hFontNormal;
+
+        RECT m_rcLink;
+#ifndef _WIN32_WCE
+        CToolTipCtrl m_tip;
+#endif // !_WIN32_WCE
+
+        COLORREF m_clrLink;
+        COLORREF m_clrVisited;
+
+        DWORD m_dwExtendedStyle;   // Hyper Link specific extended styles
+
+        bool m_bPaintLabel:1;
+        bool m_bVisited:1;
+        bool m_bHover:1;
+        bool m_bInternalLinkFont:1;
+
+
+// Constructor/Destructor
+        CHyperLinkImpl(DWORD dwExtendedStyle = HLINK_UNDERLINED) : 
+                        m_lpstrLabel(NULL), m_lpstrHyperLink(NULL),
+                        m_hCursor(NULL), m_hFont(NULL), m_hFontNormal(NULL),
+                        m_clrLink(RGB(0, 0, 255)), m_clrVisited(RGB(128, 0, 128)),
+                        m_dwExtendedStyle(dwExtendedStyle),
+                        m_bPaintLabel(true), m_bVisited(false),
+                        m_bHover(false), m_bInternalLinkFont(false)
+        {
+                ::SetRectEmpty(&m_rcLink);
+        }
+
+        ~CHyperLinkImpl()
+        {
+                delete [] m_lpstrLabel;
+                delete [] m_lpstrHyperLink;
+                if(m_bInternalLinkFont && m_hFont != NULL)
+                        ::DeleteObject(m_hFont);
+#if (WINVER < 0x0500) && !defined(_WIN32_WCE)
+                // It was created, not loaded, so we have to destroy it
+                if(m_hCursor != NULL)
+                        ::DestroyCursor(m_hCursor);
+#endif // (WINVER < 0x0500) && !defined(_WIN32_WCE)
+        }
+
+// Attributes
+        DWORD GetHyperLinkExtendedStyle() const
+        {
+                return m_dwExtendedStyle;
+        }
+
+        DWORD SetHyperLinkExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
+        {
+                DWORD dwPrevStyle = m_dwExtendedStyle;
+                if(dwMask == 0)
+                        m_dwExtendedStyle = dwExtendedStyle;
+                else
+                        m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
+                return dwPrevStyle;
+        }
+
+        bool GetLabel(LPTSTR lpstrBuffer, int nLength) const
+        {
+                if(m_lpstrLabel == NULL)
+                        return false;
+                ATLASSERT(lpstrBuffer != NULL);
+                if(nLength <= lstrlen(m_lpstrLabel))
+                        return false;
+
+                SecureHelper::strcpy_x(lpstrBuffer, nLength, m_lpstrLabel);
+
+                return true;
+        }
+
+        bool SetLabel(LPCTSTR lpstrLabel)
+        {
+                delete [] m_lpstrLabel;
+                m_lpstrLabel = NULL;
+                int cchLen = lstrlen(lpstrLabel) + 1;
+                ATLTRY(m_lpstrLabel = new TCHAR[cchLen]);
+                if(m_lpstrLabel == NULL)
+                        return false;
+
+                SecureHelper::strcpy_x(m_lpstrLabel, cchLen, lpstrLabel);
+                T* pT = static_cast<T*>(this);
+                pT->CalcLabelRect();
+
+                if(m_hWnd != NULL)
+                        SetWindowText(lpstrLabel);   // Set this for accessibility
+
+                return true;
+        }
+
+        bool GetHyperLink(LPTSTR lpstrBuffer, int nLength) const
+        {
+                if(m_lpstrHyperLink == NULL)
+                        return false;
+                ATLASSERT(lpstrBuffer != NULL);
+                if(nLength <= lstrlen(m_lpstrHyperLink))
+                        return false;
+
+                SecureHelper::strcpy_x(lpstrBuffer, nLength, m_lpstrHyperLink);
+
+                return true;
+        }
+
+        bool SetHyperLink(LPCTSTR lpstrLink)
+        {
+                delete [] m_lpstrHyperLink;
+                m_lpstrHyperLink = NULL;
+                int cchLen = lstrlen(lpstrLink) + 1;
+                ATLTRY(m_lpstrHyperLink = new TCHAR[cchLen]);
+                if(m_lpstrHyperLink == NULL)
+                        return false;
+
+                SecureHelper::strcpy_x(m_lpstrHyperLink, cchLen, lpstrLink);
+                if(m_lpstrLabel == NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->CalcLabelRect();
+                }
+#ifndef _WIN32_WCE
+                if(m_tip.IsWindow())
+                {
+                        m_tip.Activate(TRUE);
+                        m_tip.AddTool(m_hWnd, m_lpstrHyperLink, &m_rcLink, 1);
+                }
+#endif // !_WIN32_WCE
+                return true;
+        }
+
+        HFONT GetLinkFont() const
+        {
+                return m_hFont;
+        }
+
+        void SetLinkFont(HFONT hFont)
+        {
+                if(m_bInternalLinkFont && m_hFont != NULL)
+                {
+                        ::DeleteObject(m_hFont);
+                        m_bInternalLinkFont = false;
+                }
+                m_hFont = hFont;
+        }
+
+        int GetIdealHeight() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
+                        return -1;
+                if(!m_bPaintLabel)
+                        return -1;
+
+                CClientDC dc(m_hWnd);
+                RECT rect = { 0 };
+                GetClientRect(&rect);
+                HFONT hFontOld = dc.SelectFont(m_hFontNormal);
+                RECT rcText = rect;
+                dc.DrawText(_T("NS"), -1, &rcText, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+                dc.SelectFont(m_hFont);
+                RECT rcLink = rect;
+                dc.DrawText(_T("NS"), -1, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+                dc.SelectFont(hFontOld);
+                return __max(rcText.bottom - rcText.top, rcLink.bottom - rcLink.top);
+        }
+
+        bool GetIdealSize(SIZE& size) const
+        {
+                int cx = 0, cy = 0;
+                bool bRet = GetIdealSize(cx, cy);
+                if(bRet)
+                {
+                        size.cx = cx;
+                        size.cy = cy;
+                }
+                return bRet;
+        }
+
+        bool GetIdealSize(int& cx, int& cy) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
+                        return false;
+                if(!m_bPaintLabel)
+                        return false;
+
+                CClientDC dc(m_hWnd);
+                RECT rcClient = { 0 };
+                GetClientRect(&rcClient);
+                RECT rcAll = rcClient;
+
+                if(IsUsingTags())
+                {
+                        // find tags and label parts
+                        LPTSTR lpstrLeft = NULL;
+                        int cchLeft = 0;
+                        LPTSTR lpstrLink = NULL;
+                        int cchLink = 0;
+                        LPTSTR lpstrRight = NULL;
+                        int cchRight = 0;
+
+                        const T* pT = static_cast<const T*>(this);
+                        pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
+
+                        // get label part rects
+                        HFONT hFontOld = dc.SelectFont(m_hFontNormal);
+                        RECT rcLeft = rcClient;
+                        dc.DrawText(lpstrLeft, cchLeft, &rcLeft, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+
+                        dc.SelectFont(m_hFont);
+                        RECT rcLink = { rcLeft.right, rcLeft.top, rcClient.right, rcClient.bottom };
+                        dc.DrawText(lpstrLink, cchLink, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+
+                        dc.SelectFont(m_hFontNormal);
+                        RECT rcRight = { rcLink.right, rcLink.top, rcClient.right, rcClient.bottom };
+                        dc.DrawText(lpstrRight, cchRight, &rcRight, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+
+                        dc.SelectFont(hFontOld);
+
+                        int cyMax = __max(rcLeft.bottom, max(rcLink.bottom, rcRight.bottom));
+                        ::SetRect(&rcAll, rcLeft.left, rcLeft.top, rcRight.right, cyMax);
+                }
+                else
+                {
+                        HFONT hOldFont = NULL;
+                        if(m_hFont != NULL)
+                                hOldFont = dc.SelectFont(m_hFont);
+                        LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
+                        DWORD dwStyle = GetStyle();
+                        int nDrawStyle = DT_LEFT;
+                        if (dwStyle & SS_CENTER)
+                                nDrawStyle = DT_CENTER;
+                        else if (dwStyle & SS_RIGHT)
+                                nDrawStyle = DT_RIGHT;
+                        dc.DrawText(lpstrText, -1, &rcAll, nDrawStyle | DT_WORDBREAK | DT_CALCRECT);
+                        if(m_hFont != NULL)
+                                dc.SelectFont(hOldFont);
+                        if (dwStyle & SS_CENTER)
+                        {
+                                int dx = (rcClient.right - rcAll.right) / 2;
+                                ::OffsetRect(&rcAll, dx, 0);
+                        }
+                        else if (dwStyle & SS_RIGHT)
+                        {
+                                int dx = rcClient.right - rcAll.right;
+                                ::OffsetRect(&rcAll, dx, 0);
+                        }
+                }
+
+                cx = rcAll.right - rcAll.left;
+                cy = rcAll.bottom - rcAll.top;
+
+                return true;
+        }
+
+        // for command buttons only
+        bool GetToolTipText(LPTSTR lpstrBuffer, int nLength) const
+        {
+                ATLASSERT(IsCommandButton());
+                return GetHyperLink(lpstrBuffer, nLength);
+        }
+
+        bool SetToolTipText(LPCTSTR lpstrToolTipText)
+        {
+                ATLASSERT(IsCommandButton());
+                return SetHyperLink(lpstrToolTipText);
+        }
+
+// Operations
+        BOOL SubclassWindow(HWND hWnd)
+        {
+                ATLASSERT(m_hWnd == NULL);
+                ATLASSERT(::IsWindow(hWnd));
+#if (_MSC_VER >= 1300)
+                BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits>::SubclassWindow(hWnd);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImpl< T, TBase, TWinTraits>   _baseClass;
+                BOOL bRet = _baseClass::SubclassWindow(hWnd);
+#endif // !(_MSC_VER >= 1300)
+                if(bRet)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->Init();
+                }
+                return bRet;
+        }
+
+        bool Navigate()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                bool bRet = true;
+                if(IsNotifyButton())
+                {
+                        NMHDR nmhdr = { m_hWnd, GetDlgCtrlID(), NM_CLICK };
+                        ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nmhdr);
+                }
+                else if(IsCommandButton())
+                {
+                        ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
+                }
+                else
+                {
+                        ATLASSERT(m_lpstrHyperLink != NULL);
+#ifndef _WIN32_WCE
+                        DWORD_PTR dwRet = (DWORD_PTR)::ShellExecute(0, _T("open"), m_lpstrHyperLink, 0, 0, SW_SHOWNORMAL);
+                        bRet = (dwRet > 32);
+#else // CE specific
+                        SHELLEXECUTEINFO shExeInfo = { sizeof(SHELLEXECUTEINFO), 0, 0, L"open", m_lpstrHyperLink, 0, 0, SW_SHOWNORMAL, 0, 0, 0, 0, 0, 0, 0 };
+                        ::ShellExecuteEx(&shExeInfo);
+                        DWORD_PTR dwRet = (DWORD_PTR)shExeInfo.hInstApp;
+                        bRet = (dwRet == 0) || (dwRet > 32);
+#endif // _WIN32_WCE
+                        ATLASSERT(bRet);
+                        if(bRet)
+                        {
+                                m_bVisited = true;
+                                Invalidate();
+                        }
+                }
+                return bRet;
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CHyperLinkImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+                MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseMessage)
+#endif // !_WIN32_WCE
+                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
+                MESSAGE_HANDLER(WM_PAINT, OnPaint)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
+#endif // !_WIN32_WCE
+                MESSAGE_HANDLER(WM_SETFOCUS, OnFocus)
+                MESSAGE_HANDLER(WM_KILLFOCUS, OnFocus)
+                MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_MOUSELEAVE, OnMouseLeave)
+#endif // !_WIN32_WCE
+                MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
+                MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
+                MESSAGE_HANDLER(WM_CHAR, OnChar)
+                MESSAGE_HANDLER(WM_GETDLGCODE, OnGetDlgCode)
+                MESSAGE_HANDLER(WM_SETCURSOR, OnSetCursor)
+                MESSAGE_HANDLER(WM_ENABLE, OnEnable)
+                MESSAGE_HANDLER(WM_GETFONT, OnGetFont)
+                MESSAGE_HANDLER(WM_SETFONT, OnSetFont)
+                MESSAGE_HANDLER(WM_UPDATEUISTATE, OnUpdateUiState)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->Init();
+                return 0;
+        }
+
+#ifndef _WIN32_WCE
+        LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(m_tip.IsWindow())
+                {
+                        m_tip.DestroyWindow();
+                        m_tip.m_hWnd = NULL;
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+        {
+                MSG msg = { m_hWnd, uMsg, wParam, lParam };
+                if(m_tip.IsWindow() && IsUsingToolTip())
+                        m_tip.RelayEvent(&msg);
+                bHandled = FALSE;
+                return 1;
+        }
+#endif // !_WIN32_WCE
+
+        LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return 1;   // no background painting needed (we do it all during WM_PAINT)
+        }
+
+        LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(!m_bPaintLabel)
+                {
+                        bHandled = FALSE;
+                        return 1;
+                }
+
+                T* pT = static_cast<T*>(this);
+                if(wParam != NULL)
+                {
+                        pT->DoEraseBackground((HDC)wParam);
+                        pT->DoPaint((HDC)wParam);
+                }
+                else
+                {
+                        CPaintDC dc(m_hWnd);
+                        pT->DoEraseBackground(dc.m_hDC);
+                        pT->DoPaint(dc.m_hDC);
+                }
+
+                return 0;
+        }
+
+        LRESULT OnFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(m_bPaintLabel)
+                        Invalidate();
+                else
+                        bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                if((m_lpstrHyperLink != NULL  || IsCommandButton()) && ::PtInRect(&m_rcLink, pt))
+                {
+                        ::SetCursor(m_hCursor);
+                        if(IsUnderlineHover())
+                        {
+                                if(!m_bHover)
+                                {
+                                        m_bHover = true;
+                                        InvalidateRect(&m_rcLink);
+                                        UpdateWindow();
+#ifndef _WIN32_WCE
+                                        StartTrackMouseLeave();
+#endif // !_WIN32_WCE
+                                }
+                        }
+                }
+                else
+                {
+                        if(IsUnderlineHover())
+                        {
+                                if(m_bHover)
+                                {
+                                        m_bHover = false;
+                                        InvalidateRect(&m_rcLink);
+                                        UpdateWindow();
+                                }
+                        }
+                        bHandled = FALSE;
+                }
+                return 0;
+        }
+
+#ifndef _WIN32_WCE
+        LRESULT OnMouseLeave(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(IsUnderlineHover() && m_bHover)
+                {
+                        m_bHover = false;
+                        InvalidateRect(&m_rcLink);
+                        UpdateWindow();
+                }
+                return 0;
+        }
+#endif // !_WIN32_WCE
+
+        LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                if(::PtInRect(&m_rcLink, pt))
+                {
+                        SetFocus();
+                        SetCapture();
+                }
+                return 0;
+        }
+
+        LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                if(GetCapture() == m_hWnd)
+                {
+                        ReleaseCapture();
+                        POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                        if(::PtInRect(&m_rcLink, pt))
+                        {
+                                T* pT = static_cast<T*>(this);
+                                pT->Navigate();
+                        }
+                }
+                return 0;
+        }
+
+        LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(wParam == VK_RETURN || wParam == VK_SPACE)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->Navigate();
+                }
+                return 0;
+        }
+
+        LRESULT OnGetDlgCode(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return DLGC_WANTCHARS;
+        }
+
+        LRESULT OnSetCursor(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                POINT pt = { 0, 0 };
+                GetCursorPos(&pt);
+                ScreenToClient(&pt);
+                if((m_lpstrHyperLink != NULL  || IsCommandButton()) && ::PtInRect(&m_rcLink, pt))
+                {
+                        return TRUE;
+                }
+                bHandled = FALSE;
+                return FALSE;
+        }
+
+        LRESULT OnEnable(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                Invalidate();
+                UpdateWindow();
+                return 0;
+        }
+
+        LRESULT OnGetFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return (LRESULT)m_hFontNormal;
+        }
+
+        LRESULT OnSetFont(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                m_hFontNormal = (HFONT)wParam;
+                if((BOOL)lParam)
+                {
+                        Invalidate();
+                        UpdateWindow();
+                }
+                return 0;
+        }
+
+        LRESULT OnUpdateUiState(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                // If the control is subclassed or superclassed, this message can cause
+                // repainting without WM_PAINT. We don't use this state, so just do nothing.
+                return 0;
+        }
+
+        LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->CalcLabelRect();
+                pT->Invalidate();
+                return 0;
+        }
+
+// Implementation
+        void Init()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+
+                // Check if we should paint a label
+                const int cchBuff = 8;
+                TCHAR szBuffer[cchBuff] = { 0 };
+                if(::GetClassName(m_hWnd, szBuffer, cchBuff))
+                {
+                        if(lstrcmpi(szBuffer, _T("static")) == 0)
+                        {
+                                ModifyStyle(0, SS_NOTIFY);   // we need this
+                                DWORD dwStyle = GetStyle() & 0x000000FF;
+#ifndef _WIN32_WCE
+                                if(dwStyle == SS_ICON || dwStyle == SS_BLACKRECT || dwStyle == SS_GRAYRECT || 
+                                                dwStyle == SS_WHITERECT || dwStyle == SS_BLACKFRAME || dwStyle == SS_GRAYFRAME || 
+                                                dwStyle == SS_WHITEFRAME || dwStyle == SS_OWNERDRAW || 
+                                                dwStyle == SS_BITMAP || dwStyle == SS_ENHMETAFILE)
+#else // CE specific
+                                if(dwStyle == SS_ICON || dwStyle == SS_BITMAP)
+#endif // _WIN32_WCE
+                                        m_bPaintLabel = false;
+                        }
+                }
+
+                // create or load a cursor
+#if (WINVER >= 0x0500) || defined(_WIN32_WCE)
+                m_hCursor = ::LoadCursor(NULL, IDC_HAND);
+#else
+                m_hCursor = ::CreateCursor(ModuleHelper::GetModuleInstance(), _AtlHyperLink_CursorData.xHotSpot, _AtlHyperLink_CursorData.yHotSpot, _AtlHyperLink_CursorData.cxWidth, _AtlHyperLink_CursorData.cyHeight, _AtlHyperLink_CursorData.arrANDPlane, _AtlHyperLink_CursorData.arrXORPlane);
+#endif
+                ATLASSERT(m_hCursor != NULL);
+
+                // set font
+                if(m_bPaintLabel)
+                {
+                        ATL::CWindow wnd = GetParent();
+                        m_hFontNormal = wnd.GetFont();
+                        if(m_hFontNormal == NULL)
+                                m_hFontNormal = (HFONT)::GetStockObject(SYSTEM_FONT);
+                        if(m_hFontNormal != NULL && m_hFont == NULL)
+                        {
+                                LOGFONT lf = { 0 };
+                                CFontHandle font = m_hFontNormal;
+                                font.GetLogFont(&lf);
+                                if(IsUsingTagsBold())
+                                        lf.lfWeight = FW_BOLD;
+                                else if(!IsNotUnderlined())
+                                        lf.lfUnderline = TRUE;
+                                m_hFont = ::CreateFontIndirect(&lf);
+                                m_bInternalLinkFont = true;
+                                ATLASSERT(m_hFont != NULL);
+                        }
+                }
+
+#ifndef _WIN32_WCE
+                // create a tool tip
+                m_tip.Create(m_hWnd);
+                ATLASSERT(m_tip.IsWindow());
+#endif // !_WIN32_WCE
+
+                // set label (defaults to window text)
+                if(m_lpstrLabel == NULL)
+                {
+                        int nLen = GetWindowTextLength();
+                        if(nLen > 0)
+                        {
+                                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                                LPTSTR lpstrText = buff.Allocate(nLen + 1);
+                                ATLASSERT(lpstrText != NULL);
+                                if((lpstrText != NULL) && (GetWindowText(lpstrText, nLen + 1) > 0))
+                                        SetLabel(lpstrText);
+                        }
+                }
+
+                T* pT = static_cast<T*>(this);
+                pT->CalcLabelRect();
+
+                // set hyperlink (defaults to label), or just activate tool tip if already set
+                if(m_lpstrHyperLink == NULL && !IsCommandButton())
+                {
+                        if(m_lpstrLabel != NULL)
+                                SetHyperLink(m_lpstrLabel);
+                }
+#ifndef _WIN32_WCE
+                else
+                {
+                        m_tip.Activate(TRUE);
+                        m_tip.AddTool(m_hWnd, m_lpstrHyperLink, &m_rcLink, 1);
+                }
+#endif // !_WIN32_WCE
+
+                // set link colors
+                if(m_bPaintLabel)
+                {
+                        ATL::CRegKey rk;
+                        LONG lRet = rk.Open(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Internet Explorer\\Settings"));
+                        if(lRet == 0)
+                        {
+                                const int cchValue = 12;
+                                TCHAR szValue[cchValue] = { 0 };
+#if (_ATL_VER >= 0x0700)
+                                ULONG ulCount = cchValue;
+                                lRet = rk.QueryStringValue(_T("Anchor Color"), szValue, &ulCount);
+#else
+                                DWORD dwCount = cchValue * sizeof(TCHAR);
+                                lRet = rk.QueryValue(szValue, _T("Anchor Color"), &dwCount);
+#endif
+                                if(lRet == 0)
+                                {
+                                        COLORREF clr = pT->_ParseColorString(szValue);
+                                        ATLASSERT(clr != CLR_INVALID);
+                                        if(clr != CLR_INVALID)
+                                                m_clrLink = clr;
+                                }
+
+#if (_ATL_VER >= 0x0700)
+                                ulCount = cchValue;
+                                lRet = rk.QueryStringValue(_T("Anchor Color Visited"), szValue, &ulCount);
+#else
+                                dwCount = cchValue * sizeof(TCHAR);
+                                lRet = rk.QueryValue(szValue, _T("Anchor Color Visited"), &dwCount);
+#endif
+                                if(lRet == 0)
+                                {
+                                        COLORREF clr = pT->_ParseColorString(szValue);
+                                        ATLASSERT(clr != CLR_INVALID);
+                                        if(clr != CLR_INVALID)
+                                                m_clrVisited = clr;
+                                }
+                        }
+                }
+        }
+
+        static COLORREF _ParseColorString(LPTSTR lpstr)
+        {
+                int c[3] = { -1, -1, -1 };
+                LPTSTR p = NULL;
+                for(int i = 0; i < 2; i++)
+                {
+                        for(p = lpstr; *p != _T('\0'); p = ::CharNext(p))
+                        {
+                                if(*p == _T(','))
+                                {
+                                        *p = _T('\0');
+                                        c[i] = T::_xttoi(lpstr);
+                                        lpstr = &p[1];
+                                        break;
+                                }
+                        }
+                        if(c[i] == -1)
+                                return CLR_INVALID;
+                }
+                if(*lpstr == _T('\0'))
+                        return CLR_INVALID;
+                c[2] = T::_xttoi(lpstr);
+
+                return RGB(c[0], c[1], c[2]);
+        }
+
+        bool CalcLabelRect()
+        {
+                if(!::IsWindow(m_hWnd))
+                        return false;
+                if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
+                        return false;
+
+                CClientDC dc(m_hWnd);
+                RECT rcClient = { 0 };
+                GetClientRect(&rcClient);
+                m_rcLink = rcClient;
+                if(!m_bPaintLabel)
+                        return true;
+
+                if(IsUsingTags())
+                {
+                        // find tags and label parts
+                        LPTSTR lpstrLeft = NULL;
+                        int cchLeft = 0;
+                        LPTSTR lpstrLink = NULL;
+                        int cchLink = 0;
+                        LPTSTR lpstrRight = NULL;
+                        int cchRight = 0;
+
+                        T* pT = static_cast<T*>(this);
+                        pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
+                        ATLASSERT(lpstrLink != NULL);
+                        ATLASSERT(cchLink > 0);
+
+                        // get label part rects
+                        HFONT hFontOld = dc.SelectFont(m_hFontNormal);
+
+                        RECT rcLeft = rcClient;
+                        if(lpstrLeft != NULL)
+                                dc.DrawText(lpstrLeft, cchLeft, &rcLeft, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+
+                        dc.SelectFont(m_hFont);
+                        RECT rcLink = rcClient;
+                        if(lpstrLeft != NULL)
+                                rcLink.left = rcLeft.right;
+                        dc.DrawText(lpstrLink, cchLink, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
+
+                        dc.SelectFont(hFontOld);
+
+                        m_rcLink = rcLink;
+                }
+                else
+                {
+                        HFONT hOldFont = NULL;
+                        if(m_hFont != NULL)
+                                hOldFont = dc.SelectFont(m_hFont);
+                        LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
+                        DWORD dwStyle = GetStyle();
+                        int nDrawStyle = DT_LEFT;
+                        if (dwStyle & SS_CENTER)
+                                nDrawStyle = DT_CENTER;
+                        else if (dwStyle & SS_RIGHT)
+                                nDrawStyle = DT_RIGHT;
+                        dc.DrawText(lpstrText, -1, &m_rcLink, nDrawStyle | DT_WORDBREAK | DT_CALCRECT);
+                        if(m_hFont != NULL)
+                                dc.SelectFont(hOldFont);
+                        if (dwStyle & SS_CENTER)
+                        {
+                                int dx = (rcClient.right - m_rcLink.right) / 2;
+                                ::OffsetRect(&m_rcLink, dx, 0);
+                        }
+                        else if (dwStyle & SS_RIGHT)
+                        {
+                                int dx = rcClient.right - m_rcLink.right;
+                                ::OffsetRect(&m_rcLink, dx, 0);
+                        }
+                }
+
+                return true;
+        }
+
+        void CalcLabelParts(LPTSTR& lpstrLeft, int& cchLeft, LPTSTR& lpstrLink, int& cchLink, LPTSTR& lpstrRight, int& cchRight) const
+        {
+                lpstrLeft = NULL;
+                cchLeft = 0;
+                lpstrLink = NULL;
+                cchLink = 0;
+                lpstrRight = NULL;
+                cchRight = 0;
+
+                LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
+                int cchText = lstrlen(lpstrText);
+                bool bOutsideLink = true;
+                for(int i = 0; i < cchText; i++)
+                {
+                        if(lpstrText[i] != _T('<'))
+                                continue;
+
+                        if(bOutsideLink)
+                        {
+                                if(::CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, &lpstrText[i], 3, _T("<A>"), 3) == CSTR_EQUAL)
+                                {
+                                        if(i > 0)
+                                        {
+                                                lpstrLeft = lpstrText;
+                                                cchLeft = i;
+                                        }
+                                        lpstrLink = &lpstrText[i + 3];
+                                        bOutsideLink = false;
+                                }
+                        }
+                        else
+                        {
+                                if(::CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, &lpstrText[i], 4, _T("</A>"), 4) == CSTR_EQUAL)
+                                {
+                                        cchLink = i - 3 - cchLeft;
+                                        if(lpstrText[i + 4] != 0)
+                                        {
+                                                lpstrRight = &lpstrText[i + 4];
+                                                cchRight = cchText - (i + 4);
+                                                break;
+                                        }
+                                }
+                        }
+                }
+
+        }
+
+        void DoEraseBackground(CDCHandle dc)
+        {
+                HBRUSH hBrush = (HBRUSH)::SendMessage(GetParent(), WM_CTLCOLORSTATIC, (WPARAM)dc.m_hDC, (LPARAM)m_hWnd);
+                if(hBrush != NULL)
+                {
+                        RECT rect = { 0 };
+                        GetClientRect(&rect);
+                        dc.FillRect(&rect, hBrush);
+                }
+        }
+
+        void DoPaint(CDCHandle dc)
+        {
+                if(IsUsingTags())
+                {
+                        // find tags and label parts
+                        LPTSTR lpstrLeft = NULL;
+                        int cchLeft = 0;
+                        LPTSTR lpstrLink = NULL;
+                        int cchLink = 0;
+                        LPTSTR lpstrRight = NULL;
+                        int cchRight = 0;
+
+                        T* pT = static_cast<T*>(this);
+                        pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
+
+                        // get label part rects
+                        RECT rcClient = { 0 };
+                        GetClientRect(&rcClient);
+
+                        dc.SetBkMode(TRANSPARENT);
+                        HFONT hFontOld = dc.SelectFont(m_hFontNormal);
+
+                        if(lpstrLeft != NULL)
+                                dc.DrawText(lpstrLeft, cchLeft, &rcClient, DT_LEFT | DT_WORDBREAK);
+
+                        COLORREF clrOld = dc.SetTextColor(IsWindowEnabled() ? (m_bVisited ? m_clrVisited : m_clrLink) : (::GetSysColor(COLOR_GRAYTEXT)));
+                        if(m_hFont != NULL && (!IsUnderlineHover() || (IsUnderlineHover() && m_bHover)))
+                                dc.SelectFont(m_hFont);
+                        else
+                                dc.SelectFont(m_hFontNormal);
+
+                        dc.DrawText(lpstrLink, cchLink, &m_rcLink, DT_LEFT | DT_WORDBREAK);
+
+                        dc.SetTextColor(clrOld);
+                        dc.SelectFont(m_hFontNormal);
+                        if(lpstrRight != NULL)
+                        {
+                                RECT rcRight = { m_rcLink.right, m_rcLink.top, rcClient.right, rcClient.bottom };
+                                dc.DrawText(lpstrRight, cchRight, &rcRight, DT_LEFT | DT_WORDBREAK);
+                        }
+
+                        if(GetFocus() == m_hWnd)
+                                dc.DrawFocusRect(&m_rcLink);
+
+                        dc.SelectFont(hFontOld);
+                }
+                else
+                {
+                        dc.SetBkMode(TRANSPARENT);
+                        COLORREF clrOld = dc.SetTextColor(IsWindowEnabled() ? (m_bVisited ? m_clrVisited : m_clrLink) : (::GetSysColor(COLOR_GRAYTEXT)));
+
+                        HFONT hFontOld = NULL;
+                        if(m_hFont != NULL && (!IsUnderlineHover() || (IsUnderlineHover() && m_bHover)))
+                                hFontOld = dc.SelectFont(m_hFont);
+                        else
+                                hFontOld = dc.SelectFont(m_hFontNormal);
+
+                        LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
+
+                        DWORD dwStyle = GetStyle();
+                        int nDrawStyle = DT_LEFT;
+                        if (dwStyle & SS_CENTER)
+                                nDrawStyle = DT_CENTER;
+                        else if (dwStyle & SS_RIGHT)
+                                nDrawStyle = DT_RIGHT;
+
+                        dc.DrawText(lpstrText, -1, &m_rcLink, nDrawStyle | DT_WORDBREAK);
+
+                        if(GetFocus() == m_hWnd)
+                                dc.DrawFocusRect(&m_rcLink);
+
+                        dc.SetTextColor(clrOld);
+                        dc.SelectFont(hFontOld);
+                }
+        }
+
+#ifndef _WIN32_WCE
+        BOOL StartTrackMouseLeave()
+        {
+                TRACKMOUSEEVENT tme = { 0 };
+                tme.cbSize = sizeof(tme);
+                tme.dwFlags = TME_LEAVE;
+                tme.hwndTrack = m_hWnd;
+                return _TrackMouseEvent(&tme);
+        }
+#endif // !_WIN32_WCE
+
+// Implementation helpers
+        bool IsUnderlined() const
+        {
+                return ((m_dwExtendedStyle & (HLINK_NOTUNDERLINED | HLINK_UNDERLINEHOVER)) == 0);
+        }
+
+        bool IsNotUnderlined() const
+        {
+                return ((m_dwExtendedStyle & HLINK_NOTUNDERLINED) != 0);
+        }
+
+        bool IsUnderlineHover() const
+        {
+                return ((m_dwExtendedStyle & HLINK_UNDERLINEHOVER) != 0);
+        }
+
+        bool IsCommandButton() const
+        {
+                return ((m_dwExtendedStyle & HLINK_COMMANDBUTTON) != 0);
+        }
+
+        bool IsNotifyButton() const
+        {
+                return ((m_dwExtendedStyle & HLINK_NOTIFYBUTTON) == HLINK_NOTIFYBUTTON);
+        }
+
+        bool IsUsingTags() const
+        {
+                return ((m_dwExtendedStyle & HLINK_USETAGS) != 0);
+        }
+
+        bool IsUsingTagsBold() const
+        {
+                return ((m_dwExtendedStyle & HLINK_USETAGSBOLD) == HLINK_USETAGSBOLD);
+        }
+
+        bool IsUsingToolTip() const
+        {
+                return ((m_dwExtendedStyle & HLINK_NOTOOLTIP) == 0);
+        }
+
+        static int _xttoi(const TCHAR* nptr)
+        {
+#ifndef _ATL_MIN_CRT
+                return _ttoi(nptr);
+#else // _ATL_MIN_CRT
+                while(*nptr == _T(' '))   // skip spaces
+                        ++nptr;
+
+                int c = (int)(_TUCHAR)*nptr++;
+                int sign = c;   // save sign indication
+                if (c == _T('-') || c == _T('+'))
+                        c = (int)(_TUCHAR)*nptr++;   // skip sign
+
+                int total = 0;
+                while((TCHAR)c >= _T('0') && (TCHAR)c <= _T('9'))
+                {
+                        total = 10 * total + ((TCHAR)c - _T('0'));   // accumulate digit
+                        c = (int)(_TUCHAR)*nptr++;        // get next char
+                }
+
+                // return result, negated if necessary
+                return ((TCHAR)sign != _T('-')) ? total : -total;
+#endif // _ATL_MIN_CRT
+        }
+};
+
+
+class CHyperLink : public CHyperLinkImpl<CHyperLink>
+{
+public:
+        DECLARE_WND_CLASS(_T("WTL_HyperLink"))
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWaitCursor - displays a wait cursor
+
+class CWaitCursor
+{
+public:
+// Data
+        HCURSOR m_hWaitCursor;
+        HCURSOR m_hOldCursor;
+        bool m_bInUse;
+
+// Constructor/destructor
+        CWaitCursor(bool bSet = true, LPCTSTR lpstrCursor = IDC_WAIT, bool bSys = true) : m_hOldCursor(NULL), m_bInUse(false)
+        {
+                HINSTANCE hInstance = bSys ? NULL : ModuleHelper::GetResourceInstance();
+                m_hWaitCursor = ::LoadCursor(hInstance, lpstrCursor);
+                ATLASSERT(m_hWaitCursor != NULL);
+
+                if(bSet)
+                        Set();
+        }
+
+        ~CWaitCursor()
+        {
+                Restore();
+        }
+
+// Methods
+        bool Set()
+        {
+                if(m_bInUse)
+                        return false;
+                m_hOldCursor = ::SetCursor(m_hWaitCursor);
+                m_bInUse = true;
+                return true;
+        }
+
+        bool Restore()
+        {
+                if(!m_bInUse)
+                        return false;
+                ::SetCursor(m_hOldCursor);
+                m_bInUse = false;
+                return true;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CCustomWaitCursor - for custom and animated cursors
+
+class CCustomWaitCursor : public CWaitCursor
+{
+public:
+// Constructor/destructor
+        CCustomWaitCursor(ATL::_U_STRINGorID cursor, bool bSet = true, HINSTANCE hInstance = NULL) : 
+                        CWaitCursor(false, IDC_WAIT, true)
+        {
+                if(hInstance == NULL)
+                        hInstance = ModuleHelper::GetResourceInstance();
+                m_hWaitCursor = (HCURSOR)::LoadImage(hInstance, cursor.m_lpstr, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE);
+
+                if(bSet)
+                        Set();
+        }
+
+        ~CCustomWaitCursor()
+        {
+                Restore();
+#if !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))
+                ::DestroyCursor(m_hWaitCursor);
+#endif // !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CMultiPaneStatusBarCtrl - Status Bar with multiple panes
+
+template <class T, class TBase = CStatusBarCtrl>
+class ATL_NO_VTABLE CMultiPaneStatusBarCtrlImpl : public ATL::CWindowImpl< T, TBase >
+{
+public:
+        DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
+
+// Data
+        enum { m_cxPaneMargin = 3 };
+
+        int m_nPanes;
+        int* m_pPane;
+
+// Constructor/destructor
+        CMultiPaneStatusBarCtrlImpl() : m_nPanes(0), m_pPane(NULL)
+        { }
+
+        ~CMultiPaneStatusBarCtrlImpl()
+        {
+                delete [] m_pPane;
+        }
+
+// Methods
+        HWND Create(HWND hWndParent, LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
+        {
+#if (_MSC_VER >= 1300)
+                return ATL::CWindowImpl< T, TBase >::Create(hWndParent, rcDefault, lpstrText, dwStyle, 0, nID);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImpl< T, TBase >   _baseClass;
+                return _baseClass::Create(hWndParent, rcDefault, lpstrText, dwStyle, 0, nID);
+#endif // !(_MSC_VER >= 1300)
+        }
+
+        HWND Create(HWND hWndParent, UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
+        {
+                const int cchMax = 128;   // max text length is 127 for status bars (+1 for null)
+                TCHAR szText[cchMax];
+                szText[0] = 0;
+                ::LoadString(ModuleHelper::GetResourceInstance(), nTextID, szText, cchMax);
+                return Create(hWndParent, szText, dwStyle, nID);
+        }
+
+        BOOL SetPanes(int* pPanes, int nPanes, bool bSetText = true)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(nPanes > 0);
+
+                m_nPanes = nPanes;
+                delete [] m_pPane;
+                m_pPane = NULL;
+
+                ATLTRY(m_pPane = new int[nPanes]);
+                ATLASSERT(m_pPane != NULL);
+                if(m_pPane == NULL)
+                        return FALSE;
+
+                CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                int* pPanesPos = buff.Allocate(nPanes);
+                ATLASSERT(pPanesPos != NULL);
+                if(pPanesPos == NULL)
+                        return FALSE;
+
+                SecureHelper::memcpy_x(m_pPane, nPanes * sizeof(int), pPanes, nPanes * sizeof(int));
+
+                // get status bar DC and set font
+                CClientDC dc(m_hWnd);
+                HFONT hOldFont = dc.SelectFont(GetFont());
+
+                // get status bar borders
+                int arrBorders[3] = { 0 };
+                GetBorders(arrBorders);
+
+                const int cchBuff = 128;
+                TCHAR szBuff[cchBuff] = { 0 };
+                SIZE size = { 0, 0 };
+                int cxLeft = arrBorders[0];
+
+                // calculate right edge of each part
+                for(int i = 0; i < nPanes; i++)
+                {
+                        if(pPanes[i] == ID_DEFAULT_PANE)
+                        {
+                                // make very large, will be resized later
+                                pPanesPos[i] = INT_MAX / 2;
+                        }
+                        else
+                        {
+                                ::LoadString(ModuleHelper::GetResourceInstance(), pPanes[i], szBuff, cchBuff);
+                                dc.GetTextExtent(szBuff, lstrlen(szBuff), &size);
+                                T* pT = static_cast<T*>(this);
+                                pT;
+                                pPanesPos[i] = cxLeft + size.cx + arrBorders[2] + 2 * pT->m_cxPaneMargin;
+                        }
+                        cxLeft = pPanesPos[i];
+                }
+
+                BOOL bRet = SetParts(nPanes, pPanesPos);
+
+                if(bRet && bSetText)
+                {
+                        for(int i = 0; i < nPanes; i++)
+                        {
+                                if(pPanes[i] != ID_DEFAULT_PANE)
+                                {
+                                        ::LoadString(ModuleHelper::GetResourceInstance(), pPanes[i], szBuff, cchBuff);
+                                        SetPaneText(m_pPane[i], szBuff);
+                                }
+                        }
+                }
+
+                dc.SelectFont(hOldFont);
+                return bRet;
+        }
+
+        bool GetPaneTextLength(int nPaneID, int* pcchLength = NULL, int* pnType = NULL) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return false;
+
+                int nLength = GetTextLength(nIndex, pnType);
+                if(pcchLength != NULL)
+                        *pcchLength = nLength;
+
+                return true;
+        }
+
+        BOOL GetPaneText(int nPaneID, LPTSTR lpstrText, int* pcchLength = NULL, int* pnType = NULL) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                int nLength = GetText(nIndex, lpstrText, pnType);
+                if(pcchLength != NULL)
+                        *pcchLength = nLength;
+
+                return TRUE;
+        }
+
+        BOOL SetPaneText(int nPaneID, LPCTSTR lpstrText, int nType = 0)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                return SetText(nIndex, lpstrText, nType);
+        }
+
+        BOOL GetPaneRect(int nPaneID, LPRECT lpRect) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                return GetRect(nIndex, lpRect);
+        }
+
+        BOOL SetPaneWidth(int nPaneID, int cxWidth)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(nPaneID != ID_DEFAULT_PANE);   // Can't resize this one
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                // get pane positions
+                CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                int* pPanesPos = buff.Allocate(m_nPanes);
+                if(pPanesPos == NULL)
+                        return FALSE;
+                GetParts(m_nPanes, pPanesPos);
+                // calculate offset
+                int cxPaneWidth = pPanesPos[nIndex] - ((nIndex == 0) ? 0 : pPanesPos[nIndex - 1]);
+                int cxOff = cxWidth - cxPaneWidth;
+                // find variable width pane
+                int nDef = m_nPanes;
+                for(int i = 0; i < m_nPanes; i++)
+                {
+                        if(m_pPane[i] == ID_DEFAULT_PANE)
+                        {
+                                nDef = i;
+                                break;
+                        }
+                }
+                // resize
+                if(nIndex < nDef)   // before default pane
+                {
+                        for(int i = nIndex; i < nDef; i++)
+                                pPanesPos[i] += cxOff;
+                                
+                }
+                else                    // after default one
+                {
+                        for(int i = nDef; i < nIndex; i++)
+                                pPanesPos[i] -= cxOff;
+                }
+                // set pane postions
+                return SetParts(m_nPanes, pPanesPos);
+        }
+
+#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
+        BOOL GetPaneTipText(int nPaneID, LPTSTR lpstrText, int nSize) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                GetTipText(nIndex, lpstrText, nSize);
+                return TRUE;
+        }
+
+        BOOL SetPaneTipText(int nPaneID, LPCTSTR lpstrText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                SetTipText(nIndex, lpstrText);
+                return TRUE;
+        }
+#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
+
+#if ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
+        BOOL GetPaneIcon(int nPaneID, HICON& hIcon) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                hIcon = GetIcon(nIndex);
+                return TRUE;
+        }
+
+        BOOL SetPaneIcon(int nPaneID, HICON hIcon)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                int nIndex  = GetPaneIndexFromID(nPaneID);
+                if(nIndex == -1)
+                        return FALSE;
+
+                return SetIcon(nIndex, hIcon);
+        }
+#endif // ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CMultiPaneStatusBarCtrlImpl< T >)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+        END_MSG_MAP()
+
+        LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
+                if(wParam != SIZE_MINIMIZED && m_nPanes > 0)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdatePanesLayout();
+                }
+                return lRet;
+        }
+
+// Implementation
+        BOOL UpdatePanesLayout()
+        {
+                // get pane positions
+                CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                int* pPanesPos = buff.Allocate(m_nPanes);
+                ATLASSERT(pPanesPos != NULL);
+                if(pPanesPos == NULL)
+                        return FALSE;
+                int nRet = GetParts(m_nPanes, pPanesPos);
+                ATLASSERT(nRet == m_nPanes);
+                if(nRet != m_nPanes)
+                        return FALSE;
+                // calculate offset
+                RECT rcClient = { 0 };
+                GetClientRect(&rcClient);
+                int cxOff = rcClient.right - pPanesPos[m_nPanes - 1];
+#ifndef _WIN32_WCE
+                // Move panes left if size grip box is present
+                if((GetStyle() & SBARS_SIZEGRIP) != 0)
+                        cxOff -= ::GetSystemMetrics(SM_CXVSCROLL) + ::GetSystemMetrics(SM_CXEDGE);
+#endif // !_WIN32_WCE
+                // find variable width pane
+                int i;
+                for(i = 0; i < m_nPanes; i++)
+                {
+                        if(m_pPane[i] == ID_DEFAULT_PANE)
+                                break;
+                }
+                // resize all panes from the variable one to the right
+                if((i < m_nPanes) && (pPanesPos[i] + cxOff) > ((i == 0) ? 0 : pPanesPos[i - 1]))
+                {
+                        for(; i < m_nPanes; i++)
+                                pPanesPos[i] += cxOff;
+                }
+                // set pane postions
+                return SetParts(m_nPanes, pPanesPos);
+        }
+
+        int GetPaneIndexFromID(int nPaneID) const
+        {
+                for(int i = 0; i < m_nPanes; i++)
+                {
+                        if(m_pPane[i] == nPaneID)
+                                return i;
+                }
+
+                return -1;   // not found
+        }
+};
+
+class CMultiPaneStatusBarCtrl : public CMultiPaneStatusBarCtrlImpl<CMultiPaneStatusBarCtrl>
+{
+public:
+        DECLARE_WND_SUPERCLASS(_T("WTL_MultiPaneStatusBar"), GetWndClassName())
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CPaneContainer - provides header with title and close button for panes
+
+// pane container extended styles
+#define PANECNT_NOCLOSEBUTTON   0x00000001
+#define PANECNT_VERTICAL        0x00000002
+#define PANECNT_FLATBORDER      0x00000004
+#define PANECNT_NOBORDER        0x00000008
+
+template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
+class ATL_NO_VTABLE CPaneContainerImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CCustomDraw< T >
+{
+public:
+        DECLARE_WND_CLASS_EX(NULL, 0, -1)
+
+// Constants
+        enum
+        {
+                m_cxyBorder = 2,
+                m_cxyTextOffset = 4,
+                m_cxyBtnOffset = 1,
+
+                m_cchTitle = 80,
+
+                m_cxImageTB = 13,
+                m_cyImageTB = 11,
+                m_cxyBtnAddTB = 7,
+
+                m_cxToolBar = m_cxImageTB + m_cxyBtnAddTB + m_cxyBorder + m_cxyBtnOffset,
+
+                m_xBtnImageLeft = 6,
+                m_yBtnImageTop = 5,
+                m_xBtnImageRight = 12,
+                m_yBtnImageBottom = 11,
+
+                m_nCloseBtnID = ID_PANE_CLOSE
+        };
+
+// Data members
+        CToolBarCtrl m_tb;
+        ATL::CWindow m_wndClient;
+        int m_cxyHeader;
+        TCHAR m_szTitle[m_cchTitle];
+        DWORD m_dwExtendedStyle;   // Pane container specific extended styles
+
+
+// Constructor
+        CPaneContainerImpl() : m_cxyHeader(0), m_dwExtendedStyle(0)
+        {
+                m_szTitle[0] = 0;
+        }
+
+// Attributes
+        DWORD GetPaneContainerExtendedStyle() const
+        {
+                return m_dwExtendedStyle;
+        }
+
+        DWORD SetPaneContainerExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
+        {
+                DWORD dwPrevStyle = m_dwExtendedStyle;
+                if(dwMask == 0)
+                        m_dwExtendedStyle = dwExtendedStyle;
+                else
+                        m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
+                if(m_hWnd != NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        bool bUpdate = false;
+
+                        if(((dwPrevStyle & PANECNT_NOCLOSEBUTTON) != 0) && ((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) == 0))   // add close button
+                        {
+                                pT->CreateCloseButton();
+                                bUpdate = true;
+                        }
+                        else if(((dwPrevStyle & PANECNT_NOCLOSEBUTTON) == 0) && ((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) != 0))   // remove close button
+                        {
+                                pT->DestroyCloseButton();
+                                bUpdate = true;
+                        }
+
+                        if((dwPrevStyle & PANECNT_VERTICAL) != (m_dwExtendedStyle & PANECNT_VERTICAL))   // change orientation
+                        {
+                                pT->CalcSize();
+                                bUpdate = true;
+                        }
+
+                        if((dwPrevStyle & (PANECNT_FLATBORDER | PANECNT_NOBORDER)) != 
+                           (m_dwExtendedStyle & (PANECNT_FLATBORDER | PANECNT_NOBORDER)))   // change border
+                        {
+                                bUpdate = true;
+                        }
+
+                        if(bUpdate)
+                                pT->UpdateLayout();
+                }
+                return dwPrevStyle;
+        }
+
+        HWND GetClient() const
+        {
+                return m_wndClient;
+        }
+
+        HWND SetClient(HWND hWndClient)
+        {
+                HWND hWndOldClient = m_wndClient;
+                m_wndClient = hWndClient;
+                if(m_hWnd != NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdateLayout();
+                }
+                return hWndOldClient;
+        }
+
+        BOOL GetTitle(LPTSTR lpstrTitle, int cchLength) const
+        {
+                ATLASSERT(lpstrTitle != NULL);
+
+                errno_t nRet = SecureHelper::strncpy_x(lpstrTitle, cchLength, m_szTitle, _TRUNCATE);
+
+                return (nRet == 0 || nRet == STRUNCATE);
+        }
+
+        BOOL SetTitle(LPCTSTR lpstrTitle)
+        {
+                ATLASSERT(lpstrTitle != NULL);
+
+                errno_t nRet = SecureHelper::strncpy_x(m_szTitle, m_cchTitle, lpstrTitle, _TRUNCATE);
+                bool bRet = (nRet == 0 || nRet == STRUNCATE);
+                if(bRet && m_hWnd != NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdateLayout();
+                }
+
+                return bRet;
+        }
+
+        int GetTitleLength() const
+        {
+                return lstrlen(m_szTitle);
+        }
+
+// Methods
+        HWND Create(HWND hWndParent, LPCTSTR lpstrTitle = NULL, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+                        DWORD dwExStyle = 0, UINT nID = 0, LPVOID lpCreateParam = NULL)
+        {
+                if(lpstrTitle != NULL)
+                        SecureHelper::strncpy_x(m_szTitle, m_cchTitle, lpstrTitle, _TRUNCATE);
+#if (_MSC_VER >= 1300)
+                return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImpl< T, TBase, TWinTraits >   _baseClass;
+                return _baseClass::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
+#endif // !(_MSC_VER >= 1300)
+        }
+
+        HWND Create(HWND hWndParent, UINT uTitleID, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+                        DWORD dwExStyle = 0, UINT nID = 0, LPVOID lpCreateParam = NULL)
+        {
+                if(uTitleID != 0U)
+                        ::LoadString(ModuleHelper::GetResourceInstance(), uTitleID, m_szTitle, m_cchTitle);
+#if (_MSC_VER >= 1300)
+                return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
+#else // !(_MSC_VER >= 1300)
+                typedef ATL::CWindowImpl< T, TBase, TWinTraits >   _baseClass;
+                return _baseClass::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
+#endif // !(_MSC_VER >= 1300)
+        }
+
+        BOOL EnableCloseButton(BOOL bEnable)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT;   // avoid level 4 warning
+                return (m_tb.m_hWnd != NULL) ? m_tb.EnableButton(pT->m_nCloseBtnID, bEnable) : FALSE;
+        }
+
+        void UpdateLayout()
+        {
+                RECT rcClient = { 0 };
+                GetClientRect(&rcClient);
+                T* pT = static_cast<T*>(this);
+                pT->UpdateLayout(rcClient.right, rcClient.bottom);
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CPaneContainerImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+                MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
+                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
+                MESSAGE_HANDLER(WM_PAINT, OnPaint)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
+#endif // !_WIN32_WCE
+                MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
+                MESSAGE_HANDLER(WM_COMMAND, OnCommand)
+                FORWARD_NOTIFICATIONS()
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->CalcSize();
+
+                if((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) == 0)
+                        pT->CreateCloseButton();
+
+                return 0;
+        }
+
+        LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->UpdateLayout(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+                return 0;
+        }
+
+        LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(m_wndClient.m_hWnd != NULL)
+                        m_wndClient.SetFocus();
+                return 0;
+        }
+
+        LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return 1;   // no background needed
+        }
+
+        LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                if(wParam != NULL)
+                {
+                        pT->DrawPaneTitle((HDC)wParam);
+
+                        if(m_wndClient.m_hWnd == NULL)   // no client window
+                                pT->DrawPane((HDC)wParam);
+                }
+                else
+                {
+                        CPaintDC dc(m_hWnd);
+                        pT->DrawPaneTitle(dc.m_hDC);
+
+                        if(m_wndClient.m_hWnd == NULL)   // no client window
+                                pT->DrawPane(dc.m_hDC);
+                }
+
+                return 0;
+        }
+
+        LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                if(m_tb.m_hWnd == NULL)
+                {
+                        bHandled = FALSE;
+                        return 1;
+                }
+
+                T* pT = static_cast<T*>(this);
+                pT;
+                LPNMHDR lpnmh = (LPNMHDR)lParam;
+                LRESULT lRet = 0;
+
+                // pass toolbar custom draw notifications to the base class
+                if(lpnmh->code == NM_CUSTOMDRAW && lpnmh->hwndFrom == m_tb.m_hWnd)
+                        lRet = CCustomDraw< T >::OnCustomDraw(0, lpnmh, bHandled);
+#ifndef _WIN32_WCE
+                // tooltip notifications come with the tooltip window handle and button ID,
+                // pass them to the parent if we don't handle them
+                else if(lpnmh->code == TTN_GETDISPINFO && lpnmh->idFrom == pT->m_nCloseBtnID)
+                        bHandled = pT->GetToolTipText(lpnmh);
+#endif // !_WIN32_WCE
+                // only let notifications not from the toolbar go to the parent
+                else if(lpnmh->hwndFrom != m_tb.m_hWnd && lpnmh->idFrom != pT->m_nCloseBtnID)
+                        bHandled = FALSE;
+
+                return lRet;
+        }
+
+        LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+        {
+                // if command comes from the close button, substitute HWND of the pane container instead
+                if(m_tb.m_hWnd != NULL && (HWND)lParam == m_tb.m_hWnd)
+                        return ::SendMessage(GetParent(), WM_COMMAND, wParam, (LPARAM)m_hWnd);
+
+                bHandled = FALSE;
+                return 1;
+        }
+
+// Custom draw overrides
+        DWORD OnPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
+        {
+                return CDRF_NOTIFYITEMDRAW;   // we need per-item notifications
+        }
+
+        DWORD OnItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW lpNMCustomDraw)
+        {
+                CDCHandle dc = lpNMCustomDraw->hdc;
+#if (_WIN32_IE >= 0x0400)
+                RECT& rc = lpNMCustomDraw->rc;
+#else // !(_WIN32_IE >= 0x0400)
+                RECT rc;
+                m_tb.GetItemRect(0, &rc);
+#endif // !(_WIN32_IE >= 0x0400)
+
+                dc.FillRect(&rc, COLOR_3DFACE);
+
+                return CDRF_NOTIFYPOSTPAINT;
+        }
+
+        DWORD OnItemPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW lpNMCustomDraw)
+        {
+                CDCHandle dc = lpNMCustomDraw->hdc;
+#if (_WIN32_IE >= 0x0400)
+                RECT& rc = lpNMCustomDraw->rc;
+#else // !(_WIN32_IE >= 0x0400)
+                RECT rc = { 0 };
+                m_tb.GetItemRect(0, &rc);
+#endif // !(_WIN32_IE >= 0x0400)
+
+                RECT rcImage = { m_xBtnImageLeft, m_yBtnImageTop, m_xBtnImageRight + 1, m_yBtnImageBottom + 1 };
+                ::OffsetRect(&rcImage, rc.left, rc.top);
+                T* pT = static_cast<T*>(this);
+
+                if((lpNMCustomDraw->uItemState & CDIS_DISABLED) != 0)
+                {
+                        RECT rcShadow = rcImage;
+                        ::OffsetRect(&rcShadow, 1, 1);
+                        CPen pen1;
+                        pen1.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_3DHILIGHT));
+                        pT->DrawButtonImage(dc, rcShadow, pen1);
+                        CPen pen2;
+                        pen2.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_3DSHADOW));
+                        pT->DrawButtonImage(dc, rcImage, pen2);
+                }
+                else
+                {
+                        if((lpNMCustomDraw->uItemState & CDIS_SELECTED) != 0)
+                                ::OffsetRect(&rcImage, 1, 1);
+                        CPen pen;
+                        pen.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_BTNTEXT));
+                        pT->DrawButtonImage(dc, rcImage, pen);
+                }
+
+                return CDRF_DODEFAULT;   // continue with the default item painting
+        }
+
+// Implementation - overrideable methods
+        void UpdateLayout(int cxWidth, int cyHeight)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                RECT rect = { 0 };
+
+                if(IsVertical())
+                {
+                        ::SetRect(&rect, 0, 0, m_cxyHeader, cyHeight);
+                        if(m_tb.m_hWnd != NULL)
+                                m_tb.SetWindowPos(NULL, m_cxyBorder, m_cxyBorder + m_cxyBtnOffset, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
+
+                        if(m_wndClient.m_hWnd != NULL)
+                                m_wndClient.SetWindowPos(NULL, m_cxyHeader, 0, cxWidth - m_cxyHeader, cyHeight, SWP_NOZORDER);
+                        else
+                                rect.right = cxWidth;
+                }
+                else
+                {
+                        ::SetRect(&rect, 0, 0, cxWidth, m_cxyHeader);
+                        if(m_tb.m_hWnd != NULL)
+                                m_tb.SetWindowPos(NULL, rect.right - m_cxToolBar, m_cxyBorder + m_cxyBtnOffset, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
+
+                        if(m_wndClient.m_hWnd != NULL)
+                                m_wndClient.SetWindowPos(NULL, 0, m_cxyHeader, cxWidth, cyHeight - m_cxyHeader, SWP_NOZORDER);
+                        else
+                                rect.bottom = cyHeight;
+                }
+
+                InvalidateRect(&rect);
+        }
+
+        void CreateCloseButton()
+        {
+                ATLASSERT(m_tb.m_hWnd == NULL);
+                // create toolbar for the "x" button
+                m_tb.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NORESIZE | CCS_NOPARENTALIGN | CCS_NOMOVEY | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT, 0);
+                ATLASSERT(m_tb.IsWindow());
+
+                if(m_tb.m_hWnd != NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT;   // avoid level 4 warning
+
+                        m_tb.SetButtonStructSize();
+
+                        TBBUTTON tbbtn = { 0 };
+                        tbbtn.idCommand = pT->m_nCloseBtnID;
+                        tbbtn.fsState = TBSTATE_ENABLED;
+                        tbbtn.fsStyle = TBSTYLE_BUTTON;
+                        m_tb.AddButtons(1, &tbbtn);
+
+                        m_tb.SetBitmapSize(m_cxImageTB, m_cyImageTB);
+                        m_tb.SetButtonSize(m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB);
+
+                        if(IsVertical())
+                                m_tb.SetWindowPos(NULL, m_cxyBorder + m_cxyBtnOffset, m_cxyBorder + m_cxyBtnOffset, m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB, SWP_NOZORDER | SWP_NOACTIVATE);
+                        else
+                                m_tb.SetWindowPos(NULL, 0, 0, m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
+                }
+        }
+
+        void DestroyCloseButton()
+        {
+                if(m_tb.m_hWnd != NULL)
+                        m_tb.DestroyWindow();
+        }
+
+        void CalcSize()
+        {
+                T* pT = static_cast<T*>(this);
+                CFontHandle font = pT->GetTitleFont();
+                LOGFONT lf = { 0 };
+                font.GetLogFont(lf);
+                if(IsVertical())
+                {
+                        m_cxyHeader = m_cxImageTB + m_cxyBtnAddTB + m_cxyBorder;
+                }
+                else
+                {
+                        int cyFont = abs(lf.lfHeight) + m_cxyBorder + 2 * m_cxyTextOffset;
+                        int cyBtn = m_cyImageTB + m_cxyBtnAddTB + m_cxyBorder + 2 * m_cxyBtnOffset;
+                        m_cxyHeader = __max(cyFont, cyBtn);
+                }
+        }
+
+        HFONT GetTitleFont() const
+        {
+                return AtlGetDefaultGuiFont();
+        }
+
+#ifndef _WIN32_WCE
+        BOOL GetToolTipText(LPNMHDR /*lpnmh*/)
+        {
+                return FALSE;
+        }
+#endif // !_WIN32_WCE
+
+        void DrawPaneTitle(CDCHandle dc)
+        {
+                RECT rect = { 0 };
+                GetClientRect(&rect);
+
+                UINT uBorder = BF_LEFT | BF_TOP | BF_ADJUST;
+                if(IsVertical())
+                {
+                        rect.right = rect.left + m_cxyHeader;
+                        uBorder |= BF_BOTTOM;
+                }
+                else
+                {
+                        rect.bottom = rect.top + m_cxyHeader;
+                        uBorder |= BF_RIGHT;
+                }
+
+                if((m_dwExtendedStyle & PANECNT_NOBORDER) == 0)
+                {
+                        if((m_dwExtendedStyle & PANECNT_FLATBORDER) != 0)
+                                uBorder |= BF_FLAT;
+                        dc.DrawEdge(&rect, EDGE_ETCHED, uBorder);
+                }
+                dc.FillRect(&rect, COLOR_3DFACE);
+
+                if(!IsVertical())   // draw title only for horizontal pane container
+                {
+                        dc.SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
+                        dc.SetBkMode(TRANSPARENT);
+                        T* pT = static_cast<T*>(this);
+                        HFONT hFontOld = dc.SelectFont(pT->GetTitleFont());
+                        rect.left += m_cxyTextOffset;
+                        rect.right -= m_cxyTextOffset;
+                        if(m_tb.m_hWnd != NULL)
+                                rect.right -= m_cxToolBar;;
+#ifndef _WIN32_WCE
+                        dc.DrawText(m_szTitle, -1, &rect, DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
+#else // CE specific
+                        dc.DrawText(m_szTitle, -1, &rect, DT_LEFT | DT_SINGLELINE | DT_VCENTER);
+#endif // _WIN32_WCE
+                        dc.SelectFont(hFontOld);
+                }
+        }
+
+        // called only if pane is empty
+        void DrawPane(CDCHandle dc)
+        {
+                RECT rect = { 0 };
+                GetClientRect(&rect);
+                if(IsVertical())
+                        rect.left += m_cxyHeader;
+                else
+                        rect.top += m_cxyHeader;
+                if((GetExStyle() & WS_EX_CLIENTEDGE) == 0)
+                        dc.DrawEdge(&rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
+                dc.FillRect(&rect, COLOR_APPWORKSPACE);
+        }
+
+        // drawing helper - draws "x" button image
+        void DrawButtonImage(CDCHandle dc, RECT& rcImage, HPEN hPen)
+        {
+#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
+                HPEN hPenOld = dc.SelectPen(hPen);
+
+                dc.MoveTo(rcImage.left, rcImage.top);
+                dc.LineTo(rcImage.right, rcImage.bottom);
+                dc.MoveTo(rcImage.left + 1, rcImage.top);
+                dc.LineTo(rcImage.right + 1, rcImage.bottom);
+
+                dc.MoveTo(rcImage.left, rcImage.bottom - 1);
+                dc.LineTo(rcImage.right, rcImage.top - 1);
+                dc.MoveTo(rcImage.left + 1, rcImage.bottom - 1);
+                dc.LineTo(rcImage.right + 1, rcImage.top - 1);
+
+                dc.SelectPen(hPenOld);
+#else // (_WIN32_WCE < 400)
+                rcImage;
+                hPen;
+                // no support for the "x" button image
+#endif // (_WIN32_WCE < 400)
+        }
+
+        bool IsVertical() const
+        {
+                return ((m_dwExtendedStyle & PANECNT_VERTICAL) != 0);
+        }
+};
+
+class CPaneContainer : public CPaneContainerImpl<CPaneContainer>
+{
+public:
+        DECLARE_WND_CLASS_EX(_T("WTL_PaneContainer"), 0, -1)
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CSortListViewCtrl - implements sorting for a listview control
+
+// sort listview extended styles
+#define SORTLV_USESHELLBITMAPS  0x00000001
+
+// Notification sent to parent when sort column is changed by user clicking header.  
+#define SLVN_SORTCHANGED        LVN_LAST
+
+// A LPNMSORTLISTVIEW is sent with the SLVN_SORTCHANGED notification
+typedef struct tagNMSORTLISTVIEW
+{
+    NMHDR hdr;
+    int iNewSortColumn;
+    int iOldSortColumn;
+} NMSORTLISTVIEW, *LPNMSORTLISTVIEW;
+
+// Column sort types. Can be set on a per-column basis with the SetColumnSortType method.
+enum
+{
+        LVCOLSORT_NONE,
+        LVCOLSORT_TEXT,   // default
+        LVCOLSORT_TEXTNOCASE,
+        LVCOLSORT_LONG,
+        LVCOLSORT_DOUBLE,
+        LVCOLSORT_DECIMAL,
+        LVCOLSORT_DATETIME,
+        LVCOLSORT_DATE,
+        LVCOLSORT_TIME,
+        LVCOLSORT_CUSTOM,
+        LVCOLSORT_LAST = LVCOLSORT_CUSTOM
+};
+
+
+template <class T>
+class CSortListViewImpl
+{
+public:
+        enum
+        {
+                m_cchCmpTextMax = 32, // overrideable
+                m_cxSortImage = 16,
+                m_cySortImage = 15,
+                m_cxSortArrow = 11,
+                m_cySortArrow = 6,
+                m_iSortUp = 0,        // index of sort bitmaps
+                m_iSortDown = 1,
+                m_nShellSortUpID = 133
+        };
+
+        // passed to LVCompare functions as lParam1 and lParam2 
+        struct LVCompareParam
+        {
+                int iItem;
+                DWORD_PTR dwItemData;
+                union
+                {
+                        long lValue;
+                        double dblValue;
+                        DECIMAL decValue;
+                        LPCTSTR pszValue;
+                };
+        };
+        
+        // passed to LVCompare functions as the lParamSort parameter
+        struct LVSortInfo
+        {
+                T* pT;
+                int iSortCol;
+                bool bDescending;
+        };
+
+        bool m_bSortDescending;
+        bool m_bCommCtrl6;
+        int m_iSortColumn;
+        CBitmap m_bmSort[2];
+        int m_fmtOldSortCol;
+        HBITMAP m_hbmOldSortCol;
+        DWORD m_dwSortLVExtendedStyle;
+        ATL::CSimpleArray<WORD> m_arrColSortType;
+        bool m_bUseWaitCursor;
+        
+        CSortListViewImpl() :
+                        m_bSortDescending(false),
+                        m_bCommCtrl6(false),
+                        m_iSortColumn(-1), 
+                        m_fmtOldSortCol(0),
+                        m_hbmOldSortCol(NULL),
+                        m_dwSortLVExtendedStyle(SORTLV_USESHELLBITMAPS),
+                        m_bUseWaitCursor(true)
+        {
+#ifndef _WIN32_WCE
+                DWORD dwMajor = 0;
+                DWORD dwMinor = 0;
+                HRESULT hRet = ATL::AtlGetCommCtrlVersion(&dwMajor, &dwMinor);
+                m_bCommCtrl6 = SUCCEEDED(hRet) && dwMajor >= 6;
+#endif // !_WIN32_WCE
+        }
+        
+// Attributes
+        void SetSortColumn(int iCol)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(::IsWindow(pT->m_hWnd));
+                CHeaderCtrl header = pT->GetHeader();
+                ATLASSERT(header.m_hWnd != NULL);
+                ATLASSERT(iCol >= -1 && iCol < m_arrColSortType.GetSize());
+
+                int iOldSortCol = m_iSortColumn;
+                m_iSortColumn = iCol;
+                if(m_bCommCtrl6)
+                {
+#ifndef HDF_SORTUP
+                        const int HDF_SORTUP = 0x0400;  
+#endif // HDF_SORTUP
+#ifndef HDF_SORTDOWN
+                        const int HDF_SORTDOWN = 0x0200;        
+#endif // HDF_SORTDOWN
+                        const int nMask = HDF_SORTUP | HDF_SORTDOWN;
+                        HDITEM hditem = { HDI_FORMAT };
+                        if(iOldSortCol != iCol && iOldSortCol >= 0 && header.GetItem(iOldSortCol, &hditem))
+                        {
+                                hditem.fmt &= ~nMask;
+                                header.SetItem(iOldSortCol, &hditem);
+                        }
+                        if(iCol >= 0 && header.GetItem(iCol, &hditem))
+                        {
+                                hditem.fmt &= ~nMask;
+                                hditem.fmt |= m_bSortDescending ? HDF_SORTDOWN : HDF_SORTUP;
+                                header.SetItem(iCol, &hditem);
+                        }
+                        return;
+                }
+
+                if(m_bmSort[m_iSortUp].IsNull())
+                        pT->CreateSortBitmaps();
+
+                // restore previous sort column's bitmap, if any, and format
+                HDITEM hditem = { HDI_BITMAP | HDI_FORMAT };
+                if(iOldSortCol != iCol && iOldSortCol >= 0)
+                {
+                        hditem.hbm = m_hbmOldSortCol;
+                        hditem.fmt = m_fmtOldSortCol;
+                        header.SetItem(iOldSortCol, &hditem);
+                }
+
+                // save new sort column's bitmap and format, and add our sort bitmap
+                if(iCol >= 0 && header.GetItem(iCol, &hditem))
+                {
+                        if(iOldSortCol != iCol)
+                        {
+                                m_fmtOldSortCol = hditem.fmt;
+                                m_hbmOldSortCol = hditem.hbm;
+                        }
+                        hditem.fmt &= ~HDF_IMAGE;
+                        hditem.fmt |= HDF_BITMAP | HDF_BITMAP_ON_RIGHT;
+                        int i = m_bSortDescending ? m_iSortDown : m_iSortUp;
+                        hditem.hbm = m_bmSort[i];
+                        header.SetItem(iCol, &hditem);
+                }
+        }
+
+        int GetSortColumn() const
+        {
+                return m_iSortColumn;
+        }
+
+        void SetColumnSortType(int iCol, WORD wType)
+        {
+                ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize());
+                ATLASSERT(wType >= LVCOLSORT_NONE && wType <= LVCOLSORT_LAST);
+                m_arrColSortType[iCol] = wType;
+        }
+
+        WORD GetColumnSortType(int iCol) const
+        {
+                ATLASSERT((iCol >= 0) && iCol < m_arrColSortType.GetSize());
+                return m_arrColSortType[iCol];
+        }
+
+        int GetColumnCount() const
+        {
+                const T* pT = static_cast<const T*>(this);
+                ATLASSERT(::IsWindow(pT->m_hWnd));
+                CHeaderCtrl header = pT->GetHeader();
+                return header.m_hWnd != NULL ? header.GetItemCount() : 0;
+        }
+
+        bool IsSortDescending() const
+        {
+                return m_bSortDescending;
+        }
+
+        DWORD GetSortListViewExtendedStyle() const
+        {
+                return m_dwSortLVExtendedStyle;
+        }
+
+        DWORD SetSortListViewExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
+        {
+                DWORD dwPrevStyle = m_dwSortLVExtendedStyle;
+                if(dwMask == 0)
+                        m_dwSortLVExtendedStyle = dwExtendedStyle;
+                else
+                        m_dwSortLVExtendedStyle = (m_dwSortLVExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
+                return dwPrevStyle;
+        }
+
+// Operations
+        bool DoSortItems(int iCol, bool bDescending = false)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(::IsWindow(pT->m_hWnd));
+                ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize());
+
+                WORD wType = m_arrColSortType[iCol];
+                if(wType == LVCOLSORT_NONE)
+                        return false;
+
+                int nCount = pT->GetItemCount();
+                if(nCount < 2)
+                {
+                        m_bSortDescending = bDescending;
+                        SetSortColumn(iCol);
+                        return true;
+                }
+
+                CWaitCursor waitCursor(false);
+                if(m_bUseWaitCursor)
+                        waitCursor.Set();
+
+                LVCompareParam* pParam = NULL;
+                ATLTRY(pParam = new LVCompareParam[nCount]);
+                PFNLVCOMPARE pFunc = NULL;
+                TCHAR pszTemp[pT->m_cchCmpTextMax];
+                bool bStrValue = false;
+
+                switch(wType)
+                {
+                case LVCOLSORT_TEXT:
+                        pFunc = (PFNLVCOMPARE)pT->LVCompareText;
+                case LVCOLSORT_TEXTNOCASE:
+                        if(pFunc == NULL)
+                                pFunc = (PFNLVCOMPARE)pT->LVCompareTextNoCase;
+                case LVCOLSORT_CUSTOM:
+                        {
+                                if(pFunc == NULL)
+                                        pFunc = (PFNLVCOMPARE)pT->LVCompareCustom;
+
+                                for(int i = 0; i < nCount; i++)
+                                {
+                                        pParam[i].iItem = i;
+                                        pParam[i].dwItemData = pT->GetItemData(i);
+                                        pParam[i].pszValue = new TCHAR[pT->m_cchCmpTextMax];
+                                        pT->GetItemText(i, iCol, (LPTSTR)pParam[i].pszValue, pT->m_cchCmpTextMax);
+                                        pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
+                                }
+                                bStrValue = true;
+                        }
+                        break;
+                case LVCOLSORT_LONG:
+                        {
+                                pFunc = (PFNLVCOMPARE)pT->LVCompareLong;
+                                for(int i = 0; i < nCount; i++)
+                                {
+                                        pParam[i].iItem = i;
+                                        pParam[i].dwItemData = pT->GetItemData(i);
+                                        pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
+                                        pParam[i].lValue = pT->StrToLong(pszTemp);
+                                        pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
+                                }
+                        }
+                        break;
+                case LVCOLSORT_DOUBLE:
+                        {
+                                pFunc = (PFNLVCOMPARE)pT->LVCompareDouble;
+                                for(int i = 0; i < nCount; i++)
+                                {
+                                        pParam[i].iItem = i;
+                                        pParam[i].dwItemData = pT->GetItemData(i);
+                                        pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
+                                        pParam[i].dblValue = pT->StrToDouble(pszTemp);
+                                        pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
+                                }
+                        }
+                        break;
+                case LVCOLSORT_DECIMAL:
+                        {
+                                pFunc = (PFNLVCOMPARE)pT->LVCompareDecimal;
+                                for(int i = 0; i < nCount; i++)
+                                {
+                                        pParam[i].iItem = i;
+                                        pParam[i].dwItemData = pT->GetItemData(i);
+                                        pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
+                                        pT->StrToDecimal(pszTemp, &pParam[i].decValue);
+                                        pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
+                                }
+                        }
+                        break;
+                case LVCOLSORT_DATETIME:
+                case LVCOLSORT_DATE:
+                case LVCOLSORT_TIME:
+                        {
+                                pFunc = (PFNLVCOMPARE)pT->LVCompareDouble;
+                                DWORD dwFlags = LOCALE_NOUSEROVERRIDE;
+                                if(wType == LVCOLSORT_DATE)
+                                        dwFlags |= VAR_DATEVALUEONLY;
+                                else if(wType == LVCOLSORT_TIME)
+                                        dwFlags |= VAR_TIMEVALUEONLY;
+                                for(int i = 0; i < nCount; i++)
+                                {
+                                        pParam[i].iItem = i;
+                                        pParam[i].dwItemData = pT->GetItemData(i);
+                                        pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
+                                        pParam[i].dblValue = pT->DateStrToDouble(pszTemp, dwFlags);
+                                        pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
+                                }
+                        }
+                        break;
+                default:
+                        ATLTRACE2(atlTraceUI, 0, _T("Unknown value for sort type in CSortListViewImpl::DoSortItems()\n"));
+                        break;
+                } // switch(wType)
+
+                ATLASSERT(pFunc != NULL);
+                LVSortInfo lvsi = { pT, iCol, bDescending };
+                bool bRet = ((BOOL)pT->DefWindowProc(LVM_SORTITEMS, (WPARAM)&lvsi, (LPARAM)pFunc) != FALSE);
+                for(int i = 0; i < nCount; i++)
+                {
+                        DWORD_PTR dwItemData = pT->GetItemData(i);
+                        LVCompareParam* p = (LVCompareParam*)dwItemData;
+                        ATLASSERT(p != NULL);
+                        if(bStrValue)
+                                delete [] (TCHAR*)p->pszValue;
+                        pT->SetItemData(i, p->dwItemData);
+                }
+                delete [] pParam;
+
+                if(bRet)
+                {
+                        m_bSortDescending = bDescending;
+                        SetSortColumn(iCol);
+                }
+
+                if(m_bUseWaitCursor)
+                        waitCursor.Restore();
+
+                return bRet;
+        }
+
+        void CreateSortBitmaps()
+        {
+                if((m_dwSortLVExtendedStyle & SORTLV_USESHELLBITMAPS) != 0)
+                {
+                        bool bFree = false;
+                        LPCTSTR pszModule = _T("shell32.dll"); 
+                        HINSTANCE hShell = ::GetModuleHandle(pszModule);
+
+                        if (hShell == NULL)             
+                        {
+                                hShell = ::LoadLibrary(pszModule);
+                                bFree = true;
+                        }
+ 
+                        if (hShell != NULL)
+                        {
+                                bool bSuccess = true;
+                                for(int i = m_iSortUp; i <= m_iSortDown; i++)
+                                {
+                                        if(!m_bmSort[i].IsNull())
+                                                m_bmSort[i].DeleteObject();
+                                        m_bmSort[i] = (HBITMAP)::LoadImage(hShell, MAKEINTRESOURCE(m_nShellSortUpID + i), 
+#ifndef _WIN32_WCE
+                                                IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
+#else // CE specific
+                                                IMAGE_BITMAP, 0, 0, 0);
+#endif // _WIN32_WCE
+                                        if(m_bmSort[i].IsNull())
+                                        {
+                                                bSuccess = false;
+                                                break;
+                                        }
+                                }
+                                if(bFree)
+                                        ::FreeLibrary(hShell);
+                                if(bSuccess)
+                                        return;
+                        }
+                }
+
+                T* pT = static_cast<T*>(this);
+                for(int i = m_iSortUp; i <= m_iSortDown; i++)
+                {
+                        if(!m_bmSort[i].IsNull())
+                                m_bmSort[i].DeleteObject();
+
+                        CDC dcMem;
+                        CClientDC dc(::GetDesktopWindow());
+                        dcMem.CreateCompatibleDC(dc.m_hDC);
+                        m_bmSort[i].CreateCompatibleBitmap(dc.m_hDC, m_cxSortImage, m_cySortImage);
+                        HBITMAP hbmOld = dcMem.SelectBitmap(m_bmSort[i]);
+                        RECT rc = {0,0,m_cxSortImage, m_cySortImage};
+                        pT->DrawSortBitmap(dcMem.m_hDC, i, &rc);
+                        dcMem.SelectBitmap(hbmOld);
+                        dcMem.DeleteDC();
+                }
+        }
+
+        void NotifyParentSortChanged(int iNewSortCol, int iOldSortCol)
+        {
+                T* pT = static_cast<T*>(this);
+                int nID = pT->GetDlgCtrlID();
+                NMSORTLISTVIEW nm = { { pT->m_hWnd, nID, SLVN_SORTCHANGED }, iNewSortCol, iOldSortCol };
+                ::SendMessage(pT->GetParent(), WM_NOTIFY, (WPARAM)nID, (LPARAM)&nm);
+        }
+
+// Overrideables
+        int CompareItemsCustom(LVCompareParam* /*pItem1*/, LVCompareParam* /*pItem2*/, int /*iSortCol*/)
+        {
+                // pItem1 and pItem2 contain valid iItem, dwItemData, and pszValue members.
+                // If item1 > item2 return 1, if item1 < item2 return -1, else return 0.
+                return 0;
+        }
+
+        void DrawSortBitmap(CDCHandle dc, int iBitmap, LPRECT prc)
+        {
+                dc.FillRect(prc, ::GetSysColorBrush(COLOR_BTNFACE));    
+                HBRUSH hbrOld = dc.SelectBrush(::GetSysColorBrush(COLOR_BTNSHADOW));
+                CPen pen;
+                pen.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_BTNSHADOW));
+                HPEN hpenOld = dc.SelectPen(pen);
+                POINT ptOrg = { (m_cxSortImage - m_cxSortArrow) / 2, (m_cySortImage - m_cySortArrow) / 2 };
+                if(iBitmap == m_iSortUp)
+                {
+                        POINT pts[3] = 
+                        {
+                                { ptOrg.x + m_cxSortArrow / 2, ptOrg.y },
+                                { ptOrg.x, ptOrg.y + m_cySortArrow - 1 }, 
+                                { ptOrg.x + m_cxSortArrow - 1, ptOrg.y + m_cySortArrow - 1 }
+                        };
+                        dc.Polygon(pts, 3);
+                }
+                else
+                {
+                        POINT pts[3] = 
+                        {
+                                { ptOrg.x, ptOrg.y },
+                                { ptOrg.x + m_cxSortArrow / 2, ptOrg.y + m_cySortArrow - 1 },
+                                { ptOrg.x + m_cxSortArrow - 1, ptOrg.y }
+                        };
+                        dc.Polygon(pts, 3);
+                }
+                dc.SelectBrush(hbrOld);
+                dc.SelectPen(hpenOld);
+        }
+
+        double DateStrToDouble(LPCTSTR lpstr, DWORD dwFlags)
+        {
+                ATLASSERT(lpstr != NULL);
+                if(lpstr == NULL || lpstr[0] == _T('\0'))
+                        return 0;
+
+                USES_CONVERSION;
+                HRESULT hRet = E_FAIL;
+                DATE dRet = 0;
+                if (FAILED(hRet = ::VarDateFromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, dwFlags, &dRet)))
+                {
+                        ATLTRACE2(atlTraceUI, 0, _T("VarDateFromStr failed with result of 0x%8.8X\n"), hRet);
+                        dRet = 0;
+                }
+                return dRet;
+        }
+
+        long StrToLong(LPCTSTR lpstr)
+        {
+                ATLASSERT(lpstr != NULL);
+                if(lpstr == NULL || lpstr[0] == _T('\0'))
+                        return 0;
+                
+                USES_CONVERSION;
+                HRESULT hRet = E_FAIL;
+                long lRet = 0;
+                if (FAILED(hRet = ::VarI4FromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, &lRet)))
+                {
+                        ATLTRACE2(atlTraceUI, 0, _T("VarI4FromStr failed with result of 0x%8.8X\n"), hRet);
+                        lRet = 0;
+                }
+                return lRet;
+        }
+
+        double StrToDouble(LPCTSTR lpstr)
+        {
+                ATLASSERT(lpstr != NULL);
+                if(lpstr == NULL || lpstr[0] == _T('\0'))
+                        return 0;
+
+                USES_CONVERSION;
+                HRESULT hRet = E_FAIL;
+                double dblRet = 0;
+                if (FAILED(hRet = ::VarR8FromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, &dblRet)))
+                {
+                        ATLTRACE2(atlTraceUI, 0, _T("VarR8FromStr failed with result of 0x%8.8X\n"), hRet);
+                        dblRet = 0;
+                }
+                return dblRet;
+        }
+
+        bool StrToDecimal(LPCTSTR lpstr, DECIMAL* pDecimal)
+        {
+                ATLASSERT(lpstr != NULL);
+                ATLASSERT(pDecimal != NULL);
+                if(lpstr == NULL || pDecimal == NULL)
+                        return false;
+
+                USES_CONVERSION;
+                HRESULT hRet = E_FAIL;
+                if (FAILED(hRet = ::VarDecFromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, pDecimal)))
+                {
+                        ATLTRACE2(atlTraceUI, 0, _T("VarDecFromStr failed with result of 0x%8.8X\n"), hRet);
+                        pDecimal->Lo64 = 0;
+                        pDecimal->Hi32 = 0;
+                        pDecimal->signscale = 0;
+                        return false;
+                }
+                return true;
+        }
+
+// Overrideable PFNLVCOMPARE functions
+        static int CALLBACK LVCompareText(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = lstrcmp(pParam1->pszValue, pParam2->pszValue);
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+
+        static int CALLBACK LVCompareTextNoCase(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = lstrcmpi(pParam1->pszValue, pParam2->pszValue);
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+
+        static int CALLBACK LVCompareLong(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = 0;
+                if(pParam1->lValue > pParam2->lValue)
+                        nRet = 1;
+                else if(pParam1->lValue < pParam2->lValue)
+                        nRet = -1;
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+
+        static int CALLBACK LVCompareDouble(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = 0;
+                if(pParam1->dblValue > pParam2->dblValue)
+                        nRet = 1;
+                else if(pParam1->dblValue < pParam2->dblValue)
+                        nRet = -1;
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+
+        static int CALLBACK LVCompareCustom(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = pInfo->pT->CompareItemsCustom(pParam1, pParam2, pInfo->iSortCol);
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+
+#ifndef _WIN32_WCE
+        static int CALLBACK LVCompareDecimal(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = (int)::VarDecCmp(&pParam1->decValue, &pParam2->decValue);
+                nRet--;
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+#else
+        // Compare mantissas, ignore sign and scale
+        static int CompareMantissas(const DECIMAL& decLeft, const DECIMAL& decRight)
+        {
+                if (decLeft.Hi32 < decRight.Hi32)
+                {
+                        return -1;
+                }
+                if (decLeft.Hi32 > decRight.Hi32)
+                {
+                        return 1;
+                }
+                // Here, decLeft.Hi32 == decRight.Hi32
+                if (decLeft.Lo64 < decRight.Lo64)
+                {
+                        return -1;
+                }
+                if (decLeft.Lo64 > decRight.Lo64)
+                {
+                        return 1;
+                }
+                return 0;
+        }
+
+        // return values: VARCMP_LT, VARCMP_EQ, VARCMP_GT, VARCMP_NULL
+        static HRESULT VarDecCmp(const DECIMAL* pdecLeft, const DECIMAL* pdecRight)
+        {
+                static const ULONG powersOfTen[] =
+                {
+                        10ul,
+                        100ul,
+                        1000ul,
+                        10000ul,
+                        100000ul,
+                        1000000ul,
+                        10000000ul,
+                        100000000ul,
+                        1000000000ul
+                };
+                static const int largestPower = sizeof(powersOfTen) / sizeof(powersOfTen[0]);
+                if (!pdecLeft || !pdecRight)
+                {
+                        return VARCMP_NULL;
+                }
+                
+                // Degenerate case - at least one comparand is of the form
+                // [+-]0*10^N (denormalized zero)
+                bool bLeftZero = (!pdecLeft->Lo64 && !pdecLeft->Hi32);
+                bool bRightZero = (!pdecRight->Lo64 && !pdecRight->Hi32);
+                if (bLeftZero && bRightZero)
+                {
+                        return VARCMP_EQ;
+                }
+                bool bLeftNeg = ((pdecLeft->sign & DECIMAL_NEG) != 0);
+                bool bRightNeg = ((pdecRight->sign & DECIMAL_NEG) != 0);
+                if (bLeftZero)
+                {
+                        return (bRightNeg ? VARCMP_GT : VARCMP_LT);
+                }
+                // This also covers the case where the comparands have different signs
+                if (bRightZero || bLeftNeg != bRightNeg)
+                {
+                        return (bLeftNeg ? VARCMP_LT : VARCMP_GT);
+                }
+
+                // Here both comparands have the same sign and need to be compared
+                // on mantissa and scale. The result is obvious when
+                // 1. Scales are equal (then compare mantissas)
+                // 2. A number with smaller scale is also the one with larger mantissa
+                //    (then this number is obviously larger)
+                // In the remaining case, we would multiply the number with smaller
+                // scale by 10 and simultaneously increment its scale (which amounts to
+                // adding trailing zeros after decimal point), until the numbers fall under
+                // one of the two cases above
+                DECIMAL temp;
+                bool bInvert = bLeftNeg; // the final result needs to be inverted
+                if (pdecLeft->scale < pdecRight->scale)
+                {
+                        temp = *pdecLeft;
+                }
+                else
+                {
+                        temp = *pdecRight;
+                        pdecRight = pdecLeft;
+                        bInvert = !bInvert;
+                }
+
+                // Now temp is the number with smaller (or equal) scale, and
+                // we can modify it freely without touching original parameters
+                int comp;
+                while ((comp = CompareMantissas(temp, *pdecRight)) < 0 &&
+                        temp.scale < pdecRight->scale)
+                {
+                        // Multiply by an appropriate power of 10
+                        int scaleDiff = pdecRight->scale - temp.scale;
+                        if (scaleDiff > largestPower)
+                        {
+                                // Keep the multiplier representable in 32bit
+                                scaleDiff = largestPower;
+                        }
+                        DWORDLONG power = powersOfTen[scaleDiff - 1];
+                        // Multiply temp's mantissa by power
+                        DWORDLONG product = temp.Lo32 * power;
+                        ULONG carry = static_cast<ULONG>(product >> 32);
+                        temp.Lo32  = static_cast<ULONG>(product);
+                        product = temp.Mid32 * power + carry;
+                        carry = static_cast<ULONG>(product >> 32);
+                        temp.Mid32 = static_cast<ULONG>(product);
+                        product = temp.Hi32 * power + carry;
+                        if (static_cast<ULONG>(product >> 32))
+                        {
+                                // Multiplication overflowed - pdecLeft is clearly larger
+                                break;
+                        }
+                        temp.Hi32 = static_cast<ULONG>(product);
+                        temp.scale = (BYTE)(temp.scale + scaleDiff);
+                }
+                if (temp.scale < pdecRight->scale)
+                {
+                        comp = 1;
+                }
+                if (bInvert)
+                {
+                        comp = -comp;
+                }
+                return (comp > 0 ? VARCMP_GT : comp < 0 ? VARCMP_LT : VARCMP_EQ);
+        }
+
+        static int CALLBACK LVCompareDecimal(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+        {
+                ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
+
+                LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
+                LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
+                LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
+                
+                int nRet = (int)VarDecCmp(&pParam1->decValue, &pParam2->decValue);
+                nRet--;
+                return pInfo->bDescending ? -nRet : nRet;
+        }
+#endif // !_WIN32_WCE
+
+        BEGIN_MSG_MAP(CSortListViewImpl)
+                MESSAGE_HANDLER(LVM_INSERTCOLUMN, OnInsertColumn)
+                MESSAGE_HANDLER(LVM_DELETECOLUMN, OnDeleteColumn)
+                NOTIFY_CODE_HANDLER(HDN_ITEMCLICKA, OnHeaderItemClick)
+                NOTIFY_CODE_HANDLER(HDN_ITEMCLICKW, OnHeaderItemClick)
+                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
+        END_MSG_MAP()
+
+        LRESULT OnInsertColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)     
+        {
+                T* pT = static_cast<T*>(this);
+                LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam);
+                if(lRet == -1)
+                        return -1;
+
+                WORD wType = 0;
+                m_arrColSortType.Add(wType);
+                int nCount = m_arrColSortType.GetSize();
+                ATLASSERT(nCount == GetColumnCount());
+
+                for(int i = nCount - 1; i > lRet; i--)
+                        m_arrColSortType[i] = m_arrColSortType[i - 1];
+                m_arrColSortType[(int)lRet] = LVCOLSORT_TEXT;
+
+                if(lRet <= m_iSortColumn)
+                        m_iSortColumn++;
+
+                return lRet;
+        }
+
+        LRESULT OnDeleteColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)     
+        {
+                T* pT = static_cast<T*>(this);
+                LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam);
+                if(lRet == 0)
+                        return 0;
+
+                int iCol = (int)wParam; 
+                if(m_iSortColumn == iCol)
+                        m_iSortColumn = -1;
+                else if(m_iSortColumn > iCol)
+                        m_iSortColumn--;
+                m_arrColSortType.RemoveAt(iCol);
+
+                return lRet;
+        }
+
+        LRESULT OnHeaderItemClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
+        {
+                LPNMHEADER p = (LPNMHEADER)pnmh;
+                if(p->iButton == 0)
+                {
+                        int iOld = m_iSortColumn;
+                        bool bDescending = (m_iSortColumn == p->iItem) ? !m_bSortDescending : false;
+                        if(DoSortItems(p->iItem, bDescending))
+                                NotifyParentSortChanged(p->iItem, iOld);                                
+                }
+                bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+#ifndef _WIN32_WCE
+                if(wParam == SPI_SETNONCLIENTMETRICS)
+                        GetSystemSettings();
+#else  // CE specific
+                wParam; // avoid level 4 warning
+                GetSystemSettings();
+#endif // _WIN32_WCE
+                bHandled = FALSE;
+                return 0;
+        }
+
+        void GetSystemSettings()
+        {
+                if(!m_bCommCtrl6 && !m_bmSort[m_iSortUp].IsNull())
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->CreateSortBitmaps();
+                        if(m_iSortColumn != -1)
+                                SetSortColumn(m_iSortColumn);
+                }
+        }
+
+};
+
+
+typedef ATL::CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | LVS_REPORT | LVS_SHOWSELALWAYS , WS_EX_CLIENTEDGE>   CSortListViewCtrlTraits;
+
+template <class T, class TBase = CListViewCtrl, class TWinTraits = CSortListViewCtrlTraits>
+class ATL_NO_VTABLE CSortListViewCtrlImpl: public ATL::CWindowImpl<T, TBase, TWinTraits>, public CSortListViewImpl<T>
+{
+public:
+        DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
+
+        bool SortItems(int iCol, bool bDescending = false)
+        {
+                return DoSortItems(iCol, bDescending);
+        }
+                
+        BEGIN_MSG_MAP(CSortListViewCtrlImpl)
+                MESSAGE_HANDLER(LVM_INSERTCOLUMN, CSortListViewImpl<T>::OnInsertColumn)
+                MESSAGE_HANDLER(LVM_DELETECOLUMN, CSortListViewImpl<T>::OnDeleteColumn)
+                NOTIFY_CODE_HANDLER(HDN_ITEMCLICKA, CSortListViewImpl<T>::OnHeaderItemClick)
+                NOTIFY_CODE_HANDLER(HDN_ITEMCLICKW, CSortListViewImpl<T>::OnHeaderItemClick)
+                MESSAGE_HANDLER(WM_SETTINGCHANGE, CSortListViewImpl<T>::OnSettingChange)
+        END_MSG_MAP()
+};
+
+class CSortListViewCtrl : public CSortListViewCtrlImpl<CSortListViewCtrl>
+{
+public:
+        DECLARE_WND_SUPERCLASS(_T("WTL_SortListViewCtrl"), GetWndClassName())
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CTabView - implements tab view window
+
+// TabView Notifications
+#define TBVN_PAGEACTIVATED   (0U-741)
+#define TBVN_CONTEXTMENU     (0U-742)
+
+// Notification data for TBVN_CONTEXTMENU
+struct TBVCONTEXTMENUINFO
+{
+        NMHDR hdr;
+        POINT pt;
+};
+
+typedef TBVCONTEXTMENUINFO* LPTBVCONTEXTMENUINFO;
+
+
+template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
+class ATL_NO_VTABLE CTabViewImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>
+{
+public:
+        DECLARE_WND_CLASS_EX(NULL, 0, COLOR_APPWORKSPACE)
+
+// Declarations and enums
+        struct TABVIEWPAGE
+        {
+                HWND hWnd;
+                LPTSTR lpstrTitle;
+                LPVOID pData;
+        };
+
+        struct TCITEMEXTRA
+        {
+                TCITEMHEADER tciheader;
+                TABVIEWPAGE tvpage;
+
+                operator LPTCITEM() { return (LPTCITEM)this; }
+        };
+
+        enum
+        {
+                m_nTabID = 1313,
+                m_cxMoveMark = 6,
+                m_cyMoveMark = 3,
+                m_nMenuItemsMax = (ID_WINDOW_TABLAST - ID_WINDOW_TABFIRST + 1)
+        };
+
+// Data members
+        ATL::CContainedWindowT<CTabCtrl> m_tab;
+        int m_cyTabHeight;
+
+        int m_nActivePage;
+
+        int m_nInsertItem;
+        POINT m_ptStartDrag;
+
+        CMenuHandle m_menu;
+
+        int m_cchTabTextLength;
+
+        int m_nMenuItemsCount;
+
+        ATL::CWindow m_wndTitleBar;
+        LPTSTR m_lpstrTitleBarBase;
+        int m_cchTitleBarLength;
+
+        CImageList m_ilDrag;
+
+        bool m_bDestroyPageOnRemove:1;
+        bool m_bDestroyImageList:1;
+        bool m_bActivePageMenuItem:1;
+        bool m_bActiveAsDefaultMenuItem:1;
+        bool m_bEmptyMenuItem:1;
+        bool m_bWindowsMenuItem:1;
+        // internal
+        bool m_bTabCapture:1;
+        bool m_bTabDrag:1;
+
+// Constructor/destructor
+        CTabViewImpl() :
+                        m_nActivePage(-1), 
+                        m_cyTabHeight(0), 
+                        m_tab(this, 1), 
+                        m_nInsertItem(-1), 
+                        m_cchTabTextLength(30), 
+                        m_nMenuItemsCount(10), 
+                        m_lpstrTitleBarBase(NULL), 
+                        m_cchTitleBarLength(100), 
+                        m_bDestroyPageOnRemove(true), 
+                        m_bDestroyImageList(true), 
+                        m_bActivePageMenuItem(true), 
+                        m_bActiveAsDefaultMenuItem(false), 
+                        m_bEmptyMenuItem(false), 
+                        m_bWindowsMenuItem(false), 
+                        m_bTabCapture(false), 
+                        m_bTabDrag(false)
+        {
+                m_ptStartDrag.x = 0;
+                m_ptStartDrag.y = 0;
+        }
+
+        ~CTabViewImpl()
+        {
+                delete [] m_lpstrTitleBarBase;
+        }
+
+// Message filter function - to be called from PreTranslateMessage of the main window
+        BOOL PreTranslateMessage(MSG* pMsg)
+        {
+                if(IsWindow() == FALSE)
+                        return FALSE;
+
+                BOOL bRet = FALSE;
+
+                // Check for TabView built-in accelerators (Ctrl+Tab/Ctrl+Shift+Tab - next/previous page)
+                int nCount = GetPageCount();
+                if(nCount > 0)
+                {
+                        bool bControl = (::GetKeyState(VK_CONTROL) < 0);
+                        if((pMsg->message == WM_KEYDOWN) && (pMsg->wParam == VK_TAB) && bControl)
+                        {
+                                if(nCount > 1)
+                                {
+                                        int nPage = m_nActivePage;
+                                        bool bShift = (::GetKeyState(VK_SHIFT) < 0);
+                                        if(bShift)
+                                                nPage = (nPage > 0) ? (nPage - 1) : (nCount - 1);
+                                        else
+                                                nPage = ((nPage >= 0) && (nPage < (nCount - 1))) ? (nPage + 1) : 0;
+
+                                        SetActivePage(nPage);
+                                        T* pT = static_cast<T*>(this);
+                                        pT->OnPageActivated(m_nActivePage);
+                                }
+
+                                bRet = TRUE;
+                        }
+                }
+
+                // If we are doing drag-drop, check for Escape key that cancels it
+                if(bRet == FALSE)
+                {
+                        if(m_bTabCapture && pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE)
+                        {
+                                ::ReleaseCapture();
+                                bRet = TRUE;
+                        }
+                }
+
+                // Pass the message to the active page
+                if(bRet == FALSE)
+                {
+                        if(m_nActivePage != -1)
+                                bRet = (BOOL)::SendMessage(GetPageHWND(m_nActivePage), WM_FORWARDMSG, 0, (LPARAM)pMsg);
+                }
+
+                return bRet;
+        }
+
+// Attributes
+        int GetPageCount() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return m_tab.GetItemCount();
+        }
+
+        int GetActivePage() const
+        {
+                return m_nActivePage;
+        }
+
+        void SetActivePage(int nPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                T* pT = static_cast<T*>(this);
+
+                SetRedraw(FALSE);
+
+                if(m_nActivePage != -1)
+                        ::ShowWindow(GetPageHWND(m_nActivePage), FALSE);
+                m_nActivePage = nPage;
+                m_tab.SetCurSel(m_nActivePage);
+                ::ShowWindow(GetPageHWND(m_nActivePage), TRUE);
+
+                pT->UpdateLayout();
+
+                SetRedraw(TRUE);
+                RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
+
+                if(::GetFocus() != m_tab.m_hWnd)
+                        ::SetFocus(GetPageHWND(m_nActivePage));
+
+                pT->UpdateTitleBar();
+                pT->UpdateMenu();
+        }
+
+        HIMAGELIST GetImageList() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return m_tab.GetImageList();
+        }
+
+        HIMAGELIST SetImageList(HIMAGELIST hImageList)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return m_tab.SetImageList(hImageList);
+        }
+
+        void SetWindowMenu(HMENU hMenu)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+
+                m_menu = hMenu;
+
+                T* pT = static_cast<T*>(this);
+                pT->UpdateMenu();
+        }
+
+        void SetTitleBarWindow(HWND hWnd)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+
+                delete [] m_lpstrTitleBarBase;
+                m_lpstrTitleBarBase = NULL;
+
+                m_wndTitleBar = hWnd;
+                if(hWnd == NULL)
+                        return;
+
+                int cchLen = m_wndTitleBar.GetWindowTextLength() + 1;
+                ATLTRY(m_lpstrTitleBarBase = new TCHAR[cchLen]);
+                if(m_lpstrTitleBarBase != NULL)
+                {
+                        m_wndTitleBar.GetWindowText(m_lpstrTitleBarBase, cchLen);
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdateTitleBar();
+                }
+        }
+
+// Page attributes
+        HWND GetPageHWND(int nPage) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_PARAM;
+                m_tab.GetItem(nPage, tcix);
+
+                return tcix.tvpage.hWnd;
+        }
+
+        LPCTSTR GetPageTitle(int nPage) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_PARAM;
+                if(m_tab.GetItem(nPage, tcix) == FALSE)
+                        return NULL;
+
+                return tcix.tvpage.lpstrTitle;
+        }
+
+        bool SetPageTitle(int nPage, LPCTSTR lpstrTitle)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                T* pT = static_cast<T*>(this);
+
+                int cchBuff = lstrlen(lpstrTitle) + 1;
+                LPTSTR lpstrBuff = NULL;
+                ATLTRY(lpstrBuff = new TCHAR[cchBuff]);
+                if(lpstrBuff == NULL)
+                        return false;
+
+                SecureHelper::strcpy_x(lpstrBuff, cchBuff, lpstrTitle);
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_PARAM;
+                if(m_tab.GetItem(nPage, tcix) == FALSE)
+                        return false;
+
+                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
+                if(lpstrTabText == NULL)
+                        return false;
+
+                delete [] tcix.tvpage.lpstrTitle;
+
+                pT->ShortenTitle(lpstrTitle, lpstrTabText, m_cchTabTextLength + 1);
+
+                tcix.tciheader.mask = TCIF_TEXT | TCIF_PARAM;
+                tcix.tciheader.pszText = lpstrTabText;
+                tcix.tvpage.lpstrTitle = lpstrBuff;
+                if(m_tab.SetItem(nPage, tcix) == FALSE)
+                        return false;
+
+                pT->UpdateTitleBar();
+                pT->UpdateMenu();
+
+                return true;
+        }
+
+        LPVOID GetPageData(int nPage) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_PARAM;
+                m_tab.GetItem(nPage, tcix);
+
+                return tcix.tvpage.pData;
+        }
+
+        LPVOID SetPageData(int nPage, LPVOID pData)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_PARAM;
+                m_tab.GetItem(nPage, tcix);
+                LPVOID pDataOld = tcix.tvpage.pData;
+
+                tcix.tvpage.pData = pData;
+                m_tab.SetItem(nPage, tcix);
+
+                return pDataOld;
+        }
+
+        int GetPageImage(int nPage) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_IMAGE;
+                m_tab.GetItem(nPage, tcix);
+
+                return tcix.tciheader.iImage;
+        }
+
+        int SetPageImage(int nPage, int nImage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_IMAGE;
+                m_tab.GetItem(nPage, tcix);
+                int nImageOld = tcix.tciheader.iImage;
+
+                tcix.tciheader.iImage = nImage;
+                m_tab.SetItem(nPage, tcix);
+
+                return nImageOld;
+        }
+
+// Operations
+        bool AddPage(HWND hWndView, LPCTSTR lpstrTitle, int nImage = -1, LPVOID pData = NULL)
+        {
+                return InsertPage(GetPageCount(), hWndView, lpstrTitle, nImage, pData);
+        }
+
+        bool InsertPage(int nPage, HWND hWndView, LPCTSTR lpstrTitle, int nImage = -1, LPVOID pData = NULL)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(nPage == GetPageCount() || IsValidPageIndex(nPage));
+
+                T* pT = static_cast<T*>(this);
+
+                int cchBuff = lstrlen(lpstrTitle) + 1;
+                LPTSTR lpstrBuff = NULL;
+                ATLTRY(lpstrBuff = new TCHAR[cchBuff]);
+                if(lpstrBuff == NULL)
+                        return false;
+
+                SecureHelper::strcpy_x(lpstrBuff, cchBuff, lpstrTitle);
+
+                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
+                if(lpstrTabText == NULL)
+                        return false;
+
+                pT->ShortenTitle(lpstrTitle, lpstrTabText, m_cchTabTextLength + 1);
+
+                SetRedraw(FALSE);
+
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
+                tcix.tciheader.pszText = lpstrTabText;
+                tcix.tciheader.iImage = nImage;
+                tcix.tvpage.hWnd = hWndView;
+                tcix.tvpage.lpstrTitle = lpstrBuff;
+                tcix.tvpage.pData = pData;
+                int nItem = m_tab.InsertItem(nPage, tcix);
+                if(nItem == -1)
+                {
+                        delete [] lpstrBuff;
+                        SetRedraw(TRUE);
+                        return false;
+                }
+
+                SetActivePage(nItem);
+                pT->OnPageActivated(m_nActivePage);
+
+                if(GetPageCount() == 1)
+                        pT->ShowTabControl(true);
+
+                pT->UpdateLayout();
+
+                SetRedraw(TRUE);
+                RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
+
+                return true;
+        }
+
+        void RemovePage(int nPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(IsValidPageIndex(nPage));
+
+                T* pT = static_cast<T*>(this);
+
+                SetRedraw(FALSE);
+
+                if(GetPageCount() == 1)
+                        pT->ShowTabControl(false);
+
+                if(m_bDestroyPageOnRemove)
+                        ::DestroyWindow(GetPageHWND(nPage));
+                else
+                        ::ShowWindow(GetPageHWND(nPage), FALSE);
+                LPTSTR lpstrTitle = (LPTSTR)GetPageTitle(nPage);
+                delete [] lpstrTitle;
+
+                ATLVERIFY(m_tab.DeleteItem(nPage) != FALSE);
+
+                if(m_nActivePage == nPage)
+                {
+                        m_nActivePage = -1;
+
+                        if(nPage > 0)
+                        {
+                                SetActivePage(nPage - 1);
+                        }
+                        else if(GetPageCount() > 0)
+                        {
+                                SetActivePage(nPage);
+                        }
+                        else
+                        {
+                                SetRedraw(TRUE);
+                                Invalidate();
+                                UpdateWindow();
+                                pT->UpdateTitleBar();
+                                pT->UpdateMenu();
+                        }
+                }
+                else
+                {
+                        nPage = (nPage < m_nActivePage) ? (m_nActivePage - 1) : m_nActivePage;
+                        m_nActivePage = -1;
+                        SetActivePage(nPage);
+                }
+
+                pT->OnPageActivated(m_nActivePage);
+        }
+
+        void RemoveAllPages()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+
+                if(GetPageCount() == 0)
+                        return;
+
+                T* pT = static_cast<T*>(this);
+
+                SetRedraw(FALSE);
+
+                pT->ShowTabControl(false);
+
+                for(int i = 0; i < GetPageCount(); i++)
+                {
+                        if(m_bDestroyPageOnRemove)
+                                ::DestroyWindow(GetPageHWND(i));
+                        else
+                                ::ShowWindow(GetPageHWND(i), FALSE);
+                        LPTSTR lpstrTitle = (LPTSTR)GetPageTitle(i);
+                        delete [] lpstrTitle;
+                }
+                m_tab.DeleteAllItems();
+
+                m_nActivePage = -1;
+                pT->OnPageActivated(m_nActivePage);
+
+                SetRedraw(TRUE);
+                Invalidate();
+                UpdateWindow();
+
+                pT->UpdateTitleBar();
+                pT->UpdateMenu();
+        }
+
+        int PageIndexFromHwnd(HWND hWnd) const
+        {
+                int nIndex = -1;
+
+                for(int i = 0; i < GetPageCount(); i++)
+                {
+                        if(GetPageHWND(i) == hWnd)
+                        {
+                                nIndex = i;
+                                break;
+                        }
+                }
+
+                return nIndex;
+        }
+
+        void BuildWindowMenu(HMENU hMenu, int nMenuItemsCount = 10, bool bEmptyMenuItem = true, bool bWindowsMenuItem = true, bool bActivePageMenuItem = true, bool bActiveAsDefaultMenuItem = false)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+
+                CMenuHandle menu = hMenu;
+                T* pT = static_cast<T*>(this);
+                pT;   // avoid level 4 warning
+                int nFirstPos = 0;
+
+                // Find first menu item in our range
+#ifndef _WIN32_WCE
+                for(nFirstPos = 0; nFirstPos < menu.GetMenuItemCount(); nFirstPos++)
+                {
+                        UINT nID = menu.GetMenuItemID(nFirstPos);
+                        if((nID >= ID_WINDOW_TABFIRST && nID <= ID_WINDOW_TABLAST) || nID == ID_WINDOW_SHOWTABLIST)
+                                break;
+                }
+#else // CE specific
+                for(nFirstPos = 0; ; nFirstPos++)
+                {
+                        CMenuItemInfo mii;
+                        mii.fMask = MIIM_ID;
+                        BOOL bRet = menu.GetMenuItemInfo(nFirstPos, TRUE, &mii);
+                        if(bRet == FALSE)
+                                break;
+                        if((mii.wID >= ID_WINDOW_TABFIRST && mii.wID <= ID_WINDOW_TABLAST) || mii.wID == ID_WINDOW_SHOWTABLIST)
+                                break;
+                }
+#endif // _WIN32_WCE
+
+                // Remove all menu items for tab pages
+                BOOL bRet = TRUE;
+                while(bRet != FALSE)
+                        bRet = menu.DeleteMenu(nFirstPos, MF_BYPOSITION);
+
+                // Add separator if it's not already there
+                int nPageCount = GetPageCount();
+                if((bWindowsMenuItem || (nPageCount > 0)) && (nFirstPos > 0))
+                {
+                        CMenuItemInfo mii;
+                        mii.fMask = MIIM_TYPE;
+                        menu.GetMenuItemInfo(nFirstPos - 1, TRUE, &mii);
+                        if((nFirstPos <= 0) || ((mii.fType & MFT_SEPARATOR) == 0))
+                        {
+                                menu.AppendMenu(MF_SEPARATOR);
+                                nFirstPos++;
+                        }
+                }
+
+                // Add menu items for all pages
+                if(nPageCount > 0)
+                {
+                        // Append menu items for all pages
+                        const int cchPrefix = 3;   // 2 digits + space
+                        nMenuItemsCount = __min(min(nPageCount, nMenuItemsCount), (int)m_nMenuItemsMax);
+                        ATLASSERT(nMenuItemsCount < 100);   // 2 digits only
+                        if(nMenuItemsCount >= 100)
+                                nMenuItemsCount = 99;
+
+                        for(int i = 0; i < nMenuItemsCount; i++)
+                        {
+                                LPCTSTR lpstrTitle = GetPageTitle(i);
+                                int nLen = lstrlen(lpstrTitle);
+                                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                                LPTSTR lpstrText = buff.Allocate(cchPrefix + nLen + 1);
+                                ATLASSERT(lpstrText != NULL);
+                                if(lpstrText != NULL)
+                                {
+                                        LPCTSTR lpstrFormat = (i < 9) ? _T("&%i %s") : _T("%i %s");
+                                        SecureHelper::wsprintf_x(lpstrText, cchPrefix + nLen + 1, lpstrFormat, i + 1, lpstrTitle);
+                                        menu.AppendMenu(MF_STRING, ID_WINDOW_TABFIRST + i, lpstrText);
+                                }
+                        }
+
+                        // Mark active page
+                        if(bActivePageMenuItem && (m_nActivePage != -1))
+                        {
+#ifndef _WIN32_WCE
+                                if(bActiveAsDefaultMenuItem)
+                                {
+                                        menu.SetMenuDefaultItem((UINT)-1,  TRUE);
+                                        menu.SetMenuDefaultItem(nFirstPos + m_nActivePage,  TRUE);
+                                }
+                                else
+#else // CE specific
+                                bActiveAsDefaultMenuItem;   // avoid level 4 warning
+#endif // _WIN32_WCE
+                                {
+                                        menu.CheckMenuRadioItem(nFirstPos, nFirstPos + nMenuItemsCount, nFirstPos + m_nActivePage, MF_BYPOSITION);
+                                }
+                        }
+                }
+                else
+                {
+                        if(bEmptyMenuItem)
+                        {
+                                menu.AppendMenu(MF_BYPOSITION | MF_STRING, ID_WINDOW_TABFIRST, pT->GetEmptyListText());
+                                menu.EnableMenuItem(ID_WINDOW_TABFIRST, MF_GRAYED);
+                        }
+
+                        // Remove separator if nothing else is there
+                        if(!bEmptyMenuItem && !bWindowsMenuItem && (nFirstPos > 0))
+                        {
+                                CMenuItemInfo mii;
+                                mii.fMask = MIIM_TYPE;
+                                menu.GetMenuItemInfo(nFirstPos - 1, TRUE, &mii);
+                                if((mii.fType & MFT_SEPARATOR) != 0)
+                                        menu.DeleteMenu(nFirstPos - 1, MF_BYPOSITION);
+                        }
+                }
+
+                // Add "Windows..." menu item
+                if(bWindowsMenuItem)
+                        menu.AppendMenu(MF_BYPOSITION | MF_STRING, ID_WINDOW_SHOWTABLIST, pT->GetWindowsMenuItemText());
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CTabViewImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+                MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+                MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
+                NOTIFY_HANDLER(m_nTabID, TCN_SELCHANGE, OnTabChanged)
+                NOTIFY_ID_HANDLER(m_nTabID, OnTabNotification)
+#ifndef _WIN32_WCE
+                NOTIFY_CODE_HANDLER(TTN_GETDISPINFO, OnTabGetDispInfo)
+#endif // !_WIN32_WCE
+                FORWARD_NOTIFICATIONS()
+        ALT_MSG_MAP(1)   // tab control
+                MESSAGE_HANDLER(WM_LBUTTONDOWN, OnTabLButtonDown)
+                MESSAGE_HANDLER(WM_LBUTTONUP, OnTabLButtonUp)
+                MESSAGE_HANDLER(WM_CAPTURECHANGED, OnTabCaptureChanged)
+                MESSAGE_HANDLER(WM_MOUSEMOVE, OnTabMouseMove)
+                MESSAGE_HANDLER(WM_RBUTTONUP, OnTabRButtonUp)
+                MESSAGE_HANDLER(WM_SYSKEYDOWN, OnTabSysKeyDown)
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->CreateTabControl();
+
+                return 0;
+        }
+
+        LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                RemoveAllPages();
+
+                if(m_bDestroyImageList)
+                {
+                        CImageList il = m_tab.SetImageList(NULL);
+                        if(il.m_hImageList != NULL)
+                                il.Destroy();
+                }
+
+                return 0;
+        }
+
+        LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->UpdateLayout();
+                return 0;
+        }
+
+        LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(m_nActivePage != -1)
+                        ::SetFocus(GetPageHWND(m_nActivePage));
+                return 0;
+        }
+
+        LRESULT OnTabChanged(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
+        {
+                SetActivePage(m_tab.GetCurSel());
+                T* pT = static_cast<T*>(this);
+                pT->OnPageActivated(m_nActivePage);
+
+                return 0;
+        }
+
+        LRESULT OnTabNotification(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
+        {
+                // nothing to do - this just blocks all tab control
+                // notifications from being propagated further
+                return 0;
+        }
+
+#ifndef _WIN32_WCE
+        LRESULT OnTabGetDispInfo(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
+        {
+                LPNMTTDISPINFO pTTDI = (LPNMTTDISPINFO)pnmh;
+                if(pTTDI->hdr.hwndFrom == m_tab.GetTooltips())
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdateTooltipText(pTTDI);
+                }
+                else
+                {
+                        bHandled = FALSE;
+                }
+
+                return 0;
+        }
+#endif // !_WIN32_WCE
+
+// Tab control message handlers
+        LRESULT OnTabLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                if(m_tab.GetItemCount() > 1)
+                {
+                        m_bTabCapture = true;
+                        m_tab.SetCapture();
+
+                        m_ptStartDrag.x = GET_X_LPARAM(lParam);
+                        m_ptStartDrag.y = GET_Y_LPARAM(lParam);
+                }
+
+                bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnTabLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                if(m_bTabCapture)
+                {
+                        if(m_bTabDrag)
+                        {
+                                TCHITTESTINFO hti = { 0 };
+                                hti.pt.x = GET_X_LPARAM(lParam);
+                                hti.pt.y = GET_Y_LPARAM(lParam);
+                                int nItem = m_tab.HitTest(&hti);
+                                if(nItem != -1)
+                                        MovePage(m_nActivePage, nItem);
+                        }
+
+                        ::ReleaseCapture();
+                }
+
+                bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnTabCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(m_bTabCapture)
+                {
+                        m_bTabCapture = false;
+
+                        if(m_bTabDrag)
+                        {
+                                m_bTabDrag = false;
+                                T* pT = static_cast<T*>(this);
+                                pT->DrawMoveMark(-1);
+
+#ifndef _WIN32_WCE
+                                m_ilDrag.DragLeave(GetDesktopWindow());
+#endif // !_WIN32_WCE
+                                m_ilDrag.EndDrag();
+
+                                m_ilDrag.Destroy();
+                                m_ilDrag.m_hImageList = NULL;
+                        }
+                }
+
+                bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnTabMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                bHandled = FALSE;
+
+                if(m_bTabCapture)
+                {
+                        POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+
+                        if(!m_bTabDrag)
+                        {
+#ifndef _WIN32_WCE
+                                if(abs(m_ptStartDrag.x - GET_X_LPARAM(lParam)) >= ::GetSystemMetrics(SM_CXDRAG) ||
+                                   abs(m_ptStartDrag.y - GET_Y_LPARAM(lParam)) >= ::GetSystemMetrics(SM_CYDRAG))
+#else // CE specific
+                                if(abs(m_ptStartDrag.x - GET_X_LPARAM(lParam)) >= 4 ||
+                                   abs(m_ptStartDrag.y - GET_Y_LPARAM(lParam)) >= 4)
+#endif // _WIN32_WCE
+                                {
+                                        T* pT = static_cast<T*>(this);
+                                        pT->GenerateDragImage(m_nActivePage);
+
+                                        int cxCursor = ::GetSystemMetrics(SM_CXCURSOR);
+                                        int cyCursor = ::GetSystemMetrics(SM_CYCURSOR);
+                                        m_ilDrag.BeginDrag(0, -(cxCursor / 2), -(cyCursor / 2));
+#ifndef _WIN32_WCE
+                                        POINT ptEnter = m_ptStartDrag;
+                                        m_tab.ClientToScreen(&ptEnter);
+                                        m_ilDrag.DragEnter(GetDesktopWindow(), ptEnter);
+#endif // !_WIN32_WCE
+
+                                        m_bTabDrag = true;
+                                }
+                        }
+
+                        if(m_bTabDrag)
+                        {
+                                TCHITTESTINFO hti = { 0 };
+                                hti.pt = pt;
+                                int nItem = m_tab.HitTest(&hti);
+
+                                T* pT = static_cast<T*>(this);
+                                pT->SetMoveCursor(nItem != -1);
+
+                                if(m_nInsertItem != nItem)
+                                        pT->DrawMoveMark(nItem);
+
+                                m_ilDrag.DragShowNolock((nItem != -1) ? TRUE : FALSE);
+                                m_tab.ClientToScreen(&pt);
+                                m_ilDrag.DragMove(pt);
+
+                                bHandled = TRUE;
+                        }
+                }
+
+                return 0;
+        }
+
+        LRESULT OnTabRButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                TCHITTESTINFO hti = { 0 };
+                hti.pt.x = GET_X_LPARAM(lParam);
+                hti.pt.y = GET_Y_LPARAM(lParam);
+                int nItem = m_tab.HitTest(&hti);
+                if(nItem != -1)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->OnContextMenu(nItem, hti.pt);
+                }
+
+                return 0;
+        }
+
+        LRESULT OnTabSysKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                bool bShift = (::GetKeyState(VK_SHIFT) < 0);
+                if(wParam == VK_F10 && bShift)
+                {
+                        if(m_nActivePage != -1)
+                        {
+                                RECT rect = { 0 };
+                                m_tab.GetItemRect(m_nActivePage, &rect);
+                                POINT pt = { rect.left, rect.bottom };
+                                T* pT = static_cast<T*>(this);
+                                pT->OnContextMenu(m_nActivePage, pt);
+                        }
+                }
+                else
+                {
+                        bHandled = FALSE;
+                }
+
+                return 0;
+        }
+
+// Implementation helpers
+        bool IsValidPageIndex(int nPage) const
+        {
+                return (nPage >= 0 && nPage < GetPageCount());
+        }
+
+        bool MovePage(int nMovePage, int nInsertBeforePage)
+        {
+                ATLASSERT(IsValidPageIndex(nMovePage));
+                ATLASSERT(IsValidPageIndex(nInsertBeforePage));
+
+                if(!IsValidPageIndex(nMovePage) || !IsValidPageIndex(nInsertBeforePage))
+                        return false;
+
+                if(nMovePage == nInsertBeforePage)
+                        return true;   // nothing to do
+
+                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
+                if(lpstrTabText == NULL)
+                        return false;
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
+                tcix.tciheader.pszText = lpstrTabText;
+                tcix.tciheader.cchTextMax = m_cchTabTextLength + 1;
+                BOOL bRet = m_tab.GetItem(nMovePage, tcix);
+                ATLASSERT(bRet != FALSE);
+                if(bRet == FALSE)
+                        return false;
+
+                int nInsertItem = (nInsertBeforePage > nMovePage) ? nInsertBeforePage + 1 : nInsertBeforePage;
+                int nNewItem = m_tab.InsertItem(nInsertItem, tcix);
+                ATLASSERT(nNewItem == nInsertItem);
+                if(nNewItem != nInsertItem)
+                {
+                        ATLVERIFY(m_tab.DeleteItem(nNewItem));
+                        return false;
+                }
+
+                if(nMovePage > nInsertBeforePage)
+                        ATLVERIFY(m_tab.DeleteItem(nMovePage + 1) != FALSE);
+                else if(nMovePage < nInsertBeforePage)
+                        ATLVERIFY(m_tab.DeleteItem(nMovePage) != FALSE);
+
+                SetActivePage(nInsertBeforePage);
+                T* pT = static_cast<T*>(this);
+                pT->OnPageActivated(m_nActivePage);
+
+                return true;
+        }
+
+// Implementation overrideables
+        bool CreateTabControl()
+        {
+#ifndef _WIN32_WCE
+                m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_TOOLTIPS, 0, m_nTabID);
+#else // CE specific
+                m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0, m_nTabID);
+#endif // _WIN32_WCE
+                ATLASSERT(m_tab.m_hWnd != NULL);
+                if(m_tab.m_hWnd == NULL)
+                        return false;
+
+                m_tab.SetFont(AtlGetDefaultGuiFont());
+
+                m_tab.SetItemExtra(sizeof(TABVIEWPAGE));
+
+                T* pT = static_cast<T*>(this);
+                m_cyTabHeight = pT->CalcTabHeight();
+
+                return true;
+        }
+
+        int CalcTabHeight()
+        {
+                int nCount = m_tab.GetItemCount();
+                TCITEMEXTRA tcix = { 0 };
+                tcix.tciheader.mask = TCIF_TEXT;
+                tcix.tciheader.pszText = _T("NS");
+                int nIndex = m_tab.InsertItem(nCount, tcix);
+
+                RECT rect = { 0, 0, 1000, 1000 };
+                m_tab.AdjustRect(FALSE, &rect);
+
+                RECT rcWnd = { 0, 0, 1000, rect.top };
+                ::AdjustWindowRectEx(&rcWnd, m_tab.GetStyle(), FALSE, m_tab.GetExStyle());
+
+                int nHeight = rcWnd.bottom - rcWnd.top;
+
+                m_tab.DeleteItem(nIndex);
+
+                return nHeight;
+        }
+
+        void ShowTabControl(bool bShow)
+        {
+                m_tab.ShowWindow(bShow ? SW_SHOWNOACTIVATE : SW_HIDE);
+        }
+
+        void UpdateLayout()
+        {
+                RECT rect;
+                GetClientRect(&rect);
+
+                if(m_tab.IsWindow() && ((m_tab.GetStyle() & WS_VISIBLE) != 0))
+                        m_tab.SetWindowPos(NULL, 0, 0, rect.right - rect.left, m_cyTabHeight, SWP_NOZORDER);
+
+                if(m_nActivePage != -1)
+                        ::SetWindowPos(GetPageHWND(m_nActivePage), NULL, 0, m_cyTabHeight, rect.right - rect.left, rect.bottom - rect.top - m_cyTabHeight, SWP_NOZORDER);
+        }
+
+        void UpdateMenu()
+        {
+                if(m_menu.m_hMenu != NULL)
+                        BuildWindowMenu(m_menu, m_nMenuItemsCount, m_bEmptyMenuItem, m_bWindowsMenuItem, m_bActivePageMenuItem, m_bActiveAsDefaultMenuItem);
+        }
+
+        void UpdateTitleBar()
+        {
+                if(!m_wndTitleBar.IsWindow() || m_lpstrTitleBarBase == NULL)
+                        return;   // nothing to do
+
+                if(m_nActivePage != -1)
+                {
+                        T* pT = static_cast<T*>(this);
+                        LPCTSTR lpstrTitle = pT->GetPageTitle(m_nActivePage);
+                        LPCTSTR lpstrDivider = pT->GetTitleDividerText();
+                        int cchBuffer = m_cchTitleBarLength + lstrlen(lpstrDivider) + lstrlen(m_lpstrTitleBarBase) + 1;
+                        CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
+                        LPTSTR lpstrPageTitle = buff.Allocate(cchBuffer);
+                        ATLASSERT(lpstrPageTitle != NULL);
+                        if(lpstrPageTitle != NULL)
+                        {
+                                pT->ShortenTitle(lpstrTitle, lpstrPageTitle, m_cchTitleBarLength + 1);
+                                SecureHelper::strcat_x(lpstrPageTitle, cchBuffer, lpstrDivider);
+                                SecureHelper::strcat_x(lpstrPageTitle, cchBuffer, m_lpstrTitleBarBase);
+                        }
+                        else
+                        {
+                                lpstrPageTitle = m_lpstrTitleBarBase;
+                        }
+
+                        m_wndTitleBar.SetWindowText(lpstrPageTitle);
+                }
+                else
+                {
+                        m_wndTitleBar.SetWindowText(m_lpstrTitleBarBase);
+                }
+        }
+
+        void DrawMoveMark(int nItem)
+        {
+                T* pT = static_cast<T*>(this);
+
+                if(m_nInsertItem != -1)
+                {
+                        RECT rect = { 0 };
+                        pT->GetMoveMarkRect(rect);
+                        m_tab.InvalidateRect(&rect);
+                }
+
+                m_nInsertItem = nItem;
+
+                if(m_nInsertItem != -1)
+                {
+                        CClientDC dc(m_tab.m_hWnd);
+
+                        RECT rect = { 0 };
+                        pT->GetMoveMarkRect(rect);
+
+                        CPen pen;
+                        pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_WINDOWTEXT));
+                        CBrush brush;
+                        brush.CreateSolidBrush(::GetSysColor(COLOR_WINDOWTEXT));
+
+                        HPEN hPenOld = dc.SelectPen(pen);
+                        HBRUSH hBrushOld = dc.SelectBrush(brush);
+
+                        int x = rect.left;
+                        int y = rect.top;
+                        POINT ptsTop[3] = { { x, y }, { x + m_cxMoveMark, y }, { x + (m_cxMoveMark / 2), y + m_cyMoveMark } };
+                        dc.Polygon(ptsTop, 3);
+
+                        y = rect.bottom - 1;
+                        POINT ptsBottom[3] = { { x, y }, { x + m_cxMoveMark, y }, { x + (m_cxMoveMark / 2), y - m_cyMoveMark } };
+                        dc.Polygon(ptsBottom, 3);
+
+                        dc.SelectPen(hPenOld);
+                        dc.SelectBrush(hBrushOld);
+                }
+        }
+
+        void GetMoveMarkRect(RECT& rect) const
+        {
+                m_tab.GetClientRect(&rect);
+
+                RECT rcItem = { 0 };
+                m_tab.GetItemRect(m_nInsertItem, &rcItem);
+
+                if(m_nInsertItem <= m_nActivePage)
+                {
+                        rect.left = rcItem.left - m_cxMoveMark / 2 - 1;
+                        rect.right = rcItem.left + m_cxMoveMark / 2;
+                }
+                else
+                {
+                        rect.left = rcItem.right - m_cxMoveMark / 2 - 1;
+                        rect.right = rcItem.right + m_cxMoveMark / 2;
+                }
+        }
+
+        void SetMoveCursor(bool bCanMove)
+        {
+                ::SetCursor(::LoadCursor(NULL, bCanMove ? IDC_ARROW : IDC_NO));
+        }
+
+        void GenerateDragImage(int nItem)
+        {
+                ATLASSERT(IsValidPageIndex(nItem));
+
+#ifndef _WIN32_WCE
+                RECT rcItem = { 0 };
+                m_tab.GetItemRect(nItem, &rcItem);
+                ::InflateRect(&rcItem, 2, 2);   // make bigger to cover selected item
+#else // CE specific
+                nItem;   // avoid level 4 warning
+                RECT rcItem = { 0, 0, 40, 20 };
+#endif // _WIN32_WCE
+
+                ATLASSERT(m_ilDrag.m_hImageList == NULL);
+                m_ilDrag.Create(rcItem.right - rcItem.left, rcItem.bottom - rcItem.top, ILC_COLORDDB | ILC_MASK, 1, 1);
+
+                CClientDC dc(m_hWnd);
+                CDC dcMem;
+                dcMem.CreateCompatibleDC(dc);
+                ATLASSERT(dcMem.m_hDC != NULL);
+                dcMem.SetViewportOrg(-rcItem.left, -rcItem.top);
+
+                CBitmap bmp;
+                bmp.CreateCompatibleBitmap(dc, rcItem.right - rcItem.left, rcItem.bottom - rcItem.top);
+                ATLASSERT(bmp.m_hBitmap != NULL);
+
+                HBITMAP hBmpOld = dcMem.SelectBitmap(bmp);
+#ifndef _WIN32_WCE
+                m_tab.SendMessage(WM_PRINTCLIENT, (WPARAM)dcMem.m_hDC);
+#else // CE specific
+                dcMem.Rectangle(&rcItem);
+#endif // _WIN32_WCE
+                dcMem.SelectBitmap(hBmpOld);
+
+                ATLVERIFY(m_ilDrag.Add(bmp.m_hBitmap, RGB(255, 0, 255)) != -1);
+        }
+
+        void ShortenTitle(LPCTSTR lpstrTitle, LPTSTR lpstrShortTitle, int cchShortTitle)
+        {
+                if(lstrlen(lpstrTitle) >= cchShortTitle)
+                {
+                        LPCTSTR lpstrEllipsis = _T("...");
+                        int cchEllipsis = lstrlen(lpstrEllipsis);
+                        SecureHelper::strncpy_x(lpstrShortTitle, cchShortTitle, lpstrTitle, cchShortTitle - cchEllipsis - 1);
+                        SecureHelper::strcat_x(lpstrShortTitle, cchShortTitle, lpstrEllipsis);
+                }
+                else
+                {
+                        SecureHelper::strcpy_x(lpstrShortTitle, cchShortTitle, lpstrTitle);
+                }
+        }
+
+#ifndef _WIN32_WCE
+        void UpdateTooltipText(LPNMTTDISPINFO pTTDI)
+        {
+                ATLASSERT(pTTDI != NULL);
+                pTTDI->lpszText = (LPTSTR)GetPageTitle((int)pTTDI->hdr.idFrom);
+        }
+#endif // !_WIN32_WCE
+
+// Text for menu items and title bar - override to provide different strings
+        static LPCTSTR GetEmptyListText()
+        {
+                return _T("(Empty)");
+        }
+
+        static LPCTSTR GetWindowsMenuItemText()
+        {
+                return _T("&Windows...");
+        }
+
+        static LPCTSTR GetTitleDividerText()
+        {
+                return _T(" - ");
+        }
+
+// Notifications - override to provide different behavior
+        void OnPageActivated(int nPage)
+        {
+                NMHDR nmhdr = { 0 };
+                nmhdr.hwndFrom = m_hWnd;
+                nmhdr.idFrom = nPage;
+                nmhdr.code = TBVN_PAGEACTIVATED;
+                ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nmhdr);
+        }
+
+        void OnContextMenu(int nPage, POINT pt)
+        {
+                m_tab.ClientToScreen(&pt);
+
+                TBVCONTEXTMENUINFO cmi = { 0 };
+                cmi.hdr.hwndFrom = m_hWnd;
+                cmi.hdr.idFrom = nPage;
+                cmi.hdr.code = TBVN_CONTEXTMENU;
+                cmi.pt = pt;
+                ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&cmi);
+        }
+};
+
+
+class CTabView : public CTabViewImpl<CTabView>
+{
+public:
+        DECLARE_WND_CLASS_EX(_T("WTL_TabView"), 0, COLOR_APPWORKSPACE)
+};
+
+}; // namespace WTL
+
+#endif // __ATLCTRLX_H__