sd/source/core/CustomAnimationCloner.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 #include <com/sun/star/animations/XAnimate.hpp>
  21 #include <com/sun/star/animations/XAnimationNode.hpp>
  22 #include <com/sun/star/animations/Event.hpp>
  23 #include <com/sun/star/animations/XCommand.hpp>
  24 #include <com/sun/star/animations/XIterateContainer.hpp>
  25 #include <com/sun/star/animations/XAudio.hpp>
  26 #include <com/sun/star/animations/AnimationNodeType.hpp>
  27 #include <com/sun/star/animations/ValuePair.hpp>
  28 #include <com/sun/star/util/XCloneable.hpp>
  29 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  30 #include <com/sun/star/container/XEnumerationAccess.hpp>
  31 #include <com/sun/star/beans/NamedValue.hpp>
  32
  33 #include <map>
  34
  35 #include <comphelper/anytostring.hxx>
  36 #include <cppuhelper/exc_hlp.hxx>
  37 #include <rtl/ref.hxx>
  38 #include <animations/animationnodehelper.hxx>
  39
  40 #include <svx/svditer.hxx>
  41
  42 #include <CustomAnimationCloner.hxx>
  43 #include <sdpage.hxx>
  44
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::animations;
  47 using namespace ::com::sun::star::presentation;
  48 using namespace ::com::sun::star::container;
  49
  50 using ::com::sun::star::drawing::XShape;
  51 using ::com::sun::star::beans::NamedValue;
  52
  53 namespace sd
  54 {
  55     class CustomAnimationClonerImpl
  56     {
  57     public:
  58         CustomAnimationClonerImpl();
  59         Reference< XAnimationNode > Clone( const Reference< XAnimationNode >& xSourceNode, const SdPage* pSource, const SdPage* pTarget );
  60
  61     private:
  62         void transformNode( const Reference< XAnimationNode >& xNode );
  63         Any transformValue( const Any& rValue );
  64
  65         Reference< XShape > getClonedShape( const Reference< XShape >& xSource ) const;
  66         Reference< XAnimationNode > getClonedNode( const Reference< XAnimationNode >& xSource ) const;
  67
  68         mutable ::std::map< Reference< XShape >, Reference< XShape > > maShapeMap;
  69         std::vector< Reference< XAnimationNode > > maSourceNodeVector;
  70         std::vector< Reference< XAnimationNode > > maCloneNodeVector;
  71     };
  72
  73     CustomAnimationClonerImpl::CustomAnimationClonerImpl()
  74     {
  75     }
  76
  77     Reference< XAnimationNode > Clone( const Reference< XAnimationNode >& xSourceNode, const SdPage* pSource, const SdPage* pTarget )
  78     {
  79         CustomAnimationClonerImpl aCloner;
  80         return aCloner.Clone( xSourceNode, pSource, pTarget );
  81     }
  82
  83     Reference< XAnimationNode > CustomAnimationClonerImpl::Clone( const Reference< XAnimationNode >& xSourceNode, const SdPage* pSourcePage, const SdPage* pTargetPage )
  84     {
  85         try
  86         {
  87             // clone animation hierarchy
  88             Reference< css::util::XCloneable > xClonable( xSourceNode, UNO_QUERY_THROW );
  89             Reference< XAnimationNode > xCloneNode( xClonable->createClone(), UNO_QUERY_THROW );
  90
  91             // create a dictionary to map source to cloned shapes
  92             if( pSourcePage && pTargetPage )
  93             {
  94                 SdrObjListIter aSourceIter( *pSourcePage, SdrIterMode::DeepWithGroups );
  95                 SdrObjListIter aTargetIter( *pTargetPage, SdrIterMode::DeepWithGroups );
  96
  97                 while( aSourceIter.IsMore() && aTargetIter.IsMore() )
  98                 {
  99                     SdrObject* pSource = aSourceIter.Next();
 100                     SdrObject* pTarget = aTargetIter.Next();
 101
 102                     if( pSource && pTarget)
 103                     {
 104                         Reference< XShape > xSource( pSource->getUnoShape(), UNO_QUERY );
 105                         Reference< XShape > xTarget( pTarget->getUnoShape(), UNO_QUERY );
 106                         if( xSource.is() && xTarget.is() )
 107                         {
 108                             maShapeMap[xSource] = xTarget;
 109                         }
 110                     }
 111                 }
 112             }
 113
 114             // create a dictionary to map source to cloned nodes
 115             ::anim::create_deep_vector( xSourceNode, maSourceNodeVector );
 116             ::anim::create_deep_vector( xCloneNode, maCloneNodeVector );
 117
 118             transformNode( xCloneNode );
 119
 120             return xCloneNode;
 121         }
 122         catch( Exception& )
 123         {
 124             SAL_WARN( "sd", "sd::CustomAnimationClonerImpl::Clone(), "
 125                       "exception caught: " <<  comphelper::anyToString( cppu::getCaughtException() ) );
 126             Reference< XAnimationNode > xEmpty;
 127             return xEmpty;
 128         }
 129     }
 130
 131     void CustomAnimationClonerImpl::transformNode( const Reference< XAnimationNode >& xNode )
 132     {
 133         try
 134         {
 135             xNode->setBegin( transformValue( xNode->getBegin() ) );
 136             xNode->setEnd( transformValue( xNode->getEnd() ) );
 137
 138             sal_Int16 nNodeType( xNode->getType() );
 139             switch( nNodeType )
 140             {
 141             case AnimationNodeType::ITERATE:
 142             {
 143                 Reference< XIterateContainer > xIter( xNode, UNO_QUERY_THROW );
 144                 xIter->setTarget( transformValue( xIter->getTarget() ) );
 145                 SAL_FALLTHROUGH;
 146             }
 147             case AnimationNodeType::PAR:
 148             case AnimationNodeType::SEQ:
 149             {
 150                 Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
 151                 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
 152                 while( xEnumeration->hasMoreElements() )
 153                 {
 154                     Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
 155                     transformNode( xChildNode );
 156                 }
 157             }
 158             break;
 159
 160             case AnimationNodeType::ANIMATE:
 161             case AnimationNodeType::SET:
 162             case AnimationNodeType::ANIMATEMOTION:
 163             case AnimationNodeType::ANIMATECOLOR:
 164             case AnimationNodeType::ANIMATETRANSFORM:
 165             case AnimationNodeType::TRANSITIONFILTER:
 166             {
 167                 Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
 168                 xAnimate->setTarget( transformValue( xAnimate->getTarget() ) );
 169             }
 170             break;
 171
 172             case AnimationNodeType::COMMAND:
 173             {
 174                 Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
 175                 xCommand->setTarget( transformValue( xCommand->getTarget() ) );
 176             }
 177             break;
 178
 179             case AnimationNodeType::AUDIO:
 180             {
 181                 Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
 182                 xAudio->setSource( transformValue( xAudio->getSource() ) );
 183             }
 184             break;
 185             }
 186
 187             Sequence< NamedValue > aUserData( xNode->getUserData() );
 188             if( aUserData.hasElements() )
 189             {
 190                 for( NamedValue & namedValue : aUserData )
 191                 {
 192                     namedValue.Value = transformValue( namedValue.Value );
 193                 }
 194
 195                 xNode->setUserData( aUserData );
 196             }
 197         }
 198         catch( Exception& )
 199         {
 200             SAL_WARN( "sd", "sd::CustomAnimationClonerImpl::transformNode(), "
 201                       "exception caught: "
 202                       << comphelper::anyToString( cppu::getCaughtException() ) );
 203         }
 204     }
 205
 206     Any CustomAnimationClonerImpl::transformValue( const Any& rValue )
 207     {
 208         if( rValue.hasValue() ) try
 209         {
 210             if( rValue.getValueType() == cppu::UnoType<ValuePair>::get() )
 211             {
 212                 ValuePair aValuePair;
 213                 rValue >>= aValuePair;
 214
 215                 aValuePair.First = transformValue( aValuePair.First );
 216                 aValuePair.Second = transformValue( aValuePair.Second );
 217
 218                 return makeAny( aValuePair );
 219             }
 220             else if( rValue.getValueType() == cppu::UnoType< Sequence<Any> >::get() )
 221             {
 222                 Sequence<Any> aSequence;
 223                 rValue >>= aSequence;
 224
 225                 const sal_Int32 nLength = aSequence.getLength();
 226                 sal_Int32 nElement;
 227                 Any* pAny = aSequence.getArray();
 228
 229                 for( nElement = 0; nElement < nLength; nElement++, pAny++ )
 230                     *pAny = transformValue( *pAny );
 231
 232                 return makeAny( aSequence );
 233             }
 234             else if( rValue.getValueTypeClass() == TypeClass_INTERFACE )
 235             {
 236                 Reference< XShape > xShape;
 237                 rValue >>= xShape;
 238                 if( xShape.is() )
 239                 {
 240                     return makeAny( getClonedShape( xShape ) );
 241                 }
 242                 else
 243                 {
 244                     Reference< XAnimationNode > xNode;
 245                     rValue >>= xNode;
 246                     if( xNode.is() )
 247                         return makeAny( getClonedNode( xNode ) );
 248                 }
 249             }
 250             else if( rValue.getValueType() == cppu::UnoType<ParagraphTarget>::get() )
 251             {
 252                 ParagraphTarget aParaTarget;
 253                 rValue >>= aParaTarget;
 254
 255                 aParaTarget.Shape = getClonedShape( aParaTarget.Shape );
 256
 257                 return makeAny( aParaTarget );
 258             }
 259             else if( rValue.getValueType() == cppu::UnoType<Event>::get() )
 260             {
 261                 Event aEvent;
 262                 rValue >>= aEvent;
 263
 264                 aEvent.Source = transformValue( aEvent.Source );
 265
 266                 return makeAny( aEvent );
 267             }
 268         }
 269         catch( Exception& )
 270         {
 271             SAL_WARN( "sd", "sd::CustomAnimationClonerImpl::transformValue(), "
 272                       "exception caught: "
 273                       << comphelper::anyToString( cppu::getCaughtException() ) );
 274         }
 275
 276         return rValue;
 277     }
 278
 279     Reference< XShape > CustomAnimationClonerImpl::getClonedShape( const Reference< XShape >& xSource ) const
 280     {
 281         if( xSource.is() )
 282         {
 283             if( maShapeMap.find(xSource) != maShapeMap.end() )
 284             {
 285                 return maShapeMap[xSource];
 286             }
 287
 288             DBG_ASSERT( maShapeMap.empty(), "sd::CustomAnimationClonerImpl::getClonedShape() failed!" );
 289         }
 290         return xSource;
 291     }
 292
 293     Reference< XAnimationNode > CustomAnimationClonerImpl::getClonedNode( const Reference< XAnimationNode >& xSource ) const
 294     {
 295         sal_Int32 nNode, nNodeCount = maSourceNodeVector.size();
 296
 297         for( nNode = 0; nNode < nNodeCount; nNode++ )
 298         {
 299             if( maSourceNodeVector[nNode] == xSource )
 300                 return maCloneNodeVector[nNode];
 301         }
 302
 303         OSL_FAIL( "sd::CustomAnimationClonerImpl::getClonedNode() failed!" );
 304         return xSource;
 305     }
 306 }
 307
 308 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */