|
|
/*******************************************************************************
* * (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); }
|