windows-server-2003/shell/ext/shimgvw/seltrack.cpp

#include "precomp.h"
#include "seltrack.h"

#ifndef _countof
#define _countof(array) (sizeof(array)/sizeof(array[0]))
#endif

#define CX_BORDER   1
#define CY_BORDER   1

/////////////////////////////////////////////////////////////////////////////
// CSelectionTracker global state

// various GDI objects we need to draw

class Statics
{
public:
    HCURSOR hCursors[10];
    HBRUSH hHatchBrush;
    HBRUSH hHalftoneBrush;
    HPEN hBlackDottedPen;
    int nHandleSize;
    int nRefCount;

    Statics()
    {
        hCursors[0] = 0;
        hCursors[1] = 0;
        hCursors[2] = 0;
        hCursors[3] = 0;
        hCursors[4] = 0;
        hCursors[5] = 0;
        hCursors[6] = 0;
        hCursors[7] = 0;
        hCursors[8] = 0;
        hCursors[9] = 0;
        hHatchBrush = 0;
        hHalftoneBrush = 0;
        hBlackDottedPen = 0;
        nHandleSize = 0;
        nRefCount=0;
    }

    ~Statics()
    {
        if (hHatchBrush != 0)
            ::DeleteObject(hHatchBrush);
        if (hHalftoneBrush != 0)
            ::DeleteObject(hHalftoneBrush);
        if (hBlackDottedPen != 0)
            ::DeleteObject(hBlackDottedPen);
    };
};

static Statics* s_pStatics = NULL;

// the struct below is used to determine the qualities of a particular handle
struct HANDLEINFO
{
    size_t nOffsetX;    // offset within RECT for X coordinate
    size_t nOffsetY;    // offset within RECT for Y coordinate
    int nCenterX;       // adjust X by Width()/2 * this number
    int nCenterY;       // adjust Y by Height()/2 * this number
    int nHandleX;       // adjust X by handle size * this number
    int nHandleY;       // adjust Y by handle size * this number
    int nInvertX;       // handle converts to this when X inverted
    int nInvertY;       // handle converts to this when Y inverted
};

// this array describes all 8 handles (clock-wise)
static const HANDLEINFO c_HandleInfo[] =
{
    // corner handles (top-left, top-right, bottom-right, bottom-left
    { offsetof(RECT, left), offsetof(RECT, top),        0, 0,  0,  0, 1, 3 },
    { offsetof(RECT, right), offsetof(RECT, top),       0, 0, -1,  0, 0, 2 },
    { offsetof(RECT, right), offsetof(RECT, bottom),    0, 0, -1, -1, 3, 1 },
    { offsetof(RECT, left), offsetof(RECT, bottom),     0, 0,  0, -1, 2, 0 },

    // side handles (top, right, bottom, left)
    { offsetof(RECT, left), offsetof(RECT, top),        1, 0,  0,  0, 4, 6 },
    { offsetof(RECT, right), offsetof(RECT, top),       0, 1, -1,  0, 7, 5 },
    { offsetof(RECT, left), offsetof(RECT, bottom),     1, 0,  0, -1, 6, 4 },
    { offsetof(RECT, left), offsetof(RECT, top),        0, 1,  0,  0, 5, 7 }
};

// the struct below gives us information on the layout of a RECT struct and
//  the relationship between its members
struct RECTINFO
{
    size_t nOffsetAcross;   // offset of opposite point (ie. left->right)
    int nSignAcross;        // sign relative to that point (ie. add/subtract)
};

// this array is indexed by the offset of the RECT member / sizeof(int)
static const RECTINFO c_RectInfo[] =
{
    { offsetof(RECT, right), +1 },
    { offsetof(RECT, bottom), +1 },
    { offsetof(RECT, left), -1 },
    { offsetof(RECT, top), -1 },
};

/////////////////////////////////////////////////////////////////////////////
// SelectionTracking intitialization / cleanup

