Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2266 lines
75 KiB

/*******************************************************************************
*
* (C) COPYRIGHT MICROSOFT CORPORATION, 1998
*
* TITLE: PREVWND.CPP
*
* VERSION: 1.0
*
* AUTHOR: ShaunIv
*
* DATE: 10/9/1998
*
* DESCRIPTION: Scanner Preview Control
*
*******************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include "prevwnd.h"
#include "pviewids.h"
#include "simcrack.h"
#include "miscutil.h"
#include "simrect.h"
#include "waitcurs.h"
#include "comctrlp.h"
#include "dlgunits.h"
#include "simrect.h"
#define IDC_PROGRESSCONTROL 100
#undef DITHER_DISABLED_CONTROL
//
// The range of image sizes for which we will detect regions.
//
#define MIN_REGION_DETECTION_X 100
#define MIN_REGION_DETECTION_Y 100
#define MAX_REGION_DETECTION_X 1275
#define MAX_REGION_DETECTION_Y 2100
#if defined(OLD_CRAPPY_HOME_SETUP)
static HINSTANCE g_hMsImgInst=LoadLibrary( TEXT("msimg32.dll") );
static AlphaBlendFn AlphaBlend=(AlphaBlendFn)GetProcAddress( g_hMsImgInst, "AlphaBlend" );
#endif
/*
* Mouse hit test codes
*/
#define HIT_NONE 0x0000
#define HIT_BORDER 0x0001
#define HIT_TOP 0x0002
#define HIT_BOTTOM 0x0004
#define HIT_LEFT 0x0008
#define HIT_RIGHT 0x0010
#define HIT_SELECTED 0x0020
#define HIT_TOPLEFT (HIT_TOP|HIT_LEFT)
#define HIT_TOPRIGHT (HIT_TOP|HIT_RIGHT)
#define HIT_BOTTOMLEFT (HIT_BOTTOM|HIT_LEFT)
#define HIT_BOTTOMRIGHT (HIT_BOTTOM|HIT_RIGHT)
/*
* Defaults
*/
#define DEFAULT_ACCEL_FACTOR 8
#define DEFAULT_HANDLE_SIZE 6
#define DEFAULT_BORDER 6
#define DEFAULT_BG_ALPHA 96
#define DEFAULT_SELECTED_HANDLE_FILL_COLOR RGB(0,128,0)
#define DEFAULT_UNSELECTED_HANDLE_FILL_COLOR RGB(128,0,0)
#define DEFAULT_DISABLED_HANDLE_FILL_COLOR GetSysColor(COLOR_3DSHADOW)
#define DEFAULT_SELECTED_BORDER_COLOR RGB(0,0,0)
#define DEFAULT_UNSELECTED_BORDER_COLOR RGB(0,0,0)
#define DEFAULT_DISABLED_BORDER_COLOR GetSysColor(COLOR_3DSHADOW)
#define DEFAULT_SELECTION_HANDLE_SHADOW RGB(128,128,128)
#define DEFAULT_SELECTION_HANDLE_HIGHLIGHT RGB(255,255,255)
#define DEFAULT_HANDLE_TYPE (PREVIEW_WINDOW_SQUAREHANDLES|PREVIEW_WINDOW_FILLEDHANDLES)
#define DEFAULT_BORDER_STYLE PS_DOT
#define BORDER_SELECTION_PEN_THICKNESS 0
#define REGION_DETECTION_BORDER 1
static inline RECT CreateRect( int left, int top, int right, int bottom )
{
RECT r;
r.left = left;
r.top = top;
r.right = right;
r.bottom = bottom;
return(r);
}
static HBRUSH CreateDitheredPatternBrush(void)
{
const BYTE s_GrayBitmapBits[] = {
0xAA, 0x00,
0x55, 0x00,
0xAA, 0x00,
0x55, 0x00,
0xAA, 0x00,
0x55, 0x00,
0xAA, 0x00,
0x55, 0x00
};
HBITMAP hBmp = CreateBitmap( 8, 8, 1, 1, s_GrayBitmapBits );
if (hBmp)
{
HBRUSH hbrPatBrush = CreatePatternBrush(hBmp);
DeleteObject(hBmp);
return(hbrPatBrush);
}
return(NULL);
}
static void DitherRect( HDC hDC, RECT &rc )
{
const DWORD ROP_DPNA = 0x000A0329;
HBRUSH hbr = CreateDitheredPatternBrush();
if (hbr)
{
HBRUSH hbrOld = (HBRUSH)SelectObject(hDC, hbr);
PatBlt( hDC, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, ROP_DPNA );
SelectObject( hDC, hbrOld );
DeleteObject( hbr );
}
}
static inline int PointInRect( const RECT &rc, const POINT &pt )
{
return(PtInRect(&rc,pt));
}
static inline int Boundary( int val, int min, int max )
{
if (val < min)
return(min);
if (val > max)
return(max);
return(val);
}
template <class T>
static inline T Minimum( const T &a, const T &b )
{
return(a < b) ? a : b;
}
template <class T>
static inline T Maximum( const T &a, const T &b )
{
return(a > b) ? a : b;
}
// Just like API UnionRect, but handles empty rects
static void TrueUnionRect( RECT *prcDest, const RECT *prcSrc1, const RECT *prcSrc2 )
{
prcDest->left = Minimum( prcSrc1->left, prcSrc2->left );
prcDest->right = Maximum( prcSrc1->right, prcSrc2->right );
prcDest->top = Minimum( prcSrc1->top, prcSrc2->top );
prcDest->bottom = Maximum( prcSrc1->bottom, prcSrc2->bottom );
}
// Constructor
CWiaPreviewWindow::CWiaPreviewWindow( HWND hWnd )
: m_hWnd(hWnd),
m_bDeleteBitmap(TRUE),
m_bSizing(FALSE),
m_bAllowNullSelection(FALSE),
m_hBufferBitmap(NULL),
m_hPaintBitmap(NULL),
m_hAlphaBitmap(NULL),
m_hPreviewBitmap(NULL),
m_hCursorArrow(LoadCursor(NULL,IDC_ARROW)),
m_hCursorCrossHairs(LoadCursor(NULL,IDC_CROSS)),
m_hCursorMove(LoadCursor(NULL,IDC_SIZEALL)),
m_hCursorSizeNS(LoadCursor(NULL,IDC_SIZENS)),
m_hCursorSizeNeSw(LoadCursor(NULL,IDC_SIZENESW)),
m_hCursorSizeNwSe(LoadCursor(NULL,IDC_SIZENWSE)),
m_hCursorSizeWE(LoadCursor(NULL,IDC_SIZEWE)),
m_MovingSel(HIT_NONE),
m_nBorderSize(DEFAULT_BORDER),
m_nHandleType(DEFAULT_HANDLE_TYPE),
m_nHandleSize(DEFAULT_HANDLE_SIZE),
m_hHalftonePalette(NULL),
m_nCurrentRect(0),
m_hBackgroundBrush(CreateSolidBrush(GetSysColor(COLOR_WINDOW))),
m_bPreviewMode(false),
m_bSuccessfulRegionDetection(false),
m_bUserChangedSelection(false)
{
ZeroMemory(&m_rcCurrSel,sizeof(m_rcCurrSel));
ZeroMemory(&m_rcSavedImageRect,sizeof(m_rcSavedImageRect));
ZeroMemory(&m_Resolution,sizeof(m_Resolution));
ZeroMemory(&m_Delta,sizeof(m_Delta));
ZeroMemory(&m_bfBlendFunction,sizeof(m_bfBlendFunction));
ZeroMemory(&m_rcSavedImageRect,sizeof(m_rcSavedImageRect));
m_bfBlendFunction.BlendOp = AC_SRC_OVER;
m_bfBlendFunction.SourceConstantAlpha = DEFAULT_BG_ALPHA;
m_aHandlePens[Selected] = CreatePen( PS_SOLID|PS_INSIDEFRAME, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_SELECTED_BORDER_COLOR );
m_aHandlePens[Unselected] = CreatePen( PS_SOLID|PS_INSIDEFRAME, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_UNSELECTED_BORDER_COLOR );
m_aHandlePens[Disabled] = CreatePen( PS_SOLID|PS_INSIDEFRAME, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_DISABLED_BORDER_COLOR );
m_aBorderPens[Selected] = CreatePen( DEFAULT_BORDER_STYLE, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_SELECTED_BORDER_COLOR );
m_aBorderPens[Unselected] = CreatePen( DEFAULT_BORDER_STYLE, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_UNSELECTED_BORDER_COLOR );
m_aBorderPens[Disabled] = CreatePen( DEFAULT_BORDER_STYLE, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_DISABLED_BORDER_COLOR );
m_aHandleBrushes[Selected] = CreateSolidBrush( DEFAULT_SELECTED_HANDLE_FILL_COLOR );
m_aHandleBrushes[Unselected] = CreateSolidBrush( DEFAULT_UNSELECTED_HANDLE_FILL_COLOR );
m_aHandleBrushes[Disabled] = CreateSolidBrush( DEFAULT_DISABLED_HANDLE_FILL_COLOR );
m_hHandleShadow = CreatePen( PS_SOLID|PS_INSIDEFRAME, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_SELECTION_HANDLE_SHADOW);
m_hHandleHighlight = CreatePen( PS_SOLID|PS_INSIDEFRAME, BORDER_SELECTION_PEN_THICKNESS, DEFAULT_SELECTION_HANDLE_HIGHLIGHT);
}
void CWiaPreviewWindow::DestroyBitmaps(void)
{
if (m_hPaintBitmap)
{
DeleteObject(m_hPaintBitmap);
m_hPaintBitmap = NULL;
}
if (m_hBufferBitmap)
{
DeleteObject(m_hBufferBitmap);
m_hBufferBitmap = NULL;
}
if (m_hAlphaBitmap)
{
DeleteObject(m_hAlphaBitmap);
m_hAlphaBitmap = NULL;
}
}
CWiaPreviewWindow::~CWiaPreviewWindow()
{
DestroyBitmaps();
if (m_bDeleteBitmap && m_hPreviewBitmap)
{
DeleteObject(m_hPreviewBitmap);
m_hPreviewBitmap = NULL;
}
else
{
m_hPreviewBitmap = NULL;
}
if (m_hHalftonePalette)
{
DeleteObject(m_hHalftonePalette);
m_hHalftonePalette = NULL;
}
// Destroy all of the handle pens
for (int i=0;i<ARRAYSIZE(m_aHandlePens);i++)
{
if (m_aHandlePens[i])
{
DeleteObject(m_aHandlePens[i]);
m_aHandlePens[i] = NULL;
}
}
// Destroy all of the selection rectangle pens
for (i=0;i<ARRAYSIZE(m_aBorderPens);i++)
{
if (m_aBorderPens[i])
{
DeleteObject(m_aBorderPens[i]);
m_aBorderPens[i] = NULL;
}
}
// Destroy all of the brushes
for (i=0;i<ARRAYSIZE(m_aHandleBrushes);i++)
{
if (m_aHandleBrushes[i])
{
DeleteObject(m_aHandleBrushes[i]);
m_aHandleBrushes[i] = NULL;
}
}
if (m_hHandleHighlight)
{
DeleteObject(m_hHandleHighlight);
m_hHandleHighlight = NULL;
}
if (m_hHandleShadow)
{
DeleteObject(m_hHandleShadow);
m_hHandleShadow = NULL;
}
if (m_hBackgroundBrush)
{
DeleteObject(m_hBackgroundBrush);
m_hBackgroundBrush = NULL;
}
m_hWnd = NULL;
// Zero out all of the cursors. No need to free them
m_hCursorSizeNeSw = NULL;
m_hCursorSizeNwSe = NULL;
m_hCursorCrossHairs = NULL;
m_hCursorMove = NULL;
m_hCursorSizeNS = NULL;
m_hCursorSizeWE = NULL;
m_hCursorArrow = NULL;
}
void CWiaPreviewWindow::Repaint( PRECT pRect, bool bErase )
{
InvalidateRect( m_hWnd, pRect, (bErase != false) );
UpdateWindow( m_hWnd );
}
void CWiaPreviewWindow::DrawHandle( HDC dc, const RECT &r, int nState )
{
HPEN hOldPen = (HPEN)SelectObject( dc, m_aHandlePens[nState] );
HBRUSH hOldBrush = (HBRUSH)SelectObject( dc, m_aHandleBrushes[nState] );
if (PREVIEW_WINDOW_HOLLOWHANDLES&m_nHandleType)
{
SelectObject( dc, GetStockObject(NULL_BRUSH) );
}
if (PREVIEW_WINDOW_ROUNDHANDLES&m_nHandleType)
{
Ellipse(dc,r.left,r.top,r.right,r.bottom);
if (!(PREVIEW_WINDOW_HOLLOWHANDLES&m_nHandleType))
{
RECT rcHighlight = r;
InflateRect(&rcHighlight,-1,-1);
SelectObject(dc,GetStockObject(NULL_BRUSH));
SelectObject(dc,m_hHandleShadow);
Arc(dc,rcHighlight.left,rcHighlight.top,rcHighlight.right,rcHighlight.bottom,rcHighlight.left,rcHighlight.bottom,rcHighlight.right,rcHighlight.top);
SelectObject(dc,m_hHandleHighlight);
Arc(dc,rcHighlight.left,rcHighlight.top,rcHighlight.right,rcHighlight.bottom,rcHighlight.right,rcHighlight.top,rcHighlight.left,rcHighlight.bottom);
}
}
else
{
Rectangle(dc,r.left,r.top,r.right,r.bottom);
if (!(PREVIEW_WINDOW_HOLLOWHANDLES&m_nHandleType))
{
RECT rcHighlight = r;
InflateRect(&rcHighlight,-1,-1);
rcHighlight.right--;
rcHighlight.bottom--;
if (!IsRectEmpty(&rcHighlight))
{
SelectObject(dc,m_hHandleHighlight);
MoveToEx(dc,rcHighlight.left,rcHighlight.bottom,NULL);
LineTo(dc,rcHighlight.left,rcHighlight.top);
LineTo(dc,rcHighlight.right,rcHighlight.top);
SelectObject(dc,m_hHandleShadow);
LineTo(dc,rcHighlight.right,rcHighlight.bottom);
LineTo(dc,rcHighlight.left,rcHighlight.bottom);
}
}
}
SelectObject( dc, hOldPen );
SelectObject( dc, hOldBrush );
}
RECT CWiaPreviewWindow::GetSizingHandleRect( const RECT &rcSelection, int iWhich )
{
RECT rcSel;
CopyRect(&rcSel,&rcSelection);
NormalizeRect(rcSel);
int sizeWidth = Minimum<int>(m_nHandleSize,WiaUiUtil::RectWidth(rcSel)/2);
int sizeHeight = Minimum<int>(m_nHandleSize,WiaUiUtil::RectHeight(rcSel)/2);
switch (iWhich)
{
case HIT_TOPLEFT:
return(CreateRect( rcSel.left - m_nHandleSize, rcSel.top - m_nHandleSize, rcSel.left + sizeWidth, rcSel.top + sizeHeight ));
case HIT_TOPRIGHT:
return(CreateRect( rcSel.right - sizeWidth, rcSel.top - m_nHandleSize, rcSel.right + m_nHandleSize, rcSel.top + sizeHeight));
case HIT_BOTTOMRIGHT:
return(CreateRect( rcSel.right - sizeWidth, rcSel.bottom - sizeHeight, rcSel.right + m_nHandleSize, rcSel.bottom + m_nHandleSize ));
case HIT_BOTTOMLEFT:
return(CreateRect( rcSel.left - m_nHandleSize, rcSel.bottom - sizeHeight, rcSel.left + sizeWidth, rcSel.bottom + m_nHandleSize ));
default:
return(CreateRect(0,0,0,0));
}
}
RECT CWiaPreviewWindow::GetSelectionRect( RECT &rcSel, int iWhich )
{
switch (iWhich)
{
case HIT_LEFT:
return(CreateRect( rcSel.left-m_nHandleSize,rcSel.top-m_nHandleSize,rcSel.left+m_nHandleSize,rcSel.bottom+m_nHandleSize));
case HIT_RIGHT:
return(CreateRect( rcSel.right-m_nHandleSize, rcSel.top-m_nHandleSize, rcSel.right+m_nHandleSize, rcSel.bottom+m_nHandleSize ));
case HIT_TOP:
return(CreateRect( rcSel.left-m_nHandleSize, rcSel.top-m_nHandleSize, rcSel.right+m_nHandleSize, rcSel.top+m_nHandleSize ));
case HIT_BOTTOM:
return(CreateRect( rcSel.left-m_nHandleSize, rcSel.bottom-m_nHandleSize, rcSel.right+m_nHandleSize, rcSel.bottom+m_nHandleSize ));
default:
return(CreateRect(0,0,0,0));
}
}
POINT CWiaPreviewWindow::GetCornerPoint( int iWhich )
{
RECT rcTmp(m_rcCurrSel);
NormalizeRect(m_rcCurrSel);
POINT pt;
pt.x = pt.y = 0;
if (iWhich & HIT_TOP)
pt.y = rcTmp.top;
if (iWhich & HIT_BOTTOM)
pt.y = rcTmp.bottom;
if (iWhich & HIT_RIGHT)
pt.x = rcTmp.right;
if (iWhich & HIT_LEFT)
pt.x = rcTmp.left;
return(pt);
}
void CWiaPreviewWindow::DrawSizingFrame( HDC dc, RECT &rc, bool bHasFocus, bool bDisabled )
{
RECT rcTmp;
CopyRect(&rcTmp,&rc);
NormalizeRect(rcTmp);
int nState = Unselected;
if (bDisabled)
nState = Disabled;
else if (bHasFocus)
nState = Selected;
HPEN hOldPen = (HPEN)SelectObject(dc,m_aBorderPens[nState]);
HBRUSH hOldBrush = (HBRUSH)SelectObject(dc,GetStockObject(NULL_BRUSH));
COLORREF crOldColor = SetBkColor(dc,RGB(255,255,255));
int nOldROP2 = SetROP2(dc,R2_COPYPEN);
Rectangle(dc,rcTmp.left,rcTmp.top,rcTmp.right,rcTmp.bottom);
DrawHandle( dc, GetSizingHandleRect( rcTmp, HIT_TOPLEFT ), nState );
DrawHandle( dc, GetSizingHandleRect( rcTmp, HIT_TOPRIGHT ), nState );
DrawHandle( dc, GetSizingHandleRect( rcTmp, HIT_BOTTOMLEFT ), nState );
DrawHandle( dc, GetSizingHandleRect( rcTmp, HIT_BOTTOMRIGHT ), nState );
SetROP2(dc,nOldROP2);
SetBkColor(dc,crOldColor);
SelectObject(dc,hOldBrush);
SelectObject(dc,hOldPen);
}
bool CWiaPreviewWindow::IsAlphaBlendEnabled(void)
{
return(m_bfBlendFunction.SourceConstantAlpha != 0xFF);
}
HPALETTE CWiaPreviewWindow::SetHalftonePalette( HDC hDC )
{
if (m_hHalftonePalette)
{
HPALETTE hOldPalette = SelectPalette( hDC, m_hHalftonePalette, FALSE );
RealizePalette( hDC );
SetBrushOrgEx( hDC, 0,0, NULL );
return(hOldPalette);
}
else
{
HPALETTE hOldPalette = SelectPalette( hDC, (HPALETTE)GetStockObject(DEFAULT_PALETTE), FALSE );
RealizePalette( hDC );
return(hOldPalette);
}
}
void CWiaPreviewWindow::PaintWindowTitle( HDC hDC )
{
//
// Get the length of the caption text
//
int nTextLen = (int)SendMessage( m_hWnd, WM_GETTEXTLENGTH, 0, 0 );
if (nTextLen >= 0)
{
//
// Allocate a buffer to hold it
//
LPTSTR pszText = new TCHAR[nTextLen+1];
if (pszText)
{
//
// Get the text
//
if (SendMessage( m_hWnd, WM_GETTEXT, nTextLen+1, (LPARAM)pszText ))
{
//
// Save the DC's state
//
int nDrawTextFlags = DT_CENTER|DT_NOPREFIX|DT_WORDBREAK;
COLORREF crOldTextColor = SetTextColor( hDC, GetSysColor( COLOR_WINDOWTEXT ) );
int nOldBkMode = SetBkMode( hDC, TRANSPARENT );
//
// Get the size of the image rectangle
//
RECT rcImage = GetImageRect();
RECT rcAvailable = rcImage;
//
// Leave some space for a margin
//
rcAvailable.right -= 20;
//
// Get the control's font, if there is one
//
HFONT hOldFont = NULL, hWndFont = WiaUiUtil::GetFontFromWindow( m_hWnd );
//
// Set the DC's font
//
if (hWndFont)
{
hOldFont = reinterpret_cast<HFONT>(SelectObject( hDC, hWndFont ));
}
//
// Calculate the size of the text
//
RECT rcText = {0};
if (DrawText( hDC, pszText, lstrlen(pszText), &rcAvailable, nDrawTextFlags|DT_CALCRECT ))
{
//
// add the extra margin back in and form the text rectangle
//
rcAvailable.right += 20;
//
// Calculate the text size
//
rcText.left = rcImage.left + (WiaUiUtil::RectWidth(rcImage) - WiaUiUtil::RectWidth(rcAvailable))/2;
rcText.top = rcImage.top + (WiaUiUtil::RectHeight(rcImage) - WiaUiUtil::RectHeight(rcAvailable))/2;
rcText.right = rcText.left + WiaUiUtil::RectWidth(rcAvailable);
rcText.bottom = rcText.top + WiaUiUtil::RectHeight(rcAvailable);
}
//
// See if the progress control is active
//
HWND hWndProgress = GetDlgItem( m_hWnd, IDC_PROGRESSCONTROL );
if (hWndProgress)
{
//
// Get the window rect of the progress control
//
CSimpleRect ProgressRect( hWndProgress, CSimpleRect::WindowRect );
//
// Move the y origin of the text up
//
rcText.top = ProgressRect.ScreenToClient(m_hWnd).top - CDialogUnits(m_hWnd).Y(3) - WiaUiUtil::RectHeight(rcText);
//
// Resize the text rectangle to encompass the bottom of the progress control
//
rcText.bottom = ProgressRect.ScreenToClient(m_hWnd).bottom;
}
//
// Draw the background rectangle and the text
//
RECT rcBorder = { rcImage.left + CDialogUnits(m_hWnd).X(7), rcText.top - CDialogUnits(m_hWnd).X(3), rcImage.right - CDialogUnits(m_hWnd).X(7), rcText.bottom + CDialogUnits(m_hWnd).X(3) };
FillRect( hDC, &rcBorder, GetSysColorBrush(COLOR_WINDOW));
FrameRect( hDC, &rcBorder, GetSysColorBrush(COLOR_WINDOWFRAME));
DrawText( hDC, pszText, lstrlen(pszText), &rcText, nDrawTextFlags );
//
// Restore the DC to its original condition
//
if (hWndFont)
{
SelectObject( hDC, hOldFont );
}
SetTextColor( hDC, crOldTextColor );
SetBkMode( hDC, nOldBkMode );
}
delete[] pszText;
}
}
}
LRESULT CWiaPreviewWindow::OnPaint( WPARAM, LPARAM )
{
PAINTSTRUCT ps;
HDC hDC;
RECT rcIntersection, rcImage = GetImageRect(), rcCurrentSelection;
hDC = BeginPaint(m_hWnd,&ps);
if (hDC)
{
if (!m_hBufferBitmap)
{
FillRect( hDC, &ps.rcPaint, m_hBackgroundBrush );
PaintWindowTitle( hDC );
}
else
{
// Select the halftone palette
HPALETTE hOldDCPalette = SetHalftonePalette( hDC );
HDC hdcMem = CreateCompatibleDC(hDC);
if (hdcMem)
{
HPALETTE hOldMemDCPalette = SetHalftonePalette( hdcMem );
HDC hdcBuffer = CreateCompatibleDC(hDC);
if (hdcBuffer)
{
HPALETTE hOldBufferDCPalette = SetHalftonePalette( hdcBuffer );
HBITMAP hOldBufferDCBitmap = (HBITMAP)SelectObject(hdcBuffer,m_hBufferBitmap);
CopyRect(&rcCurrentSelection,&m_rcCurrSel);
NormalizeRect(rcCurrentSelection);
if (IsDefaultSelectionRect(rcCurrentSelection))
rcCurrentSelection = rcImage;
// Prepare the double buffer bitmap by painting the selected and non-selected regions
if (m_hAlphaBitmap && m_bfBlendFunction.SourceConstantAlpha != 0xFF && !m_bPreviewMode)
{
HBITMAP hOldMemDCBitmap = (HBITMAP)SelectObject(hdcMem,m_hAlphaBitmap);
BitBlt(hdcBuffer,ps.rcPaint.left,ps.rcPaint.top,WiaUiUtil::RectWidth(ps.rcPaint),WiaUiUtil::RectHeight(ps.rcPaint),hdcMem,ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
SelectObject(hdcMem,m_hPaintBitmap);
if (IntersectRect( &rcIntersection, &ps.rcPaint, &rcCurrentSelection ))
BitBlt(hdcBuffer,rcIntersection.left,rcIntersection.top,WiaUiUtil::RectWidth(rcIntersection),WiaUiUtil::RectHeight(rcIntersection),hdcMem,rcIntersection.left,rcIntersection.top,SRCCOPY);
SelectObject(hdcMem,hOldMemDCBitmap);
}
else if (m_hPaintBitmap)
{
HBITMAP hOldMemDCBitmap = (HBITMAP)SelectObject(hdcMem,m_hPaintBitmap);
BitBlt(hdcBuffer,ps.rcPaint.left,ps.rcPaint.top,WiaUiUtil::RectWidth(ps.rcPaint),WiaUiUtil::RectHeight(ps.rcPaint),hdcMem,ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
SelectObject(hdcMem,hOldMemDCBitmap);
}
else
{
FillRect( hdcBuffer, &ps.rcPaint, m_hBackgroundBrush );
}
bool bDisabled = ((GetWindowLong(m_hWnd,GWL_STYLE)&WS_DISABLED) != 0);
#if defined(DITHER_DISABLED_CONTROL)
if (bDisabled)
{
// paint the disabled mask
if (IntersectRect( &rcIntersection, &rcImage, &ps.rcPaint ))
DitherRect(hdcBuffer,rcIntersection);
}
#endif // DITHER_DISABLED_CONTROL
//
// paint the selection rectangle
//
rcCurrentSelection = m_rcCurrSel;
NormalizeRect(rcCurrentSelection);
if (!IsDefaultSelectionRect( rcCurrentSelection ) && !m_bPreviewMode)
{
DrawSizingFrame( hdcBuffer, rcCurrentSelection, (GetFocus()==m_hWnd), bDisabled );
}
PaintWindowTitle( hdcBuffer );
// show it!
BitBlt( hDC, ps.rcPaint.left, ps.rcPaint.top, WiaUiUtil::RectWidth(ps.rcPaint), WiaUiUtil::RectHeight(ps.rcPaint),hdcBuffer,ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
// Paint all of the area outside the buffer bitmap
RECT rcClient;
GetClientRect( m_hWnd, &rcClient );
BITMAP bm;
if (GetObject( m_hBufferBitmap, sizeof(BITMAP), &bm ))
{
if (ps.rcPaint.right > bm.bmWidth)
{
RECT rc;
rc.left = bm.bmWidth;
rc.top = ps.rcPaint.top;
rc.right = rcClient.right;
rc.bottom = rcClient.bottom;
FillRect( hDC, &rc, m_hBackgroundBrush );
}
if (ps.rcPaint.bottom > bm.bmHeight)
{
RECT rc;
rc.left = ps.rcPaint.left;
rc.top = bm.bmHeight;
rc.right = bm.bmWidth;
rc.bottom = rcClient.bottom;
FillRect( hDC, &rc, m_hBackgroundBrush );
}
}
SelectObject( hdcBuffer, hOldBufferDCBitmap );
SelectPalette( hdcBuffer, hOldBufferDCPalette, FALSE );
DeleteDC(hdcBuffer);
}
SelectPalette( hdcMem, hOldMemDCPalette, FALSE );
DeleteDC( hdcMem );
}
SelectPalette( hDC, hOldDCPalette, FALSE );
}
EndPaint(m_hWnd,&ps);
}
return(LRESULT)0;
}
BOOL CWiaPreviewWindow::RegisterClass( HINSTANCE hInstance )
{
WNDCLASS wc;
memset( &wc, 0, sizeof(wc) );
wc.style = CS_DBLCLKS;
wc.cbWndExtra = sizeof(CWiaPreviewWindow*);
wc.lpfnWndProc = WndProc;
wc.hInstance = hInstance;
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszClassName = PREVIEW_WINDOW_CLASS;
BOOL res = (::RegisterClass(&wc) != 0);
return(res != 0);
}
RECT CWiaPreviewWindow::GetImageRect(void)
{
RECT rcImg;
::GetClientRect( m_hWnd, &rcImg );
InflateRect( &rcImg, -static_cast<int>(m_nBorderSize), -static_cast<int>(m_nBorderSize) );
return(rcImg);
}
int CWiaPreviewWindow::GetHitArea( POINT &pt )
{
RECT rcTmp;
CopyRect(&rcTmp,&m_rcCurrSel);
NormalizeRect(rcTmp);
int Hit = 0;
if (PointInRect(GetSelectionRect(rcTmp,HIT_TOP),pt))
Hit |= HIT_TOP;
else if (PointInRect(GetSelectionRect(rcTmp,HIT_BOTTOM),pt))
Hit |= HIT_BOTTOM;
if (PointInRect(GetSelectionRect(rcTmp,HIT_LEFT),pt))
Hit |= HIT_LEFT;
else if (PointInRect(GetSelectionRect(rcTmp,HIT_RIGHT),pt))
Hit |= HIT_RIGHT;
if (!Hit && PointInRect(rcTmp,pt))
Hit = HIT_SELECTED;
if (!Hit && !PointInRect(GetImageRect(),pt))
Hit = HIT_BORDER;
return(Hit);
}
void CWiaPreviewWindow::NormalizeRect( RECT &r )
{
if (r.right < r.left)
{
int t = r.left;
r.left = r.right;
r.right = t;
}
if (r.bottom < r.top)
{
int t = r.top;
r.top = r.bottom;
r.bottom = t;
}
}
LRESULT CWiaPreviewWindow::OnMouseMove( WPARAM wParam, LPARAM lParam )
{
POINT point;
if (!m_hPreviewBitmap || m_SelectionDisabled || m_bPreviewMode)
{
SetCursor(m_hCursorArrow);
return(0);
}
point.x = (short int)LOWORD(lParam);
point.y = (short int)HIWORD(lParam);
RECT rcClient = GetImageRect();
RECT rcOldSel;
CopyRect(&rcOldSel,&m_rcCurrSel);
if (m_MovingSel != HIT_NONE)
{
switch (m_MovingSel)
{
case HIT_SELECTED:
{
int Width = WiaUiUtil::RectWidth(m_rcCurrSel);
int Height = WiaUiUtil::RectHeight(m_rcCurrSel);
if (point.x + m_Delta.cx < rcClient.left)
point.x = 0 - m_Delta.cx + rcClient.left;
else if (point.x + m_Delta.cx + Width > rcClient.right)
point.x = rcClient.right - Width - m_Delta.cx;
if (point.y + m_Delta.cy < rcClient.top)
point.y = 0 - m_Delta.cy + rcClient.top;
else if (point.y + m_Delta.cy + Height > rcClient.bottom)
point.y = rcClient.bottom - Height - m_Delta.cy;
m_rcCurrSel.left = point.x + m_Delta.cx;
m_rcCurrSel.right = m_rcCurrSel.left + Width;
m_rcCurrSel.top = point.y + m_Delta.cy;
m_rcCurrSel.bottom = m_rcCurrSel.top + Height;
}
break;
default:
if (m_MovingSel & HIT_TOP)
m_rcCurrSel.top = Boundary(point.y + m_Delta.cy,rcClient.top,rcClient.bottom);
if (m_MovingSel & HIT_BOTTOM)
m_rcCurrSel.bottom = Boundary(point.y + m_Delta.cy,rcClient.top,rcClient.bottom);
if (m_MovingSel & HIT_LEFT)
m_rcCurrSel.left = Boundary(point.x + m_Delta.cx,rcClient.left,rcClient.right);
if (m_MovingSel & HIT_RIGHT)
m_rcCurrSel.right = Boundary(point.x + m_Delta.cx,rcClient.left,rcClient.right);
break;
}
if (memcmp(&rcOldSel,&m_rcCurrSel,sizeof(RECT)))
{
RECT rcCurSel = m_rcCurrSel, rcInvalid;
NormalizeRect(rcOldSel);
NormalizeRect(rcCurSel);
TrueUnionRect(&rcInvalid,&rcCurSel,&rcOldSel);
rcInvalid.left-=m_nHandleSize;
rcInvalid.top-=m_nHandleSize;
rcInvalid.right+=m_nHandleSize;
rcInvalid.bottom+=m_nHandleSize;
SendSelChangeNotification();
Repaint(&rcInvalid,false);
UpdateWindow(m_hWnd);
}
}
int Hit;
if (m_MovingSel == HIT_NONE)
{
if (wParam & MK_CONTROL)
Hit = HIT_NONE;
else Hit = GetHitArea(point);
if (Hit == HIT_SELECTED)
SetCursor(m_hCursorMove);
else if (Hit == HIT_NONE)
SetCursor(m_hCursorCrossHairs);
else if (Hit == HIT_TOPLEFT || Hit == HIT_BOTTOMRIGHT)
SetCursor(m_hCursorSizeNwSe);
else if (Hit == HIT_TOPRIGHT || Hit == HIT_BOTTOMLEFT)
SetCursor(m_hCursorSizeNeSw);
else if (Hit == HIT_TOP || Hit == HIT_BOTTOM)
SetCursor(m_hCursorSizeNS);
else if (Hit == HIT_BORDER)
SetCursor(m_hCursorArrow);
else SetCursor(m_hCursorSizeWE);
}
else
{
Hit = m_MovingSel;
if (Hit == HIT_SELECTED)
SetCursor(m_hCursorMove);
else if (Hit == HIT_TOP || Hit == HIT_BOTTOM)
SetCursor(m_hCursorSizeNS);
else if (Hit == HIT_LEFT || Hit == HIT_RIGHT)
SetCursor(m_hCursorSizeWE);
else
{
if (m_rcCurrSel.top > m_rcCurrSel.bottom)
{
if (Hit & HIT_TOP)
{
Hit &= ~HIT_TOP;
Hit |= HIT_BOTTOM;
}
else if (Hit & HIT_BOTTOM)
{
Hit |= HIT_TOP;
Hit &= ~HIT_BOTTOM;
}
}
if (m_rcCurrSel.left > m_rcCurrSel.right)
{
if (Hit & HIT_LEFT)
{
Hit &= ~HIT_LEFT;
Hit |= HIT_RIGHT;
}
else if (Hit & HIT_RIGHT)
{
Hit |= HIT_LEFT;
Hit &= ~HIT_RIGHT;
}
}
if (Hit == HIT_TOPLEFT || Hit == HIT_BOTTOMRIGHT)
SetCursor(m_hCursorSizeNwSe);
else if (Hit == HIT_TOPRIGHT || Hit == HIT_BOTTOMLEFT)
SetCursor(m_hCursorSizeNeSw);
}
}
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnLButtonDown( WPARAM wParam, LPARAM lParam )
{
if (!m_hPreviewBitmap || m_bPreviewMode || m_SelectionDisabled)
return(0);
if (GetFocus() != m_hWnd)
SetFocus(m_hWnd);
POINT point;
point.x = LOWORD(lParam);
point.y = HIWORD(lParam);
int Hit = GetHitArea(point);
if (wParam & MK_CONTROL)
Hit = HIT_NONE;
if (Hit == HIT_SELECTED)
{
m_MovingSel = HIT_SELECTED;
POINT pt = GetCornerPoint(HIT_TOPLEFT);
m_Delta.cx = pt.x - point.x;
m_Delta.cy = pt.y - point.y;
SetCapture(m_hWnd);
}
else if (Hit == HIT_NONE)
{
m_MovingSel = HIT_TOPLEFT;
m_rcCurrSel.left = m_rcCurrSel.right = point.x;
m_rcCurrSel.top = m_rcCurrSel.bottom = point.y;
POINT pt = GetCornerPoint(m_MovingSel);
m_Delta.cx = pt.x - point.x;
m_Delta.cy = pt.y - point.y;
SendSelChangeNotification();
Repaint(NULL,false);
UpdateWindow(m_hWnd);
SetCapture(m_hWnd);
}
else
{
m_MovingSel = Hit;
POINT pt = GetCornerPoint(Hit);
m_Delta.cx = pt.x - point.x;
m_Delta.cy = pt.y - point.y;
SetCapture(m_hWnd);
}
return(LRESULT)0;
}
void CWiaPreviewWindow::SendSelChangeNotification( bool bSetUserChangedSelection )
{
HWND hWndParent = GetParent(m_hWnd);
if (hWndParent && IsWindow(hWndParent))
{
SendNotifyMessage(hWndParent,WM_COMMAND,MAKEWPARAM(GetWindowLongPtr(m_hWnd,GWLP_ID),PWN_SELCHANGE),reinterpret_cast<LPARAM>(m_hWnd));
}
if (bSetUserChangedSelection)
{
m_bUserChangedSelection = true;
}
}
LRESULT CWiaPreviewWindow::OnLButtonUp( WPARAM, LPARAM )
{
if (!m_hPreviewBitmap || m_bPreviewMode || m_SelectionDisabled)
return(0);
m_MovingSel = HIT_NONE;
ReleaseCapture();
NormalizeRect(m_rcCurrSel);
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnCreate( WPARAM, LPARAM )
{
SetWindowLong( m_hWnd, GWL_EXSTYLE, GetWindowLong(m_hWnd,GWL_EXSTYLE) & ~WS_EX_LAYOUTRTL );
m_rcCurrSel = GetDefaultSelection();
CreateNewBitmaps();
return(0);
}
void CWiaPreviewWindow::CreateNewBitmaps(void)
{
DestroyBitmaps();
// No need to create the bitmaps if we have no bitmap to display
if (!m_hPreviewBitmap)
return;
// Get client window size
CSimpleRect rcClient( m_hWnd );
bool bSuccess = true;
// Get a client DC
HDC hdcClient = GetDC(m_hWnd);
if (hdcClient)
{
m_hBufferBitmap = CreateCompatibleBitmap(hdcClient,WiaUiUtil::RectWidth(rcClient),WiaUiUtil::RectHeight(rcClient));
if (m_hBufferBitmap)
{
m_hPaintBitmap = CreateCompatibleBitmap(hdcClient,WiaUiUtil::RectWidth(rcClient),WiaUiUtil::RectHeight(rcClient));
if (m_hPaintBitmap)
{
if (IsAlphaBlendEnabled())
{
m_hAlphaBitmap = CreateCompatibleBitmap(hdcClient,WiaUiUtil::RectWidth(rcClient),WiaUiUtil::RectHeight(rcClient));
if (!m_hAlphaBitmap)
bSuccess = false;
}
}
else bSuccess = false;
}
else bSuccess = false;
ReleaseDC(m_hWnd,hdcClient);
}
else bSuccess = false;
if (!bSuccess)
DestroyBitmaps();
}
LRESULT CWiaPreviewWindow::OnGetImageSize( WPARAM, LPARAM lParam )
{
if (lParam)
{
*reinterpret_cast<SIZE*>(lParam) = m_BitmapSize;
return(1);
}
return(0);
}
bool CWiaPreviewWindow::GetOriginAndExtentInImagePixels( WORD nItem, POINT &ptOrigin, SIZE &sizeExtent )
{
SIZE sizeSavedResolution;
bool bResult = false;
if (WiaPreviewControl_GetResolution(m_hWnd,&sizeSavedResolution))
{
WiaPreviewControl_SetResolution(m_hWnd, &m_BitmapSize);
bResult = (WiaPreviewControl_GetSelOrigin( m_hWnd, nItem, 0, &ptOrigin ) && WiaPreviewControl_GetSelExtent( m_hWnd, nItem, 0, &sizeExtent ));
// Restore the old resolution
WiaPreviewControl_SetResolution(m_hWnd, &sizeSavedResolution);
}
return(bResult);
}
void CWiaPreviewWindow::DrawBitmaps(void)
{
// Don't bother painting the bitmap if we don't have an image.
if (!m_hPreviewBitmap)
return;
RECT rcImage = GetImageRect();
// Nuke old halftone palette
if (m_hHalftonePalette)
{
DeleteObject(m_hHalftonePalette);
m_hHalftonePalette = NULL;
}
// Get client window size
CSimpleRect rcClient( m_hWnd );
// Get a client DC
HDC hdcClient = GetDC(m_hWnd);
if (hdcClient)
{
// Recreate the halftone palette
m_hHalftonePalette = CreateHalftonePalette(hdcClient);
if (m_hHalftonePalette)
{
// Create a compatible dc
HDC hdcCompat = CreateCompatibleDC(hdcClient);
if (hdcCompat)
{
HBITMAP hOldBitmap = (HBITMAP)SelectObject( hdcCompat, m_hPaintBitmap );
HPALETTE hOldPalette = SetHalftonePalette( hdcCompat );
if (m_hPaintBitmap)
{
FillRect( hdcCompat, &rcClient, m_hBackgroundBrush );
HDC hdcMem = CreateCompatibleDC(hdcCompat);
if (hdcMem)
{
HPALETTE hOldMemDCPalette = SetHalftonePalette( hdcMem );
HBITMAP hOldMemDCBitmap = (HBITMAP)SelectObject( hdcMem, m_hPreviewBitmap );
int nOldStretchMode = SetStretchBltMode(hdcCompat,STRETCH_HALFTONE);
POINT ptSource = { 0, 0};
SIZE sizeSource = { m_BitmapSize.cx, m_BitmapSize.cy};
if (m_bPreviewMode)
{
POINT ptOrigin;
SIZE sizeExtent;
if (GetOriginAndExtentInImagePixels( 0, ptOrigin, sizeExtent ))
{
ptSource = ptOrigin;
sizeSource = sizeExtent;
}
}
StretchBlt(hdcCompat,rcImage.left,rcImage.top,WiaUiUtil::RectWidth(rcImage),WiaUiUtil::RectHeight(rcImage),hdcMem,ptSource.x,ptSource.y,sizeSource.cx,sizeSource.cy,SRCCOPY);
if (m_hAlphaBitmap)
{
SelectObject(hdcMem,m_hAlphaBitmap);
// First, lay down our lovely border
FillRect( hdcMem,&rcClient,m_hBackgroundBrush );
// The lay down the alpha blend background
FillRect( hdcMem,&rcImage,(HBRUSH)GetStockObject(WHITE_BRUSH) );
// Alpha blend it
AlphaBlend(hdcMem,rcImage.left,rcImage.top,WiaUiUtil::RectWidth(rcImage),WiaUiUtil::RectHeight(rcImage),hdcCompat,rcImage.left,rcImage.top,WiaUiUtil::RectWidth(rcImage),WiaUiUtil::RectHeight(rcImage),m_bfBlendFunction);
}
//
// Restore DC state and delete DC
//
SelectPalette(hdcMem,hOldMemDCPalette,FALSE);
SetStretchBltMode(hdcCompat,nOldStretchMode);
SelectObject(hdcMem,hOldMemDCBitmap);
DeleteDC(hdcMem);
}
}
//
// Restore DC state and delete DC
//
SelectObject( hdcCompat, hOldBitmap );
SelectPalette( hdcCompat, hOldPalette, FALSE );
DeleteDC(hdcCompat);
}
}
ReleaseDC(m_hWnd,hdcClient);
}
}
#ifndef RECT_WIDTH
#define RECT_WIDTH(x) ((x).right - (x).left)
#endif
#ifndef RECT_HEIGHT
#define RECT_HEIGHT(x) ((x).bottom - (x).top)
#endif
RECT CWiaPreviewWindow::ScaleSelectionRect( const RECT &rcOriginalImage, const RECT &rcCurrentImage, const RECT &rcOriginalSel )
{
RECT rcCurrentSel;
if (IsDefaultSelectionRect(rcOriginalSel))
return(rcOriginalSel);
if (RECT_WIDTH(rcOriginalImage) && RECT_HEIGHT(rcOriginalImage))
{
rcCurrentSel.left = rcCurrentImage.left + MulDiv(rcOriginalSel.left-rcOriginalImage.left,RECT_WIDTH(rcCurrentImage),RECT_WIDTH(rcOriginalImage));
rcCurrentSel.right = rcCurrentImage.left + MulDiv(rcOriginalSel.right-rcOriginalImage.left,RECT_WIDTH(rcCurrentImage),RECT_WIDTH(rcOriginalImage));
rcCurrentSel.top = rcCurrentImage.top + MulDiv(rcOriginalSel.top-rcOriginalImage.top,RECT_HEIGHT(rcCurrentImage),RECT_HEIGHT(rcOriginalImage));
rcCurrentSel.bottom = rcCurrentImage.top + MulDiv(rcOriginalSel.bottom-rcOriginalImage.top,RECT_HEIGHT(rcCurrentImage),RECT_HEIGHT(rcOriginalImage));
}
else rcCurrentSel = GetDefaultSelection();
// If we're gone, start over with max selection
if (rcCurrentSel.left >= rcCurrentSel.right || rcCurrentSel.top >= rcCurrentSel.bottom)
{
rcCurrentSel = GetDefaultSelection();
}
NormalizeRect(rcCurrentSel);
if (rcCurrentSel.left < rcCurrentImage.left)
rcCurrentSel.left = rcCurrentImage.left;
if (rcCurrentSel.top < rcCurrentImage.top)
rcCurrentSel.top = rcCurrentImage.top;
if (rcCurrentSel.right > rcCurrentImage.right)
rcCurrentSel.right = rcCurrentImage.right;
if (rcCurrentSel.bottom > rcCurrentImage.bottom)
rcCurrentSel.bottom = rcCurrentImage.bottom;
return(rcCurrentSel);
}
LRESULT CWiaPreviewWindow::OnSize( WPARAM wParam, LPARAM )
{
int nType = (int)wParam;
if ((nType == SIZE_RESTORED || nType == SIZE_MAXIMIZED))
{
//
// Resize the progress control if it exists
//
ResizeProgressBar();
if (!m_bSizing)
{
RECT rcCurrentImageRect = GetImageRect();
m_rcCurrSel = ScaleSelectionRect( m_rcSavedImageRect, rcCurrentImageRect, m_rcCurrSel );
m_rcSavedImageRect = rcCurrentImageRect;
CreateNewBitmaps();
DrawBitmaps();
Repaint(NULL,false);
SendSelChangeNotification(false);
}
else Repaint(NULL,false);
}
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnSetText( WPARAM wParam, LPARAM lParam )
{
LRESULT lResult = DefWindowProc( m_hWnd, WM_SETTEXT, wParam, lParam );
InvalidateRect( m_hWnd, NULL, FALSE );
UpdateWindow( m_hWnd );
return(lResult);
}
LRESULT CWiaPreviewWindow::OnGetDlgCode( WPARAM, LPARAM )
{
return(LRESULT)(DLGC_WANTARROWS);
}
LRESULT CWiaPreviewWindow::OnKeyDown( WPARAM wParam, LPARAM )
{
if (!m_hPreviewBitmap || m_SelectionDisabled || m_bPreviewMode || IsDefaultSelectionRect(m_rcCurrSel))
return(0);
int nVirtKey = (int)wParam;
int nAccelerate = 1;
if (GetKeyState(VK_CONTROL) & 0x8000)
nAccelerate = DEFAULT_ACCEL_FACTOR;
RECT rcImage = GetImageRect(), rcOldCurrSel;
CopyRect(&rcOldCurrSel,&m_rcCurrSel);
// If SHIFT key is pressed, but ALT is not
if (!(GetKeyState(VK_MENU) & 0x8000) && (GetKeyState(VK_SHIFT) & 0x8000))
{
switch (nVirtKey)
{
case VK_UP:
if (m_rcCurrSel.bottom > m_rcCurrSel.top+nAccelerate)
m_rcCurrSel.bottom -= nAccelerate;
else m_rcCurrSel.bottom = m_rcCurrSel.top;
break;
case VK_DOWN:
m_rcCurrSel.bottom += nAccelerate;
if (m_rcCurrSel.bottom > rcImage.bottom)
m_rcCurrSel.bottom = rcImage.bottom;
break;
case VK_RIGHT:
m_rcCurrSel.right += nAccelerate;
if (m_rcCurrSel.right > rcImage.right)
m_rcCurrSel.right = rcImage.right;
break;
case VK_LEFT:
if (m_rcCurrSel.right > m_rcCurrSel.left+nAccelerate)
m_rcCurrSel.right -= nAccelerate;
else m_rcCurrSel.right = m_rcCurrSel.left;
break;
}
}
// If SHIFT key not is pressed and ALT is not
if (!(GetKeyState(VK_MENU) & 0x8000) && !(GetKeyState(VK_SHIFT) & 0x8000))
{
switch (nVirtKey)
{
case VK_DELETE:
m_rcCurrSel = GetDefaultSelection();
break;
case VK_HOME:
OffsetRect( &m_rcCurrSel, rcImage.left-m_rcCurrSel.left, 0 );
break;
case VK_END:
OffsetRect( &m_rcCurrSel, rcImage.right-m_rcCurrSel.right, 0 );
break;
case VK_PRIOR:
OffsetRect( &m_rcCurrSel, 0, rcImage.top-m_rcCurrSel.top );
break;
case VK_NEXT:
OffsetRect( &m_rcCurrSel, 0, rcImage.bottom-m_rcCurrSel.bottom );
break;
case VK_UP:
OffsetRect(&m_rcCurrSel,0,-nAccelerate);
if (m_rcCurrSel.top < rcImage.top)
OffsetRect(&m_rcCurrSel,0,-m_rcCurrSel.top+rcImage.top);
break;
case VK_LEFT:
OffsetRect(&m_rcCurrSel,-nAccelerate,0);
if (m_rcCurrSel.left < rcImage.left)
OffsetRect(&m_rcCurrSel,-m_rcCurrSel.left+rcImage.left,0);
break;
case VK_DOWN:
OffsetRect(&m_rcCurrSel,0,nAccelerate);
if (m_rcCurrSel.bottom > rcImage.bottom)
OffsetRect(&m_rcCurrSel,0,-(m_rcCurrSel.bottom-rcImage.bottom));
break;
case VK_RIGHT:
OffsetRect(&m_rcCurrSel,nAccelerate,0);
if (m_rcCurrSel.right > rcImage.right)
OffsetRect(&m_rcCurrSel,-(m_rcCurrSel.right-rcImage.right),0);
break;
}
}
if (IsDefaultSelectionRect(m_rcCurrSel))
{
InvalidateRect( m_hWnd, NULL, FALSE );
UpdateWindow( m_hWnd );
SendSelChangeNotification();
}
else if (memcmp(&rcOldCurrSel,&m_rcCurrSel,sizeof(RECT)))
{
RECT rcCurSel = m_rcCurrSel, rcInvalid;
NormalizeRect(rcOldCurrSel);
NormalizeRect(rcCurSel);
TrueUnionRect(&rcInvalid,&rcCurSel,&rcOldCurrSel);
rcInvalid.left-=m_nHandleSize;
rcInvalid.top-=m_nHandleSize;
rcInvalid.right+=m_nHandleSize;
rcInvalid.bottom+=m_nHandleSize;
Repaint(&rcInvalid,false);
UpdateWindow(m_hWnd);
SendSelChangeNotification();
}
return(LRESULT)0;
}
//wParam = 0, lParam = LPSIZE lpResolution
LRESULT CWiaPreviewWindow::OnSetResolution( WPARAM, LPARAM lParam )
{
if (lParam)
{
m_Resolution = *((LPSIZE)lParam);
}
else
{
m_Resolution.cx = m_Resolution.cy = 0;
}
return(LRESULT)0;
}
//wParam = 0, lParam = LPSIZE lpResolution
LRESULT CWiaPreviewWindow::OnGetResolution( WPARAM, LPARAM lParam )
{
if (lParam)
{
*reinterpret_cast<SIZE*>(lParam) = m_Resolution;
return(LRESULT)1;
}
return(LRESULT)0;
}
//wParam = 0, lParam = LPRECT lprcSelRect
LRESULT CWiaPreviewWindow::OnClearSelection( WPARAM, LPARAM )
{
m_rcCurrSel = GetDefaultSelection();
Repaint(NULL,false);
return(LRESULT)0;
}
// wParam = (BOOL)MAKEWPARAM(bRepaint,bDontDestroy), lParam = (HBITMAP)hBmp
LRESULT CWiaPreviewWindow::OnSetBitmap( WPARAM wParam, LPARAM lParam )
{
if (m_bDeleteBitmap && m_hPreviewBitmap)
DeleteObject(m_hPreviewBitmap);
m_hPreviewBitmap = (HBITMAP)lParam;
m_BitmapSize.cx = m_BitmapSize.cy = 0;
if (m_hPreviewBitmap)
{
BITMAP bm = {0};
if (GetObject(m_hPreviewBitmap,sizeof(BITMAP),&bm))
{
m_BitmapSize.cx = bm.bmWidth;
m_BitmapSize.cy = bm.bmHeight;
}
}
m_bDeleteBitmap = !HIWORD(wParam);
if (!m_hPaintBitmap || !m_hBufferBitmap || (!m_hAlphaBitmap && IsAlphaBlendEnabled()))
{
CreateNewBitmaps();
}
DrawBitmaps();
if (LOWORD(wParam))
{
Repaint(NULL,false);
}
return(LRESULT)0;
}
// wParam = 0, lParam = 0
LRESULT CWiaPreviewWindow::OnGetBitmap( WPARAM wParam, LPARAM lParam )
{
return(LRESULT)m_hPreviewBitmap;
}
LRESULT CWiaPreviewWindow::OnSetFocus( WPARAM, LPARAM )
{
// If the rect isn't visible, recreate it.
if (m_rcCurrSel.left == m_rcCurrSel.right || m_rcCurrSel.top == m_rcCurrSel.bottom && !IsDefaultSelectionRect(m_rcCurrSel))
{
m_rcCurrSel = GetDefaultSelection();
}
Repaint(NULL,false);
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnKillFocus( WPARAM, LPARAM )
{
Repaint(NULL,false);
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnEnable( WPARAM, LPARAM )
{
Repaint(NULL,false);
return(LRESULT)0;
}
LRESULT CWiaPreviewWindow::OnEraseBkgnd( WPARAM, LPARAM )
{
return(LRESULT)1;
}
LRESULT CWiaPreviewWindow::OnGetBorderSize( WPARAM, LPARAM )
{
return(m_nBorderSize);
}
LRESULT CWiaPreviewWindow::OnGetHandleSize( WPARAM, LPARAM )
{
return(m_nHandleSize);
}
LRESULT CWiaPreviewWindow::OnGetBgAlpha( WPARAM, LPARAM )
{
return(m_bfBlendFunction.SourceConstantAlpha);
}
LRESULT CWiaPreviewWindow::OnGetHandleType( WPARAM, LPARAM )
{
return(m_nHandleType);
}
LRESULT CWiaPreviewWindow::OnSetBorderSize( WPARAM wParam, LPARAM lParam )
{
int nOldBorder = m_nBorderSize;
m_nBorderSize = (UINT)lParam;
if (wParam)
{
DrawBitmaps();
Repaint(NULL,false);
}
return(nOldBorder);
}
LRESULT CWiaPreviewWindow::OnSetHandleSize( WPARAM wParam, LPARAM lParam )
{
int nOldHandleSize = m_nHandleSize;
m_nHandleSize = (int)lParam;
if (wParam)
Repaint(NULL,false);
return(nOldHandleSize);
}
LRESULT CWiaPreviewWindow::OnSetBgAlpha( WPARAM wParam, LPARAM lParam )
{
int nOldBgAlpha = m_bfBlendFunction.SourceConstantAlpha;
m_bfBlendFunction.SourceConstantAlpha = (BYTE)lParam;
if (wParam)
{
DrawBitmaps();
Repaint(NULL,false);
}
return(nOldBgAlpha);
}
LRESULT CWiaPreviewWindow::OnSetHandleType( WPARAM wParam, LPARAM lParam )
{
int nOldHandleType = m_nHandleType;
m_nHandleType = (int)lParam;
if (wParam)
Repaint(NULL,false);
return(nOldHandleType);
}
LRESULT CWiaPreviewWindow::OnEnterSizeMove( WPARAM, LPARAM )
{
m_bSizing = true;
return(0);
}
LRESULT CWiaPreviewWindow::OnExitSizeMove( WPARAM, LPARAM )
{
if (m_bSizing)
{
m_bSizing = false;
RECT rcCurrentImageRect = GetImageRect();
if (memcmp(&rcCurrentImageRect,&m_rcSavedImageRect,sizeof(RECT)))
{
m_rcCurrSel = ScaleSelectionRect( m_rcSavedImageRect, rcCurrentImageRect, m_rcCurrSel );
m_rcSavedImageRect = rcCurrentImageRect;
CreateNewBitmaps();
DrawBitmaps();
SendSelChangeNotification(false);
}
Repaint(NULL,false);
}
return(0);
}
// wParam = (BOOL)MAKEWPARAM((WORD)nItem,(BOOL)bPhysical), lParam = (PPOINT)pOrigin
LRESULT CWiaPreviewWindow::OnGetSelOrigin( WPARAM wParam, LPARAM lParam )
{
int nCount = static_cast<int>(SendMessage( m_hWnd, PWM_GETSELCOUNT, 0, 0 ));
int nItem = (int)LOWORD(wParam);
BOOL bPhysical = (BOOL)HIWORD(wParam);
PPOINT pOrigin = (PPOINT)lParam;
RECT rcImage = GetImageRect();
if (nCount <= 0 || nItem < 0 || nItem >= nCount || !pOrigin)
return(0);
RECT rcSel = m_rcCurrSel;
NormalizeRect(rcSel);
if (IsRectEmpty(&rcSel))
rcSel = rcImage;
if (bPhysical)
{
pOrigin->x = rcSel.left - rcImage.left;
pOrigin->y = rcSel.top - rcImage.top;
return(1);
}
else if (RECT_WIDTH(rcImage) && RECT_HEIGHT(rcImage)) // Make sure we get no divide by zero errors
{
pOrigin->x = WiaUiUtil::MulDivNoRound(m_Resolution.cx,rcSel.left-rcImage.left,RECT_WIDTH(rcImage));
pOrigin->y = WiaUiUtil::MulDivNoRound(m_Resolution.cy,rcSel.top-rcImage.top,RECT_HEIGHT(rcImage));
return(1);
}
else return(0);
}
// wParam = (BOOL)MAKEWPARAM((WORD)nItem,(BOOL)bPhysical), lParam = (PSIZE)pExtent
LRESULT CWiaPreviewWindow::OnGetSelExtent( WPARAM wParam, LPARAM lParam )
{
int nCount = static_cast<int>(SendMessage( m_hWnd, PWM_GETSELCOUNT, 0, 0 ));
int nItem = (int)LOWORD(wParam);
BOOL bPhysical = (BOOL)HIWORD(wParam);
PSIZE pExtent = (PSIZE)lParam;
RECT rcImage = GetImageRect();
if (nCount <= 0 || nItem < 0 || nItem >= nCount || !pExtent)
return(0);
RECT rcSel = m_rcCurrSel;
NormalizeRect(rcSel);
if (IsRectEmpty(&rcSel))
rcSel = rcImage;
if (bPhysical)
{
pExtent->cx = RECT_WIDTH(rcSel);
pExtent->cy = RECT_HEIGHT(rcSel);
return(1);
}
else if (RECT_WIDTH(rcImage) && RECT_HEIGHT(rcImage)) // Make sure we get no divide by zero errors
{
pExtent->cx = WiaUiUtil::MulDivNoRound(m_Resolution.cx,RECT_WIDTH(rcSel),RECT_WIDTH(rcImage));
pExtent->cy = WiaUiUtil::MulDivNoRound(m_Resolution.cy,RECT_HEIGHT(rcSel),RECT_HEIGHT(rcImage));
return(1);
}
else return(0);
}
// wParam = (BOOL)MAKEWPARAM((WORD)nItem,(BOOL)bPhysical), lParam = (PPOINT)pOrigin
LRESULT CWiaPreviewWindow::OnSetSelOrigin( WPARAM wParam, LPARAM lParam )
{
int nCount = static_cast<int>(SendMessage( m_hWnd, PWM_GETSELCOUNT, 0, 0 ));
int nItem = (int)LOWORD(wParam);
BOOL bPhysical = (BOOL)HIWORD(wParam);
PPOINT pOrigin = (PPOINT)lParam;
RECT rcImage = GetImageRect();
if (nCount <= 0 || nItem < 0 || nItem >= nCount)
{
return(0);
}
else if (!pOrigin)
{
m_rcCurrSel = rcImage;
Repaint( NULL, FALSE );
return(1);
}
else if (bPhysical)
{
m_rcCurrSel.left = rcImage.left + pOrigin->x;
m_rcCurrSel.top = rcImage.top + pOrigin->y;
Repaint( NULL, FALSE );
return(1);
}
else if (m_Resolution.cx && m_Resolution.cy) // Make sure we get no divide by zero errors
{
m_rcCurrSel.left = rcImage.left + MulDiv(pOrigin->x,RECT_WIDTH(rcImage),m_Resolution.cx);
m_rcCurrSel.top = rcImage.top + MulDiv(pOrigin->y,RECT_HEIGHT(rcImage),m_Resolution.cy);
Repaint( NULL, FALSE );
return(1);
}
else return(0);
}
// wParam = (BOOL)MAKEWPARAM((WORD)nItem,(BOOL)bPhysical), lParam = (PSIZE)pExtent
LRESULT CWiaPreviewWindow::OnSetSelExtent( WPARAM wParam, LPARAM lParam )
{
int nCount = static_cast<int>(SendMessage( m_hWnd, PWM_GETSELCOUNT, 0, 0 ));
int nItem = static_cast<int>(LOWORD(wParam));
BOOL bPhysical = (BOOL)HIWORD(wParam);
PSIZE pExtent = (PSIZE)lParam;
RECT rcImage = GetImageRect();
if (nCount <= 0 || nItem < 0 || nItem >= nCount)
{
return(0);
}
else if (!pExtent)
{
m_rcCurrSel = rcImage;
Repaint( NULL, FALSE );
return(1);
}
else if (bPhysical)
{
m_rcCurrSel.right = m_rcCurrSel.left + pExtent->cx;
m_rcCurrSel.bottom = m_rcCurrSel.top + pExtent->cy;
Repaint(NULL,FALSE);
return(1);
}
else if (m_Resolution.cx && m_Resolution.cy) // Make sure we get no divide by zero errors
{
m_rcCurrSel.right = m_rcCurrSel.left + MulDiv(pExtent->cx,RECT_WIDTH(rcImage),m_Resolution.cx);
m_rcCurrSel.bottom = m_rcCurrSel.top + MulDiv(pExtent->cy,RECT_HEIGHT(rcImage),m_Resolution.cy);
Repaint( NULL, FALSE );
return(1);
}
else return(0);
}
LRESULT CWiaPreviewWindow::OnGetSelCount( WPARAM wParam, LPARAM lParam )
{
return(GetSelectionRectCount()); // For now...
}
BOOL CWiaPreviewWindow::IsDefaultSelectionRect( const RECT &rc )
{
if (!m_bAllowNullSelection)
return(FALSE);
RECT rcSel = rc;
NormalizeRect(rcSel);
RECT rcDefault = GetDefaultSelection();
return(rcSel.left == rcDefault.left &&
rcSel.top == rcDefault.top &&
rcSel.right == rcDefault.right &&
rcSel.bottom == rcDefault.bottom);
}
RECT CWiaPreviewWindow::GetDefaultSelection(void)
{
if (m_bAllowNullSelection)
{
RECT r = {-100,-100,-100,-100};
return(r);
}
else return(GetImageRect());
}
LRESULT CWiaPreviewWindow::OnGetAllowNullSelection( WPARAM, LPARAM )
{
return(m_bAllowNullSelection != FALSE);
}
// wParam = (BOOL)bAllowNullSelection, lParam = 0
LRESULT CWiaPreviewWindow::OnSetAllowNullSelection( WPARAM wParam, LPARAM )
{
BOOL bOldAllowNullSelection = m_bAllowNullSelection;
if (wParam)
m_bAllowNullSelection = TRUE;
else m_bAllowNullSelection = FALSE;
return(bOldAllowNullSelection);
}
LRESULT CWiaPreviewWindow::OnGetDisableSelection( WPARAM, LPARAM )
{
return(m_SelectionDisabled != FALSE);
}
// wParam = (BOOL)bDisableSelection, lParam = 0
LRESULT CWiaPreviewWindow::OnSetDisableSelection( WPARAM wParam, LPARAM )
{
BOOL bReturn = (m_SelectionDisabled != FALSE);
m_SelectionDisabled = (wParam != 0);
Repaint(NULL,false);
return(bReturn);
}
int CWiaPreviewWindow::GetSelectionRectCount(void)
{
return(1);
}
// wParam = 0, lParam = 0
LRESULT CWiaPreviewWindow::OnGetBkColor( WPARAM, LPARAM )
{
LOGBRUSH lb = { 0};
GetObject(m_hBackgroundBrush,sizeof(LOGBRUSH),&lb);
return(lb.lbColor);
}
// wParam = (BOOL)bRepaint, lParam = (COLORREF)color
LRESULT CWiaPreviewWindow::OnSetBkColor( WPARAM wParam, LPARAM lParam )
{
HBRUSH hBrush = CreateSolidBrush( static_cast<int>(lParam) );
if (hBrush)
{
if (m_hBackgroundBrush)
{
DeleteObject(m_hBackgroundBrush);
m_hBackgroundBrush = NULL;
}
m_hBackgroundBrush = hBrush;
if (wParam)
{
DrawBitmaps();
Repaint(NULL,false);
}
return(1);
}
return(0);
}
LRESULT CWiaPreviewWindow::OnSetPreviewMode( WPARAM, LPARAM lParam )
{
m_bPreviewMode = (lParam != FALSE);
DrawBitmaps();
Repaint(NULL,false);
return(0);
}
LRESULT CWiaPreviewWindow::OnRefreshBitmap( WPARAM, LPARAM )
{
DrawBitmaps();
Repaint(NULL,false);
return(0);
}
LRESULT CWiaPreviewWindow::OnGetPreviewMode( WPARAM, LPARAM )
{
return(m_bPreviewMode != false);
}
void CWiaPreviewWindow::SetCursor( HCURSOR hCursor )
{
m_hCurrentCursor = hCursor;
::SetCursor(m_hCurrentCursor);
}
LRESULT CWiaPreviewWindow::OnSetCursor( WPARAM wParam, LPARAM lParam )
{
if (reinterpret_cast<HWND>(wParam) == m_hWnd && m_hCurrentCursor)
{
::SetCursor(m_hCurrentCursor);
return(TRUE);
}
else return(DefWindowProc( m_hWnd, WM_SETCURSOR, wParam, lParam ));
}
// wParam = MAKEWPARAM(bRepaint,0), lParam = MAKELPARAM(nBorderStyle,nBorderThickness)
LRESULT CWiaPreviewWindow::OnSetBorderStyle( WPARAM wParam, LPARAM lParam )
{
// Recreate the handle border pens. Don't apply the line style, just the thickness.
for (int i=0;i<ARRAYSIZE(m_aHandlePens);i++)
{
LOGPEN LogPen;
ZeroMemory(&LogPen,sizeof(LOGPEN));
if (GetObject( m_aHandlePens[i], sizeof(LOGPEN), &LogPen ))
{
LogPen.lopnWidth.x = HIWORD(lParam);
if (m_aHandlePens[i])
DeleteObject(m_aHandlePens[i]);
m_aHandlePens[i] = CreatePenIndirect(&LogPen);
}
}
// Recreate the selection border pens. Apply the line style, just the thickness.
for (i=0;i<ARRAYSIZE(m_aBorderPens);i++)
{
LOGPEN LogPen;
ZeroMemory(&LogPen,sizeof(LOGPEN));
if (GetObject( m_aBorderPens[i], sizeof(LOGPEN), &LogPen ))
{
LogPen.lopnWidth.x = (UINT)HIWORD(lParam);
LogPen.lopnStyle = LOWORD(lParam);
if (m_aBorderPens[i])
DeleteObject(m_aBorderPens[i]);
m_aBorderPens[i] = CreatePenIndirect(&LogPen);
}
}
if (LOWORD(wParam))
{
Repaint(NULL,FALSE);
}
return(0);
}
// wParam = MAKEWPARAM(bRepaint,nState), lParam = (COLORREF)crColor
LRESULT CWiaPreviewWindow::OnSetBorderColor( WPARAM wParam, LPARAM lParam )
{
int nState = static_cast<int>(HIWORD(wParam));
if (nState >= 0 && nState < 3)
{
LOGPEN LogPen;
ZeroMemory(&LogPen,sizeof(LOGPEN));
if (GetObject( m_aHandlePens[nState], sizeof(LOGPEN), &LogPen ))
{
LogPen.lopnColor = static_cast<COLORREF>(lParam);
if (m_aHandlePens[nState])
DeleteObject(m_aHandlePens[nState]);
m_aHandlePens[nState] = CreatePenIndirect(&LogPen);
}
ZeroMemory(&LogPen,sizeof(LOGPEN));
if (GetObject( m_aBorderPens[nState], sizeof(LOGPEN), &LogPen ))
{
LogPen.lopnColor = static_cast<COLORREF>(lParam);
if (m_aBorderPens[nState])
DeleteObject(m_aBorderPens[nState]);
m_aBorderPens[nState] = CreatePenIndirect(&LogPen);
}
}
if (LOWORD(wParam))
{
Repaint(NULL,FALSE);
}
return(0);
}
// wParam = MAKEWPARAM(bRepaint,nState), lParam = (COLORREF)crColor
LRESULT CWiaPreviewWindow::OnSetHandleColor( WPARAM wParam, LPARAM lParam )
{
int nState = static_cast<int>(HIWORD(wParam));
if (nState >= 0 && nState < 3)
{
if (m_aHandleBrushes[nState])
{
DeleteObject(m_aHandleBrushes[nState]);
m_aHandleBrushes[nState] = NULL;
}
m_aHandleBrushes[nState] = CreateSolidBrush( static_cast<COLORREF>(lParam) );
}
if (LOWORD(wParam))
{
Repaint(NULL,FALSE);
}
return(0);
}
void CWiaPreviewWindow::ResizeProgressBar()
{
HWND hWndProgress = GetDlgItem( m_hWnd, IDC_PROGRESSCONTROL );
if (hWndProgress)
{
//
// Resize the progress control to fill the client
//
RECT rcImage = GetImageRect();
CDialogUnits DialogUnits( m_hWnd );
SIZE sizeProgress = { WiaUiUtil::RectWidth(rcImage) - DialogUnits.X(28), DialogUnits.Y(14) };
POINT ptProgress = { rcImage.left + (WiaUiUtil::RectWidth(rcImage) - sizeProgress.cx) / 2, rcImage.top + (WiaUiUtil::RectHeight(rcImage) - sizeProgress.cy) / 2 };
MoveWindow( hWndProgress, ptProgress.x, ptProgress.y, sizeProgress.cx, sizeProgress.cy, TRUE );
}
}
//
// wParam = bShow
//
LRESULT CWiaPreviewWindow::OnSetProgress( WPARAM wParam, LPARAM lParam )
{
//
// Assume failure
//
LRESULT lResult = FALSE;
//
// If wParam is true, create the control
//
if (wParam)
{
//
// See if the control is already created.
//
HWND hWndProgress = GetDlgItem( m_hWnd, IDC_PROGRESSCONTROL );
if (!hWndProgress)
{
//
// If it isn't, create it.
//
hWndProgress = CreateWindow( PROGRESS_CLASS, TEXT(""), WS_CHILD|WS_VISIBLE|PBS_MARQUEE, 0, 0, 0, 0, m_hWnd, reinterpret_cast<HMENU>(IDC_PROGRESSCONTROL), NULL, NULL );
if (hWndProgress)
{
//
// Put it in marquee mode
//
SendMessage( hWndProgress, PBM_SETMARQUEE, TRUE, 100 );
//
// Resize it
//
ResizeProgressBar();
}
}
//
// Success = we have a progress bar
//
lResult = (hWndProgress != NULL);
}
//
// Otherwise, destroy the control if it exists
//
else
{
HWND hWndProgress = GetDlgItem( m_hWnd, IDC_PROGRESSCONTROL );
if (hWndProgress)
{
//
// Nuke it
//
DestroyWindow(hWndProgress);
}
lResult = true;
}
//
// Force a repaint
//
InvalidateRect( m_hWnd, NULL, FALSE );
UpdateWindow(m_hWnd);
return lResult;
}
LRESULT CWiaPreviewWindow::OnGetProgress( WPARAM, LPARAM )
{
return (NULL != GetDlgItem( m_hWnd, IDC_PROGRESSCONTROL ));
}
LRESULT CWiaPreviewWindow::OnCtlColorStatic( WPARAM wParam, LPARAM )
{
SetBkColor( reinterpret_cast<HDC>( wParam ), GetSysColor( COLOR_WINDOW ) );
return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_WINDOW));
}
LRESULT CWiaPreviewWindow::OnSetUserChangedSelection( WPARAM wParam, LPARAM )
{
LRESULT lRes = m_bUserChangedSelection;
m_bUserChangedSelection = (wParam != 0);
return lRes;
}
LRESULT CWiaPreviewWindow::OnGetUserChangedSelection( WPARAM, LPARAM )
{
return static_cast<LRESULT>(m_bUserChangedSelection);
}
LRESULT CALLBACK CWiaPreviewWindow::WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
SC_BEGIN_MESSAGE_HANDLERS(CWiaPreviewWindow)
{
SC_HANDLE_MESSAGE( WM_CREATE, OnCreate );
SC_HANDLE_MESSAGE( WM_ERASEBKGND, OnEraseBkgnd );
SC_HANDLE_MESSAGE( WM_PAINT, OnPaint );
SC_HANDLE_MESSAGE( WM_MOUSEMOVE, OnMouseMove );
SC_HANDLE_MESSAGE( WM_LBUTTONDOWN, OnLButtonDown );
SC_HANDLE_MESSAGE( WM_LBUTTONUP, OnLButtonUp );
SC_HANDLE_MESSAGE( WM_LBUTTONDBLCLK , OnLButtonDblClk );
SC_HANDLE_MESSAGE( WM_SIZE, OnSize );
SC_HANDLE_MESSAGE( WM_GETDLGCODE, OnGetDlgCode );
SC_HANDLE_MESSAGE( WM_KEYDOWN, OnKeyDown );
SC_HANDLE_MESSAGE( WM_SETFOCUS, OnSetFocus );
SC_HANDLE_MESSAGE( WM_KILLFOCUS, OnKillFocus );
SC_HANDLE_MESSAGE( WM_ENABLE, OnEnable );
SC_HANDLE_MESSAGE( WM_SETTEXT, OnSetText );
SC_HANDLE_MESSAGE( WM_SETCURSOR, OnSetCursor );
SC_HANDLE_MESSAGE( WM_CTLCOLORSTATIC, OnCtlColorStatic );
SC_HANDLE_MESSAGE( PWM_CLEARSELECTION, OnClearSelection );
SC_HANDLE_MESSAGE( PWM_SETRESOLUTION, OnSetResolution );
SC_HANDLE_MESSAGE( PWM_GETRESOLUTION, OnGetResolution );
SC_HANDLE_MESSAGE( PWM_SETBITMAP, OnSetBitmap );
SC_HANDLE_MESSAGE( PWM_GETBITMAP, OnGetBitmap );
SC_HANDLE_MESSAGE( PWM_GETBORDERSIZE, OnGetBorderSize );
SC_HANDLE_MESSAGE( PWM_GETHANDLESIZE, OnGetHandleSize );
SC_HANDLE_MESSAGE( PWM_GETBGALPHA, OnGetBgAlpha );
SC_HANDLE_MESSAGE( PWM_GETHANDLETYPE, OnGetHandleType );
SC_HANDLE_MESSAGE( PWM_SETBORDERSIZE, OnSetBorderSize );
SC_HANDLE_MESSAGE( PWM_SETHANDLESIZE, OnSetHandleSize );
SC_HANDLE_MESSAGE( PWM_SETBGALPHA, OnSetBgAlpha );
SC_HANDLE_MESSAGE( PWM_SETHANDLETYPE, OnSetHandleType );
SC_HANDLE_MESSAGE( PWM_GETSELCOUNT, OnGetSelCount );
SC_HANDLE_MESSAGE( PWM_GETSELORIGIN, OnGetSelOrigin );
SC_HANDLE_MESSAGE( PWM_GETSELEXTENT, OnGetSelExtent );
SC_HANDLE_MESSAGE( PWM_SETSELORIGIN, OnSetSelOrigin );
SC_HANDLE_MESSAGE( PWM_SETSELEXTENT, OnSetSelExtent );
SC_HANDLE_MESSAGE( WM_ENTERSIZEMOVE, OnEnterSizeMove );
SC_HANDLE_MESSAGE( WM_EXITSIZEMOVE, OnExitSizeMove );
SC_HANDLE_MESSAGE( PWM_GETALLOWNULLSELECTION, OnGetAllowNullSelection );
SC_HANDLE_MESSAGE( PWM_SETALLOWNULLSELECTION, OnSetAllowNullSelection );
SC_HANDLE_MESSAGE( PWM_SELECTIONDISABLED, OnGetDisableSelection );
SC_HANDLE_MESSAGE( PWM_DISABLESELECTION, OnSetDisableSelection );
SC_HANDLE_MESSAGE( PWM_DETECTREGIONS, OnDetectRegions);
SC_HANDLE_MESSAGE( PWM_GETBKCOLOR, OnGetBkColor );
SC_HANDLE_MESSAGE( PWM_SETBKCOLOR, OnSetBkColor );
SC_HANDLE_MESSAGE( PWM_SETPREVIEWMODE, OnSetPreviewMode );
SC_HANDLE_MESSAGE( PWM_GETPREVIEWMODE, OnGetPreviewMode );
SC_HANDLE_MESSAGE( PWM_GETIMAGESIZE, OnGetImageSize );
SC_HANDLE_MESSAGE( PWM_SETBORDERSTYLE, OnSetBorderStyle );
SC_HANDLE_MESSAGE( PWM_SETBORDERCOLOR, OnSetBorderColor );
SC_HANDLE_MESSAGE( PWM_SETHANDLECOLOR, OnSetHandleColor );
SC_HANDLE_MESSAGE( PWM_REFRESHBITMAP, OnRefreshBitmap );
SC_HANDLE_MESSAGE( PWM_SETPROGRESS, OnSetProgress );
SC_HANDLE_MESSAGE( PWM_GETPROGRESS, OnGetProgress );
SC_HANDLE_MESSAGE( PWM_SETUSERCHANGEDSELECTION, OnSetUserChangedSelection );
SC_HANDLE_MESSAGE( PWM_GETUSERCHANGEDSELECTION, OnGetUserChangedSelection );
}
SC_END_MESSAGE_HANDLERS();
}
// Detects regions using the CRegionDetector class
// The region detection class is designed to detect
// multiple regions, but OnDetectRegions merges all of the regions
// down to one region which it saves as m_rcCurrSel
LRESULT CWiaPreviewWindow::OnDetectRegions( WPARAM, LPARAM )
{
WIA_PUSH_FUNCTION((TEXT("CWiaPreviewWindow::OnDetectRegions")));
//
// We are going to assume we can't detect a region
//
m_bSuccessfulRegionDetection = false;
//
// This could take a while
//
CWaitCursor wc;
//
// m_hPreviewBitmap holds the bitmap we wish to detect regions on.
//
if (m_hBufferBitmap && m_hPreviewBitmap)
{
//
// Get the bitmap info associated with m_hPreviewBitmap
//
BITMAP bitmap = {0};
if (GetObject(m_hPreviewBitmap,sizeof(BITMAP),&bitmap))
{
//
// Unless the preview image is of a reasonable size
// We are not only wasting the users time, but we are risking
// crashing his system with too large a file
//
if ((bitmap.bmWidth>MIN_REGION_DETECTION_X && bitmap.bmWidth<=MAX_REGION_DETECTION_X) &&
(bitmap.bmHeight>MIN_REGION_DETECTION_Y && bitmap.bmHeight<=MAX_REGION_DETECTION_Y))
{
//
// Create a region detector
//
CRegionDetector *pRegionDetector = new CRegionDetector(bitmap);
if (pRegionDetector)
{
pRegionDetector->FindSingleRegion();
//
// findRegions stores coordinates in a system that
// is a mirror image of the coordinate system used
// in CWiaPreviewWindow
//
pRegionDetector->m_pRegions->FlipVertically();
if (pRegionDetector->m_pRegions->m_validRects>0)
{
pRegionDetector->ConvertToOrigionalCoordinates();
m_rectSavedDetected=pRegionDetector->m_pRegions->unionAll();
//
// we do not call grow regions because the FindSingleRegion algorithm uses edge enhancement
// which makes GrowRegion unncessary
//
//
// there may not always be a 1-1 correlation between preview pixels and image pixels
// so to be on the safe side, grow the preview rect out by a couple of pixels
//
m_rectSavedDetected=GrowRegion(m_rectSavedDetected,REGION_DETECTION_BORDER);
m_rcCurrSel=m_rectSavedDetected;
//
// we also have to worry about the extra rounding error factor from converting to
// screen coordinates
//
m_rcSavedImageRect = GetImageRect();
//
// CWiaPreviewWindow stores the selection rectangle in terms of screen coordinates instead of bitmap coordinates
//
m_rcCurrSel=ConvertToScreenCoords(m_rcCurrSel);
//
// redisplay the window with the new selection rectangle
//
InvalidateRect( m_hWnd, NULL, FALSE );
UpdateWindow( m_hWnd );
SendSelChangeNotification(false);
//
// We were successful at detecting a region
//
m_bSuccessfulRegionDetection = true;
}
else
{
WIA_TRACE((TEXT("pRegionDetector->m_pRegions->m_validRects was <= 0")));
}
//
// free CRegionDetector
//
delete pRegionDetector;
}
else
{
WIA_TRACE((TEXT("new pRegionDetector returned NULL")));
}
}
else
{
WIA_TRACE((TEXT("Bitmap is too large for region detection to work efficiently (bitmap.bmWidth: %d, bitmap.bmHeight: %d)"), bitmap.bmWidth, bitmap.bmHeight));
}
}
else
{
WIA_TRACE((TEXT("Unable to get the BITMAP for the hBitmap")));
}
}
else
{
WIA_TRACE((TEXT("No bitmap")));
}
return (m_bSuccessfulRegionDetection ? TRUE : FALSE);
}
RECT CWiaPreviewWindow::GrowRegion(RECT r, int border)
{
r.left-=border;
r.top-=border;
r.right+=border;
r.bottom+=border;
if (r.left<0) r.left=0;
if (r.right>=m_BitmapSize.cx) r.right=m_BitmapSize.cx-1;
if (r.top<0) r.top=0;
if (r.top>=m_BitmapSize.cy) r.top=m_BitmapSize.cy-1;
return(r);
}
int CWiaPreviewWindow::XConvertToBitmapCoords(int x)
{
return((x-m_rcSavedImageRect.left)*m_BitmapSize.cx)/WiaUiUtil::RectWidth(m_rcSavedImageRect);
}
int CWiaPreviewWindow::XConvertToScreenCoords(int x)
{
return(x*WiaUiUtil::RectWidth(m_rcSavedImageRect))/m_BitmapSize.cx+m_rcSavedImageRect.left;
}
int CWiaPreviewWindow::YConvertToBitmapCoords(int y)
{
return((y-m_rcSavedImageRect.top)*m_BitmapSize.cy)/WiaUiUtil::RectHeight(m_rcSavedImageRect);
}
int CWiaPreviewWindow::YConvertToScreenCoords(int y)
{
return(y*WiaUiUtil::RectHeight(m_rcSavedImageRect))/m_BitmapSize.cy+m_rcSavedImageRect.top;
}
// Convert between bitmap coordinates and screen coordinates
POINT CWiaPreviewWindow::ConvertToBitmapCoords(POINT p)
{
p.x=XConvertToBitmapCoords(p.x);
p.y=YConvertToBitmapCoords(p.y);
return(p);
}
POINT CWiaPreviewWindow::ConvertToScreenCoords(POINT p)
{
p.x=XConvertToScreenCoords(p.x);
p.y=YConvertToScreenCoords(p.y);
return(p);
}
RECT CWiaPreviewWindow::ConvertToBitmapCoords(RECT r)
{
r.left=XConvertToBitmapCoords(r.left);
r.top=YConvertToBitmapCoords(r.top);
r.right=XConvertToBitmapCoords(r.right);
r.bottom=YConvertToBitmapCoords(r.bottom);
return(r);
}
RECT CWiaPreviewWindow::ConvertToScreenCoords(RECT r)
{
RECT newRect;
newRect.left=XConvertToScreenCoords(r.left);
newRect.top=YConvertToScreenCoords(r.top);
newRect.right=XConvertToScreenCoords(r.right);
newRect.bottom=YConvertToScreenCoords(r.bottom);
return(newRect);
}
LRESULT CWiaPreviewWindow::OnLButtonDblClk( WPARAM wParam, LPARAM lParam )
{
if (!m_hPreviewBitmap || m_bPreviewMode || m_SelectionDisabled)
{
return(0);
}
if (GetFocus() != m_hWnd)
{
SetFocus(m_hWnd);
}
POINT point;
point.x = LOWORD(lParam);
point.y = HIWORD(lParam);
int Hit = GetHitArea(point);
if (wParam & MK_CONTROL)
{
Hit = HIT_NONE;
}
if (Hit != HIT_NONE && m_bSuccessfulRegionDetection)
{
m_rcCurrSel = m_rectSavedDetected; // reset to saved rectangle
m_rcSavedImageRect = GetImageRect();
m_rcCurrSel=ConvertToScreenCoords(m_rcCurrSel); // CWiaPreviewWindow stores the selection rectangle in terms of screen coordinates instead of bitmap coordinates
SendSelChangeNotification(false);
Repaint(NULL,false);
UpdateWindow(m_hWnd);
return(1);
}
return(0);
}