#include "precomp.h"
#include "shimgvw.h"
#include "cowsite.h"
#include "prevwnd.h"
#include "shutil.h"
#include "prwiziid.h"
#pragma hdrstop

// Context menu offset IDs
enum
{
    OFFSET_OPEN        = 0,
    OFFSET_PRINTTO,
    OFFSET_ROT90,
    OFFSET_ROT270,
    OFFSET_SETWALL,
    OFFSET_ZOOMIN,
    OFFSET_ZOOMOUT,
    OFFSET_ACTUALSIZE,
    OFFSET_BESTFIT,
    OFFSET_NEXTPAGE,
    OFFSET_PREVPAGE,
    OFFSET_MAX
};

#define PHOTOVERBS_THUMBNAIL    0x1
#define PHOTOVERBS_ICON         0x2
#define PHOTOVERBS_FILMSTRIP    0x3
#define PHOTOVERBS_SLIDESHOW    0x4
#define PHOTOVERBS_IMGPREVIEW   0x5


class CPhotoVerbs : public IContextMenu,
                    public IShellExtInit,
                    public IDropTarget,
                    public CObjectWithSite,
                    public NonATLObject
{
public:
    CPhotoVerbs();

    // IUnknown
    STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
    STDMETHOD_(ULONG, AddRef)();
    STDMETHOD_(ULONG, Release)();

    // IShellExtInit
    STDMETHODIMP Initialize(LPCITEMIDLIST pIDFolder, IDataObject *pdtobj, HKEY hKeyID);

    // IContextMenu
    STDMETHODIMP QueryContextMenu(HMENU hMenu, UINT uIndex, UINT uIDFirst, UINT uIDLast, UINT uFlags);
    STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO pCMI);
    STDMETHODIMP GetCommandString(UINT_PTR uID, UINT uFlags, UINT *res, LPSTR pName, UINT ccMax);

    // IDropTarget ***
    STDMETHODIMP DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
    STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
    STDMETHODIMP DragLeave(void);
    STDMETHODIMP Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);

private:
    ~CPhotoVerbs();
    void _RotatePictures(int iAngle, UINT idPrompt);
    void _OpenPictures();
    void _SetWallpaper();
//    HRESULT _InvokePrintToInPPW(LPCMINVOKECOMMANDINFO pCMI, IDataObject *pdtobj);
    BOOL _ImageOptionExists(IQueryAssociations *pqa, DWORD dwOption);
    HRESULT _QueryAssociations();
    DWORD _GetMode();
    BOOL _CheckForcePreview(IQueryAssociations *pqa);
    HRESULT _MapVerb(LPCMINVOKECOMMANDINFO pici, int *pidVerb);
    LONG _cRef;
    IDataObject *_pdtobj;
    BOOL  _fForcePreview;
    BOOL  _fAcceptPreview;
    BOOL  _fIncludeRotate;
    BOOL  _fIncludeSetWallpaper;
    IImgCmdTarget * _pict;              // if hosted in image preview, this allows us to delegate commands to it
    BOOL _fImgMode;                     // TRUE if we are hosted in defview and defview is in thumbnail or filmstip mode
    BOOL _fReadOnly;                    // TRUE if one or more items selected are SFGAO_READONLY

};

CPhotoVerbs::CPhotoVerbs() : _cRef(1)
{
    ASSERT(_pdtobj == NULL);
    ASSERT(_fForcePreview == FALSE);
    ASSERT(_fIncludeRotate == FALSE);
    ASSERT(_fIncludeSetWallpaper == FALSE);
}

CPhotoVerbs::~CPhotoVerbs()
{
    IUnknown_Set(&_punkSite, NULL);
    IUnknown_Set((IUnknown**)&_pdtobj, NULL);
    ATOMICRELEASE(_pict);
}

STDAPI CPhotoVerbs_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
    CPhotoVerbs *psid = new CPhotoVerbs();
    if (!psid)
    {
        *ppunk = NULL;          // incase of failure
        return E_OUTOFMEMORY;
    }

    HRESULT hr = psid->QueryInterface(IID_PPV_ARG(IUnknown, ppunk));
    psid->Release();
    return hr;
}

STDMETHODIMP CPhotoVerbs::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] =
    {
        QITABENT(CPhotoVerbs, IShellExtInit),
        QITABENT(CPhotoVerbs, IContextMenu),
        QITABENT(CPhotoVerbs, IDropTarget),
        QITABENT(CPhotoVerbs, IObjectWithSite),
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}

STDMETHODIMP_(ULONG) CPhotoVerbs::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

STDMETHODIMP_(ULONG) CPhotoVerbs::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}


// IShellExtInit

STDMETHODIMP CPhotoVerbs::Initialize(LPCITEMIDLIST pIDFolder, IDataObject *pdtobj, HKEY hKeyID)
{
    IUnknown_Set((IUnknown**)&_pdtobj, pdtobj);
    _fImgMode = FALSE;

    DWORD dwAttributes = 0;
    SHGetAttributesFromDataObject(pdtobj, SFGAO_READONLY, &dwAttributes, NULL);
    _fReadOnly  = BOOLIFY(dwAttributes);

    return S_OK;
}

