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

5975 lines
181 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#include "PrevWnd.h"
#include "PrevCtrl.h"
#include "resource.h"
#include <shimgdata.h>
#include "shutil.h"
#include "tasks.h"
#include <shellp.h>
#include <ccstock2.h>
#include <htmlhelp.h>
#include "prwiziid.h"
#pragma hdrstop
#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
#define COPYDATATYPE_DATAOBJECT 1
#define COPYDATATYPE_FILENAME 2
int g_x = 0, g_y = 0; // mouse coordinates
BOOL g_bMirroredOS = FALSE;
#define HTMLHELP_FILENAME TEXT("ImgPrev.chm")
static COLORREF g_crCustomColors[] = {
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255),
RGB(255,255,255)
};
static void _RotateRect(CRect &rect, CAnnotation* pAnnotation)
{
UINT uType = pAnnotation->GetType();
if (uType != MT_TYPEDTEXT && uType != MT_FILETEXT && uType != MT_STAMP && uType != MT_ATTACHANOTE)
return;
CTextAnnotation* pTextAnnotation = (CTextAnnotation*)pAnnotation;
int nOrientation = pTextAnnotation->GetOrientation();
if (nOrientation == 900 || nOrientation == 2700)
{
int nWidth = rect.Width();
int nHeight = rect.Height();
rect.right = rect.left + nHeight;
rect.bottom = rect.top + nWidth;
}
}
CPreviewWnd::CPreviewWnd() : m_ctlToolbar(NULL, this, 1), m_ctlPreview(this), m_ctlEdit(NULL, this, 2)
{
// we are often created on the stack, so we can't be sure that we're zero initialized
m_fCanCrop = FALSE;
m_fCropping = FALSE;
m_rectCropping.SetRectEmpty();
m_fBusy = FALSE;
m_hCurOld = NULL;
m_hCurrent = NULL;
m_fWarnQuietSave = TRUE;
m_fWarnNoSave = TRUE;
m_fPromptingUser = FALSE;
m_fCanAnnotate = FALSE;
m_fAnnotating = FALSE;
m_fEditingAnnotation = FALSE;
m_fDirty = FALSE;
m_pEvents = 0;
m_fPaused = FALSE;
m_fGoBack = FALSE;
m_fHidePrintBtn = FALSE;
m_fPrintable = FALSE;
m_fDisableEdit = FALSE;
m_fCanSave = TRUE;
m_fExitApp = FALSE;
m_fAllowContextMenu = TRUE; // full screen window always has a context menu
m_iCurSlide = -1;
m_iDecodingNextImage = -1;
m_pNextImageData = NULL;
m_fToolbarHidden = TRUE;
m_dwMultiPageMode = MPCMD_HIDDEN;
m_fIgnoreUITimers = FALSE;
DWORD cbSize = sizeof(m_uTimeout);
UINT uDefault = DEFAULT_SHIMGVW_TIMEOUT;
SHRegGetUSValue(REGSTR_SHIMGVW, REGSTR_TIMEOUT, NULL, (void *)&m_uTimeout, &cbSize, FALSE, (void *)&uDefault, sizeof(uDefault));
InitSelectionTracking();
g_bMirroredOS = IS_MIRRORING_ENABLED(); // global????
m_hdpaSelectedAnnotations = NULL;
m_haccel = NULL;
m_hpal = NULL;
m_dwMode = 0;
m_fShowToolbar = TRUE;
m_punkSite = NULL;
m_pImageFactory = NULL;
m_pcwndSlideShow = NULL;
m_hFont = NULL;
m_pImageData = NULL;
m_ppidls = NULL;
m_cItems = 0;
_pcm3 = NULL;
m_pTaskScheduler = NULL;
m_pici = NULL;
_pdtobj = NULL;
m_fFirstTime = TRUE;
m_fFirstItem = FALSE;
m_dwEffect = DROPEFFECT_NONE;
m_fIgnoreNextNotify = FALSE;
m_uRegister = 0;
m_fNoRestore = FALSE;
m_bRTLMirrored = FALSE;
m_cWalkDepth = 0;
}
HRESULT CPreviewWnd::Initialize(CPreviewWnd* pother, DWORD dwMode, BOOL bExitApp)
{
HRESULT hr = E_OUTOFMEMORY;
m_hdpaSelectedAnnotations = DPA_Create(16);
if (m_hdpaSelectedAnnotations)
{
hr = S_OK;
m_dwMode = dwMode;
m_fExitApp = bExitApp;
// Set some defaults based on the mode
if (CONTROL_MODE == m_dwMode)
{
m_fHidePrintBtn = TRUE;
}
if (pother)
{
m_fHidePrintBtn = pother->m_fHidePrintBtn;
m_fPrintable = pother->m_fPrintable;
m_fDisableEdit = pother->m_fDisableEdit;
m_fCanSave = pother->m_fCanSave;
m_haccel = pother->m_haccel;
m_dwMultiPageMode = pother->m_dwMultiPageMode;
m_hpal = pother->m_hpal;
m_iCurSlide = pother->m_iCurSlide;
m_uTimeout = pother->m_uTimeout;
SetSite(pother->m_punkSite);
// we grab a reference to the controlling objects m_pImageFactory
// becaue it would be odd to create new ones.
m_pImageFactory = pother->m_pImageFactory;
if (m_pImageFactory)
{
m_pImageFactory->AddRef();
}
m_pTaskScheduler = pother->m_pTaskScheduler;
if (m_pTaskScheduler)
{
m_pTaskScheduler->AddRef();
}
// lets copy the DPA of items also, and the current index
if (pother->m_ppidls)
{
m_ppidls = (LPITEMIDLIST*)CoTaskMemAlloc(sizeof(LPITEMIDLIST)*pother->m_cItems);
if (m_ppidls)
{
for (int iItem = 0; iItem != pother->m_cItems; iItem++)
{
if (SUCCEEDED(pother->_GetItem(iItem, &m_ppidls[m_cItems])))
{
m_cItems++;
}
}
}
}
}
}
return hr;
}
int ClearCB(void *p, void *pData);
CPreviewWnd::~CPreviewWnd()
{
CleanupSelectionTracking();
if (m_hdpaSelectedAnnotations != NULL)
DPA_Destroy(m_hdpaSelectedAnnotations);
::DeleteObject(m_hFont);
ATOMICRELEASE(m_pImageData);
ATOMICRELEASE(m_pNextImageData);
ATOMICRELEASE(m_pImageFactory);
SetSite(NULL);
ATOMICRELEASE(_pdtobj);
ATOMICRELEASE(m_pTaskScheduler);
_ClearDPA();
if (m_pcwndSlideShow)
{
if (m_pcwndSlideShow->m_hWnd)
{
m_pcwndSlideShow->DestroyWindow();
}
delete m_pcwndSlideShow;
}
if (m_pici)
{
LocalFree(m_pici);
m_pici = NULL;
}
}
BOOL CPreviewWnd::CreateSlideshowWindow(UINT cWalkDepth)
{
RECT rc = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 };
if (!Create(NULL, rc, NULL, WS_VISIBLE | WS_POPUP | WS_CLIPCHILDREN))
return FALSE;
WINDOWPLACEMENT wp = {0};
wp.length = sizeof(wp);
GetWindowPlacement(&wp);
wp.showCmd = SW_MAXIMIZE;
SetWindowPlacement(&wp);
SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_SHOWWINDOW);
// when we get called from autoplay to do a slideshow,
// we need to walk deeply to find everything
// that the autoplay code may have found
m_cWalkDepth = cWalkDepth;
return TRUE;
}
BOOL CPreviewWnd::_CloseSlideshowWindow()
{
if (m_fExitApp)
PostQuitMessage(0);
else
PostMessage(WM_CLOSE, 0, 0);
return TRUE;
}
BOOL CPreviewWnd::CreateViewerWindow()
{
// create the window hidden, that way any sizing etc we perform doesn't reflect
// until its actually visible.
RECT rc = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 };
BOOL bRet = (NULL != Create(NULL, rc, NULL, WS_OVERLAPPEDWINDOW));
m_haccel = LoadAccelerators(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDA_PREVWND_SINGLEPAGE));
if (bRet)
{
// restore the window size based on the information we store in the registry.
HKEY hk;
if (ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER, REGSTR_SHIMGVW, &hk))
{
DWORD cbSize, dwType;
// set the window placement, passing the restore rectangle for the window.
WINDOWPLACEMENT wp = { 0 };
wp.length = sizeof(wp);
GetWindowPlacement(&wp);
cbSize = sizeof(wp.rcNormalPosition);
RegQueryValueEx(hk, REGSTR_BOUNDS, NULL, &dwType, (BYTE*)&wp.rcNormalPosition, &cbSize);
BOOL fMaximize = TRUE;
cbSize = sizeof(fMaximize);
RegQueryValueEx(hk, REGSTR_MAXIMIZED, NULL, &dwType, (BYTE*)&fMaximize, &cbSize);
if (fMaximize)
wp.showCmd = SW_MAXIMIZE;
SetWindowPlacement(&wp);
RegCloseKey(hk);
}
// now show the window having set its placement etc.
SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_SHOWWINDOW);
}
return bRet;
}
void ReplaceWindowIcon(HWND hwnd, int id, HICON hicon)
{
HICON hiconOld = (HICON)SendMessage(hwnd, WM_SETICON, id, (LPARAM)hicon);
if (hiconOld)
DestroyIcon(hiconOld);
}
LRESULT CPreviewWnd::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
HRESULT hr = S_OK;
if (IS_BIDI_LOCALIZED_SYSTEM())
{
SHSetWindowBits(m_hWnd, GWL_EXSTYLE, WS_EX_LAYOUTRTL, WS_EX_LAYOUTRTL);
m_bRTLMirrored = TRUE;
}
if (!m_pImageFactory)
{
hr = CoCreateInstance(CLSID_ShellImageDataFactory, NULL, CLSCTX_INPROC,
IID_PPV_ARG(IShellImageDataFactory, &m_pImageFactory));
if (FAILED(hr))
return -1;
}
if (!m_pTaskScheduler)
{
hr = IUnknown_QueryService(m_punkSite, SID_ShellTaskScheduler, IID_PPV_ARG(IShellTaskScheduler, &m_pTaskScheduler));
if (FAILED(hr))
{
hr = CoCreateInstance(CLSID_ShellTaskScheduler, NULL, CLSCTX_INPROC,
IID_PPV_ARG(IShellTaskScheduler, &m_pTaskScheduler));
if (FAILED(hr))
return -1;
}
}
// figure out where to place the zoom window
RECT rcWnd;
GetClientRect(&rcWnd);
if (m_fShowToolbar)
{
// Create a toolbar control and then subclass it
if (!CreateToolbar())
return -1;
m_iSSToolbarSelect = 0;
}
HICON hicon = LoadIcon(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDI_FULLSCREEN));
ReplaceWindowIcon(m_hWnd, ICON_SMALL, hicon);
ReplaceWindowIcon(m_hWnd, ICON_BIG, hicon);
// Create the preview window
DWORD dwExStyle = 0; // (WINDOW_MODE == m_dwMode) ? WS_EX_CLIENTEDGE : 0 ;
if (m_ctlPreview.Create(m_hWnd, rcWnd, NULL, WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS, dwExStyle))
{
// When the window is created its default mode should be NOACTION. This call is needed
// because the object might have a longer life cycle than the window. If a new window
// is created for the same object we want to reset the state.
m_ctlPreview.SetMode(CZoomWnd::MODE_NOACTION);
m_ctlPreview.SetScheduler(m_pTaskScheduler);
}
RegisterDragDrop(m_hWnd, SAFECAST(this, IDropTarget *));
return 0;
}
HRESULT CPreviewWnd::_SaveIfDirty(BOOL fCanCancel)
{
// Callers assume that _SaveIfDirty will either return S_OK or S_FALSE
// since this function is designed to sit in a loop until the user gives
// up saving (cancels) or save successfully.
HRESULT hr = S_OK;
if (m_fDirty)
{
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_SAVEWARNING_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
hr = E_FAIL;
while (FAILED(hr))
{
UINT uFlags;
if (fCanCancel)
uFlags = MB_YESNOCANCEL;
else
uFlags = MB_YESNO;
uFlags |= MB_ICONQUESTION | MB_DEFBUTTON1 | MB_APPLMODAL;
m_fPromptingUser = TRUE;
int iResult = MessageBox(bstrMsg, bstrTitle, uFlags);
m_fPromptingUser = FALSE;
if (iResult == IDYES)
{
// if this fails we keep looping.
// if this returns S_OK we succeed
// if this returns S_FALSE we cancel
hr = _SaveAsCmd();
}
else if (iResult == IDCANCEL)
{
hr = S_FALSE;
}
else
{
hr = S_OK;
}
}
}
if (S_OK == hr)
m_fDirty = FALSE;
}
return hr;
}
LRESULT CPreviewWnd::OnClose(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
// hack alert- if CONTROL is held down while pressing the close button, do the registry stuff.
// make sure the E accelerator isn't being used (edit verb)!
if (m_fPromptingUser)
{
SetForegroundWindow(m_hWnd);
fHandled = TRUE;
return 0;
}
if (!m_fNoRestore && GetKeyState(VK_CONTROL) & 0x8000)
{
CRegKey Key;
if (ERROR_SUCCESS == Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.DeleteValue(REGSTR_LOSSYROTATE);
}
if (ERROR_SUCCESS == Key.Open(HKEY_CURRENT_USER, REGSTR_DONTSHOWME))
{
Key.DeleteValue(REGSTR_SAVELESS);
Key.DeleteValue(REGSTR_LOSSYROTATE);
}
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_RESET_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
m_fPromptingUser = TRUE;
MessageBox(bstrMsg, bstrTitle, MB_OK | MB_APPLMODAL);
m_fPromptingUser = FALSE;
}
}
fHandled = FALSE; // let it close
HRESULT hr = _SaveIfDirty(TRUE);
if (hr == S_FALSE) // _SaveIfDirty can only return S_OK and S_FALSE
{
m_fNoRestore = FALSE;
fHandled = TRUE;
}
if (!fHandled)
{
m_fClosed = TRUE;
}
return 0;
}
// we only have to erase the portion not covered by the zoomwnd
// change this code if the toolbar is put back at the top of the window
LRESULT CPreviewWnd::OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
RECT rc;
RECT rcZoomwnd;
m_ctlPreview.GetClientRect(&rcZoomwnd);
GetClientRect(&rc);
rc.top = RECTHEIGHT(rcZoomwnd);
SetBkColor((HDC)wParam, m_ctlPreview.GetBackgroundColor());
ExtTextOut((HDC)wParam, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
fHandled = TRUE;
return TRUE;
}
LRESULT CPreviewWnd::OnSize(UINT , WPARAM wParam, LPARAM lParam, BOOL&)
{
int x =0, y =0, cx =0, cy =0;
if (lParam == 0)
{
RECT rcClient;
GetClientRect(&rcClient);
cx = RECTWIDTH(rcClient);
cy = RECTHEIGHT(rcClient);
}
else
{
cx = GET_X_LPARAM(lParam);
cy = GET_Y_LPARAM(lParam);
}
if (m_fShowToolbar)
{
SIZE sizeToolbar;
m_ctlToolbar.SendMessage(TB_GETMAXSIZE, 0, (LPARAM)&sizeToolbar);
if (sizeToolbar.cx > cx)
sizeToolbar.cx = cx;
if (SLIDESHOW_MODE != m_dwMode)
{
// Center the toolbar horizontally
LONG cyBottomMargin = (CONTROL_MODE == m_dwMode) ? NEWTOOLBAR_BOTTOMMARGIN_CTRLMODE : NEWTOOLBAR_BOTTOMMARGIN;
LONG xNewToolbar = ( cx - sizeToolbar.cx ) / 2;
LONG yNewToolbar = cy - ( cyBottomMargin + sizeToolbar.cy );
::SetWindowPos(m_ctlToolbar.m_hWnd, NULL, xNewToolbar, yNewToolbar, sizeToolbar.cx, sizeToolbar.cy, SWP_NOZORDER);
// make the preview window shorter so the toolbar is below it
cy -= ( NEWTOOLBAR_TOPMARGIN + sizeToolbar.cy + cyBottomMargin);
}
else
{
// Pin the toolbar to the upper right corner
UINT uFlags = 0;
if (m_fToolbarHidden)
uFlags |= SWP_HIDEWINDOW;
else
uFlags |= SWP_SHOWWINDOW;
::SetWindowPos(m_ctlToolbar.m_hWnd, HWND_TOP, cx-sizeToolbar.cx, 0, sizeToolbar.cx, sizeToolbar.cy, uFlags);
}
}
::SetWindowPos(m_ctlPreview.m_hWnd, NULL, x, y, cx, cy, SWP_NOZORDER);
return 0;
}
BOOL CPreviewWnd::_VerbExists(LPCTSTR pszVerb)
{
// TODO: Create the context menu for the item and check it for the verb
return TRUE;
}
// given a verb lets invoke it for the current file
HRESULT CPreviewWnd::_InvokeVerb(LPCTSTR pszVerb, LPCTSTR szParameters)
{
SHELLEXECUTEINFO sei = {0};
sei.cbSize = sizeof(sei);
sei.fMask = SEE_MASK_INVOKEIDLIST | SEE_MASK_HMONITOR;
sei.hwnd = m_hWnd;
sei.lpVerb = pszVerb;
sei.nShow = SW_SHOW;
sei.lpParameters = szParameters;
sei.hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
LPITEMIDLIST pidl = NULL;
TCHAR szPath[MAX_PATH];
HRESULT hr = GetCurrentIDList(&pidl);
if (SUCCEEDED(hr))
{
sei.lpIDList = pidl;
}
else if (SUCCEEDED(hr = PathFromImageData(szPath, ARRAYSIZE(szPath))))
{
sei.lpFile = szPath;
}
if (SUCCEEDED(hr))
{
hr = S_OK;
if (!ShellExecuteEx(&sei))
hr = E_FAIL;
}
ILFree(pidl);
return hr;
}
// show the window and activate it
// if the window is minimized, restore it
void RestoreAndActivate(HWND hwnd)
{
if (IsIconic(hwnd))
{
ShowWindow(hwnd, SW_RESTORE);
}
SetForegroundWindow(hwnd);
}
// Handles WM_COMMAND messages sent from the toolbar control
LRESULT CPreviewWnd::OnToolbarCommand(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& fHandled)
{
switch (wID)
{
case ID_ZOOMINCMD:
ZoomIn();
break;
case ID_ZOOMOUTCMD:
ZoomOut();
break;
case ID_SELECTCMD:
if (m_fCanAnnotate)
{
_UpdateButtons(wID);
}
break;
case ID_CROPCMD:
if (m_fCanCrop)
{
m_rectCropping.SetRectEmpty();
_UpdateButtons(wID);
}
break;
case ID_ACTUALSIZECMD:
ActualSize();
break;
case ID_BESTFITCMD:
BestFit();
break;
case ID_PRINTCMD:
_RefreshSelection(FALSE);
_InvokePrintWizard();
break;
case ID_PREVPAGECMD:
case ID_NEXTPAGECMD:
_PrevNextPage(ID_NEXTPAGECMD==wID);
break;
case ID_NEXTIMGCMD:
case ID_PREVIMGCMD:
_RefreshSelection(FALSE);
if (WINDOW_MODE == m_dwMode)
{
HRESULT hr = _SaveIfDirty(TRUE);
if (hr == S_FALSE)
return 0;
_ShowNextSlide(ID_PREVIMGCMD == wID);
}
else if (m_punkSite)
{
IFolderView* pfv;
if (SUCCEEDED(IUnknown_QueryService(m_punkSite, SID_DefView, IID_PPV_ARG(IFolderView, &pfv))))
{
int iCurrent, cItems;
if (SUCCEEDED(pfv->ItemCount(SVGIO_ALLVIEW, &cItems)) && (cItems > 1) &&
SUCCEEDED(pfv->GetFocusedItem(&iCurrent)))
{
int iToSelect = iCurrent + ((ID_PREVIMGCMD == wID) ? -1 : 1);
if (iToSelect < 0)
{
iToSelect = cItems-1;
}
else if (iToSelect >= cItems)
{
iToSelect = 0;
}
pfv->SelectItem(iToSelect, SVSI_SELECTIONMARK | SVSI_SELECT
| SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED);
}
pfv->Release();
}
}
break;
case ID_FREEHANDCMD:
case ID_HIGHLIGHTCMD:
case ID_LINECMD:
case ID_FRAMECMD:
case ID_RECTCMD:
case ID_TEXTCMD:
case ID_NOTECMD:
if (m_fCanAnnotate)
{
_UpdateButtons(wID);
}
break;
case ID_PROPERTIESCMD:
_UpdateButtons(wID);
_PropertiesCmd();
break;
case ID_SAVEASCMD:
_UpdateButtons(wID);
_SaveAsCmd();
break;
case ID_EDITCMD:
_UpdateButtons(wID);
if (m_fCanAnnotate && m_fAnnotating)
{
_StartEditing();
}
break;
case ID_HELPCMD:
_UpdateButtons(wID);
HtmlHelp(::GetDesktopWindow(), HTMLHELP_FILENAME, HH_DISPLAY_TOPIC, NULL);
break;
case ID_OPENCMD:
_UpdateButtons(wID);
_OpenCmd();
break;
case ID_DELETECMD:
_UpdateButtons(wID);
if (m_fCanAnnotate && m_fAnnotating && DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
_RemoveAnnotatingSelection();
}
else
{
_DeleteCurrentSlide();
}
break;
case ID_SLIDESHOWCMD:
if (!m_fFirstTime) // don't try to do this while the namespace walk is ongoing
{
StartSlideShow(NULL);
}
break;
}
return 0;
}
// OnEditCommand
//
// Handles picture editting(rotate/flip/save etc) WM_COMMAND messages
LRESULT CPreviewWnd::OnEditCommand(WORD , WORD wID, HWND , BOOL& )
{
switch (wID)
{
case ID_ROTATE90CMD:
Rotate(90);
break;
case ID_ROTATE270CMD:
Rotate(270);
break;
}
return 0;
}
LRESULT CPreviewWnd::OnPositionCommand(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& fHandled)
{
if (SLIDESHOW_MODE == m_dwMode)
{
switch (wID)
{
case ID_NUDGELEFTCMD:
OnSlideshowCommand(0, ID_PREVCMD, NULL, fHandled);
break;
case ID_NUDGERIGHTCMD:
OnSlideshowCommand(0, ID_NEXTCMD, NULL, fHandled);
break;
default:
break;
}
}
else
{
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 0)
{
BOOL bDummy;
switch (wID)
{
case ID_MOVELEFTCMD:
m_ctlPreview.OnScroll(WM_HSCROLL, SB_PAGEUP, 0, fHandled);
break;
case ID_MOVERIGHTCMD:
m_ctlPreview.OnScroll(WM_HSCROLL, SB_PAGEDOWN, 0, fHandled);
break;
case ID_MOVEUPCMD:
m_ctlPreview.OnScroll(WM_VSCROLL, SB_PAGEUP, 0, fHandled);
break;
case ID_MOVEDOWNCMD:
m_ctlPreview.OnScroll(WM_VSCROLL, SB_PAGEDOWN, 0, fHandled);
break;
case ID_NUDGELEFTCMD:
if (m_ctlPreview.ScrollBarsPresent())
{
m_ctlPreview.OnScroll(WM_HSCROLL, SB_LINEUP, 0, fHandled);
}
else
{
OnToolbarCommand(0, ID_PREVIMGCMD, m_hWnd, bDummy);
}
break;
case ID_NUDGERIGHTCMD:
if (m_ctlPreview.ScrollBarsPresent())
{
m_ctlPreview.OnScroll(WM_HSCROLL, SB_LINEDOWN, 0, fHandled);
}
else
{
OnToolbarCommand(0, ID_NEXTIMGCMD, m_hWnd, bDummy);
}
break;
case ID_NUDGEUPCMD:
if (m_ctlPreview.ScrollBarsPresent())
{
m_ctlPreview.OnScroll(WM_VSCROLL, SB_LINEUP, 0, fHandled);
}
else
{
OnToolbarCommand(0, ID_PREVIMGCMD, m_hWnd, bDummy);
}
break;
case ID_NUDGEDOWNCMD:
if (m_ctlPreview.ScrollBarsPresent())
{
m_ctlPreview.OnScroll(WM_VSCROLL, SB_LINEDOWN, 0, fHandled);
}
else
{
OnToolbarCommand(0, ID_NEXTIMGCMD, m_hWnd, bDummy);
}
break;
default:
break;
}
}
else
{
CRect rectImage;
m_ctlPreview.GetVisibleImageWindowRect(rectImage);
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rectImage, 2);
rectImage.DeflateRect(5, 5);
CSize size(0,0);
switch (wID)
{
case ID_MOVELEFTCMD:
size.cx = -25;
break;
case ID_MOVERIGHTCMD:
size.cx = 25;
break;
case ID_MOVEUPCMD:
size.cy = -25;
break;
case ID_MOVEDOWNCMD:
size.cy = 25;
break;
case ID_NUDGELEFTCMD:
size.cx = -1;
break;
case ID_NUDGERIGHTCMD:
size.cx = 1;
break;
case ID_NUDGEUPCMD:
size.cy = -1;
break;
case ID_NUDGEDOWNCMD:
size.cy = 1;
break;
default:
break;
}
if (size.cx == 0 && size.cy == 0)
return 0;
_UpdateAnnotatingSelection();
CRect rect;
CRect rectNewPos;
BOOL bValidMove = TRUE;
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotation->GetRect(rect);
rect.NormalizeRect();
rect.OffsetRect(size);
if (!rectNewPos.IntersectRect(rectImage, rect))
bValidMove = FALSE;
}
if (!bValidMove)
return 0;
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotation->Move(size);
}
m_fDirty = TRUE;
_UpdateAnnotatingSelection();
}
}
return 0;
}
// call SetNewImage when the entire image has changed, call UpdateImage if it's the same image
// but it needs to be updated
void CPreviewWnd::_SetNewImage(CDecodeTask * pData)
{
// store the new pointer
if (m_pImageData)
{
_SaveIfDirty();
// m_pImageData might be NULL after _SaveAsCmd
ATOMICRELEASE(m_pImageData);
}
m_pImageData = pData;
m_fWarnQuietSave = TRUE; // Reset for each image
m_fWarnNoSave = TRUE;
if (!m_pImageData)
{
StatusUpdate(IDS_LOADFAILED);
return;
}
m_pImageData->AddRef();
// Even if m_hpal is NULL it is still correct, so we always go ahead and set it.
m_ctlPreview.SetPalette(m_hpal);
if (SLIDESHOW_MODE != m_dwMode)
{
// update toolbar state
_SetMultipageCommands();
_SetMultiImagesCommands();
BOOL fCanAnnotate = _CanAnnotate(m_pImageData);
_SetAnnotatingCommands(fCanAnnotate);
BOOL fCanCrop = _CanCrop(m_pImageData);
_SetCroppingCommands(fCanCrop);
_RefreshSelection(TRUE);
_SetEditCommands();
m_fPrintable = _VerbExists(TEXT("print"));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PRINTCMD, MAKELONG(m_fPrintable, 0));
// we need to watch non-TIFFs for changes so we can reload.
// TIFFs are problematic because we allow annotations, and reloading during annotation
// would suck
if (CONTROL_MODE != m_dwMode)
{
_RegisterForChangeNotify(TRUE);
}
}
// notify our child
m_ctlPreview.SetImageData(m_pImageData, TRUE);
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(FALSE, 0));
// update our toolbar
BOOL fHandled;
OnSize(0x0, 0, 0, fHandled);
}
// for refreshing the current m_pImageData because it has changed in some
// way, i.e. it has advanced to the next frame, the next page, or was edited.
void CPreviewWnd::_UpdateImage()
{
_RefreshSelection(TRUE);
m_ctlPreview.SetImageData(m_pImageData, FALSE);
}
// Handles slidwshow (pause/resume, next/previous etc) WM_COMMAND messages
void CPreviewWnd::TogglePlayState()
{
if (!m_fPaused)
{
KillTimer(TIMER_SLIDESHOW);
}
else
{
SetTimer(TIMER_SLIDESHOW, m_uTimeout);
}
m_fPaused = !m_fPaused;
WPARAM wpCheck, wpUncheck;
if (m_fPaused)
{
wpCheck = ID_PAUSECMD;
wpUncheck = ID_PLAYCMD;
}
else
{
wpCheck = ID_PLAYCMD;
wpUncheck = ID_PAUSECMD;
}
m_ctlToolbar.SendMessage(TB_SETSTATE, wpCheck, TBSTATE_ENABLED | TBSTATE_CHECKED);
m_ctlToolbar.SendMessage(TB_SETSTATE, wpUncheck, TBSTATE_ENABLED);
}
LRESULT CPreviewWnd::OnMenuMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
if (_pcm3)
_pcm3->HandleMenuMsg(uMsg, wParam, lParam);
return 0;
}
LRESULT CPreviewWnd::OnAppCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
UINT cmd = GET_APPCOMMAND_LPARAM(lParam);
DWORD dwKeys = GET_KEYSTATE_LPARAM(lParam);
switch (cmd)
{
case APPCOMMAND_BROWSER_FORWARD:
if (SLIDESHOW_MODE == m_dwMode)
OnSlideshowCommand(0, ID_NEXTCMD, NULL, fHandled);
else
{
if ((dwKeys & MK_CONTROL) || (m_pImageData && !m_pImageData->IsMultipage()))
OnToolbarCommand(0, ID_NEXTIMGCMD, NULL, fHandled);
else
NextPage();
}
break;
case APPCOMMAND_BROWSER_BACKWARD:
if (SLIDESHOW_MODE == m_dwMode)
OnSlideshowCommand(0, ID_PREVCMD, NULL, fHandled);
else
{
if ((dwKeys & MK_CONTROL) || (m_pImageData && !m_pImageData->IsMultipage()))
OnToolbarCommand(0, ID_PREVIMGCMD, NULL, fHandled);
else
PreviousPage();
}
break;
default:
fHandled = FALSE;
}
return 0;
}
LRESULT CPreviewWnd::OnSlideshowCommand(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& fHandled)
{
switch (wID)
{
case ID_PLAYCMD:
m_iSSToolbarSelect = 0;
if (m_fPaused)
{
m_fGoBack = FALSE;
TogglePlayState();
_ShowNextSlide(m_fGoBack);
}
fHandled = TRUE;
break;
case ID_PAUSECMD:
m_iSSToolbarSelect = 1;
if (!m_fPaused)
{
TogglePlayState();
}
fHandled = TRUE;
break;
case ID_NEXTCMD:
case ID_PREVCMD:
if (wID == ID_PREVCMD)
{
m_iSSToolbarSelect = 3;
m_fGoBack = TRUE;
}
else
{
m_iSSToolbarSelect = 4;
m_fGoBack = FALSE;
}
_ShowNextSlide(m_fGoBack);
fHandled = TRUE;
break;
case ID_CLOSECMD:
m_iSSToolbarSelect = 6;
_CloseSlideshowWindow();
break;
}
return 0;
}
BOOL CPreviewWnd::CreateToolbar()
{
// ensure that the common controls are initialized
INITCOMMONCONTROLSEX icc;
icc.dwSize = sizeof(icc);
icc.dwICC = ICC_BAR_CLASSES;
InitCommonControlsEx(&icc);
return (SLIDESHOW_MODE == m_dwMode) ? _CreateSlideshowToolbar() : _CreateViewerToolbar();
}
static const TBBUTTON c_tbSlideShow[] =
{
// override default toolbar width for separators; iBitmap member of
// TBBUTTON struct is a union of bitmap index & separator width
{ 0, ID_PLAYCMD, TBSTATE_ENABLED | TBSTATE_CHECKED, TBSTYLE_CHECKGROUP, {0,0}, 0, 0},
{ 1, ID_PAUSECMD, TBSTATE_ENABLED, TBSTYLE_CHECKGROUP, {0,0}, 0, 0},
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, 0},
{ 2, ID_PREVCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, 0},
{ 3, ID_NEXTCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, 0},
#if 0
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, 0},
{ 5, ID_DELETECMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, 0},
#endif
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, 0},
{ 4, ID_CLOSECMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, 0},
};
BOOL CPreviewWnd::_CreateSlideshowToolbar()
{
DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
CCS_NODIVIDER | CCS_NORESIZE |
TBSTYLE_LIST | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS;
HWND hwndTB = CreateWindowEx(WS_EX_TOOLWINDOW, TOOLBARCLASSNAME, NULL, dwStyle, 0, 0, 0, 0,
m_hWnd, NULL, _Module.GetModuleInstance(), NULL);
_InitializeToolbar(hwndTB, IDB_SLIDESHOWTOOLBAR, IDB_SLIDESHOWTOOLBAR_HOT, IDB_SLIDESHOWTOOLBARHIGH, IDB_SLIDESHOWTOOLBARHIGH_HOT);
TBBUTTON tbSlideShow[ARRAYSIZE(c_tbSlideShow)];
memcpy(tbSlideShow, c_tbSlideShow, sizeof(c_tbSlideShow));
// Add the buttons, and then set the minimum and maximum button widths.
::SendMessage(hwndTB, TB_ADDBUTTONS, (UINT)ARRAYSIZE(c_tbSlideShow), (LPARAM)tbSlideShow);
LRESULT dwSize = ::SendMessage(hwndTB, TB_GETBUTTONSIZE, 0, 0);
SIZE size = {0, HIWORD(dwSize)};
::SendMessage(hwndTB, TB_GETIDEALSIZE, 0, (LPARAM)&size);
RECT rcClient;
RECT rcToolbar = {0, 0, size.cx, size.cy};
GetClientRect(&rcClient);
AdjustWindowRectEx(&rcToolbar, dwStyle, FALSE, WS_EX_TOOLWINDOW);
::SetWindowPos(hwndTB, HWND_TOP, RECTWIDTH(rcClient)-RECTWIDTH(rcToolbar), 0,
RECTWIDTH(rcToolbar), RECTHEIGHT(rcToolbar), 0);
//> REVIEW This is a feature that CyraR would like to get into Whistler, but it doesn't seem to work. I will investigate more after Beta1
// LONG lStyle = ::GetWindowLong(hwndTB, GWL_EXSTYLE);
// ::SetWindowLong(hwndTB, GWL_EXSTYLE, lStyle | WS_EX_LAYERED);
// if (::SetLayeredWindowAttributes(hwndTB, 0, 0, 0) == 0)
// {
// void *lpMsgBuf;
// ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
// NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
//
// MessageBox((LPCTSTR)lpMsgBuf, L"Error", MB_OK | MB_ICONINFORMATION);
// ::LocalFree(lpMsgBuf);
// }
m_ctlToolbar.SubclassWindow(hwndTB);
ShowSSToolbar(FALSE, TRUE);
return (NULL != hwndTB);
}
enum EViewerToolbarButtons
{
PREVIMGPOS = 0,
NEXTIMGPOS,
VIEWSEPPOS, // seperator
BESTFITPOS,
ACTUALSIZEPOS,
SLIDESHOWPOS,
IMAGECMDSEPPOS, // seperator
ZOOMINPOS,
ZOOMEOUTPOS,
SELECTPOS,
CROPPOS,
ROTATESEPPOS, // seperator
ROTATE90POS,
ROTATE270POS,
// these are all TIFF related
PAGESEPPOS,
PREVPAGEPOS,
PAGELISTPOS,
NEXTPAGEPOS,
ANNOTATEPOS,
FREEHANDPOS,
HIGLIGHTPOS,
LINEPOS,
FRAMEPOS,
RECTPOS,
TEXTPOS,
NOTEPOS,
PRINTSEPPOS,
DELETEPOS,
PRINTPOS,
PROPERTIESPOS,
SAVEASPOS,
OPENPOS,
HELPSEPPOS,
HELPPOS,
MAXPOS,
};
static const TBBUTTON c_tbViewer[] =
{
// override default toolbar width for separators; iBitmap member of
// TBBUTTON struct is a union of bitmap index & separator width
{ 0, ID_PREVIMGCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 1, ID_NEXTIMGCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 0, ID_VIEWCMDSEP, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1},
{ 5, ID_BESTFITCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 6, ID_ACTUALSIZECMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 8, ID_SLIDESHOWCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1},
{ 2, ID_ZOOMINCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 3, ID_ZOOMOUTCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 4, ID_SELECTCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 23, ID_CROPCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 0, ID_ROTATESEP, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1},
{ 12, ID_ROTATE90CMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 11, ID_ROTATE270CMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 0, ID_PAGECMDSEP, TBSTATE_HIDDEN, TBSTYLE_SEP, {0,0}, 0, -1}, //tiff
{ 9, ID_PREVPAGECMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ I_IMAGENONE, ID_PAGELIST, TBSTATE_HIDDEN, BTNS_WHOLEDROPDOWN | BTNS_SHOWTEXT | BTNS_AUTOSIZE, {0,0}, 0, -1},//tiff
{ 10, ID_NEXTPAGECMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 0, ID_ANNOTATESEP, TBSTATE_HIDDEN, TBSTYLE_SEP, {0,0}, 0, -1}, //tiff
{ 13, ID_FREEHANDCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 14, ID_HIGHLIGHTCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 15, ID_LINECMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 16, ID_FRAMECMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 17, ID_RECTCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 18, ID_TEXTCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 19, ID_NOTECMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1}, //tiff
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1},
{ 25, ID_DELETECMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 20, ID_PRINTCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 21, ID_PROPERTIESCMD, TBSTATE_HIDDEN, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 22, ID_SAVEASCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 26, ID_OPENCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1},
{ 24, ID_HELPCMD, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
};
void CPreviewWnd::_InitializeViewerToolbarButtons(HWND hwndToolbar, const TBBUTTON c_tbbuttons[], size_t c_nButtons, TBBUTTON tbbuttons[], size_t nButtons)
{
ASSERT(c_nButtons == nButtons); // Sanity check.
ASSERT(c_nButtons <= 100); // Sanity check.
// Determine if running RTL mirrored and initialize toolbar accordingly.
if (!m_bRTLMirrored)
{
//
// Init LTR.
//
memcpy(tbbuttons, c_tbbuttons, c_nButtons * sizeof(TBBUTTON));
}
else
{
//
// Init RTL.
//
// Toolbar window inherits RTL style from parent hwnd, but we don't
// want full-blown RTL. We do want the icons to have their positions
// reversed in the toolbar, but we don't want the button bitmaps to
// get blitted backwards. So we turn of RTL for the toolbar hwnd
// and do a manual reorder of the buttons in RTL fashion.
// Remove RTL style from toolbar hwnd.
DWORD dwStyle = ::GetWindowLong(hwndToolbar, GWL_EXSTYLE);
DWORD dwNewStyle = (dwStyle & ~WS_EX_LAYOUTRTL);
ASSERT(dwStyle != dwNewStyle); // Sanity check.
::SetWindowLong(hwndToolbar, GWL_EXSTYLE, dwNewStyle);
// Reverse toolbar button order.
size_t iFrom = nButtons - 1;
size_t iTo = 0;
while (iTo < iFrom)
{
memcpy(&tbbuttons[iTo], &c_tbbuttons[iFrom], sizeof(TBBUTTON));
memcpy(&tbbuttons[iFrom], &c_tbbuttons[iTo], sizeof(TBBUTTON));
iFrom--;
iTo++;
}
if (iTo == iFrom)
{
memcpy(&tbbuttons[iTo], &c_tbbuttons[iFrom], sizeof(TBBUTTON));
}
}
}
inline UINT CPreviewWnd::_IndexOfViewerToolbarButton(EViewerToolbarButtons eButton)
{
ASSERT(eButton > 0);
if (!m_bRTLMirrored)
{
return eButton;
}
else
{
return MAXPOS - eButton - 1;
}
}
BOOL CPreviewWnd::_CreateViewerToolbar()
{
DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
CCS_NODIVIDER | CCS_NORESIZE |
TBSTYLE_LIST | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS;
HWND hwndTB = CreateWindowEx(0, TOOLBARCLASSNAME, NULL, dwStyle, 0, 0, 0, 0,
m_hWnd, NULL, _Module.GetModuleInstance(), NULL);
_InitializeToolbar(hwndTB, IDB_TOOLBAR, IDB_TOOLBAR_HOT, IDB_TOOLBARHIGH, IDB_TOOLBARHIGH_HOT);
TBBUTTON tbbuttons[ARRAYSIZE(c_tbViewer)];
_InitializeViewerToolbarButtons(hwndTB, c_tbViewer, ARRAYSIZE(c_tbViewer), tbbuttons, ARRAYSIZE(tbbuttons));
if (CONTROL_MODE == m_dwMode)
{
ASSERT(ID_BESTFITCMD==tbbuttons[_IndexOfViewerToolbarButton(BESTFITPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(BESTFITPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_ACTUALSIZECMD==tbbuttons[_IndexOfViewerToolbarButton(ACTUALSIZEPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ACTUALSIZEPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_SLIDESHOWCMD==tbbuttons[_IndexOfViewerToolbarButton(SLIDESHOWPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(SLIDESHOWPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_ZOOMINCMD==tbbuttons[_IndexOfViewerToolbarButton(ZOOMINPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ZOOMINPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_ZOOMOUTCMD==tbbuttons[_IndexOfViewerToolbarButton(ZOOMEOUTPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ZOOMEOUTPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_SAVEASCMD==tbbuttons[_IndexOfViewerToolbarButton(SAVEASPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(SAVEASPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_DELETECMD==tbbuttons[_IndexOfViewerToolbarButton(DELETEPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(DELETEPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_OPENCMD==tbbuttons[_IndexOfViewerToolbarButton(OPENPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(OPENPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_HELPCMD==tbbuttons[_IndexOfViewerToolbarButton(HELPPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(HELPPOS)].fsState = TBSTATE_HIDDEN;
// remove a few seperators too:
tbbuttons[_IndexOfViewerToolbarButton(VIEWSEPPOS)].fsState = TBSTATE_HIDDEN;
tbbuttons[_IndexOfViewerToolbarButton(IMAGECMDSEPPOS)].fsState = TBSTATE_HIDDEN;
tbbuttons[_IndexOfViewerToolbarButton(PRINTSEPPOS)].fsState = TBSTATE_HIDDEN;
tbbuttons[_IndexOfViewerToolbarButton(HELPSEPPOS)].fsState = TBSTATE_HIDDEN;
}
if (m_fHidePrintBtn)
{
ASSERT(ID_PRINTCMD==tbbuttons[_IndexOfViewerToolbarButton(PRINTPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(PRINTPOS)].fsState = TBSTATE_HIDDEN;
}
if (m_fDisableEdit)
{
ASSERT(ID_ROTATESEP == tbbuttons[_IndexOfViewerToolbarButton(ROTATESEPPOS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ROTATESEPPOS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_ROTATE90CMD == tbbuttons[_IndexOfViewerToolbarButton(ROTATE90POS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ROTATE90POS)].fsState = TBSTATE_HIDDEN;
ASSERT(ID_ROTATE270CMD == tbbuttons[_IndexOfViewerToolbarButton(ROTATE270POS)].idCommand);
tbbuttons[_IndexOfViewerToolbarButton(ROTATE270POS)].fsState = TBSTATE_HIDDEN;
}
if (m_bRTLMirrored)
{
UINT uTmp = tbbuttons[_IndexOfViewerToolbarButton(PREVIMGPOS)].iBitmap;
tbbuttons[_IndexOfViewerToolbarButton(PREVIMGPOS)].iBitmap = tbbuttons[_IndexOfViewerToolbarButton(NEXTIMGPOS)].iBitmap;
tbbuttons[_IndexOfViewerToolbarButton(NEXTIMGPOS)].iBitmap = uTmp;
uTmp = tbbuttons[_IndexOfViewerToolbarButton(PREVPAGEPOS)].iBitmap;
tbbuttons[_IndexOfViewerToolbarButton(PREVPAGEPOS)].iBitmap = tbbuttons[_IndexOfViewerToolbarButton(NEXTPAGEPOS)].iBitmap;
tbbuttons[_IndexOfViewerToolbarButton(NEXTPAGEPOS)].iBitmap = uTmp;
}
// Add the buttons, and then set the minimum and maximum button widths.
::SendMessage(hwndTB, TB_ADDBUTTONS, ARRAYSIZE(tbbuttons), (LPARAM)tbbuttons);
// we just created the toolbar so we are now in the hidden state of the multipage buttons.
m_dwMultiPageMode = MPCMD_HIDDEN;
m_fCanAnnotate = FALSE;
m_fCanCrop = FALSE;
m_ctlToolbar.SubclassWindow(hwndTB);
return (NULL != hwndTB);
}
void CPreviewWnd::_InitializeToolbar(HWND hwndTB, int idLow, int idLowHot, int idHigh, int idHighHot)
{
int cxBitmap = 16, cyBitmap = 16;
::SendMessage(hwndTB, CCM_SETVERSION, COMCTL32_VERSION, 0);
::SendMessage (hwndTB, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_HIDECLIPPEDBUTTONS | TBSTYLE_EX_MIXEDBUTTONS | TBSTYLE_EX_DOUBLEBUFFER);
// Sets the size of the TBBUTTON structure.
::SendMessage(hwndTB, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
// Set the maximum number of text rows and bitmap size.
::SendMessage(hwndTB, TB_SETMAXTEXTROWS, 1, 0);
int nDepth = SHGetCurColorRes();
HIMAGELIST himl = ImageList_LoadImage(_Module.GetModuleInstance(),
(nDepth > 8) ? MAKEINTRESOURCE(idHigh) : MAKEINTRESOURCE(idLow),
cxBitmap, 0, RGB(0, 255, 0), IMAGE_BITMAP,
(nDepth > 8) ? LR_CREATEDIBSECTION : LR_DEFAULTCOLOR);
::SendMessage(hwndTB, TB_SETIMAGELIST, 0, (LPARAM)himl);
HIMAGELIST himlHot = ImageList_LoadImage(_Module.GetModuleInstance(),
(nDepth > 8) ? MAKEINTRESOURCE(idHighHot) : MAKEINTRESOURCE(idLowHot),
cxBitmap, 0, RGB(0, 255, 0), IMAGE_BITMAP,
(nDepth > 8) ? LR_CREATEDIBSECTION : LR_DEFAULTCOLOR);
::SendMessage(hwndTB, TB_SETHOTIMAGELIST, 0, (LPARAM)himlHot);
}
LRESULT CPreviewWnd::OnPrintClient(UINT , WPARAM wParam, LPARAM lParam, BOOL&)
{
COLORREF bgClr = m_ctlPreview.GetBackgroundColor();
RECT rcFill;
GetClientRect(&rcFill);
SHFillRectClr((HDC)wParam, &rcFill, bgClr);
return TRUE;
}
LRESULT CPreviewWnd::OnNeedText(int , LPNMHDR pnmh, BOOL&)
{
TOOLTIPTEXT *pTTT = (TOOLTIPTEXT *)pnmh;
// tooltip text messages have the same string ID as the control ID
pTTT->lpszText = MAKEINTRESOURCE(pTTT->hdr.idFrom);
pTTT->hinst = _Module.GetModuleInstance();
// Except in Control Mode due to a DUI Web View bug that's too hard to fix for Whistler...
if (CONTROL_MODE == m_dwMode)
{
// keyboard accelerators are broken, so swap IDs around for the few that display them
static const struct {
UINT idCommand;
UINT idsNewName;
} map[] = {
{ ID_PRINTCMD, IDS_PRINTCMD },
{ ID_ROTATE90CMD, IDS_ROTATE90CMD },
{ ID_ROTATE270CMD, IDS_ROTATE270CMD }};
for (int i = 0 ; i < ARRAYSIZE(map) ; i++)
{
if (map[i].idCommand == pTTT->hdr.idFrom)
{
pTTT->lpszText = MAKEINTRESOURCE(map[i].idsNewName);
break;
}
}
}
return TRUE;
}
LRESULT CPreviewWnd::OnDropDown(int id, LPNMHDR pnmh, BOOL&)
{
LPNMTOOLBAR pnmTB = (LPNMTOOLBAR)pnmh;
switch (pnmTB->iItem)
{
case ID_PAGELIST:
_DropDownPageList (pnmTB);
break;
default:
return TRUE;
}
return FALSE;
}
void CPreviewWnd::_DropDownPageList(LPNMTOOLBAR pnmTB)
{
HMENU hmenuPopup = CreatePopupMenu();
if (hmenuPopup)
{
for (DWORD i = 1; i <= m_pImageData->_cImages; i++)
{
TCHAR szBuffer[10];
wsprintf(szBuffer, TEXT("%d"), i);
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = i;
mii.dwTypeData = szBuffer;
InsertMenuItem (hmenuPopup, i-1, TRUE, &mii);
}
RECT rc;
::SendMessage(pnmTB->hdr.hwndFrom, TB_GETRECT, (WPARAM)pnmTB->iItem, (LPARAM)&rc);
::MapWindowPoints(pnmTB->hdr.hwndFrom, HWND_DESKTOP, (LPPOINT)&rc, 2);
TPMPARAMS tpm = { 0};
tpm.cbSize = sizeof(TPMPARAMS);
tpm.rcExclude = rc;
BOOL bRet = ::TrackPopupMenuEx(hmenuPopup,
TPM_RETURNCMD | TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL | TPM_NONOTIFY,
rc.left, rc.bottom,
m_hWnd, &tpm);
if (bRet)
{
if (m_fDirty)
{
m_ctlPreview.CommitAnnotations();
}
m_pImageData->SelectPage((LONG)bRet-1);
_UpdateImage();
_SetMultipageCommands();
}
DestroyMenu(hmenuPopup);
}
}
void CPreviewWnd::SetNotify(CEvents * pEvents)
{
m_pEvents = pEvents;
}
void CPreviewWnd::SetPalette(HPALETTE hpal)
{
m_hpal = hpal;
}
BOOL CPreviewWnd::GetPrintable()
{
return m_fPrintable;
}
LRESULT CPreviewWnd::OnWheelTurn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
// REVIEW: Shouldn't this just be translated into a command?
// this message is ALWAYS forwarded to the zoom window
m_ctlPreview.SendMessage(uMsg, wParam, lParam);
// Since we know that the mouse wheel will either ZoomIn or ZoomOut lets update the buttons if we are in Window Mode.
if (WINDOW_MODE == m_dwMode)
{
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(!m_ctlPreview.IsBestFit(), 0));
}
return 0;
}
BOOL CPreviewWnd::OnNonSlideShowTab()
{
BOOL fHandled = FALSE;
if ((SLIDESHOW_MODE != m_dwMode) && m_fShowToolbar)
{
if (GetFocus() != m_ctlToolbar.m_hWnd)
{
m_ctlToolbar.SetFocus();
m_ctlToolbar.SetActiveWindow();
m_ctlToolbar.SendMessage(TB_SETHOTITEM, 0, 0);
m_iSSToolbarSelect = 0;
fHandled = TRUE;
}
}
return fHandled;
}
// Forwards WM_KEYUP and WM_KEYDOWN events to the zoom window but only if they are keys
// that the zoom window cares about.
// Activates the slideshow toolbar if needed
LRESULT CPreviewWnd::OnKeyEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
MSG msg;
msg.hwnd = m_hWnd;
msg.message = uMsg;
msg.wParam = wParam;
msg.lParam = lParam;
GetCursorPos (&msg.pt);
fHandled = FALSE;
if (SLIDESHOW_MODE == m_dwMode)
{
if (WM_KEYDOWN == uMsg)
{
switch (wParam)
{
case VK_TAB:
OnSlideshowCommand(0, ID_PAUSECMD, NULL, fHandled);
ShowSSToolbar(TRUE);
KillTimer(TIMER_TOOLBAR);
m_ctlToolbar.SetFocus();
m_ctlToolbar.SendMessage(TB_SETHOTITEM, 0, 0);
m_iSSToolbarSelect = 0;
fHandled = TRUE;
break;
case VK_SPACE:
ShowSSToolbar(!m_fPaused); // if we are unpausing, hide the toolbar if it's shown. if we are pausing, show the toolbar
OnSlideshowCommand(0, m_fPaused ? ID_PLAYCMD : ID_PAUSECMD, NULL, fHandled);
break;
case VK_PRIOR: // PAGEUP
case VK_UP:
case VK_LEFT:
case VK_BACK: // BACKSPACE
OnSlideshowCommand(0, ID_PREVCMD, NULL, fHandled);
break;
case VK_NEXT: // PAGEDOWN
case VK_RIGHT:
case VK_DOWN:
case VK_RETURN: // ENTER
OnSlideshowCommand(0, ID_NEXTCMD, NULL, fHandled);
break;
case VK_DELETE:
_DeleteCurrentSlide();
fHandled = TRUE;
break;
case 'K':
if (0x8000 & GetKeyState(VK_CONTROL))
{
OnSlideshowCommand(0, ID_PAUSECMD, NULL, fHandled);
Rotate(90);
fHandled = TRUE;
}
break;
case 'L':
if (0x8000 & GetKeyState(VK_CONTROL))
{
OnSlideshowCommand(0, ID_PAUSECMD, NULL, fHandled);
Rotate(270);
fHandled = TRUE;
}
break;
case VK_ESCAPE:
PostMessage(m_fExitApp ? WM_QUIT : WM_CLOSE, 0, 0);
fHandled = TRUE;
break;
}
}
}
else if (!TranslateAccelerator(&msg)) // Only translate accelerators in the non-slideshow case
// Slideshow keys are handled explicitly above
{
switch (wParam)
{
case VK_SHIFT:
case VK_CONTROL:
case VK_PRIOR:
case VK_NEXT:
case VK_HOME:
case VK_END:
// these are forwarded to the zoom window
m_ctlPreview.SendMessage(uMsg, wParam, lParam);
break;
case VK_TAB:
fHandled = OnNonSlideShowTab();
break;
case VK_ESCAPE:
m_ctlPreview.SetMode(CZoomWnd::MODE_NOACTION);
_UpdateButtons(NOBUTTON);
fHandled = TRUE;
break;
}
}
return 0;
}
// OnTBKeyEvent
//
LRESULT CPreviewWnd::OnTBKeyEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
fHandled = FALSE;
if (SLIDESHOW_MODE == m_dwMode && m_fToolbarHidden)
{
ShowSSToolbar(TRUE);
m_ctlToolbar.SetFocus();
m_ctlToolbar.SendMessage(TB_SETHOTITEM, 0, 0);
m_iSSToolbarSelect = 0;
fHandled = TRUE;
}
else
{
switch (wParam)
{
case VK_ESCAPE:
if (WM_KEYDOWN == uMsg)
{
if (SLIDESHOW_MODE == m_dwMode)
{
PostMessage(m_fExitApp ? WM_QUIT : WM_CLOSE, 0, 0);
}
else
{
m_ctlPreview.SetMode(CZoomWnd::MODE_NOACTION);
_UpdateButtons(NOBUTTON);
SetFocus();
SetActiveWindow();
}
}
break;
case VK_SHIFT:
case VK_CONTROL:
case VK_PRIOR:
case VK_NEXT:
case VK_HOME:
case VK_END:
// these are forwarded to the zoom window
m_ctlPreview.SendMessage(uMsg, wParam, lParam);
break;
case VK_LEFT:
case VK_RIGHT:
if (WM_KEYDOWN == uMsg)
{
int iSel = (int)m_ctlToolbar.SendMessage(TB_GETHOTITEM, 0, 0);
int iSize = (int)m_ctlToolbar.SendMessage(TB_BUTTONCOUNT, 0, 0);
int iStepSize = (wParam == VK_RIGHT) ? 1 : iSize - 1; // ((pos + (size - 1)) % size) == left by 1
if (iSel != -1)
{
m_iSSToolbarSelect = iSel;
}
TBBUTTON tb = {0};
do
{
m_iSSToolbarSelect = (m_iSSToolbarSelect + iStepSize) % iSize;
m_ctlToolbar.SendMessage(TB_GETBUTTON, m_iSSToolbarSelect, (LPARAM)&tb);
}
while ((tb.fsStyle & TBSTYLE_SEP) || (tb.fsState & TBSTATE_HIDDEN) || !(tb.fsState & TBSTATE_ENABLED)); // don't stop on the separators
m_ctlToolbar.SendMessage(TB_SETHOTITEM, m_iSSToolbarSelect, 0);
fHandled = TRUE;
}
break;
case VK_RETURN:
case VK_SPACE:
if ((WM_KEYDOWN == uMsg) && (SLIDESHOW_MODE == m_dwMode))
{
// to "press" the button, get its command id and sendmessage on it
// TB_PRESSBUTTON doesn't work here, don't know why.
// m_ctlToolbar.SendMessage(TB_PRESSBUTTON, m_iSSToolbarSelect, MAKELONG(TRUE, 0));
TBBUTTON tbbutton;
if (m_ctlToolbar.SendMessage(TB_GETBUTTON, m_iSSToolbarSelect, (LPARAM)&tbbutton))
{
OnSlideshowCommand(0, (WORD)tbbutton.idCommand, NULL, fHandled);
}
fHandled = TRUE;
}
break;
case VK_TAB:
if ((WM_KEYDOWN == uMsg) && (CONTROL_MODE != m_dwMode))
{
// move focus back to the previewwnd
SetFocus();
fHandled = TRUE;
ShowSSToolbar(FALSE);
SetTimer(TIMER_TOOLBAR, m_uTimeout);
}
break;
default:
break;
}
}
return 0;
}
LRESULT CPreviewWnd::OnSysCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
fHandled = FALSE;
if ((SLIDESHOW_MODE == m_dwMode) &&
((SC_MONITORPOWER == wParam) || (SC_SCREENSAVE == wParam)))
{
fHandled = TRUE;
}
return 0;
}
HRESULT CPreviewWnd::_PreviewFromStream(IStream *pStream, UINT iItem, BOOL fUpdateCaption)
{
IRunnableTask * pTask;
if (fUpdateCaption)
{
// set the caption here in case decode fails
STATSTG stat;
if (SUCCEEDED(pStream->Stat(&stat, 0)))
{
SetCaptionInfo(stat.pwcsName);
CoTaskMemFree(stat.pwcsName);
}
else
{
SetCaptionInfo(NULL);
}
}
HRESULT hr = CDecodeTask::Create(pStream, NULL, iItem, m_pImageFactory, m_hWnd, &pTask);
if (SUCCEEDED(hr))
{
TASKOWNERID toid;
GetTaskIDFromMode(GTIDFM_DECODE, m_dwMode, &toid);
hr = m_pTaskScheduler->AddTask(pTask, toid, 0, ITSAT_DEFAULT_PRIORITY);
pTask->Release();
}
return hr;
}
HRESULT CPreviewWnd::_PreviewFromFile(LPCTSTR pszFile, UINT iItem, BOOL fUpdateCaption)
{
IRunnableTask * pTask;
if (fUpdateCaption)
{
// set the caption here in case decode fails
SetCaptionInfo(pszFile);
}
HRESULT hr = CDecodeTask::Create(NULL, pszFile, iItem, m_pImageFactory, m_hWnd, &pTask);
if (SUCCEEDED(hr))
{
TASKOWNERID toid;
GetTaskIDFromMode(GTIDFM_DECODE, m_dwMode, &toid);
hr = m_pTaskScheduler->AddTask(pTask, toid, 0, ITSAT_DEFAULT_PRIORITY);
pTask->Release();
}
return hr;
}
#define SLIDESHOW_CURSOR_NOTBUSY 0x0
#define SLIDESHOW_CURSOR_BUSY 0x1
#define SLIDESHOW_CURSOR_HIDDEN 0x2
#define SLIDESHOW_CURSOR_NORMAL 0x3
#define SLIDESHOW_CURSOR_CURRENT 0x4
void CPreviewWnd::SetCursorState(DWORD dwType)
{
switch (dwType)
{
case SLIDESHOW_CURSOR_NOTBUSY:
KillTimer(TIMER_BUSYCURSOR);
if (m_fBusy) // ignore multiple NOTBUSY, which we receive for the precaching
{
m_hCurrent = m_hCurOld;
SetCursor(m_hCurrent);
m_fBusy = FALSE;
}
break;
case SLIDESHOW_CURSOR_BUSY:
if (!m_fBusy)
{
m_hCurrent = LoadCursor(NULL, IDC_APPSTARTING);
m_hCurOld = SetCursor(m_hCurrent);
m_fBusy = TRUE;
}
break;
case SLIDESHOW_CURSOR_HIDDEN:
m_hCurOld = NULL;
if (!m_fBusy)
{
m_hCurrent = m_hCurOld;
SetCursor(m_hCurrent);
}
break;
case SLIDESHOW_CURSOR_NORMAL:
m_hCurOld = LoadCursor(NULL, IDC_ARROW);
if (!m_fBusy)
{
m_hCurrent = m_hCurOld;
SetCursor(m_hCurrent);
}
break;
case SLIDESHOW_CURSOR_CURRENT:
SetCursor(m_hCurrent);
break;
}
}
LRESULT CPreviewWnd::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
if (TIMER_ANIMATION == wParam)
{
KillTimer(TIMER_ANIMATION);
if (m_pImageData && m_pImageData->IsAnimated() && _ShouldDisplayAnimations()) // might have switched pages between timer calls
{
if (m_pImageData->NextFrame())
{
SetTimer(TIMER_ANIMATION, m_pImageData->GetDelay());
// paint the new image
_UpdateImage();
}
}
}
else if (TIMER_DATAOBJECT == wParam)
{
KillTimer(TIMER_DATAOBJECT); // on shot timer
if (_pdtobj)
{
PreviewItemsFromUnk(_pdtobj);
ATOMICRELEASE(_pdtobj);
}
}
else if (TIMER_BUSYCURSOR == wParam)
{
SetCursorState(SLIDESHOW_CURSOR_BUSY);
}
else if (SLIDESHOW_MODE == m_dwMode)
{
if (TIMER_SLIDESHOW == wParam)
{
_ShowNextSlide(FALSE); // always go forward?
}
else if (TIMER_TOOLBAR == wParam && !m_fIgnoreUITimers)
{
KillTimer(TIMER_TOOLBAR);
ShowSSToolbar(FALSE);
}
}
return 0;
}
void CPreviewWnd::ShowSSToolbar(BOOL bShow, BOOL fForce /*=FALSE*/)
{
if (SLIDESHOW_MODE == m_dwMode)
{
if (fForce)
{
POINT pt;
RECT rc;
GetCursorPos(&pt);
GetWindowRect(&rc);
if (PtInRect(&rc, pt))
{
g_x = pt.x;
g_y = pt.y;
}
}
if (!bShow)
{
if (!m_fToolbarHidden || fForce)
{
//AnimateWindow(m_ctlToolbar.m_hWnd, 200, AW_VER_NEGATIVE | AW_SLIDE | AW_HIDE);
m_ctlToolbar.SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
m_fToolbarHidden = TRUE;
m_ctlToolbar.SendMessage(TB_SETHOTITEM, -1, 0);
SetCursorState(SLIDESHOW_CURSOR_HIDDEN);
}
}
else
{
KillTimer(TIMER_TOOLBAR);
if (m_fToolbarHidden || fForce)
{
//AnimateWindow(m_ctlToolbar.m_hWnd, 200, AW_VER_POSITIVE | AW_SLIDE | AW_ACTIVATE);
m_ctlToolbar.SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
m_fToolbarHidden = FALSE;
SetCursorState(SLIDESHOW_CURSOR_NORMAL);
}
SetTimer(TIMER_TOOLBAR, m_uTimeout);
}
}
}
void CPreviewWnd::OnDraw(HDC hdc)
{
if (m_fCropping)
{
CSelectionTracker tracker;
_SetupCroppingTracker(tracker);
CRect rectImage(0, 0, m_ctlPreview.m_cxImage, m_ctlPreview.m_cyImage);
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rectImage, 2);
CRect rectCrop = m_rectCropping;
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rectCrop, 2);
HRGN hrgn = ::CreateRectRgn(0, 0, 0, 0);
if (hrgn != NULL)
{
HRGN hrgnImage = ::CreateRectRgnIndirect(rectImage);
if (hrgnImage != NULL)
{
HRGN hrgnCrop = ::CreateRectRgnIndirect(rectCrop);
if (hrgnCrop != NULL)
{
if (ERROR != ::CombineRgn(hrgn, hrgnImage, hrgnCrop, RGN_DIFF))
{
::InvertRgn(hdc, hrgn);
}
::DeleteObject(hrgnCrop);
}
::DeleteObject(hrgnImage);
}
::DeleteObject(hrgn);
}
tracker.Draw(hdc);
}
else
{
if (m_fAnnotating)
{
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker);
tracker.Draw(hdc);
}
}
}
}
void CPreviewWnd::OnDrawComplete()
{
if (SLIDESHOW_MODE == m_dwMode)
{
if (!m_fPaused)
SetTimer(TIMER_SLIDESHOW, m_uTimeout);
SetCursorState(SLIDESHOW_CURSOR_NOTBUSY);
}
}
BOOL CPreviewWnd::OnMouseDown(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (SLIDESHOW_MODE == m_dwMode)
{
if (uMsg == WM_LBUTTONDOWN)
{
_ShowNextSlide(FALSE); // advance the slide (param is "go back?")
return TRUE;
}
}
else
{
if (m_fCropping)
return _OnMouseDownForCropping(uMsg, wParam, lParam);
else
return _OnMouseDownForAnnotating(uMsg, wParam, lParam);
}
return FALSE;
}
BOOL CPreviewWnd::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (SLIDESHOW_MODE == m_dwMode)
{
int xPos = GET_X_LPARAM(lParam);
int yPos = GET_Y_LPARAM(lParam);
int dx = xPos > g_x ? xPos - g_x : g_x - xPos;
int dy = yPos > g_y ? yPos - g_y : g_y - yPos;
if (dx > 10 || dy > 10)
{
ShowSSToolbar(TRUE);
}
g_x = xPos;
g_y = yPos;
}
return TRUE;
}
LRESULT CPreviewWnd::OnTBMouseLeave(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
if (SLIDESHOW_MODE == m_dwMode)
{
m_fTBTrack = FALSE;
ShowSSToolbar(TRUE);
}
fHandled = FALSE;
return 0;
}
LRESULT CPreviewWnd::OnTBMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
if (SLIDESHOW_MODE == m_dwMode)
{
if (!m_fTBTrack)
{
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = m_ctlToolbar.m_hWnd;
TrackMouseEvent(&tme);
ShowSSToolbar(TRUE);
KillTimer(TIMER_TOOLBAR); // we keep the toolbar down for as long as mouse is over it
m_fTBTrack = TRUE;
}
}
fHandled = FALSE;
return 0;
}
BOOL CPreviewWnd::OnSetCursor(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (SLIDESHOW_MODE == m_dwMode)
{
if (m_fToolbarHidden)
{
SetCursorState(SLIDESHOW_CURSOR_HIDDEN);
}
else
{
SetCursorState(SLIDESHOW_CURSOR_NORMAL);
}
return TRUE;
}
else if (m_fAnnotating)
{
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker);
if (tracker.SetCursor(m_ctlPreview.m_hWnd, lParam))
return TRUE;
}
SetCursor(LoadCursor(NULL, IDC_ARROW));
return TRUE;
}
else if (m_fCropping)
{
CSelectionTracker tracker;
_SetupCroppingTracker(tracker);
if (tracker.SetCursor(m_ctlPreview.m_hWnd, lParam))
return TRUE;
SetCursor(LoadCursor(NULL, IDC_ARROW));
return TRUE;
}
return FALSE;
}
BOOL CPreviewWnd::GetColor(COLORREF * pref)
{
*pref = 0; // black
if (SLIDESHOW_MODE == m_dwMode)
{
return TRUE;
}
return FALSE;
}
BOOL CPreviewWnd::OnSetColor(HDC hdc)
{
if (SLIDESHOW_MODE == m_dwMode)
{
SetBkColor(hdc, 0); // black
SetTextColor(hdc, 0xffffff); // white
return TRUE;
}
return FALSE;
}
// IObjectWithSite
HRESULT CPreviewWnd::SetSite(IUnknown *punk)
{
IUnknown_Set(&m_punkSite, punk);
if (m_pcwndSlideShow)
{
m_pcwndSlideShow->SetSite(punk);
}
return S_OK;
}
// This function take the name of the file being previewed and converts it into a
// title for the Full Screen Preview window. In converting the title it take into
// account user preference settings for how to display the filename.
void CPreviewWnd::SetCaptionInfo(LPCTSTR pszPath)
{
TCHAR szTitle[MAX_PATH] = TEXT("");
TCHAR szDisplayName[MAX_PATH] = TEXT("");
SHFILEINFO sfi = {0};
//
// Default to pszPath for the caption
// pszPath is non-null before the decode is attempted
if (pszPath)
{
if (SHGetFileInfo(pszPath, 0, &sfi, sizeof(sfi), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES))
{
StrCpyN(szTitle, sfi.szDisplayName, ARRAYSIZE(szTitle));
StrCatBuff(szTitle, TEXT(" - "), ARRAYSIZE(szTitle));
}
}
TCHAR szApp[64];
szApp[0] = 0;
LoadString(_Module.GetModuleInstance(), IDS_PROJNAME, szApp, ARRAYSIZE(szApp));
StrCatBuff(szTitle, szApp, ARRAYSIZE(szTitle));
SetWindowText(szTitle);
}
LRESULT CPreviewWnd::OnDestroy(UINT , WPARAM , LPARAM , BOOL& fHandled)
{
RevokeDragDrop(m_hWnd);
_RegisterForChangeNotify(FALSE);
FlushBitmapMessages();
fHandled = FALSE;
// Make sure we don't leak icons
ReplaceWindowIcon(m_hWnd, ICON_SMALL, NULL);
ReplaceWindowIcon(m_hWnd, ICON_BIG, NULL);
// release the image lists used by the toolbar.
HWND hwndTB = m_ctlToolbar.m_hWnd;
HIMAGELIST himl = (HIMAGELIST)::SendMessage(hwndTB, TB_GETHOTIMAGELIST, 0, 0);
::SendMessage(hwndTB, TB_SETHOTIMAGELIST, 0, NULL);
ImageList_Destroy(himl);
himl = (HIMAGELIST)::SendMessage(hwndTB, TB_GETIMAGELIST, 0, 0);
::SendMessage(hwndTB, TB_SETIMAGELIST, 0, NULL);
ImageList_Destroy(himl);
if (WINDOW_MODE == m_dwMode)
{
WINDOWPLACEMENT wp;
wp.length = sizeof(wp);
if (GetWindowPlacement(&wp))
{
HKEY hk;
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, REGSTR_SHIMGVW, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE,
NULL, &hk, NULL))
{
RegSetValueEx(hk, REGSTR_BOUNDS, NULL, REG_BINARY,
(BYTE*)&wp.rcNormalPosition, sizeof(wp.rcNormalPosition));
BOOL fIsMaximized = (wp.showCmd == SW_SHOWMAXIMIZED);
RegSetValueEx(hk, REGSTR_MAXIMIZED, NULL, REG_BINARY,
(BYTE*)&fIsMaximized, sizeof(fIsMaximized));
RegCloseKey(hk);
}
}
PostQuitMessage(0);
}
return 0;
}
HRESULT CPreviewWnd::GetCurrentIDList(LPITEMIDLIST *ppidl)
{
HRESULT hr = _GetItem(m_iCurSlide, ppidl);
if (FAILED(hr))
{
TCHAR szPath[MAX_PATH];
hr = PathFromImageData(szPath, ARRAYSIZE(szPath));
if (SUCCEEDED(hr))
{
hr = SHILCreateFromPath(szPath, ppidl, NULL);
}
}
return hr;
}
void CPreviewWnd::MenuPoint(LPARAM lParam, int *px, int *py)
{
if (-1 == lParam)
{
// message is from the keyboard, figure out where to place the window
RECT rc;
::GetWindowRect(m_hWnd, &rc);
*px = ((rc.left + rc.right) / 2);
*py = ((rc.top + rc.bottom) / 2);
}
else
{
*px = GET_X_LPARAM(lParam);
*py = GET_Y_LPARAM(lParam);
}
}
#define ID_FIRST 1 // Context Menu ID's
#define ID_LAST 0x7fff
LRESULT CPreviewWnd::OnContextMenu(UINT , WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
if (!m_fAllowContextMenu)
return 0;
if (m_fCanAnnotate && m_fAnnotating && DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
HMENU hpopup = CreatePopupMenu();
if (hpopup)
{
CComBSTR bstrDelete;
CComBSTR bstrProperties;
if (bstrDelete.LoadString(IDS_DELETECMD) &&
bstrProperties.LoadString(IDS_PROPERTIESCMD))
{
if (AppendMenu(hpopup, MF_STRING, ID_DELETECMD, bstrDelete) &&
AppendMenu(hpopup, MF_STRING, ID_PROPERTIESCMD, bstrProperties))
{
int x, y;
MenuPoint(lParam, &x, &y);
TrackPopupMenu(hpopup, TPM_RIGHTBUTTON | TPM_LEFTALIGN, x, y, 0, m_hWnd, NULL);
}
}
DestroyMenu(hpopup);
}
return 0;
}
LPITEMIDLIST pidl;
HRESULT hr = GetCurrentIDList(&pidl); // gets the dynamically generated title for this window
if (SUCCEEDED(hr))
{
IContextMenu *pcm;
hr = SHGetUIObjectFromFullPIDL(pidl, NULL, IID_PPV_ARG(IContextMenu, &pcm));
if (SUCCEEDED(hr))
{
HMENU hpopup = CreatePopupMenu();
if (hpopup)
{
// SetSite required if you want in place navigation
IUnknown_SetSite(pcm, SAFECAST(this, IServiceProvider *));
hr = pcm->QueryContextMenu(hpopup, 0, ID_FIRST, ID_LAST, CMF_NORMAL);
if (SUCCEEDED(hr))
{
int x, y;
MenuPoint(lParam, &x, &y);
ASSERT(_pcm3 == NULL);
pcm->QueryInterface(IID_PPV_ARG(IContextMenu3, &_pcm3));
// if there's a separator after "copy", remove it
UINT uCopy = GetMenuIndexForCanonicalVerb(hpopup, pcm,ID_FIRST, L"copy");
if (uCopy != -1)
{
UINT uState = GetMenuState(hpopup, uCopy+1, MF_BYPOSITION);
if (-1 != uState && (uState & MF_SEPARATOR))
{
RemoveMenu(hpopup, uCopy+1, MF_BYPOSITION);
}
}
ContextMenu_DeleteCommandByName(pcm, hpopup, ID_FIRST, L"link");
ContextMenu_DeleteCommandByName(pcm, hpopup, ID_FIRST, L"cut");
ContextMenu_DeleteCommandByName(pcm, hpopup, ID_FIRST, L"copy");
// the shell may have added a static Preview verb
ContextMenu_DeleteCommandByName(pcm, hpopup, ID_FIRST, L"open");
if (!m_fPaused)
{
TogglePlayState();
}
if (SLIDESHOW_MODE == m_dwMode)
{
m_fIgnoreUITimers = TRUE;
}
int idCmd = TrackPopupMenu(hpopup, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
x, y, 0, m_hWnd, NULL);
ATOMICRELEASE(_pcm3);
if (idCmd > 0)
{
CMINVOKECOMMANDINFO cmdInfo =
{
sizeof(cmdInfo),
0,
m_hWnd,
(LPSTR)MAKEINTRESOURCE(idCmd - ID_FIRST),
NULL,
NULL,
SW_NORMAL
};
TCHAR szCommandString[40] = TEXT("");
ContextMenu_GetCommandStringVerb(pcm, idCmd - ID_FIRST, szCommandString, ARRAYSIZE(szCommandString));
if (lstrcmpi(szCommandString, TEXT("edit")) == 0)
{
hr = _SaveIfDirty(TRUE);
if (S_OK != hr)
{
hr = E_ABORT;
}
}
if (SUCCEEDED(hr))
{
if (lstrcmpi(szCommandString, TEXT("print")) == 0)
{
_RefreshSelection(FALSE);
_InvokePrintWizard();
}
else
{
hr = pcm->InvokeCommand(&cmdInfo);
}
}
if (SUCCEEDED(hr))
{
if (lstrcmpi(szCommandString, TEXT("delete")) == 0)
{
_RemoveFromArray(m_iCurSlide);
_ShowNextSlide(FALSE);
}
else if (lstrcmpi(szCommandString, TEXT("edit")) == 0)
{
m_fDirty = FALSE;
m_fNoRestore = TRUE;
// RAID 414238: Image Preview Control
// Context menu "&Edit" causes image preview window
// to close, wrecking Explorer when in 'control mode'.
if (m_dwMode != CONTROL_MODE)
{
PostMessage(WM_CLOSE, 0, 0);
}
}
}
}
if (SLIDESHOW_MODE == m_dwMode)
{
SetTimer(TIMER_TOOLBAR, m_uTimeout);
m_fIgnoreUITimers = FALSE;
}
}
IUnknown_SetSite(pcm, NULL);
DestroyMenu(hpopup);
}
pcm->Release();
}
ILFree(pidl);
}
return 0;
}
int ClearCB(void *p, void *pData)
{
SHFree(p);
return 1;
}
void CPreviewWnd::_ClearDPA()
{
if (m_ppidls)
{
for (UINT i = 0; i < m_cItems; i++)
ILFree(m_ppidls[i]);
CoTaskMemFree(m_ppidls);
m_ppidls = NULL;
}
m_cItems = 0;
m_iCurSlide = 0;
}
HRESULT CPreviewWnd::SetWallpaper(BSTR pszPath)
{
return SUCCEEDED(SetWallpaperHelper(pszPath)) ? S_OK : S_FALSE;
}
HRESULT CPreviewWnd::StartSlideShow(IUnknown *punkToView)
{
HRESULT hr = E_FAIL;
if (NULL == punkToView)
punkToView = m_punkSite;
if (SLIDESHOW_MODE == m_dwMode)
{
// these are required for slideshow
KillTimer(TIMER_SLIDESHOW);
SetCursorState(SLIDESHOW_CURSOR_HIDDEN);
m_fGoBack = FALSE;
// if slide show was reopened cancel any previous tracking
TRACKMOUSEEVENT tme = {0};
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_CANCEL | TME_LEAVE;
tme.hwndTrack = m_ctlToolbar.m_hWnd;
TrackMouseEvent(&tme);
m_fTBTrack = FALSE;
if (punkToView)
hr = PreviewItemsFromUnk(punkToView);
else
hr = _PreviewItem(m_iCurSlide);
if (SUCCEEDED(hr))
m_fPaused = FALSE;
}
else
{
//create the slide show window
// Full Screen
if (m_pcwndSlideShow && m_pcwndSlideShow->m_hWnd)
{
RestoreAndActivate(m_pcwndSlideShow->m_hWnd);
}
else
{
// create the window
if (!m_pcwndSlideShow)
{
m_pcwndSlideShow = new CPreviewWnd();
if (!m_pcwndSlideShow)
{
// out of memory
return E_OUTOFMEMORY;
}
else
{
if (FAILED(m_pcwndSlideShow->Initialize(this, SLIDESHOW_MODE, FALSE)))
{
return E_OUTOFMEMORY;
}
}
}
m_pcwndSlideShow->m_iCurSlide = m_iCurSlide; // so the slide show stays in sync
RECT rc = { 0,0,GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)};
m_pcwndSlideShow->Create(NULL, rc, NULL, WS_VISIBLE | WS_POPUP);
}
hr = m_pcwndSlideShow->StartSlideShow(NULL);
}
return hr;
}
HRESULT CPreviewWnd::_GetItem(UINT iItem, LPITEMIDLIST *ppidl)
{
HRESULT hr = E_FAIL;
if (iItem < m_cItems)
{
hr = SHILClone(m_ppidls[iItem], ppidl);
}
return hr;
}
void CPreviewWnd::_RemoveFromArray(UINT iItem)
{
if (iItem < m_cItems)
{
ILFree(m_ppidls[iItem]); // this one is now gone
// slide all other pidls down in the array
for (UINT i = iItem + 1; i < m_cItems; i++)
{
m_ppidls[i - 1] = m_ppidls[i];
}
m_cItems--;
m_ppidls[m_cItems] = NULL; // make sure stale ptr is now NULL
// if we deleted an item before m_iCurSlide then we must adjust m_iCurSlide
if (iItem < m_iCurSlide)
{
m_iCurSlide--;
}
else if (m_iCurSlide == m_cItems)
{
m_iCurSlide = 0;
}
// Now prepare for "ShowNextSlide"
if (!m_iCurSlide)
{
m_iCurSlide = m_cItems ? m_cItems-1 : 0;
}
else
{
m_iCurSlide--;
}
// make sure the prefetch task has the right index
if (m_pNextImageData)
{
if (!(m_pNextImageData->_iItem) && iItem && m_cItems)
{
m_pNextImageData->_iItem = m_cItems-1;
}
else if (m_pNextImageData->_iItem > iItem)
{
m_pNextImageData->_iItem--;
}
else
{
FlushBitmapMessages();
ATOMICRELEASE(m_pNextImageData);
}
}
}
}
HRESULT CPreviewWnd::_DeleteCurrentSlide()
{
LPITEMIDLIST pidl;
HRESULT hr = _GetItem(m_iCurSlide, &pidl);
if (SUCCEEDED(hr))
{
TCHAR szPath[MAX_PATH + 1] = {0}; // +1 and zero init for dbl NULL terminate extra terminator
DWORD dwAttribs = SFGAO_FILESYSTEM | SFGAO_STREAM;
hr = SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath)-1, &dwAttribs);
if (SUCCEEDED(hr))
{
BOOL fSuccess = TRUE;
if (dwAttribs & SFGAO_FILESYSTEM)
{
SHFILEOPSTRUCT fo = {0};
fo.hwnd = m_hWnd;
fo.wFunc = FO_DELETE;
fo.pFrom = szPath;
fo.fFlags = FOF_ALLOWUNDO;
fo.fAnyOperationsAborted = FALSE;
if (SHFileOperation(&fo) == ERROR_SUCCESS)
{
if (fo.fAnyOperationsAborted == TRUE)
fSuccess = FALSE;
}
}
else
{
_InvokeVerb(TEXT("delete"));
// We have to assume success since there is no way to know if the user
// cancelled the confirmation dialog without hitting the camera again.
}
if (fSuccess)
{
m_fDirty = FALSE;
_RemoveFromArray(m_iCurSlide);
_ShowNextSlide(FALSE);
}
}
ILFree(pidl);
}
return hr;
}
// index can be either current or next slide so that user can click multiple times on next/prev button
HRESULT CPreviewWnd::_ShowNextSlide(BOOL bGoBack)
{
HRESULT hr = E_FAIL;
if (m_cItems)
{
if (bGoBack)
{
if (m_iCurSlide)
m_iCurSlide--;
else
m_iCurSlide = m_cItems - 1;
}
else
{
m_iCurSlide++;
if (m_iCurSlide >= m_cItems)
m_iCurSlide = 0;
}
if (!m_fPaused)
{
SetTimer(TIMER_SLIDESHOW, m_uTimeout);
}
SetTimer(TIMER_BUSYCURSOR, 500);
LPITEMIDLIST pidl;
// set the caption in case the load fails
if (SUCCEEDED(_GetItem(m_iCurSlide, &pidl)))
{
TCHAR szPath[MAX_PATH];
if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, szPath, ARRAYSIZE(szPath)-1, NULL)))
{
SetCaptionInfo(szPath);
}
else
{
SetCaptionInfo(NULL);
}
ILFree(pidl);
}
hr = _PreviewItem(m_iCurSlide);
if (SUCCEEDED(hr))
{
_PreLoadItem((m_iCurSlide + 1) % m_cItems);
}
}
return hr;
}
HRESULT CPreviewWnd::_StartDecode(UINT iItem, BOOL fUpdateCaption)
{
LPITEMIDLIST pidl;
HRESULT hr = _GetItem(iItem, &pidl);
if (SUCCEEDED(hr))
{
TCHAR szPath[MAX_PATH];
DWORD dwAttribs = SFGAO_FILESYSTEM | SFGAO_STREAM;
hr = SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), &dwAttribs);
if (SUCCEEDED(hr) && (dwAttribs & SFGAO_FILESYSTEM))
{
hr = _PreviewFromFile(szPath, iItem, fUpdateCaption);
}
else if (dwAttribs & SFGAO_STREAM)
{
// this might not be a file system object, try to bind to it via IStream
IStream *pstrm;
hr = SHBindToObject(NULL, IID_X_PPV_ARG(IStream, pidl, &pstrm));
if (SUCCEEDED(hr))
{
hr = _PreviewFromStream(pstrm, iItem, fUpdateCaption);
pstrm->Release();
}
}
else
{
// funky attributes?
hr = S_FALSE;
}
ILFree(pidl);
}
return hr;
}
HRESULT CPreviewWnd::_PreLoadItem(UINT iItem)
{
HRESULT hr = _StartDecode(iItem, FALSE);
if (SUCCEEDED(hr))
{
m_iDecodingNextImage = iItem;
}
return hr;
}
HRESULT CPreviewWnd::_PreviewItem(UINT iItem)
{
HRESULT hr = S_OK;
if ((SLIDESHOW_MODE == m_dwMode) && (0 == m_cItems)) // if no more items, user just deleted the last one, so quit the slideshow
{
_CloseSlideshowWindow();
}
else
{
if (!_TrySetImage())
{
// If we are not currently already decoding this item, let's get cranking!
if (m_iDecodingNextImage != iItem)
{
hr = _StartDecode(iItem, TRUE);
}
StatusUpdate((S_OK == hr) ? IDS_LOADING : IDS_LOADFAILED);
}
}
return hr;
}
int CPreviewWnd::TranslateAccelerator(MSG *pmsg)
{
if (IsVK_TABCycler(pmsg))
{
if (OnNonSlideShowTab())
{
return TRUE;
}
}
else if (m_haccel)
{
ASSERT(m_hWnd);
return ::TranslateAccelerator(m_hWnd, m_haccel, pmsg);
}
return FALSE;
}
// Sent when the image generation status has changed, once when the image is first
// being created and again if there is an error of any kind. This should invalidate
// and free any left over bitmap and the cached copy of the previous m_ImgCtx
void CPreviewWnd::StatusUpdate(int iStatus)
{
if (m_pImageData)
{
m_pImageData->Release();
m_pImageData = NULL;
}
//
// the caption is set at the first attempt to load an image
m_ctlPreview.StatusUpdate(iStatus);
_SetMultipageCommands();
_SetMultiImagesCommands();
_SetAnnotatingCommands(FALSE);
_SetEditCommands();
m_fPrintable = FALSE;
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PRINTCMD, MAKELONG(m_fPrintable, 0));
// update our toolbar
BOOL fHandled;
OnSize(0x0, 0, 0, fHandled);
}
// Return:
// S_OK walk succeeded, image files found to preview: display new images in preview
// S_FALSE walk cancelled (by user): display existing image in preview (no change)
// E_XXXX walk failed: display no image in preview
//
HRESULT CPreviewWnd::WalkItemsToPreview(IUnknown* punk)
{
HRESULT hr = _SaveIfDirty(TRUE);
if (FAILED(hr) || hr == S_FALSE)
return hr;
m_fFirstItem = TRUE;
_ClearDPA(); // clean up old stuff
INamespaceWalk *pnsw;
hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC, IID_PPV_ARG(INamespaceWalk, &pnsw));
if (SUCCEEDED(hr))
{
// in control mode we only dislay one item at a time. lets setup our
// state so this can work just like the other modes
DWORD dwFlags = (CONTROL_MODE == m_dwMode) ? 0 : NSWF_ONE_IMPLIES_ALL | NSWF_NONE_IMPLIES_ALL;
m_fClosed = FALSE;
hr = pnsw->Walk(punk, dwFlags, m_cWalkDepth, SAFECAST(this, INamespaceWalkCB *));
// the window might have been closed during the namespace walk
if (WINDOW_MODE == m_dwMode && m_fClosed)
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
hr = pnsw->GetIDArrayResult(&m_cItems, &m_ppidls);
if (SUCCEEDED(hr) && (m_dwMode == WINDOW_MODE) && m_cItems && m_fFirstTime)
{
m_fFirstTime = FALSE;
SHAddToRecentDocs(SHARD_PIDL, m_ppidls[0]);
}
}
pnsw->Release();
}
// Clarification of INamespaceWalk return values:
// S_OK walk has succeeded, and image files found to preview
// S_FALSE walk has succeeded, but no image files found to preview
// **** convert to E_FAIL to keep in line with return of function
// E_XXXX walk has failed
//
return hr == S_FALSE ? E_FAIL : hr;
}
void CPreviewWnd::PreviewItems()
{
if (WINDOW_MODE == m_dwMode)
{
RestoreAndActivate(m_hWnd);
}
_PreviewItem(0);
if (SLIDESHOW_MODE == m_dwMode)
{
if (m_cItems > 1)
{
_PreLoadItem(1);
}
}
}
// build the _ppidl and m_cItems members and preview the first one
HRESULT CPreviewWnd::PreviewItemsFromUnk(IUnknown *punk)
{
HRESULT hr = WalkItemsToPreview(punk);
if (SUCCEEDED(hr))
{
if (S_FALSE != hr)
PreviewItems();
}
else
{
StatusUpdate(IDS_LOADFAILED);
}
return hr;
}
// If the "new" image is the same as the old image, and the old image was recently edited then we assume that
// the reason we are getting a new ShowFile request is due to an FSChangeNotify on the file. We also assume
// that we are the cause of this change notify. Further we assume that we already have the correctly decoded
// image still ready. These are assumptions which might not be TRUE 100%, in which case we will do really
// strange things, but they should be TRUE 99.9% of the time which is considered "good enough". The reason we
// make these dangerous assumptions is to prevent decoding the image again and thus flickering between the
// old image, the "generating preview..." message, and the new (identical) image.
BOOL CPreviewWnd::_ReShowingSameFile(LPCTSTR pszNewFile)
{
BOOL bIsSameFile = FALSE;
if (m_pImageData)
{
if (pszNewFile && m_fWasEdited)
{
m_fWasEdited = FALSE;
TCHAR szOldPath[MAX_PATH];
if ((S_OK == PathFromImageData(szOldPath, ARRAYSIZE(szOldPath))) &&
(0 == StrCmpI(szOldPath, pszNewFile)))
{
if (m_pEvents)
m_pEvents->OnPreviewReady();
bIsSameFile = TRUE;
}
}
if (!bIsSameFile)
{
m_pImageData->Release(); // need to start clean
m_pImageData = NULL;
}
}
return bIsSameFile;
}
// pszFile may be NULL. cItems expresses how many are selected so we can
// display "multiple items selected" and not display anything.
LRESULT CPreviewWnd::ShowFile(LPCTSTR pszFile, UINT cItems, BOOL fReshow)
{
if (!m_hWnd)
return S_FALSE;
HRESULT hr = S_FALSE;
TCHAR szLongName[MAX_PATH]; // short file names are UGLY
if (GetLongPathName(pszFile, szLongName, ARRAYSIZE(szLongName)))
{
pszFile = szLongName;
}
if (!fReshow && _ReShowingSameFile(pszFile))
return S_FALSE;
// It is possible that there is already a bitmap message in our queue from the previous rendering.
// If this is the case we should remove that message and release its bitmap before we continue.
// If we do not then that message will get processed and will send the OnPreviewReady event to the
// obejct container but this event might no longer be valid.
FlushBitmapMessages();
if (pszFile && *pszFile)
{
IDataObject *pdtobj;
hr = GetUIObjectFromPath(pszFile, IID_PPV_ARG(IDataObject, &pdtobj));
if (SUCCEEDED(hr))
{
hr = PreviewItemsFromUnk(pdtobj);
m_fPaused = TRUE;
pdtobj->Release();
}
}
else
{
int iRetCode = (cItems > 1) ? IDS_MULTISELECT : IDS_NOPREVIEW;
// Set the Return Code into all owned zoom windows. This instructs these windows to disregard
// their previous images and display the status message instead.
StatusUpdate(iRetCode);
}
return hr;
}
LRESULT CPreviewWnd::IV_OnIVScroll(UINT , WPARAM , LPARAM lParam, BOOL&)
{
DWORD nHCode = LOWORD(lParam);
DWORD nVCode = HIWORD(lParam);
if (nHCode)
{
m_ctlPreview.SendMessage(WM_HSCROLL, nHCode, NULL);
}
if (nVCode)
{
m_ctlPreview.SendMessage(WM_VSCROLL, nVCode, NULL);
}
return 0;
}
// IV_OnSetOptions
//
// This message is sent to turn on or off all the optional features of the image preview control.
// NOTE: When used as a control this function is called BEFORE the window is created. Don't do
// anything in this function that will fail without a window unless you check for this condition.
LRESULT CPreviewWnd::IV_OnSetOptions(UINT , WPARAM wParam, LPARAM lParam, BOOL&)
{
BOOL bResult = TRUE;
// Boolify lParam just to be safe.
lParam = lParam ? 1:0;
switch (wParam)
{
case IVO_TOOLBAR:
if ((BOOL)lParam != m_fShowToolbar)
{
m_fShowToolbar = (BOOL)lParam;
if (m_hWnd)
{
if (m_fShowToolbar)
{
if (!m_ctlToolbar)
{
bResult = CreateToolbar();
if (!bResult)
{
m_fShowToolbar = FALSE;
break;
}
}
}
else
{
if (m_ctlToolbar)
{
m_ctlToolbar.DestroyWindow();
}
}
}
}
break;
case IVO_PRINTBTN:
if ((BOOL)lParam != m_fHidePrintBtn)
{
m_fHidePrintBtn = (BOOL)lParam;
if (m_hWnd && m_ctlToolbar)
{
m_ctlToolbar.SendMessage(TB_HIDEBUTTON,ID_PRINTCMD,lParam);
}
}
break;
case IVO_CONTEXTMENU:
m_fAllowContextMenu = (BOOL)lParam;
break;
case IVO_PRINTABLE:
TraceMsg(TF_WARNING, "Obsolete IVO_PRINTABLE option received.");
break;
case IVO_DISABLEEDIT:
m_fDisableEdit = (BOOL)lParam;
break;
default:
break;
}
return bResult;
}
void CPreviewWnd::_SetEditCommands()
{
if (CONTROL_MODE != m_dwMode)
{
// We can save if we have a file; the save dialog will show the available encoders
BOOL fCanSave = m_pImageData ? TRUE : FALSE;
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_SAVEASCMD, MAKELONG(!fCanSave, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_SAVEASCMD, MAKELONG(fCanSave, 0));
}
BOOL fCanRotate = m_pImageData != NULL;
if (CONTROL_MODE != m_dwMode)
{
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_ROTATESEP, MAKELONG(!fCanRotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_ROTATE90CMD, MAKELONG(!fCanRotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_ROTATE270CMD, MAKELONG(!fCanRotate, 0));
}
else
{
// we don't rotate multi-page images in control mode
fCanRotate = fCanRotate && !m_pImageData->IsMultipage();
}
// No matter where we are GDIPlus can't rotate WMF or EMF files. Curiously,
// we will let you rotate ICO files, but because we don't have an encoder
// we won't save them :)
if (fCanRotate)
{
fCanRotate = !(IsEqualGUID(ImageFormatWMF, m_pImageData->_guidFormat) ||
IsEqualGUID(ImageFormatEMF, m_pImageData->_guidFormat) ||
m_pImageData->IsAnimated());
}
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATESEP, MAKELONG(fCanRotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE90CMD, MAKELONG(fCanRotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE270CMD, MAKELONG(fCanRotate, 0));
TCHAR szFile[MAX_PATH];
BOOL fCanOpen = SUCCEEDED(PathFromImageData(szFile, ARRAYSIZE(szFile)));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_OPENCMD, MAKELONG(fCanOpen, 0));
}
void CPreviewWnd::_UpdatePageNumber()
{
TCHAR szText[20];
wsprintf(szText, TEXT("%d"), m_pImageData->_iCurrent+1);
TBBUTTONINFO bi = {0};
bi.cbSize = sizeof(bi);
bi.dwMask = TBIF_TEXT | TBIF_STATE;
bi.fsState = TBSTATE_ENABLED;
bi.pszText = szText;
m_ctlToolbar.SendMessage(TB_SETBUTTONINFO, ID_PAGELIST, (LPARAM)&bi);
}
void CPreviewWnd::_SetMultipageCommands()
{
DWORD dwMode;
// this code relies on the fact that TIFFs are the only multipage format we view
if (!m_pImageData || m_pImageData->_guidFormat != ImageFormatTIFF )
{
dwMode = MPCMD_HIDDEN;
}
else if (!m_pImageData->IsMultipage())
{
dwMode = MPCMD_DISABLED;
}
else if (m_pImageData->IsFirstPage())
{
dwMode = MPCMD_FIRSTPAGE;
}
else if (m_pImageData->IsLastPage())
{
dwMode = MPCMD_LASTPAGE;
}
else
{
dwMode = MPCMD_MIDDLEPAGE;
}
// remember which buttons are enabled/hidden so we can quickly create our context menu
if (dwMode != m_dwMultiPageMode)
{
m_dwMultiPageMode = dwMode;
if (CONTROL_MODE != m_dwMode)
{
// Switch accelerator tables so that Page Up and Page Down work
if (dwMode == MPCMD_HIDDEN || dwMode == MPCMD_DISABLED)
{
m_haccel = LoadAccelerators(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDA_PREVWND_SINGLEPAGE));
}
else
{
m_haccel = LoadAccelerators(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDA_PREVWND_MULTIPAGE));
}
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_PAGECMDSEP, MAKELONG((MPCMD_HIDDEN==dwMode),0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_PREVPAGECMD, MAKELONG((MPCMD_HIDDEN==dwMode),0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_PAGELIST, MAKELONG((MPCMD_HIDDEN==dwMode),0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_NEXTPAGECMD, MAKELONG((MPCMD_HIDDEN==dwMode),0));
if (MPCMD_HIDDEN != dwMode)
{
_UpdatePageNumber();
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PREVPAGECMD, MAKELONG((MPCMD_FIRSTPAGE!=dwMode && MPCMD_DISABLED!=dwMode),0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_NEXTPAGECMD, MAKELONG((MPCMD_LASTPAGE !=dwMode && MPCMD_DISABLED!=dwMode),0));
}
}
}
else
{
if (CONTROL_MODE != m_dwMode)
{
if (dwMode == MPCMD_MIDDLEPAGE)
{
_UpdatePageNumber();
}
}
}
}
void CPreviewWnd::_SetMultiImagesCommands()
{
BOOL bHasFiles = m_cItems;
if (CONTROL_MODE != m_dwMode)
{
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_PREVIMGCMD, MAKELONG(!bHasFiles, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_NEXTIMGCMD, MAKELONG(!bHasFiles, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_VIEWCMDSEP, MAKELONG(!bHasFiles, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PREVIMGCMD, MAKELONG(bHasFiles, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_NEXTIMGCMD, MAKELONG(bHasFiles, 0));
}
}
HRESULT CPreviewWnd::PathFromImageData(LPTSTR pszFile, UINT cch)
{
*pszFile = 0;
IShellImageData *pSID;
HRESULT hr = m_pImageData ? m_pImageData->Lock(&pSID) : E_FAIL;
if (SUCCEEDED(hr))
{
IPersistFile *ppf;
hr = pSID->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
if (SUCCEEDED(hr))
{
WCHAR *psz;
hr = ppf->GetCurFile(&psz);
if (SUCCEEDED(hr))
{
lstrcpyn(pszFile, psz, cch);
CoTaskMemFree(psz);
}
ppf->Release();
}
m_pImageData->Unlock();
}
return hr;
}
HRESULT CPreviewWnd::ImageDataSave(LPCTSTR pszFile, BOOL bShowUI)
{
IShellImageData * pSID = NULL;
HRESULT hr = m_pImageData ? m_pImageData->Lock(&pSID) : E_FAIL;
Image *pimgRestore = NULL;
if (SUCCEEDED(hr))
{
GUID guidFmt = GUID_NULL;
BOOL bSave = TRUE;
BOOL bWarnBurn = FALSE;
BOOL bRestoreParams = FALSE;
pSID->GetRawDataFormat(&guidFmt);
// if saving to a jpeg, set the image quality to high
// if pszFile is NULL, we're saving the same file, so don't promote the image quality
if (pszFile)
{
m_pImageFactory->GetDataFormatFromPath(pszFile, &guidFmt);
if (guidFmt == ImageFormatJPEG )
{
IPropertyBag *ppb;
if (SUCCEEDED(SHCreatePropertyBagOnMemory(STGM_READWRITE,
IID_PPV_ARG(IPropertyBag, &ppb))))
{
// write the quality value for the recompression into the property bag
// we have to write the format too...CImageData relies on "all or nothing"
// from the encoder params property bag
VARIANT var;
hr = InitVariantFromGUID(&var, ImageFormatJPEG);
if (SUCCEEDED(hr))
{
ppb->Write(SHIMGKEY_RAWFORMAT, &var);
VariantClear(&var);
}
SHPropertyBag_WriteInt(ppb, SHIMGKEY_QUALITY, 100);
pSID->SetEncoderParams(ppb);
ppb->Release();
bRestoreParams = TRUE;
}
}
}
if (bShowUI && pszFile)
{
// warn the user if saving from TIFF to something that will lose annotations
BOOL bDestTiff = ImageFormatTIFF == guidFmt;
BOOL bAnnot = m_ctlPreview.GetAnnotations()->GetCount() > 0;
bWarnBurn = bAnnot && !bDestTiff;
#if 0
if (!bWarnBurn && S_OK == m_pImageData->IsMultipage() && !bDestTiff)
{
GUID guidFmt;
bWarnBurn = TRUE;
if (SUCCEEDED(m_pImageFactory->GetDataFormatFromPath(pszFile, &guidFmt)))
{
bWarn = !FmtSupportsMultiPage(pSID, &guidFmt);
}
}
#endif // 0 Put the multipage warning back in if needed, and change the wording of IDS_SAVE_WARN_TIFF
}
if (bWarnBurn)
{
m_fPromptingUser = TRUE;
bSave = (IDYES == ShellMessageBox(_Module.GetModuleInstance(), m_hWnd,
MAKEINTRESOURCE(IDS_SAVE_WARN_TIFF),
MAKEINTRESOURCE(IDS_PROJNAME),
MB_YESNO | MB_ICONINFORMATION));
m_fPromptingUser = FALSE;
if (bSave)
{
// Save the current image frame to restore after the save to a different file is complete
pimgRestore = _BurnAnnotations(pSID);
}
}
if (bSave)
{
IPersistFile *ppf;
hr = pSID->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
if (SUCCEEDED(hr))
{
// if saving to the same file name, make sure
// the changenotify code ignores the notify this will generate
//
if (!pszFile)
{
m_fIgnoreNextNotify = TRUE;
}
hr = ppf->Save(pszFile, FALSE);
if (SUCCEEDED(hr))
{
m_fWasEdited = TRUE;
}
else if (!pszFile)
{
m_fIgnoreNextNotify = FALSE;
}
}
ppf->Release();
if (pimgRestore)
{
pSID->ReplaceFrame(pimgRestore);
}
}
else
{
hr = S_FALSE; // we did nothing
}
if (bRestoreParams)
{
pSID->SetEncoderParams(NULL);
}
m_pImageData->Unlock();
}
return hr;
}
HRESULT CPreviewWnd::_SaveAsCmd()
{
if (m_pImageData == NULL)
return S_OK;
OPENFILENAME ofn = {0};
TCHAR szOrgFile[MAX_PATH];
TCHAR szExt[MAX_PATH] = {0};
PathFromImageData(szOrgFile, ARRAYSIZE(szOrgFile));
LPTSTR psz = PathFindExtension(szOrgFile);
StrCpyN(szExt, psz, ARRAYSIZE(szExt));
TCHAR szFile[MAX_PATH];
if (!m_fDisableEdit && m_fCanSave && m_pImageData->IsEditable())
{
// If we haven't explicitly been told not to and the file is writeable then
// suggest saving on top of the current image
PathFromImageData(szFile, ARRAYSIZE(szFile));
}
else
{
// Otherwise suggest New Image.jpg
LoadString(_Module.GetModuleInstance(), IDS_NEW_FILENAME, szFile, ARRAYSIZE(szFile));
}
CComBSTR bstrTitle;
bstrTitle.LoadString(IDS_SAVEAS_TITLE);
ofn.lStructSize = sizeof(ofn);
PathRemoveExtension(szFile);
TCHAR szFilter[MAX_PATH] = TEXT("\0");
ofn.nFilterIndex = _GetFilterStringForSave(szFilter, ARRAYSIZE(szFilter), szExt);
ofn.lpstrFilter = szFilter;
ofn.hwndOwner = m_hWnd;
ofn.lpstrFile = szFile;
ofn.lpstrTitle = bstrTitle;
ofn.nMaxFile = MAX_PATH - lstrlen(szExt);
ofn.Flags = OFN_EXPLORER | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_ENABLESIZING;
ofn.lpstrDefExt = *szExt == TEXT('.') ? szExt + 1: szExt;
m_fPromptingUser = TRUE;
BOOL bResult = ::GetSaveFileName(&ofn);
m_fPromptingUser = FALSE;
if (bResult != 0)
{
m_ctlPreview.CommitAnnotations();
HRESULT hr = ImageDataSave(szFile, TRUE);
if (S_OK == hr)
{
if (lstrcmpi(szFile, szOrgFile) == 0)
{
_UpdateImage();
ShowFile(szFile, 1);
m_fDirty = FALSE;
}
}
else if (FAILED(hr))
{
// If we failed to save then we are corrupt and need to be reloaded
// If we were just copying then only show the message
if (lstrcmpi(szFile, szOrgFile) == 0)
{
_UpdateImage();
ShowFile(szOrgFile, 1, TRUE);
m_fDirty = FALSE;
}
else
{
// delete the failed copy
DeleteFile(szFile);
}
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_SAVEFAILED_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
m_fPromptingUser = TRUE;
MessageBox(bstrMsg, bstrTitle, MB_OK | MB_ICONERROR | MB_APPLMODAL);
m_fPromptingUser = FALSE;
return E_FAIL;
}
}
}
else
{
DWORD dwResult = CommDlgExtendedError();
if (dwResult == FNERR_BUFFERTOOSMALL)
{
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_NAMETOOLONG_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
m_fPromptingUser = TRUE;
MessageBox(bstrMsg, bstrTitle, MB_OK | MB_ICONERROR | MB_APPLMODAL);
m_fPromptingUser = FALSE;
}
}
return S_FALSE; // User probably cancelled
}
return S_OK;
}
void CPreviewWnd::_PropertiesCmd()
{
if (m_fAnnotating && DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 1)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
if (!pAnnotation->HasWidth() && !pAnnotation->HasTransparent() && !pAnnotation->HasColor() && pAnnotation->HasFont())
{
CHOOSEFONT cf = {0};
LOGFONT lfFont;
pAnnotation->GetFont(lfFont);
COLORREF crFont = pAnnotation->GetFontColor();
cf.lStructSize = sizeof(cf);
cf.hwndOwner = m_hWnd;
cf.lpLogFont = &lfFont;
cf.Flags = CF_SCREENFONTS | CF_EFFECTS | CF_INITTOLOGFONTSTRUCT | CF_NOVERTFONTS | CF_NOSCRIPTSEL;
cf.rgbColors = crFont;
m_fPromptingUser = TRUE;
BOOL bResult = ::ChooseFont(&cf);
m_fPromptingUser = FALSE;
if (bResult)
{
crFont = cf.rgbColors;
lfFont.lfHeight = (lfFont.lfHeight > 0) ? lfFont.lfHeight : -lfFont.lfHeight;
pAnnotation->SetFont(lfFont);
pAnnotation->SetFontColor(crFont);
m_fDirty = TRUE;
CRegKey Key;
if (ERROR_SUCCESS != Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.Create(HKEY_CURRENT_USER, REGSTR_SHIMGVW);
}
if (Key.m_hKey != NULL)
{
Key.SetValue(crFont, REGSTR_TEXTCOLOR);
::RegSetValueEx(Key, REGSTR_FONT, 0, REG_BINARY, (LPBYTE)&lfFont, sizeof(lfFont));
}
_RefreshSelection();
}
}
else
{
m_fPromptingUser = TRUE;
INT_PTR iResult = DialogBoxParam(_Module.GetModuleInstance(),
MAKEINTRESOURCE(IDD_ANNOPROPS),
m_hWnd, _AnnoPropsDlgProc, (LPARAM)this);
m_fPromptingUser = FALSE;
}
}
else
{
// Under these condition the has pressed Ctrl-I to get File Properties
// So serve them up.
CComBSTR bstrSummary;
bstrSummary.LoadString(IDS_SUMMARY);
_InvokeVerb(TEXT("properties"), bstrSummary);
}
}
HRESULT _VerbMatches(LPCWSTR pszFile, LPCWSTR pszVerb, LPCTSTR pszOurs)
{
TCHAR szTemp[MAX_PATH];
DWORD cch = ARRAYSIZE(szTemp);
HRESULT hr = AssocQueryString(ASSOCF_VERIFY, ASSOCSTR_COMMAND, pszFile, pszVerb, szTemp, &cch);
if (SUCCEEDED(hr))
{
hr = (StrStrI(szTemp, pszOurs)) ? S_OK : S_FALSE;
}
return hr;
}
void CPreviewWnd::_OpenCmd()
{
HRESULT hr = _SaveIfDirty(TRUE);
LPCTSTR pszVerb;
if (S_OK == hr)
{
TCHAR szFile[MAX_PATH];
hr = PathFromImageData(szFile, ARRAYSIZE(szFile));
if (SUCCEEDED(hr))
{
HRESULT hrOpen = _VerbMatches(szFile, L"open", TEXT("shimgvw.dll"));
HRESULT hrEdit = _VerbMatches(szFile, L"edit", TEXT("mspaint.exe"));
// if edit is empty, or if edit is mspaint and open is not shimgvw, use the open verb instead
if (SUCCEEDED(hrEdit))
{
if (S_OK == hrEdit && hrOpen == S_FALSE)
{
pszVerb = TEXT("open");
}
else
{
pszVerb = TEXT("edit");
}
}
else if (hrOpen == S_FALSE)
{
pszVerb = TEXT("open");
}
else
{
pszVerb = TEXT("openas");
}
hr = _InvokeVerb(pszVerb);
}
if (FAILED(hr))
return;
// set m_fNoRestore to avoid the rotation confirmation restoration popup-ation
m_fNoRestore = TRUE;
// The user had a chance to save but may have said no. Pretend we're not dirty
m_fDirty = FALSE;
PostMessage(WM_CLOSE, 0, 0);
}
}
BOOL CPreviewWnd::_CanAnnotate(CDecodeTask * pImageData)
{
// If we have an image and its encoder and we haven't been explicitly told not to allow editing
// and the image is writeable
if (m_pImageData && m_pImageData->IsEditable() && !m_fDisableEdit && m_fCanSave)
{
// then if its a TIFF we can annotate it
return IsEqualGUID(ImageFormatTIFF, pImageData->_guidFormat);
}
return FALSE;
}
BOOL CPreviewWnd::_CanCrop(CDecodeTask * pImageData)
{
if (m_pImageData != NULL)
{
// REVIEW I added this for CyraR as a proof of concept. If we decide to support it
// we still need to catch all the places where we should save the croppped image and
// call GDIplus to accomplish the crop.
#ifdef SUPPORT_CROPPING
if (S_OK != m_pImageData->IsEditable())
return FALSE;
LONG cPages;
if (S_OK == m_pImageData->GetPageCount(&cPages))
{
if (cPages > 1)
return FALSE;
}
return TRUE;
#endif
}
return FALSE;
}
// Called whenever the image changes to hide or show the annotation buttons.
void CPreviewWnd::_SetAnnotatingCommands(BOOL fEnableAnnotations)
{
if (CONTROL_MODE != m_dwMode)
{
if (fEnableAnnotations)
{
m_fCanAnnotate = TRUE;
m_fAnnotating = FALSE;
}
else
{
if (m_fAnnotating)
{
m_ctlPreview.SetMode(CZoomWnd::MODE_NOACTION);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMOUTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMINCMD, TBSTATE_ENABLED);
}
m_fCanAnnotate = FALSE;
m_fAnnotating = FALSE;
}
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_SELECTCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_ANNOTATESEP, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_FREEHANDCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_HIGHLIGHTCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_LINECMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_FRAMECMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_RECTCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_TEXTCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_NOTECMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_PROPERTIESCMD, MAKELONG(!m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_SELECTCMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ANNOTATESEP, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_FREEHANDCMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_HIGHLIGHTCMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_LINECMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_FRAMECMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_RECTCMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_TEXTCMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_NOTECMD, MAKELONG(m_fCanAnnotate, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PROPERTIESCMD, MAKELONG(FALSE, 0));
}
}
void CPreviewWnd::_SetCroppingCommands(BOOL fEnableCropping)
{
if (CONTROL_MODE != m_dwMode)
{
if (fEnableCropping)
{
m_fCanCrop = TRUE;
m_fCropping = FALSE;
}
else
{
if (m_fCropping)
{
m_ctlPreview.SetMode(CZoomWnd::MODE_NOACTION);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMOUTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMINCMD, TBSTATE_ENABLED);
}
m_fCanCrop = FALSE;
m_fCropping = FALSE;
}
m_ctlToolbar.SendMessage(TB_HIDEBUTTON, ID_CROPCMD, MAKELONG(!m_fCanCrop, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_CROPCMD, MAKELONG(m_fCanCrop, 0));
}
}
// Called on Toolbar command to fix the state of the other buttons.
void CPreviewWnd::_UpdateButtons(WORD wID)
{
if (CONTROL_MODE != m_dwMode)
{
switch (wID)
{
case NOBUTTON:
case ID_ZOOMINCMD:
case ID_ZOOMOUTCMD:
case ID_SELECTCMD:
case ID_CROPCMD:
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMINCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMOUTCMD, TBSTATE_ENABLED);
if (m_fCanAnnotate)
{
m_wNewAnnotation = 0;
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_SELECTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FREEHANDCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_HIGHLIGHTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_LINECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FRAMECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_RECTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_TEXTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_NOTECMD, TBSTATE_ENABLED);
m_fAnnotating = (wID == ID_SELECTCMD);
}
if (m_fCanCrop)
{
m_fCropping = (wID == ID_CROPCMD);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_CROPCMD, TBSTATE_ENABLED);
}
_RefreshSelection(!m_fAnnotating);
m_ctlToolbar.SendMessage(TB_SETSTATE, wID, TBSTATE_ENABLED|TBSTATE_CHECKED);
break;
case ID_FREEHANDCMD:
case ID_LINECMD:
case ID_FRAMECMD:
case ID_RECTCMD:
case ID_TEXTCMD:
case ID_NOTECMD:
case ID_HIGHLIGHTCMD:
if (m_fCanAnnotate)
{
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMINCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_ZOOMOUTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FREEHANDCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_HIGHLIGHTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_LINECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FRAMECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_RECTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_TEXTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_NOTECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_SELECTCMD, TBSTATE_ENABLED|TBSTATE_CHECKED);
m_fAnnotating = TRUE;
_RefreshSelection(TRUE);
m_ctlToolbar.SendMessage(TB_SETSTATE, wID, TBSTATE_ENABLED|TBSTATE_CHECKED);
m_wNewAnnotation = wID;
}
break;
default:
if (m_fCanAnnotate)
{
m_wNewAnnotation = 0;
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_SELECTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FREEHANDCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_HIGHLIGHTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_LINECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_FRAMECMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_RECTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_TEXTCMD, TBSTATE_ENABLED);
m_ctlToolbar.SendMessage(TB_SETSTATE, ID_NOTECMD, TBSTATE_ENABLED);
}
break;
}
}
}
void CPreviewWnd::_RefreshSelection(BOOL fDeselect)
{
if (m_fCropping)
_UpdateCroppingSelection();
_UpdateAnnotatingSelection(fDeselect);
}
BOOL CPreviewWnd::_ShouldDisplayAnimations()
{
return !::GetSystemMetrics(SM_REMOTESESSION);
}
void CPreviewWnd::_UpdateAnnotatingSelection(BOOL fDeselect)
{
BOOL bEditing = FALSE;
if (m_ctlEdit.m_hWnd != NULL)
{
if (m_ctlEdit.IsWindowVisible())
{
_HideEditing();
bEditing = TRUE;
}
}
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
CRect rectUpdate;
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker, bEditing);
tracker.GetTrueRect(rectUpdate);
// If we were editing or this was a straight line, we
// need to get the bounding rect as well
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 1)
{
CRect rect;
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
pAnnotation->GetRect(rect);
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
rectUpdate.UnionRect(rectUpdate, rect);
}
m_ctlPreview.InvalidateRect(&rectUpdate);
if (m_fAnnotating && !fDeselect)
{
if (bEditing)
_StartEditing(FALSE);
}
else
{
_StopEditing();
DPA_DeleteAllPtrs(m_hdpaSelectedAnnotations);
}
}
// Disable the properties button if there are 0 or 2 or more annotations selected
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PROPERTIESCMD, MAKELONG(DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 1, 0));
}
void CPreviewWnd::_UpdateCroppingSelection()
{
if (m_fCropping)
{
m_ctlPreview.InvalidateRect(NULL);
}
}
void CPreviewWnd::_RemoveAnnotatingSelection()
{
// Invalidate current selection and remove annotations
_UpdateAnnotatingSelection();
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotations->RemoveAnnotation(pAnnotation);
delete pAnnotation;
m_fDirty = TRUE;
}
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_PROPERTIESCMD, MAKELONG(FALSE, 0));
DPA_DeleteAllPtrs(m_hdpaSelectedAnnotations);
}
void CPreviewWnd::_SetupAnnotatingTracker(CSelectionTracker& tracker, BOOL bEditing)
{
CRect rect;
rect.SetRectEmpty();
if (!bEditing)
{
if (m_ctlEdit.m_hWnd != NULL)
bEditing = m_ctlEdit.IsWindowVisible();
}
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 0)
{
CAnnotation* pAnnotation;
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 1)
{
pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
// If this is a straight-line annotation then we need to get
// to the actual points rather than the bounding rect
if (pAnnotation->GetType() == MT_STRAIGHTLINE)
{
CLineMark* pLine = (CLineMark*)pAnnotation;
pLine->GetPointsRect(rect);
}
else
{
pAnnotation->GetRect(rect);
}
if (bEditing)
_RotateRect(rect, pAnnotation);
}
else
{
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CRect rectAnnotation;
pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotation->GetRect(rectAnnotation);
rectAnnotation.NormalizeRect();
rect.UnionRect(rect, rectAnnotation);
}
}
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
}
tracker.m_rect = rect;
UINT uStyle = 0;
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 1)
{
uStyle = CSelectionTracker::hatchedBorder;
}
else if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 1)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
if (pAnnotation->CanResize())
{
if (pAnnotation->GetType() == MT_STRAIGHTLINE)
uStyle = CSelectionTracker::resizeOutside | CSelectionTracker::lineSelection;
else
uStyle = CSelectionTracker::solidLine | CSelectionTracker::resizeOutside;
}
else
{
uStyle = CSelectionTracker::hatchedBorder;
}
}
tracker.m_uStyle = uStyle;
}
void CPreviewWnd::_SetupCroppingTracker(CSelectionTracker& tracker)
{
if (m_fCropping)
{
CRect rect(0, 0, m_ctlPreview.m_cxImage, m_ctlPreview.m_cyImage);
if (m_rectCropping.IsRectEmpty())
m_rectCropping = rect;
rect = m_rectCropping;
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
tracker.m_rect = rect;
tracker.m_uStyle = CSelectionTracker::solidLine | CSelectionTracker::resizeOutside;
}
}
BOOL CPreviewWnd::_OnMouseDownForCropping(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (!m_fCropping)
return FALSE;
if (uMsg != WM_LBUTTONDOWN)
return TRUE;
CSelectionTracker tracker;
CPoint point(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
_SetupCroppingTracker(tracker);
_RefreshSelection();
if (tracker.HitTest(point) == CSelectionTracker::hitNothing)
return TRUE;
if (tracker.Track(m_ctlPreview.m_hWnd, point))
{
CRect rectNewPos;
tracker.GetTrueRect(rectNewPos);
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rectNewPos, 2);
CRect rectImage(0, 0, m_ctlPreview.m_cxImage, m_ctlPreview.m_cyImage);
if (rectNewPos.left < rectImage.left)
m_rectCropping.left = rectImage.left;
else
m_rectCropping.left = rectNewPos.left;
if (rectNewPos.top < rectImage.top)
m_rectCropping.top = rectImage.top;
else
m_rectCropping.top = rectNewPos.top;
if (rectNewPos.right > rectImage.right)
m_rectCropping.right = rectImage.right;
else
m_rectCropping.right = rectNewPos.right;
if (rectNewPos.bottom > rectImage.bottom)
m_rectCropping.bottom = rectImage.bottom;
else
m_rectCropping.bottom = rectNewPos.bottom;
m_fDirty = TRUE;
}
_RefreshSelection();
return TRUE;
}
BOOL CPreviewWnd::_OnMouseDownForAnnotating(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (!m_fAnnotating)
return FALSE;
if (uMsg != WM_LBUTTONDOWN)
return TRUE;
CRect rect;
CRect rectImage;
CPoint point(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
CSelectionTracker tracker;
m_ctlPreview.GetVisibleImageWindowRect(rectImage);
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 0)
{
_OnMouseDownForAnnotatingHelper(point, rectImage);
return TRUE;
}
_SetupAnnotatingTracker(tracker);
tracker.GetTrueRect(rect);
if (tracker.HitTest(point) == CSelectionTracker::hitNothing)
{
_RefreshSelection(TRUE);
_OnMouseDownForAnnotatingHelper(point, rectImage);
return TRUE;
}
if (!tracker.Track(m_ctlPreview.m_hWnd, point))
{
_StartEditing();
return TRUE;
}
CRect rectNewPos;
tracker.GetTrueRect(rectNewPos);
rect.BottomRight() = rectNewPos.TopLeft();
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rect, 2);
CSize size = rect.BottomRight() - rect.TopLeft();
_RefreshSelection();
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) > 1)
{
if (size.cx == 0 && size.cy == 0)
return TRUE;
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rectImage, 2);
rectImage.DeflateRect(5, 5);
BOOL bValidMove = TRUE;
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotation->GetRect(rect);
rect.NormalizeRect();
rect.OffsetRect(size);
if (!rectNewPos.IntersectRect(rectImage, rect))
bValidMove = FALSE;
}
if (!bValidMove)
return TRUE;
for (int i = 0; i < DPA_GetPtrCount(m_hdpaSelectedAnnotations); i++)
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, i);
pAnnotation->Move(size);
}
}
else
{
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
if (pAnnotation->CanResize())
{
CRect rectTest;
rect = tracker.m_rect;
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rect, 2);
rectTest = rect;
// If the annotation being manipulated is a straight line then the rectangle
// returned from the tracker could be empty (ie left=right or top=bottom)
// In this case the IntersectRect test below would fail because windows
// assumes empty rectangle don't intersect anything.
if (pAnnotation->GetType() == MT_STRAIGHTLINE)
{
if (rectTest.left == rectTest.right)
rectTest.right++;
if (rectTest.top == rectTest.bottom)
rectTest.bottom++;
}
rectTest.NormalizeRect();
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rectImage, 2);
rectImage.DeflateRect(5, 5);
if (!rectTest.IntersectRect(rectImage, rectTest))
return TRUE;
if (m_ctlEdit.m_hWnd != NULL)
{
if (m_ctlEdit.IsWindowVisible())
{
_RotateRect(rect, pAnnotation);
}
}
// If this is a line then the rect is assumed to be
// a non-normalized array of points.
pAnnotation->Resize(rect);
}
else
{
if (size.cx == 0 && size.cy == 0)
return TRUE;
pAnnotation->Move(size);
}
}
m_fDirty = TRUE;
_RefreshSelection();
return TRUE;
}
void CPreviewWnd::_OnMouseDownForAnnotatingHelper(CPoint ptMouse, CRect rectImage)
{
CRect rect;
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker);
if (m_wNewAnnotation == ID_FREEHANDCMD)
{
_CreateFreeHandAnnotation(ptMouse);
return;
}
// If we are creating a line then make sure the tracker has the lineSelection
// style so we get the appropriate visual feedback.
if (m_wNewAnnotation == ID_LINECMD)
{
tracker.m_uStyle = CSelectionTracker::resizeOutside | CSelectionTracker::lineSelection;
}
if (tracker.TrackRubberBand(m_ctlPreview.m_hWnd, ptMouse, TRUE))
{
rect = tracker.m_rect;
rect.NormalizeRect();
if ((rect.Width() > 10) || (rect.Height() > 10))
{
if (m_wNewAnnotation != 0)
{
_CreateAnnotation(tracker.m_rect);
}
else
{
CRect rectTest;
CRect rectAnnotation;
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rect, 2);
INT_PTR nCount = pAnnotations->GetCount();
for (INT_PTR i = 0; i < nCount; i++)
{
CAnnotation* pAnnotation = pAnnotations->GetAnnotation(i);
pAnnotation->GetRect(rectAnnotation);
rectAnnotation.NormalizeRect();
rectTest.UnionRect(rect, rectAnnotation);
if (rectTest == rect)
{
DPA_AppendPtr(m_hdpaSelectedAnnotations, pAnnotation);
}
}
_RefreshSelection(DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 0);
}
}
}
else
{
if (m_wNewAnnotation == 0)
{
if (PtInRect(rectImage, ptMouse))
{
m_ctlPreview.GetImageFromWindow(&ptMouse, 1);
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
INT_PTR nCount = pAnnotations->GetCount();
// if the user is clicking a single point then
// we need to search the annotations in zorder
// from top to bottom
for (INT_PTR i = nCount - 1; i >= 0; i--)
{
CAnnotation* pAnnotation = pAnnotations->GetAnnotation(i);
pAnnotation->GetRect(rect);
rect.NormalizeRect();
if (PtInRect(rect, ptMouse))
{
DPA_AppendPtr(m_hdpaSelectedAnnotations, pAnnotation);
_RefreshSelection();
return;
}
}
_RefreshSelection(DPA_GetPtrCount(m_hdpaSelectedAnnotations) == 0);
}
}
else
{
_UpdateButtons(ID_SELECTCMD);
}
}
}
void CPreviewWnd::_CreateAnnotation(CRect rect)
{
if (m_wNewAnnotation == 0 || m_wNewAnnotation == ID_FREEHANDCMD)
return;
ULONG xDPI;
ULONG yDPI;
if (!(m_pImageData->GetResolution(&xDPI, &yDPI)))
return;
CAnnotation* pAnnotation = NULL;
switch(m_wNewAnnotation)
{
case ID_LINECMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_STRAIGHTLINE, yDPI);
break;
case ID_FRAMECMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_HOLLOWRECT, yDPI);
break;
case ID_RECTCMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_FILLRECT, yDPI);
break;
case ID_TEXTCMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_TYPEDTEXT, yDPI);
break;
case ID_NOTECMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_ATTACHANOTE, yDPI);
break;
case ID_HIGHLIGHTCMD:
pAnnotation = CAnnotation::CreateAnnotation(MT_FILLRECT, yDPI);
if (pAnnotation != NULL)
pAnnotation->SetTransparent(TRUE);
break;
}
if (pAnnotation != NULL)
{
COLORREF crBackColor = RGB(255,255,0);
COLORREF crLineColor = RGB(255,0,0);
COLORREF crTextColor = RGB(0,0,0);
LOGFONT lfFont = {12, 0, 0, 0, 400, 0, 0, 0, 0, 0, 0, 0, 0, TEXT("Arial") };
DWORD dwWidth = 1;
CRegKey Key;
if (ERROR_SUCCESS == Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.QueryValue(dwWidth, REGSTR_LINEWIDTH);
Key.QueryValue(crBackColor, REGSTR_BACKCOLOR);
Key.QueryValue(crLineColor, REGSTR_LINECOLOR);
Key.QueryValue(crTextColor, REGSTR_TEXTCOLOR);
DWORD dwType, cbSize;
cbSize = sizeof(lfFont);
::RegQueryValueEx(Key, REGSTR_FONT, NULL, &dwType, (LPBYTE)&lfFont, &cbSize);
}
if (m_wNewAnnotation != ID_LINECMD)
rect.NormalizeRect();
m_ctlPreview.GetImageFromWindow((LPPOINT)(LPRECT)rect, 2);
pAnnotation->Resize(rect);
if (pAnnotation->HasWidth())
pAnnotation->SetWidth(dwWidth);
if (pAnnotation->HasColor())
{
if (m_wNewAnnotation == ID_LINECMD || m_wNewAnnotation == ID_FRAMECMD)
pAnnotation->SetColor(crLineColor);
else
pAnnotation->SetColor(crBackColor);
}
if (pAnnotation->HasFont())
{
pAnnotation->SetFont(lfFont);
pAnnotation->SetFontColor(crTextColor);
}
DPA_DeleteAllPtrs(m_hdpaSelectedAnnotations);
DPA_AppendPtr(m_hdpaSelectedAnnotations, pAnnotation);
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
pAnnotations->AddAnnotation(pAnnotation);
m_fDirty = TRUE;
}
_UpdateButtons(ID_SELECTCMD);
}
void CPreviewWnd::_CreateFreeHandAnnotation(CPoint ptMouse)
{
if (m_wNewAnnotation != ID_FREEHANDCMD)
return;
// don't handle if capture already set
if (::GetCapture() != NULL)
return;
// set capture to the window which received this message
::SetCapture(m_ctlPreview.m_hWnd);
ASSERT(m_ctlPreview.m_hWnd == ::GetCapture());
::UpdateWindow(m_ctlPreview.m_hWnd);
ULONG xDPI;
ULONG yDPI;
if (!(m_pImageData->GetResolution(&xDPI, &yDPI)))
return;
CLineMark* pAnnotation = (CLineMark*)CAnnotation::CreateAnnotation(MT_FREEHANDLINE, yDPI);
if (pAnnotation == NULL)
return;
CDSA<POINT> Points;
Points.Create(256);
CPoint ptLast = ptMouse;
m_ctlPreview.GetImageFromWindow(&ptMouse, 1);
Points.AppendItem(&ptMouse);
// get DC for drawing
HDC hdcDraw;
// otherwise, just use normal DC
hdcDraw = ::GetDC(m_ctlPreview.m_hWnd);
ASSERT(hdcDraw != NULL);
COLORREF crLineColor = RGB(255,0,0);
DWORD dwWidth = 1;
CRegKey Key;
if (ERROR_SUCCESS == Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.QueryValue(dwWidth, REGSTR_LINEWIDTH);
Key.QueryValue(crLineColor, REGSTR_LINECOLOR);
}
CRect rect(0,0,0,dwWidth);
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
DWORD dwRenderWidth = rect.Height();
HPEN hpen = ::CreatePen(PS_SOLID, dwRenderWidth, crLineColor);
HPEN hOld =(HPEN)::SelectObject(hdcDraw, hpen);
BOOL bCancel=FALSE;
// get messages until capture lost or cancelled/accepted
for (;;)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
ASSERT(FALSE);
}
if (m_ctlPreview.m_hWnd != ::GetCapture())
{
bCancel = TRUE;
goto ExitLoop;
}
ptMouse.x = GET_X_LPARAM(msg.lParam);
ptMouse.y = GET_Y_LPARAM(msg.lParam);
switch (msg.message)
{
// handle movement/accept messages
case WM_LBUTTONUP:
case WM_MOUSEMOVE:
::MoveToEx(hdcDraw, ptLast.x, ptLast.y, NULL);
::LineTo(hdcDraw, ptMouse.x, ptMouse.y);
ptLast = ptMouse;
m_ctlPreview.GetImageFromWindow(&ptMouse, 1);
Points.AppendItem(&ptMouse);
if (msg.message == WM_LBUTTONUP)
goto ExitLoop;
break;
// handle cancel messages
case WM_KEYDOWN:
if (msg.wParam != VK_ESCAPE)
break;
// else fall through
case WM_RBUTTONDOWN:
bCancel = TRUE;
goto ExitLoop;
default:
::DispatchMessage(&msg);
break;
}
}
ExitLoop:
::SelectObject(hdcDraw, hOld);
::DeleteObject(hpen);
::ReleaseDC(m_ctlPreview.m_hWnd, hdcDraw);
::ReleaseCapture();
if (!bCancel)
{
int nAnnoPoints = Points.GetItemCount();
POINT* AnnoPoints = new POINT[nAnnoPoints];
if (AnnoPoints == NULL)
{
delete pAnnotation;
Points.Destroy();
_UpdateButtons(ID_SELECTCMD);
return;
}
for (int i = 0; i < nAnnoPoints; i++)
{
CPoint pt;
Points.GetItem(i, &pt);
AnnoPoints[i].x = pt.x;
AnnoPoints[i].y = pt.y;
}
Points.Destroy();
pAnnotation->SetPoints(AnnoPoints, nAnnoPoints);
pAnnotation->SetWidth(dwWidth);
pAnnotation->SetColor(crLineColor);
DPA_DeleteAllPtrs(m_hdpaSelectedAnnotations);
DPA_AppendPtr(m_hdpaSelectedAnnotations, pAnnotation);
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
pAnnotations->AddAnnotation(pAnnotation);
m_fDirty = TRUE;
}
_UpdateButtons(ID_SELECTCMD);
}
void CPreviewWnd::_StartEditing(BOOL bUpdateText)
{
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) != 1)
return;
CTextAnnotation* pAnnotation = (CTextAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
if (!pAnnotation)
{
return;
}
UINT uType = pAnnotation->GetType();
if (uType != MT_TYPEDTEXT && uType != MT_FILETEXT && uType != MT_STAMP && uType != MT_ATTACHANOTE)
return;
if (m_ctlEdit.m_hWnd == NULL)
{
HWND hwndEdit = ::CreateWindow(TEXT("EDIT"), NULL, ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL |
ES_WANTRETURN | WS_CHILD, 1, 1, 10, 10,
m_ctlPreview.m_hWnd, (HMENU)1496, NULL, NULL);
if (hwndEdit == NULL)
return;
m_ctlEdit.SubclassWindow(hwndEdit);
}
if (bUpdateText)
{
CComBSTR bstrText;
bstrText.Attach(pAnnotation->GetText());
if (bstrText.m_str != NULL)
m_ctlEdit.SetWindowText(bstrText);
else
m_ctlEdit.SetWindowText(TEXT(""));
}
m_ctlEdit.EnableWindow(TRUE);
LOGFONT lfFont;
pAnnotation->GetFont(lfFont);
HDC hdc = ::GetDC(NULL);
LONG lHeight = pAnnotation->GetFontHeight(hdc);
::ReleaseDC(NULL, hdc);
CRect rect(0,0,0,lHeight);
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
lfFont.lfHeight = -rect.Height();
HFONT hNewFont = ::CreateFontIndirect(&lfFont);
if (hNewFont)
{
::DeleteObject(m_hFont);
m_hFont = hNewFont;
m_ctlEdit.SendMessage(WM_SETFONT, (WPARAM)m_hFont, MAKELPARAM(TRUE,0));
}
pAnnotation->GetRect(rect);
_RotateRect(rect, pAnnotation);
m_ctlPreview.GetWindowFromImage((LPPOINT)(LPRECT)rect, 2);
m_ctlEdit.SetWindowPos(NULL, rect.left, rect.top, rect.Width(), rect.Height(), SWP_NOZORDER);
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker, FALSE);
CRect rectUpdate;
tracker.GetTrueRect(rectUpdate);
m_ctlPreview.InvalidateRect(rectUpdate);
_SetupAnnotatingTracker(tracker, TRUE);
tracker.GetTrueRect(rectUpdate);
m_ctlPreview.InvalidateRect(rectUpdate);
m_ctlEdit.ShowWindow(SW_SHOW);
m_ctlEdit.SetFocus();
m_fEditingAnnotation = TRUE;
}
void CPreviewWnd::_HideEditing()
{
if (m_ctlEdit.m_hWnd == NULL)
return;
if (!m_ctlEdit.IsWindowVisible())
return;
SetFocus();
m_ctlEdit.SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
m_ctlEdit.EnableWindow(FALSE);
}
void CPreviewWnd::_StopEditing()
{
if (m_ctlEdit.m_hWnd == NULL)
return;
_HideEditing();
if (!m_fEditingAnnotation)
return;
m_fEditingAnnotation = FALSE;
if (DPA_GetPtrCount(m_hdpaSelectedAnnotations) != 1)
return;
CTextAnnotation* pAnnotation = (CTextAnnotation*)DPA_GetPtr(m_hdpaSelectedAnnotations, 0);
UINT uType = pAnnotation->GetType();
if (uType != MT_TYPEDTEXT && uType != MT_FILETEXT && uType != MT_STAMP && uType != MT_ATTACHANOTE)
return;
// if the length greater than zero we save it
// otherwise be blow away the annotation.
int nLen = m_ctlEdit.GetWindowTextLength();
if (nLen > 0)
{
CComBSTR bstrText(nLen+1);
m_ctlEdit.GetWindowText(bstrText, nLen+1);
pAnnotation->SetText(bstrText);
m_fDirty = TRUE;
}
else
{
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker, TRUE);
CRect rectUpdate;
tracker.GetTrueRect(rectUpdate);
CRect rect;
pAnnotation->GetRect(rect);
rectUpdate.UnionRect(rectUpdate, rect);
DPA_DeleteAllPtrs(m_hdpaSelectedAnnotations);
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
pAnnotations->RemoveAnnotation(pAnnotation);
delete pAnnotation;
m_ctlPreview.InvalidateRect(rectUpdate);
m_fDirty = TRUE;
}
}
LRESULT CPreviewWnd::OnEditKeyEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
switch (wParam)
{
case VK_ESCAPE:
{
CSelectionTracker tracker;
_SetupAnnotatingTracker(tracker);
CRect rectUpdate;
tracker.GetTrueRect(rectUpdate);
_HideEditing();
m_ctlPreview.InvalidateRect(rectUpdate);
_RefreshSelection();
fHandled = TRUE;
}
break;
default:
fHandled = FALSE;
break;
}
return 0;
}
BOOL_PTR CALLBACK CPreviewWnd::_AnnoPropsDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static LOGFONT lfFont;
static COLORREF crFont;
static COLORREF crColor;
CPreviewWnd* pThis;
switch (msg)
{
case WM_INITDIALOG:
{
HWND hwndCtl = NULL;
::SetWindowLongPtr(hwnd, DWLP_USER, lParam);
pThis = (CPreviewWnd*)lParam;
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(pThis->m_hdpaSelectedAnnotations, 0);
hwndCtl = ::GetDlgItem(hwnd, IDC_WIDTHTEXT);
if (!pAnnotation->HasWidth())
{
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
}
hwndCtl = ::GetDlgItem(hwnd, IDC_WIDTH);
if (pAnnotation->HasWidth())
{
UINT i = pAnnotation->GetWidth();
::SetDlgItemInt(hwnd, IDC_WIDTH, i, FALSE);
hwndCtl = ::GetDlgItem(hwnd, IDC_SPIN);
::SendMessage(hwndCtl, UDM_SETRANGE32, (WPARAM)1, (LPARAM)50);
::SendMessage(hwndCtl, UDM_SETPOS32, 0, (LPARAM)i);
}
else
{
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
hwndCtl = ::GetDlgItem(hwnd, IDC_SPIN);
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
}
hwndCtl = ::GetDlgItem(hwnd, IDC_TRANSPARENT);
if (pAnnotation->HasTransparent())
{
BOOL bTransparent = pAnnotation->GetTransparent();
::SendMessage(hwndCtl, BM_SETCHECK, (WPARAM)(bTransparent ? BST_CHECKED : BST_UNCHECKED), 0);
}
else
{
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
}
if (pAnnotation->HasFont())
{
pAnnotation->GetFont(lfFont);
crFont = pAnnotation->GetFontColor();
}
else
{
hwndCtl = ::GetDlgItem(hwnd, IDC_FONT);
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
}
if (pAnnotation->HasColor())
{
crColor = pAnnotation->GetColor();
}
else
{
hwndCtl = ::GetDlgItem(hwnd, IDC_COLOR);
::EnableWindow(hwndCtl, FALSE);
::ShowWindow(hwndCtl, SW_HIDE);
}
}
break;
case WM_COMMAND:
pThis = (CPreviewWnd*)::GetWindowLongPtr(hwnd, DWLP_USER);
switch (wParam)
{
case IDOK:
pThis->_RefreshSelection();
{
HWND hwndCtl = NULL;
CAnnotation* pAnnotation = (CAnnotation*)DPA_GetPtr(pThis->m_hdpaSelectedAnnotations, 0);
CRegKey Key;
if (ERROR_SUCCESS != Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.Create(HKEY_CURRENT_USER, REGSTR_SHIMGVW);
}
if (pAnnotation->HasWidth())
{
UINT uWidth = ::GetDlgItemInt(hwnd, IDC_WIDTH, NULL, FALSE);
if (uWidth > 50 || uWidth < 1)
{
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_WIDTHBAD_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
::MessageBox(hwnd, bstrMsg, bstrTitle, MB_OK | MB_ICONERROR | MB_APPLMODAL);
}
::SetDlgItemInt(hwnd, IDC_WIDTH, 50, FALSE);
return FALSE;
}
pAnnotation->SetWidth(uWidth);
if (Key.m_hKey != NULL)
{
Key.SetValue(uWidth, REGSTR_LINEWIDTH);
}
}
if (pAnnotation->HasTransparent())
{
hwndCtl = ::GetDlgItem(hwnd, IDC_TRANSPARENT);
BOOL bTransparent = FALSE;
if (::SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == BST_CHECKED)
bTransparent = TRUE;
pAnnotation->SetTransparent(bTransparent);
}
if (pAnnotation->HasFont())
{
lfFont.lfHeight = (lfFont.lfHeight > 0) ? lfFont.lfHeight : -lfFont.lfHeight;
pAnnotation->SetFont(lfFont);
pAnnotation->SetFontColor(crFont);
if (Key.m_hKey != NULL)
{
Key.SetValue(crFont, REGSTR_TEXTCOLOR);
::RegSetValueEx(Key, REGSTR_FONT, 0, REG_BINARY, (LPBYTE)&lfFont, sizeof(lfFont));
}
}
if (pAnnotation->HasColor())
{
pAnnotation->SetColor(crColor);
UINT uType = pAnnotation->GetType();
if (Key.m_hKey != NULL)
{
if (uType == MT_STRAIGHTLINE || uType == MT_FREEHANDLINE || uType == MT_HOLLOWRECT)
Key.SetValue(crColor, REGSTR_LINECOLOR);
else
Key.SetValue(crColor, REGSTR_BACKCOLOR);
}
}
}
pThis->m_fDirty = TRUE;
pThis->_RefreshSelection();
EndDialog(hwnd, wParam);
return FALSE;
case IDCANCEL:
EndDialog(hwnd, wParam);
return FALSE;
case IDC_FONT:
{
CHOOSEFONT cf = {0};
LOGFONT lf;
lf = lfFont;
cf.lStructSize = sizeof(cf);
cf.hwndOwner = hwnd;
cf.lpLogFont = &lf;
cf.Flags = CF_SCREENFONTS | CF_EFFECTS | CF_INITTOLOGFONTSTRUCT | CF_NOVERTFONTS | CF_NOSCRIPTSEL;
cf.rgbColors = crFont;
if (::ChooseFont(&cf))
{
CopyMemory (&lfFont, &lf, sizeof(lf));
crFont = cf.rgbColors;
}
}
return FALSE;
case IDC_COLOR:
{
CHOOSECOLOR cc = {0};
cc.lStructSize = sizeof(cc);
cc.hwndOwner = hwnd;
cc.rgbResult = crColor;
cc.lpCustColors = g_crCustomColors;
cc.Flags = CC_RGBINIT | CC_SOLIDCOLOR;
if (::ChooseColor(&cc))
{
crColor = cc.rgbResult;
}
}
return FALSE;
default:
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
BOOL CPreviewWnd::_TrySetImage()
{
BOOL fRet = FALSE;
if (m_pNextImageData && m_pNextImageData->_iItem == m_iCurSlide)
{
if (SUCCEEDED(m_pNextImageData->_hr))
{
m_fCanSave = !m_pNextImageData->_fIsReadOnly;
// update the toolbar state, our child windows, and our sibling windows
_SetNewImage(m_pNextImageData);
ATOMICRELEASE(m_pNextImageData);
if (m_pImageData->IsAnimated() && _ShouldDisplayAnimations())
{
// start the animation timer
SetTimer(TIMER_ANIMATION, m_pImageData->GetDelay());
}
// Notify anyone listening to our events that a preview has been completed
// we only fire this upon success
if (m_pEvents)
{
m_pEvents->OnPreviewReady();
}
fRet = TRUE;
}
else
{
// update the status to display an error message. This will also update the toolbar state.
StatusUpdate(IDS_LOADFAILED);
//
// We can't remove the item from the array because the user might try to delete it while
// the "load failed" string is still visible for it.
// even though the item failed to decode we must wait on the "Load Failed" state when we are in
// windowed mode, otherwise "open with..." is broken when you open a corrupted image or non-image.
// In slideshow mode we could simply skip to the next image.
if (m_pEvents)
m_pEvents->OnError();
}
}
return fRet;
}
LRESULT CPreviewWnd::IV_OnSetImageData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled)
{
CDecodeTask * pData = (CDecodeTask *)wParam;
ATOMICRELEASE(m_pNextImageData);
m_pNextImageData = pData;
if (m_pNextImageData && m_iDecodingNextImage == m_pNextImageData->_iItem)
{
// We have finished decoding now, let's remember this.
m_iDecodingNextImage = -1;
// Let 's prepare the drawing now. This draws in the back buffer. Don't start this if we want to see
// the image now, as it would delay things.
if (SUCCEEDED(m_pNextImageData->_hr) && m_pNextImageData->_iItem != m_iCurSlide)
{
m_ctlPreview.PrepareImageData(m_pNextImageData);
}
}
_TrySetImage();
return TRUE;
}
// Creation of the image data is asynchronous. When our worker thread is done decoding
// an image it posts a IV_SETIMAGEDATA message with the image data object. As a result,
// we must flush these messages when the window is destroyed to prevent leaking any handles.
void CPreviewWnd::FlushBitmapMessages()
{
// Pass TRUE to wait for task to be removed before peeking out its messages
// Otherwise, if the task is in the middle of running, our PeekMessage won't
// see anything and we will return. Then the task will finish, post its message,
// and leak the data since we're not around to receive it.
TASKOWNERID toid;
GetTaskIDFromMode(GTIDFM_DECODE, m_dwMode, &toid);
if (m_pTaskScheduler)
{
m_pTaskScheduler->RemoveTasks(toid, ITSAT_DEFAULT_LPARAM, TRUE);
}
// if we were waiting for another image frame to be generated then cut it out, we don't care about that anymore
// if we have an animation timer running then kill it and remove any WM_TIMER messages
KillTimer(TIMER_ANIMATION);
KillTimer(TIMER_SLIDESHOW);
MSG msg;
while (PeekMessage(&msg, m_hWnd, WM_TIMER, WM_TIMER, PM_REMOVE))
{
// NTRAID#NTBUG9-359356-2001/04/05-seank
// If the queue is empty when PeekMessage is called and we have already
// Posted a quit message then PeekMessage will return a WM_QUIT message
// regardless of the filter min and max and subsequent calls to
// GetMessage will hang indefinitely see SEANK or JASONSCH for more
// info.
if (msg.message == WM_QUIT)
{
PostQuitMessage(0);
return;
}
}
// make sure any posted messages get flushed and we free the associated data
while (PeekMessage(&msg, m_hWnd, IV_SETIMAGEDATA, IV_SETIMAGEDATA, PM_REMOVE))
{
// NTRAID#NTBUG9-359356-2001/04/05-seank
// If the queue is empty when PeekMessage is called and we have already
// Posted a quit message then PeekMessage will return a WM_QUIT message
// regardless of the filter min and max and subsequent calls to
// GetMessage will hang indefinitely see SEANK or JASONSCH for more
// info.
if (msg.message == WM_QUIT)
{
PostQuitMessage(0);
return;
}
CDecodeTask * pData = (CDecodeTask *)msg.wParam;
ATOMICRELEASE(pData);
}
}
LRESULT CPreviewWnd::OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)
{
// We can get into a situation where we are still trying to preview
// the previous oncopydata because the previous window to that was a
// tiff that was being annotated and is prompting you to save. In this
// case throw away any future data
if (_pdtobj != NULL || m_fPromptingUser)
return TRUE;
COPYDATASTRUCT *pcds = (COPYDATASTRUCT*)lParam;
if (pcds)
{
HRESULT hr = E_FAIL;
switch (pcds->dwData)
{
case COPYDATATYPE_DATAOBJECT:
{
IStream *pstm;
if (SUCCEEDED(CreateStreamOnHGlobal(NULL, TRUE, &pstm)))
{
const LARGE_INTEGER li = {0, 0};
pstm->Write(pcds->lpData, pcds->cbData, NULL);
pstm->Seek(li, STREAM_SEEK_SET, NULL);
// unfortunaly we can not program the data object here as we are in a
// SendMessage() and any calls made on the data object will fail because
// of this. instead we grab a ref to the data object and set a timer
// so we can handle this once we have unwound from the send.
hr = CoUnmarshalInterface(pstm, IID_PPV_ARG(IDataObject, &_pdtobj));
pstm->Release();
}
}
break;
case COPYDATATYPE_FILENAME:
{
hr = GetUIObjectFromPath((LPCTSTR)pcds->lpData, IID_PPV_ARG(IDataObject, &_pdtobj));
}
break;
}
// unfortunaly we can not program the data object here as we are in a
// SendMessage() and any calls made on the data object will fail because
// of this. instead we grab a ref to the data object and set a timer
// so we can handle this once we have unwound from the send.
if (SUCCEEDED(hr))
{
SetTimer(TIMER_DATAOBJECT, 100); // do the real work here
}
}
return TRUE;
}
DWORD MakeFilterFromCodecs(LPTSTR szFilter, size_t cbFilter, UINT nCodecs, ImageCodecInfo *pCodecs, LPTSTR szExt, BOOL fExcludeTIFF)
{
size_t nOffset = 0;
DWORD dwRet = 1;
for (UINT i = 0; i < nCodecs && nOffset < cbFilter - 1; i++)
{
if (fExcludeTIFF && StrStrI(pCodecs->FilenameExtension, L"*.tif"))
{
continue;
}
// make sure there's space for nulls between strings and 2 at the end
if (4+lstrlen(pCodecs->FormatDescription) + lstrlen(pCodecs->FilenameExtension) + nOffset < cbFilter)
{
StrCpyN(szFilter+nOffset,pCodecs->FormatDescription, cbFilter -(nOffset + 1));
nOffset+=lstrlen(pCodecs->FormatDescription)+1;
StrCpyN(szFilter+nOffset,pCodecs->FilenameExtension, cbFilter -(nOffset + 1));
nOffset+=lstrlen(pCodecs->FilenameExtension)+1;
if (StrStrI(pCodecs->FilenameExtension, szExt))
{
dwRet = i + 1;
}
pCodecs++;
}
}
szFilter[nOffset] = 0;
return dwRet;
}
DWORD CPreviewWnd::_GetFilterStringForSave(LPTSTR szFilter, size_t cbFilter, LPTSTR szExt)
{
UINT nCodecs = 0;
UINT cbCodecs = 0;
BYTE *pData;
GetImageEncodersSize (&nCodecs, &cbCodecs);
DWORD dwRet = 1; // ofn.nFilterIndex is 1-based
if (cbCodecs)
{
pData = new BYTE[cbCodecs];
if (pData)
{
ImageCodecInfo *pCodecs = reinterpret_cast<ImageCodecInfo*>(pData);
if (Ok == GetImageEncoders (nCodecs, cbCodecs, pCodecs))
{
dwRet = MakeFilterFromCodecs(szFilter, cbFilter, nCodecs, pCodecs, szExt, m_pImageData->IsExtendedPixelFmt());
}
delete [] pData;
}
}
return dwRet;
}
HRESULT CPreviewWnd::SaveAs(BSTR bstrPath)
{
HRESULT hr = E_FAIL;
if (m_pImageData && m_pImageFactory)
{
IShellImageData * pSID;
hr = m_pImageData->Lock(&pSID);
if (SUCCEEDED(hr))
{
GUID guidFmt;
if (SUCCEEDED(m_pImageFactory->GetDataFormatFromPath(bstrPath, &guidFmt)))
{
IPropertyBag *pbagEnc;
hr = SHCreatePropertyBagOnMemory(STGM_READWRITE, IID_PPV_ARG(IPropertyBag, &pbagEnc));
if (SUCCEEDED(hr))
{
VARIANT var;
hr = InitVariantFromGUID(&var, guidFmt);
if (SUCCEEDED(hr))
{
hr = pbagEnc->Write(SHIMGKEY_RAWFORMAT, &var);
if (SUCCEEDED(hr))
{
hr = pSID->SetEncoderParams(pbagEnc);
}
VariantClear(&var);
}
pbagEnc->Release();
}
}
IPersistFile *ppf;
hr = pSID->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
if (SUCCEEDED(hr))
{
hr = ppf->Save(bstrPath, TRUE);
ppf->Release();
}
m_pImageData->Unlock();
}
}
return hr;
}
BOOL CPreviewWnd::_IsImageFile(LPCTSTR pszFile)
{
BOOL bRet = FALSE;
if (m_pici || _BuildDecoderList())
{
bRet = (-1 != FindInDecoderList(m_pici, m_cDecoders, pszFile));
}
return bRet;
}
BOOL CPreviewWnd::_BuildDecoderList()
{
UINT cb;
BOOL bRet = FALSE;
if (Ok == GetImageDecodersSize(&m_cDecoders, &cb))
{
m_pici = (ImageCodecInfo*)LocalAlloc(LPTR, cb);
if (m_pici)
{
if (Ok != GetImageDecoders(m_cDecoders, cb, m_pici))
{
LocalFree(m_pici);
m_pici = NULL;
}
else
{
bRet = TRUE;
}
}
}
return bRet;
}
void CPreviewWnd::OpenFileList(HWND hwnd, IDataObject *pdtobj)
{
if (NULL == hwnd)
hwnd = m_hWnd;
IStream *pstm;
HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pstm);
if (SUCCEEDED(hr))
{
hr = CoMarshalInterface(pstm, IID_IDataObject, pdtobj, MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_NORMAL);
if (SUCCEEDED(hr))
{
HGLOBAL hGlobal;
hr = GetHGlobalFromStream(pstm, &hGlobal);
if (SUCCEEDED(hr))
{
COPYDATASTRUCT cds = {0};
cds.dwData = COPYDATATYPE_DATAOBJECT;
cds.cbData = (DWORD)GlobalSize(hGlobal);
cds.lpData = GlobalLock(hGlobal);
SendMessage(hwnd, WM_COPYDATA, NULL, (LPARAM)&cds);
SetForegroundWindow(hwnd);
GlobalUnlock(hGlobal);
}
}
pstm->Release();
}
}
void CPreviewWnd::OpenFile(HWND hwnd, LPCTSTR pszFile)
{
if (NULL == hwnd)
hwnd = m_hWnd;
COPYDATASTRUCT cds = {0};
cds.dwData = COPYDATATYPE_FILENAME;
cds.cbData = (lstrlen(pszFile)+1)*sizeof(TCHAR);
cds.lpData = (void*)pszFile;
SendMessage(hwnd, WM_COPYDATA, NULL, (LPARAM)&cds);
SetForegroundWindow(hwnd);
}
// returns:
// TRUE window was re-used
BOOL CPreviewWnd::TryWindowReuse(IDataObject *pdtobj)
{
BOOL bRet = FALSE;
HWND hwnd = FindWindow(TEXT("ShImgVw:CPreviewWnd"), NULL);
if (hwnd)
{
// window reuse can't always work because shortcuts are launched on a thread that
// is too short lived to support the marshalled IDataObject given to us via WM_COPYDATA
// For now we'll try to close an existing window and open a new one.
::PostMessage(hwnd, WM_CLOSE, 0, 0);
}
return bRet;
}
// returns:
// TRUE window was re-used
BOOL CPreviewWnd::TryWindowReuse(LPCTSTR pszFileName)
{
BOOL bRet = FALSE;
HWND hwnd = FindWindow(TEXT("ShImgVw:CPreviewWnd"), NULL);
if (hwnd)
{
DWORD_PTR dwResult = FALSE;
SendMessageTimeout(hwnd, IV_ISAVAILABLE, 0, 0, SMTO_ABORTIFHUNG | SMTO_BLOCK, 1000, &dwResult);
if (dwResult)
{
OpenFile(hwnd, pszFileName);
bRet = TRUE;
}
}
return bRet;
}
STDMETHODIMP CPreviewWnd::QueryInterface(REFIID riid, void **ppv)
{
static const QITAB qit[] =
{
QITABENT(CPreviewWnd, IDropTarget),
QITABENT(CPreviewWnd, INamespaceWalkCB),
QITABENT(CPreviewWnd, IServiceProvider),
QITABENT(CPreviewWnd, IImgCmdTarget),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
STDMETHODIMP_(ULONG) CPreviewWnd::AddRef()
{
return 3;
}
STDMETHODIMP_(ULONG) CPreviewWnd::Release()
{
return 2;
}
// INamespaceWalkCB
STDMETHODIMP CPreviewWnd::FoundItem(IShellFolder *psf, LPCITEMIDLIST pidl)
{
HRESULT hr = S_FALSE;
if (m_fFirstItem && (WINDOW_MODE == m_dwMode))
{
// REVIEW: Do this in other modes too?
StatusUpdate(IDS_LOADING);
m_fFirstItem = FALSE;
hr = S_OK;
}
else
{
TCHAR szName[MAX_PATH];
DisplayNameOf(psf, pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, szName, ARRAYSIZE(szName));
if (_IsImageFile(szName))
{
hr = S_OK;
}
}
if (WINDOW_MODE == m_dwMode)
{
MSG msg;
while (PeekMessage(&msg, m_hWnd, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return hr;
}
STDMETHODIMP CPreviewWnd::EnterFolder(IShellFolder *psf, LPCITEMIDLIST pidl)
{
return S_OK;
}
STDMETHODIMP CPreviewWnd::LeaveFolder(IShellFolder *psf, LPCITEMIDLIST pidl)
{
return S_OK;
}
// IDropTarget
STDMETHODIMP CPreviewWnd::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
m_dwEffect = DROPEFFECT_NONE;
//
// We only support CFSTR_SHELLIDLIST and CF_HDROP
//
static CLIPFORMAT cfidlist = 0;
if (!cfidlist)
{
cfidlist = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_SHELLIDLIST);
}
FORMATETC fmt = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
if (SUCCEEDED(pdtobj->QueryGetData(&fmt)))
{
m_dwEffect = DROPEFFECT_COPY;
}
else
{
fmt.cfFormat = cfidlist;
if (SUCCEEDED(pdtobj->QueryGetData(&fmt)))
{
m_dwEffect = DROPEFFECT_COPY;
}
}
*pdwEffect &= m_dwEffect;
return S_OK;
}
STDMETHODIMP CPreviewWnd::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
*pdwEffect &= m_dwEffect;
return S_OK;
}
STDMETHODIMP CPreviewWnd::DragLeave()
{
m_dwEffect = DROPEFFECT_NONE;
return S_OK;
}
STDMETHODIMP CPreviewWnd::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
if (m_dwEffect != DROPEFFECT_NONE)
{
PreviewItemsFromUnk(pdtobj);
}
*pdwEffect &= m_dwEffect;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// IServiceProvider
//
//////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CPreviewWnd::QueryService(REFGUID guidService, REFIID riid, void **ppv)
{
if (SID_SImageView == guidService)
{
return QueryInterface(riid, ppv);
}
else if (m_punkSite)
{
return IUnknown_QueryService(m_punkSite, guidService, riid, ppv);
}
return E_FAIL;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// IImgCmdTarget
//
//////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CPreviewWnd::GetMode(DWORD * pdw)
{
*pdw = m_dwMode;
return S_OK;
}
STDMETHODIMP CPreviewWnd::GetPageFlags(DWORD * pdw)
{
*pdw = m_dwMultiPageMode;
return S_OK;
}
STDMETHODIMP CPreviewWnd::ZoomIn()
{
if (SLIDESHOW_MODE == m_dwMode)
{
m_ctlPreview.ZoomIn();
}
else
{
m_ctlPreview.SetMode(CZoomWnd::MODE_ZOOMIN);
m_ctlPreview.ZoomIn();
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(TRUE, 0));
_UpdateButtons(ID_ZOOMINCMD);
}
return S_OK;
}
STDMETHODIMP CPreviewWnd::ZoomOut()
{
if (SLIDESHOW_MODE == m_dwMode)
{
m_ctlPreview.ZoomOut();
}
else
{
m_ctlPreview.SetMode(CZoomWnd::MODE_ZOOMOUT);
m_ctlPreview.ZoomOut();
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(!m_ctlPreview.IsBestFit(), 0));
_UpdateButtons(ID_ZOOMOUTCMD);
}
return S_OK;
}
STDMETHODIMP CPreviewWnd::ActualSize()
{
_RefreshSelection(FALSE);
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(FALSE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(TRUE, 0));
m_ctlPreview.ActualSize();
if (m_pEvents)
{
m_pEvents->OnActualSizePress();
}
return S_OK;
}
STDMETHODIMP CPreviewWnd::BestFit()
{
_RefreshSelection(FALSE);
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ACTUALSIZECMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_BESTFITCMD, MAKELONG(FALSE, 0));
m_ctlPreview.BestFit();
if (m_pEvents)
{
m_pEvents->OnBestFitPress();
}
return S_OK;
}
STDMETHODIMP CPreviewWnd::Rotate(DWORD dwAngle)
{
WORD wRotate;
switch (dwAngle)
{
case 90:
wRotate = ID_ROTATE90CMD;
break;
case 270:
wRotate = ID_ROTATE270CMD;
break;
default:
return E_INVALIDARG;
}
// If we don't have an image yet, there is nothing for us to do.
// Note: The keyboard accelerator will hit this path if no image is selected
if (!m_pImageData)
return E_FAIL;
// We quietly (the button is disabled but just in case you hit the
// accelerator key) don't rotate WMF or EMF.
if (IsEqualGUID(ImageFormatWMF, m_pImageData->_guidFormat) || IsEqualGUID(ImageFormatEMF, m_pImageData->_guidFormat))
return E_FAIL;
// Animated GIFs are not editable even though normal GIFs are. This can
// cause a lot of confusion, so provide some feedback if the user tries
// to rotate an animated image.
if (m_pImageData->IsAnimated())
{
TCHAR szPath[MAX_PATH];
PathFromImageData(szPath, ARRAYSIZE(szPath));
m_fPromptingUser = TRUE;
ShellMessageBox(_Module.GetModuleInstance(), m_hWnd, MAKEINTRESOURCE(IDS_ROTATE_MESSAGE), MAKEINTRESOURCE(IDS_PROJNAME), MB_OK | MB_ICONERROR, szPath);
m_fPromptingUser = FALSE;
return E_FAIL;
}
// From here on out you need to goto ErrorCleanup rather than return
_UpdateButtons(wRotate);
SetCursorState(SLIDESHOW_CURSOR_BUSY);
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE90CMD, MAKELONG(FALSE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE270CMD, MAKELONG(FALSE, 0));
m_ctlToolbar.UpdateWindow();
if (m_pTaskScheduler)
{
TASKOWNERID toid;
GetTaskIDFromMode(GTIDFM_DRAW, m_dwMode, &toid);
m_pTaskScheduler->RemoveTasks(toid, ITSAT_DEFAULT_LPARAM, TRUE);
}
HRESULT hr = E_FAIL;
SIZE sz;
m_pImageData->GetSize(&sz);
// if we're thinking we can quietly save
if (m_pImageData->IsEditable() && !m_fDisableEdit && m_fCanSave)
{
// And the rotation might be lossy
if (::IsEqualGUID(ImageFormatJPEG, m_pImageData->_guidFormat) && ((sz.cx % 16 != 0) || (sz.cy % 16 != 0)))
{
int nResult = IDOK;
if (m_fWarnQuietSave)
{
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_ROTATE_LOSS) && bstrTitle.LoadString(IDS_PROJNAME))
{
// Set default to return IDOK so we know if the user selected something or
// if the "don't show me this again" bit was respected
m_fPromptingUser = TRUE;
nResult = SHMessageBoxCheck(m_hWnd, bstrMsg, bstrTitle, MB_YESNO|MB_ICONWARNING, IDOK, REGSTR_LOSSYROTATE);
m_fPromptingUser = FALSE;
}
if (nResult != IDNO)
m_fWarnQuietSave = FALSE;
}
CRegKey Key;
if (ERROR_SUCCESS != Key.Open(HKEY_CURRENT_USER, REGSTR_SHIMGVW))
{
Key.Create(HKEY_CURRENT_USER, REGSTR_SHIMGVW);
}
if (Key.m_hKey != NULL)
{
if (nResult == IDOK) // If hidden, then load last result from registry
{
DWORD dwResult = 0;
Key.QueryValue(dwResult, REGSTR_LOSSYROTATE);
nResult = (int)dwResult;
}
else // Otherwise, write this as last result to registry
{
DWORD dwResult = (DWORD)nResult;
Key.SetValue(dwResult, REGSTR_LOSSYROTATE);
}
}
if (nResult == IDNO)
goto ErrorCleanup;
}
}
CAnnotationSet* pAnnotations = m_ctlPreview.GetAnnotations();
INT_PTR nCount = pAnnotations->GetCount();
for (INT_PTR i = 0; i < nCount; i++)
{
CAnnotation* pAnnotation = pAnnotations->GetAnnotation(i);
pAnnotation->Rotate(m_ctlPreview.m_cyImage, m_ctlPreview.m_cxImage, (ID_ROTATE90CMD == wRotate));
}
m_ctlPreview.CommitAnnotations();
hr = m_pImageData->Rotate(dwAngle);
if (FAILED(hr))
goto ErrorCleanup;
// Only if we have an encoder and we haven't been explicitly told not to edit and the source is writeable
if (m_pImageData->IsEditable() && !m_fDisableEdit && m_fCanSave)
{
// on successful edit we immediately save the result. If we want to do multiple edits
// before saving then you would simply need to wait and call Save later.
// NB: We currently only allow editing of items loaded from file system paths, no path means
// no edit. This is stupid, but that's how it is for now.
hr = ImageDataSave(NULL, FALSE);
if (SUCCEEDED(hr))
m_fDirty = FALSE;
else
{
// if we failed to save then go into can't save mode
if (WINDOW_MODE == m_dwMode)
m_fCanSave = FALSE;
}
}
_UpdateImage();
if ((!m_pImageData->IsEditable() || !m_fCanSave) && WINDOW_MODE == m_dwMode)
{
if (m_fWarnNoSave)
{
m_fWarnNoSave = FALSE;
CComBSTR bstrMsg, bstrTitle;
TCHAR szMsg[MAX_PATH];
if (LoadSPString(IDS_SHIMGVW_ROTATE_CANTSAVE, szMsg, ARRAYSIZE(szMsg)) && bstrTitle.LoadString(IDS_PROJNAME))
{
m_fPromptingUser = TRUE;
SHMessageBoxCheck(m_hWnd, szMsg, bstrTitle, MB_OK|MB_ICONWARNING, IDOK, REGSTR_SAVELESS);
m_fPromptingUser = FALSE;
}
}
}
ErrorCleanup:
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE90CMD, MAKELONG(TRUE, 0));
m_ctlToolbar.SendMessage(TB_ENABLEBUTTON, ID_ROTATE270CMD, MAKELONG(TRUE, 0));
SetCursorState(SLIDESHOW_CURSOR_NOTBUSY);
return hr;
}
STDMETHODIMP CPreviewWnd::NextPage()
{
return _PrevNextPage(TRUE);
}
STDMETHODIMP CPreviewWnd::PreviousPage()
{
return _PrevNextPage(FALSE);
}
HRESULT CPreviewWnd::_PrevNextPage(BOOL fForward)
{
_RefreshSelection(FALSE);
if (m_pImageData && m_pImageData->IsMultipage())
{
if (m_fDirty)
{
m_ctlPreview.CommitAnnotations();
}
if (fForward)
{
m_pImageData->NextPage();
}
else
{
m_pImageData->PrevPage();
}
_UpdateImage();
_SetMultipageCommands();
}
return S_OK;
}
//
// When the user saves to a format other than TIFF and the current
// TIFF has annotations, we need to burn annotations
// into the current image frame before saving.
// If we ever support other multi-page format encoding besides TIFF, this
// code will get more complicated
// assumes the pSID is already locked
// note that the resulting image is always a color image. Eventually we should make
// the annotation rendering code respect the bit depth and palette of the
// current image.
Image *CPreviewWnd::_BurnAnnotations(IShellImageData *pSID)
{
Image *pimg = NULL;
if (SUCCEEDED(pSID->CloneFrame(&pimg)))
{
HDC hdc = ::GetDC(NULL);
if (hdc)
{
LPVOID pBits;
BITMAPINFO bi = {0};
bi.bmiHeader.biBitCount = 24;
bi.bmiHeader.biHeight = pimg->GetHeight();
bi.bmiHeader.biWidth = pimg->GetWidth();
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
HBITMAP hbm = CreateDIBSection(hdc, &bi, DIB_RGB_COLORS, &pBits, NULL, 0);
if (hbm)
{
//
// For ROP codes to work we need to use pure GDI, then convert the new
// DIBSection back to an Image object
//
HDC hdcMem = ::CreateCompatibleDC(hdc);
Status s = GenericError;
if (hdcMem)
{
HBITMAP hbmOld = (HBITMAP)::SelectObject(hdcMem, hbm);
Graphics *g = Graphics::FromHDC(hdcMem);
if (g)
{
s = g->DrawImage(pimg, 0L, 0L, pimg->GetWidth(), pimg->GetHeight());
g->ReleaseHDC(hdcMem);
delete g;
// now draw the annotations
m_ctlPreview.GetAnnotations()->RenderAllMarks(hdcMem);
}
::SelectObject(hdcMem, hbmOld);
::DeleteDC(hdcMem);
}
if (Ok == s)
{
//
// Now create a new Bitmap from our DIBSection
Bitmap *pbmNew = Bitmap::FromHBITMAP(hbm, NULL);
if (pbmNew)
{
pSID->ReplaceFrame(pbmNew);
}
}
DeleteObject(hbm);
}
::ReleaseDC(NULL, hdc);
}
}
return pimg;
}
void CPreviewWnd::_InvokePrintWizard()
{
if (m_fPrintable)
{
HRESULT hr = S_OK;
if (m_fDirty)
{
m_ctlPreview.CommitAnnotations();
hr = ImageDataSave(NULL, FALSE);
}
if (SUCCEEDED(hr))
{
m_fDirty = FALSE;
IPrintPhotosWizardSetInfo *pwiz;
HRESULT hr = CoCreateInstance(CLSID_PrintPhotosWizard,
NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IPrintPhotosWizardSetInfo, &pwiz));
if (SUCCEEDED(hr))
{
if (m_pImageData != NULL && m_pImageData->_guidFormat == ImageFormatTIFF && m_pImageData->IsMultipage())
hr = pwiz->SetFileListArray(&(m_ppidls[m_iCurSlide]), 1, 0);
else
hr = pwiz->SetFileListArray(m_ppidls, m_cItems, m_iCurSlide);
if (SUCCEEDED(hr))
{
m_fPromptingUser = TRUE;
hr = pwiz->RunWizard();
m_fPromptingUser = FALSE;
}
pwiz->Release();
}
// fall back to the shell if the wizard fails
if (FAILED(hr))
{
_InvokeVerb(TEXT("print"));
}
}
else
{
CComBSTR bstrMsg, bstrTitle;
if (bstrMsg.LoadString(IDS_SAVEFAILED_MSGBOX) && bstrTitle.LoadString(IDS_PROJNAME))
{
m_fPromptingUser = TRUE;
MessageBox(bstrMsg, bstrTitle, MB_OK | MB_ICONERROR | MB_APPLMODAL);
m_fPromptingUser = FALSE;
}
}
}
}
void GetTaskIDFromMode(DWORD dwTask, DWORD dwMode, TASKOWNERID *ptoid)
{
switch (dwTask)
{
case GTIDFM_DECODE:
*ptoid = (SLIDESHOW_MODE == dwMode) ? TOID_SlideshowDecode : TOID_PrimaryDecode;
break;
case GTIDFM_DRAW:
*ptoid = (SLIDESHOW_MODE == dwMode) ? TOID_DrawSlideshowFrame : TOID_DrawFrame;
break;
default:
ASSERTMSG(FALSE, "someone passed bad task to GetTaskIDFromMode");
break;
}
}
// Watch for changes in the file we are currently viewing. This ignores changes
// in the file being pre-fetched, but we'll live with that for now.
//
void CPreviewWnd::_RegisterForChangeNotify(BOOL fRegister)
{
// always deregister the current pidl first
if (m_uRegister)
{
SHChangeNotifyDeregister(m_uRegister);
m_uRegister = 0;
}
if (fRegister)
{
SHChangeNotifyEntry cne = {0};
if (SUCCEEDED(_GetItem(m_iCurSlide, (LPITEMIDLIST*)&cne.pidl)))
{
m_uRegister = SHChangeNotifyRegister(m_hWnd,
SHCNRF_ShellLevel | SHCNRF_InterruptLevel | SHCNRF_NewDelivery,
SHCNE_DISKEVENTS,
IV_ONCHANGENOTIFY,
1, &cne);
ILFree((LPITEMIDLIST)cne.pidl);
}
}
}
LRESULT CPreviewWnd::OnChangeNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
// We can assume this notify is for the currently viewed PIDL and the event
// is one that would force us to reload
//
LONG lEvent;
LPSHChangeNotificationLock pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, NULL, &lEvent);
if (pshcnl)
{
// we can't render or manipulate deleted files so don't try
if (!m_fDirty || lEvent == SHCNE_DELETE || lEvent == SHCNE_RENAMEITEM)
{
if (!m_fIgnoreNextNotify)
{
m_fDirty = FALSE;
_PreviewItem(m_iCurSlide);
}
else
{
m_fIgnoreNextNotify = FALSE;
}
bHandled = TRUE;
}
SHChangeNotification_Unlock(pshcnl);
}
return 0;
}
LRESULT CPreviewWnd::OnIsAvailable(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
bHandled = TRUE;
return !m_fPromptingUser;
}
Reference in a new issue Copy permalink