windows-xp/Source/XPSP1/NT/multimedia/media/sndrec32/soundrec/srs.cxx

//+---------------------------------------------------------------------
//
//   File:       srs.cxx
//
//   Contents:   OLE2 Server Class code
//
//   Classes:
//               SRCtrl
//               SRInPlace
//               SRDV
//
//------------------------------------------------------------------------

#include <stdlib.h>

#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>      // common dialog boxes

#include <ole2.h>
#include <o2base.hxx>     // the base classes and utilities

#include "srecids.h"      // for resources
#include "srs.hxx"

// Our class factory
extern SRFactory *gpSRFactory;
extern "C" HINSTANCE ghInst;

DWORD       gdwRegROT           = 0L;   // Registered on the running object table?
LPMONIKER   gpFileMoniker       = NULL; // Application wide file moniker for linking
LPXBAG      gpXBagOnClipboard   = NULL;
BOOL        gfXBagOnClipboard   = FALSE;
LPSRCTRL    gpCtrlThis          = NULL;


// Glue functions for the C code
//===============================
//
void
FlushOleClipboard(void)
{
    if (!gfOleInitialized)
        return;
    
    if(gfXBagOnClipboard)
    {
        if(OleIsCurrentClipboard(gpXBagOnClipboard) == NOERROR)
        {
            DOUT(TEXT("\\\\Soundrec: OleFlushClipboard()\r\n"));
            //
            // Keep the data object on the clipboard for object pasting
            //
            OleFlushClipboard();
            
            gpXBagOnClipboard->Detach();
            gpXBagOnClipboard = NULL;
        }
        gfXBagOnClipboard = FALSE;
    }
}

               
// copied from pbrush
void
TransferToClipboard(void)
{
    DOUT(TEXT("TransferToClipboard\r\n"));

    if(gpCtrlThis != NULL)
    {
        LPXBAG pXBag;
        HRESULT hr = CXBag::Create(&pXBag, gpCtrlThis, NULL);
        if(hr == NOERROR)
        {
            if(gfXBagOnClipboard)
                OleSetClipboard(NULL);
            hr = OleSetClipboard(pXBag);
            gfXBagOnClipboard = (hr == NOERROR) ? TRUE : FALSE;
            if(hr == NOERROR)
            {
                gpXBagOnClipboard = pXBag;
            }
            else
            {
                DOUT(TEXT("TransferToClipboard FAILED!\r\n"));
            }
        }
    }
    else
    {
        DOUT(TEXT("TransferToClipboard called with a NULL gpCtrlThis!\r\n"));
    }

}
void AdviseDataChange(void)
{
    if(gpCtrlThis)
    {
        gpCtrlThis->_pDV->OnDataChange();
        gpCtrlThis->MarkAsLoaded();
    }
}

void AdviseRename(LPTSTR lpname)
{
    if(gpCtrlThis)
    {
        if (gpCtrlThis->_pOleAdviseHolder != NULL)
        {
            LPMONIKER pmk = NULL;
#if !defined(UNICODE) && !defined(OLE2ANSI)            
            LPOLESTR lpstr = ConvertMBToOLESTR(lpname,-1);
            if(NOERROR == CreateFileMoniker(lpstr, &pmk))
#else
            if(NOERROR == CreateFileMoniker(lpname, &pmk))                
#endif                
                
            {
                gpCtrlThis->_pOleAdviseHolder->SendOnRename(pmk);
                pmk->Release();
            }
#if !defined(UNICODE) && !defined(OLE2ANSI)                        
            TaskFreeMem(lpstr);
#endif            
        }
    }
}

void AdviseSaved(void)
{
    if(gpCtrlThis)
    {
        if (gpCtrlThis->_pOleAdviseHolder != NULL)
        {
            gpCtrlThis->_pOleAdviseHolder->SendOnSave();
        }
    }
}

void AdviseClosed(void)
{
    if(gpCtrlThis)
    {
        if (gpCtrlThis->_pOleAdviseHolder != NULL)
        {
            gpCtrlThis->_pOleAdviseHolder->SendOnClose();
        }
    }
}

void DoOleSave(void)
{
    if(!gfStandalone && gpCtrlThis && gpCtrlThis->_pClientSite)
    {
        gpCtrlThis->_pClientSite->SaveObject();
    }
}

void DoOleClose(BOOL fSave)
{
    if(gpCtrlThis)
    {
        DOUT(TEXT("SoundRec: DoOleClose\r\n"));
        if (gfStandalone)
        {
            RevokeAsRunning(&gdwRegROT);
            if(gpFileMoniker != NULL)
            {
                gpFileMoniker->Release();
                gpFileMoniker = NULL;
            }
            gfClosing = TRUE;
            gpCtrlThis->UnLock();

//        This release will cause a fatal recursion in SRCtrl::~SRCtrl on
//        objects that were created due to link conversations.
                        
            if (gfEmbedded)
                gpCtrlThis->Release();
        }
        else
            gpCtrlThis->Close(fSave ? OLECLOSE_SAVEIFDIRTY: OLECLOSE_NOSAVE);
    }
}

void WriteObjectIfEmpty()
{
    if (gpCtrlThis)
    {
        if (!gpCtrlThis->IsLoaded())
        {
            AdviseDataChange();
        }
    }
}

void OleObjGetHostNames(
    LPTSTR *ppCntr,
    LPTSTR *ppObj)
{
    if (gpCtrlThis)
    {
#if !defined(UNICODE) && !defined(OLE2ANSI)
        *ppCntr = gpCtrlThis->_lpstrCntrAppA;
        *ppObj  = gpCtrlThis->_lpstrCntrObjA;
#else
        *ppCntr = gpCtrlThis->_lpstrCntrApp;
        *ppObj  = gpCtrlThis->_lpstrCntrObj;
#endif        
    }
}

//
// Data Transfer Object
//========================
//

//
// List of formats offered by our data transfer object via EnumFormatEtc
// NOTE: OleClipFormat is a global array of stock formats defined in
//       o2base\dvutils.cxx and initialized via RegisterOleClipFormats()
//       in our class factory.
//
static FORMATETC g_aGetFmtEtcs[] = {
    //
    //Other formats go here..
    //{ CF_WHATEVER, NULL, DVASPECT_ALL, -1L, TYMED_HGLOBAL }

    //
    // put the embed source first so containers recognize this is an object
    //
    { (unsigned short)-OCF_EMBEDSOURCE, NULL, DVASPECT_CONTENT, -1L, TYMED_ISTORAGE },

    //
    // everything else
    //
    { (unsigned short)-OCF_OBJECTDESCRIPTOR, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },
    { CF_WAVE, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },
    { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1L, TYMED_MFPICT },
    { CF_DIB, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },

    //    
    // I am reserving the *LAST TWO* for the links.  We can prevent a
    // link from being offered
    //    
    { (unsigned short)-OCF_LINKSOURCE, NULL, DVASPECT_CONTENT, -1L, TYMED_ISTREAM | TYMED_HGLOBAL },
    { (unsigned short)-OCF_LINKSRCDESCRIPTOR, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL }

};


//+---------------------------------------------------------------
//
//  Member:     CXBag::Create, static
//
//  Synopsis:   Create a new, initialized transfer object
//
//---------------------------------------------------------------
HRESULT
CXBag::Create(LPXBAG *ppXBag, LPSRCTRL pHost, LPPOINT pptSelected)
{
//    Assert(ppXBag != NULL && pHost != NULL && pptSelected != NULL);

    LPXBAG pXBag = new CXBag(pHost);
    if((*ppXBag = pXBag) == NULL)
        return E_OUTOFMEMORY;

    return NOERROR;
}


//+---------------------------------------------------------------
//
//  Member:     CXBag::CXBag
//
//  Synopsis:   constructor
//
//---------------------------------------------------------------
CXBag::CXBag(LPSRCTRL pHost)
{
    _pHost = pHost;
    _ulRefs = 1;
    _pStgBag = NULL;
}

//+---------------------------------------------------------------
//
//  Member:     CXBag::~CXBag
//
//  Synopsis:   destructor
//
//---------------------------------------------------------------
CXBag::~CXBag()
{
    _pHost = NULL;
    if(_pStgBag != NULL)
        _pStgBag->Release();
}