BOOL InitSelectionTracking()
{
    // Only call this once.
    // Synchronization is the responsibility of the caller.
    if (s_pStatics != NULL)
    {
        s_pStatics->nRefCount++;
        return true;
    }

    s_pStatics = new Statics;

    // sanity checks for assumptions we make in the code
    ASSERT(sizeof(((RECT*)NULL)->left) == sizeof(int));
    ASSERT(offsetof(RECT, top) > offsetof(RECT, left));
    ASSERT(offsetof(RECT, right) > offsetof(RECT, top));
    ASSERT(offsetof(RECT, bottom) > offsetof(RECT, right));

    // create the hatch pattern + bitmap
    WORD hatchPattern[8];
    WORD wPattern = 0x1111;
    for (int i = 0; i < 4; i++)
    {
        hatchPattern[i] = wPattern;
        hatchPattern[i+4] = wPattern;
        wPattern <<= 1;
    }

    HBITMAP hatchBitmap = ::CreateBitmap(8, 8, 1, 1, hatchPattern);
    if (hatchBitmap == NULL)
    {
        delete s_pStatics;
        return false;
    }

    // create black hatched brush
    s_pStatics->hHatchBrush = ::CreatePatternBrush(hatchBitmap);
    DeleteObject(hatchBitmap);

    if (s_pStatics->hHatchBrush == NULL)
    {
        delete s_pStatics;
        return false;
    }

    WORD grayPattern[8];
    for (int i = 0; i < 8; i++)
        grayPattern[i] = (WORD)(0x5555 << (i & 1));

    HBITMAP grayBitmap = ::CreateBitmap(8, 8, 1, 1, grayPattern);
    if (grayBitmap == NULL)
    {
        delete s_pStatics;
        return false;
    }

    s_pStatics->hHalftoneBrush = ::CreatePatternBrush(grayBitmap);
    DeleteObject(grayBitmap);
    if (s_pStatics->hHalftoneBrush == NULL)
    {
        delete s_pStatics;
        return false;
    }

    // create black dotted pen
    s_pStatics->hBlackDottedPen = ::CreatePen(PS_DOT, 0, RGB(0, 0, 0));
    if (s_pStatics->hBlackDottedPen == NULL)
    {
        delete s_pStatics;
        return false;
    }

    // initialize the cursor array
    s_pStatics->hCursors[0] = ::LoadCursor(NULL, IDC_SIZENWSE);
    s_pStatics->hCursors[1] = ::LoadCursor(NULL, IDC_SIZENESW);
    s_pStatics->hCursors[2] = s_pStatics->hCursors[0];
    s_pStatics->hCursors[3] = s_pStatics->hCursors[1];
    s_pStatics->hCursors[4] = ::LoadCursor(NULL, IDC_SIZENS);
    s_pStatics->hCursors[5] = ::LoadCursor(NULL, IDC_SIZEWE);
    s_pStatics->hCursors[6] = s_pStatics->hCursors[4];
    s_pStatics->hCursors[7] = s_pStatics->hCursors[5];
    s_pStatics->hCursors[8] = ::LoadCursor(NULL, IDC_SIZEALL);
    s_pStatics->hCursors[9] = s_pStatics->hCursors[8];

    s_pStatics->nHandleSize = 6;

    s_pStatics->nRefCount = 1;
    return true;
}

void CleanupSelectionTracking()
{
    // Only call this once.
    // Synchronization is the responsibility of the caller.
    if (s_pStatics != NULL)
    {
        s_pStatics->nRefCount--;
        if (s_pStatics->nRefCount == 0)
        {
            delete s_pStatics;
            s_pStatics = NULL;
        }
    }
}

/////////////////////////////////////////////////////////////////////////////
// CSelectionTracker intitialization

CSelectionTracker::CSelectionTracker()
{
    ASSERT(s_pStatics != NULL);

    m_uStyle = 0;
    m_nHandleSize = s_pStatics->nHandleSize;
    m_sizeMin.cy = m_sizeMin.cx = m_nHandleSize*2;

    m_rect.SetRectEmpty();

    _rectLast.SetRectEmpty();
    _sizeLast.cx = _sizeLast.cy = 0;
    _bErase = false;
    _bFinalErase =  false;
    _bAllowInvert = true;
}


CSelectionTracker::~CSelectionTracker()
{
}

/////////////////////////////////////////////////////////////////////////////
// CSelectionTracker operations

void CSelectionTracker::Draw(HDC hdc) const
{
    ASSERT(s_pStatics != NULL);

    // set initial DC state
    if (::SaveDC(hdc) == 0)
    {
        ASSERT(false);
    }

    ::SetMapMode(hdc, MM_TEXT);
    ::SetViewportOrgEx(hdc, 0, 0, NULL);
    ::SetWindowOrgEx(hdc, 0, 0, NULL);

    // get normalized rectangle
    CRect rect = m_rect;
    rect.NormalizeRect();

    HPEN hOldPen = NULL;
    HBRUSH hOldBrush = NULL;
    HGDIOBJ hTemp;
    int nOldROP;

    // draw lines
    if ((m_uStyle & (dottedLine|solidLine)) != 0)
    {
        if (m_uStyle & dottedLine)
        {
            hOldPen = (HPEN)::SelectObject(hdc, s_pStatics->hBlackDottedPen);
        }
        else
        {
            hOldPen = (HPEN)::SelectObject(hdc, GetStockObject(BLACK_PEN));
        }

        hOldBrush = (HBRUSH)::SelectObject(hdc, GetStockObject(NULL_BRUSH));

        nOldROP = ::SetROP2(hdc, R2_COPYPEN);
        rect.InflateRect(+1, +1); // borders are one pixel outside

        ::Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
        ::SetROP2(hdc, nOldROP);
    }

    // if hatchBrush is going to be used, need to unrealize it
    if ((m_uStyle & (hatchInside|hatchedBorder)) != 0)
        ::UnrealizeObject(s_pStatics->hHatchBrush);

    // hatch inside
    if ((m_uStyle & hatchInside) != 0)
    {
        hTemp = ::SelectObject(hdc, GetStockObject(NULL_PEN));
        if (hOldPen == NULL)
            hOldPen = (HPEN)hTemp;
        hTemp = ::SelectObject(hdc, s_pStatics->hHatchBrush);
        if (hOldBrush == NULL)
            hOldBrush = (HBRUSH)hTemp;

        ::SetBkMode(hdc, TRANSPARENT);
        nOldROP = ::SetROP2(hdc, R2_MASKNOTPEN);

        ::Rectangle(hdc, rect.left+1, rect.top+1, rect.right, rect.bottom);
        ::SetROP2(hdc, nOldROP);
    }

    // draw hatched border
    if ((m_uStyle & hatchedBorder) != 0)
    {
        hTemp = ::SelectObject(hdc, s_pStatics->hHatchBrush);
        if (hOldBrush == NULL)
            hOldBrush = (HBRUSH)hTemp;
        ::SetBkMode(hdc, OPAQUE);
        CRect rectTrue;
        GetTrueRect(&rectTrue);

        ::PatBlt(hdc, rectTrue.left, rectTrue.top, rectTrue.Width(), rect.top-rectTrue.top, 0x000F0001 /* Pn */);
        ::PatBlt(hdc, rectTrue.left, rect.bottom, rectTrue.Width(), rectTrue.bottom-rect.bottom, 0x000F0001 /* Pn */);
        ::PatBlt(hdc, rectTrue.left, rect.top, rect.left-rectTrue.left, rect.Height(), 0x000F0001 /* Pn */);
        ::PatBlt(hdc, rect.right, rect.top, rectTrue.right-rect.right, rect.Height(), 0x000F0001 /* Pn */);
    }

    // draw resize handles
    if ((m_uStyle & (resizeInside|resizeOutside)) != 0)
    {
        UINT mask = _GetHandleMask();
        for (int i = 0; i < 8; ++i)
        {
            if (mask & (1<<i))
            {
                _GetHandleRect((TrackerHit)i, &rect);
                ::SetBkColor(hdc, RGB(0, 0, 0));
                ::ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
            }
        }
    }

    // cleanup pDC state
    if (hOldPen != NULL)
        ::SelectObject(hdc, hOldPen);
    if (hOldBrush != NULL)
        ::SelectObject(hdc, hOldBrush);

    if (::RestoreDC(hdc, -1) == 0)
    {
        ASSERT(false);
    }
}

