Windows2000/private/shell/ext/pack/pack2.cpp

#include "priv.h"
#include "privcpp.h"

#define CPP_FUNCTIONS
// #include <crtfree.h>

UINT    g_cfFileContents;
UINT    g_cfFileDescriptor;
UINT    g_cfObjectDescriptor;
UINT    g_cfEmbedSource;
UINT    g_cfFileNameW;

INT     g_cxIcon;
INT     g_cyIcon;
INT     g_cxArrange;
INT     g_cyArrange;
HFONT   g_hfontTitle;

static TCHAR szUserType[] = TEXT("Package");
static TCHAR szDefTempFile[] = TEXT("PKG");

CPackage::CPackage() :
    _cRef(1)
{
    DebugMsg(DM_TRACE, "pack - CPackage() called.");
    g_cRefThisDll++;

    ASSERT(_cf == 0);
    ASSERT(_panetype == NOTHING);
    ASSERT(_pEmbed == NULL);
    ASSERT(_pCml == NULL);
    ASSERT(_fLoaded == FALSE);

    ASSERT(_lpszContainerApp == NULL);
    ASSERT(_lpszContainerObj == NULL);

    ASSERT(_fIsDirty == FALSE);

    ASSERT(_pIStorage == NULL);
    ASSERT(_pstmFileContents == NULL);
    ASSERT(_pstm == NULL);

    ASSERT(_pIPersistStorage == NULL);
    ASSERT(_pIDataObject == NULL);
    ASSERT(_pIOleObject == NULL);
    ASSERT(_pIViewObject2 == NULL);
    ASSERT(_pIAdviseSink == NULL);
    ASSERT(_pIRunnableObject == NULL);

    ASSERT(_pIDataAdviseHolder == NULL);
    ASSERT(_pIOleAdviseHolder == NULL);
    ASSERT(_pIOleClientSite == NULL);

    ASSERT(_pViewSink == NULL);
    ASSERT(_dwViewAspects == 0);
    ASSERT(_dwViewAdvf == 0);

    ASSERT(_cVerbs == 0);
    ASSERT(_nCurVerb == 0);
    ASSERT(_pVerbs == NULL);
    ASSERT(_pcm == NULL);
}


CPackage::~CPackage()
{
    DebugMsg(DM_TRACE, "pack - ~CPackage() called.");

    // We should never be destroyed unless our ref count is zero.
    ASSERT(_cRef == 0);

    g_cRefThisDll--;

    // Destroy our interfaces...

    delete _pIOleObject;
    delete _pIViewObject2;
    delete _pIDataObject;
    delete _pIPersistStorage;
    delete _pIAdviseSink;
    delete _pIRunnableObject;

    // Destroy the packaged file structure...

    DestroyIC();

    // we destroy depending on which type of object we had packaged
    switch (_panetype) {
    case PEMBED:
        if (_pEmbed->pszTempName) {
            DeleteFile(_pEmbed->pszTempName);
            delete _pEmbed->pszTempName;
        }
        delete _pEmbed;
        break;

    case CMDLINK:
        delete _pCml;
        break;

    }

    // Release Advise pointers...

    if (_pIDataAdviseHolder)
        _pIDataAdviseHolder->Release();
    if (_pIOleAdviseHolder)
        _pIOleAdviseHolder->Release();
    if (_pIOleClientSite)
        _pIOleClientSite->Release();


    // Release Storage pointers...

    if (_pIStorage)
        _pIStorage->Release();
    if (_pstmFileContents)
        _pstmFileContents->Release();
    if (_pstm)
        _pstm->Release();

    delete _lpszContainerApp;
    delete _lpszContainerObj;

    ReleaseContextMenu();
    if (NULL != _pVerbs) {
        for (ULONG i = 0; i < _cVerbs; i++) {
            delete _pVerbs[i].lpszVerbName;
        }
        delete _pVerbs;
    }

    DebugMsg(DM_TRACE, "CPackage being destroyed. _cRef == %d", _cRef);
}

HRESULT CPackage::Init()
{

    // initializes parts of a package object that have a potential to fail
    // return:  S_OK            -- everything initialized
    //          E_FAIL          -- error in initialzation
    //          E_OUTOFMEMORY   -- out of memory


    DebugMsg(DM_TRACE, "pack - Init() called.");

    // Initialize all the interfaces...

    if (!(_pIOleObject = new CPackage_IOleObject(this)))
        return E_OUTOFMEMORY;
    if (!(_pIViewObject2 = new CPackage_IViewObject2(this)))
        return E_OUTOFMEMORY;
    if (!(_pIDataObject = new CPackage_IDataObject(this)))
        return E_OUTOFMEMORY;
    if (!(_pIPersistStorage = new CPackage_IPersistStorage(this)))
        return E_OUTOFMEMORY;
    if (!(_pIPersistFile = new CPackage_IPersistFile(this)))
        return E_OUTOFMEMORY;
    if (!(_pIAdviseSink = new CPackage_IAdviseSink(this)))
        return E_OUTOFMEMORY;
    if (!(_pIRunnableObject = new CPackage_IRunnableObject(this)))
        return E_OUTOFMEMORY;

    // Get some system metrics that we'll need later...

    LOGFONT lf;
    SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, FALSE);
    SystemParametersInfo(SPI_ICONHORIZONTALSPACING, 0, &g_cxArrange, FALSE);
    SystemParametersInfo(SPI_ICONVERTICALSPACING, 0, &g_cyArrange, FALSE);
    g_cxIcon = GetSystemMetrics(SM_CXICON);
    g_cyIcon = GetSystemMetrics(SM_CYICON);
    g_hfontTitle = CreateFontIndirect(&lf);

    // register some clipboard formats that we support...

    g_cfFileContents = RegisterClipboardFormat(CFSTR_FILECONTENTS);
    g_cfFileDescriptor = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
    g_cfObjectDescriptor = RegisterClipboardFormat(CFSTR_OBJECTDESCRIPTOR);
    g_cfEmbedSource = RegisterClipboardFormat(CFSTR_EMBEDSOURCE);
    g_cfFileNameW = RegisterClipboardFormat(TEXT("FileNameW"));

    // Initialize a generic icon
    _lpic = IconCreate();
    IconRefresh();


    return S_OK;
}



