able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/shimgvw/seltrack.cpp

971 lines
27 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#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);
}
}
/////////////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink