LibreOffice Module oox (master)  1
timenode.cxx
Go to the documentation of this file.
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 <oox/ppt/timenode.hxx>
21 
22 #include <com/sun/star/beans/NamedValue.hpp>
23 #include <com/sun/star/container/XEnumerationAccess.hpp>
24 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
25 #include <com/sun/star/animations/XAnimateColor.hpp>
26 #include <com/sun/star/animations/XAnimateMotion.hpp>
27 #include <com/sun/star/animations/XAnimateTransform.hpp>
28 #include <com/sun/star/animations/XCommand.hpp>
29 #include <com/sun/star/animations/XAudio.hpp>
30 #include <com/sun/star/animations/XIterateContainer.hpp>
31 #include <com/sun/star/animations/XTimeContainer.hpp>
32 #include <com/sun/star/animations/XTransitionFilter.hpp>
33 #include <com/sun/star/animations/AnimationNodeType.hpp>
34 #include <com/sun/star/animations/Event.hpp>
35 #include <com/sun/star/animations/EventTrigger.hpp>
36 #include <com/sun/star/io/WrongFormatException.hpp>
37 #include <com/sun/star/presentation/EffectNodeType.hpp>
38 #include <com/sun/star/uno/XComponentContext.hpp>
39 
42 #include <oox/token/tokens.hxx>
43 #include <sal/log.hxx>
44 #include <tools/diagnose_ex.h>
45 
46 using namespace ::oox::core;
47 using namespace ::com::sun::star::beans;
48 using namespace ::com::sun::star::container;
49 using namespace ::com::sun::star::uno;
50 using namespace ::com::sun::star::lang;
51 using namespace ::com::sun::star::animations;
52 using namespace ::com::sun::star::presentation;
53 
54 namespace {
55 
56 void lcl_setAncestorSubItem( const Reference<XAnimationNode>& xParent, sal_Int16 nSubItem )
57 {
58 
59  Reference<XAnimationNode> xNode = xParent;
60 
61  while ( xNode.is() )
62  {
63  if ( xNode->getType() == AnimationNodeType::ANIMATE )
64  {
65  Reference<XAnimate> xAnimate( xNode, UNO_QUERY );
66  if ( xAnimate.is() )
67  xAnimate->setSubItem( nSubItem );
68  break;
69  }
70  else if ( xNode->getType() == AnimationNodeType::ITERATE )
71  {
72  Reference<XIterateContainer> xIterateContainer( xNode, UNO_QUERY );
73  if ( xIterateContainer.is() )
74  xIterateContainer->setSubItem( nSubItem );
75  break;
76  }
77 
78  xNode.set( xNode->getParent(), UNO_QUERY );
79  }
80 }
81 
82 }
83 
84 namespace oox::ppt {
85  OUString TimeNode::getServiceName( sal_Int16 nNodeType )
86  {
87  OUString sServiceName;
88  switch( nNodeType )
89  {
90  case AnimationNodeType::PAR:
91  sServiceName = "com.sun.star.animations.ParallelTimeContainer";
92  break;
93  case AnimationNodeType::SEQ:
94  sServiceName = "com.sun.star.animations.SequenceTimeContainer";
95  break;
96  case AnimationNodeType::ANIMATE:
97  sServiceName = "com.sun.star.animations.Animate";
98  break;
99  case AnimationNodeType::ITERATE:
100  sServiceName = "com.sun.star.animations.IterateContainer";
101  break;
102  case AnimationNodeType::ANIMATECOLOR:
103  sServiceName = "com.sun.star.animations.AnimateColor";
104  break;
105  case AnimationNodeType::TRANSITIONFILTER:
106  sServiceName = "com.sun.star.animations.TransitionFilter";
107  break;
108  case AnimationNodeType::ANIMATEMOTION:
109  sServiceName = "com.sun.star.animations.AnimateMotion";
110  break;
111  case AnimationNodeType::ANIMATETRANSFORM:
112  sServiceName = "com.sun.star.animations.AnimateTransform";
113  break;
114  case AnimationNodeType::COMMAND:
115  sServiceName = "com.sun.star.animations.Command";
116  break;
117  case AnimationNodeType::SET:
118  sServiceName = "com.sun.star.animations.AnimateSet";
119  break;
121  sServiceName = "com.sun.star.animations.Audio";
122  break;
123  default:
124  SAL_INFO("oox.ppt","OOX: unhandled type " << nNodeType );
125  break;
126  }
127  return sServiceName;
128  }
129 
130  TimeNode::TimeNode( sal_Int16 nNodeType )
131  : mnNodeType( nNodeType )
132  , mbHasEndSyncValue( false )
133  {
134  }
135 
137  {
138  }
139 
140  void fixMainSequenceTiming( const css::uno::Reference< css::animations::XAnimationNode >& xNode )
141  {
142  try
143  {
144  bool bFirst = true;
145  Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
146  Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_SET_THROW );
147  while( xE->hasMoreElements() )
148  {
149  // click node
150  Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
151 
152  Event aEvent;
153  aEvent.Trigger = EventTrigger::ON_NEXT;
154  aEvent.Repeat = 0;
155  xClickNode->setBegin( makeAny( aEvent ) );
156 
157  if( bFirst )
158  {
159  bFirst = false;
160  Reference< XEnumerationAccess > xEA2( xClickNode, UNO_QUERY_THROW );
161  Reference< XEnumeration > xE2( xEA2->createEnumeration(), UNO_SET_THROW );
162  if( xE2->hasMoreElements() )
163  {
164  // with node
165  xE2->nextElement() >>= xEA2;
166  if( xEA2.is() )
167  xE2 = xEA2->createEnumeration();
168  else
169  xE2.clear();
170 
171  if( xE2.is() && xE2->hasMoreElements() )
172  {
173  Reference< XAnimationNode > xEffectNode( xE2->nextElement(), UNO_QUERY_THROW );
174  const Sequence< NamedValue > aUserData( xEffectNode->getUserData() );
175  for( const NamedValue& rProp : aUserData )
176  {
177  if ( rProp.Name == "node-type" )
178  {
179  sal_Int16 nNodeType = 0;
180  rProp.Value >>= nNodeType;
181  if( nNodeType != css::presentation::EffectNodeType::ON_CLICK )
182  {
183  // first effect does not start on click, so correct
184  // first click nodes begin to 0s
185  xClickNode->setBegin( makeAny( 0.0 ) );
186  break;
187  }
188  }
189  }
190  }
191  }
192  }
193  }
194  }
195  catch( Exception& )
196  {
197  SAL_INFO("oox.ppt","fixMainSequenceTiming(), exception caught!" );
198  }
199  }
200 
201  void fixInteractiveSequenceTiming( const css::uno::Reference< css::animations::XAnimationNode >& xNode )
202  {
203  try
204  {
205  Any aBegin( xNode->getBegin() );
206  Any aEmpty;
207  xNode->setBegin( aEmpty );
208 
209  Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
210  Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_SET_THROW );
211  while( xE->hasMoreElements() )
212  {
213  // click node
214  Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
215  xClickNode->setBegin( aBegin );
216  }
217  }
218  catch( Exception& )
219  {
220  SAL_INFO("oox.ppt","fixInteractiveSequenceTiming(), exception caught!" );
221  }
222  }
223 
224  void TimeNode::addNode( const XmlFilterBase& rFilter, const Reference< XAnimationNode >& rxNode, const SlidePersistPtr & pSlide )
225  {
226  try {
227  sal_Int16 nNodeType = mnNodeType;
228 
229  if (mnNodeType == AnimationNodeType::PAR && maNodeProperties[NP_ITERATETYPE].hasValue())
230  nNodeType = AnimationNodeType::ITERATE;
231 
232  OUString sServiceName = getServiceName(nNodeType);
233 
234  Reference< XAnimationNode > xNode = createAndInsert( rFilter, sServiceName, rxNode );
235  if (!xNode)
236  return;
237  setNode(rFilter, xNode, pSlide, rxNode);
238  }
239  catch( const Exception& )
240  {
241  TOOLS_INFO_EXCEPTION("oox.ppt","OOX: exception raised in TimeNode::addNode()" );
242  }
243  }
244 
245  void TimeNode::setNode(const XmlFilterBase& rFilter, const Reference< XAnimationNode >& xNode, const SlidePersistPtr & pSlide, const Reference<XAnimationNode>& xParent)
246  {
247  SAL_WARN_IF( !xNode.is(), "oox.ppt", "null node passed" );
248 
249  try {
250  if( !msId.isEmpty() )
251  {
252  pSlide->getAnimNodesMap()[ msId ] = xNode;
253  }
254 
255  if( mpTarget )
256  {
257  sal_Int16 nSubItem(0);
258  maNodeProperties[ NP_TARGET ] = mpTarget->convert( pSlide, nSubItem );
259  if( mpTarget->mnType == XML_spTgt )
260  {
261  if ( xNode->getType() == AnimationNodeType::ANIMATE ||
262  xNode->getType() == AnimationNodeType::ITERATE )
263  {
264  maNodeProperties[ NP_SUBITEM ] <<= nSubItem;
265  }
266  else
267  lcl_setAncestorSubItem( xParent, nSubItem );
268  }
269  }
270 
271  if( !maStCondList.empty() )
272  {
274  if( aAny.hasValue() )
275  {
276  xNode->setBegin( aAny );
277  }
278 
279  }
280  if( !maEndCondList.empty() )
281  {
283  if( aAny.hasValue() )
284  {
285  xNode->setEnd( aAny );
286  }
287  }
288  if( mbHasEndSyncValue )
289  {
290  Any aValue = maEndSyncValue.convert( pSlide );
291  xNode->setEndSync(aValue);
292  }
293 
294  if( !maUserData.empty() )
295  {
296  Sequence< NamedValue > aUserDataSeq( static_cast< sal_Int32 >( maUserData.size() ) );
297  NamedValue* pValues = aUserDataSeq.getArray();
298  for (auto const& elem : maUserData)
299  {
300  pValues->Name = elem.first;
301  pValues->Value = elem.second;
302  ++pValues;
303  }
304  maNodeProperties[ NP_USERDATA ] <<= aUserDataSeq;
305  }
306 
307  Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
308  Reference< XAnimateColor > xAnimateColor( xNode, UNO_QUERY );
309  Reference< XAnimateMotion > xAnimateMotion( xNode, UNO_QUERY );
310  Reference< XAnimateTransform > xAnimateTransform( xNode, UNO_QUERY );
311  Reference< XCommand > xCommand( xNode, UNO_QUERY );
312  Reference< XAudio > xAudio( xNode, UNO_QUERY );
313  Reference< XIterateContainer > xIterateContainer( xNode, UNO_QUERY );
314  sal_Int16 nInt16 = 0;
315  bool bBool = false;
316  double fDouble = 0;
317  OUString sString;
318  Sequence< NamedValue > aSeq;
319 
320  for( int i = 0; i < NP_SIZE_; i++)
321  {
322  Any & aValue( maNodeProperties[ i ] );
323  if( aValue.hasValue() )
324  {
325  switch( i )
326  {
327  case NP_TO:
328  if( xAnimate.is() )
329  xAnimate->setTo( aValue );
330  break;
331  case NP_FROM:
332  if( xAnimate.is() )
333  xAnimate->setFrom( aValue );
334  break;
335  case NP_BY:
336  if( xAnimate.is() )
337  xAnimate->setBy( aValue );
338  break;
339  case NP_HIDEDURINGSHOW:
340  if (xAudio.is() && (aValue >>= bBool))
341  {
342  xAudio->setHideDuringShow(bBool);
343  }
344  break;
345  case NP_ISNARRATION:
346  if (xAudio.is() && (aValue >>= bBool))
347  {
348  xAudio->setNarration(bBool);
349  }
350  break;
351  case NP_TARGET:
352 
353  if (xParent.is() && xParent->getType() == AnimationNodeType::ITERATE)
354  {
355  Reference<XIterateContainer> xParentContainer(xParent, UNO_QUERY);
356  if (xParentContainer.is())
357  xParentContainer->setTarget(aValue);
358  }
359  else
360  {
361  if (xAnimate.is())
362  xAnimate->setTarget(aValue);
363  if (xCommand.is())
364  xCommand->setTarget(aValue);
365  if (xAudio.is())
366  xAudio->setSource(aValue);
367  }
368  break;
369  case NP_SUBITEM:
370  if( aValue >>= nInt16 )
371  {
372  if( xAnimate.is() )
373  {
374  xAnimate->setSubItem( nInt16 );
375  }
376  else if ( xIterateContainer.is() )
377  {
378  xIterateContainer->setSubItem( nInt16 );
379  }
380  }
381  else
382  {
383  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
384  }
385  break;
386  case NP_ATTRIBUTENAME:
387  if( xAnimate.is() )
388  {
389  if( aValue >>= sString )
390  xAnimate->setAttributeName( sString );
391  else
392  {
393  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
394  }
395  }
396  break;
397  case NP_CALCMODE:
398  if( xAnimate.is() )
399  {
400  if( aValue >>= nInt16 )
401  xAnimate->setCalcMode( nInt16 );
402  else
403  {
404  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
405  }
406  }
407  break;
408  case NP_KEYTIMES:
409  if( xAnimate.is() )
410  {
411  Sequence<double> aKeyTimes;
412  if( aValue >>= aKeyTimes )
413  xAnimate->setKeyTimes(aKeyTimes);
414  else
415  {
416  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
417  }
418  }
419  break;
420  case NP_VALUES:
421  if( xAnimate.is() )
422  {
423  Sequence<Any> aValues;
424  if( aValue >>= aValues )
425  xAnimate->setValues(aValues);
426  else
427  {
428  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
429  }
430  }
431  break;
432  case NP_FORMULA:
433  if( xAnimate.is() )
434  {
435  if( aValue >>= sString )
436  xAnimate->setFormula(sString);
437  else
438  {
439  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
440  }
441  }
442  break;
444  if( xAnimateColor.is() )
445  {
446  if( aValue >>= nInt16 )
447  xAnimateColor->setColorInterpolation( nInt16 );
448  else
449  {
450  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
451  }
452  }
453  break;
454  case NP_DIRECTION:
455  if( xAnimateColor.is() )
456  {
457  if( aValue >>= bBool )
458  xAnimateColor->setDirection( bBool );
459  else
460  {
461  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
462  }
463  }
464  break;
465  case NP_PATH:
466  if( xAnimateMotion.is() )
467  xAnimateMotion->setPath( aValue );
468  break;
469  case NP_TRANSFORMTYPE:
470  if( xAnimateTransform.is() )
471  {
472  if( aValue >>= nInt16 )
473  xAnimateTransform->setTransformType( nInt16 );
474  else
475  {
476  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
477  }
478  }
479  break;
480  case NP_USERDATA:
481  if( aValue >>= aSeq )
482  xNode->setUserData( aSeq );
483  else
484  {
485  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
486  }
487  break;
488  case NP_ACCELERATION:
489  if( aValue >>= fDouble )
490  xNode->setAcceleration( fDouble );
491  else
492  {
493  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
494  }
495  break;
496  case NP_DECELERATE:
497  if( aValue >>= fDouble )
498  xNode->setDecelerate( fDouble );
499  else
500  {
501  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
502  }
503  break;
504  case NP_AUTOREVERSE:
505  if( aValue >>= bBool )
506  xNode->setAutoReverse( bBool );
507  else
508  {
509  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
510  }
511  break;
512  case NP_DURATION:
513  xNode->setDuration( aValue );
514  break;
515  case NP_FILL:
516  if( aValue >>= nInt16 )
517  xNode->setFill( nInt16 );
518  else
519  {
520  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
521  }
522  break;
523  case NP_REPEATCOUNT:
524  xNode->setRepeatCount( aValue );
525  break;
526  case NP_REPEATDURATION:
527  xNode->setRepeatDuration( aValue );
528  break;
529  case NP_RESTART:
530  if( aValue >>= nInt16 )
531  xNode->setRestart( nInt16 );
532  else
533  {
534  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
535  }
536  break;
537  case NP_COMMAND:
538  if( xCommand.is() )
539  {
540  if( aValue >>= nInt16 )
541  xCommand->setCommand( nInt16 );
542  else
543  {
544  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
545  }
546  }
547  break;
548  case NP_PARAMETER:
549  if( xCommand.is() )
550  xCommand->setParameter( aValue );
551  break;
552  case NP_ITERATETYPE:
553  if( xIterateContainer.is() )
554  {
555  if( aValue >>= nInt16 )
556  xIterateContainer->setIterateType( nInt16 );
557  else
558  {
559  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
560  }
561  }
562  break;
563  case NP_ITERATEINTERVAL:
564  if( xIterateContainer.is() )
565  {
566  if( aValue >>= fDouble )
567  xIterateContainer->setIterateInterval( fDouble );
568  else
569  {
570  SAL_INFO("oox.ppt","any >>= failed " << __LINE__ );
571  }
572  }
573  break;
574  default:
575  SAL_INFO("oox.ppt","ERR-OOX: unknown prop index " << i );
576  break;
577  }
578  }
579  }
580 
581  if (xAnimate.is() && xAnimate->getValues().getLength() != xAnimate->getKeyTimes().getLength())
582  throw css::io::WrongFormatException();
583 
584  if( mnNodeType == AnimationNodeType::TRANSITIONFILTER )
585  {
586 
587  Reference< XTransitionFilter > xFilter( xNode, UNO_QUERY );
589  }
590 
591  std::for_each(
592  maChildren.begin(), maChildren.end(),
593  [&rFilter, &xNode, &pSlide] (TimeNodePtr const & child) {
594  child->addNode(rFilter, xNode, pSlide);
595  } );
596 
597  switch( mnNodeType )
598  {
599  case AnimationNodeType::SEQ:
600  {
601  sal_Int16 nEnum = 0;
602  if( maUserData[ "node-type" ] >>= nEnum )
603  {
604  if( nEnum == EffectNodeType::MAIN_SEQUENCE )
605  {
606  fixMainSequenceTiming( xNode );
607  }
608  else if( nEnum == EffectNodeType::INTERACTIVE_SEQUENCE )
609  {
611  }
612  }
613  break;
614  }
615  case AnimationNodeType::PAR:
616  // some other cut&paste... from AnimationImporter::importAnimationContainer()
617  break;
618  }
619  }
620  catch( const Exception& )
621  {
622  TOOLS_INFO_EXCEPTION("oox.ppt","OOX: exception raised in TimeNode::setNode()");
623  }
624  }
625 
626  Reference< XAnimationNode > TimeNode::createAndInsert(
627  const XmlFilterBase& rFilter,
628  const OUString& rServiceName,
629  const Reference< XAnimationNode >& rxNode )
630  {
631  try {
632  Reference< XAnimationNode > xNode( Reference<css::lang::XMultiServiceFactory>(rFilter.getComponentContext()->getServiceManager(), UNO_QUERY_THROW)->createInstance( rServiceName ), UNO_QUERY_THROW );
633  Reference< XTimeContainer > xParentContainer( rxNode, UNO_QUERY_THROW );
634 
635  xParentContainer->appendChild( xNode );
636  return xNode;
637  }
638  catch( const Exception& )
639  {
640  TOOLS_INFO_EXCEPTION("oox.ppt", "OOX: exception raised in TimeNode::createAndInsert() trying to create a service " << rServiceName);
641  }
642 
643  return Reference< XAnimationNode >();
644  }
645 
646  void TimeNode::setId( sal_Int32 nId )
647  {
648  msId = OUString::number(nId);
649  }
650 
651  void TimeNode::setTo( const Any & aTo )
652  {
653  maNodeProperties[ NP_TO ] = aTo;
654  }
655 
656  void TimeNode::setFrom( const Any & aFrom )
657  {
658  maNodeProperties[ NP_FROM ] = aFrom;
659  }
660 
661  void TimeNode::setBy( const Any & aBy )
662  {
663  maNodeProperties[ NP_BY ] = aBy;
664  }
665 
666 }
667 
668 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
TimeNode(sal_Int16 nNodeType)
Definition: timenode.cxx:130
void setTransitionFilterProperties(const css::uno::Reference< css::animations::XTransitionFilter > &xFilter)
NodePropertyMap maNodeProperties
Definition: timenode.hxx:113
sal_Int16 nId
Definition: olehelper.cxx:97
AnimTargetElementPtr mpTarget
Definition: timenode.hxx:116
static css::uno::Any convertList(const SlidePersistPtr &pSlide, const AnimationConditionList &l)
void setTo(const css::uno::Any &aTo)
Definition: timenode.cxx:651
AnimationCondition maEndSyncValue
Definition: timenode.hxx:118
void setNode(const ::oox::core::XmlFilterBase &rFilter, const css::uno::Reference< css::animations::XAnimationNode > &xNode, const SlidePersistPtr &pSlide, const css::uno::Reference< css::animations::XAnimationNode > &xParent)
Definition: timenode.cxx:245
TimeNodePtrList maChildren
Definition: timenode.hxx:110
css::uno::Any convert(const SlidePersistPtr &pSlide) const
constexpr OUStringLiteral sServiceName
const sal_Int16 mnNodeType
Definition: timenode.hxx:108
SlideTransition maTransitionFilter
Definition: timenode.hxx:115
void fixMainSequenceTiming(const css::uno::Reference< css::animations::XAnimationNode > &xNode)
Definition: timenode.cxx:140
static OUString getServiceName(sal_Int16 nNodeType)
Definition: timenode.cxx:85
static css::uno::Reference< css::animations::XAnimationNode > createAndInsert(const ::oox::core::XmlFilterBase &rFilter, const OUString &rServiceName, const css::uno::Reference< css::animations::XAnimationNode > &rxNode)
Definition: timenode.cxx:626
HRESULT createInstance(REFIID iid, Ifc **ppIfc)
AnimationConditionList maEndCondList
Definition: timenode.hxx:119
#define TOOLS_INFO_EXCEPTION(area, stream)
const PropertyValue * pValues
void setFrom(const css::uno::Any &aFrom)
Definition: timenode.cxx:656
#define SAL_WARN_IF(condition, area, stream)
#define SAL_INFO(area, stream)
Sequence< sal_Int8 > aSeq
std::shared_ptr< SlidePersist > SlidePersistPtr
const sal_Int16 mnNodeType
std::shared_ptr< TimeNode > TimeNodePtr
Definition: timenode.hxx:44
void setBy(const css::uno::Any &aBy)
Definition: timenode.cxx:661
void addNode(const ::oox::core::XmlFilterBase &rFilter, const css::uno::Reference< css::animations::XAnimationNode > &rxNode, const SlidePersistPtr &slide)
Definition: timenode.cxx:224
void fixInteractiveSequenceTiming(const css::uno::Reference< css::animations::XAnimationNode > &xNode)
Definition: timenode.cxx:201
UserDataMap maUserData
Definition: timenode.hxx:114
void setId(sal_Int32 nId)
Definition: timenode.cxx:646
AnimationConditionList maStCondList
Definition: timenode.hxx:119
AnyEventRef aEvent
css::uno::Any SAL_CALL makeAny(const SharedUNOComponent< INTERFACE, COMPONENT > &value)