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