/**************************************************************
*
* 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include <tools/debug.hxx>
#include <com/sun/star/util/XCloneable.hpp>
#include <com/sun/star/animations/AnimationFill.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/presentation/EffectNodeType.hpp>
#include <com/sun/star/presentation/EffectCommands.hpp>
#include <com/sun/star/presentation/EffectPresetClass.hpp>
#include <com/sun/star/presentation/ParagraphTarget.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
#include <com/sun/star/animations/AnimationNodeType.hpp>
#include <com/sun/star/animations/XCommand.hpp>
#include <com/sun/star/animations/AnimationTransformType.hpp>
#include <com/sun/star/animations/XIterateContainer.hpp>
#include <com/sun/star/animations/XAnimateTransform.hpp>
#include <com/sun/star/animations/Event.hpp>
#include <com/sun/star/animations/EventTrigger.hpp>
#include <com/sun/star/animations/Timing.hpp>
#include <com/sun/star/drawing/XDrawPage.hpp>
#include <com/sun/star/text/XText.hpp>
#include <com/sun/star/animations/XAnimate.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/util/XChangesNotifier.hpp>
#include <com/sun/star/animations/XAnimateMotion.hpp>
#include <comphelper/processfactory.hxx>
#include <comphelper/sequence.hxx>
#include <com/sun/star/lang/Locale.hpp>
#include <com/sun/star/i18n/XBreakIterator.hpp>
#include <com/sun/star/i18n/CharacterIteratorMode.hpp>
#ifndef _COM_SUN_STAR_TEXT_WORDTYPE_HPP_
#include <com/sun/star/i18n/WordType.hpp>
#endif
#include <com/sun/star/presentation/TextAnimationType.hpp>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <algorithm>
#include <cppuhelper/implbase1.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <svx/sdr/contact/viewcontact.hxx>
#include <svx/svdopath.hxx>
#include <svx/svdpage.hxx>
#include <svx/unoapi.hxx>
#include "CustomAnimationEffect.hxx"
#include <CustomAnimationPreset.hxx>
#include "animations.hxx"
using namespace ::com::sun::star;
using namespace ::com::sun::star::presentation;
using namespace ::com::sun::star::animations;
using ::rtl::OUString;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::uno::XInterface;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::uno::UNO_QUERY_THROW;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::makeAny;
using ::com::sun::star::uno::Exception;
using ::com::sun::star::uno::RuntimeException;
using ::com::sun::star::container::XEnumerationAccess;
using ::com::sun::star::container::XEnumeration;
using ::com::sun::star::beans::NamedValue;
using ::com::sun::star::container::XChild;
using ::com::sun::star::container::XElementAccess;
using ::com::sun::star::drawing::XShape;
using ::com::sun::star::lang::XInitialization;
using ::com::sun::star::drawing::XShapes;
using ::com::sun::star::drawing::XDrawPage;
using ::com::sun::star::text::XText;
using ::com::sun::star::text::XTextRange;
using ::com::sun::star::beans::XPropertySet;
using ::com::sun::star::lang::XMultiServiceFactory;
using ::com::sun::star::util::XCloneable;
using ::com::sun::star::lang::Locale;
using ::com::sun::star::util::XChangesNotifier;
using ::com::sun::star::util::XChangesListener;
namespace sd
{
class MainSequenceChangeGuard
{
public:
MainSequenceChangeGuard( EffectSequenceHelper* pSequence )
{
mpMainSequence = dynamic_cast< MainSequence* >( pSequence );
if( mpMainSequence == 0 )
{
InteractiveSequence* pI = dynamic_cast< InteractiveSequence* >( pSequence );
if( pI )
mpMainSequence = pI->mpMainSequence;
}
DBG_ASSERT( mpMainSequence, "sd::MainSequenceChangeGuard::MainSequenceChangeGuard(), no main sequence to guard!" );
if( mpMainSequence )
mpMainSequence->mbIgnoreChanges++;
}
~MainSequenceChangeGuard()
{
if( mpMainSequence )
mpMainSequence->mbIgnoreChanges++;
}
private:
MainSequence* mpMainSequence;
};
CustomAnimationEffect::CustomAnimationEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
: mnNodeType(-1),
mnPresetClass(-1),
mfBegin(-1.0),
mfDuration(-1.0),
mfAbsoluteDuration(-1.0),
mnGroupId(-1),
mnIterateType(0),
mfIterateInterval(0.0),
mnParaDepth( -1 ),
mbHasText(sal_False),
mfAcceleration( 1.0 ),
mfDecelerate( 1.0 ),
mbAutoReverse(false),
mnTargetSubItem(0),
mnCommand(0),
mpEffectSequence( 0 ),
mbHasAfterEffect(false),
mbAfterEffectOnNextEffect(false)
{
setNode( xNode );
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setNode( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
{
mxNode = xNode;
mxAudio.clear();
Sequence< NamedValue > aUserData( mxNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
const NamedValue* p = aUserData.getConstArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "node-type" ) )
{
p->Value >>= mnNodeType;
}
else if( p->Name.equalsAscii( "preset-id" ) )
{
p->Value >>= maPresetId;
}
else if( p->Name.equalsAscii( "preset-sub-type" ) )
{
p->Value >>= maPresetSubType;
}
else if( p->Name.equalsAscii( "preset-class" ) )
{
p->Value >>= mnPresetClass;
}
else if( p->Name.equalsAscii( "preset-property" ) )
{
p->Value >>= maProperty;
}
else if( p->Name.equalsAscii( "group-id" ) )
{
p->Value >>= mnGroupId;
}
p++;
}
// get effect start time
mxNode->getBegin() >>= mfBegin;
mfAcceleration = mxNode->getAcceleration();
mfDecelerate = mxNode->getDecelerate();
mbAutoReverse = mxNode->getAutoReverse();
// get iteration data
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
if( xIter.is() )
{
mfIterateInterval = xIter->getIterateInterval();
mnIterateType = xIter->getIterateType();
maTarget = xIter->getTarget();
mnTargetSubItem = xIter->getSubItem();
}
else
{
mfIterateInterval = 0.0f;
mnIterateType = 0;
}
// calculate effect duration and get target shape
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
if( !xChildNode.is() )
continue;
if( xChildNode->getType() == AnimationNodeType::AUDIO )
{
mxAudio.set( xChildNode, UNO_QUERY );
}
else if( xChildNode->getType() == AnimationNodeType::COMMAND )
{
Reference< XCommand > xCommand( xChildNode, UNO_QUERY );
if( xCommand.is() )
{
mnCommand = xCommand->getCommand();
if( !maTarget.hasValue() )
maTarget = xCommand->getTarget();
}
}
else
{
double fBegin = 0.0;
double fDuration = 0.0;
xChildNode->getBegin() >>= fBegin;
xChildNode->getDuration() >>= fDuration;
fDuration += fBegin;
if( fDuration > mfDuration )
mfDuration = fDuration;
// no target shape yet?
if( !maTarget.hasValue() )
{
// go get it boys!
Reference< XAnimate > xAnimate( xChildNode, UNO_QUERY );
if( xAnimate.is() )
{
maTarget = xAnimate->getTarget();
mnTargetSubItem = xAnimate->getSubItem();
}
}
}
}
}
}
mfAbsoluteDuration = mfDuration;
checkForText();
}
// --------------------------------------------------------------------
sal_Int32 CustomAnimationEffect::getNumberOfSubitems( const Any& aTarget, sal_Int16 nIterateType )
{
sal_Int32 nSubItems = 0;
try
{
// first get target text
sal_Int32 nOnlyPara = -1;
Reference< XText > xShape;
aTarget >>= xShape;
if( !xShape.is() )
{
ParagraphTarget aParaTarget;
if( aTarget >>= aParaTarget )
{
xShape.set( aParaTarget.Shape, UNO_QUERY );
nOnlyPara = aParaTarget.Paragraph;
}
}
// now use the break iterator to iterate over the given text
// and count the sub items
if( xShape.is() )
{
// TODO/LATER: Optimize this, don't create a break iterator each time
Reference< lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() );
Reference < i18n::XBreakIterator > xBI( xMSF->createInstance( OUString::createFromAscii( "com.sun.star.i18n.BreakIterator" ) ), UNO_QUERY );
DBG_ASSERT( xBI.is(), "sd::CustomAnimationEffect::getNumberOfSubitems(), could not create a 'com.sun.star.i18n.BreakIterator'!" );
if( xBI.is() )
{
Reference< XEnumerationAccess > xEA( xShape, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEA->createEnumeration(), UNO_QUERY_THROW );
Locale aLocale;
const OUString aStrLocaleName( RTL_CONSTASCII_USTRINGPARAM("CharLocale") );
Reference< XTextRange > xParagraph;
sal_Int32 nPara = 0;
while( xEnumeration->hasMoreElements() )
{
xEnumeration->nextElement() >>= xParagraph;
// skip this if its not the only paragraph we want to count
if( (nOnlyPara != -1) && (nOnlyPara != nPara ) )
continue;
if( nIterateType == TextAnimationType::BY_PARAGRAPH )
{
nSubItems++;
}
else
{
const OUString aText( xParagraph->getString() );
Reference< XPropertySet > xSet( xParagraph, UNO_QUERY_THROW );
xSet->getPropertyValue( aStrLocaleName ) >>= aLocale;
sal_Int32 nPos;
const sal_Int32 nEndPos = aText.getLength();
if( nIterateType == TextAnimationType::BY_WORD )
{
for( nPos = 0; nPos < nEndPos; nPos++ )
{
nPos = xBI->getWordBoundary(aText, nPos, aLocale, i18n::WordType::ANY_WORD, sal_True).endPos;
nSubItems++;
}
break;
}
else
{
sal_Int32 nDone;
for( nPos = 0; nPos < nEndPos; nPos++ )
{
nPos = xBI->nextCharacters(aText, nPos, aLocale, i18n::CharacterIteratorMode::SKIPCELL, 0, nDone);
nSubItems++;
}
}
}
if( nPara == nOnlyPara )
break;
nPara++;
}
}
}
}
catch( Exception& e )
{
(void)e;
nSubItems = 0;
DBG_ERROR( "sd::CustomAnimationEffect::getNumberOfSubitems(), exception caught!" );
}
return nSubItems;
}
// --------------------------------------------------------------------
CustomAnimationEffect::~CustomAnimationEffect()
{
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr CustomAnimationEffect::clone() const
{
Reference< XCloneable > xCloneable( mxNode, UNO_QUERY_THROW );
Reference< XAnimationNode > xNode( xCloneable->createClone(), UNO_QUERY_THROW );
CustomAnimationEffectPtr pEffect( new CustomAnimationEffect( xNode ) );
pEffect->setEffectSequence( getEffectSequence() );
return pEffect;
}
// --------------------------------------------------------------------
sal_Int32 CustomAnimationEffect::get_node_type( const Reference< XAnimationNode >& xNode )
{
sal_Int16 nNodeType = -1;
if( xNode.is() )
{
Sequence< NamedValue > aUserData( xNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
if( nLength )
{
const NamedValue* p = aUserData.getConstArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "node-type" ) )
{
p->Value >>= nNodeType;
break;
}
p++;
}
}
}
return nNodeType;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setPresetClass( sal_Int16 nPresetClass )
{
if( mnPresetClass != nPresetClass )
{
mnPresetClass = nPresetClass;
if( mxNode.is() )
{
// first try to find a "preset-class" entry in the user data
// and change it
Sequence< NamedValue > aUserData( mxNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
bool bFound = false;
if( nLength )
{
NamedValue* p = aUserData.getArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "preset-class" ) )
{
p->Value <<= mnPresetClass;
bFound = true;
break;
}
p++;
}
}
// no "node-type" entry inside user data, so add it
if( !bFound )
{
nLength = aUserData.getLength();
aUserData.realloc( nLength + 1);
aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "preset-class" ) );
aUserData[nLength].Value <<= mnPresetClass;
}
mxNode->setUserData( aUserData );
}
}
}
void CustomAnimationEffect::setNodeType( sal_Int16 nNodeType )
{
if( mnNodeType != nNodeType )
{
mnNodeType = nNodeType;
if( mxNode.is() )
{
// first try to find a "node-type" entry in the user data
// and change it
Sequence< NamedValue > aUserData( mxNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
bool bFound = false;
if( nLength )
{
NamedValue* p = aUserData.getArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "node-type" ) )
{
p->Value <<= mnNodeType;
bFound = true;
break;
}
p++;
}
}
// no "node-type" entry inside user data, so add it
if( !bFound )
{
nLength = aUserData.getLength();
aUserData.realloc( nLength + 1);
aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
aUserData[nLength].Value <<= mnNodeType;
}
mxNode->setUserData( aUserData );
}
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setGroupId( sal_Int32 nGroupId )
{
mnGroupId = nGroupId;
if( mxNode.is() )
{
// first try to find a "group-id" entry in the user data
// and change it
Sequence< NamedValue > aUserData( mxNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
bool bFound = false;
if( nLength )
{
NamedValue* p = aUserData.getArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "group-id" ) )
{
p->Value <<= mnGroupId;
bFound = true;
break;
}
p++;
}
}
// no "node-type" entry inside user data, so add it
if( !bFound )
{
nLength = aUserData.getLength();
aUserData.realloc( nLength + 1);
aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "group-id" ) );
aUserData[nLength].Value <<= mnGroupId;
}
mxNode->setUserData( aUserData );
}
}
// --------------------------------------------------------------------
/** checks if the text for this effect has changed and updates internal flags.
returns true if something changed.
*/
bool CustomAnimationEffect::checkForText()
{
bool bChange = false;
Reference< XText > xText;
if( maTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
// calc para depth
ParagraphTarget aParaTarget;
maTarget >>= aParaTarget;
xText = Reference< XText >::query( aParaTarget.Shape );
// get paragraph
if( xText.is() )
{
Reference< XEnumerationAccess > xEA( xText, UNO_QUERY );
if( xEA.is() )
{
Reference< XEnumeration > xEnumeration( xEA->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
sal_Bool bHasText = xEnumeration->hasMoreElements();
bChange |= bHasText != mbHasText;
mbHasText = bHasText;
sal_Int32 nPara = aParaTarget.Paragraph;
while( xEnumeration->hasMoreElements() && nPara-- )
xEnumeration->nextElement();
if( xEnumeration->hasMoreElements() )
{
Reference< XPropertySet > xParaSet;
xEnumeration->nextElement() >>= xParaSet;
if( xParaSet.is() )
{
sal_Int32 nParaDepth = 0;
const OUString strNumberingLevel( RTL_CONSTASCII_USTRINGPARAM("NumberingLevel") );
xParaSet->getPropertyValue( strNumberingLevel ) >>= nParaDepth;
bChange |= nParaDepth != mnParaDepth;
mnParaDepth = nParaDepth;
}
}
}
}
}
}
else
{
maTarget >>= xText;
sal_Bool bHasText = xText.is() && xText->getString().getLength();
bChange |= bHasText != mbHasText;
mbHasText = bHasText;
}
bChange |= calculateIterateDuration();
return bChange;
}
bool CustomAnimationEffect::calculateIterateDuration()
{
bool bChange = false;
// if we have an iteration, we must also calculate the
// 'true' container duration, that is
// ( ( is form animated ) ? [contained effects duration] : 0 ) +
// ( [number of animated children] - 1 ) * [interval-delay] + [contained effects duration]
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
if( xIter.is() )
{
double fDuration = mfDuration;
const double fSubEffectDuration = mfDuration;
if( mnTargetSubItem != ShapeAnimationSubType::ONLY_BACKGROUND ) // does not make sense for iterate container but better check
{
const sal_Int32 nSubItems = getNumberOfSubitems( maTarget, mnIterateType );
if( nSubItems )
{
const double f = (nSubItems-1) * mfIterateInterval;
fDuration += f;
}
}
// if we also animate the form first, we have to add the
// sub effect duration to the whole effect duration
if( mnTargetSubItem == ShapeAnimationSubType::AS_WHOLE )
fDuration += fSubEffectDuration;
bChange |= fDuration != mfAbsoluteDuration;
mfAbsoluteDuration = fDuration;
}
return bChange;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setTarget( const ::com::sun::star::uno::Any& rTarget )
{
try
{
maTarget = rTarget;
// first, check special case for random node
Reference< XInitialization > xInit( mxNode, UNO_QUERY );
if( xInit.is() )
{
const Sequence< Any > aArgs( &maTarget, 1 );
xInit->initialize( aArgs );
}
else
{
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
if( xIter.is() )
{
xIter->setTarget(maTarget);
}
else
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
const Any aElem( xEnumeration->nextElement() );
Reference< XAnimate > xAnimate( aElem, UNO_QUERY );
if( xAnimate.is() )
xAnimate->setTarget( rTarget );
else
{
Reference< XCommand > xCommand( aElem, UNO_QUERY );
if( xCommand.is() )
xCommand->setTarget( rTarget );
}
}
}
}
}
}
checkForText();
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setTarget(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setTargetSubItem( sal_Int16 nSubItem )
{
try
{
mnTargetSubItem = nSubItem;
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
if( xIter.is() )
{
xIter->setSubItem(mnTargetSubItem);
}
else
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
if( xAnimate.is() )
xAnimate->setSubItem( mnTargetSubItem );
}
}
}
}
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setTargetSubItem(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setDuration( double fDuration )
{
if( (mfDuration != -1.0) && (mfDuration != fDuration) ) try
{
double fScale = fDuration / mfDuration;
mfDuration = fDuration;
mfAbsoluteDuration = mfDuration;
// calculate effect duration and get target shape
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
if( !xChildNode.is() )
continue;
double fChildBegin = 0.0;
xChildNode->getBegin() >>= fChildBegin;
if( fChildBegin != 0.0 )
{
fChildBegin *= fScale;
xChildNode->setBegin( makeAny( fChildBegin ) );
}
double fChildDuration = 0.0;
xChildNode->getDuration() >>= fChildDuration;
if( fChildDuration != 0.0 )
{
fChildDuration *= fScale;
xChildNode->setDuration( makeAny( fChildDuration ) );
}
}
}
}
calculateIterateDuration();
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setDuration(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setBegin( double fBegin )
{
if( mxNode.is() ) try
{
mfBegin = fBegin;
mxNode->setBegin( makeAny( fBegin ) );
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setBegin(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setAcceleration( double fAcceleration )
{
if( mxNode.is() ) try
{
mfAcceleration = fAcceleration;
mxNode->setAcceleration( fAcceleration );
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setAcceleration(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setDecelerate( double fDecelerate )
{
if( mxNode.is() ) try
{
mfDecelerate = fDecelerate;
mxNode->setDecelerate( fDecelerate );
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setDecelerate(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setAutoReverse( sal_Bool bAutoReverse )
{
if( mxNode.is() ) try
{
mbAutoReverse = bAutoReverse;
mxNode->setAutoReverse( bAutoReverse );
}
catch( Exception& )
{
DBG_ERROR( "sd::CustomAnimationEffect::setAutoReverse(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::replaceNode( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
{
sal_Int16 nNodeType = mnNodeType;
Any aTarget = maTarget;
double fBegin = mfBegin;
double fDuration = mfDuration;
double fAcceleration = mfAcceleration;
double fDecelerate = mfDecelerate ;
sal_Bool bAutoReverse = mbAutoReverse;
Reference< XAudio > xAudio( mxAudio );
sal_Int16 nIterateType = mnIterateType;
double fIterateInterval = mfIterateInterval;
sal_Int16 nSubItem = mnTargetSubItem;
setNode( xNode );
setAudio( xAudio );
setNodeType( nNodeType );
setTarget( aTarget );
setTargetSubItem( nSubItem );
setDuration( fDuration );
setBegin( fBegin );
setAcceleration( fAcceleration );
setDecelerate( fDecelerate );
setAutoReverse( bAutoReverse );
if( nIterateType != mnIterateType )
setIterateType( nIterateType );
if( mnIterateType && ( fIterateInterval != mfIterateInterval ) )
setIterateInterval( fIterateInterval );
}
// --------------------------------------------------------------------
Reference< XShape > CustomAnimationEffect::getTargetShape() const
{
Reference< XShape > xShape;
maTarget >>= xShape;
if( !xShape.is() )
{
ParagraphTarget aParaTarget;
if( maTarget >>= aParaTarget )
xShape = aParaTarget.Shape;
}
return xShape;
}
// --------------------------------------------------------------------
Any CustomAnimationEffect::getRepeatCount() const
{
if( mxNode.is() )
{
return mxNode->getRepeatCount();
}
else
{
Any aAny;
return aAny;
}
}
// --------------------------------------------------------------------
Any CustomAnimationEffect::getEnd() const
{
if( mxNode.is() )
{
return mxNode->getEnd();
}
else
{
Any aAny;
return aAny;
}
}
// --------------------------------------------------------------------
sal_Int16 CustomAnimationEffect::getFill() const
{
if( mxNode.is() )
return mxNode->getFill();
else
return 0;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setRepeatCount( const Any& rRepeatCount )
{
if( mxNode.is() )
mxNode->setRepeatCount( rRepeatCount );
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setEnd( const Any& rEnd )
{
if( mxNode.is() )
mxNode->setEnd( rEnd );
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setFill( sal_Int16 nFill )
{
if( mxNode.is() )
mxNode->setFill( nFill );
}
// --------------------------------------------------------------------
Reference< XAnimationNode > CustomAnimationEffect::createAfterEffectNode() const throw (Exception)
{
DBG_ASSERT( mbHasAfterEffect, "sd::CustomAnimationEffect::createAfterEffectNode(), this node has no after effect!" );
Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
const char* pServiceName = maDimColor.hasValue() ?
"com.sun.star.animations.AnimateColor" : "com.sun.star.animations.AnimateSet";
Reference< XAnimate > xAnimate( xMsf->createInstance(OUString::createFromAscii(pServiceName) ), UNO_QUERY_THROW );
Any aTo;
OUString aAttributeName;
if( maDimColor.hasValue() )
{
aTo = maDimColor;
aAttributeName = OUString( RTL_CONSTASCII_USTRINGPARAM( "DimColor" ) );
}
else
{
aTo = makeAny( (sal_Bool)sal_False );
aAttributeName = OUString( RTL_CONSTASCII_USTRINGPARAM( "Visibility" ) );
}
Any aBegin;
if( !mbAfterEffectOnNextEffect ) // sameClick
{
Event aEvent;
aEvent.Source <<= getNode();
aEvent.Trigger = EventTrigger::END_EVENT;
aEvent.Repeat = 0;
aBegin <<= aEvent;
}
else
{
aBegin <<= (double)0.0;
}
xAnimate->setBegin( aBegin );
xAnimate->setTo( aTo );
xAnimate->setAttributeName( aAttributeName );
xAnimate->setDuration( makeAny( (double)0.001 ) );
xAnimate->setFill( AnimationFill::HOLD );
xAnimate->setTarget( maTarget );
return Reference< XAnimationNode >( xAnimate, UNO_QUERY_THROW );
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setIterateType( sal_Int16 nIterateType )
{
if( mnIterateType != nIterateType ) try
{
// do we need to exchange the container node?
if( (mnIterateType == 0) || (nIterateType == 0) )
{
sal_Int16 nTargetSubItem = mnTargetSubItem;
Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
const char * pServiceName =
nIterateType ? "com.sun.star.animations.IterateContainer" : "com.sun.star.animations.ParallelTimeContainer";
Reference< XTimeContainer > xNewContainer(
xMsf->createInstance( OUString::createFromAscii(pServiceName) ), UNO_QUERY_THROW );
Reference< XTimeContainer > xOldContainer( mxNode, UNO_QUERY_THROW );
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
xOldContainer->removeChild( xChildNode );
xNewContainer->appendChild( xChildNode );
}
Reference< XAnimationNode > xNewNode( xNewContainer, UNO_QUERY_THROW );
xNewNode->setBegin( mxNode->getBegin() );
xNewNode->setDuration( mxNode->getDuration() );
xNewNode->setEnd( mxNode->getEnd() );
xNewNode->setEndSync( mxNode->getEndSync() );
xNewNode->setRepeatCount( mxNode->getRepeatCount() );
xNewNode->setFill( mxNode->getFill() );
xNewNode->setFillDefault( mxNode->getFillDefault() );
xNewNode->setRestart( mxNode->getRestart() );
xNewNode->setRestartDefault( mxNode->getRestartDefault() );
xNewNode->setAcceleration( mxNode->getAcceleration() );
xNewNode->setDecelerate( mxNode->getDecelerate() );
xNewNode->setAutoReverse( mxNode->getAutoReverse() );
xNewNode->setRepeatDuration( mxNode->getRepeatDuration() );
xNewNode->setEndSync( mxNode->getEndSync() );
xNewNode->setRepeatCount( mxNode->getRepeatCount() );
xNewNode->setUserData( mxNode->getUserData() );
mxNode = xNewNode;
Any aTarget;
if( nIterateType )
{
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY_THROW );
xIter->setTarget(maTarget);
xIter->setSubItem( nTargetSubItem );
}
else
{
aTarget = maTarget;
}
Reference< XEnumerationAccess > xEA( mxNode, UNO_QUERY_THROW );
Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
while( xE->hasMoreElements() )
{
Reference< XAnimate > xAnimate( xE->nextElement(), UNO_QUERY );
if( xAnimate.is() )
{
xAnimate->setTarget( aTarget );
xAnimate->setSubItem( nTargetSubItem );
}
}
}
mnIterateType = nIterateType;
// if we have an iteration container, we must set its type
if( mnIterateType )
{
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY_THROW );
xIter->setIterateType( nIterateType );
}
checkForText();
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::CustomAnimationEffect::setIterateType(), Exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setIterateInterval( double fIterateInterval )
{
if( mfIterateInterval != fIterateInterval )
{
Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
DBG_ASSERT( xIter.is(), "sd::CustomAnimationEffect::setIterateInterval(), not an iteration node" );
if( xIter.is() )
{
mfIterateInterval = fIterateInterval;
xIter->setIterateInterval( fIterateInterval );
}
calculateIterateDuration();
}
}
// --------------------------------------------------------------------
::rtl::OUString CustomAnimationEffect::getPath() const
{
::rtl::OUString aPath;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimateMotion > xMotion( xEnumeration->nextElement(), UNO_QUERY );
if( xMotion.is() )
{
xMotion->getPath() >>= aPath;
break;
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::getPath(), exception caught!" );
}
return aPath;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setPath( const ::rtl::OUString& rPath )
{
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimateMotion > xMotion( xEnumeration->nextElement(), UNO_QUERY );
if( xMotion.is() )
{
MainSequenceChangeGuard aGuard( mpEffectSequence );
xMotion->setPath( Any( rPath ) );
break;
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setPath(), exception caught!" );
}
}
// --------------------------------------------------------------------
Any CustomAnimationEffect::getProperty( sal_Int32 nNodeType, const OUString& rAttributeName, EValue eValue )
{
Any aProperty;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() && !aProperty.hasValue() )
{
Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
if( !xAnimate.is() )
continue;
if( xAnimate->getType() == nNodeType )
{
if( xAnimate->getAttributeName() == rAttributeName )
{
switch( eValue )
{
case VALUE_FROM: aProperty = xAnimate->getFrom(); break;
case VALUE_TO: aProperty = xAnimate->getTo(); break;
case VALUE_BY: aProperty = xAnimate->getBy(); break;
case VALUE_FIRST:
case VALUE_LAST:
{
Sequence<Any> aValues( xAnimate->getValues() );
if( aValues.hasElements() )
aProperty = aValues[ eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1 ];
}
break;
}
}
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::getProperty(), exception caught!" );
}
return aProperty;
}
// --------------------------------------------------------------------
bool CustomAnimationEffect::setProperty( sal_Int32 nNodeType, const OUString& rAttributeName, EValue eValue, const Any& rValue )
{
bool bChanged = false;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
if( !xAnimate.is() )
continue;
if( xAnimate->getType() == nNodeType )
{
if( xAnimate->getAttributeName() == rAttributeName )
{
switch( eValue )
{
case VALUE_FROM:
if( xAnimate->getFrom() != rValue )
{
xAnimate->setFrom( rValue );
bChanged = true;
}
break;
case VALUE_TO:
if( xAnimate->getTo() != rValue )
{
xAnimate->setTo( rValue );
bChanged = true;
}
break;
case VALUE_BY:
if( xAnimate->getTo() != rValue )
{
xAnimate->setBy( rValue );
bChanged = true;
}
break;
case VALUE_FIRST:
case VALUE_LAST:
{
Sequence<Any> aValues( xAnimate->getValues() );
if( !aValues.hasElements() )
aValues.realloc(1);
sal_Int32 nIndex = eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1;
if( aValues[ nIndex ] != rValue )
{
aValues[ nIndex ] = rValue;
xAnimate->setValues( aValues );
bChanged = true;
}
}
}
}
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setProperty(), exception caught!" );
}
return bChanged;
}
// --------------------------------------------------------------------
static bool implIsColorAttribute( const OUString& rAttributeName )
{
return rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("FillColor") ) ||
rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("LineColor") ) ||
rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("CharColor") );
}
// --------------------------------------------------------------------
Any CustomAnimationEffect::getColor( sal_Int32 nIndex )
{
Any aColor;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() && !aColor.hasValue() )
{
Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
if( !xAnimate.is() )
continue;
switch( xAnimate->getType() )
{
case AnimationNodeType::SET:
case AnimationNodeType::ANIMATE:
if( !implIsColorAttribute( xAnimate->getAttributeName() ) )
break;
case AnimationNodeType::ANIMATECOLOR:
Sequence<Any> aValues( xAnimate->getValues() );
if( aValues.hasElements() )
{
if( aValues.getLength() > nIndex )
aColor = aValues[nIndex];
}
else if( nIndex == 0 )
aColor = xAnimate->getFrom();
else
aColor = xAnimate->getTo();
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::getColor(), exception caught!" );
}
return aColor;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setColor( sal_Int32 nIndex, const Any& rColor )
{
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
if( !xAnimate.is() )
continue;
switch( xAnimate->getType() )
{
case AnimationNodeType::SET:
case AnimationNodeType::ANIMATE:
if( !implIsColorAttribute( xAnimate->getAttributeName() ) )
break;
case AnimationNodeType::ANIMATECOLOR:
{
Sequence<Any> aValues( xAnimate->getValues() );
if( aValues.hasElements() )
{
if( aValues.getLength() > nIndex )
{
aValues[nIndex] = rColor;
xAnimate->setValues( aValues );
}
}
else if( (nIndex == 0) && xAnimate->getFrom().hasValue() )
xAnimate->setFrom(rColor);
else if( (nIndex == 1) && xAnimate->getTo().hasValue() )
xAnimate->setTo(rColor);
}
break;
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setColor(), exception caught!" );
}
}
// --------------------------------------------------------------------
Any CustomAnimationEffect::getTransformationProperty( sal_Int32 nTransformType, EValue eValue )
{
Any aProperty;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() && !aProperty.hasValue() )
{
Reference< XAnimateTransform > xTransform( xEnumeration->nextElement(), UNO_QUERY );
if( !xTransform.is() )
continue;
if( xTransform->getTransformType() == nTransformType )
{
switch( eValue )
{
case VALUE_FROM: aProperty = xTransform->getFrom(); break;
case VALUE_TO: aProperty = xTransform->getTo(); break;
case VALUE_BY: aProperty = xTransform->getBy(); break;
case VALUE_FIRST:
case VALUE_LAST:
{
Sequence<Any> aValues( xTransform->getValues() );
if( aValues.hasElements() )
aProperty = aValues[ eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1 ];
}
break;
}
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::getTransformationProperty(), exception caught!" );
}
return aProperty;
}
// --------------------------------------------------------------------
bool CustomAnimationEffect::setTransformationProperty( sal_Int32 nTransformType, EValue eValue, const Any& rValue )
{
bool bChanged = false;
if( mxNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
if( xEnumerationAccess.is() )
{
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
if( xEnumeration.is() )
{
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimateTransform > xTransform( xEnumeration->nextElement(), UNO_QUERY );
if( !xTransform.is() )
continue;
if( xTransform->getTransformType() == nTransformType )
{
switch( eValue )
{
case VALUE_FROM:
if( xTransform->getFrom() != rValue )
{
xTransform->setFrom( rValue );
bChanged = true;
}
break;
case VALUE_TO:
if( xTransform->getTo() != rValue )
{
xTransform->setTo( rValue );
bChanged = true;
}
break;
case VALUE_BY:
if( xTransform->getBy() != rValue )
{
xTransform->setBy( rValue );
bChanged = true;
}
break;
case VALUE_FIRST:
case VALUE_LAST:
{
Sequence<Any> aValues( xTransform->getValues() );
if( !aValues.hasElements() )
aValues.realloc(1);
sal_Int32 nIndex = eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1;
if( aValues[nIndex] != rValue )
{
aValues[nIndex] = rValue;
xTransform->setValues( aValues );
bChanged = true;
}
}
}
}
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setTransformationProperty(), exception caught!" );
}
return bChanged;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::createAudio( const ::com::sun::star::uno::Any& rSource, double fVolume /* = 1.0 */ )
{
DBG_ASSERT( !mxAudio.is(), "sd::CustomAnimationEffect::createAudio(), node already has an audio!" );
if( !mxAudio.is() ) try
{
Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
Reference< XAudio > xAudio( xMsf->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.Audio") ) ), UNO_QUERY_THROW );
xAudio->setSource( rSource );
xAudio->setVolume( fVolume );
setAudio( xAudio );
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::createAudio(), exception caught!" );
}
}
// --------------------------------------------------------------------
static Reference< XCommand > findCommandNode( const Reference< XAnimationNode >& xRootNode )
{
Reference< XCommand > xCommand;
if( xRootNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( !xCommand.is() && xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xNode( xEnumeration->nextElement(), UNO_QUERY );
if( xNode.is() && (xNode->getType() == AnimationNodeType::COMMAND) )
xCommand.set( xNode, UNO_QUERY_THROW );
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::findCommandNode(), exception caught!" );
}
return xCommand;
}
void CustomAnimationEffect::removeAudio()
{
try
{
Reference< XAnimationNode > xChild;
if( mxAudio.is() )
{
xChild.set( mxAudio, UNO_QUERY );
mxAudio.clear();
}
else if( mnCommand == EffectCommands::STOPAUDIO )
{
xChild.set( findCommandNode( mxNode ), UNO_QUERY );
mnCommand = 0;
}
if( xChild.is() )
{
Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY );
if( xContainer.is() )
xContainer->removeChild( xChild );
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::removeAudio(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setAudio( const Reference< ::com::sun::star::animations::XAudio >& xAudio )
{
if( mxAudio != xAudio ) try
{
removeAudio();
mxAudio = xAudio;
Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY );
Reference< XAnimationNode > xChild( mxAudio, UNO_QUERY );
if( xContainer.is() && xChild.is() )
xContainer->appendChild( xChild );
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setAudio(), exception caught!" );
}
}
// --------------------------------------------------------------------
void CustomAnimationEffect::setStopAudio()
{
if( mnCommand != EffectCommands::STOPAUDIO ) try
{
if( mxAudio.is() )
removeAudio();
Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
Reference< XCommand > xCommand( xMsf->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.Command") ) ), UNO_QUERY_THROW );
xCommand->setCommand( EffectCommands::STOPAUDIO );
Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY_THROW );
Reference< XAnimationNode > xChild( xCommand, UNO_QUERY_THROW );
xContainer->appendChild( xChild );
mnCommand = EffectCommands::STOPAUDIO;
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::CustomAnimationEffect::setStopAudio(), exception caught!" );
}
}
// --------------------------------------------------------------------
bool CustomAnimationEffect::getStopAudio() const
{
return mnCommand == EffectCommands::STOPAUDIO;
}
// --------------------------------------------------------------------
SdrPathObj* CustomAnimationEffect::createSdrPathObjFromPath()
{
SdrPathObj * pPathObj = new SdrPathObj( OBJ_PATHLINE );
updateSdrPathObjFromPath( *pPathObj );
return pPathObj;
}
// --------------------------------------------------------------------
void CustomAnimationEffect::updateSdrPathObjFromPath( SdrPathObj& rPathObj )
{
::basegfx::B2DPolyPolygon xPolyPoly;
if( ::basegfx::tools::importFromSvgD( xPolyPoly, getPath(), true, 0 ) )
{
SdrObject* pObj = GetSdrObjectFromXShape( getTargetShape() );
if( pObj )
{
SdrPage* pPage = pObj->GetPage();
if( pPage )
{
const Size aPageSize( pPage->GetSize() );
xPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix((double)aPageSize.Width(), (double)aPageSize.Height()));
}
const Rectangle aBoundRect( pObj->GetCurrentBoundRect() );
const Point aCenter( aBoundRect.Center() );
xPolyPoly.transform(basegfx::tools::createTranslateB2DHomMatrix(aCenter.X(), aCenter.Y()));
}
}
rPathObj.SetPathPoly( xPolyPoly );
}
// --------------------------------------------------------------------
void CustomAnimationEffect::updatePathFromSdrPathObj( const SdrPathObj& rPathObj )
{
::basegfx::B2DPolyPolygon xPolyPoly( rPathObj.GetPathPoly() );
SdrObject* pObj = GetSdrObjectFromXShape( getTargetShape() );
if( pObj )
{
Rectangle aBoundRect(0,0,0,0);
const drawinglayer::primitive2d::Primitive2DSequence xPrimitives(pObj->GetViewContact().getViewIndependentPrimitive2DSequence());
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
const basegfx::B2DRange aRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xPrimitives, aViewInformation2D));
if(!aRange.isEmpty())
{
aBoundRect = Rectangle(
(sal_Int32)floor(aRange.getMinX()), (sal_Int32)floor(aRange.getMinY()),
(sal_Int32)ceil(aRange.getMaxX()), (sal_Int32)ceil(aRange.getMaxY()));
}
const Point aCenter( aBoundRect.Center() );
xPolyPoly.transform(basegfx::tools::createTranslateB2DHomMatrix(-aCenter.X(), -aCenter.Y()));
SdrPage* pPage = pObj->GetPage();
if( pPage )
{
const Size aPageSize( pPage->GetSize() );
xPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix(
1.0 / (double)aPageSize.Width(), 1.0 / (double)aPageSize.Height()));
}
}
setPath( ::basegfx::tools::exportToSvgD( xPolyPoly, true, true, true) );
}
// ====================================================================
EffectSequenceHelper::EffectSequenceHelper()
: mnSequenceType( EffectNodeType::DEFAULT )
{
}
// --------------------------------------------------------------------
EffectSequenceHelper::EffectSequenceHelper( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XTimeContainer >& xSequenceRoot )
: mxSequenceRoot( xSequenceRoot ), mnSequenceType( EffectNodeType::DEFAULT )
{
Reference< XAnimationNode > xNode( mxSequenceRoot, UNO_QUERY_THROW );
create( xNode );
}
// --------------------------------------------------------------------
EffectSequenceHelper::~EffectSequenceHelper()
{
reset();
}
// --------------------------------------------------------------------
void EffectSequenceHelper::reset()
{
EffectSequence::iterator aIter( maEffects.begin() );
EffectSequence::iterator aEnd( maEffects.end() );
if( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect = (*aIter++);
pEffect->setEffectSequence(0);
}
maEffects.clear();
}
Reference< XAnimationNode > EffectSequenceHelper::getRootNode()
{
Reference< XAnimationNode > xRoot( mxSequenceRoot, UNO_QUERY );
return xRoot;
}
// --------------------------------------------------------------------
void EffectSequenceHelper::append( const CustomAnimationEffectPtr& pEffect )
{
pEffect->setEffectSequence( this );
maEffects.push_back(pEffect);
rebuild();
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr EffectSequenceHelper::append( const CustomAnimationPresetPtr& pPreset, const Any& rTarget, double fDuration /* = -1.0 */ )
{
CustomAnimationEffectPtr pEffect;
if( pPreset.get() )
{
OUString strEmpty;
Reference< XAnimationNode > xNode( pPreset->create( strEmpty ) );
if( xNode.is() )
{
// first, filter all only ui relevant user data
std::vector< NamedValue > aNewUserData;
Sequence< NamedValue > aUserData( xNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
const NamedValue* p = aUserData.getConstArray();
bool bFilter = false;
while( nLength-- )
{
if( !p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "text-only" ) ) &&
!p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "preset-property" ) ) )
{
aNewUserData.push_back( *p );
bFilter = true;
}
p++;
}
if( bFilter )
{
aUserData = ::comphelper::containerToSequence< NamedValue, std::vector< NamedValue > >( aNewUserData );
xNode->setUserData( aUserData );
}
// check target, maybe we need to force it to text
Any aTarget( rTarget );
sal_Int16 nSubItem = ShapeAnimationSubType::AS_WHOLE;
if( aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
nSubItem = ShapeAnimationSubType::ONLY_TEXT;
}
else if( pPreset->isTextOnly() )
{
Reference< XShape > xShape;
aTarget >>= xShape;
if( xShape.is() )
{
// thats bad, we target a shape here but the effect is only for text
// so change subitem
nSubItem = ShapeAnimationSubType::ONLY_TEXT;
}
}
// now create effect from preset
pEffect.reset( new CustomAnimationEffect( xNode ) );
pEffect->setEffectSequence( this );
pEffect->setTarget( aTarget );
pEffect->setTargetSubItem( nSubItem );
if( fDuration != -1.0 )
pEffect->setDuration( fDuration );
maEffects.push_back(pEffect);
rebuild();
}
}
DBG_ASSERT( pEffect.get(), "sd::EffectSequenceHelper::append(), failed!" );
return pEffect;
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr EffectSequenceHelper::append( const SdrPathObj& rPathObj, const Any& rTarget, double fDuration /* = -1.0 */ )
{
CustomAnimationEffectPtr pEffect;
if( fDuration <= 0.0 )
fDuration = 2.0;
try
{
Reference< XTimeContainer > xEffectContainer( createParallelTimeContainer() );
const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.animations.AnimateMotion" ) );
Reference< XAnimationNode > xAnimateMotion( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName), UNO_QUERY_THROW );
xAnimateMotion->setDuration( Any( fDuration ) );
xAnimateMotion->setFill( AnimationFill::HOLD );
xEffectContainer->appendChild( xAnimateMotion );
sal_Int16 nSubItem = ShapeAnimationSubType::AS_WHOLE;
if( rTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
nSubItem = ShapeAnimationSubType::ONLY_TEXT;
Reference< XAnimationNode > xEffectNode( xEffectContainer, UNO_QUERY_THROW );
pEffect.reset( new CustomAnimationEffect( xEffectNode ) );
pEffect->setEffectSequence( this );
pEffect->setTarget( rTarget );
pEffect->setTargetSubItem( nSubItem );
pEffect->setNodeType( ::com::sun::star::presentation::EffectNodeType::ON_CLICK );
pEffect->setPresetClass( ::com::sun::star::presentation::EffectPresetClass::MOTIONPATH );
pEffect->setAcceleration( 0.5 );
pEffect->setDecelerate( 0.5 );
pEffect->setFill( AnimationFill::HOLD );
pEffect->setBegin( 0.0 );
pEffect->updatePathFromSdrPathObj( rPathObj );
if( fDuration != -1.0 )
pEffect->setDuration( fDuration );
maEffects.push_back(pEffect);
rebuild();
}
catch( Exception& )
{
DBG_ERROR( "sd::EffectSequenceHelper::append(), exception caught!" );
}
return pEffect;
}
// --------------------------------------------------------------------
void EffectSequenceHelper::replace( const CustomAnimationEffectPtr& pEffect, const CustomAnimationPresetPtr& pPreset, const OUString& rPresetSubType, double fDuration /* = -1.0 */ )
{
if( pEffect.get() && pPreset.get() ) try
{
Reference< XAnimationNode > xNewNode( pPreset->create( rPresetSubType ) );
if( xNewNode.is() )
{
pEffect->replaceNode( xNewNode );
if( fDuration != -1.0 )
pEffect->setDuration( fDuration );
}
rebuild();
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::EffectSequenceHelper::replace(), exception caught!" );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::replace( const CustomAnimationEffectPtr& pEffect, const CustomAnimationPresetPtr& pPreset, double fDuration /* = -1.0 */ )
{
OUString strEmpty;
replace( pEffect, pPreset, strEmpty, fDuration );
}
// --------------------------------------------------------------------
void EffectSequenceHelper::remove( const CustomAnimationEffectPtr& pEffect )
{
if( pEffect.get() )
{
pEffect->setEffectSequence( 0 );
maEffects.remove( pEffect );
}
rebuild();
}
// --------------------------------------------------------------------
void EffectSequenceHelper::rebuild()
{
implRebuild();
}
// --------------------------------------------------------------------
void EffectSequenceHelper::implRebuild()
{
try
{
// first we delete all time containers on the first two levels
Reference< XEnumerationAccess > xEnumerationAccess( mxSequenceRoot, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
Reference< XTimeContainer > xChildContainer( xChildNode, UNO_QUERY_THROW );
Reference< XEnumerationAccess > xChildEnumerationAccess( xChildNode, UNO_QUERY_THROW );
Reference< XEnumeration > xChildEnumeration( xChildEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xChildEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xNode( xChildEnumeration->nextElement(), UNO_QUERY_THROW );
xChildContainer->removeChild( xNode );
}
mxSequenceRoot->removeChild( xChildNode );
}
// second, rebuild main sequence
EffectSequence::iterator aIter( maEffects.begin() );
EffectSequence::iterator aEnd( maEffects.end() );
if( aIter != aEnd )
{
AfterEffectNodeList aAfterEffects;
CustomAnimationEffectPtr pEffect = (*aIter++);
bool bFirst = true;
do
{
// create a par container for the next click node and all following with and after effects
Reference< XTimeContainer > xOnClickContainer( createParallelTimeContainer() );
Event aEvent;
if( mxEventSource.is() )
{
aEvent.Source <<= mxEventSource;
aEvent.Trigger = EventTrigger::ON_CLICK;
}
else
{
aEvent.Trigger = EventTrigger::ON_NEXT;
}
aEvent.Repeat = 0;
Any aBegin( makeAny( aEvent ) );
if( bFirst )
{
// if the first node is not a click action, this click container
// must not have INDEFINITE begin but start at 0s
bFirst = false;
if( pEffect->getNodeType() != EffectNodeType::ON_CLICK )
aBegin <<= (double)0.0;
}
xOnClickContainer->setBegin( aBegin );
Reference< XAnimationNode > xOnClickContainerNode( xOnClickContainer, UNO_QUERY_THROW );
mxSequenceRoot->appendChild( xOnClickContainerNode );
double fBegin = 0.0;
do
{
// create a par container for the current click or after effect node and all following with effects
Reference< XTimeContainer > xWithContainer( createParallelTimeContainer() );
Reference< XAnimationNode > xWithContainerNode( xWithContainer, UNO_QUERY_THROW );
xWithContainer->setBegin( makeAny( fBegin ) );
xOnClickContainer->appendChild( xWithContainerNode );
double fDuration = 0.0;
do
{
Reference< XAnimationNode > xEffectNode( pEffect->getNode() );
xWithContainer->appendChild( xEffectNode );
if( pEffect->hasAfterEffect() )
{
Reference< XAnimationNode > xAfterEffect( pEffect->createAfterEffectNode() );
AfterEffectNode a( xAfterEffect, xEffectNode, pEffect->IsAfterEffectOnNext() );
aAfterEffects.push_back( a );
}
double fTemp = pEffect->getBegin() + pEffect->getAbsoluteDuration();
if( fTemp > fDuration )
fDuration = fTemp;
if( aIter != aEnd )
pEffect = (*aIter++);
else
pEffect.reset();
}
while( pEffect.get() && (pEffect->getNodeType() == EffectNodeType::WITH_PREVIOUS) );
fBegin += fDuration;
}
while( pEffect.get() && (pEffect->getNodeType() != EffectNodeType::ON_CLICK) );
}
while( pEffect.get() );
// process after effect nodes
std::for_each( aAfterEffects.begin(), aAfterEffects.end(), stl_process_after_effect_node_func );
updateTextGroups();
// reset duration, might have been altered (see below)
mxSequenceRoot->setDuration( Any() );
}
else
{
// empty sequence, set duration to 0.0 explicitely
// (otherwise, this sequence will never end)
mxSequenceRoot->setDuration( makeAny((double)0.0) );
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::EffectSequenceHelper::rebuild(), exception caught!" );
}
}
// --------------------------------------------------------------------
Reference< XTimeContainer > EffectSequenceHelper::createParallelTimeContainer() const
{
const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.animations.ParallelTimeContainer" ) );
return Reference< XTimeContainer >( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName), UNO_QUERY );
}
// --------------------------------------------------------------------
stl_CustomAnimationEffect_search_node_predict::stl_CustomAnimationEffect_search_node_predict( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xSearchNode )
: mxSearchNode( xSearchNode )
{
}
// --------------------------------------------------------------------
bool stl_CustomAnimationEffect_search_node_predict::operator()( CustomAnimationEffectPtr pEffect ) const
{
return pEffect->getNode() == mxSearchNode;
}
// --------------------------------------------------------------------
static bool implFindNextContainer( Reference< XTimeContainer >& xParent, Reference< XTimeContainer >& xCurrent, Reference< XTimeContainer >& xNext )
throw(Exception)
{
Reference< XEnumerationAccess > xEnumerationAccess( xParent, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration() );
if( xEnumeration.is() )
{
Reference< XInterface > x;
while( xEnumeration->hasMoreElements() && !xNext.is() )
{
if( (xEnumeration->nextElement() >>= x) && (x == xCurrent) )
{
if( xEnumeration->hasMoreElements() )
xEnumeration->nextElement() >>= xNext;
}
}
}
return xNext.is();
}
// --------------------------------------------------------------------
void stl_process_after_effect_node_func(AfterEffectNode& rNode)
{
try
{
if( rNode.mxNode.is() && rNode.mxMaster.is() )
{
// set master node
Reference< XAnimationNode > xMasterNode( rNode.mxMaster, UNO_QUERY_THROW );
Sequence< NamedValue > aUserData( rNode.mxNode->getUserData() );
sal_Int32 nSize = aUserData.getLength();
aUserData.realloc(nSize+1);
aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "master-element" ) );
aUserData[nSize].Value <<= xMasterNode;
rNode.mxNode->setUserData( aUserData );
// insert after effect node into timeline
Reference< XTimeContainer > xContainer( rNode.mxMaster->getParent(), UNO_QUERY_THROW );
if( !rNode.mbOnNextEffect ) // sameClick
{
// insert the aftereffect after its effect is animated
xContainer->insertAfter( rNode.mxNode, rNode.mxMaster );
}
else // nextClick
{
Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
// insert the aftereffect in the next group
Reference< XTimeContainer > xClickContainer( xContainer->getParent(), UNO_QUERY_THROW );
Reference< XTimeContainer > xSequenceContainer( xClickContainer->getParent(), UNO_QUERY_THROW );
Reference< XTimeContainer > xNextContainer;
// first try if we have an after effect container
if( !implFindNextContainer( xClickContainer, xContainer, xNextContainer ) )
{
Reference< XTimeContainer > xNextClickContainer;
// if not, try to find the next click effect container
if( implFindNextContainer( xSequenceContainer, xClickContainer, xNextClickContainer ) )
{
Reference< XEnumerationAccess > xEnumerationAccess( xNextClickContainer, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
if( xEnumeration->hasMoreElements() )
{
// the next container is the first child container
xEnumeration->nextElement() >>= xNextContainer;
}
else
{
// this does not yet have a child container, create one
const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.ParallelTimeContainer") );
xNextContainer = Reference< XTimeContainer >::query( xMsf->createInstance(aServiceName) );
if( xNextContainer.is() )
{
Reference< XAnimationNode > xNode( xNextContainer, UNO_QUERY_THROW );
xNode->setBegin( makeAny( (double)0.0 ) );
// xNode->setFill( AnimationFill::HOLD );
xNextClickContainer->appendChild( xNode );
}
}
DBG_ASSERT( xNextContainer.is(), "ppt::stl_process_after_effect_node_func::operator(), could not find/create container!" );
}
}
// if we don't have a next container, we add one to the sequence container
if( !xNextContainer.is() )
{
const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.ParallelTimeContainer") );
Reference< XTimeContainer > xNewClickContainer( xMsf->createInstance(aServiceName), UNO_QUERY_THROW );
Reference< XAnimationNode > xNewClickNode( xNewClickContainer, UNO_QUERY_THROW );
Event aEvent;
aEvent.Trigger = EventTrigger::ON_NEXT;
aEvent.Repeat = 0;
xNewClickNode->setBegin( makeAny( aEvent ) );
Reference< XAnimationNode > xRefNode( xClickContainer, UNO_QUERY_THROW );
xSequenceContainer->insertAfter( xNewClickNode, xRefNode );
xNextContainer = Reference< XTimeContainer >::query( xMsf->createInstance(aServiceName) );
DBG_ASSERT( xNextContainer.is(), "ppt::stl_process_after_effect_node_func::operator(), could not create container!" );
if( xNextContainer.is() )
{
Reference< XAnimationNode > xNode( xNextContainer, UNO_QUERY_THROW );
xNode->setBegin( makeAny( (double)0.0 ) );
// xNode->setFill( AnimationFill::HOLD );
xNewClickContainer->appendChild( xNode );
}
}
if( xNextContainer.is() )
{
// find begin time of first element
Reference< XEnumerationAccess > xEnumerationAccess( xNextContainer, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
if( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChild;
// the next container is the first child container
xEnumeration->nextElement() >>= xChild;
if( xChild.is() )
{
Any aBegin( xChild->getBegin() );
double fBegin = 0.0;
if( (aBegin >>= fBegin) && (fBegin >= 0.0))
rNode.mxNode->setBegin( aBegin );
}
}
xNextContainer->appendChild( rNode.mxNode );
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "ppt::stl_process_after_effect_node_func::operator(), exception caught!" );
}
}
// --------------------------------------------------------------------
EffectSequence::iterator EffectSequenceHelper::find( const CustomAnimationEffectPtr& pEffect )
{
return std::find( maEffects.begin(), maEffects.end(), pEffect );
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr EffectSequenceHelper::findEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode ) const
{
CustomAnimationEffectPtr pEffect;
EffectSequence::const_iterator aIter( maEffects.begin() );
for( ; aIter != maEffects.end(); aIter++ )
{
if( (*aIter)->getNode() == xNode )
{
pEffect = (*aIter);
break;
}
}
return pEffect;
}
// --------------------------------------------------------------------
sal_Int32 EffectSequenceHelper::getOffsetFromEffect( const CustomAnimationEffectPtr& xEffect ) const
{
sal_Int32 nOffset = 0;
EffectSequence::const_iterator aIter( maEffects.begin() );
for( ; aIter != maEffects.end(); aIter++, nOffset++ )
{
if( (*aIter) == xEffect )
return nOffset;
}
return -1;
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr EffectSequenceHelper::getEffectFromOffset( sal_Int32 nOffset ) const
{
EffectSequence::const_iterator aIter( maEffects.begin() );
while( nOffset-- && aIter != maEffects.end() )
aIter++;
CustomAnimationEffectPtr pEffect;
if( aIter != maEffects.end() )
pEffect = (*aIter);
return pEffect;
}
// --------------------------------------------------------------------
bool EffectSequenceHelper::disposeShape( const Reference< XShape >& xShape )
{
bool bChanges = false;
EffectSequence::iterator aIter( maEffects.begin() );
while( aIter != maEffects.end() )
{
if( (*aIter)->getTargetShape() == xShape )
{
(*aIter)->setEffectSequence( 0 );
bChanges = true;
aIter = maEffects.erase( aIter );
}
else
{
aIter++;
}
}
return bChanges;
}
// --------------------------------------------------------------------
bool EffectSequenceHelper::hasEffect( const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape )
{
EffectSequence::iterator aIter( maEffects.begin() );
while( aIter != maEffects.end() )
{
if( (*aIter)->getTargetShape() == xShape )
return true;
aIter++;
}
return false;
}
// --------------------------------------------------------------------
void EffectSequenceHelper::insertTextRange( const com::sun::star::uno::Any& aTarget )
{
bool bChanges = false;
ParagraphTarget aParaTarget;
if( !(aTarget >>= aParaTarget ) )
return;
EffectSequence::iterator aIter( maEffects.begin() );
while( aIter != maEffects.end() )
{
if( (*aIter)->getTargetShape() == aParaTarget.Shape )
bChanges |= (*aIter)->checkForText();
aIter++;
}
if( bChanges )
rebuild();
}
// --------------------------------------------------------------------
void EffectSequenceHelper::disposeTextRange( const com::sun::star::uno::Any& aTarget )
{
ParagraphTarget aParaTarget;
if( !(aTarget >>= aParaTarget ) )
return;
bool bChanges = false;
bool bErased = false;
EffectSequence::iterator aIter( maEffects.begin() );
while( aIter != maEffects.end() )
{
Any aIterTarget( (*aIter)->getTarget() );
if( aIterTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
ParagraphTarget aIterParaTarget;
if( (aIterTarget >>= aIterParaTarget) && (aIterParaTarget.Shape == aParaTarget.Shape) )
{
if( aIterParaTarget.Paragraph == aParaTarget.Paragraph )
{
// delete this effect if it targets the disposed paragraph directly
(*aIter)->setEffectSequence( 0 );
aIter = maEffects.erase( aIter );
bChanges = true;
bErased = true;
}
else
{
if( aIterParaTarget.Paragraph > aParaTarget.Paragraph )
{
// shift all paragraphs after disposed paragraph
aIterParaTarget.Paragraph--;
(*aIter)->setTarget( makeAny( aIterParaTarget ) );
}
}
}
}
else if( (*aIter)->getTargetShape() == aParaTarget.Shape )
{
bChanges |= (*aIter)->checkForText();
}
if( bErased )
bErased = false;
else
aIter++;
}
if( bChanges )
rebuild();
}
// --------------------------------------------------------------------
CustomAnimationTextGroup::CustomAnimationTextGroup( const Reference< XShape >& rTarget, sal_Int32 nGroupId )
: maTarget( rTarget ),
mnGroupId( nGroupId )
{
reset();
}
// --------------------------------------------------------------------
void CustomAnimationTextGroup::reset()
{
mnTextGrouping = -1;
mbAnimateForm = false;
mbTextReverse = false;
mfGroupingAuto = -1.0;
mnLastPara = -1; // used to check for TextReverse
int i = 5;
while( i-- ) mnDepthFlags[i] = 0;
maEffects.clear();
}
// --------------------------------------------------------------------
void CustomAnimationTextGroup::addEffect( CustomAnimationEffectPtr& pEffect )
{
maEffects.push_back( pEffect );
Any aTarget( pEffect->getTarget() );
if( aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
// now look at the paragraph
ParagraphTarget aParaTarget;
aTarget >>= aParaTarget;
if( mnLastPara != -1 )
mbTextReverse = mnLastPara > aParaTarget.Paragraph;
mnLastPara = aParaTarget.Paragraph;
const sal_Int32 nParaDepth = pEffect->getParaDepth();
// only look at the first 5 levels
if( nParaDepth < 5 )
{
// our first paragraph with this level?
if( mnDepthFlags[nParaDepth] == 0 )
{
// so set it to the first found
mnDepthFlags[nParaDepth] = (sal_Int8)pEffect->getNodeType();
}
else if( mnDepthFlags[nParaDepth] != pEffect->getNodeType() )
{
mnDepthFlags[nParaDepth] = -1;
}
if( pEffect->getNodeType() == EffectNodeType::AFTER_PREVIOUS )
mfGroupingAuto = pEffect->getBegin();
mnTextGrouping = 0;
while( (mnTextGrouping < 5) && (mnDepthFlags[mnTextGrouping] > 0) )
mnTextGrouping++;
}
}
else
{
// if we have an effect with the shape as a target, we animate the background
mbAnimateForm = pEffect->getTargetSubItem() != ShapeAnimationSubType::ONLY_TEXT;
}
}
// --------------------------------------------------------------------
class TextGroupMapImpl : public std::map< sal_Int32, CustomAnimationTextGroup* >
{
public:
CustomAnimationTextGroup* findGroup( sal_Int32 nGroupId );
};
// --------------------------------------------------------------------
CustomAnimationTextGroupPtr EffectSequenceHelper::findGroup( sal_Int32 nGroupId )
{
CustomAnimationTextGroupPtr aPtr;
CustomAnimationTextGroupMap::iterator aIter( maGroupMap.find( nGroupId ) );
if( aIter != maGroupMap.end() )
aPtr = (*aIter).second;
return aPtr;
}
// --------------------------------------------------------------------
void EffectSequenceHelper::updateTextGroups()
{
maGroupMap.clear();
// first create all the groups
EffectSequence::iterator aIter( maEffects.begin() );
const EffectSequence::iterator aEnd( maEffects.end() );
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
const sal_Int32 nGroupId = pEffect->getGroupId();
if( nGroupId == -1 )
continue; // trivial case, no group
CustomAnimationTextGroupPtr pGroup = findGroup( nGroupId );
if( !pGroup.get() )
{
pGroup.reset( new CustomAnimationTextGroup( pEffect->getTargetShape(), nGroupId ) );
maGroupMap[nGroupId] = pGroup;
}
pGroup->addEffect( pEffect );
}
}
// --------------------------------------------------------------------
CustomAnimationTextGroupPtr EffectSequenceHelper::createTextGroup( CustomAnimationEffectPtr pEffect, sal_Int32 nTextGrouping, double fTextGroupingAuto, sal_Bool bAnimateForm, sal_Bool bTextReverse )
{
// first finde a free group-id
sal_Int32 nGroupId = 0;
CustomAnimationTextGroupMap::iterator aIter( maGroupMap.begin() );
const CustomAnimationTextGroupMap::iterator aEnd( maGroupMap.end() );
while( aIter != aEnd )
{
if( (*aIter).first == nGroupId )
{
nGroupId++;
aIter = maGroupMap.begin();
}
else
{
aIter++;
}
}
Reference< XShape > xTarget( pEffect->getTargetShape() );
CustomAnimationTextGroupPtr pTextGroup( new CustomAnimationTextGroup( xTarget, nGroupId ) );
maGroupMap[nGroupId] = pTextGroup;
bool bUsed = false;
// do we need to target the shape?
if( (nTextGrouping == 0) || bAnimateForm )
{
sal_Int16 nSubItem;
if( nTextGrouping == 0)
nSubItem = bAnimateForm ? ShapeAnimationSubType::AS_WHOLE : ShapeAnimationSubType::ONLY_TEXT;
else
nSubItem = ShapeAnimationSubType::ONLY_BACKGROUND;
pEffect->setTarget( makeAny( xTarget ) );
pEffect->setTargetSubItem( nSubItem );
pEffect->setEffectSequence( this );
pEffect->setGroupId( nGroupId );
pTextGroup->addEffect( pEffect );
bUsed = true;
}
pTextGroup->mnTextGrouping = nTextGrouping;
pTextGroup->mfGroupingAuto = fTextGroupingAuto;
pTextGroup->mbTextReverse = bTextReverse;
// now add an effect for each paragraph
createTextGroupParagraphEffects( pTextGroup, pEffect, bUsed );
notify_listeners();
return pTextGroup;
}
// --------------------------------------------------------------------
void EffectSequenceHelper::createTextGroupParagraphEffects( CustomAnimationTextGroupPtr pTextGroup, CustomAnimationEffectPtr pEffect, bool bUsed )
{
Reference< XShape > xTarget( pTextGroup->maTarget );
sal_Int32 nTextGrouping = pTextGroup->mnTextGrouping;
double fTextGroupingAuto = pTextGroup->mfGroupingAuto;
sal_Bool bTextReverse = pTextGroup->mbTextReverse;
// now add an effect for each paragraph
if( nTextGrouping >= 0 ) try
{
EffectSequence::iterator aInsertIter( find( pEffect ) );
const OUString strNumberingLevel( RTL_CONSTASCII_USTRINGPARAM("NumberingLevel") );
Reference< XEnumerationAccess > xText( xTarget, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xText->createEnumeration(), UNO_QUERY_THROW );
std::list< sal_Int16 > aParaList;
sal_Int16 nPara;
// fill the list with all valid paragraphs
for( nPara = 0; xEnumeration->hasMoreElements(); nPara++ )
{
Reference< XTextRange > xRange( xEnumeration->nextElement(), UNO_QUERY );
if( xRange.is() && xRange->getString().getLength() )
{
if( bTextReverse ) // sort them
aParaList.push_front( nPara );
else
aParaList.push_back( nPara );
}
}
ParagraphTarget aTarget;
aTarget.Shape = xTarget;
std::list< sal_Int16 >::iterator aIter( aParaList.begin() );
std::list< sal_Int16 >::iterator aEnd( aParaList.end() );
while( aIter != aEnd )
{
aTarget.Paragraph = (*aIter++);
CustomAnimationEffectPtr pNewEffect;
if( bUsed )
{
// clone a new effect from first effect
pNewEffect = pEffect->clone();
++aInsertIter;
aInsertIter = maEffects.insert( aInsertIter, pNewEffect );
}
else
{
// reuse first effect if its not yet used
pNewEffect = pEffect;
bUsed = true;
aInsertIter = find( pNewEffect );
}
// set target and group-id
pNewEffect->setTarget( makeAny( aTarget ) );
pNewEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_TEXT );
pNewEffect->setGroupId( pTextGroup->mnGroupId );
pNewEffect->setEffectSequence( this );
// set correct node type
if( pNewEffect->getParaDepth() < nTextGrouping )
{
if( fTextGroupingAuto == -1.0 )
{
pNewEffect->setNodeType( EffectNodeType::ON_CLICK );
pNewEffect->setBegin( 0.0 );
}
else
{
pNewEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
pNewEffect->setBegin( fTextGroupingAuto );
}
}
else
{
pNewEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
pNewEffect->setBegin( 0.0 );
}
pTextGroup->addEffect( pNewEffect );
}
notify_listeners();
}
catch( Exception& e )
{
(void)e;
DBG_ERROR("sd::EffectSequenceHelper::createTextGroup(), exception caught!" );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::setTextGrouping( CustomAnimationTextGroupPtr pTextGroup, sal_Int32 nTextGrouping )
{
if( pTextGroup->mnTextGrouping == nTextGrouping )
{
// first case, trivial case, do nothing
}
else if( (pTextGroup->mnTextGrouping == -1) && (nTextGrouping >= 0) )
{
// second case, we need to add new effects for each paragraph
CustomAnimationEffectPtr pEffect( pTextGroup->maEffects.front() );
pTextGroup->mnTextGrouping = nTextGrouping;
createTextGroupParagraphEffects( pTextGroup, pEffect, true );
notify_listeners();
}
else if( (pTextGroup->mnTextGrouping >= 0) && (nTextGrouping == -1 ) )
{
// third case, we need to remove effects for each paragraph
EffectSequence aEffects( pTextGroup->maEffects );
pTextGroup->reset();
EffectSequence::iterator aIter( aEffects.begin() );
const EffectSequence::iterator aEnd( aEffects.end() );
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
remove( pEffect );
else
pTextGroup->addEffect( pEffect );
}
notify_listeners();
}
else
{
// fourth case, we need to change the node types for the text nodes
double fTextGroupingAuto = pTextGroup->mfGroupingAuto;
EffectSequence aEffects( pTextGroup->maEffects );
pTextGroup->reset();
EffectSequence::iterator aIter( aEffects.begin() );
const EffectSequence::iterator aEnd( aEffects.end() );
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
// set correct node type
if( pEffect->getParaDepth() < nTextGrouping )
{
if( fTextGroupingAuto == -1.0 )
{
pEffect->setNodeType( EffectNodeType::ON_CLICK );
pEffect->setBegin( 0.0 );
}
else
{
pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
pEffect->setBegin( fTextGroupingAuto );
}
}
else
{
pEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
pEffect->setBegin( 0.0 );
}
}
pTextGroup->addEffect( pEffect );
}
notify_listeners();
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::setAnimateForm( CustomAnimationTextGroupPtr pTextGroup, sal_Bool bAnimateForm )
{
if( pTextGroup->mbAnimateForm == bAnimateForm )
{
// trivial case, do nothing
}
else
{
EffectSequence aEffects( pTextGroup->maEffects );
pTextGroup->reset();
EffectSequence::iterator aIter( aEffects.begin() );
const EffectSequence::iterator aEnd( aEffects.end() );
// first insert if we have to
if( bAnimateForm )
{
EffectSequence::iterator aInsertIter( find( (*aIter) ) );
CustomAnimationEffectPtr pEffect;
if( (aEffects.size() == 1) && ((*aIter)->getTarget().getValueType() != ::getCppuType((const ParagraphTarget*)0) ) )
{
// special case, only one effect and that targets whole text,
// convert this to target whole shape
pEffect = (*aIter++);
pEffect->setTargetSubItem( ShapeAnimationSubType::AS_WHOLE );
}
else
{
pEffect = (*aIter)->clone();
pEffect->setTarget( makeAny( (*aIter)->getTargetShape() ) );
pEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_BACKGROUND );
maEffects.insert( aInsertIter, pEffect );
}
pTextGroup->addEffect( pEffect );
}
if( !bAnimateForm && (aEffects.size() == 1) )
{
CustomAnimationEffectPtr pEffect( (*aIter) );
pEffect->setTarget( makeAny( (*aIter)->getTargetShape() ) );
pEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_TEXT );
pTextGroup->addEffect( pEffect );
}
else
{
// readd the rest to the group again
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
pTextGroup->addEffect( pEffect );
}
else
{
DBG_ASSERT( !bAnimateForm, "sd::EffectSequenceHelper::setAnimateForm(), something is wrong here!" );
remove( pEffect );
}
}
}
notify_listeners();
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::setTextGroupingAuto( CustomAnimationTextGroupPtr pTextGroup, double fTextGroupingAuto )
{
sal_Int32 nTextGrouping = pTextGroup->mnTextGrouping;
EffectSequence aEffects( pTextGroup->maEffects );
pTextGroup->reset();
EffectSequence::iterator aIter( aEffects.begin() );
const EffectSequence::iterator aEnd( aEffects.end() );
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
// set correct node type
if( pEffect->getParaDepth() < nTextGrouping )
{
if( fTextGroupingAuto == -1.0 )
{
pEffect->setNodeType( EffectNodeType::ON_CLICK );
pEffect->setBegin( 0.0 );
}
else
{
pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
pEffect->setBegin( fTextGroupingAuto );
}
}
else
{
pEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
pEffect->setBegin( 0.0 );
}
}
pTextGroup->addEffect( pEffect );
}
notify_listeners();
}
// --------------------------------------------------------------------
struct ImplStlTextGroupSortHelper
{
ImplStlTextGroupSortHelper( bool bReverse ) : mbReverse( bReverse ) {};
bool operator()( const CustomAnimationEffectPtr& p1, const CustomAnimationEffectPtr& p2 );
bool mbReverse;
sal_Int32 getTargetParagraph( const CustomAnimationEffectPtr& p1 );
};
// --------------------------------------------------------------------
sal_Int32 ImplStlTextGroupSortHelper::getTargetParagraph( const CustomAnimationEffectPtr& p1 )
{
const Any aTarget(p1->getTarget());
if( aTarget.hasValue() && aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
{
ParagraphTarget aParaTarget;
aTarget >>= aParaTarget;
return aParaTarget.Paragraph;
}
else
{
return mbReverse ? 0x7fffffff : -1;
}
}
// --------------------------------------------------------------------
bool ImplStlTextGroupSortHelper::operator()( const CustomAnimationEffectPtr& p1, const CustomAnimationEffectPtr& p2 )
{
if( mbReverse )
{
return getTargetParagraph( p2 ) < getTargetParagraph( p1 );
}
else
{
return getTargetParagraph( p1 ) < getTargetParagraph( p2 );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::setTextReverse( CustomAnimationTextGroupPtr pTextGroup, sal_Bool bTextReverse )
{
if( pTextGroup->mbTextReverse == bTextReverse )
{
// do nothing
}
else
{
std::vector< CustomAnimationEffectPtr > aSortedVector(pTextGroup->maEffects.size());
std::copy( pTextGroup->maEffects.begin(), pTextGroup->maEffects.end(), aSortedVector.begin() );
ImplStlTextGroupSortHelper aSortHelper( bTextReverse );
std::sort( aSortedVector.begin(), aSortedVector.end(), aSortHelper );
pTextGroup->reset();
std::vector< CustomAnimationEffectPtr >::iterator aIter( aSortedVector.begin() );
const std::vector< CustomAnimationEffectPtr >::iterator aEnd( aSortedVector.end() );
if( aIter != aEnd )
{
pTextGroup->addEffect( (*aIter ) );
EffectSequence::iterator aInsertIter( find( (*aIter++) ) );
while( aIter != aEnd )
{
CustomAnimationEffectPtr pEffect( (*aIter++) );
maEffects.erase( find( pEffect ) );
aInsertIter = maEffects.insert( ++aInsertIter, pEffect );
pTextGroup->addEffect( pEffect );
}
}
notify_listeners();
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::addListener( ISequenceListener* pListener )
{
if( std::find( maListeners.begin(), maListeners.end(), pListener ) == maListeners.end() )
maListeners.push_back( pListener );
}
// --------------------------------------------------------------------
void EffectSequenceHelper::removeListener( ISequenceListener* pListener )
{
maListeners.remove( pListener );
}
// --------------------------------------------------------------------
struct stl_notify_listeners_func : public std::unary_function<ISequenceListener*, void>
{
stl_notify_listeners_func() {}
void operator()(ISequenceListener* pListener) { pListener->notify_change(); }
};
// --------------------------------------------------------------------
void EffectSequenceHelper::notify_listeners()
{
stl_notify_listeners_func aFunc;
std::for_each( maListeners.begin(), maListeners.end(), aFunc );
}
// --------------------------------------------------------------------
void EffectSequenceHelper::create( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
{
DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::create(), illegal argument" );
if( xNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
createEffectsequence( xChildNode );
}
}
catch( Exception& )
{
DBG_ERROR( "sd::EffectSequenceHelper::create(), exception caught!" );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::createEffectsequence( const Reference< XAnimationNode >& xNode )
{
DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::createEffectsequence(), illegal argument" );
if( xNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
createEffects( xChildNode );
}
}
catch( Exception& )
{
DBG_ERROR( "sd::EffectSequenceHelper::createEffectsequence(), exception caught!" );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::createEffects( const Reference< XAnimationNode >& xNode )
{
DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::createEffects(), illegal argument" );
if( xNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
switch( xChildNode->getType() )
{
// found an effect
case AnimationNodeType::PAR:
case AnimationNodeType::ITERATE:
{
CustomAnimationEffectPtr pEffect( new CustomAnimationEffect( xChildNode ) );
if( pEffect->mnNodeType != -1 )
{
pEffect->setEffectSequence( this );
maEffects.push_back(pEffect);
}
}
break;
// found an after effect
case AnimationNodeType::SET:
case AnimationNodeType::ANIMATECOLOR:
{
processAfterEffect( xChildNode );
}
break;
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::EffectSequenceHelper::createEffects(), exception caught!" );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::processAfterEffect( const Reference< XAnimationNode >& xNode )
{
try
{
Reference< XAnimationNode > xMaster;
Sequence< NamedValue > aUserData( xNode->getUserData() );
sal_Int32 nLength = aUserData.getLength();
const NamedValue* p = aUserData.getConstArray();
while( nLength-- )
{
if( p->Name.equalsAscii( "master-element" ) )
{
p->Value >>= xMaster;
break;
}
p++;
}
// only process if this is a valid after effect
if( xMaster.is() )
{
CustomAnimationEffectPtr pMasterEffect;
// find the master effect
stl_CustomAnimationEffect_search_node_predict aSearchPredict( xMaster );
EffectSequence::iterator aIter( std::find_if( maEffects.begin(), maEffects.end(), aSearchPredict ) );
if( aIter != maEffects.end() )
pMasterEffect = (*aIter );
if( pMasterEffect.get() )
{
pMasterEffect->setHasAfterEffect( true );
// find out what kind of after effect this is
if( xNode->getType() == AnimationNodeType::ANIMATECOLOR )
{
// its a dim
Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
pMasterEffect->setDimColor( xAnimate->getTo() );
pMasterEffect->setAfterEffectOnNext( true );
}
else
{
// its a hide
Reference< XChild > xNodeChild( xNode, UNO_QUERY_THROW );
Reference< XChild > xMasterChild( xMaster, UNO_QUERY_THROW );
pMasterEffect->setAfterEffectOnNext( xNodeChild->getParent() != xMasterChild->getParent() );
}
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::EffectSequenceHelper::processAfterEffect(), exception caught!" );
}
}
/*
double EffectSequenceHelper::calculateIterateNodeDuration(
{
Reference< i18n::XBreakIterator > xBI( ImplGetBreakIterator() );
sal_Int32 nDone;
sal_Int32 nNextCellBreak( xBI->nextCharacters(rTxt, nIdx, rLocale, i18n::CharacterIteratorMode::SKIPCELL, 0, nDone) );
i18n::Boundary nNextWordBoundary( xBI->getWordBoundary(rTxt, nIdx, rLocale, i18n::WordType::ANY_WORD, sal_True) );
sal_Int32 nNextSentenceBreak( xBI->endOfSentence(rTxt, nIdx, rLocale) );
const sal_Int32 nEndPos( nIdx + nLen );
sal_Int32 i, currOffset(0);
for( i=nIdx; i<nEndPos; ++i )
{
// TODO: Check whether position update is valid for CTL/BiDi
rOutDev.DrawText( rPos + Point(currOffset,0), rTxt, i, 1 );
currOffset = *pDXArray++;
// issue the comments at the respective break positions
if( i == nNextCellBreak )
{
rMtf.AddAction( new MetaCommentAction( "XTEXT_EOC" ) );
nNextCellBreak = xBI->nextCharacters(rTxt, i, rLocale, i18n::CharacterIteratorMode::SKIPCELL, 1, nDone);
}
if( i == nNextWordBoundary.endPos )
{
rMtf.AddAction( new MetaCommentAction( "XTEXT_EOW" ) );
nNextWordBoundary = xBI->getWordBoundary(rTxt, i+1, rLocale, i18n::WordType::ANY_WORD, sal_True);
}
if( i == nNextSentenceBreak )
{
rMtf.AddAction( new MetaCommentAction( "XTEXT_EOS" ) );
nNextSentenceBreak = xBI->endOfSentence(rTxt, i+1, rLocale);
}
}
}
*/
// ====================================================================
class AnimationChangeListener : public cppu::WeakImplHelper1< XChangesListener >
{
public:
AnimationChangeListener( MainSequence* pMainSequence ) : mpMainSequence( pMainSequence ) {}
virtual void SAL_CALL changesOccurred( const ::com::sun::star::util::ChangesEvent& Event ) throw (RuntimeException);
virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException);
private:
MainSequence* mpMainSequence;
};
void SAL_CALL AnimationChangeListener::changesOccurred( const ::com::sun::star::util::ChangesEvent& ) throw (RuntimeException)
{
if( mpMainSequence )
mpMainSequence->startRecreateTimer();
}
void SAL_CALL AnimationChangeListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (RuntimeException)
{
}
// ====================================================================
MainSequence::MainSequence()
: mxTimingRootNode( ::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))), UNO_QUERY )
, mbRebuilding( false )
, mnRebuildLockGuard( 0 )
, mbPendingRebuildRequest( false )
{
if( mxTimingRootNode.is() )
{
Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::MAIN_SEQUENCE;
mxTimingRootNode->setUserData( aUserData );
}
init();
}
// --------------------------------------------------------------------
MainSequence::MainSequence( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
: mxTimingRootNode( xNode, UNO_QUERY )
, mbRebuilding( false )
, mnRebuildLockGuard( 0 )
, mbPendingRebuildRequest( false )
, mbIgnoreChanges( 0 )
{
init();
}
// --------------------------------------------------------------------
MainSequence::~MainSequence()
{
reset();
}
// --------------------------------------------------------------------
void MainSequence::init()
{
mnSequenceType = EffectNodeType::MAIN_SEQUENCE;
maTimer.SetTimeoutHdl( LINK(this, MainSequence, onTimerHdl) );
maTimer.SetTimeout(500);
mxChangesListener.set( new AnimationChangeListener( this ) );
createMainSequence();
}
// --------------------------------------------------------------------
void MainSequence::reset( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xTimingRootNode )
{
reset();
mxTimingRootNode.set( xTimingRootNode, UNO_QUERY );
createMainSequence();
}
// --------------------------------------------------------------------
Reference< ::com::sun::star::animations::XAnimationNode > MainSequence::getRootNode()
{
DBG_ASSERT( mnRebuildLockGuard == 0, "MainSequence::getRootNode(), rebuild is locked, ist this really what you want?" );
if( maTimer.IsActive() && mbTimerMode )
{
// force a rebuild NOW if one is pending
maTimer.Stop();
implRebuild();
}
return EffectSequenceHelper::getRootNode();
}
// --------------------------------------------------------------------
void MainSequence::createMainSequence()
{
if( mxTimingRootNode.is() ) try
{
Reference< XEnumerationAccess > xEnumerationAccess( mxTimingRootNode, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
sal_Int32 nNodeType = CustomAnimationEffect::get_node_type( xChildNode );
if( nNodeType == EffectNodeType::MAIN_SEQUENCE )
{
mxSequenceRoot.set( xChildNode, UNO_QUERY );
EffectSequenceHelper::create( xChildNode );
}
else if( nNodeType == EffectNodeType::INTERACTIVE_SEQUENCE )
{
Reference< XTimeContainer > xInteractiveRoot( xChildNode, UNO_QUERY_THROW );
InteractiveSequencePtr pIS( new InteractiveSequence( xInteractiveRoot, this ) );
pIS->addListener( this );
maInteractiveSequenceList.push_back( pIS );
}
}
// see if we have a mainsequence at all. if not, create one...
if( !mxSequenceRoot.is() )
{
mxSequenceRoot = Reference< XTimeContainer >::query(::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))));
if( mxSequenceRoot.is() )
{
uno::Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::MAIN_SEQUENCE;
mxSequenceRoot->setUserData( aUserData );
// empty sequence until now, set duration to 0.0
// explicitely (otherwise, this sequence will never
// end)
mxSequenceRoot->setDuration( makeAny((double)0.0) );
Reference< XAnimationNode > xMainSequenceNode( mxSequenceRoot, UNO_QUERY_THROW );
mxTimingRootNode->appendChild( xMainSequenceNode );
}
}
updateTextGroups();
notify_listeners();
Reference< XChangesNotifier > xNotifier( mxTimingRootNode, UNO_QUERY );
if( xNotifier.is() )
xNotifier->addChangesListener( mxChangesListener );
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::MainSequence::create(), exception caught!" );
return;
}
DBG_ASSERT( mxSequenceRoot.is(), "sd::MainSequence::create(), found no main sequence!" );
}
// --------------------------------------------------------------------
void MainSequence::reset()
{
EffectSequenceHelper::reset();
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
(*aIter)->reset();
maInteractiveSequenceList.clear();
try
{
Reference< XChangesNotifier > xNotifier( mxTimingRootNode, UNO_QUERY );
if( xNotifier.is() )
xNotifier->removeChangesListener( mxChangesListener );
}
catch( Exception& )
{
// ...
}
}
// --------------------------------------------------------------------
InteractiveSequencePtr MainSequence::createInteractiveSequence( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xShape )
{
InteractiveSequencePtr pIS;
// create a new interactive sequence container
Reference< XTimeContainer > xISRoot( ::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))), UNO_QUERY );
DBG_ASSERT( xISRoot.is(), "sd::MainSequence::createInteractiveSequence(), could not create \"com.sun.star.animations.SequenceTimeContainer\"!");
if( xISRoot.is() )
{
uno::Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::INTERACTIVE_SEQUENCE ;
xISRoot->setUserData( aUserData );
Reference< XChild > xChild( mxSequenceRoot, UNO_QUERY_THROW );
Reference< XAnimationNode > xISNode( xISRoot, UNO_QUERY_THROW );
Reference< XTimeContainer > xParent( xChild->getParent(), UNO_QUERY_THROW );
xParent->appendChild( xISNode );
}
pIS.reset( new InteractiveSequence( xISRoot, this) );
pIS->setTriggerShape( xShape );
pIS->addListener( this );
maInteractiveSequenceList.push_back( pIS );
return pIS;
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr MainSequence::findEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode ) const
{
CustomAnimationEffectPtr pEffect = EffectSequenceHelper::findEffect( xNode );
if( pEffect.get() == 0 )
{
InteractiveSequenceList::const_iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); (aIter != maInteractiveSequenceList.end()) && (pEffect.get() == 0); aIter++ )
{
pEffect = (*aIter)->findEffect( xNode );
}
}
return pEffect;
}
// --------------------------------------------------------------------
sal_Int32 MainSequence::getOffsetFromEffect( const CustomAnimationEffectPtr& pEffect ) const
{
sal_Int32 nOffset = EffectSequenceHelper::getOffsetFromEffect( pEffect );
if( nOffset != -1 )
return nOffset;
nOffset = EffectSequenceHelper::getCount();
InteractiveSequenceList::const_iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
{
sal_Int32 nTemp = (*aIter)->getOffsetFromEffect( pEffect );
if( nTemp != -1 )
return nOffset + nTemp;
nOffset += (*aIter)->getCount();
}
return -1;
}
// --------------------------------------------------------------------
CustomAnimationEffectPtr MainSequence::getEffectFromOffset( sal_Int32 nOffset ) const
{
if( nOffset >= 0 )
{
if( nOffset < getCount() )
return EffectSequenceHelper::getEffectFromOffset( nOffset );
nOffset -= getCount();
InteractiveSequenceList::const_iterator aIter( maInteractiveSequenceList.begin() );
while( (aIter != maInteractiveSequenceList.end()) && (nOffset > (*aIter)->getCount()) )
nOffset -= (*aIter++)->getCount();
if( (aIter != maInteractiveSequenceList.end()) && (nOffset >= 0) )
return (*aIter)->getEffectFromOffset( nOffset );
}
CustomAnimationEffectPtr pEffect;
return pEffect;
}
// --------------------------------------------------------------------
bool MainSequence::disposeShape( const Reference< XShape >& xShape )
{
bool bChanges = EffectSequenceHelper::disposeShape( xShape );
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); )
{
bChanges |= (*aIter++)->disposeShape( xShape );
}
if( bChanges )
startRebuildTimer();
return bChanges;
}
// --------------------------------------------------------------------
bool MainSequence::hasEffect( const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape )
{
if( EffectSequenceHelper::hasEffect( xShape ) )
return true;
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); )
{
if( (*aIter)->getTriggerShape() == xShape )
return true;
if( (*aIter++)->hasEffect( xShape ) )
return true;
}
return false;
}
// --------------------------------------------------------------------
void MainSequence::insertTextRange( const com::sun::star::uno::Any& aTarget )
{
EffectSequenceHelper::insertTextRange( aTarget );
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
{
(*aIter)->insertTextRange( aTarget );
}
}
// --------------------------------------------------------------------
void MainSequence::disposeTextRange( const com::sun::star::uno::Any& aTarget )
{
EffectSequenceHelper::disposeTextRange( aTarget );
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
{
(*aIter)->disposeTextRange( aTarget );
}
}
// --------------------------------------------------------------------
/** callback from the sd::View when an object just left text edit mode */
void MainSequence::onTextChanged( const Reference< XShape >& xShape )
{
EffectSequenceHelper::onTextChanged( xShape );
InteractiveSequenceList::iterator aIter;
for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
{
(*aIter)->onTextChanged( xShape );
}
}
// --------------------------------------------------------------------
void EffectSequenceHelper::onTextChanged( const Reference< XShape >& xShape )
{
bool bChanges = false;
EffectSequence::iterator aIter;
for( aIter = maEffects.begin(); aIter != maEffects.end(); aIter++ )
{
if( (*aIter)->getTargetShape() == xShape )
bChanges |= (*aIter)->checkForText();
}
if( bChanges )
EffectSequenceHelper::implRebuild();
}
// --------------------------------------------------------------------
void MainSequence::rebuild()
{
startRebuildTimer();
}
// --------------------------------------------------------------------
void MainSequence::lockRebuilds()
{
mnRebuildLockGuard++;
}
// --------------------------------------------------------------------
void MainSequence::unlockRebuilds()
{
DBG_ASSERT( mnRebuildLockGuard, "sd::MainSequence::unlockRebuilds(), no corresponding lockRebuilds() call!" );
if( mnRebuildLockGuard )
mnRebuildLockGuard--;
if( (mnRebuildLockGuard == 0) && mbPendingRebuildRequest )
{
mbPendingRebuildRequest = false;
startRebuildTimer();
}
}
// --------------------------------------------------------------------
void MainSequence::implRebuild()
{
if( mnRebuildLockGuard )
{
mbPendingRebuildRequest = true;
return;
}
mbRebuilding = true;
EffectSequenceHelper::implRebuild();
InteractiveSequenceList::iterator aIter( maInteractiveSequenceList.begin() );
const InteractiveSequenceList::iterator aEnd( maInteractiveSequenceList.end() );
while( aIter != aEnd )
{
InteractiveSequencePtr pIS( (*aIter) );
if( pIS->maEffects.empty() )
{
// remove empty interactive sequences
aIter = maInteractiveSequenceList.erase( aIter );
Reference< XChild > xChild( mxSequenceRoot, UNO_QUERY_THROW );
Reference< XTimeContainer > xParent( xChild->getParent(), UNO_QUERY_THROW );
Reference< XAnimationNode > xISNode( pIS->mxSequenceRoot, UNO_QUERY_THROW );
xParent->removeChild( xISNode );
}
else
{
pIS->implRebuild();
aIter++;
}
}
notify_listeners();
mbRebuilding = false;
}
// --------------------------------------------------------------------
void MainSequence::notify_change()
{
notify_listeners();
}
// --------------------------------------------------------------------
bool MainSequence::setTrigger( const CustomAnimationEffectPtr& pEffect, const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xTriggerShape )
{
EffectSequenceHelper* pOldSequence = pEffect->getEffectSequence();
EffectSequenceHelper* pNewSequence = 0;
if( xTriggerShape.is() )
{
InteractiveSequenceList::iterator aIter( maInteractiveSequenceList.begin() );
const InteractiveSequenceList::iterator aEnd( maInteractiveSequenceList.end() );
while( aIter != aEnd )
{
InteractiveSequencePtr pIS( (*aIter++) );
if( pIS->getTriggerShape() == xTriggerShape )
{
pNewSequence = pIS.get();
break;
}
}
if( !pNewSequence )
pNewSequence = createInteractiveSequence( xTriggerShape ).get();
}
else
{
pNewSequence = this;
}
if( pOldSequence != pNewSequence )
{
if( pOldSequence )
pOldSequence->maEffects.remove( pEffect );
if( pNewSequence )
pNewSequence->maEffects.push_back( pEffect );
pEffect->setEffectSequence( pNewSequence );
return true;
}
else
{
return false;
}
}
// --------------------------------------------------------------------
IMPL_LINK( MainSequence, onTimerHdl, Timer *, EMPTYARG )
{
if( mbTimerMode )
{
implRebuild();
}
else
{
reset();
createMainSequence();
}
return 0;
}
// --------------------------------------------------------------------
/** starts a timer that recreates the internal structure from the API core after 1 second */
void MainSequence::startRecreateTimer()
{
if( !mbRebuilding && (mbIgnoreChanges == 0) )
{
mbTimerMode = false;
maTimer.Start();
}
}
// --------------------------------------------------------------------
/** starts a timer that rebuilds the API core from the internal structure after 1 second */
void MainSequence::startRebuildTimer()
{
mbTimerMode = true;
maTimer.Start();
}
// ====================================================================
InteractiveSequence::InteractiveSequence( const Reference< XTimeContainer >& xSequenceRoot, MainSequence* pMainSequence )
: EffectSequenceHelper( xSequenceRoot ), mpMainSequence( pMainSequence )
{
mnSequenceType = EffectNodeType::INTERACTIVE_SEQUENCE;
try
{
if( mxSequenceRoot.is() )
{
Reference< XEnumerationAccess > xEnumerationAccess( mxSequenceRoot, UNO_QUERY_THROW );
Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
while( !mxEventSource.is() && xEnumeration->hasMoreElements() )
{
Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
Event aEvent;
if( (xChildNode->getBegin() >>= aEvent) && (aEvent.Trigger == EventTrigger::ON_CLICK) )
aEvent.Source >>= mxEventSource;
}
}
}
catch( Exception& e )
{
(void)e;
DBG_ERROR( "sd::InteractiveSequence::InteractiveSequence(), exception caught!" );
return;
}
}
// --------------------------------------------------------------------
void InteractiveSequence::rebuild()
{
mpMainSequence->rebuild();
}
void InteractiveSequence::implRebuild()
{
EffectSequenceHelper::implRebuild();
}
// --------------------------------------------------------------------
MainSequenceRebuildGuard::MainSequenceRebuildGuard( const MainSequencePtr& pMainSequence )
: mpMainSequence( pMainSequence )
{
if( mpMainSequence.get() )
mpMainSequence->lockRebuilds();
}
MainSequenceRebuildGuard::~MainSequenceRebuildGuard()
{
if( mpMainSequence.get() )
mpMainSequence->unlockRebuilds();
}
}