BOOL CPhotoVerbs::_ImageOptionExists(IQueryAssociations *pqa, DWORD dwOption)
{
    BOOL fRetVal = FALSE;
    DWORD dwFlags = 0;
    DWORD cbFlags = sizeof(dwFlags);
    if (SUCCEEDED(pqa->GetData(0, ASSOCDATA_VALUE, TEXT("ImageOptionFlags"), &dwFlags, &cbFlags)))
    {
        fRetVal = (dwFlags & dwOption);
    }

    return fRetVal;
}

BOOL _VerbExists(IQueryAssociations *pqa, LPCTSTR pszVerb)
{
    DWORD cch;
    return SUCCEEDED(pqa->GetString(ASSOCF_VERIFY, ASSOCSTR_EXECUTABLE, pszVerb, NULL, &cch)) && cch;
}

BOOL CPhotoVerbs::_CheckForcePreview(IQueryAssociations *pqa)
{
    //  we force if the app has no a preview and the user has not customized
    //  and we are not the current default (we install on open)
    BOOL fRet = FALSE;
    if (!_VerbExists(pqa, TEXT("preview")))
    {
        //  if nobody owns we always accept
        //  this is for when somebody does an InvokeCommand("preview");
        _fAcceptPreview = TRUE;
        if (S_FALSE == pqa->GetData(0, ASSOCDATA_HASPERUSERASSOC, NULL, NULL, NULL))
        {
            WCHAR sz[MAX_PATH];
            DWORD cch = ARRAYSIZE(sz);
            _fForcePreview = FAILED(pqa->GetString(0, ASSOCSTR_COMMAND, NULL, sz, &cch));
            if (!_fForcePreview)
            {
                //  there is a default handler
                //  if its us hide the preview verb
                //  because the static menu will do it for us
                if (StrStrIW(sz, L"shimgvw.dll"))
                {
                    _fAcceptPreview = FALSE;
                }
                else
                    _fForcePreview = TRUE;
            }
        }
    }

    return fRet;
}

HRESULT CPhotoVerbs::_QueryAssociations()
{
    IQueryAssociations *pqa;
    HRESULT hr = IUnknown_QueryService(_punkSite, SID_CtxQueryAssociations, IID_PPV_ARG(IQueryAssociations, &pqa));
    if (SUCCEEDED(hr))
    {
        //  dont do preview if the user has customized
         _CheckForcePreview(pqa);
        _fIncludeRotate       = _ImageOptionExists(pqa, IMAGEOPTION_CANROTATE);
        _fIncludeSetWallpaper = _ImageOptionExists(pqa, IMAGEOPTION_CANWALLPAPER);
        pqa->Release();
        return S_OK;
    }
    else
    {
        // we may have been invoked directly instead of via ShellExecute or right-click
        _fAcceptPreview = TRUE;
    }
    return S_FALSE;
}

DWORD CPhotoVerbs::_GetMode()
{
    DWORD dwMode, dw;
    if (_pict)
    {
        _pict->GetMode(&dw);
        switch (dw)
        {
        case SLIDESHOW_MODE:
            dwMode = PHOTOVERBS_SLIDESHOW;
            break;
        case WINDOW_MODE:
            dwMode = PHOTOVERBS_IMGPREVIEW;
            break;
        case CONTROL_MODE:
            dwMode = PHOTOVERBS_FILMSTRIP;
            break;
        default:
            dwMode = PHOTOVERBS_ICON;
            break;
        }
    }
    else
    {
        dwMode = (_fImgMode) ? PHOTOVERBS_THUMBNAIL : PHOTOVERBS_ICON;
    }

    return dwMode;
}