BOOL CSelectionTracker::SetCursor(HWND hwnd, LPARAM lParam) const
{
    ASSERT(s_pStatics != NULL);

    UINT uHitTest = (short)LOWORD(lParam);

    // trackers should only be in client area
    if (uHitTest != HTCLIENT)
        return FALSE;

    // convert cursor position to client co-ordinates
    CPoint point;
    ::GetCursorPos(&point);
    ::ScreenToClient(hwnd, &point);

    // do hittest and normalize hit
    int nHandle = _HitTestHandles(point);
    if (nHandle < 0)
        return FALSE;

    // need to normalize the hittest such that we get proper cursors
    nHandle = NormalizeHit(nHandle);

    // handle special case of hitting area between handles
    //  (logically the same -- handled as a move -- but different cursor)
    if (nHandle == hitMiddle && !m_rect.PtInRect(point))
    {
        // only for trackers with hatchedBorder (ie. in-place resizing)
        if (m_uStyle & hatchedBorder)
            nHandle = (TrackerHit)9;
    }

    ASSERT(nHandle < _countof(s_pStatics->hCursors));
    ::SetCursor(s_pStatics->hCursors[nHandle]);
    return TRUE;
}

int CSelectionTracker::HitTest(CPoint point) const
{
    ASSERT(s_pStatics != NULL);

    TrackerHit hitResult = hitNothing;

    CRect rectTrue;
    GetTrueRect(&rectTrue);
    ASSERT(rectTrue.left <= rectTrue.right);
    ASSERT(rectTrue.top <= rectTrue.bottom);
    if (rectTrue.PtInRect(point))
    {
        if ((m_uStyle & (resizeInside|resizeOutside)) != 0)
            hitResult = (TrackerHit)_HitTestHandles(point);
        else
            hitResult = hitMiddle;
    }
    return hitResult;
}

int CSelectionTracker::NormalizeHit(int nHandle) const
{
    ASSERT(s_pStatics != NULL);

    ASSERT(nHandle <= 8 && nHandle >= -1);
    if (nHandle == hitMiddle || nHandle == hitNothing)
        return nHandle;
    const HANDLEINFO* pHandleInfo = &c_HandleInfo[nHandle];
    if (m_rect.Width() < 0)
    {
        nHandle = (TrackerHit)pHandleInfo->nInvertX;
        pHandleInfo = &c_HandleInfo[nHandle];
    }
    if (m_rect.Height() < 0)
        nHandle = (TrackerHit)pHandleInfo->nInvertY;
    return nHandle;
}

BOOL CSelectionTracker::Track(HWND hwnd, CPoint point, BOOL bAllowInvert, HWND hwndClipTo)
{
    ASSERT(s_pStatics != NULL);

    // perform hit testing on the handles
    int nHandle = _HitTestHandles(point);
    if (nHandle < 0)
    {
        // didn't hit a handle, so just return FALSE
        return FALSE;
    }

    if (m_uStyle & lineSelection)
    {
        bAllowInvert = true;
        _sizeMin = CSize(0, 0);
    }
    else
    {
        _sizeMin = m_sizeMin;
    }

    // otherwise, call helper function to do the tracking
    _bAllowInvert = bAllowInvert;
    return _TrackHandle(nHandle, hwnd, point, hwndClipTo);
}

BOOL CSelectionTracker::TrackRubberBand(HWND hwnd, CPoint point, BOOL bAllowInvert)
{
    ASSERT(s_pStatics != NULL);

    // simply call helper function to track from bottom right handle

    if (m_uStyle & lineSelection)
    {
        bAllowInvert = true;
        _sizeMin = CSize(0, 0);
    }
    else
    {
        _sizeMin = m_sizeMin;
    }
    _bAllowInvert = bAllowInvert;
    m_rect.SetRect(point.x, point.y, point.x, point.y);
    return _TrackHandle(hitBottomRight, hwnd, point, NULL);
}

void CSelectionTracker::_DrawTrackerRect(LPCRECT lpRect, HWND hwndClipTo, HDC hdc, HWND hwnd)
{
    ASSERT(s_pStatics != NULL);
    ASSERT(lpRect != NULL);

    // first, normalize the rectangle for drawing
    CRect rect(0,0,0,0);
    if (lpRect)
        rect = *lpRect;

    if (!(m_uStyle & lineSelection))
    {
        rect.NormalizeRect();
    }

    // convert to client coordinates
    if (hwndClipTo != NULL)
    {
        ::ClientToScreen(hwnd, (LPPOINT)(LPRECT)&rect);
        ::ClientToScreen(hwnd, ((LPPOINT)(LPRECT)&rect)+1);
        if (IS_WINDOW_RTL_MIRRORED(hwnd))
        {
            LONG temp = rect.left;
            rect.left = rect.right;
            rect.right = temp;
        }

        ::ScreenToClient(hwndClipTo, (LPPOINT)(LPRECT)&rect);
        ::ScreenToClient(hwndClipTo, ((LPPOINT)(LPRECT)&rect)+1);
        if (IS_WINDOW_RTL_MIRRORED(hwndClipTo))
        {
            LONG temp = rect.left;
            rect.left = rect.right;
            rect.right = temp;
        }
    }

    CSize size(0, 0);
    if (!_bFinalErase)
    {
        // otherwise, size depends on the style
        if (m_uStyle & hatchedBorder)
        {
            size.cx = size.cy = max(1, _GetHandleSize(rect)-1);
            rect.InflateRect(size);
        }
        else
        {
            size.cx = CX_BORDER;
            size.cy = CY_BORDER;
        }
    }

    // and draw it
    if ((_bFinalErase || !_bErase) && hdc)
        _DrawDragRect(hdc, rect, size, _rectLast, _sizeLast);

    // remember last rectangles
    _rectLast = rect;
    _sizeLast = size;
}

void CSelectionTracker::_AdjustRect(int nHandle, LPRECT)
{
    ASSERT(s_pStatics != NULL);

    if (nHandle == hitMiddle)
        return;

    // convert the handle into locations within m_rect
    int *px, *py;
    _GetModifyPointers(nHandle, &px, &py, NULL, NULL);

    // enforce minimum width
    int nNewWidth = m_rect.Width();
    int nAbsWidth = _bAllowInvert ? abs(nNewWidth) : nNewWidth;
    if (px != NULL && nAbsWidth < _sizeMin.cx)
    {
        nNewWidth = nAbsWidth != 0 ? nNewWidth / nAbsWidth : 1;
        ASSERT((int*)px - (int*)&m_rect < _countof(c_RectInfo));
        const RECTINFO* pRectInfo = &c_RectInfo[(int*)px - (int*)&m_rect];
        *px = *(int*)((BYTE*)&m_rect + pRectInfo->nOffsetAcross) +
            nNewWidth * _sizeMin.cx * -pRectInfo->nSignAcross;
    }

    // enforce minimum height
    int nNewHeight = m_rect.Height();
    int nAbsHeight = _bAllowInvert ? abs(nNewHeight) : nNewHeight;
    if (py != NULL && nAbsHeight < _sizeMin.cy)
    {
        nNewHeight = nAbsHeight != 0 ? nNewHeight / nAbsHeight : 1;
        ASSERT((int*)py - (int*)&m_rect < _countof(c_RectInfo));
        const RECTINFO* pRectInfo = &c_RectInfo[(int*)py - (int*)&m_rect];
        *py = *(int*)((BYTE*)&m_rect + pRectInfo->nOffsetAcross) +
            nNewHeight * _sizeMin.cy * -pRectInfo->nSignAcross;
    }
}

void CSelectionTracker::GetTrueRect(LPRECT lpTrueRect) const
{
    ASSERT(s_pStatics != NULL);

    CRect rect = m_rect;
    rect.NormalizeRect();
    int nInflateBy = 0;
    if ((m_uStyle & (resizeOutside|hatchedBorder)) != 0)
        nInflateBy += _GetHandleSize() - 1;
    if ((m_uStyle & (solidLine|dottedLine)) != 0)
        ++nInflateBy;
    rect.InflateRect(nInflateBy, nInflateBy);
    *lpTrueRect = rect;
}

/////////////////////////////////////////////////////////////////////////////
// CSelectionTracker implementation helpers

