/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/msw/ole/oleutils.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/msw/ole/oleutils.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (10 years, 10 months ago) by william
File MIME type: text/plain
File size: 10634 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: oleutils.h
3 // Purpose: OLE helper routines, OLE debugging support &c
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 19.02.1998
7 // RCS-ID: $Id: oleutils.h 49804 2007-11-10 01:09:42Z VZ $
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_OLEUTILS_H
13 #define _WX_OLEUTILS_H
14
15 #include "wx/defs.h"
16
17 #if wxUSE_OLE
18
19 // ole2.h includes windows.h, so include wrapwin.h first
20 #include "wx/msw/wrapwin.h"
21 // get IUnknown, REFIID &c
22 #include <ole2.h>
23 #include "wx/intl.h"
24 #include "wx/log.h"
25
26 // ============================================================================
27 // General purpose functions and macros
28 // ============================================================================
29
30 // ----------------------------------------------------------------------------
31 // initialize/cleanup OLE
32 // ----------------------------------------------------------------------------
33
34 // call OleInitialize() or CoInitialize[Ex]() depending on the platform
35 //
36 // return true if ok, false otherwise
37 inline bool wxOleInitialize()
38 {
39 // we need to initialize OLE library
40 #ifdef __WXWINCE__
41 if ( FAILED(::CoInitializeEx(NULL, COINIT_MULTITHREADED)) )
42 #else
43 if ( FAILED(::OleInitialize(NULL)) )
44 #endif
45 {
46 wxLogError(_("Cannot initialize OLE"));
47
48 return false;
49 }
50
51 return true;
52 }
53
54 inline void wxOleUninitialize()
55 {
56 #ifdef __WXWINCE__
57 ::CoUninitialize();
58 #else
59 ::OleUninitialize();
60 #endif
61 }
62
63 // ----------------------------------------------------------------------------
64 // misc helper functions/macros
65 // ----------------------------------------------------------------------------
66
67 // release the interface pointer (if !NULL)
68 inline void ReleaseInterface(IUnknown *pIUnk)
69 {
70 if ( pIUnk != NULL )
71 pIUnk->Release();
72 }
73
74 // release the interface pointer (if !NULL) and make it NULL
75 #define RELEASE_AND_NULL(p) if ( (p) != NULL ) { p->Release(); p = NULL; };
76
77 // return true if the iid is in the array
78 extern bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount);
79
80 // ============================================================================
81 // IUnknown implementation helpers
82 // ============================================================================
83
84 /*
85 The most dumb implementation of IUnknown methods. We don't support
86 aggregation nor containment, but for 99% of cases this simple
87 implementation is quite enough.
88
89 Usage is trivial: here is all you should have
90 1) DECLARE_IUNKNOWN_METHODS in your (IUnknown derived!) class declaration
91 2) BEGIN/END_IID_TABLE with ADD_IID in between for all interfaces you
92 support (at least all for which you intent to return 'this' from QI,
93 i.e. you should derive from IFoo if you have ADD_IID(Foo)) somewhere else
94 3) IMPLEMENT_IUNKNOWN_METHODS somewhere also
95
96 These macros are quite simple: AddRef and Release are trivial and QI does
97 lookup in a static member array of IIDs and returns 'this' if it founds
98 the requested interface in it or E_NOINTERFACE if not.
99 */
100
101 /*
102 wxAutoULong: this class is used for automatically initalising m_cRef to 0
103 */
104 class wxAutoULong
105 {
106 public:
107 wxAutoULong(ULONG value = 0) : m_Value(value) { }
108
109 operator ULONG&() { return m_Value; }
110 ULONG& operator=(ULONG value) { m_Value = value; return m_Value; }
111
112 wxAutoULong& operator++() { ++m_Value; return *this; }
113 const wxAutoULong operator++( int ) { wxAutoULong temp = *this; ++m_Value; return temp; }
114
115 wxAutoULong& operator--() { --m_Value; return *this; }
116 const wxAutoULong operator--( int ) { wxAutoULong temp = *this; --m_Value; return temp; }
117
118 private:
119 ULONG m_Value;
120 };
121
122 // declare the methods and the member variable containing reference count
123 // you must also define the ms_aIids array somewhere with BEGIN_IID_TABLE
124 // and friends (see below)
125
126 #define DECLARE_IUNKNOWN_METHODS \
127 public: \
128 STDMETHODIMP QueryInterface(REFIID, void **); \
129 STDMETHODIMP_(ULONG) AddRef(); \
130 STDMETHODIMP_(ULONG) Release(); \
131 private: \
132 static const IID *ms_aIids[]; \
133 wxAutoULong m_cRef
134
135 // macros for declaring supported interfaces
136 // NB: you should write ADD_INTERFACE(Foo) and not ADD_INTERFACE(IID_IFoo)!
137 #define BEGIN_IID_TABLE(cname) const IID *cname::ms_aIids[] = {
138 #define ADD_IID(iid) &IID_I##iid,
139 #define END_IID_TABLE }
140
141 // implementation is as straightforward as possible
142 // Parameter: classname - the name of the class
143 #define IMPLEMENT_IUNKNOWN_METHODS(classname) \
144 STDMETHODIMP classname::QueryInterface(REFIID riid, void **ppv) \
145 { \
146 wxLogQueryInterface(_T(#classname), riid); \
147 \
148 if ( IsIidFromList(riid, ms_aIids, WXSIZEOF(ms_aIids)) ) { \
149 *ppv = this; \
150 AddRef(); \
151 \
152 return S_OK; \
153 } \
154 else { \
155 *ppv = NULL; \
156 \
157 return (HRESULT) E_NOINTERFACE; \
158 } \
159 } \
160 \
161 STDMETHODIMP_(ULONG) classname::AddRef() \
162 { \
163 wxLogAddRef(_T(#classname), m_cRef); \
164 \
165 return ++m_cRef; \
166 } \
167 \
168 STDMETHODIMP_(ULONG) classname::Release() \
169 { \
170 wxLogRelease(_T(#classname), m_cRef); \
171 \
172 if ( --m_cRef == wxAutoULong(0) ) { \
173 delete this; \
174 return 0; \
175 } \
176 else \
177 return m_cRef; \
178 }
179
180 // ============================================================================
181 // Debugging support
182 // ============================================================================
183
184 // VZ: I don't know it's not done for compilers other than VC++ but I leave it
185 // as is. Please note, though, that tracing OLE interface calls may be
186 // incredibly useful when debugging OLE programs.
187 #if defined(__WXDEBUG__) && ( ( defined(__VISUALC__) && (__VISUALC__ >= 1000) ) || defined(__MWERKS__) )
188 // ----------------------------------------------------------------------------
189 // All OLE specific log functions have DebugTrace level (as LogTrace)
190 // ----------------------------------------------------------------------------
191
192 // tries to translate riid into a symbolic name, if possible
193 void wxLogQueryInterface(const wxChar *szInterface, REFIID riid);
194
195 // these functions print out the new value of reference counter
196 void wxLogAddRef (const wxChar *szInterface, ULONG cRef);
197 void wxLogRelease(const wxChar *szInterface, ULONG cRef);
198
199 #else //!__WXDEBUG__
200 #define wxLogQueryInterface(szInterface, riid)
201 #define wxLogAddRef(szInterface, cRef)
202 #define wxLogRelease(szInterface, cRef)
203 #endif //__WXDEBUG__
204
205 // wrapper around BSTR type (by Vadim Zeitlin)
206
207 class WXDLLEXPORT wxBasicString
208 {
209 public:
210 // ctors & dtor
211 wxBasicString(const char *sz);
212 wxBasicString(const wxString& str);
213 ~wxBasicString();
214
215 void Init(const char* sz);
216
217 // accessors
218 // just get the string
219 operator BSTR() const { return m_wzBuf; }
220 // retrieve a copy of our string - caller must SysFreeString() it later!
221 BSTR Get() const { return SysAllocString(m_wzBuf); }
222
223 private:
224 // @@@ not implemented (but should be)
225 wxBasicString(const wxBasicString&);
226 wxBasicString& operator=(const wxBasicString&);
227
228 OLECHAR *m_wzBuf; // actual string
229 };
230
231 #if wxUSE_VARIANT
232 // Convert variants
233 class WXDLLIMPEXP_FWD_BASE wxVariant;
234
235 WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant);
236 WXDLLEXPORT bool wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant);
237 #endif // wxUSE_VARIANT
238
239 // Convert string to Unicode
240 WXDLLEXPORT BSTR wxConvertStringToOle(const wxString& str);
241
242 // Convert string from BSTR to wxString
243 WXDLLEXPORT wxString wxConvertStringFromOle(BSTR bStr);
244
245 #else // !wxUSE_OLE
246
247 // ----------------------------------------------------------------------------
248 // stub functions to avoid #if wxUSE_OLE in the main code
249 // ----------------------------------------------------------------------------
250
251 inline bool wxOleInitialize() { return false; }
252 inline void wxOleUninitialize() { }
253
254 #endif // wxUSE_OLE/!wxUSE_OLE
255
256 #endif //_WX_OLEUTILS_H

  ViewVC Help
Powered by ViewVC 1.1.22