xref: /aoo41x/main/oox/source/ppt/timenode.cxx (revision ca5ec200)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#include "oox/ppt/timenode.hxx"

#include <boost/bind.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/animations/XAnimateColor.hpp>
#include <com/sun/star/animations/XAnimateMotion.hpp>
#include <com/sun/star/animations/XAnimateTransform.hpp>
#include <com/sun/star/animations/XCommand.hpp>
#include <com/sun/star/animations/XIterateContainer.hpp>
#include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
#include <com/sun/star/animations/XTimeContainer.hpp>
#include <com/sun/star/animations/AnimationNodeType.hpp>
#include <com/sun/star/animations/Event.hpp>
#include <com/sun/star/animations/EventTrigger.hpp>
#include <com/sun/star/presentation/EffectNodeType.hpp>

#include "oox/helper/helper.hxx"
#include "oox/core/xmlfilterbase.hxx"

using ::rtl::OUString;
using namespace ::oox::core;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::animations;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::presentation;

namespace oox { namespace ppt {

		OUString TimeNode::getServiceName( sal_Int16 nNodeType )
		{
			OUString sServiceName;
			switch( nNodeType )
			{
			case AnimationNodeType::PAR:
//				sServiceName = CREATE_OUSTRING("com.sun.star.animations.IterateContainer");
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.ParallelTimeContainer");
				break;
			case AnimationNodeType::SEQ:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.SequenceTimeContainer");
				break;
			case AnimationNodeType::ANIMATE:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.Animate");
				break;
			case AnimationNodeType::ANIMATECOLOR:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateColor");
				break;
			case AnimationNodeType::TRANSITIONFILTER:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.TransitionFilter");
				break;
			case AnimationNodeType::ANIMATEMOTION:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateMotion");
				break;
			case AnimationNodeType::ANIMATETRANSFORM:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateTransform");
				break;
			case AnimationNodeType::COMMAND:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.Command");
				break;
			case AnimationNodeType::SET:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateSet");
				break;
			case AnimationNodeType::AUDIO:
				sServiceName = CREATE_OUSTRING("com.sun.star.animations.Audio");
				break;
			default:
				OSL_TRACE( "OOX: uhandled type %x", nNodeType );
				break;
			}
			return sServiceName;
		}



	TimeNode::TimeNode( sal_Int16 nNodeType )
		: mnNodeType( nNodeType )
		, mbHasEndSyncValue( false )
	{
	}


	TimeNode::~TimeNode()
	{
	}

// BEGIN CUT&PASTE from sd/source/filter/ppt/pptinanimations.hxx
// --------------------------------------------------------------------
	static void fixMainSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
	{
		try
		{
			bool bFirst = true;
			Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
			Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
			while( xE->hasMoreElements() )
			{
				// click node
				Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );

				Event aEvent;
				aEvent.Trigger = EventTrigger::ON_NEXT;
				aEvent.Repeat = 0;
				xClickNode->setBegin( makeAny( aEvent ) );

				if( bFirst )
				{
					bFirst = false;
					Reference< XEnumerationAccess > xEA2( xClickNode, UNO_QUERY_THROW );
					Reference< XEnumeration > xE2( xEA2->createEnumeration(), UNO_QUERY_THROW );
					if( xE2->hasMoreElements() )
					{
						// with node
						xE2->nextElement() >>= xEA2;
						if( xEA2.is() )
							xE2.query( xEA2->createEnumeration() );
						else
							xE2.clear();

						if( xE2.is() && xE2->hasMoreElements() )
						{
							Reference< XAnimationNode > xEffectNode( xE2->nextElement(), UNO_QUERY_THROW );
							const Sequence< NamedValue > aUserData( xEffectNode->getUserData() );
							const NamedValue* p = aUserData.getConstArray();
							sal_Int32 nLength = aUserData.getLength();
							while( nLength-- )
							{
								if( p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "node-type" ) ) )
								{
									sal_Int16 nNodeType = 0;
									p->Value >>= nNodeType;
									if( nNodeType != ::com::sun::star::presentation::EffectNodeType::ON_CLICK )
									{
										// first effect does not start on click, so correct
										// first click nodes begin to 0s
										xClickNode->setBegin( makeAny( (double)0.0 ) );
										break;
									}
								}
								p++;
							}
						}
					}
				}
			}
		}
		catch( Exception& e )
		{
			(void)e;
			OSL_TRACE("fixMainSequenceTiming(), exception caught!" );
		}
	}

// --------------------------------------------------------------------

	static void fixInteractiveSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
	{
		try
		{
			Any aBegin( xNode->getBegin() );
			Any aEmpty;
			xNode->setBegin( aEmpty );

			Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
			Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
			while( xE->hasMoreElements() )
			{
				// click node
				Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
				xClickNode->setBegin( aBegin );
			}
		}
		catch( Exception& e )
		{
			(void)e;
			OSL_TRACE("fixInteractiveSequenceTiming(), exception caught!" );
		}
	}

// END CUT&PASTE

    void TimeNode::addNode( const XmlFilterBase& rFilter, const Reference< XAnimationNode >& rxNode, const SlidePersistPtr & pSlide )
	{
		try {
			OUString sServiceName = getServiceName( mnNodeType );
            Reference< XAnimationNode > xNode = createAndInsert( rFilter, sServiceName, rxNode );
            setNode( rFilter, xNode, pSlide );
		}
		catch( const Exception& e )
		{
			OSL_TRACE( "OOX: exception raised in TimeNode::addNode() - %s",
								 OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
		}
	}

    void TimeNode::setNode( const XmlFilterBase& rFilter, const Reference< XAnimationNode >& xNode, const SlidePersistPtr & pSlide )
	{
		OSL_ENSURE( xNode.is(), "null node passed" );

		try {
			if( msId.getLength() )
			{
				pSlide->getAnimNodesMap()[ msId ] = xNode;
			}

			if( mpTarget )
			{
				sal_Int16 nSubType;
				maNodeProperties[ NP_TARGET ] = mpTarget->convert( pSlide, nSubType );
				if( mpTarget->mnType == XML_spTgt )
				{
					maNodeProperties[ NP_SUBITEM ] <<= nSubType;
				}
			}

			if( !maStCondList.empty() )
			{
				Any aAny = AnimationCondition::convertList( pSlide, maStCondList );
 				if( aAny.hasValue() )
				{
					xNode->setBegin( aAny );
				}

			}
			if( !maEndCondList.empty() )
			{
				Any aAny = AnimationCondition::convertList( pSlide, maEndCondList );
				if( aAny.hasValue() )
				{
					xNode->setEnd( aAny );
				}
			}
#if 0  // FIXME even the binary filter has this disabled.
			if( !maNextCondList.empty() )
			{
				Any aAny = AnimationCondition::convertList( pSlide, maNextCondList );
				if( aAny.hasValue() )
				{
					xNode->setNext( aAny );
				}
			}
			if( !maPrevCondList.empty() )
			{
				Any aAny = AnimationCondition::convertList( pSlide, maPrevCondList );
				if( aAny.hasValue() )
				{
					xNode->setPrev( aAny );
				}
			}
#endif
			if( mbHasEndSyncValue )
			{
				Any aValue = maEndSyncValue.convert( pSlide );
				xNode->setEndSync(aValue);
			}

            if( !maUserData.empty() )
            {
                Sequence< NamedValue > aUserDataSeq( static_cast< sal_Int32 >( maUserData.size() ) );
                NamedValue* pValues = aUserDataSeq.getArray();
                for( UserDataMap::const_iterator aIt = maUserData.begin(), aEnd = maUserData.end(); aIt != aEnd; ++aIt, ++pValues )
                {
                    pValues->Name = aIt->first;
                    pValues->Value = aIt->second;
                }
                maNodeProperties[ NP_USERDATA ] <<= aUserDataSeq;
			}

			Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
			Reference< XAnimateColor > xAnimateColor( xNode, UNO_QUERY );
			Reference< XAnimateMotion > xAnimateMotion( xNode, UNO_QUERY );
			Reference< XAnimateTransform > xAnimateTransform( xNode, UNO_QUERY );
			Reference< XCommand > xCommand( xNode, UNO_QUERY );
			Reference< XIterateContainer > xIterateContainer( xNode, UNO_QUERY );
			sal_Int16 nInt16 = 0;
			sal_Bool bBool = sal_False;
			double fDouble = 0;
			OUString sString;
			Sequence< NamedValue > aSeq;

			for( int i = 0; i < _NP_SIZE; i++)
			{
				Any & aValue( maNodeProperties[ i ] );
				if( aValue.hasValue() )
				{
					switch( i )
					{
					case NP_TO:
						if( xAnimate.is() )
							xAnimate->setTo( aValue );
						break;
					case NP_FROM:
						if( xAnimate.is() )
							xAnimate->setFrom( aValue );
						break;
					case NP_BY:
						if( xAnimate.is() )
							xAnimate->setBy( aValue );
						break;
					case NP_TARGET:
						if( xAnimate.is() )
							xAnimate->setTarget( aValue );
						break;
					case NP_SUBITEM:
						if( xAnimate.is() )
						{
							if( aValue >>= nInt16 )
								xAnimate->setSubItem( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_ATTRIBUTENAME:
						if( xAnimate.is() )
						{
							if(	aValue >>= sString )
								xAnimate->setAttributeName( sString );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_CALCMODE:
						if( xAnimate.is() )
						{
							if( aValue >>= nInt16 )
								xAnimate->setCalcMode( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_KEYTIMES:
						if( xAnimate.is() )
						{
							Sequence<double> aKeyTimes;
							if( aValue >>= aKeyTimes )
								xAnimate->setKeyTimes(aKeyTimes);
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_VALUES:
						if( xAnimate.is() )
						{
							Sequence<Any> aValues;
							if( aValue >>= aValues )
								xAnimate->setValues(aValues);
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_FORMULA:
						if( xAnimate.is() )
						{
							if( aValue >>= sString )
								xAnimate->setFormula(sString);
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_COLORINTERPOLATION:
						if( xAnimateColor.is() )
						{
							if( aValue >>= nInt16 )
								xAnimateColor->setColorInterpolation( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_DIRECTION:
						if( xAnimateColor.is() )
						{
							if( aValue >>= bBool )
								xAnimateColor->setDirection( bBool );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_PATH:
						if( xAnimateMotion.is() )
							xAnimateMotion->setPath( aValue );
						break;
					case NP_TRANSFORMTYPE:
						if( xAnimateTransform.is() )
						{
							if( aValue >>= nInt16 )
								xAnimateTransform->setTransformType( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_USERDATA:
						if( aValue >>= aSeq )
							xNode->setUserData( aSeq );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_ACCELERATION:
						if( aValue >>= fDouble )
							xNode->setAcceleration( fDouble );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_DECELERATE:
						if( aValue >>= fDouble )
							xNode->setDecelerate( fDouble );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_AUTOREVERSE:
						if( aValue >>= bBool )
							xNode->setAutoReverse( bBool );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_DURATION:
						xNode->setDuration( aValue );
						break;
					case NP_FILL:
						if( aValue >>= nInt16 )
							xNode->setFill( nInt16 );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_REPEATCOUNT:
						xNode->setRepeatCount( aValue );
						break;
					case NP_REPEATDURATION:
						xNode->setRepeatDuration( aValue );
						break;
					case NP_RESTART:
						if( aValue >>= nInt16 )
							xNode->setRestart( nInt16 );
						else
						{
							OSL_TRACE( "any >>= failed %d", __LINE__ );
						}
						break;
					case NP_COMMAND:
						if( xCommand.is() )
						{
							if( aValue >>= nInt16 )
								xCommand->setCommand( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_PARAMETER:
						if( xCommand.is() )
							xCommand->setParameter( aValue );
						break;
					case NP_ITERATETYPE:
						if( xIterateContainer.is() )
						{
							if( aValue >>= nInt16 )
								xIterateContainer->setIterateType( nInt16 );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					case NP_ITERATEINTERVAL:
						if( xIterateContainer.is() )
						{
							if( aValue >>= fDouble )
								xIterateContainer->setIterateInterval( fDouble );
							else
							{
								OSL_TRACE( "any >>= failed %d", __LINE__ );
							}
						}
						break;
					default:
						OSL_TRACE( "ERR-OOX: unknown prop index %d", i );
						break;
					}
				}
			}

			if( mnNodeType == AnimationNodeType::TRANSITIONFILTER )
			{

				Reference< XTransitionFilter > xFilter( xNode, UNO_QUERY );
				maTransitionFilter.setTransitionFilterProperties( xFilter );
			}

            std::for_each( maChildren.begin(), maChildren.end(),
                           boost::bind(&TimeNode::addNode, _1, boost::cref(rFilter), boost::ref(xNode),
									   boost::ref(pSlide) ) );

			switch( mnNodeType )
			{
			case AnimationNodeType::SEQ:
			{
				sal_Int16 nEnum = 0;
				if( maUserData[ CREATE_OUSTRING( "node-type" ) ] >>= nEnum )
				{
					if( nEnum == EffectNodeType::MAIN_SEQUENCE )
					{
						fixMainSequenceTiming( xNode );
					}
					else if( nEnum ==  EffectNodeType::INTERACTIVE_SEQUENCE )
					{
						fixInteractiveSequenceTiming( xNode );
					}
				}
				break;
			}
			case AnimationNodeType::PAR:
				// some other cut&paste... from AnimationImporter::importAnimationContainer()
				break;
			}
		}
		catch( const Exception& e )
		{
			OSL_TRACE( "OOX: exception raised in TimeNode::setNode() - %s",
								 OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
		}
	}


    Reference< XAnimationNode > TimeNode::createAndInsert(
            const XmlFilterBase& rFilter,
            const OUString& rServiceName,
            const Reference< XAnimationNode >& rxNode )
	{
		try {
            Reference< XAnimationNode > xNode ( rFilter.getServiceFactory()->createInstance( rServiceName ), UNO_QUERY_THROW );
			Reference< XTimeContainer > xParentContainer( rxNode, UNO_QUERY_THROW );

			xParentContainer->appendChild( xNode );
			return xNode;
		}
		catch( const Exception& e )
		{
			OSL_TRACE( "OOX: exception raised in TimeNode::createAndInsert() trying to create a service %s = %s",
								 OUStringToOString( rServiceName, RTL_TEXTENCODING_ASCII_US ).getStr(),
								 OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
		}

		return Reference< XAnimationNode >();
	}


	void 	TimeNode::setId( sal_Int32 nId )
	{
		msId = OUString::valueOf(nId);
	}

	void TimeNode::setTo( const Any & aTo )
	{
		maNodeProperties[ NP_TO ] = aTo;
	}


	void TimeNode::setFrom( const Any & aFrom )
	{
		maNodeProperties[ NP_FROM ] = aFrom;
	}

	void TimeNode::setBy( const Any & aBy )
	{
		maNodeProperties[ NP_BY ] = aBy;
	}


} }