polyline.cpp

英文版的 想要的话可以下载了 为大家服务

/*
 * POLYLINE.CPP
 * Polyline Component Chapter 24
 *
 * Implementation of the CPolyline class that we expose as a
 * component object.
 *
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
 *
 * Kraig Brockschmidt, Microsoft
 * Internet  :  [e-mail]
 * Compuserve:  >INTERNET:[e-mail]
 */


#include "polyline.h"


/*
 * CPolyline:CPolyline
 * CPolyline::~CPolyline
 *
 * Constructor Parameters:
 *  pUnkOuter       LPUNKNOWN of the controlling unknown.
 *  pfnDestroy      PFNDESTROYED to call when an object is
 *                  destroyed.
 *  hInst           HINSTANCE of the application we're in.
 */

CPolyline::CPolyline(LPUNKNOWN pUnkOuter, PFNDESTROYED pfnDestroy
    , HINSTANCE hInst)
    {
    m_hWnd=NULL;
    m_hInst=hInst;

    m_cRef=0;
    m_pUnkOuter=pUnkOuter;
    m_pfnDestroy=pfnDestroy;
    m_fDirty=FALSE;

    m_pImpIPolyline=NULL;
    m_pImpIConnPtCont=NULL;

    m_pAdv=NULL;
    m_pConnPt=NULL;

    m_pST  =NULL;
    m_cf   =0;
    m_clsID=CLSID_Polyline19;

    m_pIStorage=NULL;
    m_pIStream =NULL;

    m_pImpIPersistStorage=NULL;
    m_pImpIPersistStreamInit=NULL;

    m_pImpIDataObject   =NULL;
    m_pIDataAdviseHolder=NULL;

    m_pDefIUnknown       =NULL;
    m_pDefIDataObject    =NULL;
    m_pDefIViewObject    =NULL;
    m_pDefIPersistStorage=NULL;

    m_pIOleAdviseHolder =NULL;
    m_pImpIOleObject    =NULL;
    m_pIOleClientSite   =NULL;
    m_pImpIViewObject   =NULL;
    m_pIAdviseSink      =NULL;

    m_dwFrozenAspects   =0;
    m_dwAdviseAspects   =0;
    m_dwAdviseFlags     =0;

    m_pImpIRunnableObject=NULL;
    m_hDlg=NULL;

    m_pImpIExternalConnection=NULL;
    m_fLockContainer=FALSE;
    m_dwRegROT=0L;

    m_pIOleIPSite=NULL;
    m_pIOleIPFrame=NULL;
    m_pIOleIPUIWindow=NULL;
    m_pImpIOleIPObject=NULL;
    m_pImpIOleIPActiveObject=NULL;
    m_hMenuShared=NULL;
    m_hOLEMenu=NULL;
    m_pHW=NULL;
    m_fAllowInPlace=TRUE;
    m_fUIActive=FALSE;

    m_fContainerKnowsInsideOut=FALSE;

    //CHAPTER24MOD
    m_pImpISpecifyPP=NULL;
    m_pImpIProvideClassInfo=NULL;
    m_pImpIDispatch=NULL;
    m_pImpIPolylineControl=NULL;
    m_pImpIOleControl=NULL;

    m_pITypeLib=NULL;
    m_pIOleControlSite=NULL;
    m_pIDispatchAmbients=NULL;
    m_fFreezeEvents=FALSE;

    m_fHatch=TRUE;
    m_fUIDead=FALSE;
    //End CHAPTER24MOD

    return;
    }


