sd/source/ui/unoidl/randomnode.cxx

   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
  21 #include <com/sun/star/animations/XTimeContainer.hpp>
  22 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  23 #include <com/sun/star/animations/AnimationFill.hpp>
  24 #include <com/sun/star/animations/XAnimate.hpp>
  25 #include <com/sun/star/animations/AnimationRestart.hpp>
  26 #include <com/sun/star/animations/ParallelTimeContainer.hpp>
  27 #include <com/sun/star/lang/XServiceInfo.hpp>
  28 #include <com/sun/star/lang/XInitialization.hpp>
  29 #include <com/sun/star/container/XEnumerationAccess.hpp>
  30 #include <com/sun/star/util/XCloneable.hpp>
  31 #include <comphelper/processfactory.hxx>
  32
  33 #include <cppuhelper/implbase5.hxx>
  34 #include <osl/mutex.hxx>
  35 #include "CustomAnimationPreset.hxx"
  36
  37 using ::osl::Mutex;
  38 using ::osl::Guard;
  39
  40 using ::com::sun::star::uno::Reference;
  41 using ::com::sun::star::uno::RuntimeException;
  42 using ::com::sun::star::uno::Exception;
  43 using ::com::sun::star::uno::Sequence;
  44 using ::com::sun::star::uno::Any;
  45 using ::com::sun::star::uno::UNO_QUERY;
  46 using ::com::sun::star::uno::XInterface;
  47 using ::com::sun::star::lang::NoSupportException;
  48 using ::com::sun::star::beans::NamedValue;
  49 using ::com::sun::star::lang::IllegalArgumentException;
  50 using ::com::sun::star::container::NoSuchElementException;
  51 using ::com::sun::star::container::ElementExistException;
  52 using ::com::sun::star::lang::WrappedTargetException;
  53 using ::com::sun::star::container::XEnumeration;
  54 using ::com::sun::star::container::XEnumerationAccess;
  55 using ::com::sun::star::util::XCloneable;
  56 using ::com::sun::star::lang::XServiceInfo;
  57 using ::com::sun::star::lang::XInitialization;
  58 using ::com::sun::star::uno::Type;
  59 using ::com::sun::star::uno::XWeak;
  60 using ::com::sun::star::lang::XMultiServiceFactory;
  61 using ::com::sun::star::presentation::ParagraphTarget;
  62 using ::com::sun::star::drawing::XShape;
  63
  64 using namespace ::com::sun::star::animations;
  65 namespace sd
  66 {
  67
  68 typedef ::cppu::WeakImplHelper5< XTimeContainer, XEnumerationAccess, XCloneable, XServiceInfo, XInitialization > RandomAnimationNodeBase;
  69 class RandomAnimationNode : public RandomAnimationNodeBase
  70 {
  71 public:
  72     RandomAnimationNode( const RandomAnimationNode& rNode );
  73     RandomAnimationNode( sal_Int16 nPresetClass );
  74     RandomAnimationNode();
  75
  76     void init( sal_Int16 nPresetClass );
  77
  78     // XInitialization
  79     void SAL_CALL initialize( const Sequence< Any >& aArguments ) throw (Exception, RuntimeException);
  80
  81     // XChild
  82     Reference< XInterface > SAL_CALL getParent(  ) throw (RuntimeException);
  83     void SAL_CALL setParent( const Reference< XInterface >& Parent ) throw (NoSupportException, RuntimeException);
  84
  85     // XCloneable
  86     virtual Reference< XCloneable > SAL_CALL createClone() throw (RuntimeException);
  87
  88     // XServiceInfo
  89     OUString SAL_CALL getImplementationName() throw();
  90     Sequence< OUString > SAL_CALL getSupportedServiceNames(void) throw();
  91     sal_Bool SAL_CALL supportsService(const OUString& ServiceName) throw();
  92
  93     // XAnimationNode
  94     ::sal_Int16 SAL_CALL getType() throw (RuntimeException);
  95     Any SAL_CALL getBegin() throw (RuntimeException);
  96     void SAL_CALL setBegin( const Any& _begin ) throw (RuntimeException);
  97     Any SAL_CALL getDuration() throw (RuntimeException);
  98     void SAL_CALL setDuration( const Any& _duration ) throw (RuntimeException);
  99     Any SAL_CALL getEnd() throw (RuntimeException);
 100     void SAL_CALL setEnd( const Any& _end ) throw (RuntimeException);
 101     Any SAL_CALL getEndSync() throw (RuntimeException);
 102     void SAL_CALL setEndSync( const Any& _endsync ) throw (RuntimeException);
 103     Any SAL_CALL getRepeatCount() throw (RuntimeException);
 104     void SAL_CALL setRepeatCount( const Any& _repeatcount ) throw (RuntimeException);
 105     Any SAL_CALL getRepeatDuration() throw (RuntimeException);
 106     void SAL_CALL setRepeatDuration( const Any& _repeatduration ) throw (RuntimeException);
 107     ::sal_Int16 SAL_CALL getFill() throw (RuntimeException);
 108     void SAL_CALL setFill( ::sal_Int16 _fill ) throw (RuntimeException);
 109     ::sal_Int16 SAL_CALL getFillDefault() throw (RuntimeException);
 110     void SAL_CALL setFillDefault( ::sal_Int16 _filldefault ) throw (RuntimeException);
 111     ::sal_Int16 SAL_CALL getRestart() throw (RuntimeException);
 112     void SAL_CALL setRestart( ::sal_Int16 _restart ) throw (RuntimeException);
 113     ::sal_Int16 SAL_CALL getRestartDefault() throw (RuntimeException);
 114     void SAL_CALL setRestartDefault( ::sal_Int16 _restartdefault ) throw (RuntimeException);
 115     double SAL_CALL getAcceleration() throw (RuntimeException);
 116     void SAL_CALL setAcceleration( double _acceleration ) throw (RuntimeException);
 117     double SAL_CALL getDecelerate() throw (RuntimeException);
 118     void SAL_CALL setDecelerate( double _decelerate ) throw (RuntimeException);
 119     ::sal_Bool SAL_CALL getAutoReverse() throw (RuntimeException);
 120     void SAL_CALL setAutoReverse( ::sal_Bool _autoreverse ) throw (RuntimeException);
 121     Sequence< NamedValue > SAL_CALL getUserData() throw (RuntimeException);
 122     void SAL_CALL setUserData( const Sequence< NamedValue >& _userdata ) throw (RuntimeException);
 123
 124     // XElementAccess
 125     virtual Type SAL_CALL getElementType() throw (RuntimeException);
 126     virtual sal_Bool SAL_CALL hasElements() throw (RuntimeException);
 127
 128     // XEnumerationAccess
 129     virtual Reference< XEnumeration > SAL_CALL createEnumeration() throw (RuntimeException);
 130
 131     // XTimeContainer
 132     Reference< XAnimationNode > SAL_CALL insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) throw (IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException);
 133     Reference< XAnimationNode > SAL_CALL insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) throw (IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException);
 134     Reference< XAnimationNode > SAL_CALL replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& oldChild ) throw (IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException);
 135     Reference< XAnimationNode > SAL_CALL removeChild( const Reference< XAnimationNode >& oldChild ) throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException);
 136     Reference< XAnimationNode > SAL_CALL appendChild( const Reference< XAnimationNode >& newChild ) throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException);
 137
 138 private:
 139     // our first, last and only protection from mutli-threads!
 140     Mutex maMutex;
 141
 142     sal_Int16 mnPresetClass;
 143     Reference< XInterface > mxParent;
 144
 145     Any maBegin, maDuration, maEnd, maEndSync, maRepeatCount, maRepeatDuration, maTarget;
 146     sal_Int16 mnFill, mnFillDefault, mnRestart, mnRestartDefault;
 147     double mfAcceleration, mfDecelerate;
 148     sal_Bool mbAutoReverse;
 149     Sequence< NamedValue > maUserData;
 150
 151     Reference< XAnimate > mxFirstNode;
 152 };
 153
 154 // --------------------------------------------------------------------
 155
 156 static const sal_Char* pSN1 = "com.sun.star.animations.ParallelTimeContainer";
 157 static const sal_Char* pSN2 = "com.sun.star.comp.sd.RandomAnimationNode";
 158
 159 // --------------------------------------------------------------------
 160
 161 SD_DLLPUBLIC Reference< XInterface > RandomAnimationNode_createInstance( sal_Int16 nPresetClass )
 162 {
 163     Reference< XInterface > xInt( static_cast<XWeak*>( new RandomAnimationNode( nPresetClass ) ) );
 164     return xInt;
 165 }
 166
 167 // --------------------------------------------------------------------
 168
 169 Reference< XInterface > SAL_CALL RandomNode_createInstance( const Reference< XMultiServiceFactory > &  )
 170 {
 171     Reference< XInterface > xInt( static_cast<XWeak*>( new RandomAnimationNode() ) );
 172     return xInt;
 173 }
 174
 175 // --------------------------------------------------------------------
 176
 177 OUString RandomNode__getImplementationName() throw( RuntimeException )
 178 {
 179     return OUString( "sd::RandomAnimationNode" ) ;
 180 }
 181
 182 // --------------------------------------------------------------------
 183
 184 Sequence< OUString > SAL_CALL RandomNode_getSupportedServiceNames() throw( RuntimeException )
 185 {
 186     static const OUString aSN2( OUString::createFromAscii( pSN2 ) );
 187     Sequence< OUString > aSeq( &aSN2, 1 );
 188     return aSeq;
 189 }
 190
 191 // --------------------------------------------------------------------
 192
 193 RandomAnimationNode::RandomAnimationNode( const RandomAnimationNode& rNode )
 194 :   RandomAnimationNodeBase(),
 195     mnPresetClass( rNode.mnPresetClass ),
 196     maBegin( rNode.maBegin ),
 197     maDuration( rNode.maDuration ),
 198     maEnd( rNode.maEnd ),
 199     maEndSync( rNode.maEndSync ),
 200     maRepeatCount( rNode.maRepeatCount ),
 201     maRepeatDuration( rNode.maRepeatDuration ),
 202     maTarget( rNode.maTarget ),
 203     mnFill( rNode.mnFill ),
 204     mnFillDefault( rNode.mnFillDefault ),
 205     mnRestart( rNode.mnRestart ),
 206     mnRestartDefault( rNode.mnRestartDefault ),
 207     mfAcceleration( rNode.mfAcceleration ),
 208     mfDecelerate( rNode.mfDecelerate ),
 209     mbAutoReverse( rNode.mbAutoReverse ),
 210     maUserData( rNode.maUserData )
 211 {
 212 }
 213
 214 // --------------------------------------------------------------------
 215
 216 RandomAnimationNode::RandomAnimationNode( sal_Int16 nPresetClass )
 217 {
 218     init( nPresetClass );
 219 }
 220
 221 RandomAnimationNode::RandomAnimationNode()
 222 {
 223     init( 1 );
 224 }
 225
 226 void RandomAnimationNode::init( sal_Int16 nPresetClass )
 227 {
 228     mnPresetClass = nPresetClass;
 229     mnFill = AnimationFill::DEFAULT;
 230     mnFillDefault = AnimationFill::INHERIT;
 231     mnRestart = AnimationRestart::DEFAULT;
 232     mnRestartDefault = AnimationRestart::INHERIT;
 233     mfAcceleration = 0.0;
 234     mfDecelerate = 0.0;
 235     mbAutoReverse = sal_False;
 236 }
 237
 238 // --------------------------------------------------------------------
 239
 240 // XInitialization
 241 void SAL_CALL RandomAnimationNode::initialize( const Sequence< Any >& aArguments ) throw (Exception, RuntimeException)
 242 {
 243     if( aArguments.getLength() != 1 )
 244         throw IllegalArgumentException();
 245
 246     if( aArguments[0].getValueType() == ::getCppuType((const sal_Int16*)0) )
 247     {
 248         aArguments[0] >>= mnPresetClass;
 249     }
 250     else if( aArguments[0].getValueType() != ::getCppuType((const ParagraphTarget*)0) )
 251     {
 252         Reference< XShape > xShape;
 253         aArguments[0] >>= xShape;
 254         if( !xShape.is() )
 255             throw IllegalArgumentException();
 256     }
 257     maTarget = aArguments[0];
 258 }
 259
 260 // --------------------------------------------------------------------
 261
 262 // XAnimationNode
 263 sal_Int16 SAL_CALL RandomAnimationNode::getType() throw (RuntimeException)
 264 {
 265     Guard< Mutex > aGuard( maMutex );
 266     return ::com::sun::star::animations::AnimationNodeType::PAR;
 267 }
 268
 269 // --------------------------------------------------------------------
 270
 271 // XAnimationNode
 272 Any SAL_CALL RandomAnimationNode::getBegin() throw (RuntimeException)
 273 {
 274     Guard< Mutex > aGuard( maMutex );
 275     return maBegin;
 276 }
 277
 278 // --------------------------------------------------------------------
 279
 280 // XAnimationNode
 281 void SAL_CALL RandomAnimationNode::setBegin( const Any& _begin ) throw (RuntimeException)
 282 {
 283     Guard< Mutex > aGuard( maMutex );
 284     maBegin = _begin;
 285 }
 286
 287 // --------------------------------------------------------------------
 288
 289 // XAnimationNode
 290 Any SAL_CALL RandomAnimationNode::getDuration() throw (RuntimeException)
 291 {
 292     Guard< Mutex > aGuard( maMutex );
 293     return maDuration;
 294 }
 295
 296 // --------------------------------------------------------------------
 297
 298 // XAnimationNode
 299 void SAL_CALL RandomAnimationNode::setDuration( const Any& _duration ) throw (RuntimeException)
 300 {
 301     Guard< Mutex > aGuard( maMutex );
 302     maDuration = _duration;
 303 }
 304
 305 // --------------------------------------------------------------------
 306
 307 // XAnimationNode
 308 Any SAL_CALL RandomAnimationNode::getEnd() throw (RuntimeException)
 309 {
 310     Guard< Mutex > aGuard( maMutex );
 311     return maEnd;
 312 }
 313
 314 // --------------------------------------------------------------------
 315
 316 // XAnimationNode
 317 void SAL_CALL RandomAnimationNode::setEnd( const Any& _end ) throw (RuntimeException)
 318 {
 319     Guard< Mutex > aGuard( maMutex );
 320     maEnd = _end;
 321 }
 322
 323 // --------------------------------------------------------------------
 324
 325 // XAnimationNode
 326 Any SAL_CALL RandomAnimationNode::getEndSync() throw (RuntimeException)
 327 {
 328     Guard< Mutex > aGuard( maMutex );
 329     return maEndSync;
 330 }
 331
 332 // --------------------------------------------------------------------
 333
 334 // XAnimationNode
 335 void SAL_CALL RandomAnimationNode::setEndSync( const Any& _endsync ) throw (RuntimeException)
 336 {
 337     Guard< Mutex > aGuard( maMutex );
 338     maEndSync = _endsync;
 339 }
 340
 341 // --------------------------------------------------------------------
 342
 343 // XAnimationNode
 344 Any SAL_CALL RandomAnimationNode::getRepeatCount() throw (RuntimeException)
 345 {
 346     Guard< Mutex > aGuard( maMutex );
 347     return maRepeatCount;
 348 }
 349
 350 // --------------------------------------------------------------------
 351
 352 // XAnimationNode
 353 void SAL_CALL RandomAnimationNode::setRepeatCount( const Any& _repeatcount ) throw (RuntimeException)
 354 {
 355     Guard< Mutex > aGuard( maMutex );
 356     maRepeatCount = _repeatcount;
 357 }
 358
 359 // --------------------------------------------------------------------
 360
 361 // XAnimationNode
 362 Any SAL_CALL RandomAnimationNode::getRepeatDuration() throw (RuntimeException)
 363 {
 364     Guard< Mutex > aGuard( maMutex );
 365     return maRepeatDuration;
 366 }
 367
 368 // --------------------------------------------------------------------
 369
 370 // XAnimationNode
 371 void SAL_CALL RandomAnimationNode::setRepeatDuration( const Any& _repeatduration ) throw (RuntimeException)
 372 {
 373     Guard< Mutex > aGuard( maMutex );
 374     maRepeatDuration = _repeatduration;
 375 }
 376
 377 // --------------------------------------------------------------------
 378
 379 // XAnimationNode
 380 sal_Int16 SAL_CALL RandomAnimationNode::getFill() throw (RuntimeException)
 381 {
 382     Guard< Mutex > aGuard( maMutex );
 383     return mnFill;
 384 }
 385
 386 // --------------------------------------------------------------------
 387
 388 // XAnimationNode
 389 void SAL_CALL RandomAnimationNode::setFill( sal_Int16 _fill ) throw (RuntimeException)
 390 {
 391     Guard< Mutex > aGuard( maMutex );
 392     mnFill = _fill;
 393 }
 394
 395 // --------------------------------------------------------------------
 396
 397 // XAnimationNode
 398 sal_Int16 SAL_CALL RandomAnimationNode::getFillDefault() throw (RuntimeException)
 399 {
 400     Guard< Mutex > aGuard( maMutex );
 401     return mnFillDefault;
 402 }
 403
 404 // --------------------------------------------------------------------
 405
 406 // XAnimationNode
 407 void SAL_CALL RandomAnimationNode::setFillDefault( sal_Int16 _filldefault ) throw (RuntimeException)
 408 {
 409     Guard< Mutex > aGuard( maMutex );
 410     mnFillDefault = _filldefault;
 411 }
 412
 413 // --------------------------------------------------------------------
 414
 415 // XAnimationNode
 416 sal_Int16 SAL_CALL RandomAnimationNode::getRestart() throw (RuntimeException)
 417 {
 418     Guard< Mutex > aGuard( maMutex );
 419     return mnRestart;
 420 }
 421
 422 // --------------------------------------------------------------------
 423
 424 // XAnimationNode
 425 void SAL_CALL RandomAnimationNode::setRestart( sal_Int16 _restart ) throw (RuntimeException)
 426 {
 427     Guard< Mutex > aGuard( maMutex );
 428     mnRestart = _restart;
 429 }
 430
 431 // --------------------------------------------------------------------
 432
 433 // XAnimationNode
 434 sal_Int16 SAL_CALL RandomAnimationNode::getRestartDefault() throw (RuntimeException)
 435 {
 436     Guard< Mutex > aGuard( maMutex );
 437     return mnRestartDefault;
 438 }
 439
 440 // --------------------------------------------------------------------
 441
 442 // XAnimationNode
 443 void SAL_CALL RandomAnimationNode::setRestartDefault( sal_Int16 _restartdefault ) throw (RuntimeException)
 444 {
 445     Guard< Mutex > aGuard( maMutex );
 446     mnRestartDefault = _restartdefault;
 447 }
 448
 449 // --------------------------------------------------------------------
 450
 451 // XAnimationNode
 452 double SAL_CALL RandomAnimationNode::getAcceleration() throw (RuntimeException)
 453 {
 454     Guard< Mutex > aGuard( maMutex );
 455     return mfAcceleration;
 456 }
 457
 458 // --------------------------------------------------------------------
 459
 460 // XAnimationNode
 461 void SAL_CALL RandomAnimationNode::setAcceleration( double _acceleration ) throw (RuntimeException)
 462 {
 463     Guard< Mutex > aGuard( maMutex );
 464     mfAcceleration = _acceleration;
 465 }
 466
 467 // --------------------------------------------------------------------
 468
 469 // XAnimationNode
 470 double SAL_CALL RandomAnimationNode::getDecelerate() throw (RuntimeException)
 471 {
 472     Guard< Mutex > aGuard( maMutex );
 473     return mfDecelerate;
 474 }
 475
 476 // --------------------------------------------------------------------
 477
 478 // XAnimationNode
 479 void SAL_CALL RandomAnimationNode::setDecelerate( double _decelerate ) throw (RuntimeException)
 480 {
 481     Guard< Mutex > aGuard( maMutex );
 482     mfDecelerate = _decelerate;
 483 }
 484
 485 // --------------------------------------------------------------------
 486
 487 // XAnimationNode
 488 sal_Bool SAL_CALL RandomAnimationNode::getAutoReverse() throw (RuntimeException)
 489 {
 490     Guard< Mutex > aGuard( maMutex );
 491     return mbAutoReverse;
 492 }
 493
 494 // --------------------------------------------------------------------
 495
 496 // XAnimationNode
 497 void SAL_CALL RandomAnimationNode::setAutoReverse( sal_Bool _autoreverse ) throw (RuntimeException)
 498 {
 499     Guard< Mutex > aGuard( maMutex );
 500     mbAutoReverse = _autoreverse;
 501 }
 502
 503 // --------------------------------------------------------------------
 504
 505 Sequence< NamedValue > SAL_CALL RandomAnimationNode::getUserData() throw (RuntimeException)
 506 {
 507     Guard< Mutex > aGuard( maMutex );
 508     return maUserData;
 509 }
 510
 511 // --------------------------------------------------------------------
 512
 513 void SAL_CALL RandomAnimationNode::setUserData( const Sequence< NamedValue >& _userdata ) throw (RuntimeException)
 514 {
 515     Guard< Mutex > aGuard( maMutex );
 516     maUserData = _userdata;
 517 }
 518
 519 // --------------------------------------------------------------------
 520
 521 // XChild
 522 Reference< XInterface > SAL_CALL RandomAnimationNode::getParent() throw (RuntimeException)
 523 {
 524     Guard< Mutex > aGuard( maMutex );
 525     return mxParent;
 526 }
 527
 528 // --------------------------------------------------------------------
 529
 530 // XChild
 531 void SAL_CALL RandomAnimationNode::setParent( const Reference< XInterface >& Parent ) throw (NoSupportException, RuntimeException)
 532 {
 533     Guard< Mutex > aGuard( maMutex );
 534     mxParent = Parent;
 535 }
 536
 537 // --------------------------------------------------------------------
 538
 539 // XCloneable
 540 Reference< XCloneable > SAL_CALL RandomAnimationNode::createClone() throw (RuntimeException)
 541 {
 542     Reference< XCloneable > xNewNode( new RandomAnimationNode( *this ) );
 543     return xNewNode;
 544 }
 545
 546 // --------------------------------------------------------------------
 547
 548 // XElementAccess
 549 Type SAL_CALL RandomAnimationNode::getElementType() throw (RuntimeException)
 550 {
 551     return ::getCppuType((const Reference< XAnimationNode >*)0);
 552 }
 553
 554 // --------------------------------------------------------------------
 555
 556 // XElementAccess
 557 sal_Bool SAL_CALL RandomAnimationNode::hasElements() throw (RuntimeException)
 558 {
 559     return sal_True;
 560 }
 561
 562 // --------------------------------------------------------------------
 563
 564 // XEnumerationAccess
 565 Reference< XEnumeration > SAL_CALL RandomAnimationNode::createEnumeration()
 566     throw (RuntimeException)
 567 {
 568     Guard< Mutex > aGuard( maMutex );
 569
 570     if( !maTarget.hasValue() && mxFirstNode.is() )
 571     {
 572         Any aTarget( mxFirstNode->getTarget() );
 573         if( aTarget.hasValue() )
 574         {
 575             maTarget = aTarget;
 576             mxFirstNode.clear();
 577         }
 578     }
 579
 580     Reference< XEnumeration > xEnum;
 581
 582     Reference< XEnumerationAccess > aEnumAccess( CustomAnimationPresets::getCustomAnimationPresets().getRandomPreset( mnPresetClass ), UNO_QUERY );
 583
 584     if( aEnumAccess.is() )
 585     {
 586         Reference< XEnumeration > xEnumeration( aEnumAccess->createEnumeration(), UNO_QUERY );
 587         if( xEnumeration.is() )
 588         {
 589             while( xEnumeration->hasMoreElements() )
 590             {
 591                 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
 592                 if( xAnimate.is() )
 593                     xAnimate->setTarget( maTarget );
 594             }
 595         }
 596         xEnum = aEnumAccess->createEnumeration();
 597     }
 598     else
 599     {
 600         // no presets? give empty node!
 601         Reference< XParallelTimeContainer > xTimeContainer  = ParallelTimeContainer::create( comphelper::getProcessComponentContext() );
 602         xEnum = xTimeContainer->createEnumeration();
 603     }
 604
 605     return xEnum;
 606 }
 607
 608 // --------------------------------------------------------------------
 609
 610
 611 // XTimeContainer
 612 Reference< XAnimationNode > SAL_CALL RandomAnimationNode::insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >&  )
 613     throw (IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException)
 614 {
 615     return appendChild( newChild );
 616 }
 617
 618 // --------------------------------------------------------------------
 619
 620 // XTimeContainer
 621 Reference< XAnimationNode > SAL_CALL RandomAnimationNode::insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >&  )
 622     throw (IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException)
 623 {
 624     return appendChild( newChild );
 625 }
 626
 627 // --------------------------------------------------------------------
 628
 629 // XTimeContainer
 630 Reference< XAnimationNode > SAL_CALL RandomAnimationNode::replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >&  )
 631     throw( IllegalArgumentException, NoSuchElementException, ElementExistException, WrappedTargetException, RuntimeException)
 632 {
 633     return appendChild( newChild );
 634 }
 635
 636 // --------------------------------------------------------------------
 637
 638 // XTimeContainer
 639 Reference< XAnimationNode > SAL_CALL RandomAnimationNode::removeChild( const Reference< XAnimationNode >& oldChild )
 640     throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
 641 {
 642     return oldChild;
 643 }
 644
 645 // --------------------------------------------------------------------
 646
 647 // XTimeContainer
 648 Reference< XAnimationNode > SAL_CALL RandomAnimationNode::appendChild( const Reference< XAnimationNode >& newChild )
 649     throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
 650 {
 651     Reference< XAnimate > xAnimate( newChild, UNO_QUERY );
 652     if( xAnimate.is() )
 653     {
 654         Any aTarget( xAnimate->getTarget() );
 655         if( aTarget.hasValue() )
 656             maTarget = aTarget;
 657     }
 658
 659     if( !maTarget.hasValue() && !mxFirstNode.is() )
 660         mxFirstNode = xAnimate;
 661
 662     return newChild;
 663 }
 664
 665 // XServiceInfo
 666 OUString RandomAnimationNode::getImplementationName() throw()
 667 {
 668     return RandomNode__getImplementationName();
 669 }
 670
 671 // XServiceInfo
 672 sal_Bool RandomAnimationNode::supportsService(const OUString& ServiceName) throw()
 673 {
 674     return ServiceName.equalsAscii( pSN1 ) || ServiceName.equalsAscii( pSN2 );
 675 }
 676
 677 // XServiceInfo
 678 Sequence< OUString > RandomAnimationNode::getSupportedServiceNames(void) throw()
 679 {
 680     return RandomNode_getSupportedServiceNames();
 681 }
 682
 683 }
 684
 685 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */