Windows编程

开发平台：
Visual C++

UTIL.H：源码内容
							/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
    Util.h
Abstract:
    Definition of Utilities for use
Author:
Environment:
    User mode
Revision History :
--*/
#ifndef _UTIL_H_
#define _UTIL_H_
#include "formtrck.h"
//+---------------------------------------------------------------------
//
//   Generally useful #defines and inline functions for OLE2.
//
//------------------------------------------------------------------------
// These are the major and minor version returned by OleBuildVersion
#define OLE_MAJ_VER 0x0003
#define OLE_MIN_VER 0x003A
//---------------------------------------------------------------
//  SCODE and HRESULT macros
//---------------------------------------------------------------
#define OK(r)       (SUCCEEDED(r))
#define NOTOK(r)    (FAILED(r))
//---------------------------------------------------------------
//  IUnknown
//---------------------------------------------------------------
#define InterlockedIncrement(plong) (++(*(plong)))
#define InterlockedDecrement(plong) (--(*(plong)))
#define ADsIncrement(__ul) InterlockedIncrement((long *) &__ul)
#define ADsDecrement(__ul) InterlockedDecrement((long *) &__ul)
#define DECLARE_ADs_IUNKNOWN_METHODS                              
    STDMETHOD(QueryInterface) (REFIID riid, LPVOID * ppv);          
    STDMETHOD_(ULONG, AddRef) (void);                               
    STDMETHOD_(ULONG, Release) (void);
#define DECLARE_ADs_STANDARD_IUNKNOWN(cls)                        
    STDMETHOD(QueryInterface) (REFIID riid, LPVOID * ppv);          
    ULONG _ulRefs;                                                  
    STDMETHOD_(ULONG, AddRef) (void)                                
        {                                                           
            ADsIncrement(_ulRefs);                                
            return _ulRefs;                                         
        }                                                           
    STDMETHOD_(ULONG, Release) (void)                               
        {                                                           
            if (!ADsDecrement(_ulRefs))                           
            {                                                       
                ADsIncrement(_ulRefs);                            
                delete this;                                        
                return 0;                                           
            }                                                       
            return _ulRefs;                                         
        }
#define DECLARE_ADs_DELEGATING_IUNKNOWN(cls)                      
    IUnknown * _pUnkOuter;                                          
    STDMETHOD(QueryInterface) (REFIID iid, LPVOID * ppv)            
        { return _pUnkOuter->QueryInterface(iid, ppv); }            
    STDMETHOD_(ULONG, AddRef) (void)                                
        { return _pUnkOuter->AddRef(); }                            
    STDMETHOD_(ULONG, Release) (void)                               
        { return _pUnkOuter->Release(); }
#if DBG == 0
//
// Retail versions of these macros
//
#define DECLARE_ADs_PRIVATE_IUNKNOWN(cls)                         
    class PrivateUnknown : public IUnknown                          
    {                                                               
    private:                                                        
        ULONG   _ulRefs;                                            
        cls *   My##cls(void)                                       
            { return CONTAINING_RECORD(this, cls, _PrivUnk); }      
                                                                    
    public:                                                         
        PrivateUnknown(void)                                        
            { _ulRefs = 1; }                                        
                                                                    
        DECLARE_ADs_IUNKNOWN_METHODS                              
    };                                                              
    friend class PrivateUnknown;                                    
    PrivateUnknown _PrivUnk;
#define IMPLEMENT_ADs_PRIVATE_IUNKNOWN(cls)                       
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::AddRef( )             
    {                                                               
        ADsIncrement(_ulRefs);                                    
        return _ulRefs;                                             
    }                                                               
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::Release( )            
    {                                                               
        if (!ADsDecrement(_ulRefs))                               
        {                                                           
            ADsIncrement(_ulRefs);                                
            delete My##cls();                                       
            return 0;                                               
        }                                                           
        return _ulRefs;                                             
    }
