animations/source/animcore/targetpropertiescreator.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: targetpropertiescreator.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <com/sun/star/uno/XComponentContext.hpp>
  32 #include <com/sun/star/lang/XServiceInfo.hpp>
  33 #include <com/sun/star/lang/XTypeProvider.hpp>
  34 #include <com/sun/star/animations/XTargetPropertiesCreator.hpp>
  35 #include <com/sun/star/animations/XIterateContainer.hpp>
  36 #include <com/sun/star/animations/TargetProperties.hpp>
  37 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  38 #include <com/sun/star/registry/XRegistryKey.hpp>
  39 #include <com/sun/star/lang/XInitialization.hpp>
  40 #include <com/sun/star/lang/XServiceName.hpp>
  41 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  42 #include <com/sun/star/drawing/XShape.hpp>
  43 #include <com/sun/star/animations/AnimationNodeType.hpp>
  44 #include <com/sun/star/animations/XAnimate.hpp>
  45 #include <cppuhelper/compbase3.hxx>
  46 #include <cppuhelper/factory.hxx>
  47 #include <cppuhelper/implementationentry.hxx>
  48 #include <comphelper/optionalvalue.hxx>
  49 #include <comphelper/broadcasthelper.hxx>
  50 #include <comphelper/sequence.hxx>
  51
  52 #include <animations/animationnodehelper.hxx>
  53
  54 #include <vector>
  55 #include <hash_map>
  56
  57
  58 using namespace ::com::sun::star;
  59
  60 #define IMPLEMENTATION_NAME "animcore::TargetPropertiesCreator"
  61 #define SERVICE_NAME "com.sun.star.animations.TargetPropertiesCreator"
  62
  63 namespace animcore
  64 {
  65     typedef ::cppu::WeakComponentImplHelper3< ::com::sun::star::animations::XTargetPropertiesCreator,
  66                                               lang::XServiceInfo,
  67                                               lang::XServiceName >  TargetPropertiesCreator_Base;
  68
  69     class TargetPropertiesCreator : public ::comphelper::OBaseMutex,
  70                                     public TargetPropertiesCreator_Base
  71     {
  72     public:
  73         static uno::Reference< uno::XInterface > SAL_CALL createInstance( const uno::Reference< uno::XComponentContext >& xContext ) throw ( uno::Exception )
  74         {
  75             return uno::Reference< uno::XInterface >( static_cast<cppu::OWeakObject*>(new TargetPropertiesCreator( xContext )) );
  76         }
  77
  78         /// Dispose all internal references
  79         virtual void SAL_CALL disposing();
  80
  81         // XTargetPropertiesCreator
  82         virtual uno::Sequence< animations::TargetProperties > SAL_CALL createInitialTargetProperties( const uno::Reference< animations::XAnimationNode >& rootNode ) throw (uno::RuntimeException);
  83
  84         // XServiceInfo
  85         virtual ::rtl::OUString SAL_CALL getImplementationName() throw( uno::RuntimeException );
  86         virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException );
  87         virtual uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames()  throw( uno::RuntimeException );
  88
  89         // XServiceName
  90         virtual ::rtl::OUString SAL_CALL getServiceName(  ) throw (uno::RuntimeException);
  91
  92     protected:
  93         ~TargetPropertiesCreator(); // we're a ref-counted UNO class. _We_ destroy ourselves.
  94
  95     private:
  96         // default: disabled copy/assignment
  97         TargetPropertiesCreator(const TargetPropertiesCreator&);
  98         TargetPropertiesCreator& operator=( const TargetPropertiesCreator& );
  99
 100         TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >& rxContext );
 101     };
 102
 103     // --------------------------------------------------------------------
 104
 105     uno::Reference< uno::XInterface > SAL_CALL createInstance_TargetPropertiesCreator( const uno::Reference< uno::XComponentContext > & rSMgr ) throw (uno::Exception)
 106     {
 107         return TargetPropertiesCreator::createInstance( rSMgr );
 108     }
 109
 110     ::rtl::OUString getImplementationName_TargetPropertiesCreator()
 111     {
 112         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) );
 113     }
 114
 115     uno::Sequence< ::rtl::OUString > getSupportedServiceNames_TargetPropertiesCreator(void)
 116     {
 117         uno::Sequence< ::rtl::OUString > aRet(1);
 118         aRet.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
 119         return aRet;
 120     }
 121
 122     // --------------------------------------------------------------------
 123
 124     namespace
 125     {
 126         // Vector containing all properties for a given shape
 127         typedef ::std::vector< beans::NamedValue > VectorOfNamedValues;
 128
 129         /** The hash map key
 130
 131             This key contains both XShape reference and a paragraph
 132             index, as we somehow have to handle shape and paragraph
 133             targets with the same data structure.
 134          */
 135         struct ShapeHashKey
 136         {
 137             /// Shape target
 138             uno::Reference< drawing::XShape >   mxRef;
 139
 140             /** Paragraph index.
 141
 142                 If this is a pure shape target, mnParagraphIndex is
 143                 set to -1.
 144              */
 145             sal_Int16                                                   mnParagraphIndex;
 146
 147             /// Comparison needed for hash_map
 148             bool operator==( const ShapeHashKey& rRHS ) const
 149             {
 150                 return mxRef == rRHS.mxRef && mnParagraphIndex == rRHS.mnParagraphIndex;
 151             }
 152         };
 153
 154         // A hash map which maps a XShape to the corresponding vector of initial properties
 155         typedef ::std::hash_map< ShapeHashKey,
 156                                  VectorOfNamedValues,
 157                                  ::std::size_t (*)(const ShapeHashKey&) > XShapeHash;
 158
 159         ::std::size_t refhasher( const ShapeHashKey& rKey )
 160         {
 161             // TODO(P2): Maybe a better hash function would be to
 162             // spread mnParagraphIndex to 32 bit: a0b0c0d0e0... Hakmem
 163             // should have a formula.
 164             //
 165             // Yes it has:
 166             // x = (x & 0x0000FF00) << 8) | (x >> 8) & 0x0000FF00 | x & 0xFF0000FF;
 167             // x = (x & 0x00F000F0) << 4) | (x >> 4) & 0x00F000F0 | x & 0xF00FF00F;
 168             // x = (x & 0x0C0C0C0C) << 2) | (x >> 2) & 0x0C0C0C0C | x & 0xC3C3C3C3;
 169             // x = (x & 0x22222222) << 1) | (x >> 1) & 0x22222222 | x & 0x99999999;
 170             //
 171             // Costs about 17 cycles on a RISC machine with infinite
 172             // instruction level parallelism (~42 basic
 173             // instructions). Thus I truly doubt this pays off...
 174             return reinterpret_cast< ::std::size_t >(rKey.mxRef.get()) ^ (rKey.mnParagraphIndex << 16L);
 175         }
 176
 177
 178         class NodeFunctor
 179         {
 180         public:
 181             explicit NodeFunctor( XShapeHash& rShapeHash ) :
 182                 mrShapeHash( rShapeHash ),
 183                 mxTargetShape(),
 184                 mnParagraphIndex( -1 )
 185             {
 186             }
 187
 188             NodeFunctor( XShapeHash&                                                            rShapeHash,
 189                          const uno::Reference< drawing::XShape >&       rTargetShape,
 190                          sal_Int16                                                                      nParagraphIndex ) :
 191                 mrShapeHash( rShapeHash ),
 192                 mxTargetShape( rTargetShape ),
 193                 mnParagraphIndex( nParagraphIndex )
 194             {
 195             }
 196
 197             void operator()( const uno::Reference< animations::XAnimationNode >& xNode ) const
 198             {
 199                 if( !xNode.is() )
 200                 {
 201                     OSL_ENSURE( false,
 202                                 "AnimCore: NodeFunctor::operator(): invalid XAnimationNode" );
 203                     return;
 204                 }
 205
 206                 uno::Reference< drawing::XShape > xTargetShape( mxTargetShape );
 207                 sal_Int16                                                 nParagraphIndex( mnParagraphIndex );
 208
 209                 switch( xNode->getType() )
 210                 {
 211                     case animations::AnimationNodeType::ITERATE:
 212                     {
 213                         // extract target shape from iterate node
 214                         // (will override the target for all children)
 215                         // --------------------------------------------------
 216
 217                         uno::Reference< animations::XIterateContainer > xIterNode( xNode,
 218                                                                                    uno::UNO_QUERY );
 219
 220                         // TODO(E1): I'm not too sure what to expect here...
 221                         if( !xIterNode->getTarget().hasValue() )
 222                         {
 223                             OSL_ENSURE( false,
 224                                         "animcore: NodeFunctor::operator(): no target on ITERATE node" );
 225                             return;
 226                         }
 227
 228                         xTargetShape.set( xIterNode->getTarget(),
 229                                           uno::UNO_QUERY );
 230
 231                         if( !xTargetShape.is() )
 232                         {
 233                             ::com::sun::star::presentation::ParagraphTarget aTarget;
 234
 235                             // no shape provided. Maybe a ParagraphTarget?
 236                             if( !(xIterNode->getTarget() >>= aTarget) )
 237                             {
 238                                 OSL_ENSURE( false,
 239                                             "animcore: NodeFunctor::operator(): could not extract any "
 240                                             "target information" );
 241                                 return;
 242                             }
 243
 244                             xTargetShape = aTarget.Shape;
 245                             nParagraphIndex = aTarget.Paragraph;
 246
 247                             if( !xTargetShape.is() )
 248                             {
 249                                 OSL_ENSURE( false,
 250                                             "animcore: NodeFunctor::operator(): invalid shape in ParagraphTarget" );
 251                                 return;
 252                             }
 253                         }
 254                     }
 255                         // FALLTHROUGH intended
 256                     case animations::AnimationNodeType::PAR:
 257                         // FALLTHROUGH intended
 258                     case animations::AnimationNodeType::SEQ:
 259                     {
 260                         NodeFunctor aFunctor( mrShapeHash,
 261                                               xTargetShape,
 262                                               nParagraphIndex );
 263                         if( !::anim::for_each_childNode( xNode,
 264                                                          aFunctor ) )
 265                         {
 266                             OSL_ENSURE( false,
 267                                         "AnimCore: NodeFunctor::operator(): child node iteration failed, "
 268                                         "or extraneous container nodes encountered" );
 269                         }
 270                     }
 271                     break;
 272
 273                     case animations::AnimationNodeType::CUSTOM:
 274                         // FALLTHROUGH intended
 275                     case animations::AnimationNodeType::ANIMATE:
 276                         // FALLTHROUGH intended
 277                     case animations::AnimationNodeType::ANIMATEMOTION:
 278                         // FALLTHROUGH intended
 279                     case animations::AnimationNodeType::ANIMATECOLOR:
 280                         // FALLTHROUGH intended
 281                     case animations::AnimationNodeType::ANIMATETRANSFORM:
 282                         // FALLTHROUGH intended
 283                     case animations::AnimationNodeType::TRANSITIONFILTER:
 284                         // FALLTHROUGH intended
 285                     case animations::AnimationNodeType::AUDIO:
 286                         // FALLTHROUGH intended
 287                     default:
 288                         // ignore this node, no valuable content for now.
 289                         break;
 290
 291                     case animations::AnimationNodeType::SET:
 292                     {
 293                         // evaluate set node content
 294                         uno::Reference< animations::XAnimate > xAnimateNode( xNode,
 295                                                                              uno::UNO_QUERY );
 296
 297                         if( !xAnimateNode.is() )
 298                             break; // invalid node
 299
 300                         // determine target shape (if any)
 301                         ShapeHashKey aTarget;
 302                         if( xTargetShape.is() )
 303                         {
 304                             // override target shape with parent-supplied
 305                             aTarget.mxRef = xTargetShape;
 306                             aTarget.mnParagraphIndex = nParagraphIndex;
 307                         }
 308                         else
 309                         {
 310                             // no parent-supplied target, retrieve
 311                             // node target
 312                             if( (xAnimateNode->getTarget() >>= aTarget.mxRef) )
 313                             {
 314                                 // pure shape target - set paragraph
 315                                 // index to magic
 316                                 aTarget.mnParagraphIndex = -1;
 317                             }
 318                             else
 319                             {
 320                                 // not a pure shape target - maybe a
 321                                 // ParagraphTarget?
 322                                 presentation::ParagraphTarget aUnoTarget;
 323
 324                                 if( !(xAnimateNode->getTarget() >>= aUnoTarget) )
 325                                 {
 326                                     OSL_ENSURE( false,
 327                                                 "AnimCore: NodeFunctor::operator(): unknown target type encountered" );
 328                                     break;
 329                                 }
 330
 331                                 aTarget.mxRef = aUnoTarget.Shape;
 332                                 aTarget.mnParagraphIndex = aUnoTarget.Paragraph;
 333                             }
 334                         }
 335
 336                         if( !aTarget.mxRef.is() )
 337                         {
 338                             OSL_ENSURE( false,
 339                                         "AnimCore: NodeFunctor::operator(): Found target, but XShape is NULL" );
 340                             break; // invalid target XShape
 341                         }
 342
 343                         // check whether we already have an entry for
 344                         // this target (we only take the first set
 345                         // effect for every shape)
 346                         XShapeHash::const_iterator aIter;
 347                         if( (aIter=mrShapeHash.find( aTarget )) != mrShapeHash.end() )
 348                             break; // already an entry in existence for given XShape
 349
 350                         // if this is an appear effect, hide shape
 351                         // initially. This is currently the only place
 352                         // where a shape effect influences shape
 353                         // attributes outside it's effective duration.
 354                         if( xAnimateNode->getAttributeName().equalsIgnoreAsciiCaseAscii("visibility") )
 355                         {
 356                             sal_Bool bVisible( sal_False );
 357
 358                             uno::Any aAny( xAnimateNode->getTo() );
 359
 360                             // try to extract bool value
 361                             if( !(aAny >>= bVisible) )
 362                             {
 363                                 // try to extract string
 364                                 ::rtl::OUString aString;
 365                                 if( (aAny >>= aString) )
 366                                 {
 367                                     // we also take the strings "true" and "false",
 368                                     // as well as "on" and "off" here
 369                                     if( aString.equalsIgnoreAsciiCaseAscii("true") ||
 370                                         aString.equalsIgnoreAsciiCaseAscii("on") )
 371                                     {
 372                                         bVisible = sal_True;
 373                                     }
 374                                     if( aString.equalsIgnoreAsciiCaseAscii("false") ||
 375                                         aString.equalsIgnoreAsciiCaseAscii("off") )
 376                                     {
 377                                         bVisible = sal_False;
 378                                     }
 379                                 }
 380                             }
 381
 382                             if( bVisible )
 383                             {
 384                                 // target is set to 'visible' at the
 385                                 // first relevant effect. Thus, target
 386                                 // must be initially _hidden_, for the
 387                                 // effect to have visible impact.
 388                                 mrShapeHash.insert(
 389                                     XShapeHash::value_type(
 390                                         aTarget,
 391                                         VectorOfNamedValues(
 392                                             1,
 393                                             beans::NamedValue(
 394                                                 xAnimateNode->getAttributeName(),
 395                                                 uno::makeAny( sal_False ) ) ) ) );
 396                             }
 397                         }
 398                     }
 399                     break;
 400                 }
 401             }
 402
 403         private:
 404             XShapeHash&                                                 mrShapeHash;
 405             uno::Reference< drawing::XShape >   mxTargetShape;
 406             sal_Int16                                                   mnParagraphIndex;
 407         };
 408     }
 409
 410     // --------------------------------------------------------------------
 411
 412     TargetPropertiesCreator::TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >&  ) :
 413         TargetPropertiesCreator_Base( m_aMutex )
 414     {
 415     }
 416
 417     TargetPropertiesCreator::~TargetPropertiesCreator()
 418     {
 419     }
 420
 421     void SAL_CALL TargetPropertiesCreator::disposing()
 422     {
 423         ::osl::MutexGuard aGuard( m_aMutex );
 424     }
 425
 426     // XTargetPropertiesCreator
 427     uno::Sequence< animations::TargetProperties > SAL_CALL TargetPropertiesCreator::createInitialTargetProperties
 428         (
 429             const uno::Reference< animations::XAnimationNode >& xRootNode
 430         ) throw (uno::RuntimeException)
 431     {
 432         ::osl::MutexGuard aGuard( m_aMutex );
 433
 434         // scan all nodes for visibility changes, and record first
 435         // 'visibility=true' for each shape
 436         XShapeHash aShapeHash( 101,
 437                                &refhasher );
 438
 439         NodeFunctor aFunctor( aShapeHash );
 440
 441         // TODO(F1): Maybe limit functor application to main sequence
 442         // alone (CL said something that shape visibility is only
 443         // affected by effects in the main sequence for PPT).
 444         //
 445         // OTOH, client code can pass us only the main sequence (which
 446         // it actually does right now, for the slideshow implementation).
 447         aFunctor( xRootNode );
 448
 449
 450         // output to result sequence
 451         // ----------------------------------------------------------------------
 452
 453         uno::Sequence< animations::TargetProperties > aRes( aShapeHash.size() );
 454
 455         ::std::size_t                                           nCurrIndex(0);
 456         XShapeHash::const_iterator                      aCurr( aShapeHash.begin() );
 457         const XShapeHash::const_iterator        aEnd ( aShapeHash.end()   );
 458         while( aCurr != aEnd )
 459         {
 460             animations::TargetProperties& rCurrProps( aRes[ nCurrIndex++ ] );
 461
 462             if( aCurr->first.mnParagraphIndex == -1 )
 463             {
 464                 rCurrProps.Target = uno::makeAny( aCurr->first.mxRef );
 465             }
 466             else
 467             {
 468                 rCurrProps.Target = uno::makeAny(
 469                     presentation::ParagraphTarget(
 470                         aCurr->first.mxRef,
 471                         aCurr->first.mnParagraphIndex ) );
 472             }
 473
 474             rCurrProps.Properties = ::comphelper::containerToSequence( aCurr->second );
 475
 476             ++aCurr;
 477         }
 478
 479         return aRes;
 480     }
 481
 482     // XServiceInfo
 483     ::rtl::OUString SAL_CALL TargetPropertiesCreator::getImplementationName() throw( uno::RuntimeException )
 484     {
 485         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) );
 486     }
 487
 488     sal_Bool SAL_CALL TargetPropertiesCreator::supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException )
 489     {
 490         return ServiceName.equalsIgnoreAsciiCaseAscii( SERVICE_NAME );
 491     }
 492
 493     uno::Sequence< ::rtl::OUString > SAL_CALL TargetPropertiesCreator::getSupportedServiceNames()  throw( uno::RuntimeException )
 494     {
 495         uno::Sequence< ::rtl::OUString > aRet(1);
 496         aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) );
 497
 498         return aRet;
 499     }
 500
 501     // XServiceName
 502     ::rtl::OUString SAL_CALL TargetPropertiesCreator::getServiceName(  ) throw (uno::RuntimeException)
 503     {
 504         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
 505     }
 506
 507 } // namespace animcore