fpicker/source/win32/filepicker/comptr.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: comptr.hxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef COMPTR_HXX
  32 #define COMPTR_HXX
  33
  34 #include <sal/types.h>
  35 #include <osl/diagnose.h>
  36 #include <shobjidl.h>
  37
  38 template< class    T_INTERFACE          ,
  39           REFIID   P_IID   = IID_NULL   ,
  40           REFCLSID P_CLSID = CLSID_NULL >
  41 class ComPtr
  42 {
  43     public:
  44
  45         //---------------------------------------------------------------------
  46         /** initialize com ptr with null.
  47          */
  48         ComPtr()
  49         {
  50             m_pInterface = NULL;
  51         }
  52
  53         //---------------------------------------------------------------------
  54         /** initialize com ptr with given interface.
  55          */
  56         ComPtr(T_INTERFACE* pInterface)
  57         {
  58             m_pInterface = pInterface;
  59             if (m_pInterface)
  60                 m_pInterface->AddRef();
  61         }
  62
  63         //---------------------------------------------------------------------
  64         /** copy ctor.
  65          */
  66         ComPtr(const ComPtr< T_INTERFACE, P_IID, P_CLSID >& aCopy)
  67         {
  68             m_pInterface = aCopy.m_pInterface;
  69             if (m_pInterface)
  70                 m_pInterface->AddRef();
  71         }
  72
  73         //---------------------------------------------------------------------
  74         /** initialize object by quering external object for the right interface.
  75          */
  76         ComPtr(IUnknown* pIUnknown)
  77         {
  78             if (pIUnknown)
  79                 pIUnknown->QueryInterface(P_IID, (void**)&m_pInterface);
  80         }
  81
  82         //---------------------------------------------------------------------
  83         /** deinitialize com object right.
  84          */
  85         ~ComPtr()
  86         {
  87             release();
  88         }
  89
  90     public:
  91
  92         //---------------------------------------------------------------------
  93         HRESULT create()
  94         {
  95             return CoCreateInstance(P_CLSID, NULL, CLSCTX_ALL, P_IID, (void**)&m_pInterface);
  96         }
  97
  98         //---------------------------------------------------------------------
  99         operator T_INTERFACE*() const
 100         {
 101             return m_pInterface;
 102         }
 103
 104         //---------------------------------------------------------------------
 105         T_INTERFACE& operator*() const
 106         {
 107             return *m_pInterface;
 108         }
 109
 110         //---------------------------------------------------------------------
 111         T_INTERFACE** operator&()
 112         {
 113             return &m_pInterface;
 114         }
 115
 116         //---------------------------------------------------------------------
 117         T_INTERFACE* operator->() const
 118         {
 119             return m_pInterface;
 120         }
 121
 122         //---------------------------------------------------------------------
 123         T_INTERFACE* operator=(T_INTERFACE* pInterface)
 124         {
 125             if ( equals(pInterface) )
 126                 return m_pInterface;
 127
 128             m_pInterface->Release();
 129             m_pInterface = pInterface;
 130             if (m_pInterface)
 131                 m_pInterface->AddRef();
 132
 133             return m_pInterface;
 134         }
 135
 136         //---------------------------------------------------------------------
 137         T_INTERFACE* operator=(IUnknown* pIUnknown)
 138         {
 139             if (pIUnknown)
 140                 pIUnknown->QueryInterface(P_IID, (void**)&m_pInterface);
 141             return m_pInterface;
 142         }
 143
 144         //---------------------------------------------------------------------
 145         T_INTERFACE* operator=(const ComPtr< T_INTERFACE, P_IID, P_CLSID >& aCopy)
 146         {
 147             m_pInterface = aCopy.m_pInterface;
 148             if (m_pInterface)
 149                 m_pInterface->AddRef();
 150
 151             return m_pInterface;
 152         }
 153
 154         //---------------------------------------------------------------------
 155         T_INTERFACE* get() const
 156         {
 157             return m_pInterface;
 158         }
 159
 160         //---------------------------------------------------------------------
 161         void attach(T_INTERFACE* pInterface)
 162         {
 163             if (pInterface)
 164             {
 165                 m_pInterface->Release();
 166                 m_pInterface = pInterface;
 167             }
 168         }
 169
 170         //---------------------------------------------------------------------
 171         T_INTERFACE* detach()
 172         {
 173             T_INTERFACE* pInterface = m_pInterface;
 174             m_pInterface = NULL;
 175             return pInterface;
 176         }
 177
 178         //---------------------------------------------------------------------
 179         void release()
 180         {
 181             if (m_pInterface)
 182             {
 183                 m_pInterface->Release();
 184                 m_pInterface = NULL;
 185             }
 186         }
 187
 188 #ifndef __MINGW32__
 189         //---------------------------------------------------------------------
 190         template< class T_QUERYINTERFACE >
 191         HRESULT query(T_QUERYINTERFACE** pQuery)
 192         {
 193             return m_pInterface->QueryInterface(__uuidof(T_QUERYINTERFACE), (void**)pQuery);
 194         }
 195 #endif
 196
 197         //---------------------------------------------------------------------
 198         ::sal_Bool equals(IUnknown* pCheck)
 199         {
 200             if (
 201                 ( ! m_pInterface ) &&
 202                 ( ! pCheck       )
 203                )
 204                 return sal_True;
 205
 206             IUnknown* pCurrent = NULL;
 207             m_pInterface->QueryInterface(IID_IUnknown, (void**)&pCurrent);
 208
 209             ::sal_Bool bEquals = (pCheck == pCurrent);
 210             pCurrent->Release();
 211
 212             return bEquals;
 213         }
 214
 215         //---------------------------------------------------------------------
 216         ::sal_Bool is()
 217         {
 218             return (m_pInterface != 0);
 219         }
 220
 221     private:
 222         T_INTERFACE* m_pInterface;
 223 };
 224
 225 #endif