DBEEPER.CPP

/* 
 * DBEEPER.CPP 
 * Beeper Automation Object Chapter 14 
 * 
 * Server module code for the Beeper object. 
 * 
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Microsoft 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#define INITGUIDS 
#include "dbeeper.h" 
 
 
//Count number of objects and number of locks. 
ULONG       g_cObj=0; 
ULONG       g_cLock=0; 
HINSTANCE   g_hInst=NULL;   //For LoadString 
 
#ifdef WIN32 
DWORD       g_dwTLS;        //For thread-local storage 
#endif 
 
/* 
 * LibMain(32) 
 * 
 * Purpose: 
 *  Entry point conditionally compiled for Win32 and Windows 
 *  3.1.  Provides the proper structure for each environment. 
 */ 
 
#ifdef WIN32 
BOOL WINAPI LibMain32(HINSTANCE hInstance, ULONG ulReason 
    , LPVOID pvReserved) 
    { 
    g_hInst=hInstance; 
 
    if (DLL_PROCESS_DETACH==ulReason) 
        { 
        TlsFree(g_dwTLS); 
        return TRUE; 
        } 
    else 
        { 
        if (DLL_PROCESS_ATTACH!=ulReason) 
            return TRUE; 
 
        g_dwTLS=TlsAlloc(); 
        } 
 
    return TRUE; 
    } 
#else 
int PASCAL LibMain(HINSTANCE hInstance, WORD wDataSeg 
    , WORD cbHeapSize, LPSTR lpCmdLine) 
    { 
    if (0!=cbHeapSize) 
        UnlockData(0); 
 
    g_hInst=hInstance; 
    return (int)hInstance; 
    } 
#endif 
 
 
 
/* 
 * DllGetClassObject 
 * DllCanUnloadNow 
 * Standard COM exports for DLL servers. 
 */ 
 
HRESULT APIENTRY DllGetClassObject(REFCLSID rclsid, REFIID riid 
    , PPVOID ppv) 
    { 
    CBeeperFactory *pBF; 
    HRESULT         hr; 
 
    if (CLSID_Beeper!=rclsid) 
        return ResultFromScode(E_FAIL); 
 
    //Check that we can provide the interface 
    if (IID_IUnknown!=riid && IID_IClassFactory!=riid) 
        return ResultFromScode(E_NOINTERFACE); 
 
    //Return our beeper factory's IClassFactory 
    pBF=new CBeeperFactory(); 
 
    if (NULL==pBF) 
        return ResultFromScode(E_OUTOFMEMORY); 
 
    //If the factory hasn't the interface, delete it 
    hr=pBF->QueryInterface(riid, ppv); 
 
    if (FAILED(hr)) 
        delete pBF; 
    else 
        g_cObj++; 
 
    return hr; 
    } 
 
 
STDAPI DllCanUnloadNow(void) 
    { 
    SCODE   sc; 
 
    //Our answer is whether there are any object or locks 
    sc=(0L==g_cObj && 0L==g_cLock) ? S_OK : S_FALSE; 
    return ResultFromScode(sc); 
    } 
 
 
 
/* 
 * ObjectDestroyed 
 * 
 * Purpose: 
 *  Function for the object to call when it gets destroyed.  Since 
 *  we're in a DLL we only track the number of objects here, letting 
 *  DllCanUnloadNow take care of the rest. 
 */ 
 
void ObjectDestroyed(void) 
    { 
    g_cObj--; 
    return; 
    } 
 
 
 
/* 
 * CBeeperFactory::CBeeperFactory 
 * CBeeperFactory::~CBeeperFactory 
 */ 
 
CBeeperFactory::CBeeperFactory(void) 
    { 
    m_cRef=0L; 
    return; 
    } 
 
 
CBeeperFactory::~CBeeperFactory(void) 
    { 
    return; 
    } 
 
 
 
 
 
 
/* 
 * CBeeperFactory::QueryInterface 
 * CBeeperFactory::AddRef 
 * CBeeperFactory::Release 
 */ 
 
STDMETHODIMP CBeeperFactory::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 ResultFromScode(E_NOINTERFACE); 
    } 
 
 
STDMETHODIMP_(ULONG) CBeeperFactory::AddRef(void) 
    { 
    return ++m_cRef; 
    } 
 
 
STDMETHODIMP_(ULONG) CBeeperFactory::Release(void) 
    { 
    if (0!=--m_cRef) 
        return m_cRef; 
 
    delete this; 
    ObjectDestroyed(); 
    return 0; 
    } 
 
 
 
/* 
 * CBeeperFactory::CreateInstance 
 * CBeeperFactory::LockServer 
 */ 
 
STDMETHODIMP CBeeperFactory::CreateInstance(LPUNKNOWN pUnkOuter 
    , REFIID riid, PPVOID ppvObj) 
    { 
    PCBeeper            pObj; 
    HRESULT             hr; 
 
    *ppvObj=NULL; 
    hr=ResultFromScode(E_OUTOFMEMORY); 
 
    //Verify that a controlling unknown asks for IUnknown 
    if (NULL!=pUnkOuter && IID_IUnknown!=riid) 
        return ResultFromScode(CLASS_E_NOAGGREGATION); 
 
    //Create the object passing function to notify on destruction. 
    pObj=new CBeeper(pUnkOuter, ObjectDestroyed); 
 
    if (NULL==pObj) 
        return hr; 
 
    if (pObj->Init()) 
        hr=pObj->QueryInterface(riid, ppvObj); 
 
    //Kill the object if initial creation or Init failed. 
    if (FAILED(hr)) 
        delete pObj; 
    else 
        g_cObj++; 
 
    return hr; 
    } 
 
 
STDMETHODIMP CBeeperFactory::LockServer(BOOL fLock) 
    { 
    if (fLock) 
        g_cLock++; 
    else 
        g_cLock--; 
 
    return NOERROR; 
    }