xref: /AOO41X/main/svtools/source/uno/unoevent.cxx (revision 0aabba3ab117bd1ebf1560f23f52dfa1a54fd4c7) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svtools.hxx"
26 
27 #include <com/sun/star/beans/PropertyValue.hpp>
28 #include <rtl/ustrbuf.hxx>
29 #include <tools/rtti.hxx>
30 #include <tools/solar.h>
31 #include <svtools/unoevent.hxx>
32 #include <svl/macitem.hxx>
33 
34 using namespace ::com::sun::star;
35 using namespace ::com::sun::star::uno;
36 
37 using ::com::sun::star::container::NoSuchElementException;
38 using ::com::sun::star::container::XNameReplace;
39 using ::com::sun::star::lang::IllegalArgumentException;
40 using ::com::sun::star::lang::WrappedTargetException;
41 using ::com::sun::star::lang::XServiceInfo;
42 using ::com::sun::star::beans::PropertyValue;
43 using ::cppu::WeakImplHelper2;
44 using ::rtl::OUString;
45 using ::rtl::OUStringBuffer;
46 
47 
48 const sal_Char sAPI_ServiceName[] = "com.sun.star.container.XNameReplace";
49 const sal_Char sAPI_SvDetachedEventDescriptor[] = "SvDetachedEventDescriptor";
50 
51 //
52 // SvBaseEventDescriptor
53 //
54 
55 SvBaseEventDescriptor::SvBaseEventDescriptor( const SvEventDescription* pSupportedMacroItems ) :
56 		sEventType(RTL_CONSTASCII_USTRINGPARAM("EventType")),
57 		sMacroName(RTL_CONSTASCII_USTRINGPARAM("MacroName")),
58 		sLibrary(RTL_CONSTASCII_USTRINGPARAM("Library")),
59 		sStarBasic(RTL_CONSTASCII_USTRINGPARAM("StarBasic")),
60 		sJavaScript(RTL_CONSTASCII_USTRINGPARAM("JavaScript")),
61 		sScript(RTL_CONSTASCII_USTRINGPARAM("Script")),
62 		sNone(RTL_CONSTASCII_USTRINGPARAM("None")),
63 		sServiceName(RTL_CONSTASCII_USTRINGPARAM(sAPI_ServiceName)),
64 		sEmpty(),
65 		mpSupportedMacroItems(pSupportedMacroItems),
66 		mnMacroItems(0)
67 {
68 	DBG_ASSERT(pSupportedMacroItems != NULL, "Need a list of supported events!");
69 
70 	for( ; mpSupportedMacroItems[mnMacroItems].mnEvent != 0; mnMacroItems++) ;
71 }
72 
73 
74 SvBaseEventDescriptor::~SvBaseEventDescriptor()
75 {
76 }
77 
78 void SvBaseEventDescriptor::replaceByName(
79 	const OUString& rName,
80 	const Any& rElement )
81 	throw(
82 		IllegalArgumentException,
83 		NoSuchElementException,
84 		WrappedTargetException,
85 		RuntimeException)
86 {
87 	sal_uInt16 nMacroID = getMacroID(rName);
88 
89 	// error checking
90 	if (0 == nMacroID)
91 		throw NoSuchElementException();
92 	if (rElement.getValueType() != getElementType())
93 		throw IllegalArgumentException();
94 
95 	// get sequence
96 	Sequence<PropertyValue> aSequence;
97 	rElement >>= aSequence;
98 
99 	// perform replace (in subclass)
100 	SvxMacro aMacro(sEmpty,sEmpty);
101 	getMacroFromAny(aMacro, rElement);
102 	replaceByName(nMacroID, aMacro);
103 }
104 
105 Any SvBaseEventDescriptor::getByName(
106 	const OUString& rName )
107 	throw(
108 		NoSuchElementException,
109 		WrappedTargetException,
110 		RuntimeException)
111 {
112 	sal_uInt16 nMacroID = getMacroID(rName);
113 
114 	// error checking
115 	if (0 == nMacroID)
116 		throw NoSuchElementException();
117 
118 	// perform get (in subclass)
119 	Any aAny;
120 	SvxMacro aMacro( sEmpty, sEmpty );
121 	getByName(aMacro, nMacroID);
122 	getAnyFromMacro(aAny, aMacro);
123 	return aAny;
124 }
125 
126 Sequence<OUString> SvBaseEventDescriptor::getElementNames()
127 	throw(RuntimeException)
128 {
129 	// create and fill sequence
130 	Sequence<OUString> aSequence(mnMacroItems);
131 	for( sal_Int16 i = 0; i < mnMacroItems; i++)
132 	{
133 		aSequence[i] = OUString::createFromAscii( mpSupportedMacroItems[i].mpEventName );
134 	}
135 
136 	return aSequence;
137 }
138 
139 sal_Bool SvBaseEventDescriptor::hasByName(
140 	const OUString& rName )
141 	throw(RuntimeException)
142 {
143 	sal_uInt16 nMacroID = getMacroID(rName);
144 	return (nMacroID != 0);
145 }
146 
147 Type SvBaseEventDescriptor::getElementType()
148 	throw(RuntimeException)
149 {
150 	return ::getCppuType((Sequence<PropertyValue> *)0);
151 }
152 
153 sal_Bool SvBaseEventDescriptor::hasElements()
154 	throw(RuntimeException)
155 {
156 	return mnMacroItems != 0;
157 }
158 
159 sal_Bool SvBaseEventDescriptor::supportsService(const OUString& rServiceName)
160 	throw(RuntimeException)
161 {
162 	return sServiceName.equals(rServiceName);
163 }
164 
165 Sequence<OUString> SvBaseEventDescriptor::getSupportedServiceNames(void)
166 	throw(RuntimeException)
167 {
168 	Sequence<OUString> aSequence(1);
169 	aSequence[0] = sServiceName;
170 
171 	return aSequence;
172 }
173 
174 sal_uInt16 SvBaseEventDescriptor::mapNameToEventID(const OUString& rName) const
175 {
176 	// iterate over known event names
177 	for(sal_Int16 i = 0; i < mnMacroItems; i++)
178 	{
179 		if (0 == rName.compareToAscii(mpSupportedMacroItems[i].mpEventName))
180 		{
181 			return mpSupportedMacroItems[i].mnEvent;
182 		}
183 	}
184 
185 	// not found -> return zero
186 	return 0;
187 }
188 
189 OUString SvBaseEventDescriptor::mapEventIDToName(sal_uInt16 nPoolID) const
190 {
191 	// iterate over known event IDs
192 	for(sal_Int16 i = 0; i < mnMacroItems; i++)
193 	{
194 		if (nPoolID == mpSupportedMacroItems[i].mnEvent)
195 		{
196 			return OUString::createFromAscii(mpSupportedMacroItems[i].mpEventName);
197 		}
198 	}
199 
200 	// not found -> return empty string
201 	return OUString();
202 }
203 
204 sal_uInt16 SvBaseEventDescriptor::getMacroID(const OUString& rName) const
205 {
206 	return mapNameToEventID(rName);
207 }
208 
209 void SvBaseEventDescriptor::getAnyFromMacro(Any& rAny,
210 									   const SvxMacro& rMacro)
211 {
212 	sal_Bool bRetValueOK = sal_False;	// do we have a ret value?
213 
214 	if (rMacro.HasMacro())
215 	{
216 		switch (rMacro.GetScriptType())
217 		{
218 			case STARBASIC:
219 			{
220 				// create sequence
221 				Sequence<PropertyValue> aSequence(3);
222 				Any aTmp;
223 
224 				// create type
225 				PropertyValue aTypeValue;
226 				aTypeValue.Name = sEventType;
227 				aTmp <<= sStarBasic;
228 				aTypeValue.Value = aTmp;
229 				aSequence[0] = aTypeValue;
230 
231 				// macro name
232 				PropertyValue aNameValue;
233 				aNameValue.Name = sMacroName;
234 				OUString sNameTmp(rMacro.GetMacName());
235 				aTmp <<= sNameTmp;
236 				aNameValue.Value = aTmp;
237 				aSequence[1] = aNameValue;
238 
239 				// library name
240 				PropertyValue aLibValue;
241 				aLibValue.Name = sLibrary;
242 				OUString sLibTmp(rMacro.GetLibName());
243 				aTmp <<= sLibTmp;
244 				aLibValue.Value = aTmp;
245 				aSequence[2] = aLibValue;
246 
247 				rAny <<= aSequence;
248 				bRetValueOK = sal_True;
249 				break;
250 			}
251 			case EXTENDED_STYPE:
252 			{
253 				// create sequence
254 				Sequence<PropertyValue> aSequence(2);
255 				Any aTmp;
256 
257 				// create type
258 				PropertyValue aTypeValue;
259 				aTypeValue.Name = sEventType;
260 				aTmp <<= sScript;
261 				aTypeValue.Value = aTmp;
262 				aSequence[0] = aTypeValue;
263 
264 				// macro name
265 				PropertyValue aNameValue;
266 				aNameValue.Name = sScript;
267 				OUString sNameTmp(rMacro.GetMacName());
268 				aTmp <<= sNameTmp;
269 				aNameValue.Value = aTmp;
270 				aSequence[1] = aNameValue;
271 
272 				rAny <<= aSequence;
273 				bRetValueOK = sal_True;
274 				break;
275                         }
276 			case JAVASCRIPT:
277 			default:
278 				DBG_ERROR("not implemented");
279 		}
280 	}
281 	// else: bRetValueOK not set
282 
283 	// if we don't have a return value, make an empty one
284 	if (! bRetValueOK)
285 	{
286 		// create "None" macro
287 		Sequence<PropertyValue> aSequence(1);
288 
289 		PropertyValue aKindValue;
290 		aKindValue.Name = sEventType;
291 		Any aTmp;
292 		aTmp <<= sNone;
293 		aKindValue.Value = aTmp;
294 		aSequence[0] = aKindValue;
295 
296 		rAny <<= aSequence;
297 		bRetValueOK = sal_True;
298 	}
299 }
300 
301 
302 void SvBaseEventDescriptor::getMacroFromAny(
303 	SvxMacro& rMacro,
304 	const Any& rAny)
305 		throw ( IllegalArgumentException )
306 {
307 	// get sequence
308 	Sequence<PropertyValue> aSequence;
309 	rAny >>= aSequence;
310 
311 	// process ...
312 	sal_Bool bTypeOK = sal_False;
313 	sal_Bool bNone = sal_False;		// true if EventType=="None"
314 	enum ScriptType eType = EXTENDED_STYPE;
315 	OUString sScriptVal;
316 	OUString sMacroVal;
317 	OUString sLibVal;
318 	sal_Int32 nCount = aSequence.getLength();
319 	for (sal_Int32 i = 0; i < nCount; i++)
320 	{
321 		PropertyValue& aValue = aSequence[i];
322 		if (aValue.Name.equals(sEventType))
323 		{
324 			OUString sTmp;
325 			aValue.Value >>= sTmp;
326 			if (sTmp.equals(sStarBasic))
327 			{
328 				eType = STARBASIC;
329 				bTypeOK = sal_True;
330 			}
331 			else if (sTmp.equals(sJavaScript))
332 			{
333 				eType = JAVASCRIPT;
334 				bTypeOK = sal_True;
335 			}
336 			else if (sTmp.equals(sScript))
337 			{
338 				eType = EXTENDED_STYPE;
339 				bTypeOK = sal_True;
340 			}
341 			else if (sTmp.equals(sNone))
342 			{
343 				bNone = sal_True;
344 				bTypeOK = sal_True;
345 			}
346 			// else: unknown script type
347 		}
348 		else if (aValue.Name.equals(sMacroName))
349 		{
350 			aValue.Value >>= sMacroVal;
351 		}
352 		else if (aValue.Name.equals(sLibrary))
353 		{
354 			aValue.Value >>= sLibVal;
355 		}
356 		else if (aValue.Name.equals(sScript))
357 		{
358 			aValue.Value >>= sScriptVal;
359 		}
360 		// else: unknown PropertyValue -> ignore
361 	}
362 
363 	if (bTypeOK)
364 	{
365 		if (bNone)
366 		{
367 			// return empty macro
368 			rMacro = SvxMacro( sEmpty, sEmpty );
369 		}
370 		else
371 		{
372 			if (eType == STARBASIC)
373 			{
374 				// create macro and return
375 				SvxMacro aMacro(sMacroVal, sLibVal, eType);
376 				rMacro = aMacro;
377 			}
378 			else if (eType == EXTENDED_STYPE)
379 			{
380 				SvxMacro aMacro(sScriptVal, sScript);
381 				rMacro = aMacro;
382 			}
383 			else
384 			{
385 				// we can't process type: abort
386 				// TODO: JavaScript macros
387 				throw IllegalArgumentException();
388 			}
389 		}
390 	}
391 	else
392 	{
393 		// no valid type: abort
394 		throw IllegalArgumentException();
395 	}
396 }
397 
398 
399 
400 
401 //
402 // SvEventDescriptor
403 //
404 
405 
406 SvEventDescriptor::SvEventDescriptor(
407 	XInterface& rParent,
408 	const SvEventDescription* pSupportedMacroItems) :
409 		SvBaseEventDescriptor(pSupportedMacroItems),
410 		xParentRef(&rParent)
411 {
412 }
413 
414 
415 SvEventDescriptor::~SvEventDescriptor()
416 {
417 	// automatically release xParentRef !
418 }
419 
420 void SvEventDescriptor::replaceByName(
421 	const sal_uInt16 nEvent,
422 	const SvxMacro& rMacro)
423 		throw(
424 			IllegalArgumentException,
425 			NoSuchElementException,
426 			WrappedTargetException,
427 			RuntimeException)
428 {
429 	SvxMacroItem aItem(getMacroItemWhich());
430 	aItem.SetMacroTable(getMacroItem().GetMacroTable());
431 	aItem.SetMacro(nEvent, rMacro);
432 	setMacroItem(aItem);
433 }
434 
435 void SvEventDescriptor::getByName(
436 	SvxMacro& rMacro,
437 	const sal_uInt16 nEvent )
438 		throw(
439 			NoSuchElementException,
440 			WrappedTargetException,
441 			RuntimeException)
442 {
443 	const SvxMacroItem& rItem = getMacroItem();
444 	if( rItem.HasMacro( nEvent ) )
445 		rMacro = rItem.GetMacro(nEvent);
446 	else
447 	{
448 		SvxMacro aEmptyMacro(sEmpty, sEmpty);
449 		rMacro = aEmptyMacro;
450 	}
451 }
452 
453 
454 
455 
456 //
457 // SvDetachedEventDescriptor
458 //
459 
460 SvDetachedEventDescriptor::SvDetachedEventDescriptor(
461 	const SvEventDescription* pSupportedMacroItems) :
462 	SvBaseEventDescriptor(pSupportedMacroItems),
463 	sImplName(RTL_CONSTASCII_USTRINGPARAM(sAPI_SvDetachedEventDescriptor))
464 {
465 	// allocate aMacros
466 	aMacros = new SvxMacro*[mnMacroItems];
467 
468 	// ... and initialize
469 	for(sal_Int16 i = 0; i < mnMacroItems; i++)
470 	{
471 		aMacros[i] = NULL;
472 	}
473 }
474 
475 SvDetachedEventDescriptor::~SvDetachedEventDescriptor()
476 {
477 	// delete contents of aMacros
478 	for(sal_Int16 i = 0; i < mnMacroItems; i++)
479 	{
480 		if (NULL != aMacros[i])
481 			delete aMacros[i];
482 	}
483 
484     delete [] aMacros;
485 }
486 
487 sal_Int16 SvDetachedEventDescriptor::getIndex(const sal_uInt16 nID) const
488 {
489 	// iterate over supported events
490 	sal_Int16 nIndex = 0;
491 	while ( (mpSupportedMacroItems[nIndex].mnEvent != nID) &&
492 			(mpSupportedMacroItems[nIndex].mnEvent != 0)      )
493 	{
494 		nIndex++;
495 	}
496 	return (mpSupportedMacroItems[nIndex].mnEvent == nID) ? nIndex : -1;
497 }
498 
499 OUString SvDetachedEventDescriptor::getImplementationName()
500 	throw( ::com::sun::star::uno::RuntimeException )
501 {
502 	return sImplName;
503 }
504 
505 
506 void SvDetachedEventDescriptor::replaceByName(
507 	const sal_uInt16 nEvent,
508 	const SvxMacro& rMacro)
509 	throw(
510 		IllegalArgumentException,
511 		NoSuchElementException,
512 		WrappedTargetException,
513 		RuntimeException)
514 {
515 	sal_Int16 nIndex = getIndex(nEvent);
516 	if (-1 == nIndex)
517 		throw IllegalArgumentException();
518 
519 	aMacros[nIndex] = new SvxMacro(rMacro.GetMacName(), rMacro.GetLibName(),
520 								   rMacro.GetScriptType() );
521 }
522 
523 
524 void SvDetachedEventDescriptor::getByName(
525 	SvxMacro& rMacro,
526 	const sal_uInt16 nEvent )
527 	throw(
528 		NoSuchElementException,
529 		WrappedTargetException,
530 		RuntimeException)
531 {
532 	sal_Int16 nIndex = getIndex(nEvent);
533 	if (-1 == nIndex )
534 		throw NoSuchElementException();
535 
536 	if( aMacros[nIndex] )
537 		rMacro = (*aMacros[nIndex]);
538 }
539 
540 sal_Bool SvDetachedEventDescriptor::hasByName(
541 	const sal_uInt16 nEvent ) const		/// item ID of event
542 		throw(IllegalArgumentException)
543 {
544 	sal_Int16 nIndex = getIndex(nEvent);
545 	if (-1 == nIndex)
546 		throw IllegalArgumentException();
547 
548 	return (NULL == aMacros[nIndex]) ? sal_False : aMacros[nIndex]->HasMacro();
549 }
550 
551 
552 //
553 // SvMacroTableEventDescriptor
554 //
555 
556 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(const SvEventDescription* pSupportedMacroItems) :
557 	SvDetachedEventDescriptor(pSupportedMacroItems)
558 {
559 }
560 
561 SvMacroTableEventDescriptor::SvMacroTableEventDescriptor(
562 	const SvxMacroTableDtor& rMacroTable,
563 	const SvEventDescription* pSupportedMacroItems) :
564 		SvDetachedEventDescriptor(pSupportedMacroItems)
565 {
566 	copyMacrosFromTable(rMacroTable);
567 }
568 
569 SvMacroTableEventDescriptor::~SvMacroTableEventDescriptor()
570 {
571 }
572 
573 void SvMacroTableEventDescriptor::copyMacrosFromTable(
574 	const SvxMacroTableDtor& rMacroTable)
575 {
576 	for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != 0; i++)
577 	{
578 		const sal_uInt16 nEvent = mpSupportedMacroItems[i].mnEvent;
579 		const SvxMacro* pMacro = rMacroTable.Get(nEvent);
580 		if (NULL != pMacro)
581 			replaceByName(nEvent, *pMacro);
582 	}
583 
584 }
585 
586 void SvMacroTableEventDescriptor::copyMacrosIntoTable(
587 	SvxMacroTableDtor& rMacroTable)
588 {
589 	for(sal_Int16 i = 0; mpSupportedMacroItems[i].mnEvent != 0; i++)
590 	{
591 		const sal_uInt16 nEvent = mpSupportedMacroItems[i].mnEvent;
592 		if (hasByName(nEvent))
593 		{
594 			SvxMacro* pMacro = new SvxMacro(sEmpty, sEmpty);
595 			getByName(*pMacro, nEvent);
596 			rMacroTable.Insert(nEvent, pMacro);
597 		}
598 	}
599 }
600 
601 
602 
603