//+---------------------------------------------------------------
//
//  Member:     CXBag::SnapShotAndDetach
//
//  Synopsis:   Save a snapshot then detach from Host
//
//---------------------------------------------------------------
HRESULT
CXBag::SnapShotAndDetach(void)
{
    STGMEDIUM medium;
    medium.pUnkForRelease = NULL;    // transfer ownership to caller
    medium.hGlobal = NULL;
    medium.tymed = TYMED_ISTORAGE;
    HRESULT hr = BagItInStorage(&medium, FALSE);

    _pHost = NULL;
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     CXBag::BagItInStorage, private
//
//  Synopsis:   Save or copy a snapshot into specified stg
//
//---------------------------------------------------------------
HRESULT
CXBag::BagItInStorage(LPSTGMEDIUM pmedium, BOOL fStgProvided)
{
    HRESULT hr = NOERROR;
    LPPERSISTSTORAGE pPStg = NULL;

    LPSTORAGE pStg = fStgProvided ? pmedium->pstg: NULL;
    if(!fStgProvided)
    {
        //
        // allocate a temp docfile that will delete on last release
        //
        hr = StgCreateDocfile(
            NULL,
            STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE,
            0,
            &pStg);
        pmedium->tymed = TYMED_ISTORAGE;
        pmedium->pstg = pStg;
    }

    if(pStg == NULL)
        goto LExit;

    if(_pStgBag == NULL)
    {
        if(_pHost == NULL)
        {
            hr = E_UNEXPECTED;  // We got prematurely detached!
            goto LExit;
        }
        _pHost->QueryInterface(IID_IPersistStorage, (LPVOID FAR*)&pPStg);
        Assert(pPStg != NULL);
        hr = OleSave(pPStg, pStg, FALSE /* fSameAsLoad */);
        pPStg->SaveCompleted(NULL);
    }
    else
    {
        _pStgBag->CopyTo(NULL, NULL, NULL, pStg);
    }

LExit:
    if(pPStg != NULL)
        pPStg->Release();
    return hr;
}

IMPLEMENT_STANDARD_IUNKNOWN(CXBag)

//+---------------------------------------------------------------
//
//  Member:     CXBag::QueryInterface, public
//
//  Synopsis:   Expose our IFaces
//
//---------------------------------------------------------------
STDMETHODIMP
CXBag::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid,IID_IUnknown))
    {
        *ppv = (LPVOID)this;
    }
    else if (IsEqualIID(riid,IID_IDataObject))
    {
        *ppv = (LPVOID)(LPDATAOBJECT)this;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    ((IUnknown FAR*) *ppv)->AddRef();
    return NOERROR;
}


//+---------------------------------------------------------------
//
//  Member:     CXBag::QueryGetData
//
//     OLE:     IDataObject
//
//  Synopsis:   Answer whether a request for this format might suceed
//
//---------------------------------------------------------------
STDMETHODIMP
CXBag::QueryGetData(LPFORMATETC pformatetc)
{
    HRESULT hr = DV_E_FORMATETC;
    //
    // Pick out the formats we are willing to offer on IStorage
    //
    if ( (pformatetc->cfFormat == OleClipFormat[OCF_EMBEDSOURCE]) &&
         (pformatetc->dwAspect == DVASPECT_CONTENT) &&
         (pformatetc->tymed == TYMED_ISTORAGE) )
    {
        hr = NOERROR;
    }
    //
    // Pick out the formats we are willing to offer on TYMED_ISTREAM
    //
    else if (pformatetc->tymed == TYMED_ISTREAM)
    {
        DOUT(TEXT("CXBag::QueryGetData[ISTREAM]\r\n"));
        //
        // Do not offer a static link if we don't have a filename
        //
        if (pformatetc->cfFormat == OleClipFormat[OCF_LINKSOURCE] )
        {
            hr = NOERROR;
        }
    }
    //
    // Pick out the formats we are willing to offer on HGLOBAL
    //
    else if (pformatetc->tymed == TYMED_HGLOBAL)
    {
        DOUT(TEXT("CXBag::QueryGetData[HGLOBAL]"));        
        if (pformatetc->cfFormat == OleClipFormat[OCF_OBJECTDESCRIPTOR])
        {
            hr = NOERROR;
        }
        else if (pformatetc->cfFormat == OleClipFormat[OCF_LINKSRCDESCRIPTOR])
        {
            hr = NOERROR;
        }
        else if (pformatetc->cfFormat == CF_DIB)
        {
            DOUT(TEXT("CXBag::QueryGetData[DIB]"));
            hr = NOERROR;
        }
        
    }
    else if ( (pformatetc->tymed == TYMED_MFPICT) &&
              ( pformatetc->cfFormat == CF_METAFILEPICT) )
    {
        DOUT(TEXT("CXBag::QueryGetData[MFPICT]"));
        hr = NOERROR;
    }

    return hr;
}