void CSelectionTracker::_GetHandleRect(int nHandle, CRect* pHandleRect) const
{
    ASSERT(s_pStatics != NULL);
    ASSERT(nHandle < 8);

    // get normalized rectangle of the tracker
    CRect rectT = m_rect;
    rectT.NormalizeRect();
    if ((m_uStyle & (solidLine|dottedLine)) != 0)
        rectT.InflateRect(+1, +1);

    // since the rectangle itself was normalized, we also have to invert the
    //  resize handles.
    nHandle = NormalizeHit(nHandle);

    // handle case of resize handles outside the tracker
    int size = _GetHandleSize();
    if (m_uStyle & resizeOutside)
        rectT.InflateRect(size-1, size-1);

    // calculate position of the resize handle
    int nWidth = rectT.Width();
    int nHeight = rectT.Height();
    CRect rect;
    const HANDLEINFO* pHandleInfo = &c_HandleInfo[nHandle];
    rect.left = *(int*)((BYTE*)&rectT + pHandleInfo->nOffsetX);
    rect.top = *(int*)((BYTE*)&rectT + pHandleInfo->nOffsetY);
    rect.left += size * pHandleInfo->nHandleX;
    rect.top += size * pHandleInfo->nHandleY;
    rect.left += pHandleInfo->nCenterX * (nWidth - size) / 2;
    rect.top += pHandleInfo->nCenterY * (nHeight - size) / 2;
    rect.right = rect.left + size;
    rect.bottom = rect.top + size;

    *pHandleRect = rect;
}

int CSelectionTracker::_GetHandleSize(LPCRECT lpRect) const
{
    ASSERT(s_pStatics != NULL);

    if (lpRect == NULL)
        lpRect = &m_rect;

    int size = m_nHandleSize;
    if (!(m_uStyle & resizeOutside))
    {
        // make sure size is small enough for the size of the rect
        int sizeMax = min(abs(lpRect->right - lpRect->left),
            abs(lpRect->bottom - lpRect->top));
        if (size * 2 > sizeMax)
            size = sizeMax / 2;
    }
    return size;
}

int CSelectionTracker::_HitTestHandles(CPoint point) const
{
    ASSERT(s_pStatics != NULL);

    CRect rect;
    UINT mask = _GetHandleMask();

    // see if hit anywhere inside the tracker
    GetTrueRect(&rect);
    if (!rect.PtInRect(point))
        return hitNothing;  // totally missed

    // see if we hit a handle
    for (int i = 0; i < 8; ++i)
    {
        if (mask & (1<<i))
        {
            _GetHandleRect((TrackerHit)i, &rect);
            if (rect.PtInRect(point))
                return (TrackerHit)i;
        }
    }

    // last of all, check for non-hit outside of object, between resize handles
    if ((m_uStyle & hatchedBorder) == 0)
    {
        CRect rect = m_rect;
        rect.NormalizeRect();
        if ((m_uStyle & dottedLine|solidLine) != 0)
            rect.InflateRect(+1, +1);
        if (!rect.PtInRect(point))
            return hitNothing;  // must have been between resize handles
    }
    return hitMiddle;   // no handle hit, but hit object (or object border)
}