#define DECLARE_ADs_COMPOUND_IUNKNOWN(cls)                        
    class PrivateUnknown : public IUnknown                          
    {                                                               
        friend class cls;                                           
                                                                    
    public:                                                         
        PrivateUnknown(void)                                        
            { _ulRefs = 1; _ulAllRefs = 1; }                        
                                                                    
        DECLARE_ADs_IUNKNOWN_METHODS                              
                                                                    
    private:                                                        
        ULONG   _ulRefs;                                            
        ULONG   _ulAllRefs;                                         
                                                                    
        cls *   My##cls(void)                                       
            { return CONTAINING_RECORD(this, cls, _PrivUnk); }      
    };                                                              
    friend class PrivateUnknown;                                    
    PrivateUnknown _PrivUnk;                                        
                                                                    
    ULONG   SubAddRef(void);                                        
    ULONG   SubRelease(void);
#define IMPLEMENT_ADs_COMPOUND_IUNKNOWN(cls)                      
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::AddRef( )             
    {                                                               
        ADsIncrement(_ulAllRefs);                                 
        ADsIncrement(_ulRefs);                                    
        return _ulRefs;                                             
    }                                                               
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::Release( )            
    {                                                               
        if (!ADsDecrement(_ulRefs))                               
        {                                                           
            My##cls()->Passivate();                                 
        }                                                           
        if (!ADsDecrement(_ulAllRefs))                            
        {                                                           
            ADsIncrement(_ulAllRefs);                             
            delete My##cls();                                       
            return 0;                                               
        }                                                           
        return _ulRefs;                                             
    }                                                               
    ULONG cls::SubAddRef( )                                         
    {                                                               
        return ADsIncrement(_PrivUnk._ulAllRefs);                 
    }                                                               
    ULONG cls::SubRelease( )                                        
    {                                                               
        ULONG ul;                                                   
                                                                    
        ul = ADsDecrement(_PrivUnk._ulAllRefs);                   
        if (!ul)                                                    
        {                                                           
            ADsIncrement(_PrivUnk._ulAllRefs);                    
            delete this;                                            
        }                                                           
                                                                    
        return ul;                                                  
    }
