ICLASSF.CPP

/* 
 * ICLASSF.CPP 
 * Cosmo Chapter 14 
 * 
 * Implementation of an IClassFactory interface for Cosmo. 
 * 
 * Copyright (c)1993-1997 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Software Design Engineer 
 * Microsoft Systems Developer Relations 
 * 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#include "cosmo.h" 
 
 
 
/* 
 * CFigureClassFactory::CFigureClassFactory 
 * CFigureClassFactory::~CFigureClassFactory 
 * 
 * Constructor Parameters: 
 *  pFR             PCCosmoFrame that can create documents. 
 */ 
 
CFigureClassFactory::CFigureClassFactory(PCCosmoFrame pFR) 
    { 
    m_cRef=0L; 
    m_pFR=pFR; 
    m_fCreated=FALSE; 
    return; 
    } 
 
 
CFigureClassFactory::~CFigureClassFactory(void) 
    { 
    return; 
    } 
 
 
 
 
 
 
/* 
 * CFigureClassFactory::QueryInterface 
 * CFigureClassFactory::AddRef 
 * CFigureClassFactory::Release 
 */ 
 
STDMETHODIMP CFigureClassFactory::QueryInterface(REFIID riid 
    , PPVOID ppv) 
    { 
    *ppv=NULL; 
 
    if (IID_IUnknown==riid || IID_IClassFactory==riid) 
        *ppv=this; 
 
    if (NULL!=*ppv) 
        { 
        ((LPUNKNOWN)*ppv)->AddRef(); 
        return NOERROR; 
        } 
 
    return E_NOINTERFACE; 
    } 
 
 
STDMETHODIMP_(ULONG) CFigureClassFactory::AddRef(void) 
    { 
    return ++m_cRef; 
    } 
 
 
STDMETHODIMP_(ULONG) CFigureClassFactory::Release(void) 
    { 
    ULONG           cRefT; 
 
    cRefT=--m_cRef; 
 
    if (0L==m_cRef) 
        delete this; 
 
    return cRefT; 
    } 
 
 
 
 
 
 
 
/* 
 * CFigureClassFactory::CreateInstance 
 * 
 * Purpose: 
 *  Instantiates a Figure object that supports embedding. 
 * 
 * Parameters: 
 *  pUnkOuter       LPUNKNOWN to the controlling IUnknown if we are 
 *                  being used in an aggregation. 
 *  riid            REFIID identifying the interface the caller 
 *                  desires to have for the new object. 
 *  ppvObj          PPVOID in which to store the desired 
 *                  interface pointer for the new object. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR if successful, otherwise contains 
 *                  E_NOINTERFACE if we cannot support the requested 
 *                  interface. 
 */ 
 
STDMETHODIMP CFigureClassFactory::CreateInstance(LPUNKNOWN pUnkOuter 
    , REFIID riid, PPVOID ppvObj) 
    { 
    PCCosmoDoc          pDoc; 
    HRESULT             hr; 
 
    *ppvObj=NULL; 
 
    //Great idea to protect yourself from multiple creates here. 
    if (m_fCreated) 
        return E_UNEXPECTED; 
 
    m_fCreated=TRUE; 
    hr=E_OUTOFMEMORY; 
 
    //We don't support aggregation 
    if (NULL!=pUnkOuter) 
        return CLASS_E_NOAGGREGATION; 
 
    //Try creating a new document, which creates the object. 
    pDoc=(PCCosmoDoc)m_pFR->m_pCL->NewDocument(TRUE, m_pFR->m_pAdv); 
 
    if (NULL==pDoc) 
        { 
        //This will cause shutdown; object count will go to zero. 
        g_cObj++; 
        ObjectDestroyed(); 
        return hr; 
        } 
 
    //Insure the document is untitled; get the requested interface. 
    pDoc->ULoad(TRUE, NULL); 
    pDoc->m_pFigure->FrameSet(m_pFR); 
    hr=pDoc->m_pFigure->QueryInterface(riid, ppvObj); 
 
    //Closing the document will destroy the objec, cause shutdown. 
    if (FAILED(hr)) 
        { 
        m_pFR->m_pCL->CloseDocument(pDoc); 
        return hr; 
        } 
 
    return NOERROR; 
    } 
 
 
 
 
 
 
/* 
 * CFigureClassFactory::LockServer 
 * 
 * Purpose: 
 *  Increments or decrements the lock count of the serving 
 *  IClassFactory object.  When the number of locks goes to 
 *  zero and the number of objects is zero, we shut down the 
 *  application. 
 * 
 * Parameters: 
 *  fLock           BOOL specifying whether to increment or 
 *                  decrement the lock count. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR always. 
 */ 
 
STDMETHODIMP CFigureClassFactory::LockServer(BOOL fLock) 
    { 
    if (fLock) 
        g_cLock++; 
    else 
        { 
        g_cLock--; 
 
        /* 
         * To centralize shutdown, we'll artificially increase the 
         * object count here and call ObjectDestroyed, which will 
         * decrement the count, see that there are no objects or 
         * locks, then shut down. 
         */ 
        g_cObj++; 
        ObjectDestroyed(); 
        } 
 
    return NOERROR; 
    }