BOOL CSelectionTracker::_TrackHandle(int nHandle, HWND hwnd, CPoint point, HWND hwndClipTo)
{
    ASSERT(s_pStatics != NULL);
    ASSERT(nHandle >= 0 && nHandle <= 8);   // handle 8 is inside the rect

    // don't handle if capture already set
    if (::GetCapture() != NULL)
        return FALSE;

    ASSERT(!_bFinalErase);

    // save original width & height in pixels
    int nWidth = m_rect.Width();
    int nHeight = m_rect.Height();

    // set capture to the window which received this message
    ::SetCapture(hwnd);
    ASSERT(hwnd == ::GetCapture());

    UpdateWindow(hwnd);

    if (hwndClipTo != NULL)
        UpdateWindow(hwndClipTo);

    CRect rectSave = m_rect;

    // find out what x/y coords we are supposed to modify
    int *px, *py;
    int xDiff, yDiff;
    _GetModifyPointers(nHandle, &px, &py, &xDiff, &yDiff);
    xDiff = point.x - xDiff;
    yDiff = point.y - yDiff;

    // get DC for drawing
    HDC hdcDraw;
    if (hwndClipTo != NULL)
    {
        // clip to arbitrary window by using adjusted Window DC
        hdcDraw = ::GetDCEx(hwndClipTo, NULL, DCX_CACHE);
    }
    else
    {
        // otherwise, just use normal DC
        hdcDraw = ::GetDC(hwnd);
    }
    ASSERT(hdcDraw != NULL);

    CRect rectOld;
    BOOL bMoved = FALSE;

    // get messages until capture lost or cancelled/accepted
    for (;;)
    {
        MSG msg;
        if (!::GetMessage(&msg, NULL, 0, 0))
        {
            ASSERT(false);
        }

        if (hwnd != ::GetCapture())
            break;

        switch (msg.message)
        {
        // handle movement/accept messages
        case WM_LBUTTONUP:
        case WM_MOUSEMOVE:
            rectOld = m_rect;
            // handle resize cases (and part of move)
            if (px != NULL)
                *px = (int)(short)LOWORD(msg.lParam) - xDiff;
            if (py != NULL)
                *py = (int)(short)HIWORD(msg.lParam) - yDiff;

            // handle move case
            if (nHandle == hitMiddle)
            {
                m_rect.right = m_rect.left + nWidth;
                m_rect.bottom = m_rect.top + nHeight;
            }
            // allow caller to adjust the rectangle if necessary
            _AdjustRect(nHandle, &m_rect);

            // only redraw and callback if the rect actually changed!
            _bFinalErase = (msg.message == WM_LBUTTONUP);
            if (!rectOld.EqualRect(&m_rect) || _bFinalErase)
            {
                if (bMoved)
                {
                    _bErase = TRUE;
                    _DrawTrackerRect(&rectOld, hwndClipTo, hdcDraw, hwnd);
                }
                if (msg.message != WM_LBUTTONUP)
                    bMoved = TRUE;
            }
            if (_bFinalErase)
                goto ExitLoop;

            if (!rectOld.EqualRect(&m_rect))
            {
                _bErase = FALSE;
                _DrawTrackerRect(&m_rect, hwndClipTo, hdcDraw, hwnd);
            }
            break;

        // handle cancel messages
        case WM_KEYDOWN:
            if (msg.wParam != VK_ESCAPE)
                break;
        case WM_RBUTTONDOWN:
            if (bMoved)
            {
                _bErase = _bFinalErase = TRUE;
                _DrawTrackerRect(&m_rect, hwndClipTo, hdcDraw, hwnd);
            }
            m_rect = rectSave;
            goto ExitLoop;

        // just dispatch rest of the messages
        default:
            ::DispatchMessage(&msg);
            break;
        }
    }

ExitLoop:
    if (hdcDraw != NULL)
    {
        if (hwndClipTo != NULL)
            ::ReleaseDC(hwndClipTo, hdcDraw);
        else
            ::ReleaseDC(hwnd, hdcDraw);
    }

    ::ReleaseCapture();

    // restore rect in case bMoved is still FALSE
    if (!bMoved)
        m_rect = rectSave;
    _bFinalErase = FALSE;
    _bErase = FALSE;

    // return TRUE only if rect has changed
    return !rectSave.EqualRect(&m_rect);
}

void CSelectionTracker::_GetModifyPointers(int nHandle, int** ppx, int** ppy, int* px, int* py)
{
    ASSERT(s_pStatics != NULL);
    ASSERT(nHandle >= 0 && nHandle <= 8);

    if (nHandle == hitMiddle)
        nHandle = hitTopLeft;   // same as hitting top-left

    *ppx = NULL;
    *ppy = NULL;

    // fill in the part of the rect that this handle modifies
    //  (Note: handles that map to themselves along a given axis when that
    //   axis is inverted don't modify the value on that axis)

    const HANDLEINFO* pHandleInfo = &c_HandleInfo[nHandle];
    if (pHandleInfo->nInvertX != nHandle)
    {
        *ppx = (int*)((BYTE*)&m_rect + pHandleInfo->nOffsetX);
        if (px != NULL)
            *px = **ppx;
    }
    else
    {
        // middle handle on X axis
        if (px != NULL)
            *px = m_rect.left + abs(m_rect.Width()) / 2;
    }
    if (pHandleInfo->nInvertY != nHandle)
    {
        *ppy = (int*)((BYTE*)&m_rect + pHandleInfo->nOffsetY);
        if (py != NULL)
            *py = **ppy;
    }
    else
    {
        // middle handle on Y axis
        if (py != NULL)
            *py = m_rect.top + abs(m_rect.Height()) / 2;
    }
}

UINT CSelectionTracker::_GetHandleMask() const
{
    ASSERT(s_pStatics != NULL);
    UINT mask;

    if (m_uStyle & lineSelection)
    {
        mask = 0x05;
    }
    else
    {
        mask = 0x0F;   // always have 4 corner handles

        int size = m_nHandleSize*3;
        if (abs(m_rect.Width()) - size > 4)
            mask |= 0x50;
        if (abs(m_rect.Height()) - size > 4)
            mask |= 0xA0;
    }
    return mask;
}

void CSelectionTracker::_DrawDragRect(HDC hdc, LPCRECT lpRect, SIZE size, LPCRECT lpRectLast, SIZE sizeLast)
{
    if (m_uStyle & lineSelection)
    {
        int nOldROP = ::SetROP2(hdc, R2_NOTXORPEN);
        HPEN hOldPen =(HPEN)::SelectObject(hdc, (HPEN)s_pStatics->hBlackDottedPen);

        if (lpRectLast != NULL)
        {
            CRect rectLast = *lpRectLast;

            ::MoveToEx(hdc, rectLast.left, rectLast.top, NULL);
            ::LineTo(hdc, rectLast.right, rectLast.bottom);
        }
        
        CRect rect = *lpRect;

        ::MoveToEx(hdc, rect.left, rect.top, NULL);
        ::LineTo(hdc, rect.right, rect.bottom);

        ::SelectObject(hdc, hOldPen);
        ::SetROP2(hdc, nOldROP);
    }
    else
    {
        // first, determine the update region and select it
        HRGN hrgnOutside = ::CreateRectRgnIndirect(lpRect);

        CRect rect = *lpRect;
        rect.InflateRect(-size.cx, -size.cy);
        rect.IntersectRect(rect, lpRect);

        HRGN hrgnInside = ::CreateRectRgnIndirect(&rect);
        HRGN hrgnNew = ::CreateRectRgn(0, 0, 0, 0);
        ::CombineRgn(hrgnNew, hrgnOutside, hrgnInside, RGN_XOR);

        HRGN hrgnLast = NULL;
        HRGN hrgnUpdate = NULL;

        if (lpRectLast != NULL)
        {
            // find difference between new region and old region
            hrgnLast = ::CreateRectRgn(0, 0, 0, 0);
            ::SetRectRgn(hrgnOutside, lpRectLast->left, lpRectLast->top, lpRectLast->right, lpRectLast->bottom);
            rect = *lpRectLast;
            rect.InflateRect(-sizeLast.cx, -sizeLast.cy);
            rect.IntersectRect(rect, lpRectLast);
            ::SetRectRgn(hrgnInside, rect.left, rect.top, rect.right, rect.bottom);
            ::CombineRgn(hrgnLast, hrgnOutside, hrgnInside, RGN_XOR);
            hrgnUpdate = ::CreateRectRgn(0, 0, 0, 0);
            ::CombineRgn(hrgnUpdate, hrgnLast, hrgnNew, RGN_XOR);
        }

        // draw into the update/new region
        if (hrgnUpdate != NULL)
            ::SelectClipRgn(hdc, hrgnUpdate);
        else
            ::SelectClipRgn(hdc, hrgnNew);

        ::GetClipBox(hdc, &rect);

        HBRUSH hBrushOld = (HBRUSH)::SelectObject(hdc, s_pStatics->hHalftoneBrush);
        ::PatBlt(hdc, rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
        ::SelectObject(hdc, hBrushOld);

        ::SelectClipRgn(hdc, NULL);

        if (hrgnOutside != NULL)
            ::DeleteObject(hrgnOutside);
        if (hrgnInside != NULL)
            ::DeleteObject(hrgnInside);
        if (hrgnNew != NULL)
            ::DeleteObject(hrgnNew);
        if (hrgnLast != NULL)
            ::DeleteObject(hrgnLast);
        if (hrgnUpdate != NULL)
            ::DeleteObject(hrgnUpdate);
    }
}


/////////////////////////////////////////////////////////////////////////////