#else  // DBG == 0
//
// Debug versions of these macros
//
#define DECLARE_ADs_PRIVATE_IUNKNOWN(cls)                         
    class PrivateUnknown : protected ObjectTracker,                 
                           public IUnknown                          
    {                                                               
    private:                                                        
        cls *   My##cls(void)                                       
            { return CONTAINING_RECORD(this, cls, _PrivUnk); }      
                                                                    
    public:                                                         
        PrivateUnknown(void)                                        
            { _ulRefs = 1; TrackClassName(#cls); }                  
                                                                    
        DECLARE_ADs_IUNKNOWN_METHODS                              
    };                                                              
    friend class PrivateUnknown;                                    
    PrivateUnknown _PrivUnk;
#define IMPLEMENT_ADs_PRIVATE_IUNKNOWN(cls)                       
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::AddRef( )             
    {                                                               
        StdAddRef();                                                
        return _ulRefs;                                             
    }                                                               
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::Release( )            
    {                                                               
        if (!StdRelease())                                          
        {                                                           
            ADsIncrement(_ulRefs);                                
            delete My##cls();                                       
            return 0;                                               
        }                                                           
        return _ulRefs;                                             
    }
#define DECLARE_ADs_COMPOUND_IUNKNOWN(cls)                        
    class PrivateUnknown : protected ObjectTracker,                 
                           public IUnknown                          
    {                                                               
        friend class cls;                                           
                                                                    
    public:                                                         
        PrivateUnknown(void)                                        
            { _ulNRefs = 1; _ulRefs = 1; TrackClassName(#cls); }    
                                                                    
        DECLARE_ADs_IUNKNOWN_METHODS                              
                                                                    
    private:                                                        
        ULONG   _ulNRefs;                                           
                                                                    
        cls *   My##cls(void)                                       
            { return CONTAINING_RECORD(this, cls, _PrivUnk); }      
    };                                                              
    friend class PrivateUnknown;                                    
    PrivateUnknown _PrivUnk;                                        
                                                                    
    ULONG   SubAddRef(void);                                        
    ULONG   SubRelease(void);
#define IMPLEMENT_ADs_COMPOUND_IUNKNOWN(cls)                      
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::AddRef( )             
    {                                                               
        StdAddRef();                                                
        ADsIncrement(_ulNRefs);                                   
        return _ulNRefs;                                            
    }                                                               
    STDMETHODIMP_(ULONG) cls::PrivateUnknown::Release( )            
    {                                                               
        if (!ADsDecrement(_ulNRefs))                              
        {                                                           
            My##cls()->Passivate();                                 
        }                                                           
        if (!StdRelease())                                          
        {                                                           
            ADsIncrement(_ulRefs);                                
            delete My##cls();                                       
            return 0;                                               
        }                                                           
        return _ulNRefs;                                            
    }                                                               
    ULONG cls::SubAddRef( )                                         
    {                                                               
        return _PrivUnk.StdAddRef();                                
    }                                                               
    ULONG cls::SubRelease( )                                        
    {                                                               
        ULONG ul;                                                   
                                                                    
        ul = _PrivUnk.StdRelease();                                 
        if (!ul)                                                    
        {                                                           
            ADsIncrement(_PrivUnk._ulRefs);                       
            delete this;                                            
        }                                                           
                                                                    
        return ul;                                                  
    }
#endif // DBG == 0
#define DECLARE_ADs_SUBOBJECT_IUNKNOWN(cls, parent_cls, member)   
    DECLARE_ADs_IUNKNOWN_METHODS                                  
    parent_cls * My##parent_cls(void);                              
    void Detach(void)                                               
        { ; }
#define IMPLEMENT_ADs_SUBOBJECT_IUNKNOWN(cls, parent_cls, member) 
    inline parent_cls * cls::My##parent_cls(void)                   
    {                                                               
        return CONTAINING_RECORD(this, parent_cls, member);         
    }                                                               
    STDMETHODIMP_(ULONG) cls::AddRef( )                             
        { return My##parent_cls()->SubAddRef(); }                   
    STDMETHODIMP_(ULONG) cls::Release( )                            
        { return My##parent_cls()->SubRelease(); }
//+------------------------------------------------------------------------
//
//  NO_COPY *declares* the constructors and assignment operator for copying.
//  By not *defining* these functions, you can prevent your class from
//  accidentally being copied or assigned -- you will be notified by
//  a linkage error.
//
//-------------------------------------------------------------------------
#define NO_COPY(cls)    
    cls(const cls&);    
    cls& operator=(const cls&);
//+---------------------------------------------------------------------
//
//  Miscellaneous useful OLE helper and debugging functions
//
//----------------------------------------------------------------------
//
//  Some convenient OLE-related definitions and declarations
//
typedef  unsigned short far * LPUSHORT;
#define OLEMISC_STREAMABLE 1024
IsCompatibleOleVersion(WORD wMaj, WORD wMin);
//#if DBG == 1
#if 0
STDAPI  CheckAndReturnResult(
                HRESULT hr,
                LPSTR   lpstrFile,
                UINT    line,
                int     cSuccess,
                ...);
STDAPI_(void)   CheckResult(HRESULT hr, LPSTR lpstrFile, UINT line);
STDAPI_(void)   PrintIID(DWORD dwFlags, REFIID riid);
STDAPI          PrintHRESULT(DWORD dwFlags, HRESULT hr);
#define SRETURN(hr) 
    return CheckAndReturnResult((hr), __FILE__, __LINE__, -1)
#define RRETURN(hr) 
    return CheckAndReturnResult((hr), __FILE__, __LINE__, 0)
#define RRETURN1(hr, s1) 
    return CheckAndReturnResult((hr), __FILE__, __LINE__, 1, (s1))
#define RRETURN2(hr, s1, s2) 
    return CheckAndReturnResult((hr), __FILE__, __LINE__, 2, (s1), (s2))
#define RRETURN3(hr, s1, s2, s3) 
    return CheckAndReturnResult((hr), __FILE__, __LINE__, 3, (s1), (s2), (s3))
#define WARN_ERROR(hr)  CheckResult((hr), __FILE__, __LINE__)
#define TRETURN(hr)         return PrintHRESULT(DEB_TRACE, (hr))
#define TRACEIID(iid)       PrintIID(DEB_TRACE, iid)
#define TRACEHRESULT(hr)    PrintHRESULT(DEB_TRACE, (hr))
#else   // DBG == 0
#define SRETURN(hr)                 return (hr)
#define RRETURN(hr)                 return (hr)
#define RRETURN1(hr, s1)            return (hr)
#define RRETURN2(hr, s1, s2)        return (hr)
#define RRETURN3(hr, s1, s2, s3)    return (hr)
#define WARN_ERROR(hr)
#define TRETURN(hr)     return (hr)
#define TRACEIID(iid)
#define TRACEHRESULT(hr)
#endif  // DBG
//+---------------------------------------------------------------------
//
//  Interface wrapper for tracing method invocations
//
//----------------------------------------------------------------------
#if DBG == 1
LPVOID WatchInterface(REFIID riid, LPVOID pv, LPWSTR lpstr);
#define WATCHINTERFACE(iid, p, lpstr)  WatchInterface(iid, p, lpstr)
#else   // DBG == 0
#define WATCHINTERFACE(iid, p, lpstr)  (p)
#endif  // DBG
//+---------------------------------------------------------------------
//
//  Standard IClassFactory implementation
//
//----------------------------------------------------------------------
//+---------------------------------------------------------------
//
//  Class:      StdClassFactory
//
//  Purpose:    Standard implementation of a class factory object
//
//  Notes:          **************!!!!!!!!!!!!!!!!!*************
//              TAKE NOTE --- The implementation of Release on this
//              class does not perform a delete.  This is so you can
//              make the class factory a global static variable.
//              Use the CDynamicCF class below for an object
//              which is not global static data.
//
//              ALSO - The refcount is initialized to 0, NOT 1!
//
//---------------------------------------------------------------
class StdClassFactory: public IClassFactory
{
public:
    StdClassFactory(void) : _ulRefs(1) {};
    // IUnknown methods
    DECLARE_ADs_IUNKNOWN_METHODS;
    // IClassFactory methods
    STDMETHOD(LockServer) (BOOL fLock);
    // CreateInstance is left pure virtual.
protected:
    ULONG _ulRefs;
};
//+---------------------------------------------------------------------------
//
//  Class:      CDynamicCF (DYNCF)
//
//  Purpose:    Class factory which exists on the heap, and whose Release
//              method does the normal thing.
//
//  Interface:  DECLARE_ADs_STANDARD_IUNKNOWN -- IUnknown methods
//
//              LockServer             -- Per IClassFactory.
//              CDynamicCF             -- ctor.
//              ~CDynamicCF            -- dtor.
//
//  History:    6-22-94   adams   Created
//              7-13-94   adams   Moved from ADsincdyncf.hxx
//
//----------------------------------------------------------------------------
class CDynamicCF: public IClassFactory
{
public:
    // IUnknown methods
    DECLARE_ADs_STANDARD_IUNKNOWN(CDynamicCF)
    // IClassFactory methods
    STDMETHOD(LockServer) (BOOL fLock);
protected:
            CDynamicCF(void);
    virtual ~CDynamicCF(void);
};
#endif //__UTILS_H_

						