//+---------------------------------------------------------------
//
//  Member:     CXBag::EnumFormatEtc
//
//     OLE:     IDataObject
//
//  Synopsis:   Answer an enumerator over supported formats
//
//---------------------------------------------------------------
STDMETHODIMP
CXBag::EnumFormatEtc(DWORD dwDirection, LPENUMFORMATETC FAR* ppenumFormatEtc)
{
    HRESULT hr = E_NOTIMPL;
    *ppenumFormatEtc = NULL;
    if (dwDirection == DATADIR_GET)
    {
        BOOL fNoLink = IsDocUntitled();
        ULONG cFormats = ARRAY_SIZE(g_aGetFmtEtcs);

        /* Don't enumerate the link support */
        if (fNoLink)
            cFormats -= 2;  

        hr = CreateFORMATETCEnum(g_aGetFmtEtcs, cFormats,
                ppenumFormatEtc);
    }
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     CXBag::GetData
//
//     OLE:     IDataObject
//
//  Synopsis:   Deliver data in requested format
//
//---------------------------------------------------------------
STDMETHODIMP
CXBag::GetData(LPFORMATETC pformatetcIn, LPSTGMEDIUM pmedium)
{
    pmedium->pUnkForRelease = NULL;    // transfer ownership to caller
    pmedium->hGlobal = NULL;
    
    HRESULT hr = DV_E_FORMATETC;
    if ( (pformatetcIn->cfFormat == OleClipFormat[OCF_EMBEDSOURCE]) &&
         (pformatetcIn->dwAspect == DVASPECT_CONTENT) &&
         (pformatetcIn->tymed == TYMED_ISTORAGE) )
    {
        DOUT(TEXT("CXBag::GetData:OCF_EMBEDSOURCE\r\n"));        
        hr = BagItInStorage(pmedium,FALSE);
    }
    else if(pformatetcIn->tymed & TYMED_ISTREAM)
    {
        if ( pformatetcIn->cfFormat == OleClipFormat[OCF_LINKSOURCE] )
        {
            DOUT(TEXT("CXBag::GetData OCF_LINKSOURCE on STREAM\r\n"));
            if(_pHost != NULL)
            {
                hr = _pHost->_pDV->GetLINKSOURCE( (LPSRVRDV)(_pHost->_pDV),
                                                    pformatetcIn,
                                                    pmedium,
                                                    FALSE /* fHere */ );
            }
        }
    }
    else if((pformatetcIn->tymed & TYMED_HGLOBAL) && (_pHost != NULL))
    {
        pmedium->tymed = TYMED_HGLOBAL;
        if ( pformatetcIn->cfFormat == OleClipFormat[OCF_OBJECTDESCRIPTOR] )
        {
            DOUT(TEXT("CXBag::GetData OCF_OBJECTDESCRIPTOR on HGLOBAL\r\n"));
            hr = _pHost->_pDV->GetOBJECTDESCRIPTOR( (LPSRVRDV)(_pHost->_pDV),
                                                    pformatetcIn,
                                                    pmedium,
                                                    FALSE /* fHere */ );
        }
        else if (pformatetcIn->cfFormat == OleClipFormat[OCF_LINKSRCDESCRIPTOR])
        {
            DOUT(TEXT("CXBag::GetData OCF_LINKSRCDESCRIPTOR on HGLOBAL\r\n"));
            hr = _pHost->_pDV->GetOBJECTDESCRIPTOR( (LPSRVRDV)(_pHost->_pDV),
                                                    pformatetcIn,
                                                    pmedium,
                                                    FALSE /* fHere */ );
        }
        else if ( pformatetcIn->cfFormat == CF_WAVE )
        {
            DOUT(TEXT("CXBag::GetData CF_WAVE on HGLOBAL\r\n"));
            if ((pmedium->hGlobal = GetNativeData()) != NULL)
                hr = NOERROR;
        }
        else if ( pformatetcIn->cfFormat == CF_DIB )
        {
            DOUT(TEXT("CXBag::GetData CF_DIB on HGLOBAL\r\n"));            
            if ((pmedium->hGlobal = ::GetDIB(NULL)) != NULL)
                hr = NOERROR;
        }
                
    }
    else if (pformatetcIn->tymed & TYMED_MFPICT)
    {
        pmedium->tymed = TYMED_MFPICT;
        if (pformatetcIn->cfFormat == CF_METAFILEPICT)
        {
            DOUT(TEXT("CXBag::GetData CF_METAFILEPICT\r\n"));
            if (_pHost != NULL)
            {
                if ((pmedium->hGlobal = GetPicture())!= NULL)
                    hr = NOERROR;
            }
        }
    }
    return hr;
}


//+---------------------------------------------------------------
//
//  Member:     CXBag::GetDataHere
//
//     OLE:     IDataObject
//
//  Synopsis:   Deliver requested format in specified medium
//
//---------------------------------------------------------------
STDMETHODIMP
CXBag::GetDataHere(LPFORMATETC pformatetc, LPSTGMEDIUM pmedium)
{
    HRESULT hr = DV_E_FORMATETC;
            
    if ( (pformatetc->cfFormat == OleClipFormat[OCF_EMBEDSOURCE]) &&
         (pformatetc->dwAspect == DVASPECT_CONTENT) &&
         (pformatetc->tymed == TYMED_ISTORAGE) )
    {
        DOUT(TEXT("CXBag::GetDataHere:OCF_EMBEDSOURCE\r\n"));
        hr = BagItInStorage(pmedium,TRUE);
    }
    else if(pformatetc->tymed & TYMED_ISTREAM)
    {
        if (pformatetc->cfFormat = (WORD)OleClipFormat[OCF_LINKSOURCE])
        {
            DOUT(TEXT("CXBag::GetDataHere:OCF_LINKSOURCE\r\n"));
            
            if (_pHost != NULL)
            {
                hr = _pHost->_pDV->GetLINKSOURCE((LPSRVRDV)(_pHost->_pDV)
                                                 ,pformatetc
                                                 ,pmedium
                                                 ,TRUE);
            }
        }
    }                                        
    else if ((pformatetc->tymed & TYMED_HGLOBAL) && (_pHost != NULL))
    {
        if ( pformatetc->cfFormat == OleClipFormat[OCF_OBJECTDESCRIPTOR] )
        {
            DOUT(TEXT("CXBag::GetDataHere:OCF_OBJECTDESCRIPTOR\r\n"));
            
            hr = _pHost->_pDV->GetOBJECTDESCRIPTOR( _pHost->_pDV,
                    pformatetc,
                    pmedium,
                    TRUE /* fHere */ );
        }
        else if ( pformatetc->cfFormat == OleClipFormat[OCF_LINKSRCDESCRIPTOR])
        {
            DOUT(TEXT("CXBag::GetDataHere:OCF_LINKSRCDESCRIPTOR\r\n"));
            
            hr = _pHost->_pDV->GetOBJECTDESCRIPTOR( _pHost->_pDV,
                    pformatetc,
                    pmedium,
                    TRUE /* fHere */ );
        }
        else if ( pformatetc->cfFormat == CF_WAVE )
        {
            DOUT(TEXT("CXBag::GetDataHere CF_WAVE on HGLOBAL\r\n"));
            if ((pmedium->hGlobal = GetNativeData()) != NULL)
                hr = NOERROR;
        }
        else if ( pformatetc->cfFormat == CF_DIB )
        {
            DOUT(TEXT("CXBag::GetDataHere CF_DIB on HGLOBAL\r\n"));

            if ((pmedium->hGlobal = ::GetDIB(pmedium->hGlobal)) != NULL)
                hr = NOERROR;
        }
        
    }
    else if (pformatetc->tymed & TYMED_MFPICT)
    {
        pmedium->tymed = TYMED_MFPICT;
        if (pformatetc->cfFormat == CF_METAFILEPICT)
        {
            DOUT(TEXT("CXBag::GetData CF_METAFILEPICT\r\n"));
            if (_pHost != NULL)
            {
                if ((pmedium->hGlobal = GetPicture()) != NULL)
                    hr = NOERROR;
            }
        }
    }

#if 0
        //
        // Replace with appropriate format handlers...
        //
        else if ( pformatetc->cfFormat == g_cfSourceList )
        {
            hr = _pBaggedList->Copy(pmedium->hGlobal);
        }
#endif
    return hr;
}


//
// (Open-Editing) Server Object for SoundRec
//==========================================
//

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::ClassInit, public
//
//  Synopsis:   Initializes the SRCtrl class
//
//  Arguments:  [pClass] -- our class descriptor
//
//  Returns:    TRUE iff the class could be initialized successfully
//
//  Notes:      This method initializes the verb tables in the
//              class descriptor.
//
//---------------------------------------------------------------

static OLECHAR lpszPlay[64];
static OLECHAR lpszEdit[64];
static OLECHAR lpszOpen[64];

BOOL
SRCtrl::ClassInit(LPCLASSDESCRIPTOR pClass)
{
    // These are our verb tables.  They are used by the base class
    // in implementing methods of the IOleObject interface.
    // NOTE: the verb table must be in ascending, consecutive order
    static OLEVERB OleVerbs[] =
    {
    //  { lVerb, lpszVerbName, fuFlags, grfAttribs },
        { OLEIVERB_INPLACEACTIVATE, NULL, 0, 0 },
        { OLEIVERB_UIACTIVATE, NULL, 0, 0 },
        { OLEIVERB_HIDE, NULL, 0, 0 },
        { OLEIVERB_OPEN, NULL, 0, 0 },
        { OLEIVERB_SHOW, NULL, 0, 0 },
        { OLEIVERB_PRIMARY, lpszPlay, MF_ENABLED, OLEVERBATTRIB_ONCONTAINERMENU },
        { 1, lpszEdit, MF_ENABLED, OLEVERBATTRIB_ONCONTAINERMENU },
        { 2, lpszOpen, MF_ENABLED, OLEVERBATTRIB_ONCONTAINERMENU }
    };
#if !defined(UNICODE) && !defined(OLE2ANSI)
    TCHAR sz[64];
    LoadString(ghInst, IDS_PLAYVERB, sz, ARRAY_SIZE(sz));
    MultiByteToWideChar(CP_ACP, 0, sz, -1, lpszPlay, ARRAY_SIZE(lpszPlay));
    
    LoadString(ghInst, IDS_EDITVERB, sz, ARRAY_SIZE(sz));
    MultiByteToWideChar(CP_ACP, 0, sz, -1, lpszEdit, ARRAY_SIZE(lpszEdit));
    
    LoadString(ghInst, IDS_OPENVERB, sz, ARRAY_SIZE(sz));
    MultiByteToWideChar(CP_ACP, 0, sz, -1, lpszOpen, ARRAY_SIZE(lpszOpen));
    
#else
    LoadString(ghInst, IDS_PLAYVERB, lpszPlay, ARRAY_SIZE(lpszPlay));
    LoadString(ghInst, IDS_EDITVERB, lpszEdit, ARRAY_SIZE(lpszEdit));
    LoadString(ghInst, IDS_OPENVERB, lpszOpen, ARRAY_SIZE(lpszOpen));
#endif
    
    pClass->_pVerbTable = OleVerbs;
    pClass->_cVerbTable = ARRAY_SIZE(OleVerbs);

    return TRUE;
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::Create, public
//
//  Synopsis:   Creates and initializes an SRCtrl object
//
//  Arguments:  [pUnkOuter] -- A controlling unknown.  NULL if we are not
//                             being created as part of an aggregation
//              [pClass]    -- The OlePad class descriptor
//              [ppUnkCtrl] -- Where we return our controlling unknown
//              [ppObj]     -- Pointer to the SRCtrl object created
//
//  Returns:    Success if the object could be successfully created and
//              initialized.
//
//---------------------------------------------------------------

HRESULT
SRCtrl::Create( LPUNKNOWN pUnkOuter,
        LPCLASSDESCRIPTOR pClass,
        LPUNKNOWN FAR* ppUnkCtrl,
        LPSRCTRL FAR* ppObj)
{
    // set out parameters to NULL
    *ppUnkCtrl = NULL;
    *ppObj = NULL;

    if(gpCtrlThis)
    {
        DOUT(TEXT("SRCtrl::Create non-NULL gpCtrlThis!"));
        return E_FAIL;
    }

    // create an object
    HRESULT hr = E_OUTOFMEMORY;
    LPSRCTRL pObj = new SRCtrl(pUnkOuter);
    if (pObj != NULL)
    {
        // initialize it
        if (OK(hr = pObj->Init(pClass)))
        {
            // return the object and its controlling unknown
            *ppUnkCtrl = &pObj->_PrivUnk;
            *ppObj = gpCtrlThis = pObj;
        }
    }
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::SRCtrl, protected
//
//  Synopsis:   Constructor for the SRCtrl class
//
//  Arguments:  [pUnkOuter] -- the controlling unknown or NULL if we are
//                              not being created as part of an aggregate
//
//  Notes:      This is the first part of a two-stage construction process.
//              The second part is in the Init method.  Use the static
//              Create method to properly instantiate an SRCtrl object
//
//---------------------------------------------------------------

#pragma warning(disable:4355)   // `this' argument to base-member init. list.
SRCtrl::SRCtrl(LPUNKNOWN pUnkOuter):
        _PrivUnk(this)  // the controlling unknown holds a pointer to the object
{
    static SrvrCtrl::LPFNDOVERB VerbFuncs[] =
    {
        &SrvrCtrl::DoInPlaceActivate, // OLEIVERB_INPLACEACTIVATE
        &SrvrCtrl::DoUIActivate,      // OLEIVERB_UIACTIVATE
        &SrvrCtrl::DoHide,            // OLEIVERB_HIDE
        &SRCtrl::DoOpen,              // OLEIVERB_OPEN
        &SRCtrl::DoShow,              // OLEIVERB_SHOW
        &SRCtrl::DoPlay,              // Play, OLEIVERB_PRIMARY
        &SRCtrl::DoOpen,              // Edit 
        &SRCtrl::DoOpen               // Open
    };

    _pUnkOuter = (pUnkOuter != NULL) ? pUnkOuter : (LPUNKNOWN)&_PrivUnk;

    _pDVCtrlUnk = NULL;
    _pIPCtrlUnk = NULL;

    _pVerbFuncs = VerbFuncs;
    _cLock = 0;
    _fLoaded = FALSE;
}
#pragma warning(default:4355)

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::DoPlay, public, static
//
//  Synopsis:   Implementation of the play verb.
//              This verb results in a transition to the open state.
//
//---------------------------------------------------------------

HRESULT
SRCtrl::DoPlay(LPVOID pv,
        LONG iVerb,
        LPMSG lpmsg,
        LPOLECLIENTSITE pActiveSite,
        LONG lindex,
        HWND hwndParent,
        LPCRECT lprcPosRect)
{
    DOUT(TEXT("SrvrCtrl::DoPlay\r\n"));
    LPSRCTRL pCtrl = (LPSRCTRL)pv;

    BOOL fClose = FALSE;
    
    /* if we are already open, just play it.
     * if we aren't, play it and close.
     */
    if (!gfStandalone)
    {
        fClose = pCtrl->State() != OS_OPEN;
        
        /* We've never been loaded.  This means someone (Project 4.0) is
         * calling our primary verb incorrectly on Insert->Object.  They
         * really want us to DoOpen.
         */
        if (!pCtrl->IsLoaded())
            return (pCtrl->DoOpen(pv, iVerb, lpmsg, pActiveSite, lindex,
                hwndParent,lprcPosRect));
    }

    if (IsWindowVisible(ghwndApp))
        SetForegroundWindow(ghwndApp);
    
    AppPlay(fClose);
    
    return pCtrl->TransitionTo(OS_OPEN);
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::DoShow, public
//
//  Synopsis:   Implementation of the standard verb OLEIVERB_SHOW.
//              This verb results in a transition to the open state.
//
//---------------------------------------------------------------

HRESULT
SRCtrl::DoShow(LPVOID pv,
        LONG iVerb,
        LPMSG lpmsg,
        LPOLECLIENTSITE pActiveSite,
        LONG lindex,
        HWND hwndParent,
        LPCRECT lprcPosRect)
{
    DOUT(TEXT("SrvrCtrl::DoShow\r\n"));

    LPSRCTRL pCtrl = (LPSRCTRL)pv;
    if(pCtrl->State() == OS_OPEN)
    {
        HWND hwnd = NULL;
        if(pCtrl->_pInPlace)
            pCtrl->_pInPlace->GetWindow(&hwnd);
        if(hwnd != NULL)
            SetForegroundWindow(hwnd);
    }
    WriteObjectIfEmpty();
    return pCtrl->TransitionTo(OS_OPEN);
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::DoOpen, public
//
//  Synopsis:   Implementation of the standard verb OLEIVERB_OPEN.
//              This verb results in a transition to the open state.
//
//---------------------------------------------------------------
HRESULT
SRCtrl::DoOpen(LPVOID pv,
        LONG iVerb,
        LPMSG lpmsg,
        LPOLECLIENTSITE pActiveSite,
        LONG lindex,
        HWND hwndParent,
        LPCRECT lprcPosRect)
{
    DOUT(TEXT("SRCtrl::DoOpen\r\n"));

    LPSRVRCTRL pCtrl = (LPSRVRCTRL)pv;
    if(pCtrl->State() == OS_OPEN)
    {
        HWND hwnd = NULL;
        if(pCtrl->_pInPlace)
            pCtrl->_pInPlace->GetWindow(&hwnd);
        if(hwnd != NULL)
            SetForegroundWindow(hwnd);
        if (IsWindowVisible(ghwndApp))
            SetForegroundWindow(ghwndApp);

    }
    return pCtrl->TransitionTo(OS_OPEN);
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::Init, protected
//
//  Synopsis:   Initializes an SRCtrl object
//
//  Arguments:  [pClass] -- the class descriptor
//
//  Returns:    SUCCESS iff the class could be initialized
//
//  Notes:      This is the second part of a two-stage construction
//              process.  Use the static Create method to properly
//              instantiate an SRCtrl object.
//
//---------------------------------------------------------------

HRESULT
SRCtrl::Init(LPCLASSDESCRIPTOR pClass)
{
    HRESULT hr = NOERROR;

    if (OK(hr = SrvrCtrl::Init(pClass)))
    {
        LPSRDV pSRDV;
        LPUNKNOWN pDVCtrlUnk;
        if (OK(hr = SRDV::Create(this, pClass, &pDVCtrlUnk, &pSRDV)))
        {
            LPSRINPLACE pSRInPlace;
            LPUNKNOWN pIPCtrlUnk;
            if (OK(hr = SRInPlace::Create(this,
                    pClass,
                    &pIPCtrlUnk,
                    &pSRInPlace)))
            {
                _pDVCtrlUnk = pDVCtrlUnk;
                _pDV = pSRDV;
                _pIPCtrlUnk = pIPCtrlUnk;
                _pInPlace = pSRInPlace;

                pDVCtrlUnk->AddRef();
//        This was in paintbrush.  I expect it's because standalone objects don't
//        do state transitions correctly
//                Lock();
            }
            pDVCtrlUnk->Release();  // on failure this will free DV subobject
        }
    }
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::~SRCtrl
//
//  Synopsis:   Destructor for the SRCtrl class
//
//---------------------------------------------------------------

SRCtrl::~SRCtrl(void)
{
    DOUT(TEXT("SRCtrl::~SRCtrl\r\n"));
    if(_state > OS_PASSIVE)
    {
        // make sure we are back to the loaded state
        TransitionTo(OS_LOADED);
    }
    
    //
    // If we are not being shut down by the user (via FILE:EXIT etc.,)
    // then we must cause app shutdown here...
    //

// This AddRef is necessary to prevent a reentrancy within
// TerminateServer because it does a QI and Release to get a storage
// if an uncommitted object is on the clipboard at exit time. 
    AddRef();
    
    if (!gfUserClose && !gfTerminating)
        TerminateServer();

    if (gpFileMoniker != NULL)
        gpFileMoniker->Release();

    //
    // release the controlling unknowns of our subobjects, which should
    // free them...
    //
    DOUT(TEXT("~SRCtrl: DV->Release\r\n"));
    if (_pDVCtrlUnk != NULL)
    {
        _pDVCtrlUnk->Release();
    }
    
    DOUT(TEXT("~SRCtrl: IP->Release\r\n"));
    if (_pIPCtrlUnk != NULL)
    {
        _pIPCtrlUnk->Release();
    }
    
    gpCtrlThis = NULL;
}


// the standard IUnknown methods all delegate to the controlling unknown.
IMPLEMENT_DELEGATING_IUNKNOWN(SRCtrl)

IMPLEMENT_PRIVATE_IUNKNOWN(SRCtrl)

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::PrivateUnknown::QueryInterface
//
//  Synopsis:   QueryInterface on our controlling unknown
//
//---------------------------------------------------------------

STDMETHODIMP
SRCtrl::PrivateUnknown::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
#if DBG
    TCHAR achBuffer[256];
    wsprintf(achBuffer,
            TEXT("SRCtrl::PrivateUnknown::QueryInterface (%lx)\r\n"),
            riid.Data1);
    DOUT(achBuffer);
#endif
    
    if (IsEqualIID(riid, IID_IUnknown))
    {
        *ppv = (void FAR *)this;
    }
    else if (IsEqualIID(riid, IID_IOleObject))
    {
        *ppv = (void FAR *) (LPOLEOBJECT)_pSRCtrl;
    }
    else    // try each of our delegate subobjects until one succeeds
    {
        HRESULT hr;
        if (!OK(hr = _pSRCtrl->_pDVCtrlUnk->QueryInterface(riid, ppv)))
            hr = _pSRCtrl->_pIPCtrlUnk->QueryInterface(riid, ppv);
        return hr;
    }

    //
    // Important:  we must addref on the pointer that we are returning,
    // because that pointer is what will be released!
    //
    ((IUnknown FAR*) *ppv)->AddRef();
    return NOERROR;
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::GetMoniker
//
//  Synopsis:   Method of IOleObject interface
//
//  Notes:      Our overide creates a file moniker for the Standalone case
//
//---------------------------------------------------------------

STDMETHODIMP
SRCtrl::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER FAR* ppmk)
{
    DOUT(TEXT("SRCtrl::GetMoniker\r\n"));

    HRESULT hr = E_INVALIDARG;

    if (ppmk == NULL)
    {
        DOUT(TEXT("SRCtrl::GetMoniker E_INVALIDARG\r\n"));
        return hr;
    }
    *ppmk = NULL;   // set out parameters to NULL

    if(gfStandalone || gfLinked)    // set by FlagEmbededObject()
    {
        if(gpFileMoniker != NULL)
        {
            *ppmk = gpFileMoniker;
            gpFileMoniker->AddRef();
            hr = NOERROR;
        }
        else
        {
#if !defined(UNICODE) && !defined(OLE2ANSI)            
            LPOLESTR lpLinkFilename = ConvertMBToOLESTR(gachLinkFilename, -1);
            if((hr = CreateFileMoniker(lpLinkFilename, &gpFileMoniker)) == NOERROR)
            {
                gpFileMoniker->AddRef(); //because we are keeping this pointer
                *ppmk = gpFileMoniker;
                RegisterAsRunning((LPUNKNOWN)this, *ppmk, &gdwRegROT);
            }
            else
            {
                DOUT(TEXT("SRCtrl::GetMoniker CreateFileMoniker FAILED!\r\n"));
            }
            TaskFreeMem(lpLinkFilename);
#else
            if((hr = CreateFileMoniker(gachLinkFilename, &gpFileMoniker)) == NOERROR)
            {
                gpFileMoniker->AddRef(); //because we are keeping this pointer
                *ppmk = gpFileMoniker;
                RegisterAsRunning((LPUNKNOWN)this, *ppmk, &gdwRegROT);
            }
            else
            {
                DOUT(TEXT("SRCtrl::GetMoniker CreateFileMoniker FAILED!\r\n"));
            }
#endif                        
        }
    }
    else
    {
        return SrvrCtrl::GetMoniker(dwAssign, dwWhichMoniker, ppmk);
    }
    return hr;
}
//+---------------------------------------------------------------
//
//  Member:     SRCtrl::IsUpToDate
//
//  Synopsis:   Method of IOleObject interface
//
//  Notes:      Return S_FALSE if we are dirty (not up-to-date)
//
//---------------------------------------------------------------

STDMETHODIMP
SRCtrl::IsUpToDate(void)
{
    DOUT(TEXT("SRCtrl::IsUpToDate\r\n"));

    return gfDirty ? S_FALSE : S_OK;
}
#if 0
//+---------------------------------------------------------------
//
//  Member:     SRCtrl::GetHostNames, public
//
//  Synopsis:   Returns any host names set by the container
//
//  Arguments:  [plpstrCntrApp] -- location for string indicating the top-level
//                                  container application.
//              [plpstrCntrObj] -- location for string indicating the top-level
//                                  document.
//
//  Notes:      The method makes available the strings originally set by the
//              container using IOleObject::SetHostNames.  These strings are
//              used in the title bar of an open-edited object.  It is useful
//              to containers that need to forward this information to their
//              embeddings.  The returned strings are allocated using the
//              standard task allocator and should be freed appropriately by
//              the caller.
//
//---------------------------------------------------------------

void
SRCtrl::GetHostNames(LPTSTR FAR* plpstrCntrApp, LPTSTR FAR* plpstrCntrObj)
{
    if (_lpstrCntrApp != NULL)
    {
        TaskAllocString(_lpstrCntrApp, plpstrCntrApp);
    }
    else
    {
        *plpstrCntrApp = NULL;
    }

    if (_lpstrCntrObj != NULL)
    {
        TaskAllocString(_lpstrCntrObj, plpstrCntrObj);
    }
    else
    {
        *plpstrCntrObj = NULL;
    }
}
#endif
void
SRCtrl::Lock(void)
{
    ++_cLock;
#if DBG
    TCHAR achBuffer[256];
    wsprintf(achBuffer, TEXT("\\\\SRCtrl::Lock (%d)\r\n"), _cLock);
    DOUT(achBuffer);
#endif
    CoLockObjectExternal((LPUNKNOWN)&_PrivUnk, TRUE, TRUE);
}

void
SRCtrl::UnLock(void)
{
    --_cLock;
#if DBG
    TCHAR achBuffer[256];
    wsprintf(achBuffer, TEXT("\\\\SRCtrl::UnLock (%d)\r\n"), _cLock);
    DOUT(achBuffer);
#endif
    Assert(_cLock >= 0);
    CoLockObjectExternal((LPUNKNOWN)&_PrivUnk, FALSE, TRUE);
}

BOOL
SRCtrl::IsLoaded(void)
{
    return _fLoaded;
}

void
SRCtrl::MarkAsLoaded(void)
{
    _fLoaded = TRUE;
}

HRESULT
SRCtrl::PassiveToLoaded()
{
    DOUT(TEXT("=== SRCtrl::PassiveToLoaded\r\n"));
    Lock();    
    return SrvrCtrl::PassiveToLoaded();
}

HRESULT
SRCtrl::LoadedToPassive()
{
    DOUT(TEXT("=== SRCtrl::LoadedToPassive\r\n"));
    HRESULT hr = SrvrCtrl::LoadedToPassive();
    UnLock();
    return hr;
}


//+---------------------------------------------------------------
//
//  Member:     SRCtrl::RunningToOpened
//
//  Synopsis:   Effects the running to open state transition
//
//  Returns:    SUCCESS in all but catastrophic circumstances
//
//---------------------------------------------------------------

HRESULT
SRCtrl::RunningToOpened()
{
    DOUT(TEXT("SRCtrl::RunningToOpened\r\n"));

    // ...  show open editing window
    if (!gfStandalone)
    {
        FixMenus();
    
        if (gfShowWhilePlaying)
            ShowWindow(ghwndApp, SW_SHOW | SW_SHOWNORMAL);
        if (IsWindowVisible(ghwndApp))
            SetForegroundWindow(ghwndApp);
    }
    OleNoteObjectVisible((LPUNKNOWN)&_PrivUnk, TRUE);

    //
    // notify our container so it can hatch-shade our object 
    // indicating that it is open-edited...
    //
    
    if (_pClientSite != NULL)
        _pClientSite->OnShowWindow(TRUE);

    SetFocus(ghwndApp);

    return NOERROR;
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::OpenedToRunning
//
//  Synopsis:   Effects the open to running state transition
//
//  Returns:    SUCCESS in all but catastrophic circumstances
//
//---------------------------------------------------------------

HRESULT
SRCtrl::OpenedToRunning()
{
    DOUT(TEXT("SRCtrl::OpenedToRunning\r\n"));
    
    //
    // If we are transitioning to a standalone app, we don't want the app
    // to disappear.
    //
    ShowWindow(ghwndApp,SW_HIDE);
    
    HRESULT hr = SrvrCtrl::OpenedToRunning();
    
    OleNoteObjectVisible((LPUNKNOWN)&_PrivUnk, FALSE);
    
    return hr;
}


const OLECHAR szContentsStrm[] = OLETEXT("contents");
const OLECHAR szOLE1Strm[] = OLETEXT("\1Ole10Native");

//---------------------------------------------------------------
//
//  The Format Tables
//
//---------------------------------------------------------------

//
// GetData format information
// note: the LINKSRCDESCRIPTOR and OBJECTDESCRIPTOR are identical structures
//       so we use the OBJECTDESCRIPTOR get/set fns for both.
//

    static FORMATETC SRGetFormatEtc[] =
    {// { cfFormat, ptd, dwAspect, lindex, tymed },
#if 0
// NTBUG # 11225: CorelDraw 5.0 does not like our implementation of
//                CF_EMBEDDEDOBJECT and cannot save our data in the
//                Insert->Object->CreateFromFile scenerio        
        
        { (unsigned short)-OCF_EMBEDDEDOBJECT, NULL, DVASPECT_CONTENT, -1L, TYMED_ISTORAGE },
#else
        { (unsigned short)-OCF_EMBEDSOURCE, NULL, DVASPECT_CONTENT, -1L, TYMED_ISTORAGE },
#endif
        { CF_METAFILEPICT, DVTARGETIGNORE, DVASPECT_CONTENT, -1L, TYMED_MFPICT },
        { CF_DIB, DVTARGETIGNORE, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },            
        { (unsigned short)-OCF_OBJECTDESCRIPTOR, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },
        { (unsigned short)-OCF_LINKSRCDESCRIPTOR, NULL, DVASPECT_CONTENT, -1L, TYMED_HGLOBAL },
        { (unsigned short)-OCF_LINKSOURCE, NULL, DVASPECT_CONTENT, -1L, TYMED_ISTREAM }
    };
    
    static SrvrDV::LPFNGETDATA SRGetFormatFuncs[] =
    {   &SRDV::GetEMBEDDEDOBJECT,
        &SRDV::GetMETAFILEPICT,
        &SRDV::GetDIB,
        &SRDV::GetOBJECTDESCRIPTOR,
        &SRDV::GetOBJECTDESCRIPTOR,
        &SRDV::GetLINKSOURCE
    };

//+---------------------------------------------------------------
//
//  Member:     SRDV::ClassInit (static)
//
//  Synopsis:   Initializes the SRDV class
//
//  Arguments:  [pClass] -- our class descriptor
//
//  Returns:    TRUE iff the class could be initialized successfully
//
//  Notes:      This method initializes the format tables in the
//              class descriptor.
//
//---------------------------------------------------------------

BOOL
SRDV::ClassInit(LPCLASSDESCRIPTOR pClass)
{
    // fill in the class descriptor structure with the format tables
    pClass->_pGetFmtTable = SRGetFormatEtc;
    pClass->_cGetFmtTable = ARRAY_SIZE(SRGetFormatEtc);

    pClass->_pSetFmtTable = NULL;
    pClass->_cSetFmtTable = 0;

    //
    // walk our format tables and complete the cfFormat field from
    // the array of standard OLE clipboard formats.
    //
    LPFORMATETC pfe = SRGetFormatEtc;
    int c = ARRAY_SIZE(SRGetFormatEtc);

    for (int i = 0; i < c; i++, pfe++)
    {
        // if the clipformat is negative, then it really is an index into
        // our table of standard OLECLIPFORMATS
        int j = - (short)pfe->cfFormat;
        if (j >= 0 && j <= OCF_LAST)
            pfe->cfFormat = (WORD)OleClipFormat[j];
    }

    pfe = g_aGetFmtEtcs;
    c = ARRAY_SIZE(g_aGetFmtEtcs);

    for (i = 0; i < c; i++, pfe++)
    {
        // if the clipformat is negative, then it really is an index into
        // our table of standard OLECLIPFORMATS
        
        int j = - (short)pfe->cfFormat;
        if (j >= 0 && j <= OCF_LAST)
        {
            pfe->cfFormat = (WORD)OleClipFormat[j];
        }
    }
    
    return TRUE;
}

HRESULT
SRDV::GetDIB( LPSRVRDV pDV,
        LPFORMATETC pformatetc,
        LPSTGMEDIUM pmedium,
        BOOL fHere)
{
    HRESULT hr = NOERROR;
    LPVIEWOBJECT pView = (LPVIEWOBJECT)pDV;
    HANDLE hDIB;
            
    if (!fHere)
    {
        // fill in the pmedium structure
        pmedium->tymed = TYMED_HGLOBAL;
    }

    hDIB = ::GetDIB(pmedium->hGlobal);
    if (hDIB)
        pmedium->hGlobal = hDIB;
    else
        hr = E_OUTOFMEMORY;
    
    return hr;
}


//+---------------------------------------------------------------
//
//  Member:     SRDV::Create, public
//
//  Synopsis:   Creates and initializes an SRDV object
//
//  Arguments:  [pCtrl]     -- our control subobject
//              [pClass]    -- The class descriptor
//              [ppUnkCtrl] -- Where we return our controlling unknown
//              [ppObj]     -- where the created object is returned
//
//  Returns:    Success if the object could be successfully created and
//              initialized.
//
//---------------------------------------------------------------

HRESULT
SRDV::Create(LPSRCTRL pCtrl,
        LPCLASSDESCRIPTOR pClass,
        LPUNKNOWN FAR* ppUnkCtrl,
        LPSRDV FAR* ppObj)
{
    // set out parameters to NULL
    *ppUnkCtrl = NULL;
    *ppObj = NULL;

    // create an object
    HRESULT hr;
    LPSRDV pObj;
    pObj = new SRDV((LPUNKNOWN)(LPOLEOBJECT)pCtrl);
    if (pObj == NULL)
    {
        hr =  E_OUTOFMEMORY;
    }
    else
    {
        // initialize it
        if (OK(hr = pObj->Init(pCtrl, pClass)))
        {
            // return the object and its controlling unknown
            *ppUnkCtrl = &pObj->_PrivUnk;
            *ppObj = pObj;
        }
        else
        {
            pObj->_PrivUnk.Release();   //hari-kari
        }
    }
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     SRDV::SRDV, protected
//
//  Synopsis:   Constructor for the SRDV class
//
//  Arguments:  [pUnkOuter] -- the controlling unknown.  This is either
//                             a SRCtrl subobject or NULL we are being
//                             created as a transfer object.
//
//  Notes:      This is the first part of a two-stage construction process.
//              The second part is in the Init method.  Use the static
//              Create method to properly instantiate an SRDV object
//
//---------------------------------------------------------------

#pragma warning(disable:4355)   // `this' argument to base-member init. list.
SRDV::SRDV(LPUNKNOWN pUnkOuter):
    _PrivUnk(this)  // the controlling unknown holds a pointer to the object
{
    _pUnkOuter = (pUnkOuter != NULL) ? pUnkOuter : (LPUNKNOWN)&_PrivUnk;

    _pGetFuncs = SRGetFormatFuncs;
    _pSetFuncs = NULL;

    _sizel = _header._sizel;
}
#pragma warning(default:4355)

//+---------------------------------------------------------------
//
//  Member:     SRDV::Init, protected
//
//  Synopsis:   Initializes an SRDV object
//
//  Arguments:  [pCtrl]  -- our controlling SRCtrl subobject
//              [pClass] -- the class descriptor
//
//  Returns:    SUCCESS iff the class could be initialized
//
//  Notes:      This is the second part of a two-stage construction
//              process.  Use the static Create method to properly
//              instantiate an SRDV object.
//
//---------------------------------------------------------------

HRESULT
SRDV::Init(LPSRCTRL pCtrl, LPCLASSDESCRIPTOR pClass)
{
    HRESULT hr = SrvrDV::Init(pClass, pCtrl);
    //
    //do our own xtra init here...
    //
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     SRDV::~SRDV
//
//  Synopsis:   Destructor for the SRDV class
//
//---------------------------------------------------------------

SRDV::~SRDV(void)
{
    //
    // TODO: check on anything we may have to clean up here...
    //
}

// the standard IUnknown methods all delegate to a controlling unknown.
IMPLEMENT_DELEGATING_IUNKNOWN(SRDV)

IMPLEMENT_PRIVATE_IUNKNOWN(SRDV)

//+---------------------------------------------------------------
//
//  Member:     SRDV::PrivateUnknown::QueryInterface
//
//  Synopsis:   QueryInterface on our controlling unknown
//
//---------------------------------------------------------------

STDMETHODIMP
SRDV::PrivateUnknown::QueryInterface (REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid,IID_IUnknown))
    {
        *ppv = (LPVOID)this;
    }
    else if (IsEqualIID(riid,IID_IDataObject))
    {
        *ppv = (LPVOID)(LPDATAOBJECT)_pSRDV;
    }
    else if (IsEqualIID(riid,IID_IViewObject))
    {
        *ppv = (LPVOID)(LPVIEWOBJECT)_pSRDV;
    }
    else if (IsEqualIID(riid,IID_IPersist))
    {
        //
        // The standard handler wants this
        //
        *ppv = (LPVOID)(LPPERSIST)(LPPERSISTSTORAGE)_pSRDV;
    }
    else if (IsEqualIID(riid,IID_IPersistStorage))
    {
        *ppv = (LPVOID)(LPPERSISTSTORAGE)_pSRDV;
    }
    else if (IsEqualIID(riid,IID_IPersistFile))
    {
        *ppv = (LPVOID)(LPPERSISTFILE)_pSRDV;
    }
    else   
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    
    //
    // Important:  we must addref on the pointer that we are returning,
    // because that pointer is what will be released!
    //
    ((IUnknown FAR*) *ppv)->AddRef();
    return NOERROR;
}

//+---------------------------------------------------------------
//
//  Member:     SRDV::RenderContent, public
//
//  Synopsis:   Draws our contents into a display context
//
//  Arguments:  The arguments are the same as to the IViewObject::Draw method
//
//  Returns:    SUCCESS if the content was rendered
//
//  Notes:      This virtual method of the base class is called to implement
//              IViewObject::Draw for the DVASPECT_CONTENT aspect.
//
//----------------------------------------------------------------

HRESULT
SRDV::RenderContent(DWORD dwDrawAspect,
        LONG lindex,
        void FAR* pvAspect,
        DVTARGETDEVICE FAR * ptd,
        HDC hicTargetDev,
        HDC hdcDraw,
        LPCRECTL lprectl,
        LPCRECTL lprcWBounds,
        BOOL (CALLBACK *pfnContinue) (ULONG_PTR),
        ULONG_PTR dwContinue)
{
    DOUT(TEXT("SoundRec: RenderContent\r\n"));
    
    int x = GetSystemMetrics(SM_CXICON);
    int y = GetSystemMetrics(SM_CYICON);
    HDC hdc = GetDC(ghwndApp);
    HDC hdcMem = CreateCompatibleDC(hdc);
    HBITMAP hbm = CreateCompatibleBitmap(hdc, x, y);
    HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbm);
    
    PatBlt(hdcMem, 0, 0, x, y, WHITENESS); 
    DrawIcon(hdcMem, 0, 0, ghiconApp);    
    
    StretchBlt(hdcDraw, lprectl->left, lprectl->top,
                lprectl->right - lprectl->left, lprectl->bottom - lprectl->top,
                hdcMem, 0, 0, x, y, SRCCOPY);
    
    hbm = (HBITMAP)SelectObject(hdcMem, hbmOld);
    
    if (hdcMem)
        DeleteDC(hdcMem);
    if (hbm)
        DeleteObject(hbm);
    if (hdc)
        ReleaseDC(ghwndApp, hdc);
    
    return NOERROR;
}


/*
 * SRDV::Load
 * Implements IPersistFile::Load
 *
 * Side effects: gfLinked - we know we are linked.
 */

STDMETHODIMP
SRDV::Load (LPCOLESTR lpstrFile, DWORD grfMode)
{
    DOUT(TEXT("SoundRec:SRDV::Load\r\n"));
    
#if !defined(UNICODE) && !defined(OLE2ANSI)
    LPTSTR lpszFileName = ConvertOLESTRToMB(lpstrFile,-1);
    FileLoad(lpszFileName);
    TaskFreeMem(lpszFileName);
#else
    TCHAR szFileName[256];
    
    lstrcpy(szFileName,lpstrFile);
    FileLoad(szFileName);
#endif
    gfLinked = TRUE;
    if (gpCtrlThis)
        gpCtrlThis->MarkAsLoaded();
    
    return ResultFromScode( S_OK );
}
    


//+---------------------------------------------------------------
//
//  Member:     LoadFromStorage
//
//  Synopsis:   Loads our data from a storage
//
//  Arguments:  [pStg] -- storage to load from
//
//  Returns:    SUCCESS if our native data was loaded
//
//  Notes:      This is a virtual method in our base class that is called
//              on an IPersistStorage::Load and an IPersistFile::Load when
//              the file is a docfile.  We override this method to
//              do our server-specific loading.
//
//----------------------------------------------------------------

HRESULT
SRDV::LoadFromStorage(LPSTORAGE pStg)
{
    DOUT(TEXT("SoundRec: LoadFromStorage\r\n"));
    LPSTREAM pStrm;

    // Open the OLE 1 Stream. 
    HRESULT hr = pStg->OpenStream(szOLE1Strm, NULL, STGM_SALL,0, &pStrm);
    
    if (OK(hr))
    {
        DWORD cbSize = 0L;

        pStrm->Read(&cbSize, sizeof(DWORD), NULL);
        
        if (cbSize > 0L)
        {
            LPBYTE lpbData = NULL;
            HANDLE hData = GlobalAlloc(GMEM_DDESHARE | GMEM_ZEROINIT, cbSize);
        
            if(hData != NULL)
            {
                if ((lpbData = (LPBYTE)GlobalLock(hData)) != NULL)
                {
                    pStrm->Read(lpbData, cbSize - sizeof(DWORD), NULL);
                    PutNativeData(lpbData, cbSize);
                    
                    GlobalUnlock(hData);
                    GlobalFree(hData);
                    if (gpCtrlThis)
                        gpCtrlThis->MarkAsLoaded();
                }
                else
                {
                    DOUT(TEXT("!Cannot Allocate Memory\r\n"));
                }
            }
        }
        pStrm->Release();
    }
    else
    {
//  There might be, in the future this ole2 stream, also, beta
//  ole objects will break without this.
        
        hr = pStg->OpenStream(szContentsStrm, NULL, STGM_SALL,0, &pStrm);
        if (OK(hr))
        {
            // Read the whole contents stream into memory and use that as a stream
            // to do our bits and pieces reads.
            pStrm = ConvertToMemoryStream(pStrm);

            hr = _header.Read(pStrm);
            if (OK(hr))
            {
                _sizel = _header._sizel;
                if(_header._dwNative > 0)
                {
                    //
                    //TODO: this code needs to be optimized. It is bad to create
                    //      three redundant copies of the wave data! At a minimum,
                    //      the ReadWaveFile (file.c) function should get a
                    //      companion MMIOProc capable of reading directly from
                    //      the stream...
                    //
                    LPBYTE lpbData = NULL;
                    HANDLE hData = GlobalAlloc(GMEM_DDESHARE | GMEM_ZEROINIT, _header._dwNative);
                    if(hData != NULL)
                    {
                        if ((lpbData = (LPBYTE)GlobalLock(hData)) != NULL)
                        {
                            pStrm->Read(lpbData, _header._dwNative, NULL);
                            PutNativeData(lpbData, _header._dwNative);
                            GlobalUnlock(hData);
                            GlobalFree(hData);
                            if (gpCtrlThis)
                                gpCtrlThis->MarkAsLoaded();
                        }
                    }
                    else
                    {
                        DOUT(TEXT("!Cannot Allocate Memory\r\n"));
                    }
                }
            }
            pStrm->Release();
        }
        else
        {
            DOUT(TEXT("!Cannot Open Stream\r\n"));
        }
    }
    return hr;
}

//+---------------------------------------------------------------
//
//  Member:     SaveToStorage
//
//  Synopsis:   Saves our data to a storage
//
//  Arguments:  [pStg]        -- storage to save to
//              [fSameAsLoad] -- flag indicating whether this is the same
//                               storage that we originally loaded from
//
//  Returns:    SUCCESS if our native data was saved
//
//  Notes:      This is a virtual method in our base class that is called
//              on an IPersistStorage::Save and IPersistFile::Save when the
//              file is a docfile.  We override this method to
//              do our server-specific saving.
//
//----------------------------------------------------------------

HRESULT
SRDV::SaveToStorage(LPSTORAGE pStg, BOOL fSameAsLoad)
{
    DOUT(TEXT("SoundRec: SaveToStorage\r\n"));

    HRESULT hr;

    // Mark our storage as OLE1
    if (!OK(hr = WriteClassStg(pStg, CLSID_OLE1SOUNDREC)))
        return hr;
    
    // open or create the native data stream and write our native data
    LPSTREAM pStrm;

    hr = pStg->CreateStream(szOLE1Strm,
            STGM_SALL | STGM_CREATE,
            0L,
            0L,
            &pStrm);

    if (!OK(hr))
        return hr;
    
    if (OK(hr))
    {
        HANDLE hNative = GetNativeData();
        DWORD cbSize;
        
        if (hNative != NULL && (cbSize = (DWORD)GlobalSize(hNative)) > 0)
        {
            hr = pStrm->Write(&cbSize, sizeof(cbSize), NULL);
            if (OK(hr))
            {
                LPBYTE pNative = (LPBYTE)GlobalLock(hNative);
                if(pNative != NULL)
                {
                    hr = pStrm->Write(pNative, cbSize, NULL);
                    GlobalUnlock(hNative);
                }
            }
        }
        if (hNative)
            GlobalFree(hNative);
    }
    
    pStrm->Release();
    
#ifdef OLE2ONLY
    hr = pStg->CreateStream(szContentsStrm,
            STGM_SALL | STGM_CREATE,
            0L,
            0L,
            &pStrm);

    if (OK(hr))
    {
        // update the members that may have changed
        _header._sizel = _sizel;

        HANDLE hNative = GetNativeData();
        _header._dwNative = GlobalSize(hNative);
        hr = _header.Write(pStrm);
        if (OK(hr))
        {
            if(_header._dwNative > 0)
            {
                LPBYTE pNative = (LPBYTE)GlobalLock(hNative);
                if(pNative != NULL)
                {
                    hr = pStrm->Write(pNative, _header._dwNative, NULL);
                    GlobalUnlock(hNative);
                }
            }
        }
        GlobalFree(hNative);
        pStrm->Release();
    }
#endif    
    return hr;
}


#ifdef WE_SUPPORT_INPLACE

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::RunningToInPlace
//
//  Synopsis:   Effects the running to inplace-active state transition
//
//  Returns:    SUCCESS if the object results in the in-place state
//
//---------------------------------------------------------------

HRESULT
SRCtrl::RunningToInPlace(void)
{
    return SrvrCtrl::RunningToInPlace();
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::InPlaceToRunning
//
//  Synopsis:   Effects the inplace-active to running state transition
//
//  Returns:    SUCCESS in all but catastrophic circumstances
//
//---------------------------------------------------------------

HRESULT
SRCtrl::InPlaceToRunning(void)
{
    return SrvrCtrl::InPlaceToRunning();
}

//+---------------------------------------------------------------
//
//  Member:     SRCtrl::UIActiveToInPlace
//
//  Synopsis:   Effects the U.I. active to inplace-active state transition
//
//  Returns:    SUCCESS in all but catastrophic circumstances
//
//---------------------------------------------------------------

HRESULT
SRCtrl::UIActiveToInPlace(void)
{
    return SrvrCtrl::UIActiveToInPlace();
}

#endif // WE_SUPPORT_INPLACE


//+---------------------------------------------------------------
//
//  Member:     SRInPlace::ClassInit (static)
//
//  Synopsis:   Load any static resources
//
//  Arguments:  [pClass] -- an initialized ClassDescriptor
//
//  Returns:    TRUE iff window class sucesfully registered
//
//---------------------------------------------------------------

BOOL
SRInPlace::ClassInit(LPCLASSDESCRIPTOR pClass)
{
    HINSTANCE hinst = pClass->_hinst;

    return TRUE;
}

//+---------------------------------------------------------------
//
//  Member:     SRInPlace::Create (static)
//
//  Synopsis:   Create a new, fully initialize sub-object
//
//  Arguments:  [pSRCtrl] --  pointer to control we are a part of
//              [pClass] -- pointer to initialized class descriptor
//              [ppUnkCtrl] -- (out parameter) pObj's controlling unknown
//              [ppObj] -- (out parameter) the new sub-object
//
//  Returns:    NOERROR iff sucessful
//
//---------------------------------------------------------------

HRESULT
SRInPlace::Create( LPSRCTRL pSRCtrl,
        LPCLASSDESCRIPTOR pClass,
        LPUNKNOWN FAR* ppUnkCtrl,
        LPSRINPLACE FAR* ppObj)
{
    // set out parameters to NULL
    *ppUnkCtrl = NULL;
    *ppObj = NULL;

    // create an object
    HRESULT hr;
    LPSRINPLACE pObj;
    pObj = new SRInPlace((LPUNKNOWN)(LPOLEOBJECT)pSRCtrl);
    if (pObj == NULL)
    {
        hr = E_OUTOFMEMORY;
    }
    else
    {
        // initialize it
        if (OK(hr = pObj->Init(pSRCtrl, pClass)))
        {
            // return the object and its controlling unknown
            *ppUnkCtrl = &pObj->_PrivUnk;
            *ppObj = pObj;
        }
        else
        {
            pObj->_PrivUnk.Release();    //hari-kari
        }
    }
    if(OK(hr))
    {
        hr = NOERROR;
    }
    return hr;
}


//+---------------------------------------------------------------
//
//  Member:     SRInPlace::SRInPlace
//
//  Synopsis:   Construct a new IP sub-object
//
//  Arguments:  [pUnkOuter] -- Unknown to aggregate with
//
//---------------------------------------------------------------

#pragma warning(disable:4355)   // `this' argument to base-member init. list.
SRInPlace::SRInPlace(LPUNKNOWN pUnkOuter):
        _PrivUnk(this)  // controlling unknown holds a pointer to us
{
    _pUnkOuter = (pUnkOuter != NULL) ? pUnkOuter : (LPUNKNOWN)&_PrivUnk;
}
#pragma warning(default:4355)


//+---------------------------------------------------------------
//
//  Member:     SRInPlace::~SRInPlace
//
//  Synopsis:   Destroy this sub-object
//
//---------------------------------------------------------------

SRInPlace::~SRInPlace(void)
{
}

//+---------------------------------------------------------------
//
//  Member:     SRInPlace::Init
//
//  Synopsis:   Initialize sub-object
//
//  Arguments:  [pSRCtrl] --  pointer to control we are a part of
//              [pClass]  -- pointer to an initialized class descriptor
//
//  Returns:    NOERROR if sucessful
//
//---------------------------------------------------------------

HRESULT
SRInPlace::Init(LPSRCTRL pSRCtrl, LPCLASSDESCRIPTOR pClass)
{
    HRESULT hr = SrvrInPlace::Init(pClass, pSRCtrl);
    return hr;
}

IMPLEMENT_DELEGATING_IUNKNOWN(SRInPlace)

IMPLEMENT_PRIVATE_IUNKNOWN(SRInPlace)

//+---------------------------------------------------------------
//
//  Member:     SRInPlace::QueryInterface, public
//
//     OLE:     IUnkown
//
//---------------------------------------------------------------
STDMETHODIMP
SRInPlace::PrivateUnknown::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid,IID_IUnknown))
    {
        *ppv = (LPVOID)this;
    }
    else if (IsEqualIID(riid,IID_IOleInPlaceObject)
          || IsEqualIID(riid,IID_IOleWindow))
    {
        *ppv = (LPVOID)(LPOLEINPLACEOBJECT)_pSRInPlace;
    }
    else if (IsEqualIID(riid,IID_IOleInPlaceActiveObject))
    {
        *ppv = (LPVOID)(LPOLEINPLACEACTIVEOBJECT)_pSRInPlace;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    //
    // Important:  we must addref on the pointer that we are returning,
    // because that pointer is what will be released!
    //
    ((IUnknown FAR*) *ppv)->AddRef();
    return NOERROR;
}

//+---------------------------------------------------------------
//
//  Member:    SRInPlace::AttachWin
//
//  Synopsis:  Create our InPlace window
//
//  Arguments: [hwndParent] -- our container's hwnd
//
//  Returns:   hwnd of InPlace window, or NULL
//
//---------------------------------------------------------------
HWND
SRInPlace::AttachWin(HWND hwndParent)
{
    return NULL;
}