| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <com/sun/star/uno/XComponentContext.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/lang/XTypeProvider.hpp> |
| #include <com/sun/star/animations/XTargetPropertiesCreator.hpp> |
| #include <com/sun/star/animations/XIterateContainer.hpp> |
| #include <com/sun/star/animations/TargetProperties.hpp> |
| #include <com/sun/star/presentation/ParagraphTarget.hpp> |
| #include <com/sun/star/registry/XRegistryKey.hpp> |
| #include <com/sun/star/lang/XInitialization.hpp> |
| #include <com/sun/star/lang/XServiceName.hpp> |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> |
| #include <com/sun/star/drawing/XShape.hpp> |
| #include <com/sun/star/animations/AnimationNodeType.hpp> |
| #include <com/sun/star/animations/XAnimate.hpp> |
| #include <cppuhelper/compbase3.hxx> |
| #include <cppuhelper/factory.hxx> |
| #include <cppuhelper/implementationentry.hxx> |
| #include <comphelper/broadcasthelper.hxx> |
| #include <comphelper/sequence.hxx> |
| |
| #include <animations/animationnodehelper.hxx> |
| |
| #include <vector> |
| #include <hash_map> |
| |
| |
| using namespace ::com::sun::star; |
| |
| #define IMPLEMENTATION_NAME "animcore::TargetPropertiesCreator" |
| #define SERVICE_NAME "com.sun.star.animations.TargetPropertiesCreator" |
| |
| namespace animcore |
| { |
| typedef ::cppu::WeakComponentImplHelper3< ::com::sun::star::animations::XTargetPropertiesCreator, |
| lang::XServiceInfo, |
| lang::XServiceName > TargetPropertiesCreator_Base; |
| |
| class TargetPropertiesCreator : public ::comphelper::OBaseMutex, |
| public TargetPropertiesCreator_Base |
| { |
| public: |
| static uno::Reference< uno::XInterface > SAL_CALL createInstance( const uno::Reference< uno::XComponentContext >& xContext ) throw ( uno::Exception ) |
| { |
| return uno::Reference< uno::XInterface >( static_cast<cppu::OWeakObject*>(new TargetPropertiesCreator( xContext )) ); |
| } |
| |
| /// Dispose all internal references |
| virtual void SAL_CALL disposing(); |
| |
| // XTargetPropertiesCreator |
| virtual uno::Sequence< animations::TargetProperties > SAL_CALL createInitialTargetProperties( const uno::Reference< animations::XAnimationNode >& rootNode ) throw (uno::RuntimeException); |
| |
| // XServiceInfo |
| virtual ::rtl::OUString SAL_CALL getImplementationName() throw( uno::RuntimeException ); |
| virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException ); |
| virtual uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames() throw( uno::RuntimeException ); |
| |
| // XServiceName |
| virtual ::rtl::OUString SAL_CALL getServiceName( ) throw (uno::RuntimeException); |
| |
| protected: |
| ~TargetPropertiesCreator(); // we're a ref-counted UNO class. _We_ destroy ourselves. |
| |
| private: |
| // default: disabled copy/assignment |
| TargetPropertiesCreator(const TargetPropertiesCreator&); |
| TargetPropertiesCreator& operator=( const TargetPropertiesCreator& ); |
| |
| TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >& rxContext ); |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| uno::Reference< uno::XInterface > SAL_CALL createInstance_TargetPropertiesCreator( const uno::Reference< uno::XComponentContext > & rSMgr ) throw (uno::Exception) |
| { |
| return TargetPropertiesCreator::createInstance( rSMgr ); |
| } |
| |
| ::rtl::OUString getImplementationName_TargetPropertiesCreator() |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) ); |
| } |
| |
| uno::Sequence< ::rtl::OUString > getSupportedServiceNames_TargetPropertiesCreator(void) |
| { |
| uno::Sequence< ::rtl::OUString > aRet(1); |
| aRet.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) ); |
| return aRet; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| namespace |
| { |
| // Vector containing all properties for a given shape |
| typedef ::std::vector< beans::NamedValue > VectorOfNamedValues; |
| |
| /** The hash map key |
| |
| This key contains both XShape reference and a paragraph |
| index, as we somehow have to handle shape and paragraph |
| targets with the same data structure. |
| */ |
| struct ShapeHashKey |
| { |
| /// Shape target |
| uno::Reference< drawing::XShape > mxRef; |
| |
| /** Paragraph index. |
| |
| If this is a pure shape target, mnParagraphIndex is |
| set to -1. |
| */ |
| sal_Int16 mnParagraphIndex; |
| |
| /// Comparison needed for hash_map |
| bool operator==( const ShapeHashKey& rRHS ) const |
| { |
| return mxRef == rRHS.mxRef && mnParagraphIndex == rRHS.mnParagraphIndex; |
| } |
| }; |
| |
| // A hash functor for ShapeHashKey objects |
| struct ShapeKeyHasher { |
| ::std::size_t operator()( const ShapeHashKey& rKey ) const |
| { |
| // TODO(P2): Maybe a better hash function would be to |
| // spread mnParagraphIndex to 32 bit: a0b0c0d0e0... Hakmem |
| // should have a formula. |
| // |
| // Yes it has: |
| // x = (x & 0x0000FF00) << 8) | (x >> 8) & 0x0000FF00 | x & 0xFF0000FF; |
| // x = (x & 0x00F000F0) << 4) | (x >> 4) & 0x00F000F0 | x & 0xF00FF00F; |
| // x = (x & 0x0C0C0C0C) << 2) | (x >> 2) & 0x0C0C0C0C | x & 0xC3C3C3C3; |
| // x = (x & 0x22222222) << 1) | (x >> 1) & 0x22222222 | x & 0x99999999; |
| // |
| // Costs about 17 cycles on a RISC machine with infinite |
| // instruction level parallelism (~42 basic |
| // instructions). Thus I truly doubt this pays off... |
| return reinterpret_cast< ::std::size_t >(rKey.mxRef.get()) ^ (rKey.mnParagraphIndex << 16L); |
| } |
| }; |
| |
| // A hash map which maps a XShape to the corresponding vector of initial properties |
| typedef ::std::hash_map< ShapeHashKey, VectorOfNamedValues, ShapeKeyHasher > XShapeHash; |
| |
| class NodeFunctor |
| { |
| public: |
| explicit NodeFunctor( XShapeHash& rShapeHash ) : |
| mrShapeHash( rShapeHash ), |
| mxTargetShape(), |
| mnParagraphIndex( -1 ) |
| { |
| } |
| |
| NodeFunctor( XShapeHash& rShapeHash, |
| const uno::Reference< drawing::XShape >& rTargetShape, |
| sal_Int16 nParagraphIndex ) : |
| mrShapeHash( rShapeHash ), |
| mxTargetShape( rTargetShape ), |
| mnParagraphIndex( nParagraphIndex ) |
| { |
| } |
| |
| void operator()( const uno::Reference< animations::XAnimationNode >& xNode ) const |
| { |
| if( !xNode.is() ) |
| { |
| OSL_ENSURE( false, |
| "AnimCore: NodeFunctor::operator(): invalid XAnimationNode" ); |
| return; |
| } |
| |
| uno::Reference< drawing::XShape > xTargetShape( mxTargetShape ); |
| sal_Int16 nParagraphIndex( mnParagraphIndex ); |
| |
| switch( xNode->getType() ) |
| { |
| case animations::AnimationNodeType::ITERATE: |
| { |
| // extract target shape from iterate node |
| // (will override the target for all children) |
| // -------------------------------------------------- |
| |
| uno::Reference< animations::XIterateContainer > xIterNode( xNode, |
| uno::UNO_QUERY ); |
| |
| // TODO(E1): I'm not too sure what to expect here... |
| if( !xIterNode->getTarget().hasValue() ) |
| { |
| OSL_ENSURE( false, |
| "animcore: NodeFunctor::operator(): no target on ITERATE node" ); |
| return; |
| } |
| |
| xTargetShape.set( xIterNode->getTarget(), |
| uno::UNO_QUERY ); |
| |
| if( !xTargetShape.is() ) |
| { |
| ::com::sun::star::presentation::ParagraphTarget aTarget; |
| |
| // no shape provided. Maybe a ParagraphTarget? |
| if( !(xIterNode->getTarget() >>= aTarget) ) |
| { |
| OSL_ENSURE( false, |
| "animcore: NodeFunctor::operator(): could not extract any " |
| "target information" ); |
| return; |
| } |
| |
| xTargetShape = aTarget.Shape; |
| nParagraphIndex = aTarget.Paragraph; |
| |
| if( !xTargetShape.is() ) |
| { |
| OSL_ENSURE( false, |
| "animcore: NodeFunctor::operator(): invalid shape in ParagraphTarget" ); |
| return; |
| } |
| } |
| } |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::PAR: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::SEQ: |
| { |
| NodeFunctor aFunctor( mrShapeHash, |
| xTargetShape, |
| nParagraphIndex ); |
| if( !::anim::for_each_childNode( xNode, |
| aFunctor ) ) |
| { |
| OSL_ENSURE( false, |
| "AnimCore: NodeFunctor::operator(): child node iteration failed, " |
| "or extraneous container nodes encountered" ); |
| } |
| } |
| break; |
| |
| case animations::AnimationNodeType::CUSTOM: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::ANIMATE: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::ANIMATEMOTION: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::ANIMATECOLOR: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::ANIMATETRANSFORM: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::TRANSITIONFILTER: |
| // FALLTHROUGH intended |
| case animations::AnimationNodeType::AUDIO: |
| // FALLTHROUGH intended |
| /*default: |
| // ignore this node, no valuable content for now. |
| break;*/ |
| |
| case animations::AnimationNodeType::SET: |
| { |
| // evaluate set node content |
| uno::Reference< animations::XAnimate > xAnimateNode( xNode, |
| uno::UNO_QUERY ); |
| |
| if( !xAnimateNode.is() ) |
| break; // invalid node |
| |
| // determine target shape (if any) |
| ShapeHashKey aTarget; |
| if( xTargetShape.is() ) |
| { |
| // override target shape with parent-supplied |
| aTarget.mxRef = xTargetShape; |
| aTarget.mnParagraphIndex = nParagraphIndex; |
| } |
| else |
| { |
| // no parent-supplied target, retrieve |
| // node target |
| if( (xAnimateNode->getTarget() >>= aTarget.mxRef) ) |
| { |
| // pure shape target - set paragraph |
| // index to magic |
| aTarget.mnParagraphIndex = -1; |
| } |
| else |
| { |
| // not a pure shape target - maybe a |
| // ParagraphTarget? |
| presentation::ParagraphTarget aUnoTarget; |
| |
| if( !(xAnimateNode->getTarget() >>= aUnoTarget) ) |
| { |
| OSL_ENSURE( false, |
| "AnimCore: NodeFunctor::operator(): unknown target type encountered" ); |
| break; |
| } |
| |
| aTarget.mxRef = aUnoTarget.Shape; |
| aTarget.mnParagraphIndex = aUnoTarget.Paragraph; |
| } |
| } |
| |
| if( !aTarget.mxRef.is() ) |
| { |
| OSL_ENSURE( false, |
| "AnimCore: NodeFunctor::operator(): Found target, but XShape is NULL" ); |
| break; // invalid target XShape |
| } |
| |
| // check whether we already have an entry for |
| // this target (we only take the first set |
| // effect for every shape) |
| XShapeHash::const_iterator aIter; |
| if( (aIter=mrShapeHash.find( aTarget )) != mrShapeHash.end() ) |
| break; // already an entry in existence for given XShape |
| |
| // if this is an appear effect, hide shape |
| // initially. This is currently the only place |
| // where a shape effect influences shape |
| // attributes outside it's effective duration. |
| sal_Bool bVisible( sal_False ); |
| if( xAnimateNode->getAttributeName().equalsIgnoreAsciiCaseAscii("visibility") ) |
| { |
| |
| uno::Any aAny( xAnimateNode->getTo() ); |
| |
| // try to extract bool value |
| if( !(aAny >>= bVisible) ) |
| { |
| // try to extract string |
| ::rtl::OUString aString; |
| if( (aAny >>= aString) ) |
| { |
| // we also take the strings "true" and "false", |
| // as well as "on" and "off" here |
| if( aString.equalsIgnoreAsciiCaseAscii("true") || |
| aString.equalsIgnoreAsciiCaseAscii("on") ) |
| { |
| bVisible = sal_True; |
| } |
| if( aString.equalsIgnoreAsciiCaseAscii("false") || |
| aString.equalsIgnoreAsciiCaseAscii("off") ) |
| { |
| bVisible = sal_False; |
| } |
| } |
| } |
| |
| /*if( bVisible ) |
| { |
| // target is set to 'visible' at the |
| // first relevant effect. Thus, target |
| // must be initially _hidden_, for the |
| // effect to have visible impact. |
| */ |
| } |
| // target is set the 'visible' value, |
| // so we should record the opposite value |
| mrShapeHash.insert( |
| XShapeHash::value_type( |
| aTarget, |
| VectorOfNamedValues( |
| 1, |
| beans::NamedValue( |
| //xAnimateNode->getAttributeName(), |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("visibility")), |
| uno::makeAny( !bVisible ) ) ) ) ); |
| //} |
| //} |
| } |
| break; |
| } |
| } |
| |
| private: |
| XShapeHash& mrShapeHash; |
| uno::Reference< drawing::XShape > mxTargetShape; |
| sal_Int16 mnParagraphIndex; |
| }; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| TargetPropertiesCreator::TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >& ) : |
| TargetPropertiesCreator_Base( m_aMutex ) |
| { |
| } |
| |
| TargetPropertiesCreator::~TargetPropertiesCreator() |
| { |
| } |
| |
| void SAL_CALL TargetPropertiesCreator::disposing() |
| { |
| ::osl::MutexGuard aGuard( m_aMutex ); |
| } |
| |
| // XTargetPropertiesCreator |
| uno::Sequence< animations::TargetProperties > SAL_CALL TargetPropertiesCreator::createInitialTargetProperties |
| ( |
| const uno::Reference< animations::XAnimationNode >& xRootNode |
| ) throw (uno::RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aMutex ); |
| |
| // scan all nodes for visibility changes, and record first |
| // 'visibility=true' for each shape |
| XShapeHash aShapeHash( 101 ); |
| |
| NodeFunctor aFunctor( aShapeHash ); |
| |
| // TODO(F1): Maybe limit functor application to main sequence |
| // alone (CL said something that shape visibility is only |
| // affected by effects in the main sequence for PPT). |
| // |
| // OTOH, client code can pass us only the main sequence (which |
| // it actually does right now, for the slideshow implementation). |
| aFunctor( xRootNode ); |
| |
| |
| // output to result sequence |
| // ---------------------------------------------------------------------- |
| |
| uno::Sequence< animations::TargetProperties > aRes( aShapeHash.size() ); |
| |
| ::std::size_t nCurrIndex(0); |
| XShapeHash::const_iterator aCurr( aShapeHash.begin() ); |
| const XShapeHash::const_iterator aEnd ( aShapeHash.end() ); |
| while( aCurr != aEnd ) |
| { |
| animations::TargetProperties& rCurrProps( aRes[ nCurrIndex++ ] ); |
| |
| if( aCurr->first.mnParagraphIndex == -1 ) |
| { |
| rCurrProps.Target = uno::makeAny( aCurr->first.mxRef ); |
| } |
| else |
| { |
| rCurrProps.Target = uno::makeAny( |
| presentation::ParagraphTarget( |
| aCurr->first.mxRef, |
| aCurr->first.mnParagraphIndex ) ); |
| } |
| |
| rCurrProps.Properties = ::comphelper::containerToSequence( aCurr->second ); |
| |
| ++aCurr; |
| } |
| |
| return aRes; |
| } |
| |
| // XServiceInfo |
| ::rtl::OUString SAL_CALL TargetPropertiesCreator::getImplementationName() throw( uno::RuntimeException ) |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) ); |
| } |
| |
| sal_Bool SAL_CALL TargetPropertiesCreator::supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException ) |
| { |
| return ServiceName.equalsIgnoreAsciiCaseAscii( SERVICE_NAME ); |
| } |
| |
| uno::Sequence< ::rtl::OUString > SAL_CALL TargetPropertiesCreator::getSupportedServiceNames() throw( uno::RuntimeException ) |
| { |
| uno::Sequence< ::rtl::OUString > aRet(1); |
| aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) ); |
| |
| return aRet; |
| } |
| |
| // XServiceName |
| ::rtl::OUString SAL_CALL TargetPropertiesCreator::getServiceName( ) throw (uno::RuntimeException) |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) ); |
| } |
| |
| } // namespace animcore |
