xref: /AOO41X/main/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.cpp (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 // Callback.cpp : Implementation of CCallback
28 #include "stdafx.h"
29 #include "XCallback_Impl.h"
30 #include "Callback.h"
31 
32 /////////////////////////////////////////////////////////////////////////////
33 // CCallback
34 
35 
36 STDMETHODIMP CCallback::func1()
37 {
38 	MessageBox( NULL, _T("Callback::func1 called"),_T(""), MB_OK);
39 	return S_OK;
40 }
41 
42 STDMETHODIMP CCallback::returnInterface(IDispatch **ppdisp)
43 {
44 	if( ! ppdisp)
45 		return E_POINTER;
46 	CComPtr<IDispatch> spDisp;
47 	spDisp.CoCreateInstance( L"XCallback_Impl.Simple");
48 	*ppdisp= spDisp;
49 	(*ppdisp)->AddRef();
50 	return S_OK;
51 }
52 
53 STDMETHODIMP CCallback::outInterface(IDispatch **ppdisp)
54 {
55 //	return S_OK;
56 	if( ! ppdisp)
57 		return E_POINTER;
58 	CComPtr<IDispatch> spDisp;
59 	spDisp.CoCreateInstance( L"XCallback_Impl.Simple");
60 	*ppdisp= spDisp;
61 	(*ppdisp)->AddRef();
62 
63 //	MessageBox( NULL, _T("CCallback::outInterface"), _T(""), MB_OK);
64 	return S_OK;
65 }
66 
67 STDMETHODIMP CCallback::outValuesMixed(long val, long *pval, BSTR string)
68 {
69 	USES_CONVERSION;
70 	char buff[1024];
71 	*pval = val+1;
72 	sprintf( buff, "param1: %d, param2 out: %d, param3: %S", val, *pval, string);
73 	MessageBox( NULL, A2T(buff), A2T("XCallback_Impl.Callback"), MB_OK);
74 	return S_OK;
75 }
76 
77 
78 STDMETHODIMP CCallback::outValuesAll(
79             /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppdisp,
80             /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppSimpleStruct,
81             /* [out] */ long __RPC_FAR *aSimpleEnum,
82             /* [out] */ SAFEARRAY __RPC_FAR * __RPC_FAR *outSeq,
83             /* [out] */ VARIANT __RPC_FAR *varAny,
84             /* [out] */ VARIANT_BOOL __RPC_FAR *aBool,
85             /* [out] */ short __RPC_FAR *aChar,
86             /* [out] */ BSTR __RPC_FAR *aString,
87             /* [out] */ float __RPC_FAR *aFloat,
88             /* [out] */ double __RPC_FAR *aDouble,
89             /* [out] */  unsigned char __RPC_FAR *aByte,
90             /* [out] */ short __RPC_FAR *aShort,
91             /* [out] */ long __RPC_FAR *aLong)
92 //)
93 {
94 //	if( ! ppdisp || ! ppSimpleStruct || ! aSimpleEnum ||
95 //		! outSeq || !varAny ||! aBool || ! aChar ||
96 //		! aString || ! aFloat || ! aDouble || ! aByte ||
97 //		! aShort || ! aLong || ! aUShort || ! aULong)
98 //		return E_POINTER;
99 
100 	HRESULT hr=S_OK;
101 	hr= outInterface( ppdisp);
102 	hr= outStruct( ppSimpleStruct);
103 	hr= outEnum( aSimpleEnum);
104 	hr= outSeqAny( outSeq);
105 	hr= outAny( varAny);
106 	hr= outBool( aBool);
107 	hr= outChar( aChar);
108 	hr= outString( aString);
109 	hr= outFloat( aFloat);
110 	hr= outDouble( aDouble);
111 	hr= outByte( aByte);
112 	hr= outShort( aShort);
113 	hr= outLong( aLong);
114 	return hr;
115 }
116 
117 STDMETHODIMP CCallback::outStruct(IDispatch **outStruct)
118 {
119 //	return S_OK;
120 	if( !outStruct)
121 		return E_POINTER;
122 	HRESULT hr= E_FAIL;
123 //	MessageBox( NULL, _T("CCallback::outStruct"), _T(""), MB_OK);
124 
125 	CComPtr<IDispatch> _dispMgr;
126 	if( SUCCEEDED(hr= _dispMgr.CoCreateInstance(L"com.sun.star.ServiceManager")))
127 	{
128 		CComDispatchDriver manager( _dispMgr);
129 		CComVariant param1(L"com.sun.star.reflection.CoreReflection");
130 		CComVariant varRet;
131 		hr= manager.Invoke1( L"createInstance", &param1, &varRet);
132 
133 		CComDispatchDriver reflection( varRet.pdispVal);
134 		param1= L"oletest.SimpleStruct";
135 		varRet.Clear();
136 		hr= reflection.Invoke1( L"forName", &param1, &varRet);
137 
138 		CComDispatchDriver classSimpleStruct( varRet.pdispVal);
139 
140 		CComPtr<IDispatch> dispStruct;
141 		param1.vt= VT_DISPATCH | VT_BYREF;
142 		param1.ppdispVal= &dispStruct;
143 		if( SUCCEEDED( hr= classSimpleStruct.Invoke1(L"createObject", &param1)))
144 		{
145 			// Set the value
146 			CComDispatchDriver simpleStruct( dispStruct);
147 			param1=L" this is a property string";
148 			hr=	simpleStruct.PutPropertyByName(L"message", &param1);
149 			*outStruct= dispStruct;
150 			(*outStruct)->AddRef();
151 			hr= S_OK;
152 		}
153 	}
154 	return hr;
155 }
156 
157 STDMETHODIMP CCallback::outEnum(long *outEnum)
158 {
159 	if( !outEnum)
160 		return E_POINTER;
161 	*outEnum= 1;
162 	return S_OK;
163 }
164 
165 STDMETHODIMP CCallback::outSeqAny(LPSAFEARRAY* outSeq)
166 {
167 //	_CrtDbgBreak();
168 	SAFEARRAY* pArr= SafeArrayCreateVector( VT_VARIANT, 0, 3);
169 	CComVariant var[3];
170 	var[0]=L" variant 0";
171 	var[1]=L" variant 1";
172 	var[2]=L"variant 2";
173 	for( long i=0; i<3; i++)
174 	{
175 		SafeArrayPutElement( pArr, &i, (void*)&var[i]);
176 	}
177 
178 	*outSeq= pArr;
179 	return S_OK;
180 }
181 
182 // ATLASSERT //VT_EMPTY
183 
184 
185 STDMETHODIMP CCallback::outAny(VARIANT *outAny)
186 {
187 	if( ! outAny)
188 		return E_POINTER;
189 	outAny->vt= VT_BSTR;
190 	outAny->bstrVal= SysAllocString( L"This is a string in a VARIANT");
191 
192 	return S_OK;
193 }
194 
195 STDMETHODIMP CCallback::outBool(VARIANT_BOOL *outBool)
196 {
197 	if( ! outBool)
198 		return E_POINTER;
199 	*outBool= VARIANT_TRUE;
200 	return S_OK;
201 }
202 
203 STDMETHODIMP CCallback::outChar(short *outChar)
204 {
205 	if( !outChar)
206 		return E_POINTER;
207 	*outChar= (short)L'A';
208 	return S_OK;
209 }
210 
211 STDMETHODIMP CCallback::outString(BSTR *outString)
212 {
213 	if( !outString)
214 		return E_POINTER;
215 	*outString= SysAllocString(L"This is a BSTR");
216 	return S_OK;
217 }
218 
219 STDMETHODIMP CCallback::outFloat(float *outFloat)
220 {
221 	if( !outFloat)
222 		return E_POINTER;
223 	*outFloat= 3.14f;
224 	return S_OK;
225 }
226 
227 STDMETHODIMP CCallback::outDouble(double *outDouble)
228 {
229 	if(!outDouble)
230 		return E_POINTER;
231 
232 	*outDouble= 3.145;
233 	return S_OK;
234 }
235 
236 
237 
238 STDMETHODIMP CCallback::outShort(short *outShort)
239 {
240 	if(!outShort)
241 		return E_POINTER;
242 	*outShort= -1;
243 	return S_OK;
244 }
245 
246 STDMETHODIMP CCallback::outLong(long *outLong)
247 {
248 	if(!outLong)
249 		return E_POINTER;
250 	*outLong= 0xffffffff;
251 	return S_OK;
252 }
253 
254 
255 
256 STDMETHODIMP CCallback::outByte(unsigned char* outByte)
257 {
258 	if(!outByte)
259 		return E_POINTER;
260 	*outByte= 0xff;
261 	return S_OK;
262 }
263 
264 STDMETHODIMP CCallback::inoutInterface(IDispatch **ppdisp)
265 {
266 	if( !ppdisp)
267 		return E_POINTER;
268 	CComDispatchDriver disp( *ppdisp);
269 	CComVariant param1(L"");
270 	disp.Invoke1(L"func", &param1);
271 
272 	(*ppdisp)->Release();
273 
274 	CComPtr<IDispatch> outDisp;
275 	outDisp.CoCreateInstance( L"XCallback_Impl.Simple");
276 	*ppdisp= outDisp;
277 	(*ppdisp)->AddRef();
278 
279 	return S_OK;
280 }
281 
282 STDMETHODIMP CCallback::inoutStruct(IDispatch **inoutVal)
283 {
284 	if( !inoutVal)
285 		return E_POINTER;
286 	HRESULT hr= S_OK;
287 	USES_CONVERSION;
288 	CComVariant var;
289 	CComDispatchDriver disp( *inoutVal);
290 
291 	hr= disp.GetPropertyByName(L"message", &var);
292 	MessageBox( NULL, W2T(var.bstrVal), _T("XCallback_Impl.Callback"), MB_OK);
293 
294 	(*inoutVal)->Release();
295 
296 	CComDispatchDriver dispStruct;
297 	hr= outStruct( &dispStruct.p);
298 	var.Clear();
299 	var= L"This struct was created in XCallback_Imp.Callback";
300 	hr=	dispStruct.PutPropertyByName(L"message", &var);
301 
302 	*inoutVal= dispStruct;
303 	(*inoutVal)->AddRef();
304 	return hr;
305 }
306 
307 STDMETHODIMP CCallback::inoutEnum(long *inoutVal)
308 {
309 	if( !inoutVal)
310 		return E_POINTER;
311 	*inoutVal= *inoutVal+1;
312 
313 	return S_OK;
314 }
315 
316 STDMETHODIMP CCallback::inoutSeqAny(LPSAFEARRAY *pArray)
317 {
318 	if( !pArray)
319 		return E_POINTER;
320 	HRESULT hr= S_OK;
321 	long lbound=0;
322 	long ubound=0;
323 	hr= SafeArrayGetLBound( *pArray, 1, &lbound);
324 	hr= SafeArrayGetUBound( *pArray, 1, &ubound);
325 	long count= ubound - lbound + 1;
326 
327 	// the Array is supposet to contain variants
328 	CComVariant var;
329 	for( long i=0; i<count; i++)
330 	{
331 		var.Clear();
332 		hr= SafeArrayGetElement( *pArray, &i, (void*)&var);
333 	}
334 
335 	SafeArrayDestroy( *pArray);
336 
337 	outSeqAny( pArray);
338 	return S_OK;
339 }
340 
341 STDMETHODIMP CCallback::inoutAny(VARIANT *inoutVal)
342 {
343 	if( !inoutVal)
344 		return E_POINTER;
345 	USES_CONVERSION;
346 	if( inoutVal->vt= VT_BSTR)
347 		MessageBox( NULL, W2T( inoutVal->bstrVal), _T("XCallback_Impl.Callback"), MB_OK);
348 
349 	VariantClear( inoutVal);
350 	inoutVal->vt= VT_BSTR;
351 	inoutVal->bstrVal=SysAllocString( L" [string] XCallback_Impl.Callback inoutAny");
352 	return S_OK;
353 }
354 
355 STDMETHODIMP CCallback::inoutBool(VARIANT_BOOL *inoutVal)
356 {
357 	if( !inoutVal)
358 		return E_POINTER;
359 
360 	*inoutVal= *inoutVal == VARIANT_TRUE ? VARIANT_FALSE : VARIANT_TRUE;
361 	return S_OK;
362 }
363 
364 STDMETHODIMP CCallback::inoutChar(short *inoutVal)
365 {
366 	if( !inoutVal)
367 		return E_POINTER;
368 	USES_CONVERSION;
369 	char buff[256];
370 	sprintf( buff, "character value: %C", *inoutVal);
371 	MessageBox( NULL, A2T(buff), _T("XCallback_Impl.Callback"), MB_OK);
372 	*inoutVal= L'B';
373 	return S_OK;
374 }
375 
376 STDMETHODIMP CCallback::inoutString(BSTR *inoutVal)
377 {
378 	if( !inoutVal)
379 		return E_POINTER;
380 	USES_CONVERSION;
381 	MessageBox( NULL, W2T(*inoutVal), _T("XCallback_Impl.Callback"), MB_OK);
382 	SysFreeString(*inoutVal);
383 	*inoutVal= SysAllocString(L"a string from XCallback_Impl.Callback");
384 
385 	return S_OK;
386 }
387 
388 STDMETHODIMP CCallback::inoutFloat(float *inoutVal)
389 {
390 	if( !inoutVal)
391 		return E_POINTER;
392 	*inoutVal = *inoutVal+1;
393 	return S_OK;
394 }
395 
396 STDMETHODIMP CCallback::inoutDouble(double *inoutVal)
397 {
398 	if( !inoutVal)
399 		return E_POINTER;
400 	*inoutVal= *inoutVal+1;
401 	return S_OK;
402 }
403 
404 STDMETHODIMP CCallback::inoutByte(unsigned char *inoutVal)
405 {
406 	if( !inoutVal)
407 		return E_POINTER;
408 	*inoutVal= 0xff;
409 	return S_OK;
410 }
411 
412 STDMETHODIMP CCallback::inoutShort(short *inoutVal)
413 {
414 	if( !inoutVal)
415 		return E_POINTER;
416 	*inoutVal= -1;
417 	return S_OK;
418 }
419 
420 STDMETHODIMP CCallback::inoutLong(long* inoutVal)
421 {
422 	if( !inoutVal)
423 		return E_POINTER;
424 	*inoutVal= 0xffffffff;
425 	return S_OK;
426 }
427 
428 STDMETHODIMP CCallback::inoutValuesAll(
429             /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aXSimple,
430             /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aStruct,
431             /* [out][in] */ long __RPC_FAR *aEnum,
432             /* [out][in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *aSeq,
433             /* [out][in] */ VARIANT __RPC_FAR *aAny,
434             /* [out][in] */ VARIANT_BOOL __RPC_FAR *aBool,
435             /* [out][in] */ short __RPC_FAR *aChar,
436             /* [out][in] */ BSTR __RPC_FAR *aString,
437             /* [out][in] */ float __RPC_FAR *aFloat,
438             /* [out][in] */ double __RPC_FAR *aDouble,
439             /* [out][in] */ unsigned char __RPC_FAR *aByte,
440             /* [out][in] */ short __RPC_FAR *aShort,
441             /* [out][in] */ long __RPC_FAR *aLong)
442 {
443 	inoutInterface( aXSimple);
444 	inoutStruct( aStruct);
445 	inoutEnum( aEnum);
446 	inoutSeqAny( aSeq);
447 	inoutAny( aAny);
448 	inoutBool( aBool);
449 	inoutChar( aChar);
450 	inoutString( aString);
451 	inoutFloat( aFloat);
452 	inoutDouble( aDouble);
453 	inoutByte( aByte);
454 	inoutShort( aShort);
455 	inoutLong( aLong);
456 
457 	return S_OK;
458 }
459 
460 
461 STDMETHODIMP CCallback::inValues(short aChar, long aLong, BSTR aString)
462 {
463 	USES_CONVERSION;
464 	wchar_t _char= (wchar_t) aChar;
465 	char buff[1024];
466 	sprintf( buff, "Parameters: char= %C, long= %d, string= %s", _char, aLong, W2A(aString));
467 	MessageBox( NULL, A2T(buff), _T("XCallback_Impl.Callback"), MB_OK);
468 	return S_OK;
469 }
470 
471 STDMETHODIMP CCallback::outSeqByte(LPSAFEARRAY * outVal)
472 {
473 	// TODO: Add your implementation code here
474 
475 	return S_OK;
476 }
477 
478 STDMETHODIMP CCallback::inSeqByte( LPSAFEARRAY listeners)
479 {
480 
481 	return S_OK;
482 }
483 
484 STDMETHODIMP CCallback::inSeqXEventListener( LPSAFEARRAY listeners, LPSAFEARRAY events)
485 {
486 	HRESULT hr= S_OK;
487 	long ubound= 0;
488 	long lbound= 0;
489 	long count= 0;
490 	hr= SafeArrayGetUBound( listeners, 1, &ubound);
491 	hr= SafeArrayGetLBound( listeners, 1, &lbound);
492 	count= ubound - lbound +1;
493 
494 	// We assume thate the count of EventObjects in events is the same
495 	for( long i = 0; i < count; i++)
496 	{
497 		CComVariant varListener;
498 		CComVariant varEvent;
499 		hr= SafeArrayGetElement( listeners, &i, &varListener);
500 		hr= SafeArrayGetElement( events, &i, &varEvent);
501 		if( varListener.vt == VT_DISPATCH && varEvent.vt == VT_DISPATCH)
502 		{
503 			CComDispatchDriver disp( varListener.pdispVal);
504 			hr= disp.Invoke1(L"disposing", &varEvent);
505 		}
506 
507 	}
508 
509 	return S_OK;
510 }
511 
512 
513