CPolyline::~CPolyline(void)
    {
    LPUNKNOWN       pIUnknown=this;

    if (NULL!=m_pUnkOuter)
        pIUnknown=m_pUnkOuter;

    if (NULL!=m_pST)
        delete m_pST;

    if (NULL!=m_hDlg)
        DestroyWindow(m_hDlg);

    /*
     * In aggregation, release cached pointers but
     * AddRef the controlling unknown first.  The 
     * extra reference count protects from reentrancy.
     */

    m_cRef++;

    pIUnknown->AddRef();
    pIUnknown->AddRef();
    pIUnknown->AddRef();

    ReleaseInterface(m_pDefIViewObject);
    ReleaseInterface(m_pDefIDataObject);
    ReleaseInterface(m_pDefIPersistStorage);

    m_cRef--;

    //Cached pointer rules do not apply to IUnknown
    ReleaseInterface(m_pDefIUnknown);

    ReleaseInterface(m_pIAdviseSink);
    ReleaseInterface(m_pIOleClientSite);
    ReleaseInterface(m_pIOleAdviseHolder);

    DeleteInterfaceImp(m_pImpIOleObject);
    DeleteInterfaceImp(m_pImpIViewObject);
    DeleteInterfaceImp(m_pImpIRunnableObject);

    //Other in-place interfaces released in deactivation.
    DeleteInterfaceImp(m_pImpIOleIPObject);
    DeleteInterfaceImp(m_pImpIOleIPActiveObject);

    //CHAPTER24MOD
    ReleaseInterface(m_pIDispatchAmbients);
    ReleaseInterface(m_pIOleControlSite);
    ReleaseInterface(m_pITypeLib);

    DeleteInterfaceImp(m_pImpISpecifyPP);
    DeleteInterfaceImp(m_pImpIProvideClassInfo);
    DeleteInterfaceImp(m_pImpIDispatch);
    DeleteInterfaceImp(m_pImpIPolylineControl);
    DeleteInterfaceImp(m_pImpIOleControl);
    //End CHAPTER24MOD

    //Anything we might have registered in IRunnableObject::Run
    INOLE_RevokeAsRunning(&m_dwRegROT);

    DeleteInterfaceImp(m_pImpIExternalConnection);
    ReleaseInterface(m_pIDataAdviseHolder);
    DeleteInterfaceImp(m_pImpIDataObject);

    DeleteInterfaceImp(m_pImpIPersistStreamInit);
    DeleteInterfaceImp(m_pImpIPersistStorage);
    ReleaseInterface(m_pIStream);
    ReleaseInterface(m_pIStorage);

    DeleteInterfaceImp(m_pImpIConnPtCont);
    DeleteInterfaceImp(m_pImpIPolyline);

    ReleaseInterface(m_pAdv);
    ReleaseInterface(m_pConnPt);

    return;
    }




/*
 * CPolyline::Init
 *
 * Purpose:
 *  Performs any intiailization of a CPolyline that's prone to
 *  failure that we also use internally before exposing the
 *  object outside this DLL.
 *
 * Parameters:
 *  None
 *
 * Return Value:
 *  BOOL            TRUE if the function is successful,
 *                  FALSE otherwise.
 */

BOOL CPolyline::Init(void)
    {
    LPUNKNOWN       pIUnknown=this;
    HRESULT         hr;

    if (NULL!=m_pUnkOuter)
        pIUnknown=m_pUnkOuter;

    m_pST=new CStringTable(m_hInst);

    if (!m_pST->Init(IDS_POLYLINEMIN, IDS_POLYLINEMAX))
        return FALSE;

    m_cf=RegisterClipboardFormat(SZPOLYLINECLIPFORMAT);

    m_pImpIPersistStorage=new CImpIPersistStorage(this, pIUnknown);

    if (NULL==m_pImpIPersistStorage)
        return FALSE;

    m_pImpIPersistStreamInit=new CImpIPersistStreamInit(this
        , pIUnknown);

    if (NULL==m_pImpIPersistStreamInit)
        return FALSE;

    m_pImpIPolyline=new CImpIPolyline(this, pIUnknown);

    if (NULL==m_pImpIPolyline)
        return FALSE;

    m_pImpIConnPtCont=new CImpIConnPtCont(this, pIUnknown);

    if (NULL==m_pImpIConnPtCont)
        return FALSE;

    m_pConnPt=new CConnectionPoint(this);

    if (NULL==m_pConnPt)
        return FALSE;

    m_pConnPt->AddRef();    //Reversed in destructor

    m_pImpIDataObject=new CImpIDataObject(this, pIUnknown);

    if (NULL==m_pImpIDataObject)
        return FALSE;

    m_pImpIOleObject=new CImpIOleObject(this, pIUnknown);

    if (NULL==m_pImpIOleObject)
        return FALSE;

    m_pImpIViewObject=new CImpIViewObject(this, pIUnknown);

    if (NULL==m_pImpIViewObject)
        return FALSE;

    m_pImpIRunnableObject=new CImpIRunnableObject(this, pIUnknown);

    if (NULL==m_pImpIRunnableObject)
        return FALSE;

    m_pImpIExternalConnection=new CImpIExternalConnection(this
        , pIUnknown);

    if (NULL==m_pImpIExternalConnection)
        return FALSE;

    m_pImpIOleIPObject=new CImpIOleInPlaceObject(this, pIUnknown);

    if (NULL==m_pImpIOleIPObject)
        return FALSE;

    m_pImpIOleIPActiveObject=new CImpIOleInPlaceActiveObject(this
        , pIUnknown);

    if (NULL==m_pImpIOleIPActiveObject)
        return FALSE;

    //CHAPTER24MOD
    m_pImpISpecifyPP=new CImpISpecifyPP(this, pIUnknown);

    if (NULL==m_pImpISpecifyPP)
        return FALSE;

    m_pImpIProvideClassInfo=new CImpIProvideClassInfo(this, pIUnknown);

    if (NULL==m_pImpIProvideClassInfo)
        return FALSE;

    m_pImpIDispatch=new CImpIDispatch(this, pIUnknown);

    if (NULL==m_pImpIDispatch)
        return FALSE;

    m_pImpIPolylineControl=new CImpIPolylineControl(this, pIUnknown);

    if (NULL==m_pImpIPolylineControl)
        return FALSE;

    m_pImpIOleControl=new CImpIOleControl(this, pIUnknown);

    if (NULL==m_pImpIOleControl)
        return FALSE;
    //End CHAPTER24MOD

    /*
     * We're sitting at ref count 0 and the next call will AddRef a
     * few times and Release a few times.  This insures we don't
     * delete ourselves prematurely.
     */
    m_cRef++;

    //Aggregate OLE's cache for IOleCache* interfaces.
    hr=CreateDataCache(pIUnknown, CLSID_Polyline19
        , IID_IUnknown, (PPVOID)&m_pDefIUnknown);

    if (FAILED(hr))
        return FALSE;

    /*
     * NOTE:  The spec specifically states that any interfaces
     * besides IUnknown that we obtain on an aggregated object
     * should be Released immediately after we QueryInterface for
     * them because the QueryInterface will AddRef us, and since
     * we would not release these interfaces until we were
     * destroyed, we'd never go away because we'd never get a zero
     * ref count.
     */

    //Now try to get other interfaces to which we delegate
    hr=m_pDefIUnknown->QueryInterface(IID_IViewObject2
        , (PPVOID)&m_pDefIViewObject);

    if (FAILED(hr))
        return FALSE;

    pIUnknown->Release();

    hr=m_pDefIUnknown->QueryInterface(IID_IDataObject
        , (PPVOID)&m_pDefIDataObject);

    if (FAILED(hr))
        return FALSE;

    pIUnknown->Release();

    hr=m_pDefIUnknown->QueryInterface(IID_IPersistStorage
        , (PPVOID)&m_pDefIPersistStorage);

    if (FAILED(hr))
        return FALSE;

    pIUnknown->Release();

    m_cRef--;
    m_pImpIPolyline->New();

    //CHAPTER24MOD
    /*
     * Go load our own type information and save its ITypeLib
     * pointer that will be used be CImpIDispatch and
     * CImpIProvideClassInfo.
     */

    hr=LoadRegTypeLib(LIBID_PolylineTypeLibrary, 1, 0
        , LANG_NEUTRAL, &m_pITypeLib);

    if (FAILED(hr))
        hr=LoadTypeLib(OLETEXT("POLYLINE.TLB"), &m_pITypeLib);

    if (FAILED(hr))
        return FALSE;

    //Set up our CONTROLINFO structure (we have two mnemonics)
    m_ctrlInfo.cb=sizeof(CONTROLINFO);
    m_ctrlInfo.dwFlags=0;
    m_ctrlInfo.hAccel=NULL;
    m_ctrlInfo.cAccel=0;

    /*
     * Note:  we cannot initialize ambients until we get
     * a container interface pointer in IOleObject::SetClientSite.
     */
    //End CHAPTER24MOD

    return TRUE;
    }







/*
 * CPolyline::QueryInterface
 * CPolyline::AddRef
 * CPolyline::Release
 *
 * Purpose:
 *  IUnknown members for CPolyline object.
 */

STDMETHODIMP CPolyline::QueryInterface(REFIID riid, PPVOID ppv)
    {
    *ppv=NULL;

    if (IID_IUnknown==riid)
        *ppv=this;

    if (IID_IConnectionPointContainer==riid)
        *ppv=m_pImpIConnPtCont;

    if (IID_IPolyline10==riid)
        *ppv=m_pImpIPolyline;

    if (IID_IPersistStorage==riid)
        *ppv=m_pImpIPersistStorage;

    if (IID_IPersist==riid || IID_IPersistStream==riid
        || IID_IPersistStreamInit==riid)
        *ppv=m_pImpIPersistStreamInit;

    if (IID_IDataObject==riid)
        *ppv=m_pImpIDataObject;

    if (IID_IOleObject==riid)
        *ppv=m_pImpIOleObject;

    if (IID_IViewObject==riid || IID_IViewObject2==riid)
        *ppv=m_pImpIViewObject;

    if (IID_IRunnableObject==riid)
        *ppv=m_pImpIRunnableObject;

    if (IID_IExternalConnection==riid)
        *ppv=m_pImpIExternalConnection;

    //IOleWindow will be the InPlaceObject
    if (IID_IOleWindow==riid || IID_IOleInPlaceObject==riid)
        *ppv=m_pImpIOleIPObject;

    //CHAPTER24MOD
    if (IID_ISpecifyPropertyPages==riid)
        *ppv=m_pImpISpecifyPP;

    if (IID_IProvideClassInfo==riid)
        *ppv=m_pImpIProvideClassInfo;