// IContextMenu
STDMETHODIMP CPhotoVerbs::QueryContextMenu(HMENU hMenu, UINT uIndex, UINT uIDFirst, UINT uIDLast, UINT uFlags)
{
    TCHAR szBuffer[128];
    HRESULT hr = _QueryAssociations();

    DWORD dwMultiPage = MPCMD_HIDDEN;

    hr = IUnknown_QueryService(_punkSite, SID_SImageView, IID_PPV_ARG(IImgCmdTarget, &_pict));
    if (SUCCEEDED(hr))
    {
        _pict->GetPageFlags(&dwMultiPage);
    }

    IFolderView * pfv = NULL;
    hr = IUnknown_QueryService(_punkSite, SID_SFolderView, IID_PPV_ARG(IFolderView, &pfv));
    if (SUCCEEDED(hr))
    {
        UINT uViewMode;
        hr = pfv->GetCurrentViewMode(&uViewMode);
        if (SUCCEEDED(hr) &&
           ((FVM_THUMBNAIL == uViewMode) || (FVM_THUMBSTRIP == uViewMode)))
        {
            _fImgMode = TRUE;
        }
        pfv->Release();
    }

    DWORD dwMode = _GetMode();
    // always load the Open verb if no static Open verb is registered
    if (_fAcceptPreview)
    {
        if (PHOTOVERBS_SLIDESHOW != dwMode && PHOTOVERBS_IMGPREVIEW != dwMode)
        {
            LoadString(_Module.GetModuleInstance(), IDS_PREVIEW_CTX, szBuffer, ARRAYSIZE(szBuffer));
            InsertMenu(hMenu, uIndex, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_OPEN, szBuffer);

            //  only set to default if there isnt a preview already there
            if (_fForcePreview)
                SetMenuDefaultItem(hMenu, uIndex, MF_BYPOSITION);

            uIndex++;
        }
    }

    if (!(uFlags & CMF_DEFAULTONLY))
    {
        InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
        if (_fIncludeRotate)
        {
            if (PHOTOVERBS_ICON != dwMode)
            {
                UINT uFlags = MF_BYPOSITION | MF_STRING;
                if (_fReadOnly && PHOTOVERBS_THUMBNAIL == dwMode)
                {
                    uFlags |= MF_GRAYED;
                }
                else
                {
                    uFlags |= MF_ENABLED; // in all modes by thumbnails, we allow temporary rotation of readonly images
                }

                LoadString(_Module.GetModuleInstance(), IDS_ROTATE90_CTX, szBuffer, ARRAYSIZE(szBuffer));
                InsertMenu(hMenu, uIndex++, uFlags, uIDFirst + OFFSET_ROT90, szBuffer);

                LoadString(_Module.GetModuleInstance(), IDS_ROTATE270_CTX, szBuffer, ARRAYSIZE(szBuffer));
                InsertMenu(hMenu, uIndex++, uFlags, uIDFirst + OFFSET_ROT270, szBuffer);
            }
        }

        if (PHOTOVERBS_IMGPREVIEW == dwMode)
        {
            LoadString(_Module.GetModuleInstance(), IDS_ZOOMIN_CTX, szBuffer, ARRAYSIZE(szBuffer));
            InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_ZOOMIN, szBuffer);

            LoadString(_Module.GetModuleInstance(), IDS_ZOOMOUT_CTX, szBuffer, ARRAYSIZE(szBuffer));
            InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_ZOOMOUT, szBuffer);

            if (dwMultiPage != MPCMD_HIDDEN && dwMultiPage != MPCMD_DISABLED)
            {
                if (MPCMD_LASTPAGE != dwMultiPage)
                {
                    LoadString(_Module.GetModuleInstance(), IDS_NEXTPAGE_CTX, szBuffer, ARRAYSIZE(szBuffer));
                    InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_NEXTPAGE, szBuffer);
                }
                if (MPCMD_FIRSTPAGE != dwMultiPage)
                {
                    LoadString(_Module.GetModuleInstance(), IDS_PREVPAGE_CTX, szBuffer, ARRAYSIZE(szBuffer));
                    InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_PREVPAGE, szBuffer);
                }
            }
        }
        InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

        if (_fIncludeSetWallpaper)
        {
            if (PHOTOVERBS_ICON != dwMode)
            {
                LoadString(_Module.GetModuleInstance(), IDS_WALLPAPER_CTX, szBuffer, ARRAYSIZE(szBuffer));
                InsertMenu(hMenu, uIndex++, MF_BYPOSITION | MF_STRING, uIDFirst + OFFSET_SETWALL, szBuffer);
            }
        }

    }

    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, OFFSET_MAX);
}

// IDropTarget::DragEnter
HRESULT CPhotoVerbs::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
    *pdwEffect = DROPEFFECT_COPY;
    return S_OK;;
}

// IDropTarget::DragOver
HRESULT CPhotoVerbs::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
    *pdwEffect = DROPEFFECT_COPY;
    return S_OK;;
}

// IDropTarget::DragLeave
HRESULT CPhotoVerbs::DragLeave(void)
{
    return S_OK;
}

// IDropTarget::DragDrop
HRESULT CPhotoVerbs::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    *pdwEffect = DROPEFFECT_COPY;
    HRESULT hr = Initialize(NULL, pdtobj, NULL);
    if (SUCCEEDED(hr))
    {
        // we may need to get the verb.
        _OpenPictures();
    }
    return hr;
}

class VerbThreadProc : public NonATLObject
{
public:
    STDMETHOD_(ULONG, AddRef)();
    STDMETHOD_(ULONG, Release)();

    BOOL CreateVerbThread();

    VerbThreadProc(IDataObject *pdo, IUnknown *punk, HRESULT *phr);

protected:
    virtual DWORD VerbWithThreadRefCB() PURE;
    virtual DWORD VerbWithThreadRef() PURE;
    virtual DWORD VerbWithoutThreadRefCB() PURE;
    virtual DWORD VerbWithoutThreadRef() PURE;

    virtual ~VerbThreadProc();

    IDataObject *_pdo;        // the un-marshalled versions...
    IFolderView *_pfv;

private:
    static DWORD s_WithThreadRef(void *pv);
    static DWORD s_WithThreadRefCB(void *pv);

    static DWORD s_WithoutThreadRef(void *pv);
    static DWORD s_WithoutThreadRefCB(void *pv);

    void Unmarshall();

    LONG _cRef;

    IStream *_pstmDataObj;    // the marshalled IDataObject stream
    IStream *_pstmFolderView; // the marshalled IFolderView stream
};

VerbThreadProc::VerbThreadProc(IDataObject* pdo, IUnknown *punk, HRESULT *phr)
{
    _cRef = 1;

    if (punk)
    {
        IFolderView *pfv = NULL;
        if (SUCCEEDED(IUnknown_QueryService(punk, SID_SFolderView, IID_PPV_ARG(IFolderView, &pfv))))
        {
            CoMarshalInterThreadInterfaceInStream(IID_IFolderView, pfv, &_pstmFolderView);
            pfv->Release();
        }
    }

    if (pdo)
    {
        CoMarshalInterThreadInterfaceInStream(IID_IDataObject, pdo, &_pstmDataObj);
    }

    *phr = (_pstmDataObj || _pstmFolderView) ? S_OK : E_OUTOFMEMORY;
}