// IUnknown Methods...



HRESULT CPackage::QueryInterface(REFIID iid, void** ppvObj)
{
    DebugMsg(DM_TRACE, "pack - QueryInterface() called.");

    if (iid == IID_IUnknown) {
        DebugMsg(DM_TRACE, "         getting IID_IUnknown");
        *ppvObj = (void*)this;
    } else if (iid == IID_IOleObject) {
        DebugMsg(DM_TRACE, "         getting IID_IOleObject");
        *ppvObj = (void*)_pIOleObject;
    } else if ((iid == IID_IViewObject2) || (iid == IID_IViewObject)) {
        DebugMsg(DM_TRACE, "         getting IID_IViewObject");
        *ppvObj = (void*)_pIViewObject2;
    } else if (iid == IID_IDataObject) {
        DebugMsg(DM_TRACE, "         getting IID_IDataObject");
        *ppvObj = (void*)_pIDataObject;
    } else if ((iid == IID_IPersistStorage) || (iid == IID_IPersist)) {
        DebugMsg(DM_TRACE, "         getting IID_IPersistStorage");
        *ppvObj = (void*)_pIPersistStorage;
    } else if (iid == IID_IPersistFile) {
        DebugMsg(DM_TRACE, "         getting IID_IPersistFile");
        *ppvObj = (void*)_pIPersistFile;
    } else if (iid == IID_IAdviseSink) {
        DebugMsg(DM_TRACE, "         getting IID_IAdviseSink");
        *ppvObj = (void*)_pIAdviseSink;
    } else if (iid == IID_IRunnableObject) {
        DebugMsg(DM_TRACE, "         getting IID_IRunnableObject");
        *ppvObj = (void*)_pIRunnableObject;
    } else if (iid == IID_IEnumOLEVERB) {
        DebugMsg(DM_TRACE, "         getting IID_IEnumOLEVERB");
        *ppvObj = (IEnumOLEVERB*)this;
    } else {
        *ppvObj = NULL;
        return E_NOINTERFACE;
    }

    ((LPUNKNOWN)*ppvObj)->AddRef();
    return S_OK;
}

ULONG CPackage::AddRef()
{
    _cRef++;
    return _cRef;
}

ULONG CPackage::Release()
{
    _cRef--;
    if (_cRef > 0)
        return _cRef;

    delete this;
    return 0;
}

HRESULT CPackage_CreateInstnace(LPUNKNOWN* ppunk)
{
    DebugMsg(DM_TRACE, "pack - CreateInstance called");

    *ppunk = NULL;              // null the out param

    CPackage* pPack = new CPackage;
    if (!pPack)
        return E_OUTOFMEMORY;

    if (FAILED(pPack->Init())) {
        delete pPack;
        return E_OUTOFMEMORY;
    }

    *ppunk = pPack;
    return S_OK;
}

STDMETHODIMP CPackage::Next(ULONG celt, OLEVERB* rgVerbs, ULONG* pceltFetched)
{
    HRESULT hr;
    if (NULL != rgVerbs) {
        if (1 == celt) {
            if (_nCurVerb < _cVerbs) {
                ASSERT(NULL != _pVerbs);
                *rgVerbs = _pVerbs[_nCurVerb];
                if ((NULL != _pVerbs[_nCurVerb].lpszVerbName) &&
                    (NULL != (rgVerbs->lpszVerbName = (LPWSTR)CoTaskMemAlloc(
                    (lstrlenW(_pVerbs[_nCurVerb].lpszVerbName) + 1) * SIZEOF(WCHAR))))) {
                    StrCpyW(rgVerbs->lpszVerbName, _pVerbs[_nCurVerb].lpszVerbName);
                }
                _nCurVerb++;
                hr = S_OK;
            } else {
                hr = S_FALSE;
            }
            if (NULL != pceltFetched) {
                *pceltFetched = (S_OK == hr) ? 1 : 0;
            }
        } else if (NULL != pceltFetched) {
            int cVerbsToCopy = min(celt, _cVerbs - _nCurVerb);
            if (cVerbsToCopy > 0) {
                ASSERT(NULL != _pVerbs);
                CopyMemory(rgVerbs, &(_pVerbs[_nCurVerb]), cVerbsToCopy * sizeof(OLEVERB));
                for (int i = 0; i < cVerbsToCopy; i++) {
                    if ((NULL != _pVerbs[_nCurVerb + i].lpszVerbName) &&
                        (NULL != (rgVerbs[i].lpszVerbName = (LPWSTR)CoTaskMemAlloc(
                        (lstrlenW(_pVerbs[_nCurVerb + i].lpszVerbName) + 1) * SIZEOF(WCHAR))))) {
                        StrCpyW(rgVerbs[i].lpszVerbName, _pVerbs[_nCurVerb + i].lpszVerbName);
                    }
                }
                _nCurVerb += cVerbsToCopy;
            }
            *pceltFetched = (ULONG)cVerbsToCopy;
            hr = (celt == (ULONG)cVerbsToCopy) ? S_OK : S_FALSE;
        } else {
            hr = E_INVALIDARG;
        }
    } else {
        hr = E_INVALIDARG;
    }
    return hr;
}

STDMETHODIMP CPackage::Skip(ULONG celt)
{
    if (_nCurVerb + celt > _cVerbs) {
        // there aren't enough elements, go to the end and return S_FALSE
        _nCurVerb = _cVerbs;
        return S_FALSE;
    } else {
        _nCurVerb += celt;
        return S_OK;
    }
}

STDMETHODIMP CPackage::Reset()
{
    _nCurVerb = 0;
    return S_OK;
}

STDMETHODIMP CPackage::Clone(IEnumOLEVERB** ppEnum)
{
    if (NULL != ppEnum) {
        *ppEnum = NULL;
    }
    return E_NOTIMPL;
}



// Package helper functions



