]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/msw/ole/automtn.cpp | |
3 | // Purpose: OLE automation utilities | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 11/6/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998, Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // For compilers that support precompilation, includes "wx.h". | |
13 | #include "wx/wxprec.h" | |
14 | ||
15 | #if defined(__BORLANDC__) | |
16 | #pragma hdrstop | |
17 | #endif | |
18 | ||
19 | // With Borland C++, all samples crash if this is compiled in. | |
20 | #if (defined(__BORLANDC__) && (__BORLANDC__ < 0x520)) || defined(__CYGWIN10__) | |
21 | #undef wxUSE_OLE_AUTOMATION | |
22 | #define wxUSE_OLE_AUTOMATION 0 | |
23 | #endif | |
24 | ||
25 | #ifndef WX_PRECOMP | |
26 | #include "wx/log.h" | |
27 | #include "wx/math.h" | |
28 | #endif | |
29 | ||
30 | #define _FORCENAMELESSUNION | |
31 | #include "wx/msw/private.h" | |
32 | #include "wx/msw/ole/oleutils.h" | |
33 | #include "wx/msw/ole/automtn.h" | |
34 | ||
35 | #ifdef __WXWINCE__ | |
36 | #include "wx/msw/wince/time.h" | |
37 | #else | |
38 | #include <time.h> | |
39 | #endif | |
40 | ||
41 | #include <wtypes.h> | |
42 | #include <unknwn.h> | |
43 | ||
44 | #include <ole2.h> | |
45 | #define _huge | |
46 | ||
47 | #ifndef __WXWINCE__ | |
48 | #include <ole2ver.h> | |
49 | #endif | |
50 | ||
51 | #include <oleauto.h> | |
52 | ||
53 | #if wxUSE_DATETIME | |
54 | #include "wx/datetime.h" | |
55 | #endif // wxUSE_DATETIME | |
56 | ||
57 | #if wxUSE_OLE_AUTOMATION | |
58 | ||
59 | #include <wx/vector.h> | |
60 | ||
61 | // Report an OLE error when calling the specified method to the user via wxLog. | |
62 | static void | |
63 | ShowException(const wxString& member, | |
64 | HRESULT hr, | |
65 | EXCEPINFO *pexcep = NULL, | |
66 | unsigned int uiArgErr = 0); | |
67 | ||
68 | // wxAutomationObject | |
69 | ||
70 | wxAutomationObject::wxAutomationObject(WXIDISPATCH* dispatchPtr) | |
71 | { | |
72 | m_dispatchPtr = dispatchPtr; | |
73 | } | |
74 | ||
75 | wxAutomationObject::~wxAutomationObject() | |
76 | { | |
77 | if (m_dispatchPtr) | |
78 | { | |
79 | ((IDispatch*)m_dispatchPtr)->Release(); | |
80 | m_dispatchPtr = NULL; | |
81 | } | |
82 | } | |
83 | ||
84 | namespace | |
85 | { | |
86 | ||
87 | // A simple helper that ensures that VARIANT is destroyed on scope exit. | |
88 | struct wxOleVariantArg : VARIANTARG | |
89 | { | |
90 | wxOleVariantArg() { VariantInit(this); } | |
91 | ~wxOleVariantArg() { VariantClear(this); } | |
92 | }; | |
93 | ||
94 | } // anonymous namespace | |
95 | ||
96 | ||
97 | #define INVOKEARG(i) (args ? args[i] : *(ptrArgs[i])) | |
98 | ||
99 | // For Put/Get, no named arguments are allowed. | |
100 | // WARNING: if args contain IDispatches, their reference count will be decreased | |
101 | // by one after Invoke() returns! | |
102 | bool wxAutomationObject::Invoke(const wxString& member, int action, | |
103 | wxVariant& retValue, int noArgs, wxVariant args[], const wxVariant* ptrArgs[]) const | |
104 | { | |
105 | if (!m_dispatchPtr) | |
106 | return false; | |
107 | ||
108 | int ch = member.Find('.'); | |
109 | if (ch != -1) | |
110 | { | |
111 | // Use dot notation to get the next object | |
112 | wxString member2(member.Left((size_t) ch)); | |
113 | wxString rest(member.Right(member.length() - ch - 1)); | |
114 | wxAutomationObject obj; | |
115 | if (!GetObject(obj, member2)) | |
116 | return false; | |
117 | return obj.Invoke(rest, action, retValue, noArgs, args, ptrArgs); | |
118 | } | |
119 | ||
120 | wxOleVariantArg vReturn; | |
121 | wxOleVariantArg* vReturnPtr = & vReturn; | |
122 | ||
123 | // Find number of names args | |
124 | int namedArgCount = 0; | |
125 | int i; | |
126 | for (i = 0; i < noArgs; i++) | |
127 | { | |
128 | if ( !INVOKEARG(i).GetName().empty() ) | |
129 | { | |
130 | namedArgCount ++; | |
131 | } | |
132 | } | |
133 | ||
134 | int namedArgStringCount = namedArgCount + 1; | |
135 | wxVector<wxBasicString> argNames(namedArgStringCount, wxString()); | |
136 | argNames[0] = member; | |
137 | ||
138 | // Note that arguments are specified in reverse order | |
139 | // (all totally logical; hey, we're dealing with OLE here.) | |
140 | ||
141 | int j = 0; | |
142 | for (i = 0; i < namedArgCount; i++) | |
143 | { | |
144 | if ( !INVOKEARG(i).GetName().empty() ) | |
145 | { | |
146 | argNames[(namedArgCount-j)] = INVOKEARG(i).GetName(); | |
147 | j ++; | |
148 | } | |
149 | } | |
150 | ||
151 | // + 1 for the member name, + 1 again in case we're a 'put' | |
152 | wxVector<DISPID> dispIds(namedArgCount + 2); | |
153 | ||
154 | HRESULT hr; | |
155 | DISPPARAMS dispparams; | |
156 | unsigned int uiArgErr; | |
157 | ||
158 | // Get the IDs for the member and its arguments. GetIDsOfNames expects the | |
159 | // member name as the first name, followed by argument names (if any). | |
160 | hr = ((IDispatch*)m_dispatchPtr)->GetIDsOfNames(IID_NULL, | |
161 | // We rely on the fact that wxBasicString is | |
162 | // just BSTR with some methods here. | |
163 | reinterpret_cast<BSTR *>(&argNames[0]), | |
164 | 1 + namedArgCount, LOCALE_SYSTEM_DEFAULT, &dispIds[0]); | |
165 | if (FAILED(hr)) | |
166 | { | |
167 | ShowException(member, hr); | |
168 | return false; | |
169 | } | |
170 | ||
171 | // if doing a property put(ref), we need to adjust the first argument to have a | |
172 | // named arg of DISPID_PROPERTYPUT. | |
173 | if (action & (DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF)) | |
174 | { | |
175 | namedArgCount = 1; | |
176 | dispIds[1] = DISPID_PROPERTYPUT; | |
177 | vReturnPtr = NULL; | |
178 | } | |
179 | ||
180 | // Convert the wxVariants to VARIANTARGs | |
181 | wxVector<wxOleVariantArg> oleArgs(noArgs); | |
182 | for (i = 0; i < noArgs; i++) | |
183 | { | |
184 | // Again, reverse args | |
185 | if (!wxConvertVariantToOle(INVOKEARG((noArgs-1) - i), oleArgs[i])) | |
186 | return false; | |
187 | } | |
188 | ||
189 | dispparams.rgdispidNamedArgs = &dispIds[0] + 1; | |
190 | dispparams.rgvarg = &oleArgs[0]; | |
191 | dispparams.cArgs = noArgs; | |
192 | dispparams.cNamedArgs = namedArgCount; | |
193 | ||
194 | EXCEPINFO excep; | |
195 | wxZeroMemory(excep); | |
196 | ||
197 | hr = ((IDispatch*)m_dispatchPtr)->Invoke(dispIds[0], IID_NULL, LOCALE_SYSTEM_DEFAULT, | |
198 | (WORD)action, &dispparams, vReturnPtr, &excep, &uiArgErr); | |
199 | ||
200 | if (FAILED(hr)) | |
201 | { | |
202 | // display the exception information if appropriate: | |
203 | ShowException(member, hr, &excep, uiArgErr); | |
204 | ||
205 | // free exception structure information | |
206 | SysFreeString(excep.bstrSource); | |
207 | SysFreeString(excep.bstrDescription); | |
208 | SysFreeString(excep.bstrHelpFile); | |
209 | ||
210 | return false; | |
211 | } | |
212 | else | |
213 | { | |
214 | if (vReturnPtr) | |
215 | { | |
216 | // Convert result to wxVariant form | |
217 | if (!wxConvertOleToVariant(vReturn, retValue)) | |
218 | return false; | |
219 | // Mustn't release the dispatch pointer | |
220 | if (vReturn.vt == VT_DISPATCH) | |
221 | { | |
222 | vReturn.pdispVal = NULL; | |
223 | } | |
224 | } | |
225 | } | |
226 | return true; | |
227 | } | |
228 | ||
229 | // Invoke a member function | |
230 | wxVariant wxAutomationObject::CallMethod(const wxString& member, int noArgs, wxVariant args[]) | |
231 | { | |
232 | wxVariant retVariant; | |
233 | if (!Invoke(member, DISPATCH_METHOD, retVariant, noArgs, args)) | |
234 | { | |
235 | retVariant.MakeNull(); | |
236 | } | |
237 | return retVariant; | |
238 | } | |
239 | ||
240 | wxVariant wxAutomationObject::CallMethodArray(const wxString& member, int noArgs, const wxVariant **args) | |
241 | { | |
242 | wxVariant retVariant; | |
243 | if (!Invoke(member, DISPATCH_METHOD, retVariant, noArgs, NULL, args)) | |
244 | { | |
245 | retVariant.MakeNull(); | |
246 | } | |
247 | return retVariant; | |
248 | } | |
249 | ||
250 | wxVariant wxAutomationObject::CallMethod(const wxString& member, | |
251 | const wxVariant& arg1, const wxVariant& arg2, | |
252 | const wxVariant& arg3, const wxVariant& arg4, | |
253 | const wxVariant& arg5, const wxVariant& arg6) | |
254 | { | |
255 | const wxVariant** args = new const wxVariant*[6]; | |
256 | int i = 0; | |
257 | if (!arg1.IsNull()) | |
258 | { | |
259 | args[i] = & arg1; | |
260 | i ++; | |
261 | } | |
262 | if (!arg2.IsNull()) | |
263 | { | |
264 | args[i] = & arg2; | |
265 | i ++; | |
266 | } | |
267 | if (!arg3.IsNull()) | |
268 | { | |
269 | args[i] = & arg3; | |
270 | i ++; | |
271 | } | |
272 | if (!arg4.IsNull()) | |
273 | { | |
274 | args[i] = & arg4; | |
275 | i ++; | |
276 | } | |
277 | if (!arg5.IsNull()) | |
278 | { | |
279 | args[i] = & arg5; | |
280 | i ++; | |
281 | } | |
282 | if (!arg6.IsNull()) | |
283 | { | |
284 | args[i] = & arg6; | |
285 | i ++; | |
286 | } | |
287 | wxVariant retVariant; | |
288 | if (!Invoke(member, DISPATCH_METHOD, retVariant, i, NULL, args)) | |
289 | { | |
290 | retVariant.MakeNull(); | |
291 | } | |
292 | delete[] args; | |
293 | return retVariant; | |
294 | } | |
295 | ||
296 | // Get/Set property | |
297 | wxVariant wxAutomationObject::GetPropertyArray(const wxString& property, int noArgs, const wxVariant **args) const | |
298 | { | |
299 | wxVariant retVariant; | |
300 | if (!Invoke(property, DISPATCH_PROPERTYGET, retVariant, noArgs, NULL, args)) | |
301 | { | |
302 | retVariant.MakeNull(); | |
303 | } | |
304 | return retVariant; | |
305 | } | |
306 | wxVariant wxAutomationObject::GetProperty(const wxString& property, int noArgs, wxVariant args[]) const | |
307 | { | |
308 | wxVariant retVariant; | |
309 | if (!Invoke(property, DISPATCH_PROPERTYGET, retVariant, noArgs, args)) | |
310 | { | |
311 | retVariant.MakeNull(); | |
312 | } | |
313 | return retVariant; | |
314 | } | |
315 | ||
316 | wxVariant wxAutomationObject::GetProperty(const wxString& property, | |
317 | const wxVariant& arg1, const wxVariant& arg2, | |
318 | const wxVariant& arg3, const wxVariant& arg4, | |
319 | const wxVariant& arg5, const wxVariant& arg6) | |
320 | { | |
321 | const wxVariant** args = new const wxVariant*[6]; | |
322 | int i = 0; | |
323 | if (!arg1.IsNull()) | |
324 | { | |
325 | args[i] = & arg1; | |
326 | i ++; | |
327 | } | |
328 | if (!arg2.IsNull()) | |
329 | { | |
330 | args[i] = & arg2; | |
331 | i ++; | |
332 | } | |
333 | if (!arg3.IsNull()) | |
334 | { | |
335 | args[i] = & arg3; | |
336 | i ++; | |
337 | } | |
338 | if (!arg4.IsNull()) | |
339 | { | |
340 | args[i] = & arg4; | |
341 | i ++; | |
342 | } | |
343 | if (!arg5.IsNull()) | |
344 | { | |
345 | args[i] = & arg5; | |
346 | i ++; | |
347 | } | |
348 | if (!arg6.IsNull()) | |
349 | { | |
350 | args[i] = & arg6; | |
351 | i ++; | |
352 | } | |
353 | wxVariant retVariant; | |
354 | if (!Invoke(property, DISPATCH_PROPERTYGET, retVariant, i, NULL, args)) | |
355 | { | |
356 | retVariant.MakeNull(); | |
357 | } | |
358 | delete[] args; | |
359 | return retVariant; | |
360 | } | |
361 | ||
362 | bool wxAutomationObject::PutProperty(const wxString& property, int noArgs, wxVariant args[]) | |
363 | { | |
364 | wxVariant retVariant; | |
365 | if (!Invoke(property, DISPATCH_PROPERTYPUT, retVariant, noArgs, args)) | |
366 | { | |
367 | return false; | |
368 | } | |
369 | return true; | |
370 | } | |
371 | ||
372 | bool wxAutomationObject::PutPropertyArray(const wxString& property, int noArgs, const wxVariant **args) | |
373 | { | |
374 | wxVariant retVariant; | |
375 | if (!Invoke(property, DISPATCH_PROPERTYPUT, retVariant, noArgs, NULL, args)) | |
376 | { | |
377 | return false; | |
378 | } | |
379 | return true; | |
380 | } | |
381 | ||
382 | bool wxAutomationObject::PutProperty(const wxString& property, | |
383 | const wxVariant& arg1, const wxVariant& arg2, | |
384 | const wxVariant& arg3, const wxVariant& arg4, | |
385 | const wxVariant& arg5, const wxVariant& arg6) | |
386 | { | |
387 | const wxVariant** args = new const wxVariant*[6]; | |
388 | int i = 0; | |
389 | if (!arg1.IsNull()) | |
390 | { | |
391 | args[i] = & arg1; | |
392 | i ++; | |
393 | } | |
394 | if (!arg2.IsNull()) | |
395 | { | |
396 | args[i] = & arg2; | |
397 | i ++; | |
398 | } | |
399 | if (!arg3.IsNull()) | |
400 | { | |
401 | args[i] = & arg3; | |
402 | i ++; | |
403 | } | |
404 | if (!arg4.IsNull()) | |
405 | { | |
406 | args[i] = & arg4; | |
407 | i ++; | |
408 | } | |
409 | if (!arg5.IsNull()) | |
410 | { | |
411 | args[i] = & arg5; | |
412 | i ++; | |
413 | } | |
414 | if (!arg6.IsNull()) | |
415 | { | |
416 | args[i] = & arg6; | |
417 | i ++; | |
418 | } | |
419 | wxVariant retVariant; | |
420 | bool ret = Invoke(property, DISPATCH_PROPERTYPUT, retVariant, i, NULL, args); | |
421 | delete[] args; | |
422 | return ret; | |
423 | } | |
424 | ||
425 | ||
426 | // Uses DISPATCH_PROPERTYGET | |
427 | // and returns a dispatch pointer. The calling code should call Release | |
428 | // on the pointer, though this could be implicit by constructing an wxAutomationObject | |
429 | // with it and letting the destructor call Release. | |
430 | WXIDISPATCH* wxAutomationObject::GetDispatchProperty(const wxString& property, int noArgs, wxVariant args[]) const | |
431 | { | |
432 | wxVariant retVariant; | |
433 | if (Invoke(property, DISPATCH_PROPERTYGET, retVariant, noArgs, args)) | |
434 | { | |
435 | if (retVariant.GetType() == wxT("void*")) | |
436 | { | |
437 | return (WXIDISPATCH*) retVariant.GetVoidPtr(); | |
438 | } | |
439 | } | |
440 | ||
441 | return NULL; | |
442 | } | |
443 | ||
444 | // Uses DISPATCH_PROPERTYGET | |
445 | // and returns a dispatch pointer. The calling code should call Release | |
446 | // on the pointer, though this could be implicit by constructing an wxAutomationObject | |
447 | // with it and letting the destructor call Release. | |
448 | WXIDISPATCH* wxAutomationObject::GetDispatchProperty(const wxString& property, int noArgs, const wxVariant **args) const | |
449 | { | |
450 | wxVariant retVariant; | |
451 | if (Invoke(property, DISPATCH_PROPERTYGET, retVariant, noArgs, NULL, args)) | |
452 | { | |
453 | if (retVariant.GetType() == wxT("void*")) | |
454 | { | |
455 | return (WXIDISPATCH*) retVariant.GetVoidPtr(); | |
456 | } | |
457 | } | |
458 | ||
459 | return NULL; | |
460 | } | |
461 | ||
462 | ||
463 | // A way of initialising another wxAutomationObject with a dispatch object | |
464 | bool wxAutomationObject::GetObject(wxAutomationObject& obj, const wxString& property, int noArgs, wxVariant args[]) const | |
465 | { | |
466 | WXIDISPATCH* dispatch = GetDispatchProperty(property, noArgs, args); | |
467 | if (dispatch) | |
468 | { | |
469 | obj.SetDispatchPtr(dispatch); | |
470 | return true; | |
471 | } | |
472 | else | |
473 | return false; | |
474 | } | |
475 | ||
476 | // A way of initialising another wxAutomationObject with a dispatch object | |
477 | bool wxAutomationObject::GetObject(wxAutomationObject& obj, const wxString& property, int noArgs, const wxVariant **args) const | |
478 | { | |
479 | WXIDISPATCH* dispatch = GetDispatchProperty(property, noArgs, args); | |
480 | if (dispatch) | |
481 | { | |
482 | obj.SetDispatchPtr(dispatch); | |
483 | return true; | |
484 | } | |
485 | else | |
486 | return false; | |
487 | } | |
488 | ||
489 | namespace | |
490 | { | |
491 | ||
492 | HRESULT wxCLSIDFromProgID(const wxString& progId, CLSID& clsId) | |
493 | { | |
494 | HRESULT hr = CLSIDFromProgID(wxBasicString(progId), &clsId); | |
495 | if ( FAILED(hr) ) | |
496 | { | |
497 | wxLogSysError(hr, _("Failed to find CLSID of \"%s\""), progId); | |
498 | } | |
499 | return hr; | |
500 | } | |
501 | ||
502 | void *DoCreateInstance(const wxString& progId, const CLSID& clsId) | |
503 | { | |
504 | // get the server IDispatch interface | |
505 | // | |
506 | // NB: using CLSCTX_INPROC_HANDLER results in failure when getting | |
507 | // Automation interface for Microsoft Office applications so don't use | |
508 | // CLSCTX_ALL which includes it | |
509 | void *pDispatch = NULL; | |
510 | HRESULT hr = CoCreateInstance(clsId, NULL, CLSCTX_SERVER, | |
511 | IID_IDispatch, &pDispatch); | |
512 | if (FAILED(hr)) | |
513 | { | |
514 | wxLogSysError(hr, _("Failed to create an instance of \"%s\""), progId); | |
515 | return NULL; | |
516 | } | |
517 | ||
518 | return pDispatch; | |
519 | } | |
520 | ||
521 | } // anonymous namespace | |
522 | ||
523 | // Get a dispatch pointer from the current object associated | |
524 | // with a ProgID | |
525 | bool wxAutomationObject::GetInstance(const wxString& progId, int flags) const | |
526 | { | |
527 | if (m_dispatchPtr) | |
528 | return false; | |
529 | ||
530 | CLSID clsId; | |
531 | HRESULT hr = wxCLSIDFromProgID(progId, clsId); | |
532 | if (FAILED(hr)) | |
533 | return false; | |
534 | ||
535 | IUnknown *pUnk = NULL; | |
536 | hr = GetActiveObject(clsId, NULL, &pUnk); | |
537 | if (FAILED(hr)) | |
538 | { | |
539 | if ( flags & wxAutomationInstance_CreateIfNeeded ) | |
540 | { | |
541 | const_cast<wxAutomationObject *>(this)-> | |
542 | m_dispatchPtr = DoCreateInstance(progId, clsId); | |
543 | if ( m_dispatchPtr ) | |
544 | return true; | |
545 | } | |
546 | else | |
547 | { | |
548 | // Log an error except if we're supposed to fail silently when the | |
549 | // error is that no current instance exists. | |
550 | if ( hr != MK_E_UNAVAILABLE || | |
551 | !(flags & wxAutomationInstance_SilentIfNone) ) | |
552 | { | |
553 | wxLogSysError(hr, | |
554 | _("Cannot get an active instance of \"%s\""), | |
555 | progId); | |
556 | } | |
557 | } | |
558 | ||
559 | return false; | |
560 | } | |
561 | ||
562 | hr = pUnk->QueryInterface(IID_IDispatch, (LPVOID*) &m_dispatchPtr); | |
563 | if (FAILED(hr)) | |
564 | { | |
565 | wxLogSysError(hr, | |
566 | _("Failed to get OLE automation interface for \"%s\""), | |
567 | progId); | |
568 | return false; | |
569 | } | |
570 | ||
571 | return true; | |
572 | } | |
573 | ||
574 | // Get a dispatch pointer from a new object associated | |
575 | // with the given ProgID | |
576 | bool wxAutomationObject::CreateInstance(const wxString& progId) const | |
577 | { | |
578 | if (m_dispatchPtr) | |
579 | return false; | |
580 | ||
581 | CLSID clsId; | |
582 | HRESULT hr = wxCLSIDFromProgID(progId, clsId); | |
583 | if (FAILED(hr)) | |
584 | return false; | |
585 | ||
586 | const_cast<wxAutomationObject *>(this)-> | |
587 | m_dispatchPtr = DoCreateInstance(progId, clsId); | |
588 | ||
589 | return m_dispatchPtr != NULL; | |
590 | } | |
591 | ||
592 | static void | |
593 | ShowException(const wxString& member, | |
594 | HRESULT hr, | |
595 | EXCEPINFO *pexcep, | |
596 | unsigned int uiArgErr) | |
597 | { | |
598 | wxString message; | |
599 | switch (GetScode(hr)) | |
600 | { | |
601 | case DISP_E_UNKNOWNNAME: | |
602 | message = _("Unknown name or named argument."); | |
603 | break; | |
604 | ||
605 | case DISP_E_BADPARAMCOUNT: | |
606 | message = _("Incorrect number of arguments."); | |
607 | break; | |
608 | ||
609 | case DISP_E_EXCEPTION: | |
610 | if ( pexcep ) | |
611 | { | |
612 | if ( pexcep->bstrDescription ) | |
613 | message << pexcep->bstrDescription << wxS(" "); | |
614 | message += wxString::Format(wxS("error code %u"), pexcep->wCode); | |
615 | } | |
616 | else | |
617 | { | |
618 | message = _("Unknown exception"); | |
619 | } | |
620 | break; | |
621 | ||
622 | case DISP_E_MEMBERNOTFOUND: | |
623 | message = _("Method or property not found."); | |
624 | break; | |
625 | ||
626 | case DISP_E_OVERFLOW: | |
627 | message = _("Overflow while coercing argument values."); | |
628 | break; | |
629 | ||
630 | case DISP_E_NONAMEDARGS: | |
631 | message = _("Object implementation does not support named arguments."); | |
632 | break; | |
633 | ||
634 | case DISP_E_UNKNOWNLCID: | |
635 | message = _("The locale ID is unknown."); | |
636 | break; | |
637 | ||
638 | case DISP_E_PARAMNOTOPTIONAL: | |
639 | message = _("Missing a required parameter."); | |
640 | break; | |
641 | ||
642 | case DISP_E_PARAMNOTFOUND: | |
643 | message.Printf(_("Argument %u not found."), uiArgErr); | |
644 | break; | |
645 | ||
646 | case DISP_E_TYPEMISMATCH: | |
647 | message.Printf(_("Type mismatch in argument %u."), uiArgErr); | |
648 | break; | |
649 | ||
650 | case ERROR_FILE_NOT_FOUND: | |
651 | message = _("The system cannot find the file specified."); | |
652 | break; | |
653 | ||
654 | case REGDB_E_CLASSNOTREG: | |
655 | message = _("Class not registered."); | |
656 | break; | |
657 | ||
658 | default: | |
659 | message.Printf(_("Unknown error %08x"), hr); | |
660 | break; | |
661 | } | |
662 | ||
663 | wxLogError(_("OLE Automation error in %s: %s"), member, message); | |
664 | } | |
665 | ||
666 | #endif // wxUSE_OLE_AUTOMATION |