More Windows build fixes.

third_party/wtl/include/atlsplit.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 __ATLSPLIT_H__
+#define __ATLSPLIT_H__
+
+#pragma once
+
+#ifndef __cplusplus
+        #error ATL requires C++ compilation (use a .cpp suffix)
+#endif
+
+#ifndef __ATLAPP_H__
+        #error atlsplit.h requires atlapp.h to be included first
+#endif
+
+#ifndef __ATLWIN_H__
+        #error atlsplit.h requires atlwin.h to be included first
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Classes in this file:
+//
+// CSplitterImpl<T, t_bVertical>
+// CSplitterWindowImpl<T, t_bVertical, TBase, TWinTraits>
+// CSplitterWindowT<t_bVertical>
+
+
+namespace WTL
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// CSplitterImpl - Provides splitter support to any window
+
+// Splitter panes constants
+#define SPLIT_PANE_LEFT                  0
+#define SPLIT_PANE_RIGHT                 1
+#define SPLIT_PANE_TOP                   SPLIT_PANE_LEFT
+#define SPLIT_PANE_BOTTOM                SPLIT_PANE_RIGHT
+#define SPLIT_PANE_NONE                 -1
+
+// Splitter extended styles
+#define SPLIT_PROPORTIONAL              0x00000001
+#define SPLIT_NONINTERACTIVE            0x00000002
+#define SPLIT_RIGHTALIGNED              0x00000004
+#define SPLIT_BOTTOMALIGNED             SPLIT_RIGHTALIGNED
+
+// Note: SPLIT_PROPORTIONAL and SPLIT_RIGHTALIGNED/SPLIT_BOTTOMALIGNED are 
+// mutually exclusive. If both are set, splitter defaults to SPLIT_PROPORTIONAL
+
+
+template <class T, bool t_bVertical = true>
+class CSplitterImpl
+{
+public:
+        enum { m_nPanesCount = 2, m_nPropMax = 10000 };
+
+        HWND m_hWndPane[m_nPanesCount];
+        RECT m_rcSplitter;
+        int m_xySplitterPos;
+        int m_nDefActivePane;
+        int m_cxySplitBar;              // splitter bar width/height
+        static HCURSOR m_hCursor;
+        int m_cxyMin;                   // minimum pane size
+        int m_cxyBarEdge;               // splitter bar edge
+        bool m_bFullDrag;
+        int m_cxyDragOffset;
+        int m_nProportionalPos;
+        bool m_bUpdateProportionalPos;
+        DWORD m_dwExtendedStyle;       // splitter specific extended styles
+        int m_nSinglePane;             // single pane mode
+
+// Constructor
+        CSplitterImpl() :
+                        m_xySplitterPos(-1), m_nDefActivePane(SPLIT_PANE_NONE), 
+                        m_cxySplitBar(0), m_cxyMin(0), m_cxyBarEdge(0), m_bFullDrag(true), 
+                        m_cxyDragOffset(0), m_nProportionalPos(0), m_bUpdateProportionalPos(true),
+                        m_dwExtendedStyle(SPLIT_PROPORTIONAL),
+                        m_nSinglePane(SPLIT_PANE_NONE)
+        {
+                m_hWndPane[SPLIT_PANE_LEFT] = NULL;
+                m_hWndPane[SPLIT_PANE_RIGHT] = NULL;
+
+                ::SetRectEmpty(&m_rcSplitter);
+
+                if(m_hCursor == NULL)
+                {
+                        CStaticDataInitCriticalSectionLock lock;
+                        if(FAILED(lock.Lock()))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CSplitterImpl::CSplitterImpl.\n"));
+                                ATLASSERT(FALSE);
+                                return;
+                        }
+
+                        if(m_hCursor == NULL)
+                                m_hCursor = ::LoadCursor(NULL, t_bVertical ? IDC_SIZEWE : IDC_SIZENS);
+
+                        lock.Unlock();
+                }
+        }
+
+// Attributes
+        void SetSplitterRect(LPRECT lpRect = NULL, bool bUpdate = true)
+        {
+                if(lpRect == NULL)
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->GetClientRect(&m_rcSplitter);
+                }
+                else
+                {
+                        m_rcSplitter = *lpRect;
+                }
+
+                if(IsProportional())
+                        UpdateProportionalPos();
+                else if(IsRightAligned())
+                        UpdateRightAlignPos();
+
+                if(bUpdate)
+                        UpdateSplitterLayout();
+        }
+
+        void GetSplitterRect(LPRECT lpRect) const
+        {
+                ATLASSERT(lpRect != NULL);
+                *lpRect = m_rcSplitter;
+        }
+
+        bool SetSplitterPos(int xyPos = -1, bool bUpdate = true)
+        {
+                if(xyPos == -1)   // -1 == middle
+                {
+                        if(t_bVertical)
+                                xyPos = (m_rcSplitter.right - m_rcSplitter.left - m_cxySplitBar - m_cxyBarEdge) / 2;
+                        else
+                                xyPos = (m_rcSplitter.bottom - m_rcSplitter.top - m_cxySplitBar - m_cxyBarEdge) / 2;
+                }
+
+                // Adjust if out of valid range
+                int cxyMax = 0;
+                if(t_bVertical)
+                        cxyMax = m_rcSplitter.right - m_rcSplitter.left;
+                else
+                        cxyMax = m_rcSplitter.bottom - m_rcSplitter.top;
+
+                if(xyPos < m_cxyMin + m_cxyBarEdge)
+                        xyPos = m_cxyMin;
+                else if(xyPos > (cxyMax - m_cxySplitBar - m_cxyBarEdge - m_cxyMin))
+                        xyPos = cxyMax - m_cxySplitBar - m_cxyBarEdge - m_cxyMin;
+
+                // Set new position and update if requested
+                bool bRet = (m_xySplitterPos != xyPos);
+                m_xySplitterPos = xyPos;
+
+                if(m_bUpdateProportionalPos)
+                {
+                        if(IsProportional())
+                                StoreProportionalPos();
+                        else if(IsRightAligned())
+                                StoreRightAlignPos();
+                }
+                else
+                {
+                        m_bUpdateProportionalPos = true;
+                }
+
+                if(bUpdate && bRet)
+                        UpdateSplitterLayout();
+
+                return bRet;
+        }
+
+        void SetSplitterPosPct(int nPct, bool bUpdate = true)
+        {
+                ATLASSERT(nPct >= 0 && nPct <= 100);
+
+                m_nProportionalPos = ::MulDiv(nPct, m_nPropMax, 100);
+                UpdateProportionalPos();
+
+                if(bUpdate)
+                        UpdateSplitterLayout();
+        }
+
+        int GetSplitterPos() const
+        {
+                return m_xySplitterPos;
+        }
+
+        bool SetSinglePaneMode(int nPane = SPLIT_PANE_NONE)
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT || nPane == SPLIT_PANE_NONE);
+                if(!(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT || nPane == SPLIT_PANE_NONE))
+                        return false;
+
+                if(nPane != SPLIT_PANE_NONE)
+                {
+                        if(!::IsWindowVisible(m_hWndPane[nPane]))
+                                ::ShowWindow(m_hWndPane[nPane], SW_SHOW);
+                        int nOtherPane = (nPane == SPLIT_PANE_LEFT) ? SPLIT_PANE_RIGHT : SPLIT_PANE_LEFT;
+                        ::ShowWindow(m_hWndPane[nOtherPane], SW_HIDE);
+                        if(m_nDefActivePane != nPane)
+                                m_nDefActivePane = nPane;
+                }
+                else if(m_nSinglePane != SPLIT_PANE_NONE)
+                {
+                        int nOtherPane = (m_nSinglePane == SPLIT_PANE_LEFT) ? SPLIT_PANE_RIGHT : SPLIT_PANE_LEFT;
+                        ::ShowWindow(m_hWndPane[nOtherPane], SW_SHOW);
+                }
+
+                m_nSinglePane = nPane;
+                UpdateSplitterLayout();
+                return true;
+        }
+
+        int GetSinglePaneMode() const
+        {
+                return m_nSinglePane;
+        }
+
+        DWORD GetSplitterExtendedStyle() const
+        {
+                return m_dwExtendedStyle;
+        }
+
+        DWORD SetSplitterExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
+        {
+                DWORD dwPrevStyle = m_dwExtendedStyle;
+                if(dwMask == 0)
+                        m_dwExtendedStyle = dwExtendedStyle;
+                else
+                        m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
+#ifdef _DEBUG
+                if(IsProportional() && IsRightAligned())
+                        ATLTRACE2(atlTraceUI, 0, _T("CSplitterImpl::SetSplitterExtendedStyle - SPLIT_PROPORTIONAL and SPLIT_RIGHTALIGNED are mutually exclusive, defaulting to SPLIT_PROPORTIONAL.\n"));
+#endif // _DEBUG
+                return dwPrevStyle;
+        }
+
+// Splitter operations
+        void SetSplitterPanes(HWND hWndLeftTop, HWND hWndRightBottom, bool bUpdate = true)
+        {
+                m_hWndPane[SPLIT_PANE_LEFT] = hWndLeftTop;
+                m_hWndPane[SPLIT_PANE_RIGHT] = hWndRightBottom;
+                ATLASSERT(m_hWndPane[SPLIT_PANE_LEFT] == NULL || m_hWndPane[SPLIT_PANE_RIGHT] == NULL || m_hWndPane[SPLIT_PANE_LEFT] != m_hWndPane[SPLIT_PANE_RIGHT]);
+                if(bUpdate)
+                        UpdateSplitterLayout();
+        }
+
+        bool SetSplitterPane(int nPane, HWND hWnd, bool bUpdate = true)
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT);
+
+                if(nPane != SPLIT_PANE_LEFT && nPane != SPLIT_PANE_RIGHT)
+                        return false;
+                m_hWndPane[nPane] = hWnd;
+                ATLASSERT(m_hWndPane[SPLIT_PANE_LEFT] == NULL || m_hWndPane[SPLIT_PANE_RIGHT] == NULL || m_hWndPane[SPLIT_PANE_LEFT] != m_hWndPane[SPLIT_PANE_RIGHT]);
+                if(bUpdate)
+                        UpdateSplitterLayout();
+                return true;
+        }
+
+        HWND GetSplitterPane(int nPane) const
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT);
+
+                if(nPane != SPLIT_PANE_LEFT && nPane != SPLIT_PANE_RIGHT)
+                        return false;
+                return m_hWndPane[nPane];
+        }
+
+        bool SetActivePane(int nPane)
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT);
+
+                if(nPane != SPLIT_PANE_LEFT && nPane != SPLIT_PANE_RIGHT)
+                        return false;
+                if(m_nSinglePane != SPLIT_PANE_NONE && nPane != m_nSinglePane)
+                        return false;
+                ::SetFocus(m_hWndPane[nPane]);
+                m_nDefActivePane = nPane;
+                return true;
+        }
+
+        int GetActivePane() const
+        {
+                int nRet = SPLIT_PANE_NONE;
+                HWND hWndFocus = ::GetFocus();
+                if(hWndFocus != NULL)
+                {
+                        for(int nPane = 0; nPane < m_nPanesCount; nPane++)
+                        {
+                                if(hWndFocus == m_hWndPane[nPane] || ::IsChild(m_hWndPane[nPane], hWndFocus))
+                                {
+                                        nRet = nPane;
+                                        break;
+                                }
+                        }
+                }
+                return nRet;
+        }
+
+        bool ActivateNextPane(bool bNext = true)
+        {
+                int nPane = m_nSinglePane;
+                if(nPane == SPLIT_PANE_NONE)
+                {
+                        switch(GetActivePane())
+                        {
+                        case SPLIT_PANE_LEFT:
+                                nPane = SPLIT_PANE_RIGHT;
+                                break;
+                        case SPLIT_PANE_RIGHT:
+                                nPane = SPLIT_PANE_LEFT;
+                                break;
+                        default:
+                                nPane = bNext ? SPLIT_PANE_LEFT : SPLIT_PANE_RIGHT;
+                                break;
+                        }
+                }
+                return SetActivePane(nPane);
+        }
+
+        bool SetDefaultActivePane(int nPane)
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT);
+
+                if(nPane != SPLIT_PANE_LEFT && nPane != SPLIT_PANE_RIGHT)
+                        return false;
+                m_nDefActivePane = nPane;
+                return true;
+        }
+
+        bool SetDefaultActivePane(HWND hWnd)
+        {
+                for(int nPane = 0; nPane < m_nPanesCount; nPane++)
+                {
+                        if(hWnd == m_hWndPane[nPane])
+                        {
+                                m_nDefActivePane = nPane;
+                                return true;
+                        }
+                }
+                return false;   // not found
+        }
+
+        int GetDefaultActivePane() const
+        {
+                return m_nDefActivePane;
+        }
+
+        void DrawSplitter(CDCHandle dc)
+        {
+                ATLASSERT(dc.m_hDC != NULL);
+                if(m_nSinglePane == SPLIT_PANE_NONE && m_xySplitterPos == -1)
+                        return;
+
+                T* pT = static_cast<T*>(this);
+                if(m_nSinglePane == SPLIT_PANE_NONE)
+                {
+                        pT->DrawSplitterBar(dc);
+
+                        for(int nPane = 0; nPane < m_nPanesCount; nPane++)
+                        {
+                                if(m_hWndPane[nPane] == NULL)
+                                        pT->DrawSplitterPane(dc, nPane);
+                        }
+                }
+                else
+                {
+                        if(m_hWndPane[m_nSinglePane] == NULL)
+                                pT->DrawSplitterPane(dc, m_nSinglePane);
+                }
+        }
+
+// Overrideables
+        void DrawSplitterBar(CDCHandle dc)
+        {
+                RECT rect;
+                if(GetSplitterBarRect(&rect))
+                {
+                        dc.FillRect(&rect, COLOR_3DFACE);
+                        // draw 3D edge if needed
+                        T* pT = static_cast<T*>(this);
+                        if((pT->GetExStyle() & WS_EX_CLIENTEDGE) != 0)
+                                dc.DrawEdge(&rect, EDGE_RAISED, t_bVertical ? (BF_LEFT | BF_RIGHT) : (BF_TOP | BF_BOTTOM));
+                }
+        }
+
+        // called only if pane is empty
+        void DrawSplitterPane(CDCHandle dc, int nPane)
+        {
+                RECT rect;
+                if(GetSplitterPaneRect(nPane, &rect))
+                {
+                        T* pT = static_cast<T*>(this);
+                        if((pT->GetExStyle() & WS_EX_CLIENTEDGE) == 0)
+                                dc.DrawEdge(&rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
+                        dc.FillRect(&rect, COLOR_APPWORKSPACE);
+                }
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CSplitterImpl)
+                MESSAGE_HANDLER(WM_CREATE, OnCreate)
+                MESSAGE_HANDLER(WM_PAINT, OnPaint)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
+#endif // !_WIN32_WCE
+                if(IsInteractive())
+                {
+                        MESSAGE_HANDLER(WM_SETCURSOR, OnSetCursor)
+                        MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
+                        MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
+                        MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
+                        MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDoubleClick)
+                        MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
+                }
+                MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
+#ifndef _WIN32_WCE
+                MESSAGE_HANDLER(WM_MOUSEACTIVATE, OnMouseActivate)
+#endif // !_WIN32_WCE
+                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
+        END_MSG_MAP()
+
+        LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                GetSystemSettings(false);
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnPaint(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                // try setting position if not set
+                if(m_nSinglePane == SPLIT_PANE_NONE && m_xySplitterPos == -1)
+                        pT->SetSplitterPos();
+                // do painting
+                CPaintDC dc(pT->m_hWnd);
+                pT->DrawSplitter(dc.m_hDC);
+                return 0;
+        }
+
+        LRESULT OnSetCursor(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+        {
+                T* pT = static_cast<T*>(this);
+                if((HWND)wParam == pT->m_hWnd && LOWORD(lParam) == HTCLIENT)
+                {
+                        DWORD dwPos = ::GetMessagePos();
+                        POINT ptPos = { GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos) };
+                        pT->ScreenToClient(&ptPos);
+                        if(IsOverSplitterBar(ptPos.x, ptPos.y))
+                                return 1;
+                }
+
+                bHandled = FALSE;
+                return 0;
+        }
+
+        LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+        {
+                T* pT = static_cast<T*>(this);
+                int xPos = GET_X_LPARAM(lParam);
+                int yPos = GET_Y_LPARAM(lParam);
+                if((wParam & MK_LBUTTON) && ::GetCapture() == pT->m_hWnd)
+                {
+                        int xyNewSplitPos = 0;
+                        if(t_bVertical)
+                                xyNewSplitPos = xPos - m_rcSplitter.left - m_cxyDragOffset;
+                        else
+                                xyNewSplitPos = yPos - m_rcSplitter.top - m_cxyDragOffset;
+
+                        if(xyNewSplitPos == -1)   // avoid -1, that means middle
+                                xyNewSplitPos = -2;
+
+                        if(m_xySplitterPos != xyNewSplitPos)
+                        {
+                                if(m_bFullDrag)
+                                {
+                                        if(pT->SetSplitterPos(xyNewSplitPos, true))
+                                                pT->UpdateWindow();
+                                }
+                                else
+                                {
+                                        DrawGhostBar();
+                                        pT->SetSplitterPos(xyNewSplitPos, false);
+                                        DrawGhostBar();
+                                }
+                        }
+                }
+                else            // not dragging, just set cursor
+                {
+                        if(IsOverSplitterBar(xPos, yPos))
+                                ::SetCursor(m_hCursor);
+                        bHandled = FALSE;
+                }
+
+                return 0;
+        }
+
+        LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+                int xPos = GET_X_LPARAM(lParam);
+                int yPos = GET_Y_LPARAM(lParam);
+                if(IsOverSplitterBar(xPos, yPos))
+                {
+                        T* pT = static_cast<T*>(this);
+                        pT->SetCapture();
+                        ::SetCursor(m_hCursor);
+                        if(!m_bFullDrag)
+                                DrawGhostBar();
+                        if(t_bVertical)
+                                m_cxyDragOffset = xPos - m_rcSplitter.left - m_xySplitterPos;
+                        else
+                                m_cxyDragOffset = yPos - m_rcSplitter.top - m_xySplitterPos;
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                ::ReleaseCapture();
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnLButtonDoubleClick(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                pT->SetSplitterPos();   // middle
+                return 0;
+        }
+
+        LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                if(!m_bFullDrag)
+                {
+                        DrawGhostBar();
+                        UpdateSplitterLayout();
+                        T* pT = static_cast<T*>(this);
+                        pT->UpdateWindow();
+                }
+                return 0;
+        }
+
+        LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM, BOOL& bHandled)
+        {
+                if(m_nSinglePane == SPLIT_PANE_NONE)
+                {
+                        if(m_nDefActivePane == SPLIT_PANE_LEFT || m_nDefActivePane == SPLIT_PANE_RIGHT)
+                                ::SetFocus(m_hWndPane[m_nDefActivePane]);
+                }
+                else
+                {
+                        ::SetFocus(m_hWndPane[m_nSinglePane]);
+                }
+                bHandled = FALSE;
+                return 1;
+        }
+
+#ifndef _WIN32_WCE
+        LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                T* pT = static_cast<T*>(this);
+                LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam);
+                if(lRet == MA_ACTIVATE || lRet == MA_ACTIVATEANDEAT)
+                {
+                        DWORD dwPos = ::GetMessagePos();
+                        POINT pt = { GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos) };
+                        pT->ScreenToClient(&pt);
+                        RECT rcPane;
+                        for(int nPane = 0; nPane < m_nPanesCount; nPane++)
+                        {
+                                if(GetSplitterPaneRect(nPane, &rcPane) && ::PtInRect(&rcPane, pt))
+                                {
+                                        m_nDefActivePane = nPane;
+                                        break;
+                                }
+                        }
+                }
+                return lRet;
+        }
+#endif // !_WIN32_WCE
+
+        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                GetSystemSettings(true);
+                return 0;
+        }
+
+// Implementation - internal helpers
+        void UpdateSplitterLayout()
+        {
+                if(m_nSinglePane == SPLIT_PANE_NONE && m_xySplitterPos == -1)
+                        return;
+
+                T* pT = static_cast<T*>(this);
+                RECT rect = { 0, 0, 0, 0 };
+                if(m_nSinglePane == SPLIT_PANE_NONE)
+                {
+                        if(GetSplitterBarRect(&rect))
+                                pT->InvalidateRect(&rect);
+
+                        for(int nPane = 0; nPane < m_nPanesCount; nPane++)
+                        {
+                                if(GetSplitterPaneRect(nPane, &rect))
+                                {
+                                        if(m_hWndPane[nPane] != NULL)
+                                                ::SetWindowPos(m_hWndPane[nPane], NULL, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER);
+                                        else
+                                                pT->InvalidateRect(&rect);
+                                }
+                        }
+                }
+                else
+                {
+                        if(GetSplitterPaneRect(m_nSinglePane, &rect))
+                        {
+                                if(m_hWndPane[m_nSinglePane] != NULL)
+                                        ::SetWindowPos(m_hWndPane[m_nSinglePane], NULL, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER);
+                                else
+                                        pT->InvalidateRect(&rect);
+                        }
+                }
+        }
+
+        bool GetSplitterBarRect(LPRECT lpRect) const
+        {
+                ATLASSERT(lpRect != NULL);
+                if(m_nSinglePane != SPLIT_PANE_NONE || m_xySplitterPos == -1)
+                        return false;
+
+                if(t_bVertical)
+                {
+                        lpRect->left = m_rcSplitter.left + m_xySplitterPos;
+                        lpRect->top = m_rcSplitter.top;
+                        lpRect->right = m_rcSplitter.left + m_xySplitterPos + m_cxySplitBar + m_cxyBarEdge;
+                        lpRect->bottom = m_rcSplitter.bottom;
+                }
+                else
+                {
+                        lpRect->left = m_rcSplitter.left;
+                        lpRect->top = m_rcSplitter.top + m_xySplitterPos;
+                        lpRect->right = m_rcSplitter.right;
+                        lpRect->bottom = m_rcSplitter.top + m_xySplitterPos + m_cxySplitBar + m_cxyBarEdge;
+                }
+
+                return true;
+        }
+
+        bool GetSplitterPaneRect(int nPane, LPRECT lpRect) const
+        {
+                ATLASSERT(nPane == SPLIT_PANE_LEFT || nPane == SPLIT_PANE_RIGHT);
+                ATLASSERT(lpRect != NULL);
+                bool bRet = true;
+                if(m_nSinglePane != SPLIT_PANE_NONE)
+                {
+                        if(nPane == m_nSinglePane)
+                                *lpRect = m_rcSplitter;
+                        else
+                                bRet = false;
+                }
+                else if(nPane == SPLIT_PANE_LEFT)
+                {
+                        if(t_bVertical)
+                        {
+                                lpRect->left = m_rcSplitter.left;
+                                lpRect->top = m_rcSplitter.top;
+                                lpRect->right = m_rcSplitter.left + m_xySplitterPos;
+                                lpRect->bottom = m_rcSplitter.bottom;
+                        }
+                        else
+                        {
+                                lpRect->left = m_rcSplitter.left;
+                                lpRect->top = m_rcSplitter.top;
+                                lpRect->right = m_rcSplitter.right;
+                                lpRect->bottom = m_rcSplitter.top + m_xySplitterPos;
+                        }
+                }
+                else if(nPane == SPLIT_PANE_RIGHT)
+                {
+                        if(t_bVertical)
+                        {
+                                lpRect->left = m_rcSplitter.left + m_xySplitterPos + m_cxySplitBar + m_cxyBarEdge;
+                                lpRect->top = m_rcSplitter.top;
+                                lpRect->right = m_rcSplitter.right;
+                                lpRect->bottom = m_rcSplitter.bottom;
+                        }
+                        else
+                        {
+                                lpRect->left = m_rcSplitter.left;
+                                lpRect->top = m_rcSplitter.top + m_xySplitterPos + m_cxySplitBar + m_cxyBarEdge;
+                                lpRect->right = m_rcSplitter.right;
+                                lpRect->bottom = m_rcSplitter.bottom;
+                        }
+                }
+                else
+                {
+                        bRet = false;
+                }
+                return bRet;
+        }
+
+        bool IsOverSplitterRect(int x, int y) const
+        {
+                // -1 == don't check
+                return ((x == -1 || (x >= m_rcSplitter.left && x <= m_rcSplitter.right)) &&
+                        (y == -1 || (y >= m_rcSplitter.top && y <= m_rcSplitter.bottom)));
+        }
+
+        bool IsOverSplitterBar(int x, int y) const
+        {
+                if(m_nSinglePane != SPLIT_PANE_NONE)
+                        return false;
+                if(m_xySplitterPos == -1 || !IsOverSplitterRect(x, y))
+                        return false;
+                int xy = t_bVertical ? x : y;
+                int xyOff = t_bVertical ? m_rcSplitter.left : m_rcSplitter.top;
+                return ((xy >= (xyOff + m_xySplitterPos)) && (xy < xyOff + m_xySplitterPos + m_cxySplitBar + m_cxyBarEdge));
+        }
+
+        void DrawGhostBar()
+        {
+                RECT rect = { 0, 0, 0, 0 };
+                if(GetSplitterBarRect(&rect))
+                {
+                        // invert the brush pattern (looks just like frame window sizing)
+                        T* pT = static_cast<T*>(this);
+                        CWindowDC dc(pT->m_hWnd);
+                        CBrush brush = CDCHandle::GetHalftoneBrush();
+                        if(brush.m_hBrush != NULL)
+                        {
+                                CBrushHandle brushOld = dc.SelectBrush(brush);
+                                dc.PatBlt(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, PATINVERT);
+                                dc.SelectBrush(brushOld);
+                        }
+                }
+        }
+
+        void GetSystemSettings(bool bUpdate)
+        {
+#ifndef _WIN32_WCE
+                m_cxySplitBar = ::GetSystemMetrics(t_bVertical ? SM_CXSIZEFRAME : SM_CYSIZEFRAME);
+#else // CE specific
+                m_cxySplitBar = 2 * ::GetSystemMetrics(t_bVertical ? SM_CXEDGE : SM_CYEDGE);
+#endif // _WIN32_WCE
+
+                T* pT = static_cast<T*>(this);
+                if((pT->GetExStyle() & WS_EX_CLIENTEDGE))
+                {
+                        m_cxyBarEdge = 2 * ::GetSystemMetrics(t_bVertical ? SM_CXEDGE : SM_CYEDGE);
+                        m_cxyMin = 0;
+                }
+                else
+                {
+                        m_cxyBarEdge = 0;
+                        m_cxyMin = 2 * ::GetSystemMetrics(t_bVertical ? SM_CXEDGE : SM_CYEDGE);
+                }
+
+#ifndef _WIN32_WCE
+                ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &m_bFullDrag, 0);
+#endif // !_WIN32_WCE
+
+                if(bUpdate)
+                        UpdateSplitterLayout();
+        }
+
+        bool IsProportional() const
+        {
+                return ((m_dwExtendedStyle & SPLIT_PROPORTIONAL) != 0);
+        }
+
+        void StoreProportionalPos()
+        {
+                int cxyTotal = t_bVertical ? (m_rcSplitter.right - m_rcSplitter.left - m_cxySplitBar - m_cxyBarEdge) : (m_rcSplitter.bottom - m_rcSplitter.top - m_cxySplitBar - m_cxyBarEdge);
+                if(cxyTotal > 0)
+                        m_nProportionalPos = ::MulDiv(m_xySplitterPos, m_nPropMax, cxyTotal);
+                else
+                        m_nProportionalPos = 0;
+                ATLTRACE2(atlTraceUI, 0, _T("CSplitterImpl::StoreProportionalPos - %i\n"), m_nProportionalPos);
+        }
+
+        void UpdateProportionalPos()
+        {
+                int cxyTotal = t_bVertical ? (m_rcSplitter.right - m_rcSplitter.left - m_cxySplitBar - m_cxyBarEdge) : (m_rcSplitter.bottom - m_rcSplitter.top - m_cxySplitBar - m_cxyBarEdge);
+                if(cxyTotal > 0)
+                {
+                        int xyNewPos = ::MulDiv(m_nProportionalPos, cxyTotal, m_nPropMax);
+                        m_bUpdateProportionalPos = false;
+                        T* pT = static_cast<T*>(this);
+                        pT->SetSplitterPos(xyNewPos, false);
+                }
+        }
+
+        bool IsRightAligned() const
+        {
+                return ((m_dwExtendedStyle & SPLIT_RIGHTALIGNED) != 0);
+        }
+
+        void StoreRightAlignPos()
+        {
+                int cxyTotal = t_bVertical ? (m_rcSplitter.right - m_rcSplitter.left - m_cxySplitBar - m_cxyBarEdge) : (m_rcSplitter.bottom - m_rcSplitter.top - m_cxySplitBar - m_cxyBarEdge);
+                if(cxyTotal > 0)
+                        m_nProportionalPos = cxyTotal - m_xySplitterPos;
+                else
+                        m_nProportionalPos = 0;
+                ATLTRACE2(atlTraceUI, 0, _T("CSplitterImpl::StoreRightAlignPos - %i\n"), m_nProportionalPos);
+        }
+
+        void UpdateRightAlignPos()
+        {
+                int cxyTotal = t_bVertical ? (m_rcSplitter.right - m_rcSplitter.left - m_cxySplitBar - m_cxyBarEdge) : (m_rcSplitter.bottom - m_rcSplitter.top - m_cxySplitBar - m_cxyBarEdge);
+                if(cxyTotal > 0)
+                {
+                        m_bUpdateProportionalPos = false;
+                        T* pT = static_cast<T*>(this);
+                        pT->SetSplitterPos(cxyTotal - m_nProportionalPos, false);
+                }
+        }
+
+        bool IsInteractive() const
+        {
+                return ((m_dwExtendedStyle & SPLIT_NONINTERACTIVE) == 0);
+        }
+};
+
+template <class T, bool t_bVertical> HCURSOR CSplitterImpl< T, t_bVertical>::m_hCursor = NULL;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CSplitterWindowImpl - Implements a splitter window
+
+template <class T, bool t_bVertical = true, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
+class ATL_NO_VTABLE CSplitterWindowImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CSplitterImpl< T , t_bVertical >
+{
+public:
+        DECLARE_WND_CLASS_EX(NULL, CS_DBLCLKS, COLOR_WINDOW)
+
+        typedef CSplitterImpl< T , t_bVertical >   _baseClass;
+
+        BEGIN_MSG_MAP(CSplitterWindowImpl)
+                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+                CHAIN_MSG_MAP(_baseClass)
+                FORWARD_NOTIFICATIONS()
+        END_MSG_MAP()
+
+        LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                // handled, no background painting needed
+                return 1;
+        }
+
+        LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(wParam != SIZE_MINIMIZED)
+                        SetSplitterRect();
+
+                bHandled = FALSE;
+                return 1;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CSplitterWindow - Implements a splitter window to be used as is
+
+template <bool t_bVertical = true>
+class CSplitterWindowT : public CSplitterWindowImpl<CSplitterWindowT<t_bVertical>, t_bVertical>
+{
+public:
+        DECLARE_WND_CLASS_EX(_T("WTL_SplitterWindow"), CS_DBLCLKS, COLOR_WINDOW)
+};
+
+typedef CSplitterWindowT<true>    CSplitterWindow;
+typedef CSplitterWindowT<false>   CHorSplitterWindow;
+
+}; // namespace WTL
+
+#endif // __ATLSPLIT_H__