/**************************************************************
*
* 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/timenodelistcontext.hxx"
#include "comphelper/anytostring.hxx"
#include "cppuhelper/exc_hlp.hxx"
#include <osl/diagnose.h>
#include <rtl/math.hxx>
#include <com/sun/star/animations/XTimeContainer.hpp>
#include <com/sun/star/animations/XAnimationNode.hpp>
#include <com/sun/star/animations/XAnimateColor.hpp>
#include <com/sun/star/animations/XAnimateSet.hpp>
#include <com/sun/star/animations/XAnimateTransform.hpp>
#include <com/sun/star/animations/AnimationTransformType.hpp>
#include <com/sun/star/animations/AnimationCalcMode.hpp>
#include <com/sun/star/animations/AnimationColorSpace.hpp>
#include <com/sun/star/animations/AnimationNodeType.hpp>
#include <com/sun/star/animations/XCommand.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/presentation/EffectCommands.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include "oox/helper/attributelist.hxx"
#include "oox/core/xmlfilterbase.hxx"
#include "oox/drawingml/drawingmltypes.hxx"
#include "oox/drawingml/colorchoicecontext.hxx"
#include "oox/ppt/slidetransition.hxx"
#include "animvariantcontext.hxx"
#include "commonbehaviorcontext.hxx"
#include "conditioncontext.hxx"
#include "commontimenodecontext.hxx"
#include "timeanimvaluecontext.hxx"
#include "animationtypes.hxx"
using namespace ::oox::core;
using namespace ::oox::drawingml;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::animations;
using namespace ::com::sun::star::presentation;
using namespace ::com::sun::star::xml::sax;
using namespace ::com::sun::star::awt;
using ::com::sun::star::beans::NamedValue;
using ::rtl::OUString;
namespace oox { namespace ppt {
struct AnimColor
{
AnimColor(sal_Int16 cs, sal_Int32 o, sal_Int32 t, sal_Int32 th )
: colorSpace( cs ), one( o ), two( t ), three( th )
{
}
Any get()
{
sal_Int32 nColor;
Sequence< double > aHSL( 3 );
Any aColor;
switch( colorSpace )
{
case AnimationColorSpace::HSL:
aHSL[ 0 ] = double(one) / 100000;
aHSL[ 1 ] = double(two) / 100000;
aHSL[ 2 ] = double(three) / 100000;
aColor = Any(aHSL);
break;
case AnimationColorSpace::RGB:
nColor = ( ( ( one * 128 ) / 1000 ) & 0xff ) << 16
| ( ( ( two * 128 ) / 1000 ) & 0xff ) << 8
| ( ( ( three * 128 ) / 1000 ) & 0xff );
aColor = Any(nColor);
break;
default:
nColor = 0;
aColor = Any( nColor );
break;
}
return aColor;
}
sal_Int16 colorSpace;
sal_Int32 one;
sal_Int32 two;
sal_Int32 three;
};
/** CT_TLMediaNodeAudio
CT_TLMediaNodeVideo */
class MediaNodeContext
: public TimeNodeContext
{
public:
MediaNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
, mbIsNarration( false )
, mbFullScrn( false )
{
AttributeList attribs( xAttribs );
switch( aElement )
{
case PPT_TOKEN( audio ):
mbIsNarration = attribs.getBool( XML_isNarration, false );
break;
case PPT_TOKEN( video ):
mbFullScrn = attribs.getBool( XML_fullScrn, false );
break;
default:
break;
}
}
virtual void SAL_CALL endFastElement( sal_Int32 aElement )
throw ( SAXException, RuntimeException)
{
if( aElement == PPT_TOKEN( audio ) )
{
// TODO deal with mbIsNarration
}
else if( aElement == PPT_TOKEN( video ) )
{
// TODO deal with mbFullScrn
}
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
bool mbIsNarration;
bool mbFullScrn;
};
/** CT_TLSetBehavior
*/
class SetTimeNodeContext
: public TimeNodeContext
{
public:
SetTimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
}
~SetTimeNodeContext() throw ()
{
if( maTo.hasValue() )
{
// TODO
// HACK !!! discard and refactor
OUString aString;
if( maTo >>= aString )
{
OSL_TRACE( "Magic conversion %s", OUSTRING_TO_CSTR( aString ) );
maTo = makeAny( aString.equalsAscii( "visible" ) ? sal_True : sal_False );
if( !maTo.has<sal_Bool>() )
OSL_TRACE( "conversion failed" );
}
mpNode->setTo( maTo );
}
}
virtual void SAL_CALL endFastElement( sal_Int32 /*aElement*/ )
throw ( SAXException, RuntimeException)
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( to ):
// CT_TLAnimVariant
xRet.set( new AnimVariantContext( *this, aElementToken, maTo ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
Any maTo;
};
/** CT_TLCommandBehavior
*/
class CmdTimeNodeContext
: public TimeNodeContext
{
public:
CmdTimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
, maType(0)
{
switch ( aElement )
{
case PPT_TOKEN( cmd ):
msCommand = xAttribs->getOptionalValue( XML_cmd );
maType = xAttribs->getOptionalValueToken( XML_type, 0 );
break;
default:
break;
}
}
~CmdTimeNodeContext() throw ()
{
}
virtual void SAL_CALL endFastElement( sal_Int32 aElement )
throw ( SAXException, RuntimeException)
{
if( aElement == PPT_TOKEN( cmd ) )
{
try {
// see sd/source/filter/ppt/pptinanimations.cxx
// in AnimationImporter::importCommandContainer()
// REFACTOR?
// a good chunk of this code has been copied verbatim *sigh*
sal_Int16 nCommand = EffectCommands::CUSTOM;
NamedValue aParamValue;
switch( maType )
{
case XML_verb:
aParamValue.Name = OUString(RTL_CONSTASCII_USTRINGPARAM("Verb"));
// TODO make sure msCommand has what we want
aParamValue.Value <<= msCommand.toInt32();
nCommand = EffectCommands::VERB;
break;
case XML_evt:
case XML_call:
if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "onstopaudio" ) ) )
{
nCommand = EffectCommands::STOPAUDIO;
}
else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("play") ) )
{
nCommand = EffectCommands::PLAY;
}
else if( msCommand.compareToAscii( RTL_CONSTASCII_STRINGPARAM("playFrom") ) == 0 )
{
const OUString aMediaTime( msCommand.copy( 9, msCommand.getLength() - 10 ) );
rtl_math_ConversionStatus eStatus;
double fMediaTime = ::rtl::math::stringToDouble( aMediaTime, (sal_Unicode)('.'), (sal_Unicode)(','), &eStatus, NULL );
if( eStatus == rtl_math_ConversionStatus_Ok )
{
aParamValue.Name = CREATE_OUSTRING("MediaTime");
aParamValue.Value <<= fMediaTime;
}
nCommand = EffectCommands::PLAY;
}
else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("togglePause") ) )
{
nCommand = EffectCommands::TOGGLEPAUSE;
}
else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("stop") ) )
{
nCommand = EffectCommands::STOP;
}
break;
}
mpNode->getNodeProperties()[ NP_COMMAND ] = makeAny((sal_Int16)nCommand);
if( nCommand == EffectCommands::CUSTOM )
{
OSL_TRACE("OOX: CmdTimeNodeContext::endFastElement(), unknown command!");
aParamValue.Name = CREATE_OUSTRING("UserDefined");
aParamValue.Value <<= msCommand;
}
if( aParamValue.Value.hasValue() )
{
Sequence< NamedValue > aParamSeq( &aParamValue, 1 );
mpNode->getNodeProperties()[ NP_PARAMETER ] = makeAny( aParamSeq );
}
}
catch( RuntimeException& )
{
OSL_TRACE( "OOX: Exception in CmdTimeNodeContext::endFastElement()" );
}
}
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
OUString msCommand;
sal_Int32 maType;
};
/** CT_TLTimeNodeSequence
*/
class SequenceTimeNodeContext
: public TimeNodeContext
{
public:
SequenceTimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
, mnNextAc(0)
, mnPrevAc(0)
{
AttributeList attribs(xAttribs);
mbConcurrent = attribs.getBool( XML_concurrent, false );
// ST_TLNextActionType { none, seek }
mnNextAc = xAttribs->getOptionalValueToken( XML_nextAc, 0 );
// ST_TLPreviousActionType { none, skipTimed }
mnPrevAc = xAttribs->getOptionalValueToken( XML_prevAc, 0 );
}
~SequenceTimeNodeContext() throw()
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cTn ):
xRet.set( new CommonTimeNodeContext( *this, aElementToken, xAttribs, mpNode ) );
break;
case PPT_TOKEN( nextCondLst ):
xRet.set( new CondListContext( *this, aElementToken, xAttribs, mpNode,
mpNode->getNextCondition() ) );
break;
case PPT_TOKEN( prevCondLst ):
xRet.set( new CondListContext( *this, aElementToken, xAttribs, mpNode,
mpNode->getPrevCondition() ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
bool mbConcurrent;
sal_Int32 mnNextAc, mnPrevAc;
};
/** CT_TLTimeNodeParallel
* CT_TLTimeNodeExclusive
*/
class ParallelExclTimeNodeContext
: public TimeNodeContext
{
public:
ParallelExclTimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cTn ):
xRet.set( new CommonTimeNodeContext( *this, aElementToken, xAttribs, mpNode ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
protected:
};
/** CT_TLAnimateColorBehavior */
class AnimColorContext
: public TimeNodeContext
{
public:
AnimColorContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
// ST_TLAnimateColorSpace ( XML_rgb, XML_hsl }
, mnColorSpace( xAttribs->getOptionalValueToken( XML_clrSpc, 0 ) )
// ST_TLAnimateColorDirection { XML_cw, XML_ccw }
, mnDir( xAttribs->getOptionalValueToken( XML_dir, 0 ) )
, mbHasByColor( false )
, m_byColor( AnimationColorSpace::RGB, 0, 0, 0)
{
}
~AnimColorContext() throw()
{
}
virtual void SAL_CALL endFastElement( sal_Int32 aElement ) throw ( SAXException, RuntimeException)
{
//xParentNode
if( aElement == mnElement )
{
NodePropertyMap & pProps(mpNode->getNodeProperties());
pProps[ NP_DIRECTION ] = makeAny( mnDir == XML_cw );
pProps[ NP_COLORINTERPOLATION ] = makeAny( mnColorSpace == XML_hsl ? AnimationColorSpace::HSL : AnimationColorSpace::RGB );
const GraphicHelper& rGraphicHelper = getFilter().getGraphicHelper();
if( maToClr.isUsed() )
mpNode->setTo( Any( maToClr.getColor( rGraphicHelper ) ) );
if( maFromClr.isUsed() )
mpNode->setFrom( Any( maFromClr.getColor( rGraphicHelper ) ) );
if( mbHasByColor )
mpNode->setBy( m_byColor.get() );
}
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( hsl ):
// CT_TLByHslColorTransform
{
if( mbHasByColor )
{
m_byColor.colorSpace = AnimationColorSpace::HSL;
m_byColor.one = xAttribs->getOptionalValue( XML_h ).toInt32( );
m_byColor.two = xAttribs->getOptionalValue( XML_s ).toInt32( );
m_byColor.three = xAttribs->getOptionalValue( XML_l ).toInt32( );
}
xRet.set(this);
break;
}
case PPT_TOKEN( rgb ):
{
if( mbHasByColor )
{
// CT_TLByRgbColorTransform
m_byColor.colorSpace = AnimationColorSpace::RGB;
m_byColor.one = xAttribs->getOptionalValue( XML_r ).toInt32();
m_byColor.two = xAttribs->getOptionalValue( XML_g ).toInt32();
m_byColor.three = xAttribs->getOptionalValue( XML_b ).toInt32();
}
xRet.set(this);
break;
}
case PPT_TOKEN( by ):
// CT_TLByAnimateColorTransform
mbHasByColor = true;
xRet.set(this);
break;
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( to ):
// CT_Color
xRet.set( new ColorContext( *this, maToClr ) );
break;
case PPT_TOKEN( from ):
// CT_Color
xRet.set( new ColorContext( *this, maFromClr ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
sal_Int32 mnColorSpace;
sal_Int32 mnDir;
bool mbHasByColor;
AnimColor m_byColor;
oox::drawingml::Color maToClr;
oox::drawingml::Color maFromClr;
};
/** CT_TLAnimateBehavior */
class AnimContext
: public TimeNodeContext
{
public:
AnimContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
NodePropertyMap & aProps( pNode->getNodeProperties() );
sal_Int32 nCalcMode = xAttribs->getOptionalValueToken( XML_calcmode, 0 );
if(nCalcMode)
{
sal_Int16 nEnum = 0;
switch(nCalcMode)
{
case XML_discrete:
nEnum = AnimationCalcMode::DISCRETE;
break;
case XML_lin:
nEnum = AnimationCalcMode::LINEAR;
break;
case XML_fmla:
default:
// TODO what value is good ?
nEnum = AnimationCalcMode::DISCRETE;
break;
}
aProps[ NP_CALCMODE ] = makeAny(nEnum);
}
OUString aStr;
aStr = xAttribs->getOptionalValue( XML_from );
if( aStr.getLength() )
{
pNode->setFrom( makeAny( aStr ) );
}
aStr = xAttribs->getOptionalValue( XML_by );
if( aStr.getLength() )
{
pNode->setBy( makeAny( aStr ) );
}
aStr = xAttribs->getOptionalValue( XML_to );
if( aStr.getLength() )
{
pNode->setTo( makeAny( aStr ) );
}
mnValueType = xAttribs->getOptionalValueToken( XML_valueType, 0 );
}
~AnimContext() throw ()
{
::std::list< TimeAnimationValue >::iterator iter, end;
int nKeyTimes = maTavList.size();
if( nKeyTimes > 0)
{
int i;
Sequence< double > aKeyTimes( nKeyTimes );
Sequence< Any > aValues( nKeyTimes );
NodePropertyMap & aProps( mpNode->getNodeProperties() );
end = maTavList.end();
for(iter = maTavList.begin(), i=0; iter != end; iter++,i++)
{
// TODO what to do if it is Timing_INFINITE ?
Any aTime = GetTimeAnimateValueTime( iter->msTime );
aTime >>= aKeyTimes[i];
aValues[i] = iter->maValue;
OUString aTest;
iter->maValue >>= aTest;
if( aTest.getLength() != 0 )
{
aValues[i] = iter->maValue;
}
else
{
aProps[ NP_FORMULA ] <<= iter->msFormula;
}
}
aProps[ NP_VALUES ] <<= aValues;
aProps[ NP_KEYTIMES ] <<= aKeyTimes;
}
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( tavLst ):
xRet.set( new TimeAnimValueListContext ( *this, xAttribs, maTavList ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
sal_Int32 mnValueType;
TimeAnimationValueList maTavList;
};
/** CT_TLAnimateScaleBehavior */
class AnimScaleContext
: public TimeNodeContext
{
public:
AnimScaleContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
, mbZoomContents( false )
{
AttributeList attribs( xAttribs );
// TODO what to do with mbZoomContents
mbZoomContents = attribs.getBool( XML_zoomContents, false );
pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
= makeAny((sal_Int16)AnimationTransformType::SCALE);
}
~AnimScaleContext( ) throw( )
{
}
virtual void SAL_CALL endFastElement( sal_Int32 aElement ) throw ( SAXException, RuntimeException)
{
if( aElement == mnElement )
{
if( maTo.hasValue() )
{
mpNode->setTo( maTo );
}
if( maBy.hasValue() )
{
mpNode->setBy( maBy );
}
if( maFrom.hasValue() )
{
mpNode->setFrom( maFrom );
}
}
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( to ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
maTo <<= p.X;
maTo <<= p.Y;
break;
}
case PPT_TOKEN( from ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
maFrom <<= p.X;
maFrom <<= p.Y;
break;
}
case PPT_TOKEN( by ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
maBy <<= p.X;
maBy <<= p.Y;
break;
}
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
Any maBy;
Any maFrom;
Any maTo;
bool mbZoomContents;
};
/** CT_TLAnimateRotationBehavior */
class AnimRotContext
: public TimeNodeContext
{
public:
AnimRotContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
AttributeList attribs( xAttribs );
pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
= makeAny((sal_Int16)AnimationTransformType::ROTATE);
// TODO make sure the units are OK
if(attribs.hasAttribute( XML_by ) )
{
sal_Int32 nBy = attribs.getInteger( XML_by, 0 );
pNode->setBy( makeAny( (double)nBy ) );
}
if(attribs.hasAttribute( XML_from ) )
{
sal_Int32 nFrom = attribs.getInteger( XML_from, 0 );
pNode->setFrom( makeAny( nFrom ) );
}
if(attribs.hasAttribute( XML_to ) )
{
sal_Int32 nTo = attribs.getInteger( XML_to, 0 );
pNode->setTo( makeAny( nTo ) );
}
}
~AnimRotContext( ) throw( )
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
};
/** CT_TLAnimateMotionBehavior */
class AnimMotionContext
: public TimeNodeContext
{
public:
AnimMotionContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
= makeAny((sal_Int16)AnimationTransformType::TRANSLATE);
AttributeList attribs( xAttribs );
// ST_TLAnimateMotionBehaviorOrigin { parent, layour }
sal_Int32 nOrigin = xAttribs->getOptionalValueToken( XML_origin, 0 );
if( nOrigin != 0 )
{
switch(nOrigin)
{
case XML_layout:
case XML_parent:
break;
}
// TODO
}
OUString aStr = xAttribs->getOptionalValue( XML_path );
aStr = aStr.replace( 'E', ' ' );
aStr = aStr.trim();
pNode->getNodeProperties()[ NP_PATH ] = makeAny(aStr);
// ST_TLAnimateMotionPathEditMode{ fixed, relative }
mnPathEditMode = xAttribs->getOptionalValueToken( XML_pathEditMode, 0 );
msPtsTypes = xAttribs->getOptionalValue( XML_ptsTypes );
mnAngle = attribs.getInteger( XML_rAng, 0 );
// TODO make sure the units are right. Likely not.
}
~AnimMotionContext( ) throw()
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
const Reference< XFastAttributeList >& xAttribs )
throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( to ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
Any rAny;
rAny <<= p.X;
rAny <<= p.Y;
mpNode->setTo( rAny );
break;
}
case PPT_TOKEN( from ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
Any rAny;
rAny <<= p.X;
rAny <<= p.Y;
mpNode->setFrom( rAny );
break;
}
case PPT_TOKEN( by ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
Any rAny;
rAny <<= p.X;
rAny <<= p.Y;
mpNode->setBy( rAny );
break;
}
case PPT_TOKEN( rCtr ):
{
// CT_TLPoint
Point p = GetPointPercent( xAttribs );
// TODO push
break;
}
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
OUString msPtsTypes;
sal_Int32 mnPathEditMode;
sal_Int32 mnAngle;
};
/** CT_TLAnimateEffectBehavior */
class AnimEffectContext
: public TimeNodeContext
{
public:
AnimEffectContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode ) throw()
: TimeNodeContext( rParent, aElement, xAttribs, pNode )
{
sal_Int32 nDir = xAttribs->getOptionalValueToken( XML_transition, 0 );
OUString sFilter = xAttribs->getOptionalValue( XML_filter );
// TODO
// OUString sPrList = xAttribs->getOptionalValue( XML_prLst );
if( sFilter.getLength() )
{
SlideTransition aFilter( sFilter );
aFilter.setMode( nDir == XML_out ? false : true );
pNode->setTransitionFilter( aFilter );
}
}
~AnimEffectContext( ) throw()
{
}
virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
{
Reference< XFastContextHandler > xRet;
switch ( aElementToken )
{
case PPT_TOKEN( cBhvr ):
xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
break;
case PPT_TOKEN( progress ):
xRet.set( new AnimVariantContext( *this, aElementToken, maProgress ) );
// TODO handle it.
break;
default:
break;
}
if( !xRet.is() )
xRet.set( this );
return xRet;
}
private:
Any maProgress;
OUString msFilter;
OUString msPrList;
};
TimeNodeContext * TimeNodeContext::makeContext(
ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& xAttribs,
const TimeNodePtr & pNode )
{
TimeNodeContext *pCtx = NULL;
switch( aElement )
{
case PPT_TOKEN( animClr ):
pCtx = new AnimColorContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( par ):
pCtx = new ParallelExclTimeNodeContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( seq ):
pCtx = new SequenceTimeNodeContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( excl ):
pCtx = new ParallelExclTimeNodeContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( anim ):
pCtx = new AnimContext ( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( animEffect ):
pCtx = new AnimEffectContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( animMotion ):
pCtx = new AnimMotionContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( animRot ):
pCtx = new AnimRotContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( animScale ):
pCtx = new AnimScaleContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( cmd ):
pCtx = new CmdTimeNodeContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( set ):
pCtx = new SetTimeNodeContext( rParent, aElement, xAttribs, pNode );
break;
case PPT_TOKEN( audio ):
case PPT_TOKEN( video ):
pCtx = new MediaNodeContext( rParent, aElement, xAttribs, pNode );
break;
default:
break;
}
return pCtx;
}
TimeNodeContext::TimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
const Reference< XFastAttributeList >& /*xAttribs*/,
const TimeNodePtr & pNode ) throw()
: ContextHandler( rParent )
, mnElement( aElement )
, mpNode( pNode )
{
}
TimeNodeContext::~TimeNodeContext( ) throw()
{
}
TimeNodeListContext::TimeNodeListContext( ContextHandler& rParent, TimeNodePtrList & aList )
throw()
: ContextHandler( rParent )
, maList( aList )
{
}
TimeNodeListContext::~TimeNodeListContext( ) throw()
{
}
Reference< XFastContextHandler > SAL_CALL TimeNodeListContext::createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException)
{
Reference< XFastContextHandler > xRet;
sal_Int16 nNodeType;
switch( aElementToken )
{
case PPT_TOKEN( par ):
nNodeType = AnimationNodeType::PAR;
break;
case PPT_TOKEN( seq ):
nNodeType = AnimationNodeType::SEQ;
break;
case PPT_TOKEN( excl ):
// TODO pick the right type. We choose parallel for now as
// there does not seem to be an "Exclusive"
nNodeType = AnimationNodeType::PAR;
break;
case PPT_TOKEN( anim ):
nNodeType = AnimationNodeType::ANIMATE;
break;
case PPT_TOKEN( animClr ):
nNodeType = AnimationNodeType::ANIMATECOLOR;
break;
case PPT_TOKEN( animEffect ):
nNodeType = AnimationNodeType::TRANSITIONFILTER;
break;
case PPT_TOKEN( animMotion ):
nNodeType = AnimationNodeType::ANIMATEMOTION;
break;
case PPT_TOKEN( animRot ):
case PPT_TOKEN( animScale ):
nNodeType = AnimationNodeType::ANIMATETRANSFORM;
break;
case PPT_TOKEN( cmd ):
nNodeType = AnimationNodeType::COMMAND;
break;
case PPT_TOKEN( set ):
nNodeType = AnimationNodeType::SET;
break;
case PPT_TOKEN( audio ):
nNodeType = AnimationNodeType::AUDIO;
break;
case PPT_TOKEN( video ):
nNodeType = AnimationNodeType::AUDIO;
OSL_TRACE( "OOX: video requested, gave Audio instead" );
break;
default:
nNodeType = AnimationNodeType::CUSTOM;
OSL_TRACE( "OOX: uhandled token %x", aElementToken );
break;
}
TimeNodePtr pNode(new TimeNode(nNodeType));
maList.push_back( pNode );
ContextHandler * pContext = TimeNodeContext::makeContext( *this, aElementToken, xAttribs, pNode );
xRet.set( pContext ? pContext : this );
return xRet;
}
} }