HRESULT  CPackage::EmbedInitFromFile(LPTSTR lpFileName, BOOL fInitFile)
{

    // get's the file size of the packaged file and set's the name
    // of the packaged file if fInitFile == TRUE.
    // return:  S_OK    -- initialized ok
    //          E_FAIL  -- error initializing file


    DWORD dwSize;


    // if this is the first time we've been called, then we need to allocate
    // memory for the _pEmbed structure
    if (_pEmbed == NULL) {
        _pEmbed = new EMBED;
        if (_pEmbed) {
            _pEmbed->pszTempName = NULL;
            _pEmbed->hTask = NULL;
            _pEmbed->poo = NULL;
            _pEmbed->fIsOleFile = TRUE;
        }
    }

    if (_pEmbed == NULL)
        return E_OUTOFMEMORY;


    // open the file to package...

    HANDLE fh = CreateFile(lpFileName, GENERIC_READ, FILE_SHARE_READWRITE,
                           NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
    if (fh == INVALID_HANDLE_VALUE) {
        DWORD dwError = GetLastError();
        return E_FAIL;
    }

    _panetype = PEMBED;

    // Get the size of the file
    _pEmbed->fd.nFileSizeLow = GetFileSize(fh, &dwSize);
    if (_pEmbed->fd.nFileSizeLow == 0xFFFFFFFF) {
        DWORD dwError = GetLastError();
        return E_FAIL;
    }
    ASSERT(dwSize == 0);
    _pEmbed->fd.nFileSizeHigh = 0L;
    _pEmbed->fd.dwFlags = FD_FILESIZE;

    // We only want to set the filename if this is the file to be packaged.
    // If it's only a temp file that we're reloading (fInitFile == FALSE) then
    // don't bother setting the filename.

    if (fInitFile) {
        lstrcpy(_pEmbed->fd.cFileName, lpFileName);
        DestroyIC();
        _lpic = IconCreateFromFile(lpFileName);
        if (_pIDataAdviseHolder)
            _pIDataAdviseHolder->SendOnDataChange(_pIDataObject, 0, NULL);
        if (_pViewSink)
            _pViewSink->OnViewChange(_dwViewAspects, _dwViewAdvf);
    }

    _fIsDirty = TRUE;
    CloseHandle(fh);
    return S_OK;
}

HRESULT CPackage::CmlInitFromFile(LPTSTR lpFileName, BOOL fUpdateIcon)
{
    // if this is the first time we've been called, then we need to allocate
    // memory for the _pCml structure
    if (_pCml == NULL) {
        _pCml = new CML;
        if (_pCml) {
            // we don't use this, but an old packager accessing us might.
            _pCml->fCmdIsLink = FALSE;
        }
    }

    if (_pCml == NULL)
        return E_OUTOFMEMORY;

    _panetype = CMDLINK;
    lstrcpy(_pCml->szCommandLine, lpFileName);
    _fIsDirty = TRUE;

    if (fUpdateIcon) {
        DestroyIC();
        _lpic = IconCreateFromFile(lpFileName);

        if (_pIDataAdviseHolder)
            _pIDataAdviseHolder->SendOnDataChange(_pIDataObject, 0, NULL);

        if (_pViewSink)
            _pViewSink->OnViewChange(_dwViewAspects, _dwViewAdvf);
    }
    return S_OK;
}


HRESULT CPackage::InitFromPackInfo(LPPACKAGER_INFO lppi)
{
    HRESULT hr;
    DWORD   dwFileAttributes = GetFileAttributes(lppi->szFilename);

    // Ok, we need to test whether the user tried to package a folder
    // instead of a file.  If s/he did, then we'll just create a link
    // to that folder instead of an embedded file.


    if ((dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
        hr = CmlInitFromFile(lppi->szFilename, FALSE);
    } else {
        // we pass FALSE here, because we don't want to write the icon
        // information.

        hr = EmbedInitFromFile(lppi->szFilename, FALSE);
        lstrcpy(_pEmbed->fd.cFileName, lppi->szFilename);
        _panetype = PEMBED;
    }

    // set the icon information
    lstrcpy(_lpic->szIconPath, lppi->szIconPath);
    _lpic->iDlgIcon = lppi->iIcon;
    lstrcpy(_lpic->szIconText, lppi->szLabel);
    IconRefresh();

    // we need to tell the client we want to be saved...it should be smart
    // enough to do it anyway, but we can't take any chances.
    if (_pIOleClientSite)
        _pIOleClientSite->SaveObject();

    return hr;
}

HRESULT CPackage::CreateTempFileName()
{
    ASSERT(NULL != _pEmbed);
    TCHAR szDefPath[MAX_PATH];
    if (_pEmbed->pszTempName) {
        return S_OK;
    } else if (GetTempPath(ARRAYSIZE(szDefPath), szDefPath)) {
        LPTSTR pszFile;
        if ((NULL != _lpic) && (TEXT('\0') != _lpic->szIconText[0])) {
            pszFile = _lpic->szIconText;
        } else {
            pszFile = PathFindFileName(_pEmbed->fd.cFileName);
        }
        PathAppend(szDefPath, pszFile);
        if (PathFileExists(szDefPath)) {
            TCHAR szOriginal[MAX_PATH];
            lstrcpy(szOriginal, szDefPath);
            PathYetAnotherMakeUniqueName(szDefPath, szOriginal, NULL, NULL);
        }

        _pEmbed->pszTempName = new TCHAR[lstrlen(szDefPath) + 1];
        if (!_pEmbed->pszTempName) {
            DebugMsg(DM_TRACE, "            couldn't alloc memory for pszTempName!!");
            return E_OUTOFMEMORY;
        }
        lstrcpy(_pEmbed->pszTempName, szDefPath);
        return S_OK;
    } else {
        DebugMsg(DM_TRACE, "            couldn't get temp path!!");
        return E_FAIL;
    }
}

HRESULT CPackage::CreateTempFile()
{

    // used to create a temporary file that holds the file contents of the
    // packaged file.  the old packager used to keep the packaged file in
    // memory which is just a total waste.  so, being as we're much more
    // efficient, we create a temp file whenever someone wants to do something
    // with our contents.  we initialze the temp file from the original file
    // to package or our persistent storage depending on whether we are a new
    // package or a loaded package
    // return:  S_OK    -- temp file created
    //          E_FAIL  -- error creating temp file


    DebugMsg(DM_TRACE, "            CreateTempFile() called.");

    HRESULT hr = CreateTempFileName();
    if (FAILED(hr)) {
        return hr;
    }

    if (PathFileExists(_pEmbed->pszTempName)) {
        DebugMsg(DM_TRACE, "            already have a temp file!!");
        return S_OK;
    }

    // if we weren't loaded from a storage then we're in the process of
    // creating a package, and should be able to copy the packaged file
    // to create a temp file

    if (!_fLoaded) {
        if (!(CopyFile(_pEmbed->fd.cFileName, _pEmbed->pszTempName, FALSE))) {
            DebugMsg(DM_TRACE, "            couldn't copy file!!");
            return E_FAIL;
        }
    } else {
        TCHAR szTempFile[MAX_PATH];
        // copy the file name because _pEmbed may get re-created below,
        // but we want to hold on to this filename:
        lstrcpy(szTempFile, _pEmbed->pszTempName);

        // if we have a valid stream, but not a file contents stream,
        // it's because we went hands off and didn't know where to put
        // the seek pointer to init the filecontents stream.  so, we
        // call PackageReadFromStream to create the FileContents stream

        if (_pstm && !_pstmFileContents) {
            if (FAILED(PackageReadFromStream(_pstm))) {
                DebugMsg(DM_TRACE, "            couldn't read from stream!!");
                return E_FAIL;
            }
        }

        IStream* pstm;
        _pstmFileContents->Clone(&pstm);  // we don't want to move the seek
                                          // pointer on our FileContents stream

        if (FAILED(CopyStreamToFile(pstm, szTempFile))) {
            DebugMsg(DM_TRACE, "            couldn't copy from stream!!");
            pstm->Release();
            return E_FAIL;
        } else {
            ASSERT(_pEmbed);
            delete _pEmbed->pszTempName;
            if (NULL != (_pEmbed->pszTempName = new TCHAR[lstrlen(szTempFile) + 1])) {
                lstrcpy(_pEmbed->pszTempName, szTempFile);
            } else {
                return E_OUTOFMEMORY;
            }
        }
        pstm->Release();
    }


    // whenever we create a tempfile we are activating the contents which
    // means we are dirty until we get a save message
    return S_OK;
}





// Data Transfer Functions



HRESULT CPackage::GetFileDescriptor(LPFORMATETC pFE, LPSTGMEDIUM pSTM)
{
    FILEGROUPDESCRIPTOR* pfgd;


    DebugMsg(DM_TRACE, "            Getting File Descriptor");

    // we only support HGLOBAL at this time

    if (!(pFE->tymed & TYMED_HGLOBAL)) {
        DebugMsg(DM_TRACE, "            does not support HGLOBAL!");
        return DATA_E_FORMATETC;
    }

    // Copy file descriptor to HGLOBAL //

    pSTM->tymed = TYMED_HGLOBAL;

    // render the file descriptor
    if (!(pfgd = (FILEGROUPDESCRIPTOR*)GlobalAlloc(GPTR,
                                                   sizeof(FILEGROUPDESCRIPTOR))))
        return E_OUTOFMEMORY;

    pSTM->hGlobal = pfgd;

    pfgd->cItems = 1;

    switch (_panetype) {
    case PEMBED:
        pfgd->fgd[0] = _pEmbed->fd;
        GetDisplayName(pfgd->fgd[0].cFileName, _pEmbed->fd.cFileName);
        break;

    case CMDLINK:
        // the label for the package will serve as the filename for the
        // shortcut we're going to create.
        lstrcpy(pfgd->fgd[0].cFileName, _lpic->szIconText);
        // BUGBUG: harcoded use of .lnk extension!!
        lstrcat(pfgd->fgd[0].cFileName, TEXT(".lnk"));

        // we want to add the little arrow to the shortcut.
        pfgd->fgd[0].dwFlags = FD_LINKUI;
        break;
    }
    return S_OK;
}

HRESULT CPackage::GetFileContents(LPFORMATETC pFE, LPSTGMEDIUM pSTM)
{
    void* lpvDest = NULL;
    DWORD   dwSize;
    HANDLE  hFile = NULL;
    DWORD   cb;
    HRESULT hr = E_FAIL;

    DebugMsg(DM_TRACE, "            Getting File Contents");

    // Copy file contents to ISTREAM //

    // NOTE: Hopefully, everyone using our object supports TYMED_ISTREAM,
    // otherwise we could get some really slow behavior.  We might later
    // want to implement TYMED_ISTORAGE as well and shove our file contents
    // into a single stream named CONTENTS.

    if (pFE->tymed & TYMED_ISTREAM) {
        DebugMsg(DM_TRACE, "            using TYMED_ISTREAM");
        pSTM->tymed = TYMED_ISTREAM;

        switch (_panetype) {
        case PEMBED:
            if (_pstmFileContents)
                hr = _pstmFileContents->Clone(&pSTM->pstm);
            else
                return E_FAIL;
            break;

        case CMDLINK:
            hr = CreateStreamOnHGlobal(NULL, TRUE, &pSTM->pstm);
            if (SUCCEEDED(hr)) {
                hr = CreateShortcutOnStream(pSTM->pstm);
                if (FAILED(hr)) {
                    pSTM->pstm->Release();
                    pSTM->pstm = NULL;
                }
            }
            break;
        }
        return hr;
    }

    // Copy file contents to HGLOBAL //

    // NOTE: This is really icky and could potentially be very slow if
    // somebody decides to package really large files.  Hopefully,
    // everyone should be able to get the info it wants through TYMED_ISTREAM,
    // but this is here as a common denominator

    if (pFE->tymed & TYMED_HGLOBAL) {
        DebugMsg(DM_TRACE, "            using TYMED_HGLOBAL");
        pSTM->tymed = TYMED_HGLOBAL;

        if (_panetype == CMDLINK) {
            DebugMsg(DM_TRACE,
                     "    H_GLOBAL not supported for CMDLINK");
            return DATA_E_FORMATETC;
        }

        dwSize = _pEmbed->fd.nFileSizeLow;

        // caller is responsible for freeing this memory, even if we fail.
        if (!(lpvDest = GlobalAlloc(GPTR, dwSize))) {
            DebugMsg(DM_TRACE, "            out o memory!!");
            return E_OUTOFMEMORY;
        }
        pSTM->hGlobal = lpvDest;

        // This will reinitialize our FileContents stream if we had to get
        // rid of it.  For instance, we have to get rid of all our storage
        // pointers in HandsOffStorage, but there's no need to reinit our
        // FileContents stream unless we need it again.

        if (_pstm && !_pstmFileContents)
            PackageReadFromStream(_pstm);

        if (_pstmFileContents) {
            IStream* pstm;
            hr = _pstmFileContents->Clone(&pstm);
            if (FAILED(hr))
                return hr;
            hr = pstm->Read(lpvDest, dwSize, &cb);
            pstm->Release();
            if (FAILED(hr))
                return hr;
        } else
            return E_FAIL;

        if (FAILED(hr) || cb != dwSize) {
            DebugMsg(DM_TRACE, "            error reading from stream!!");
            return E_FAIL;
        }
        return hr;
    }

    return DATA_E_FORMATETC;
}

HRESULT CPackage::GetMetafilePict(LPFORMATETC pFE, LPSTGMEDIUM pSTM)
{
    LPMETAFILEPICT      lpmfpict;
    RECT                rcTemp;
    LPIC                lpic = _lpic;
    HDC                 hdcMF = NULL;
    HFONT               hfont = NULL;


    DebugMsg(DM_TRACE, "            Getting MetafilePict");

    if (!(pFE->tymed & TYMED_MFPICT)) {
        DebugMsg(DM_TRACE, "            does not support MFPICT!");
        return DATA_E_FORMATETC;
    }
    pSTM->tymed = TYMED_MFPICT;

    // Allocate memory for the metafilepict and get a pointer to it
    // NOTE: the caller is responsible for freeing this memory, even on fail

    if (!(pSTM->hMetaFilePict = GlobalAlloc(GPTR, sizeof(METAFILEPICT))))
        return E_OUTOFMEMORY;
    lpmfpict = (LPMETAFILEPICT)pSTM->hMetaFilePict;

    // Create the metafile
    if (!(hdcMF = CreateMetaFile(NULL)))
        return E_OUTOFMEMORY;

    // Initializae the metafile
    SetWindowOrgEx(hdcMF, 0, 0, NULL);
    SetWindowExtEx(hdcMF, lpic->rc.right - 1, lpic->rc.bottom - 1, NULL);

    SetRect(&rcTemp, 0, 0, lpic->rc.right, lpic->rc.bottom);
    hfont = SelectFont(hdcMF, g_hfontTitle);

    // Center the icon
    DrawIcon(hdcMF, (rcTemp.right - g_cxIcon) / 2, 0, lpic->hDlgIcon);

    // Center the text below the icon
    SetBkMode(hdcMF, TRANSPARENT);
    SetTextAlign(hdcMF, TA_CENTER);
    TextOut(hdcMF, rcTemp.right / 2, g_cxIcon + 1, lpic->szIconText,
            lstrlen(lpic->szIconText));

    if (hfont)
        SelectObject(hdcMF, hfont);

    // Map to device independent coordinates
    rcTemp.right =
        MulDiv((rcTemp.right - rcTemp.left), HIMETRIC_PER_INCH, DEF_LOGPIXELSX);
    rcTemp.bottom =
        MulDiv((rcTemp.bottom - rcTemp.top), HIMETRIC_PER_INCH, DEF_LOGPIXELSY);

    // Finish filling in the metafile header
    lpmfpict->mm = MM_ANISOTROPIC;
    lpmfpict->xExt = rcTemp.right;
    lpmfpict->yExt = rcTemp.bottom;
    lpmfpict->hMF = CloseMetaFile(hdcMF);

    return S_OK;
}


HRESULT CPackage::GetObjectDescriptor(LPFORMATETC pFE, LPSTGMEDIUM pSTM)
{
    LPOBJECTDESCRIPTOR lpobj;
    DWORD   dwFullUserTypeNameLen;

    DebugMsg(DM_TRACE, "            Getting Object Descriptor");

    // we only support HGLOBAL at this time

    if (!(pFE->tymed & TYMED_HGLOBAL)) {
        DebugMsg(DM_TRACE, "            does not support HGLOBAL!");
        return DATA_E_FORMATETC;
    }

    // Copy file descriptor to HGLOBAL //

    dwFullUserTypeNameLen = 0; //lstrlen(szUserType) + 1;
    pSTM->tymed = TYMED_HGLOBAL;

    if (!(lpobj = (OBJECTDESCRIPTOR*)GlobalAlloc(GPTR,
                                                 sizeof(OBJECTDESCRIPTOR) + dwFullUserTypeNameLen)))
        return E_OUTOFMEMORY;

    pSTM->hGlobal = lpobj;

    lpobj->cbSize = sizeof(OBJECTDESCRIPTOR) + dwFullUserTypeNameLen;
    lpobj->clsid = CLSID_CPackage;
    lpobj->dwDrawAspect = DVASPECT_CONTENT | DVASPECT_ICON;
    _pIOleObject->GetMiscStatus(DVASPECT_CONTENT | DVASPECT_ICON, &(lpobj->dwStatus));
    lpobj->dwFullUserTypeName = 0L; //sizeof(OBJECTDESCRIPTOR);
    lpobj->dwSrcOfCopy = 0L;

    // lstrcpy((LPTSTR)lpobj+lpobj->dwFullUserTypeName, szUserType);
    return S_OK;
}




// Stream I/O Functions



HRESULT CPackage::PackageReadFromStream(IStream* pstm)
{

    // initialize the package object from a stream
    // return:  s_OK   - package properly initialized
    //          E_FAIL - error initializing package


    WORD  w;
    DWORD dw;

    DebugMsg(DM_TRACE, "pack - PackageReadFromStream called.");

    // read in the package size, which we don't really need, but the old
    // packager puts it there.
    if (FAILED(pstm->Read(&dw, sizeof(dw), NULL)))
        return E_FAIL;

    // NOTE: Ok, this is really dumb.  The old packager allowed the user
    // to create packages without giving them icons or labels, which
    // in my opinion is just dumb, it should have at least created a default
    // icon and shoved it in the persistent storage...oh well...
    //     So if the appearance type comes back as NOTHING ( == 0)
    // then we just won't read any icon information.

    // read in the appearance type
    pstm->Read(&w, sizeof(w), NULL);

    // read in the icon information
    if (w == (WORD)ICON) {
        if (FAILED(IconReadFromStream(pstm))) {
            DebugMsg(DM_TRACE, "         error reading icon info!!");
            return E_FAIL;
        }
    } else if (w == (WORD)PICTURE) {
        DebugMsg(DM_TRACE, "         old Packager Appearance, not supported!!");
        // NOTE: Ideally, we could just ignore the appearance and continue, but to
        // do so, we'll need to know how much information to skip over before continuing
        // to read from the stream
        ShellMessageBox(g_hinst,
                        NULL,
                        MAKEINTRESOURCE(IDS_OLD_FORMAT_ERROR),
                        MAKEINTRESOURCE(IDS_APP_TITLE),
                        MB_OK | MB_ICONERROR | MB_TASKMODAL);
        return E_FAIL;
    }

    // read in the contents type
    pstm->Read(&w, sizeof(w), NULL);

    _panetype = (PANETYPE)w;

    switch ((PANETYPE)w) {
    case PEMBED:
        // read in the contents information
        return EmbedReadFromStream(pstm);

    case CMDLINK:
        // read in the contents information
        return CmlReadFromStream(pstm);

    default:
        return E_FAIL;
    }
}


// read the icon info from a stream
// return:  S_OK   -- icon read correctly
//          E_FAIL -- error reading icon

HRESULT CPackage::IconReadFromStream(IStream* pstm)
{
    LPIC lpic = IconCreate();
    if (lpic) {
        CHAR szTemp[MAX_PATH];
        StringReadFromStream(pstm, szTemp, ARRAYSIZE(szTemp));
        SHAnsiToTChar(szTemp, lpic->szIconText, ARRAYSIZE(lpic->szIconText));

        StringReadFromStream(pstm, szTemp, ARRAYSIZE(szTemp));
        SHAnsiToTChar(szTemp, lpic->szIconPath, ARRAYSIZE(lpic->szIconPath));

        WORD wDlgIcon;
        pstm->Read(&wDlgIcon, sizeof(wDlgIcon), NULL);
        lpic->iDlgIcon = (INT)wDlgIcon;
        GetCurrentIcon(lpic);
        IconCalcSize(lpic);
    }

    DestroyIC();
    _lpic = lpic;

    return lpic ? S_OK : E_FAIL;
}

HRESULT CPackage::EmbedReadFromStream(IStream* pstm)
{

    // reads embedded file contents from a stream
    // return:  S_OK   - contents read succesfully
    //          E_FAIL - error reading contents


    DWORD dwSize;
    CHAR  szFileName[MAX_PATH];

    DebugMsg(DM_TRACE, "pack - EmbedReadFromStream called.");

    pstm->Read(&dwSize, sizeof(dwSize), NULL);  // get string size
    pstm->Read(szFileName, dwSize, NULL);       // get string
    pstm->Read(&dwSize, sizeof(dwSize), NULL);  // get file size

    // we don't do anything with the file contents here, because anything
    // we do could be a potentially expensive operation.  so, we just clone
    // the stream and hold onto it for future use.

    if (_pstmFileContents)
        _pstmFileContents->Release();

    if (FAILED(pstm->Clone(&_pstmFileContents)))
        return E_FAIL;

    if (_pEmbed) {
        if (_pEmbed->pszTempName) {
            DeleteFile(_pEmbed->pszTempName);
            delete _pEmbed->pszTempName;
        }
        delete _pEmbed;
    }

    _pEmbed = new EMBED;
    if (NULL != _pEmbed) {
        _pEmbed->fd.dwFlags = FD_FILESIZE;
        _pEmbed->fd.nFileSizeLow = dwSize;
        _pEmbed->fd.nFileSizeHigh = 0;
        SHAnsiToTChar(szFileName, _pEmbed->fd.cFileName, ARRAYSIZE(_pEmbed->fd.cFileName));
        DebugMsg(DM_TRACE, "         %s\n\r         %d", _pEmbed->fd.cFileName, _pEmbed->fd.nFileSizeLow);
        return S_OK;
    } else {
        return E_OUTOFMEMORY;
    }
}


HRESULT CPackage::CmlReadFromStream(IStream* pstm)
{

    // reads command line contents from a stream
    // return:  S_OK   - contents read succesfully
    //          E_FAIL - error reading contents


    WORD w;
    CHAR  szCmdLink[CBCMDLINKMAX];

    DebugMsg(DM_TRACE, "pack - CmlReadFromStream called.");

    // read in the fCmdIsLink and the command line string
    if (FAILED(pstm->Read(&w, sizeof(w), NULL)))
        return E_FAIL;
    StringReadFromStream(pstm, szCmdLink, ARRAYSIZE(szCmdLink));

    if (_pCml != NULL)
        delete _pCml;

    _pCml = new CML;
    SHAnsiToTChar(szCmdLink, _pCml->szCommandLine, ARRAYSIZE(_pCml->szCommandLine));

    return S_OK;
}


HRESULT CPackage::PackageWriteToStream(IStream* pstm)
{

    // write the package object to a stream
    // return:  s_OK   - package properly written
    //          E_FAIL - error writing package


    WORD w;
    DWORD cb = 0L;
    DWORD dwSize;

    DebugMsg(DM_TRACE, "pack - PackageWriteToStream called.");

    // write out a DWORD where the package size will go
    if (FAILED(pstm->Write(&cb, sizeof(DWORD), NULL)))
        return E_FAIL;

    // write out the appearance type
    w = (WORD)ICON;
    if (FAILED(pstm->Write(&w, sizeof(WORD), NULL)))
        return E_FAIL;
    cb += 2 * sizeof(WORD);       // for appearance type and contents type

    // write out the icon information
    if (FAILED(IconWriteToStream(pstm, &dwSize))) {
        DebugMsg(DM_TRACE, "         error writing icon info!!");
        return E_FAIL;
    }
    cb += dwSize;

    // write out the contents type
    w = (WORD)_panetype;
    if (FAILED(pstm->Write(&_panetype, sizeof(WORD), NULL)))
        return E_FAIL;

    switch (_panetype) {
    case PEMBED:

        // write out the contents information
        if (FAILED(EmbedWriteToStream(pstm, &dwSize))) {
            DebugMsg(DM_TRACE, "         error writing embed info!!");
            return E_FAIL;
        }
        cb += dwSize;
        break;

    case CMDLINK:
        // write out the contents information
        if (FAILED(CmlWriteToStream(pstm, &dwSize))) {
            DebugMsg(DM_TRACE, "         error writing cml info!!");
            return E_FAIL;
        }
        cb += dwSize;
        break;
    }


    LARGE_INTEGER li = {0, 0};
    if (FAILED(pstm->Seek(li, STREAM_SEEK_SET, NULL)))
        return E_FAIL;
    if (FAILED(pstm->Write(&cb, sizeof(DWORD), NULL)))
        return E_FAIL;

    return S_OK;
}



// write the icon to a stream
// return:  s_OK   - icon properly written
//          E_FAIL - error writing icon

HRESULT CPackage::IconWriteToStream(IStream* pstm, DWORD* pdw)
{
    DWORD cb = 0;
    CHAR szTemp[MAX_PATH];
    SHTCharToAnsi(_lpic->szIconText, szTemp, ARRAYSIZE(szTemp));
    HRESULT hr = StringWriteToStream(pstm, szTemp, &cb);
    if (SUCCEEDED(hr)) {
        SHTCharToAnsi(_lpic->szIconPath, szTemp, ARRAYSIZE(szTemp));
        hr = StringWriteToStream(pstm, szTemp, &cb);
        if (SUCCEEDED(hr)) {
            DWORD dwWrite;
            WORD wDlgIcon = (WORD)_lpic->iDlgIcon;
            hr = pstm->Write(&wDlgIcon, sizeof(wDlgIcon), &dwWrite);
            if (SUCCEEDED(hr)) {
                cb += dwWrite;
                if (pdw)
                    *pdw = cb;
            }
        }
    }
    return hr;
}


// write embedded file contents to a stream
// return:  S_OK   - contents written succesfully
//          E_FAIL - error writing contents

HRESULT CPackage::EmbedWriteToStream(IStream* pstm, DWORD* pdw)
{
    DWORD cb = 0;
    CHAR szTemp[MAX_PATH];
    SHTCharToAnsi(_pEmbed->fd.cFileName, szTemp, ARRAYSIZE(szTemp));
    DWORD dwSize = lstrlenA(szTemp) + 1;
    HRESULT hr = pstm->Write(&dwSize, sizeof(dwSize), &cb);
    if (SUCCEEDED(hr)) {
        DWORD dwWrite;
        hr = StringWriteToStream(pstm, szTemp, &dwWrite);
        if (SUCCEEDED(hr)) {
            cb += dwWrite;
            hr = pstm->Write(&_pEmbed->fd.nFileSizeLow, sizeof(_pEmbed->fd.nFileSizeLow), &dwWrite);
            if (SUCCEEDED(hr)) {
                cb += dwWrite;

                // we want to make sure our file contents stream always points to latest
                // saved file contents

                // NOTE: If we're not saving to our loaded stream, we shouldn't keep a
                // pointer to it, because we're in a SaveAs situation, and we don't want
                // to be hanging onto pointers to other peoples streams.

                if (_pstmFileContents && _pstm == pstm) {
                    _pstmFileContents->Release();
                    pstm->Clone(&_pstmFileContents);
                }

                // This is for screwy apps, like MSWorks that ask us to save ourselves
                // before they've even told us to initialize ourselves.

                if (_pEmbed->fd.cFileName[0]) {
                    hr = CopyFileToStream(_pEmbed->pszTempName, pstm);
                    if (SUCCEEDED(hr)) {
                        cb += _pEmbed->fd.nFileSizeLow;
                    }
                }
                if (pdw)
                    *pdw = cb;
            }
        }
    }
    return hr;
}


// write embedded file contents to a stream
// return:  S_OK   - contents written succesfully
//          E_FAIL - error writing contents

HRESULT CPackage::CmlWriteToStream(IStream* pstm, DWORD* pdw)
{
    DWORD cb = 0;
    WORD w = _pCml->fCmdIsLink;

    DebugMsg(DM_TRACE, "pack - CmlWriteToStream called.");

    if (FAILED(pstm->Write(&w, sizeof(w), NULL)))
        return E_FAIL;                                   // write fCmdIsLink
    cb += sizeof(w);      // for fCmdIsLink

    CHAR szTemp[MAX_PATH];
    SHTCharToAnsi(_pCml->szCommandLine, szTemp, ARRAYSIZE(szTemp));
    HRESULT hres = StringWriteToStream(pstm, szTemp, &cb);
    if (FAILED(hres))
        return hres;                                   // write command link

    // return the number of bytes written in the outparam
    if (pdw)
        *pdw = cb;

    return S_OK;
}


HRESULT CPackage::CreateShortcutOnStream(IStream* pstm)
{
    HRESULT hr;
    IShellLink* psl;
    TCHAR szArgs[CBCMDLINKMAX - MAX_PATH];
    TCHAR szPath[MAX_PATH];

    hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl);
    if (SUCCEEDED(hr)) {
        IPersistStream* pps;

        lstrcpy(szPath, _pCml->szCommandLine);
        PathSeparateArgs(szPath, szArgs);

        psl->SetPath(szPath);
        psl->SetIconLocation(_lpic->szIconPath, _lpic->iDlgIcon);
        psl->SetShowCmd(SW_SHOW);
        psl->SetArguments(szArgs);

        hr = psl->QueryInterface(IID_IPersistStream, (void**)&pps);
        if (SUCCEEDED(hr)) {
            hr = pps->Save(pstm, TRUE);
            pps->Release();
        }
        psl->Release();
    }

    LARGE_INTEGER li = {0,0};
    pstm->Seek(li, STREAM_SEEK_SET, NULL);

    return hr;
}

HRESULT CPackage::InitVerbEnum(OLEVERB* pVerbs, ULONG cVerbs)
{
    if (NULL != _pVerbs) {
        for (ULONG i = 0; i < _cVerbs; i++) {
            delete _pVerbs[i].lpszVerbName;
        }
        delete _pVerbs;
    }
    _pVerbs = pVerbs;
    _cVerbs = cVerbs;
    _nCurVerb = 0;
    return (NULL != pVerbs) ? S_OK : E_FAIL;
}

VOID CPackage::ReleaseContextMenu()
{
    if (NULL != _pcm) {
        _pcm->Release();
        _pcm = NULL;
    }
}

HRESULT CPackage::GetContextMenu(IContextMenu** ppcm)
{
    HRESULT hr = E_FAIL;
    ASSERT(NULL != ppcm);
    if (NULL != _pcm) {
        _pcm->AddRef();
        *ppcm = _pcm;
        hr = S_OK;
    } else if ((PEMBED == _panetype) || (CMDLINK == _panetype)) {
        if (PEMBED == _panetype) {
            hr = CreateTempFileName();
        } else {
            hr = S_OK;
        }
        if (SUCCEEDED(hr)) {
            LPITEMIDLIST pidl = SHSimpleIDListFromPath((PEMBED == _panetype) ?
                                                       _pEmbed->pszTempName :
                                                       _pCml->szCommandLine);
            if (NULL != pidl) {
                IShellFolder* psf;
                LPCITEMIDLIST pidlChild;
                if (SUCCEEDED(hr = SHBindToIDListParent(pidl, IID_IShellFolder, (void**)&psf, &pidlChild))) {
                    hr = psf->GetUIObjectOf(NULL, 1, &pidlChild, IID_IContextMenu, NULL, (void**)&_pcm);
                    if (SUCCEEDED(hr)) {
                        _pcm->AddRef();
                        *ppcm = _pcm;
                    }
                    psf->Release();
                }
                ILFree(pidl);
            } else {
                hr = E_OUTOFMEMORY;
            }
        }
    }
    return hr;
}

HRESULT CPackage::IconRefresh()
{
    // we refresh the icon.  typically, this will be called the first time
    // the package is created to load the new icon and calculate how big
    // it should be.  this will also be called after we edit the package,
    // since the user might have changed the icon.

    // First, load the appropriate icon.  We'll load the icon specified by
    // lpic->szIconPath and lpic->iDlgIcon if possible, otherwise we'll just
    // use the generic packager icon.

    GetCurrentIcon(_lpic);

    // Next, we need to have the icon recalculate its size, since it's text
    // might have changed, causing it to get bigger or smaller.

    IconCalcSize(_lpic);

    // Next, notify our containers that our view has changed.
    if (_pIDataAdviseHolder)
        _pIDataAdviseHolder->SendOnDataChange(_pIDataObject, 0, NULL);
    if (_pViewSink)
        _pViewSink->OnViewChange(_dwViewAspects, _dwViewAdvf);

    // Set our dirty flag
    _fIsDirty = TRUE;

    return S_OK;
}


int CPackage::RunWizard()
{
    PACKAGER_INFO packInfo;
    HRESULT hr;

    PackWiz_CreateWizard(NULL, &packInfo);

    if (*packInfo.szFilename == TEXT('\0')) {
        ShellMessageBox(g_hinst,
                        NULL,
                        MAKEINTRESOURCE(IDS_CREATE_ERROR),
                        MAKEINTRESOURCE(IDS_APP_TITLE),
                        MB_ICONERROR | MB_TASKMODAL | MB_OK);
        return E_FAIL;
    }

    InitFromPackInfo(&packInfo);

    hr = OleSetClipboard(_pIDataObject);
    if (FAILED(hr)) {
        ShellMessageBox(g_hinst,
                        NULL,
                        MAKEINTRESOURCE(IDS_COPY_ERROR),
                        MAKEINTRESOURCE(IDS_APP_TITLE),
                        MB_ICONERROR | MB_TASKMODAL | MB_OK);
        return -1;
    }

    // we need to do this.  our OleUninitialze call at the end, free the
    // libarary and our dataobject on the clipboard unless we flush
    // the clipboard.

    hr = OleFlushClipboard();
    if (FAILED(hr)) {
        ShellMessageBox(g_hinst,
                        NULL,
                        MAKEINTRESOURCE(IDS_COPY_ERROR),
                        MAKEINTRESOURCE(IDS_APP_TITLE),
                        MB_ICONERROR | MB_TASKMODAL | MB_OK);
        return -1;
    }

    ShellMessageBox(g_hinst,
                    NULL,
                    MAKEINTRESOURCE(IDS_COPY_COMPLETE),
                    MAKEINTRESOURCE(IDS_APP_TITLE),
                    MB_ICONINFORMATION | MB_TASKMODAL | MB_OK);

    return 0;
}

void CPackage::DestroyIC()
{
    if (_lpic) {
        if (_lpic->hDlgIcon)
            DestroyIcon(_lpic->hDlgIcon);

        GlobalFree(_lpic);
    }
}

STDAPI_(BOOL) PackWizRunFromExe()
{
    OleInitialize(NULL);

    CPackage* pPackage = new CPackage;
    if (pPackage) {
        pPackage->Init();
        pPackage->RunWizard();
        pPackage->Release();
    }

    OleUninitialize();
    return 0;
}