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.
741 lines
25 KiB
741 lines
25 KiB
/******************************************************************************/
|
|
/* THUMNAIL.CPP: IMPLEMENTATION OF THE CThumbNailView and CFloatThumNailView */
|
|
/* and CFullScreenThumbNailView Classes */
|
|
/* */
|
|
/******************************************************************************/
|
|
/* */
|
|
/* Methods in this file */
|
|
/* */
|
|
/* CThumbNailView Class Object */
|
|
/* CThumbNailView::CThumbNailView */
|
|
/* CThumbNailView::CThumbNailView */
|
|
/* CThumbNailView::~CThumbNailView */
|
|
/* CThumbNailView::Create */
|
|
/* CThumbNailView::OnSize */
|
|
/* CThumbNailView::OnPaint */
|
|
/* CThumbNailView::DrawImage */
|
|
/* CThumbNailView::DrawTracker */
|
|
/* CThumbNailView::RefreshImage */
|
|
/* CThumbNailView::GetImgWnd */
|
|
/* CThumbNailView::OnKeyDown */
|
|
/* CThumbNailView::OnLButtonDown */
|
|
/* CThumbNailView::OnRButtonDown */
|
|
/* CThumbNailView::OnThumbnailThumbnail */
|
|
/* CThumbNailView::OnUpdateThumbnailThumbnail */
|
|
/* */
|
|
/* CFloatThumbNailView Class Object */
|
|
/* CFloatThumbNailView::CFloatThumbNailView */
|
|
/* CFloatThumbNailView::~CFloatThumbNailView */
|
|
/* CFloatThumbNailView::Create */
|
|
/* CFloatThumbNailView::OnClose */
|
|
/* CFloatThumbNailView::OnSize */
|
|
/* */
|
|
/* CFullScreenThumbNailView Class Object */
|
|
/* CFullScreenThumbNailView::CFullScreenThumbNailView */
|
|
/* CFullScreenThumbNailView::CFullScreenThumbNailView */
|
|
/* CFullScreenThumbNailView::~CFullScreenThumbNailView */
|
|
/* CFullScreenThumbNailView::Create */
|
|
/* CFullScreenThumbNailView::OnLButtonDown */
|
|
/* CFullScreenThumbNailView::OnKeyDown */
|
|
/* */
|
|
/******************************************************************************/
|
|
/* */
|
|
/* These 3 objects provide a layer around the thumbnail view window, which */
|
|
/* allow it to easily be a child, floating or a full screen. The ThumbNail */
|
|
/* View Window is just a CWnd Window which on paints does a BitBlt from the */
|
|
/* CImgWnd it was passsed on construction. */
|
|
/* */
|
|
/* The structure of the objects is as follows: */
|
|
/* */
|
|
/* CFullScreenThumbNailView is a Frame Window (with no border and sized to */
|
|
/* full screen). It destroys itself on any keystroke or button click */
|
|
/* while visible, it dissables the main application window. It contains */
|
|
/* a CThumbNailView object as a child window. */
|
|
/* */
|
|
/* CFloatThumbNailView is a MiniFrame Window */
|
|
/* CThumbNailView is a Child Window (which is sizable) A child of the */
|
|
/* the CFloatThumbNailView window. This can be created */
|
|
/* independent if a floating window is not desired (i.e. */
|
|
/* for the docked view). It is this window which has the */
|
|
/* image drawn into it. */
|
|
/* */
|
|
/* */
|
|
/******************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
#include "global.h"
|
|
#include "pbrush.h"
|
|
#include "pbrusdoc.h"
|
|
#include "pbrusfrm.h"
|
|
#include "pbrusvw.h"
|
|
#include "minifwnd.h"
|
|
#include "docking.h"
|
|
#include "bmobject.h"
|
|
#include "imgsuprt.h"
|
|
#include "imgwnd.h"
|
|
#include "imgcolor.h"
|
|
#include "imgbrush.h"
|
|
#include "imgwell.h"
|
|
#include "imgtools.h"
|
|
#include "imgwnd.h"
|
|
#include "thumnail.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static CHAR BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
IMPLEMENT_DYNAMIC(CThumbNailView, CWnd)
|
|
IMPLEMENT_DYNAMIC(CFloatThumbNailView, CMiniFrmWnd)
|
|
IMPLEMENT_DYNAMIC(CFullScreenThumbNailView, CFrameWnd)
|
|
|
|
|
|
#include "memtrace.h"
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
BEGIN_MESSAGE_MAP(CThumbNailView, CWnd)
|
|
//{{AFX_MSG_MAP(CThumbNailView)
|
|
ON_WM_PAINT()
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_LBUTTONDOWN()
|
|
ON_WM_RBUTTONDOWN()
|
|
ON_COMMAND(ID_THUMBNAIL_THUMBNAIL, OnThumbnailThumbnail)
|
|
ON_UPDATE_COMMAND_UI(ID_THUMBNAIL_THUMBNAIL, OnUpdateThumbnailThumbnail)
|
|
ON_WM_CLOSE()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/******************************************************************************/
|
|
|
|
CThumbNailView::CThumbNailView(CImgWnd *pcImgWnd)
|
|
{
|
|
m_pcImgWnd = pcImgWnd;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CThumbNailView::CThumbNailView()
|
|
{
|
|
m_pcImgWnd = NULL;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CThumbNailView::~CThumbNailView(void)
|
|
{
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
BOOL CThumbNailView::Create(DWORD dwStyle, CRect cRectWindow, CWnd *pcParentWnd)
|
|
{
|
|
return( CWnd::Create(NULL, TEXT(""), dwStyle, cRectWindow, pcParentWnd, NULL) );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CThumbNailView::OnClose()
|
|
{
|
|
ShowWindow(SW_HIDE);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnPaint()
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
|
|
// TODO: Add your message handler code here
|
|
|
|
#ifdef USE_MIRRORING
|
|
//
|
|
// Disable RTL mirroring on full screen window
|
|
//
|
|
if (PBGetLayout(dc.GetSafeHdc()) & LAYOUT_RTL)
|
|
{
|
|
PBSetLayout(dc.GetSafeHdc(), 0);
|
|
}
|
|
#endif
|
|
|
|
// Do not call CWnd::OnPaint() for painting messages
|
|
DrawImage(&dc);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::DrawImage(CDC* pDC)
|
|
{
|
|
/*
|
|
** when there is nothing to do, then don't do it
|
|
*/
|
|
if (! theApp.m_bShowThumbnail || m_pcImgWnd == NULL
|
|
|| m_pcImgWnd->m_pImg == NULL )
|
|
return;
|
|
|
|
CRect crectClient;
|
|
int iMinWidth;
|
|
int iMinHeight;
|
|
int iLeft;
|
|
int iTop;
|
|
|
|
CSize cSizeScrollPos = m_pcImgWnd->GetScrollPos();
|
|
|
|
cSizeScrollPos.cx = abs( cSizeScrollPos.cx ) - CTracker::HANDLE_SIZE;
|
|
cSizeScrollPos.cy = abs( cSizeScrollPos.cy ) - CTracker::HANDLE_SIZE;
|
|
|
|
GetClientRect(crectClient);
|
|
|
|
// find the smaller of the two the real image or the thumbnail window.
|
|
|
|
iMinWidth = min( crectClient.Width() , m_pcImgWnd->m_pImg->cxWidth );
|
|
iMinHeight = min( crectClient.Height(), m_pcImgWnd->m_pImg->cyHeight );
|
|
|
|
if (crectClient.Width() >= m_pcImgWnd->m_pImg->cxWidth)
|
|
{
|
|
iLeft = 0; // can fit the whole image width into the thumbnail
|
|
}
|
|
else // image width greater than thumbnail width
|
|
{
|
|
// does thumbnail extend past end if started at scroll pos?
|
|
if (cSizeScrollPos.cx + crectClient.Width() > m_pcImgWnd->m_pImg->cxWidth)
|
|
{
|
|
iLeft = cSizeScrollPos.cx - ( (cSizeScrollPos.cx
|
|
+ crectClient.Width()
|
|
- m_pcImgWnd->m_pImg->cxWidth));
|
|
}
|
|
else
|
|
{
|
|
iLeft = cSizeScrollPos.cx;
|
|
}
|
|
}
|
|
|
|
if (crectClient.Height() >= m_pcImgWnd->m_pImg->cyHeight)
|
|
{
|
|
iTop = 0; // can fit the whole image height into the thumbnail
|
|
}
|
|
else // image height greater than thumbnail height
|
|
{
|
|
// does thumbnail extend past bottom if started at scroll pos?
|
|
if (cSizeScrollPos.cy + crectClient.Height() > m_pcImgWnd->m_pImg->cyHeight)
|
|
{
|
|
iTop = cSizeScrollPos.cy - ( (cSizeScrollPos.cy
|
|
+ crectClient.Height()
|
|
- m_pcImgWnd->m_pImg->cyHeight));
|
|
}
|
|
else
|
|
{
|
|
iTop = cSizeScrollPos.cy;
|
|
}
|
|
}
|
|
|
|
CDC cDC;
|
|
cDC.Attach(m_pcImgWnd->m_pImg->hDC);
|
|
|
|
CPalette* ppalOldSrc = theImgBrush.SetBrushPalette(&cDC, FALSE);
|
|
CPalette* ppalOldDst = theImgBrush.SetBrushPalette( pDC, FALSE);
|
|
|
|
pDC->BitBlt(0, 0, iMinWidth, iMinHeight,
|
|
&cDC, iLeft, iTop, SRCCOPY);
|
|
|
|
if (ppalOldDst)
|
|
{
|
|
pDC->SelectPalette(ppalOldDst, FALSE);
|
|
}
|
|
if (ppalOldSrc)
|
|
{
|
|
cDC.SelectPalette(ppalOldSrc, FALSE);
|
|
}
|
|
|
|
cDC.Detach();
|
|
|
|
DrawTracker(pDC);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* basically the same processing as the imgwnd::drawtracker method, without */
|
|
/* the zoom */
|
|
|
|
void CThumbNailView::DrawTracker(CDC *pDC)
|
|
{
|
|
// BOOL bDrawTrackerRgn = FALSE;
|
|
|
|
if (m_pcImgWnd->GetCurrent() != m_pcImgWnd
|
|
|| theImgBrush.m_bMoveSel
|
|
|| theImgBrush.m_bSmearSel
|
|
|| theImgBrush.m_bMakingSelection)
|
|
{
|
|
// This is not the active view, or the user is doing something
|
|
// to prevent the tracker from appearing.
|
|
return;
|
|
}
|
|
|
|
BOOL bReleaseDC = FALSE;
|
|
CRect clientRect;
|
|
|
|
if (pDC == NULL)
|
|
{
|
|
pDC = GetDC();
|
|
|
|
if (pDC == NULL)
|
|
{
|
|
theApp.SetGdiEmergency(FALSE);
|
|
return;
|
|
}
|
|
bReleaseDC = TRUE;
|
|
}
|
|
|
|
GetClientRect(&clientRect);
|
|
|
|
CRect trackerRect;
|
|
|
|
m_pcImgWnd->GetImageRect(trackerRect);
|
|
|
|
trackerRect.InflateRect(CTracker::HANDLE_SIZE, CTracker::HANDLE_SIZE);
|
|
|
|
CTracker::EDGES edges = (CTracker::EDGES)(CTracker::right | CTracker::bottom);
|
|
|
|
// if (CImgTool::GetCurrentID() == IDMB_PICKRGNTOOL)
|
|
// {
|
|
// bDrawTrackerRgn = TRUE;
|
|
// }
|
|
|
|
if (m_pcImgWnd->m_pImg == theImgBrush.m_pImg)
|
|
{
|
|
edges = CTracker::all;
|
|
CSize cSzScroll = m_pcImgWnd->GetScrollPos();
|
|
|
|
trackerRect = theImgBrush.m_rcSelection;
|
|
|
|
// trackerRect.InflateRect( CTracker::HANDLE_SIZE,
|
|
// CTracker::HANDLE_SIZE);
|
|
trackerRect.OffsetRect( cSzScroll.cx, cSzScroll.cy);
|
|
|
|
}
|
|
|
|
if (m_pcImgWnd->m_pImg == theImgBrush.m_pImg)
|
|
{
|
|
// if (bDrawTrackerRgn)
|
|
// {
|
|
// CTracker::DrawBorderRgn( pDC, trackerRect, &(theImgBrush.m_cRgnPolyFreeHandSel) );
|
|
// }
|
|
// else
|
|
// {
|
|
CTracker::DrawBorder( pDC, trackerRect );
|
|
// }
|
|
}
|
|
|
|
if (bReleaseDC)
|
|
{
|
|
ReleaseDC(pDC);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Basically Do a paint without an erase background to prevent blinking */
|
|
|
|
void CThumbNailView::RefreshImage(void)
|
|
{
|
|
if (theApp.m_bShowThumbnail)
|
|
{
|
|
TRY
|
|
{
|
|
CClientDC dc(this);
|
|
DrawImage(&dc);
|
|
}
|
|
CATCH(CResourceException,e)
|
|
{
|
|
}
|
|
END_CATCH
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CImgWnd* CThumbNailView::GetImgWnd(void)
|
|
{
|
|
return m_pcImgWnd;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::UpdateThumbNailView()
|
|
{
|
|
CPBView* pcbActiveView = (CPBView*)((CFrameWnd*)AfxGetMainWnd())->GetActiveView();
|
|
|
|
m_pcImgWnd = pcbActiveView->m_pImgWnd;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnKeyDown(UINT /*nChar*/, UINT /*nRepCnt*/, UINT /*nFlags*/)
|
|
{
|
|
const MSG* pmsg = GetCurrentMessage();
|
|
|
|
GetParent()->SendMessage( pmsg->message, pmsg->wParam, pmsg->lParam );
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnLButtonDown(UINT /*nFlags*/, CPoint /*point*/)
|
|
{
|
|
const MSG* pmsg = GetCurrentMessage();
|
|
|
|
GetParent()->SendMessage(pmsg->message, pmsg->wParam, pmsg->lParam);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnRButtonDown(UINT /*nFlags*/, CPoint point)
|
|
{
|
|
HWND hwnd = GetSafeHwnd(); // must do this before calling SendMsg to parent, since it could delete us,
|
|
const MSG* pmsg = GetCurrentMessage();
|
|
|
|
GetParent()->SendMessage(pmsg->message, pmsg->wParam, pmsg->lParam);
|
|
// the window is destroyed by the parent if FullScreenView
|
|
|
|
if (::IsWindow(hwnd) != FALSE) // window still exists => object still valid, put up pop up menu.
|
|
{
|
|
CMenu cMenuPopup;
|
|
CMenu *pcContextMenu;
|
|
BOOL bRC;
|
|
CRect cRectClient;
|
|
|
|
GetClientRect(&cRectClient);
|
|
|
|
bRC = cMenuPopup.LoadMenu( IDR_THUMBNAIL_POPUP );
|
|
|
|
ASSERT(bRC != 0);
|
|
|
|
if (bRC != 0)
|
|
{
|
|
pcContextMenu = cMenuPopup.GetSubMenu(0);
|
|
|
|
ASSERT(pcContextMenu != NULL);
|
|
|
|
if (pcContextMenu != NULL)
|
|
{
|
|
// update the check marks
|
|
ClientToScreen(&point);
|
|
ClientToScreen(&cRectClient);
|
|
pcContextMenu->CheckMenuItem(ID_THUMBNAIL_THUMBNAIL, MF_BYCOMMAND | MF_CHECKED);
|
|
pcContextMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this, &cRectClient);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnThumbnailThumbnail()
|
|
{
|
|
CPBView* pView = (CPBView*)(((CFrameWnd*)AfxGetMainWnd())->GetActiveView());
|
|
|
|
if (pView != NULL && pView->IsKindOf( RUNTIME_CLASS( CPBView ) ))
|
|
pView->HideThumbNailView();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CThumbNailView::OnUpdateThumbnailThumbnail(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->SetCheck();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
BEGIN_MESSAGE_MAP(CFloatThumbNailView, CMiniFrmWnd)
|
|
//{{AFX_MSG_MAP(CFloatThumbNailView)
|
|
ON_WM_CLOSE()
|
|
ON_WM_SIZE()
|
|
ON_WM_GETMINMAXINFO()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/******************************************************************************/
|
|
|
|
CFloatThumbNailView::CFloatThumbNailView(CImgWnd *pcMainImgWnd)
|
|
{
|
|
m_pcThumbNailView = new CThumbNailView(pcMainImgWnd);
|
|
|
|
if (m_pcThumbNailView == NULL)
|
|
{
|
|
theApp.SetMemoryEmergency();
|
|
TRACE( TEXT("New Thumbnail View faild\n") );
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CFloatThumbNailView::CFloatThumbNailView()
|
|
{
|
|
m_pcThumbNailView = NULL;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CFloatThumbNailView::~CFloatThumbNailView(void)
|
|
{
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
BOOL CFloatThumbNailView::Create(CWnd* pParentWnd)
|
|
{
|
|
BOOL bRC;
|
|
CRect cWindowRect;
|
|
|
|
pParentWnd->GetWindowRect( &cWindowRect );
|
|
|
|
cWindowRect.BottomRight() = cWindowRect.TopLeft();
|
|
cWindowRect.right += 120;
|
|
cWindowRect.bottom += 120;
|
|
cWindowRect.OffsetRect( 15, 15 );
|
|
|
|
if (! theApp.m_rectFloatThumbnail.IsRectEmpty())
|
|
{
|
|
cWindowRect = theApp.m_rectFloatThumbnail;
|
|
}
|
|
|
|
CString pWindowName;
|
|
|
|
pWindowName.LoadString( IDS_VIEW );
|
|
|
|
bRC = CMiniFrmWnd::Create( pWindowName, WS_THICKFRAME, cWindowRect, pParentWnd );
|
|
|
|
if (bRC)
|
|
{
|
|
ASSERT( m_pcThumbNailView );
|
|
|
|
GetClientRect( &cWindowRect );
|
|
|
|
if (!m_pcThumbNailView->Create( WS_CHILD | WS_VISIBLE, cWindowRect, this ))
|
|
{
|
|
bRC = FALSE;
|
|
theApp.SetMemoryEmergency();
|
|
TRACE( TEXT("New Thumbnail View faild\n") );
|
|
}
|
|
}
|
|
|
|
GetWindowRect( &theApp.m_rectFloatThumbnail );
|
|
|
|
return bRC;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
// OnClose
|
|
//
|
|
// A Colorsbox is usally created by the parent, and will be destroyed
|
|
// specifically by the parent upon leaving the app. When the user closes
|
|
// the Colorsbox, it is simply hidden. The parent can then reshow it without
|
|
// recreating it.
|
|
//
|
|
void CFloatThumbNailView::OnClose()
|
|
{
|
|
theApp.m_bShowThumbnail = FALSE;
|
|
|
|
ShowWindow(SW_HIDE);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CFloatThumbNailView::PostNcDestroy()
|
|
{
|
|
if (m_pcThumbNailView != NULL)
|
|
{
|
|
delete m_pcThumbNailView;
|
|
m_pcThumbNailView = NULL;
|
|
}
|
|
|
|
CWnd::PostNcDestroy();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CFloatThumbNailView::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CMiniFrmWnd::OnSize(nType, cx, cy);
|
|
|
|
if (m_pcThumbNailView != NULL
|
|
&& m_pcThumbNailView->GetSafeHwnd() != NULL)
|
|
{
|
|
m_pcThumbNailView->SetWindowPos( &wndTop, 0, 0, cx, cy, SWP_NOACTIVATE );
|
|
}
|
|
|
|
theApp.m_rectFloatThumbnail.right = theApp.m_rectFloatThumbnail.left + cx;
|
|
theApp.m_rectFloatThumbnail.bottom = theApp.m_rectFloatThumbnail.top + cy;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CFloatThumbNailView::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
|
|
{
|
|
lpMMI->ptMinTrackSize.x = 2 * GetSystemMetrics( SM_CXICON );
|
|
lpMMI->ptMinTrackSize.y = 2 * GetSystemMetrics( SM_CYICON );
|
|
|
|
CWnd::OnGetMinMaxInfo( lpMMI );
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
/******************************************************************************/
|
|
|
|
BEGIN_MESSAGE_MAP(CFullScreenThumbNailView, CFrameWnd)
|
|
//{{AFX_MSG_MAP(CFullScreenThumbNailView)
|
|
ON_WM_LBUTTONDOWN()
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_RBUTTONDOWN()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_CLOSE()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/******************************************************************************/
|
|
|
|
CFullScreenThumbNailView::CFullScreenThumbNailView(CImgWnd *pcMainImgWnd)
|
|
{
|
|
m_bSaveShowFlag = theApp.m_bShowThumbnail;
|
|
theApp.m_bShowThumbnail = TRUE;
|
|
|
|
|
|
// m_brBackground.CreateSolidBrush( ::GetSysColor( COLOR_BACKGROUND ) );
|
|
|
|
m_pcThumbNailView = new CThumbNailView(pcMainImgWnd);
|
|
|
|
if (m_pcThumbNailView == NULL)
|
|
{
|
|
theApp.SetMemoryEmergency();
|
|
TRACE( TEXT("New Thumbnail View faild\n") );
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CFullScreenThumbNailView::CFullScreenThumbNailView()
|
|
{
|
|
m_hOldIcon = 0;
|
|
m_pcThumbNailView = NULL;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
CFullScreenThumbNailView::~CFullScreenThumbNailView(void)
|
|
{
|
|
if (m_hOldIcon)
|
|
{
|
|
SetClassLongPtr (((CFrameWnd*)this)->GetSafeHwnd(), GCLP_HICON, (LONG_PTR)m_hOldIcon);
|
|
}
|
|
if (m_pcThumbNailView != NULL)
|
|
{
|
|
delete m_pcThumbNailView;
|
|
|
|
theApp.m_bShowThumbnail = m_bSaveShowFlag;
|
|
}
|
|
// if (m_brBackground.m_hObject != NULL)
|
|
// m_brBackground.DeleteObject();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
BOOL CFullScreenThumbNailView::Create(LPCTSTR szCaption)
|
|
{
|
|
ASSERT( m_pcThumbNailView );
|
|
TCHAR szFileName[MAX_PATH];
|
|
HICON hIcon;
|
|
|
|
CRect cWindowRect( 0, 0, ::GetSystemMetrics( SM_CXSCREEN ),
|
|
::GetSystemMetrics( SM_CYSCREEN ) );
|
|
//
|
|
// Use the current file name as the caption of the window so
|
|
// it shows up in alt-tab
|
|
if (szCaption && *szCaption)
|
|
{
|
|
GetFileTitle (szCaption, szFileName, MAX_PATH);
|
|
}
|
|
else
|
|
{
|
|
LoadString (GetModuleHandle (NULL), AFX_IDS_UNTITLED, szFileName, MAX_PATH);
|
|
}
|
|
|
|
BOOL bRC = CFrameWnd::Create( NULL, szFileName, WS_POPUP|WS_VISIBLE | WS_CLIPCHILDREN,
|
|
cWindowRect );
|
|
//
|
|
// This window needs a Paint icon instead of a boring icon
|
|
// So set the class's icon to the Paint icon
|
|
// We want alt-tab to work decently
|
|
hIcon = LoadIcon (GetModuleHandle (NULL), MAKEINTRESOURCE(ID_MAINFRAME));
|
|
m_hOldIcon = SetClassLongPtr (((CFrameWnd*)this)->GetSafeHwnd(), GCLP_HICON, (LONG_PTR)hIcon);
|
|
|
|
if (bRC)
|
|
{
|
|
ASSERT( m_pcThumbNailView );
|
|
|
|
AfxGetMainWnd()->EnableWindow( FALSE );
|
|
|
|
CImgWnd* pcImgWnd = m_pcThumbNailView->GetImgWnd();
|
|
|
|
if (pcImgWnd != NULL)
|
|
{
|
|
// find the smaller of the two the real image or the full screen window size.
|
|
int iMinWidth = min( cWindowRect.Width(), pcImgWnd->m_pImg->cxWidth );
|
|
int iMinHeight = min( cWindowRect.Height(), pcImgWnd->m_pImg->cyHeight );
|
|
|
|
// center the image in the full screen window.
|
|
cWindowRect.left = (cWindowRect.Width() - iMinWidth) / 2;
|
|
cWindowRect.top = (cWindowRect.Height() - iMinHeight) / 2;
|
|
cWindowRect.right = cWindowRect.left + iMinWidth;
|
|
cWindowRect.bottom = cWindowRect.top + iMinHeight;
|
|
|
|
m_pcThumbNailView->Create( WS_CHILD | WS_VISIBLE, cWindowRect, this );
|
|
}
|
|
}
|
|
|
|
return bRC;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
BOOL CFullScreenThumbNailView::OnEraseBkgnd( CDC* pDC )
|
|
{
|
|
CBrush* pbr = GetSysBrush( COLOR_BACKGROUND );
|
|
|
|
// if (m_brBackground.m_hObject == NULL)
|
|
if (! pbr)
|
|
return CFrameWnd::OnEraseBkgnd( pDC );
|
|
|
|
CRect cRectClient;
|
|
|
|
GetClientRect( &cRectClient );
|
|
pDC->FillRect( &cRectClient, pbr /* &m_brBackground */ );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
void CFullScreenThumbNailView::OnLButtonDown(UINT /*nFlags*/, CPoint /*point*/)
|
|
{
|
|
PostMessage (WM_CLOSE, 0, 0);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void CFullScreenThumbNailView::OnKeyDown(UINT /*nChar*/, UINT /*nRepCnt*/, UINT /*nFlags*/)
|
|
{
|
|
PostMessage (WM_CLOSE, 0, 0);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
void CFullScreenThumbNailView::OnClose ()
|
|
{
|
|
AfxGetMainWnd()->EnableWindow( TRUE );
|
|
::DestroyWindow( m_hWnd );
|
|
}
|
|
/******************************************************************************/
|
|
|