VerbThreadProc::~VerbThreadProc()
{
    ATOMICRELEASE(_pstmDataObj);
    ATOMICRELEASE(_pstmFolderView);
    ATOMICRELEASE(_pdo);
    ATOMICRELEASE(_pfv);
}

STDMETHODIMP_(ULONG) VerbThreadProc::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

STDMETHODIMP_(ULONG) VerbThreadProc::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

DWORD VerbThreadProc::s_WithThreadRefCB(void *pv)
{
    VerbThreadProc *potd = (VerbThreadProc *)pv;
    potd->AddRef();
    potd->Unmarshall();
    return potd->VerbWithThreadRefCB();
}

DWORD VerbThreadProc::s_WithThreadRef(void *pv)
{
    VerbThreadProc *potd = (VerbThreadProc *)pv;
    DWORD dw = potd->VerbWithThreadRef();
    potd->Release();
    return dw;
}

DWORD VerbThreadProc::s_WithoutThreadRefCB(void *pv)
{
    VerbThreadProc *potd = (VerbThreadProc *)pv;
    potd->AddRef();
    potd->Unmarshall();
    return potd->VerbWithoutThreadRefCB();
}

DWORD VerbThreadProc::s_WithoutThreadRef(void *pv)
{
    VerbThreadProc *potd = (VerbThreadProc *)pv;
    DWORD dw =  potd->VerbWithoutThreadRef();
    potd->Release();
    return dw;
}

void VerbThreadProc::Unmarshall()
{
    if (_pstmDataObj)
    {
        CoGetInterfaceAndReleaseStream(_pstmDataObj, IID_PPV_ARG(IDataObject, &_pdo));
        _pstmDataObj = NULL;
    }

    if (_pstmFolderView)
    {
        CoGetInterfaceAndReleaseStream(_pstmFolderView, IID_PPV_ARG(IFolderView, &_pfv));
        _pstmFolderView = NULL;
    }
}

BOOL VerbThreadProc::CreateVerbThread()
{
    BOOL bRet;

    // The thread ref is the more efficient start-up method, but we need to
    // handle the case where the caller doesn't have one.
    bRet = SHCreateThread(s_WithThreadRef, this, CTF_COINIT | CTF_THREAD_REF, s_WithThreadRefCB);
    if (!bRet)
    {
        bRet = SHCreateThread(s_WithoutThreadRef, this, CTF_COINIT | CTF_WAIT_ALLOWCOM, s_WithoutThreadRefCB);
    }

    return bRet;
}

class OpenThreadProc : public VerbThreadProc
{
public:
    DWORD VerbWithThreadRefCB();
    DWORD VerbWithThreadRef();
    DWORD VerbWithoutThreadRefCB();
    DWORD VerbWithoutThreadRef();

    OpenThreadProc(IDataObject *pdo, IUnknown *punk, HRESULT *phr) : VerbThreadProc(pdo, punk, phr) {};

private:
    HRESULT Walk();
    void Preview();

    CPreviewWnd* _pPreview;
};

DWORD OpenThreadProc::VerbWithThreadRefCB()
{
    return 0;
}

DWORD OpenThreadProc::VerbWithThreadRef()
{
    HRESULT hr = Walk();
    SHReleaseThreadRef();
    if (S_OK == hr)
    {
        Preview();
    }
    return 0;
}

DWORD OpenThreadProc::VerbWithoutThreadRefCB()
{
    Walk();
    return 0;
}

DWORD OpenThreadProc::VerbWithoutThreadRef()
{
    Preview();
    return 0;
}

HRESULT OpenThreadProc::Walk()
{
    HRESULT hr = E_OUTOFMEMORY;

    if (_pdo)
    {
        _pPreview = new CPreviewWnd();
        if (_pPreview)
        {
            if (!_pPreview->TryWindowReuse(_pdo))
            {
                hr = _pPreview->Initialize(NULL, WINDOW_MODE, FALSE);
                if (SUCCEEDED(hr))
                {
                    // create the viewer window before doing the expensive namespace walk
                    // so if a second instance is created it will find the window                   
                    if (_pPreview->CreateViewerWindow())
                    {                       
                        hr = _pPreview->WalkItemsToPreview(_pfv ? (IUnknown *)_pfv: (IUnknown *)_pdo);
                        if (_pfv && FAILED(hr))
                        {
                            hr = _pPreview->WalkItemsToPreview((IUnknown *)_pdo);
                        }
                    }
                    else
                    {
                        DWORD dw = GetLastError();
                        hr = HRESULT_FROM_WIN32(dw);
                    }
                }               
            }
            else
            {
                hr = S_FALSE;
            }                       
        }
        // We're done with these
        ATOMICRELEASE(_pdo);
        ATOMICRELEASE(_pfv);
    }

    return hr;
}

void OpenThreadProc::Preview()
{
    if (_pPreview)
    {   
        // viewer window should have been created by now
        _pPreview->PreviewItems();
        MSG msg;
        while (GetMessage(&msg, NULL, 0, 0) > 0)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
           
        delete _pPreview;
        _pPreview = NULL;
    }
}

void CPhotoVerbs::_OpenPictures()
{
    if (_pdtobj)
    {
        HRESULT hr;
        OpenThreadProc *potd = new OpenThreadProc(_pdtobj, _punkSite, &hr);
        if (potd)
        {
            if (SUCCEEDED(hr))
            {
                potd->CreateVerbThread();
            }
            potd->Release();
        }       
    }
}

// implement the rotate verb, this is a lengthy operation so put it onto a background
// thread if we can, marshall the IDataObject and let it do its thing...
class CRotateThreadProc : public VerbThreadProc
{
public:
    DWORD VerbWithThreadRefCB() { return 0; }
    DWORD VerbWithThreadRef() { return _Rotate(); }
    DWORD VerbWithoutThreadRefCB() { return _Rotate(); }
    DWORD VerbWithoutThreadRef() { return 0; }

    CRotateThreadProc(IDataObject* pdo, int iAngle, UINT idPrompt, HRESULT *phr);

private:
    DWORD _Rotate();

    int  _iAngle;
    UINT _idPrompt;
};

CRotateThreadProc::CRotateThreadProc(IDataObject* pdo, int iAngle, UINT idPrompt, HRESULT *phr) :
    VerbThreadProc(pdo, NULL, phr)
{
    _iAngle = iAngle;
    _idPrompt = idPrompt;
}

DWORD CRotateThreadProc::_Rotate()
{
    FORMATETC fmt = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    STGMEDIUM medium = {0};

    if (_pdo)
    {
        HRESULT hr = _pdo->GetData(&fmt, &medium);
        if (SUCCEEDED(hr))
        {
            IProgressDialog *ppd;

            hr = CoCreateInstance(CLSID_ProgressDialog,  NULL, CLSCTX_INPROC, IID_PPV_ARG(IProgressDialog, &ppd));
            if (SUCCEEDED(hr))
            {
                TCHAR szBuffer[MAX_PATH];
                TCHAR szFile[MAX_PATH];
                HDROP hd = (HDROP)medium.hGlobal;
                UINT cItems = DragQueryFile(hd, (UINT)-1, NULL, 0);

                // prime the progress dialog

                if (cItems > 1)
                {
                    LoadString(_Module.GetModuleInstance(), IDS_ROTATETITLE, szBuffer, ARRAYSIZE(szBuffer));
                    ppd->SetLine(1, T2W(szBuffer), FALSE, NULL);

                    LoadString(_Module.GetModuleInstance(), _idPrompt, szBuffer, ARRAYSIZE(szBuffer));
                    ppd->SetTitle(T2W(szBuffer));

                    ppd->SetAnimation(_Module.GetModuleInstance(), IDA_ROTATEAVI);
                    ppd->StartProgressDialog(NULL, NULL, PROGDLG_AUTOTIME, NULL);
                    ppd->SetProgress(1, cItems);
                }

                // lets get GDI+, the encoder array and start messing with the bits.   this is a
                // sync operation so check for the user cancelling the UI accordingly.

                IShellImageDataFactory *pif;
                hr = CoCreateInstance(CLSID_ShellImageDataFactory, NULL, CLSCTX_INPROC, IID_PPV_ARG(IShellImageDataFactory, &pif));
                if (SUCCEEDED(hr))
                {
                    for (UINT i = 0; (i != cItems) && !((cItems > 1) ? ppd->HasUserCancelled() : FALSE); i++)
                    {
                        if (DragQueryFile(hd, i, szFile, ARRAYSIZE(szFile)))
                        {
                            if (cItems > 1)
                            {
                                ppd->SetLine(2, T2W(szFile), TRUE, NULL);
                                ppd->SetProgress(i+1, cItems);
                            }

                            // construct an image object from the file, rotate it and save it back

                            IShellImageData *pid;
                            hr = pif->CreateImageFromFile(szFile, &pid);
                            if (SUCCEEDED(hr))
                            {
                                hr = pid->Decode(SHIMGDEC_DEFAULT,0,0);
                                if (SUCCEEDED(hr))
                                {
                                    if (!((cItems > 1) ? ppd->HasUserCancelled() : FALSE))
                                    {
                                        GUID guidFormat;
                                        SIZE sz;
                                        if ( SUCCEEDED(pid->GetRawDataFormat(&guidFormat)) &&
                                             SUCCEEDED(pid->GetSize(&sz)))
                                        {
                                            if (S_OK == pid->IsEditable())
                                            {
                                                hr = S_OK;
                                                if (::IsEqualGUID(ImageFormatJPEG, guidFormat))
                                                {
                                                    if ((sz.cx % 16) || (sz.cy % 16))
                                                    {
                                                        if (cItems > 1)
                                                        {
                                                            LoadString(_Module.GetModuleInstance(), IDS_ROTATEDLGTITLE, szBuffer, ARRAYSIZE(szBuffer));
                                                            ppd->SetLine(1, T2W(szBuffer), FALSE, NULL);
                                                        }

                                                        TCHAR szTitle[MAX_PATH];
                                                        TCHAR szText[1024];

                                                        LoadString(_Module.GetModuleInstance(), IDS_ROTATE_LOSS, szText, ARRAYSIZE(szText));
                                                        LoadString(_Module.GetModuleInstance(), IDS_ROTATE_CAPTION, szTitle, ARRAYSIZE(szTitle));

                                                        // 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
                                                        int nResult = SHMessageBoxCheck(NULL, szText, szTitle,
                                                                                        MB_YESNO|MB_ICONWARNING, IDOK, REGSTR_LOSSYROTATE);
                                                        
                                                                                                                
                                                        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)                
                                                            hr = S_FALSE; // User said No, Don't make any other noise.

                                                        if (cItems > 1)
                                                        {
                                                            LoadString(_Module.GetModuleInstance(), IDS_ROTATETITLE, szBuffer, ARRAYSIZE(szBuffer));
                                                            ppd->SetLine(1, T2W(szBuffer), FALSE, NULL);
                                                        }
                                                    }
                                                }

                                                if (hr == S_OK)
                                                {
                                                    CAnnotationSet Annotations;
                                                    Annotations.SetImageData(pid);

                                                    INT_PTR nCount = Annotations.GetCount();
                                                    for (INT_PTR ix = 0; ix < nCount; ix++)
                                                    {
                                                        CAnnotation* pAnnotation = Annotations.GetAnnotation(ix);
                                                        pAnnotation->Rotate(sz.cy, sz.cx, (_iAngle == 90));
                                                    }
                                                    Annotations.CommitAnnotations(pid);

                                                    hr = pid->Rotate(_iAngle);
                                                    if (SUCCEEDED(hr))
                                                    {
                                                        IPersistFile *ppf;
                                                        hr = pid->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
                                                        if (SUCCEEDED(hr))
                                                        {
                                                            hr = ppf->Save(NULL, TRUE);
                                                            ppf->Release();
                                                        }
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                // 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 (S_OK == pid->IsAnimated())
                                                {
                                                    // Make some noise.
                                                    ShellMessageBox(_Module.GetModuleInstance(), NULL, MAKEINTRESOURCE(IDS_ROTATE_MESSAGE), MAKEINTRESOURCE(IDS_PROJNAME), MB_OK | MB_ICONERROR, szFile);

                                                    // Don't make any other noise.
                                                    hr = S_FALSE;
                                                }// we can't safely rotate images with > 8 bits per channel either; we'd lose the extra bits
                                                else if (S_OK != pid->IsEditable())
                                                {
                                                    TCHAR szMsg[MAX_PATH];
                                                    // silently fail if the string isn't available
                                                    if (LoadSPString(IDS_SHIMGVW_ROTATE_MESSAGE_EXT, szMsg, ARRAYSIZE(szMsg)))
                                                    {
                                                        ShellMessageBox(_Module.GetModuleInstance(), NULL, szMsg, MAKEINTRESOURCE(IDS_PROJNAME), MB_OK | MB_ICONERROR, szFile);
                                                    }
                                                    // Don't make any other noise.
                                                    hr = S_FALSE;
                                                }                                                
                                            }
                                        }
                                    }
                                }

                                pid->Release();
                            }
                            if (FAILED(hr))
                            {
                                if (cItems > 1)
                                {
                                    LoadString(_Module.GetModuleInstance(), IDS_ROTATEDLGTITLE, szBuffer, ARRAYSIZE(szBuffer));
                                    ppd->SetLine(1, T2W(szBuffer), FALSE, NULL);
                                }

                                ShellMessageBox(_Module.GetModuleInstance(), NULL, MAKEINTRESOURCE(IDS_ROTATE_ERROR), MAKEINTRESOURCE(IDS_ROTATE_CAPTION), MB_OK|MB_ICONERROR);

                                if (cItems > 1)
                                {
                                    LoadString(_Module.GetModuleInstance(), IDS_ROTATETITLE, szBuffer, ARRAYSIZE(szBuffer));
                                    ppd->SetLine(1, T2W(szBuffer), FALSE, NULL);
                                }
                            }
                        }
                    }
                    pif->Release();
                }

                if (cItems > 1)
                {
                    ppd->StopProgressDialog();
                }
                // Since we always create it, we must always Release it.
                ppd->Release();
            }
            ReleaseStgMedium(&medium);
        }
    }

    return 0;
}

void CPhotoVerbs::_RotatePictures(int iAngle, UINT idPrompt)
{
    if (_pict)
    {
        _pict->Rotate(iAngle);
    }
    else if (_pdtobj)
    {
        HRESULT hr;
        CRotateThreadProc *potd = new CRotateThreadProc(_pdtobj, iAngle, idPrompt, &hr);
        if (potd)
        {
            if (SUCCEEDED(hr))
            {
                potd->CreateVerbThread();
            }
            potd->Release();
        }
    }
}


DWORD CALLBACK _WallpaperThreadProc(void *pv)
{
    IStream *pstm = (IStream*)pv;
    IDataObject *pdtobj;
    HRESULT hr = CoGetInterfaceAndReleaseStream(pstm, IID_PPV_ARG(IDataObject, &pdtobj));
    if (SUCCEEDED(hr))
    {
        FORMATETC fmt = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
        STGMEDIUM medium = {0};

        hr = pdtobj->GetData(&fmt, &medium);
        if (SUCCEEDED(hr))
        {
            TCHAR szPath[MAX_PATH];
            HDROP hd = (HDROP)medium.hGlobal;

            if (DragQueryFile(hd, 0, szPath, ARRAYSIZE(szPath))) // only set the first one selected as the background
            {
                SetWallpaperHelper(szPath);
            }

            ReleaseStgMedium(&medium);
        }
        pdtobj->Release();
    }
    return 0;
}

void CPhotoVerbs::_SetWallpaper()
{
    if (_pdtobj)
    {
        IStream *pstm;
        if (FAILED(CoMarshalInterThreadInterfaceInStream(IID_IDataObject, _pdtobj, &pstm)) ||
            !SHCreateThread(_WallpaperThreadProc, pstm, CTF_COINIT, NULL))
        {
            ATOMICRELEASE(pstm);
        }
    }
}

HRESULT _InvokePrintToInPPW(LPCMINVOKECOMMANDINFO pCMI,IDataObject * pdtobj)
{
    HRESULT hr = E_FAIL;
    HMODULE hDll = LoadLibrary( TEXT("photowiz.dll") );
    if (hDll)
    {
        LPFNPPWPRINTTO pfnPrintTo = (LPFNPPWPRINTTO)GetProcAddress( hDll, PHOTO_PRINT_WIZARD_PRINTTO_ENTRY );
        if (pfnPrintTo)
        {
            hr = pfnPrintTo( pCMI, pdtobj );
        }

        FreeLibrary( hDll );
    }

    return hr;
}

const struct
{
    LPCSTR pszVerb;
    int idVerb;
}
c_szVerbs[] =
{
    { "preview", OFFSET_OPEN},
    { "printto", OFFSET_PRINTTO},
    { "rotate90", OFFSET_ROT90},
    { "rotate270", OFFSET_ROT270},
};

HRESULT CPhotoVerbs::_MapVerb(LPCMINVOKECOMMANDINFO pici, int *pidVerb)
{
    HRESULT hr = S_OK;
    if (IS_INTRESOURCE(pici->lpVerb))
    {
        *pidVerb = LOWORD(pici->lpVerb);
    }
    else
    {
        hr = E_INVALIDARG;
        for (int i = 0; i < ARRAYSIZE(c_szVerbs); i++)
        {
            if (0 == lstrcmpiA(pici->lpVerb, c_szVerbs[i].pszVerb))
            {
                hr = S_OK;
                *pidVerb = c_szVerbs[i].idVerb;
                break;
            }
        }
    }
    return hr;
}

STDMETHODIMP CPhotoVerbs::InvokeCommand(LPCMINVOKECOMMANDINFO pCMI)
{
    int idVerb;
    HRESULT hr = _MapVerb(pCMI, &idVerb);
    if (SUCCEEDED(hr))
    {
        switch (idVerb)
        {
        case OFFSET_OPEN:
            if (_fAcceptPreview)
                _OpenPictures();
            else
                hr = E_FAIL;
            break;

        case OFFSET_PRINTTO:
            hr = _InvokePrintToInPPW(pCMI,_pdtobj);
            break;

        case OFFSET_ROT90:
            _RotatePictures(90, IDS_ROTATE90);
            break;

        case OFFSET_ROT270:
            _RotatePictures(270, IDS_ROTATE270);
            break;

        case OFFSET_ZOOMIN:
            if (_pict)
            {
                _pict->ZoomIn();
            }
            break;

        case OFFSET_ZOOMOUT:
            if (_pict)
            {
                _pict->ZoomOut();
            }
            break;

        case OFFSET_ACTUALSIZE:
            if (_pict)
            {
                _pict->ActualSize();
            }
            break;

        case OFFSET_BESTFIT:
            if (_pict)
            {
                _pict->BestFit();
            }
            break;

        case OFFSET_NEXTPAGE:
            if (_pict)
            {
                _pict->NextPage();
            }
            break;

        case OFFSET_PREVPAGE:
            if (_pict)
            {
                _pict->PreviousPage();
            }
            break;

        case OFFSET_SETWALL:
            _SetWallpaper();
            break;

       default:
            hr = E_INVALIDARG;
            break;
        }
    }

    return hr;
}

STDMETHODIMP CPhotoVerbs::GetCommandString(UINT_PTR uID, UINT uFlags, UINT *res, LPSTR pName, UINT cchMax)
{
    HRESULT hr = S_OK;
    UINT idSel = (UINT)uID;

    switch (uFlags)
    {
    case GCS_VERBW:
    case GCS_VERBA:
        if (idSel < ARRAYSIZE(c_szVerbs))
        {
            if (uFlags == GCS_VERBW)
            {
                SHAnsiToUnicode(c_szVerbs[idSel].pszVerb, (LPWSTR)pName, cchMax);
            }
            else
            {
                StrCpyNA(pName, c_szVerbs[idSel].pszVerb, cchMax);
            }
        }
        break;

    case GCS_HELPTEXTW:
        LoadStringW(_Module.GetResourceInstance(), idSel+IDH_HELP_FIRST, (LPWSTR)pName, cchMax);
        break;

    case GCS_HELPTEXTA:
        LoadStringA(_Module.GetResourceInstance(), idSel+IDH_HELP_FIRST, (LPSTR)pName, cchMax);
        break;

    case GCS_VALIDATEA:
    case GCS_VALIDATEW:
        hr = E_NOTIMPL;
        break;
    }

    return hr;
}


void WINAPI ImageView_Fullscreen(HWND hwnd, HINSTANCE hAppInstance, LPTSTR pszCmdLine, int nCmdShow)
{
    HRESULT hr = SHCoInitialize();  // suppress OLE1 DDE window
    if (SUCCEEDED(hr))
    {
        OleInitialize(NULL);    // needed to get drag and drop to work

        IDataObject *pdtobj;
        hr = GetUIObjectFromPath(pszCmdLine, IID_PPV_ARG(IDataObject, &pdtobj));
        if (SUCCEEDED(hr))
        {
            // this scope is required to make sure cwndPreview gets destroyed before we call SHCoUninitialize  
            // the preview wnd will init GDI+ too
            CPreviewWnd cwndPreview;
            if (!cwndPreview.TryWindowReuse(pszCmdLine))
            {               
                if (SUCCEEDED(cwndPreview.Initialize(NULL, WINDOW_MODE, FALSE)) && cwndPreview.CreateViewerWindow())
                {
                    cwndPreview.PreviewItemsFromUnk(pdtobj);

                    MSG msg;
                    while (GetMessage(&msg, NULL, 0, 0))
                    {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                    }
                }
            }
            pdtobj->Release();
        }

        OleUninitialize();
    }

    SHCoUninitialize(hr);
}

void WINAPI ImageView_FullscreenA(HWND hwnd, HINSTANCE hAppInstance, LPSTR pszCmdLine, int nCmdShow)
{
    TCHAR szCmdLine[MAX_PATH*2];
    SHAnsiToTChar(pszCmdLine, szCmdLine, ARRAYSIZE(szCmdLine));
    ImageView_Fullscreen(hwnd, hAppInstance, szCmdLine, nCmdShow);
}

void WINAPI ImageView_FullscreenW(HWND hwnd, HINSTANCE hAppInstance, LPWSTR pszCmdLine, int nCmdShow)
{
    ImageView_Fullscreen(hwnd, hAppInstance, pszCmdLine, nCmdShow);
}

// To work around ACDSEE lower cases the shell command stuff causing us to need this
// export an all lowercase version of this function.  The short is, case matters for RunDLL32 exports.
void WINAPI imageview_fullscreenW(HWND hwnd, HINSTANCE hAppInstance, LPWSTR pszCmdLine, int nCmdShow)
{
    ImageView_FullscreenW(hwnd, hAppInstance, pszCmdLine, nCmdShow);
}

LPTSTR ParseCmdLine( LPTSTR pInput, LPTSTR pOutput, BOOL bStripQuotes )
{
    // copies the next token on the line to pOutput and returns
    // the first white space character after the processed token

    if (!pInput || (!*pInput) || !pOutput)
    {
        return pInput;
    }

    // first, skip any leading whitespace
    while (*pInput == TEXT(' '))
    {
        pInput++;
    }

    if (!(*pInput))
    {
        return pInput;
    }

    // next, start copying token

    // if the token starts with a
    // quote, note that and copy it
    BOOL bStartedWithQuote = FALSE;
    if (*pInput == TEXT('\"'))
    {
        bStartedWithQuote = TRUE;
        if (bStripQuotes)
        {
            pInput++;
        }
        else
        {
            *pOutput++ = *pInput++;
        }
    }

    // figure out what to stop on
    TCHAR cStopChar;
    if (bStartedWithQuote)
    {
        cStopChar = TEXT('\"');
    }
    else
    {
        cStopChar = TEXT(' ');
    }

    // copy up to the delimeter
    while( *pInput && (*pInput != cStopChar))
    {
        *pOutput++ = *pInput++;
    }

    // if the delimeter was a quote
    // we need to copy it into the output
    if (bStartedWithQuote && (*pInput == TEXT('\"')))
    {
        if (bStripQuotes)
        {
            pInput++;
        }
        else
        {
            *pOutput++ = *pInput++;
        }
    }

    *pOutput = 0;

    return pInput;

}


void WINAPI ImageView_PrintTo(HWND hwnd, HINSTANCE hAppInstance, LPTSTR pszCmdLine, int nCmdShow)
{
    // The command line comes to us like this (everything inside the <>):
    // </pt filename printer_name>

    TCHAR szFileName[ 1024 ];
    TCHAR szPrinterName[ 1024 ];

    LPTSTR psz = pszCmdLine;
    if (*psz == TEXT('/'))
    {
        // skip the "/pt"
        psz = ParseCmdLine( psz, szFileName, TRUE );
    }

    // Get the filename
    psz = ParseCmdLine( psz, szFileName, TRUE );

    // Get the printer name
    psz = ParseCmdLine( psz, szPrinterName, TRUE );


    // create a dataobject for the file in question, and then call
    // into photowiz to print it out...

    HRESULT hrInit = SHCoInitialize();
    if (SUCCEEDED(hrInit))
    {
        IDataObject *pdtobj;
        HRESULT hr = GetUIObjectFromPath(szFileName, IID_PPV_ARG(IDataObject, &pdtobj));
        if (SUCCEEDED(hr))
        {
            // Create CMINVOKECAMMANDINFO to pass to photowiz
            CMINVOKECOMMANDINFOEX cmi = {0};
            cmi.cbSize = sizeof(cmi);
            cmi.fMask         = CMIC_MASK_UNICODE;
            cmi.lpVerbW       = L"printto";
            cmi.lpParametersW = szPrinterName;

            hr = _InvokePrintToInPPW((LPCMINVOKECOMMANDINFO )&cmi, pdtobj);
            pdtobj->Release();
        }
    }
    SHCoUninitialize(hrInit);
}

void WINAPI ImageView_PrintToA(HWND hwnd, HINSTANCE hAppInstance, LPSTR pszCmdLine, int nCmdShow)
{
    TCHAR szCmdLine[1024];
    SHAnsiToTChar(pszCmdLine, szCmdLine, ARRAYSIZE(szCmdLine));
    ImageView_PrintTo(hwnd, hAppInstance, szCmdLine, nCmdShow);
}

void WINAPI ImageView_PrintToW(HWND hwnd, HINSTANCE hAppInstance, LPWSTR pszCmdLine, int nCmdShow)
{
    ImageView_PrintTo( hwnd, hAppInstance, pszCmdLine, nCmdShow );
}