1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #include <com/sun/star/uno/XComponentContext.hpp>
25 #include <com/sun/star/lang/XServiceInfo.hpp>
26 #include <com/sun/star/lang/XTypeProvider.hpp>
27 #include <com/sun/star/animations/XTargetPropertiesCreator.hpp>
28 #include <com/sun/star/animations/XIterateContainer.hpp>
29 #include <com/sun/star/animations/TargetProperties.hpp>
30 #include <com/sun/star/presentation/ParagraphTarget.hpp>
31 #include <com/sun/star/registry/XRegistryKey.hpp>
32 #include <com/sun/star/lang/XInitialization.hpp>
33 #include <com/sun/star/lang/XServiceName.hpp>
34 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
35 #include <com/sun/star/drawing/XShape.hpp>
36 #include <com/sun/star/animations/AnimationNodeType.hpp>
37 #include <com/sun/star/animations/XAnimate.hpp>
38 #include <cppuhelper/compbase3.hxx>
39 #include <cppuhelper/factory.hxx>
40 #include <cppuhelper/implementationentry.hxx>
41 #include <comphelper/broadcasthelper.hxx>
42 #include <comphelper/sequence.hxx>
43 
44 #include <animations/animationnodehelper.hxx>
45 
46 #include <vector>
47 #include <hash_map>
48 
49 
50 using namespace ::com::sun::star;
51 
52 #define IMPLEMENTATION_NAME "animcore::TargetPropertiesCreator"
53 #define SERVICE_NAME "com.sun.star.animations.TargetPropertiesCreator"
54 
55 namespace animcore
56 {
57     typedef ::cppu::WeakComponentImplHelper3< ::com::sun::star::animations::XTargetPropertiesCreator,
58                                               lang::XServiceInfo,
59                                               lang::XServiceName >  TargetPropertiesCreator_Base;
60 
61     class TargetPropertiesCreator : public ::comphelper::OBaseMutex,
62                                     public TargetPropertiesCreator_Base
63     {
64     public:
createInstance(const uno::Reference<uno::XComponentContext> & xContext)65         static uno::Reference< uno::XInterface > SAL_CALL createInstance( const uno::Reference< uno::XComponentContext >& xContext ) throw ( uno::Exception )
66         {
67             return uno::Reference< uno::XInterface >( static_cast<cppu::OWeakObject*>(new TargetPropertiesCreator( xContext )) );
68         }
69 
70 	    /// Dispose all internal references
71         virtual void SAL_CALL disposing();
72 
73         // XTargetPropertiesCreator
74         virtual uno::Sequence< animations::TargetProperties > SAL_CALL createInitialTargetProperties( const uno::Reference< animations::XAnimationNode >& rootNode ) throw (uno::RuntimeException);
75 
76         // XServiceInfo
77         virtual ::rtl::OUString SAL_CALL getImplementationName() throw( uno::RuntimeException );
78         virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException );
79         virtual uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames()  throw( uno::RuntimeException );
80 
81         // XServiceName
82         virtual ::rtl::OUString SAL_CALL getServiceName(  ) throw (uno::RuntimeException);
83 
84     protected:
85         ~TargetPropertiesCreator(); // we're a ref-counted UNO class. _We_ destroy ourselves.
86 
87     private:
88         // default: disabled copy/assignment
89         TargetPropertiesCreator(const TargetPropertiesCreator&);
90         TargetPropertiesCreator& operator=( const TargetPropertiesCreator& );
91 
92         TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >& rxContext );
93     };
94 
95 	// --------------------------------------------------------------------
96 
createInstance_TargetPropertiesCreator(const uno::Reference<uno::XComponentContext> & rSMgr)97     uno::Reference< uno::XInterface > SAL_CALL createInstance_TargetPropertiesCreator( const uno::Reference< uno::XComponentContext > & rSMgr ) throw (uno::Exception)
98     {
99         return TargetPropertiesCreator::createInstance( rSMgr );
100     }
101 
getImplementationName_TargetPropertiesCreator()102     ::rtl::OUString getImplementationName_TargetPropertiesCreator()
103     {
104         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) );
105     }
106 
getSupportedServiceNames_TargetPropertiesCreator(void)107     uno::Sequence< ::rtl::OUString > getSupportedServiceNames_TargetPropertiesCreator(void)
108     {
109         uno::Sequence< ::rtl::OUString > aRet(1);
110         aRet.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
111         return aRet;
112     }
113 
114 	// --------------------------------------------------------------------
115 
116     namespace
117     {
118         // Vector containing all properties for a given shape
119         typedef ::std::vector< beans::NamedValue > VectorOfNamedValues;
120 
121         /** The hash map key
122 
123         	This key contains both XShape reference and a paragraph
124         	index, as we somehow have to handle shape and paragraph
125         	targets with the same data structure.
126          */
127         struct ShapeHashKey
128         {
129             /// Shape target
130             uno::Reference< drawing::XShape >	mxRef;
131 
132             /** Paragraph index.
133 
134             	If this is a pure shape target, mnParagraphIndex is
135             	set to -1.
136              */
137             sal_Int16							mnParagraphIndex;
138 
139             /// Comparison needed for hash_map
operator ==animcore::__anon7c1cdad20111::ShapeHashKey140             bool operator==( const ShapeHashKey& rRHS ) const
141             {
142                 return mxRef == rRHS.mxRef && mnParagraphIndex == rRHS.mnParagraphIndex;
143             }
144         };
145 
146         // A hash functor for ShapeHashKey objects
147         struct ShapeKeyHasher {
operator ()animcore::__anon7c1cdad20111::ShapeKeyHasher148 		::std::size_t operator()( const ShapeHashKey& rKey ) const
149 		{
150 		// TODO(P2): Maybe a better hash function would be to
151 		// spread mnParagraphIndex to 32 bit: a0b0c0d0e0... Hakmem
152 		// should have a formula.
153 		//
154 		// Yes it has:
155 		// x = (x & 0x0000FF00) << 8) | (x >> 8) & 0x0000FF00 | x & 0xFF0000FF;
156 		// x = (x & 0x00F000F0) << 4) | (x >> 4) & 0x00F000F0 | x & 0xF00FF00F;
157 		// x = (x & 0x0C0C0C0C) << 2) | (x >> 2) & 0x0C0C0C0C | x & 0xC3C3C3C3;
158 		// x = (x & 0x22222222) << 1) | (x >> 1) & 0x22222222 | x & 0x99999999;
159 		//
160 		// Costs about 17 cycles on a RISC machine with infinite
161 		// instruction level parallelism (~42 basic
162 		// instructions). Thus I truly doubt this pays off...
163 		return reinterpret_cast< ::std::size_t >(rKey.mxRef.get()) ^ (rKey.mnParagraphIndex << 16L);
164 	    }
165 	};
166 
167         // A hash map which maps a XShape to the corresponding vector of initial properties
168         typedef ::std::hash_map< ShapeHashKey, VectorOfNamedValues, ShapeKeyHasher > XShapeHash;
169 
170         class NodeFunctor
171         {
172         public:
NodeFunctor(XShapeHash & rShapeHash)173             explicit NodeFunctor( XShapeHash& rShapeHash ) :
174                 mrShapeHash( rShapeHash ),
175                 mxTargetShape(),
176                 mnParagraphIndex( -1 )
177             {
178             }
179 
NodeFunctor(XShapeHash & rShapeHash,const uno::Reference<drawing::XShape> & rTargetShape,sal_Int16 nParagraphIndex)180             NodeFunctor( XShapeHash& 								rShapeHash,
181                          const uno::Reference< drawing::XShape >& 	rTargetShape,
182                          sal_Int16									nParagraphIndex ) :
183                 mrShapeHash( rShapeHash ),
184                 mxTargetShape( rTargetShape ),
185                 mnParagraphIndex( nParagraphIndex )
186             {
187             }
188 
operator ()(const uno::Reference<animations::XAnimationNode> & xNode) const189             void operator()( const uno::Reference< animations::XAnimationNode >& xNode ) const
190             {
191                 if( !xNode.is() )
192                 {
193                     OSL_ENSURE( false,
194                                 "AnimCore: NodeFunctor::operator(): invalid XAnimationNode" );
195                     return;
196                 }
197 
198                 uno::Reference< drawing::XShape > xTargetShape( mxTargetShape );
199                 sal_Int16						  nParagraphIndex( mnParagraphIndex );
200 
201                 switch( xNode->getType() )
202                 {
203                     case animations::AnimationNodeType::ITERATE:
204                     {
205                         // extract target shape from iterate node
206                         // (will override the target for all children)
207                         // --------------------------------------------------
208 
209                         uno::Reference< animations::XIterateContainer > xIterNode( xNode,
210                                                                                    uno::UNO_QUERY );
211 
212 	                    // TODO(E1): I'm not too sure what to expect here...
213                         if( !xIterNode->getTarget().hasValue() )
214                         {
215                             OSL_ENSURE( false,
216                                         "animcore: NodeFunctor::operator(): no target on ITERATE node" );
217                             return;
218                         }
219 
220                         xTargetShape.set( xIterNode->getTarget(),
221                                           uno::UNO_QUERY );
222 
223                         if( !xTargetShape.is() )
224                         {
225                             ::com::sun::star::presentation::ParagraphTarget aTarget;
226 
227                             // no shape provided. Maybe a ParagraphTarget?
228                             if( !(xIterNode->getTarget() >>= aTarget) )
229                             {
230                                 OSL_ENSURE( false,
231                                             "animcore: NodeFunctor::operator(): could not extract any "
232                                             "target information" );
233                                 return;
234                             }
235 
236                             xTargetShape = aTarget.Shape;
237                             nParagraphIndex = aTarget.Paragraph;
238 
239                             if( !xTargetShape.is() )
240                             {
241                                 OSL_ENSURE( false,
242                                             "animcore: NodeFunctor::operator(): invalid shape in ParagraphTarget" );
243                                 return;
244                             }
245                         }
246                     }
247 	                    // FALLTHROUGH intended
248                     case animations::AnimationNodeType::PAR:
249                         // FALLTHROUGH intended
250                     case animations::AnimationNodeType::SEQ:
251                     {
252                         NodeFunctor aFunctor( mrShapeHash,
253                                               xTargetShape,
254                                               nParagraphIndex );
255                         if( !::anim::for_each_childNode( xNode,
256                                                          aFunctor ) )
257                         {
258                             OSL_ENSURE( false,
259                                         "AnimCore: NodeFunctor::operator(): child node iteration failed, "
260                                         "or extraneous container nodes encountered" );
261                         }
262                     }
263                     break;
264 
265                     case animations::AnimationNodeType::CUSTOM:
266                         // FALLTHROUGH intended
267                     case animations::AnimationNodeType::ANIMATE:
268                         // FALLTHROUGH intended
269                     case animations::AnimationNodeType::ANIMATEMOTION:
270                         // FALLTHROUGH intended
271                     case animations::AnimationNodeType::ANIMATECOLOR:
272                         // FALLTHROUGH intended
273                     case animations::AnimationNodeType::ANIMATETRANSFORM:
274                         // FALLTHROUGH intended
275                     case animations::AnimationNodeType::TRANSITIONFILTER:
276                         // FALLTHROUGH intended
277                     case animations::AnimationNodeType::AUDIO:
278                         // FALLTHROUGH intended
279                     /*default:
280                         // ignore this node, no valuable content for now.
281                         break;*/
282 
283                     case animations::AnimationNodeType::SET:
284                     {
285                         // evaluate set node content
286                         uno::Reference< animations::XAnimate > xAnimateNode( xNode,
287                                                                              uno::UNO_QUERY );
288 
289                         if( !xAnimateNode.is() )
290                             break; // invalid node
291 
292                         // determine target shape (if any)
293                         ShapeHashKey aTarget;
294                         if( xTargetShape.is() )
295                         {
296                             // override target shape with parent-supplied
297                             aTarget.mxRef = xTargetShape;
298                             aTarget.mnParagraphIndex = nParagraphIndex;
299                         }
300                         else
301                         {
302                             // no parent-supplied target, retrieve
303                             // node target
304                             if( (xAnimateNode->getTarget() >>= aTarget.mxRef) )
305                             {
306                                 // pure shape target - set paragraph
307                                 // index to magic
308                                 aTarget.mnParagraphIndex = -1;
309                             }
310                             else
311                             {
312                                 // not a pure shape target - maybe a
313                                 // ParagraphTarget?
314                                 presentation::ParagraphTarget aUnoTarget;
315 
316                                 if( !(xAnimateNode->getTarget() >>= aUnoTarget) )
317                                 {
318                                     OSL_ENSURE( false,
319                                                 "AnimCore: NodeFunctor::operator(): unknown target type encountered" );
320                                     break;
321                                 }
322 
323                                 aTarget.mxRef = aUnoTarget.Shape;
324                                 aTarget.mnParagraphIndex = aUnoTarget.Paragraph;
325                             }
326                         }
327 
328                         if( !aTarget.mxRef.is() )
329                         {
330                             OSL_ENSURE( false,
331                                         "AnimCore: NodeFunctor::operator(): Found target, but XShape is NULL" );
332                             break; // invalid target XShape
333                         }
334 
335                         // check whether we already have an entry for
336                         // this target (we only take the first set
337                         // effect for every shape)
338                         XShapeHash::const_iterator aIter;
339                         if( (aIter=mrShapeHash.find( aTarget )) != mrShapeHash.end() )
340                             break; // already an entry in existence for given XShape
341 
342                         // if this is an appear effect, hide shape
343                         // initially. This is currently the only place
344                         // where a shape effect influences shape
345                         // attributes outside it's effective duration.
346 			sal_Bool bVisible( sal_False );
347                         if( xAnimateNode->getAttributeName().equalsIgnoreAsciiCaseAscii("visibility") )
348                         {
349 
350                             uno::Any aAny( xAnimateNode->getTo() );
351 
352                             // try to extract bool value
353                             if( !(aAny >>= bVisible) )
354                             {
355                                 // try to extract string
356                                 ::rtl::OUString aString;
357                                 if( (aAny >>= aString) )
358                                 {
359                                     // we also take the strings "true" and "false",
360                                     // as well as "on" and "off" here
361                                     if( aString.equalsIgnoreAsciiCaseAscii("true") ||
362                                         aString.equalsIgnoreAsciiCaseAscii("on") )
363                                     {
364                                         bVisible = sal_True;
365                                     }
366                                     if( aString.equalsIgnoreAsciiCaseAscii("false") ||
367                                         aString.equalsIgnoreAsciiCaseAscii("off") )
368                                     {
369                                         bVisible = sal_False;
370                                     }
371                                 }
372                             }
373 
374                             /*if( bVisible )
375                             {
376                                 // target is set to 'visible' at the
377                                 // first relevant effect. Thus, target
378                                 // must be initially _hidden_, for the
379                                 // effect to have visible impact.
380                                 */
381 				}
382 						    // target is set the 'visible' value,
383 							// so we should record the opposite value
384 				mrShapeHash.insert(
385                                     XShapeHash::value_type(
386                                         aTarget,
387                                         VectorOfNamedValues(
388                                             1,
389                                             beans::NamedValue(
390                                                 //xAnimateNode->getAttributeName(),
391 						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("visibility")),
392                                                 uno::makeAny( !bVisible ) ) ) ) );
393                             //}
394                         //}
395                     }
396                     break;
397                 }
398             }
399 
400         private:
401             XShapeHash& 						mrShapeHash;
402             uno::Reference< drawing::XShape > 	mxTargetShape;
403             sal_Int16							mnParagraphIndex;
404         };
405     }
406 
407 	// --------------------------------------------------------------------
408 
TargetPropertiesCreator(const uno::Reference<uno::XComponentContext> &)409     TargetPropertiesCreator::TargetPropertiesCreator( const uno::Reference< uno::XComponentContext >&  ) :
410         TargetPropertiesCreator_Base( m_aMutex )
411     {
412     }
413 
~TargetPropertiesCreator()414     TargetPropertiesCreator::~TargetPropertiesCreator()
415     {
416     }
417 
disposing()418 	void SAL_CALL TargetPropertiesCreator::disposing()
419 	{
420         ::osl::MutexGuard aGuard( m_aMutex );
421 	}
422 
423     // XTargetPropertiesCreator
createInitialTargetProperties(const uno::Reference<animations::XAnimationNode> & xRootNode)424     uno::Sequence< animations::TargetProperties > SAL_CALL TargetPropertiesCreator::createInitialTargetProperties
425     	(
426             const uno::Reference< animations::XAnimationNode >& xRootNode
427         ) throw (uno::RuntimeException)
428     {
429         ::osl::MutexGuard aGuard( m_aMutex );
430 
431         // scan all nodes for visibility changes, and record first
432         // 'visibility=true' for each shape
433         XShapeHash aShapeHash( 101 );
434 
435         NodeFunctor aFunctor( aShapeHash );
436 
437         // TODO(F1): Maybe limit functor application to main sequence
438         // alone (CL said something that shape visibility is only
439         // affected by effects in the main sequence for PPT).
440         //
441         // OTOH, client code can pass us only the main sequence (which
442         // it actually does right now, for the slideshow implementation).
443         aFunctor( xRootNode );
444 
445 
446         // output to result sequence
447         // ----------------------------------------------------------------------
448 
449         uno::Sequence< animations::TargetProperties > aRes( aShapeHash.size() );
450 
451         ::std::size_t						nCurrIndex(0);
452         XShapeHash::const_iterator 			aCurr( aShapeHash.begin() );
453         const XShapeHash::const_iterator	aEnd ( aShapeHash.end()   );
454         while( aCurr != aEnd )
455         {
456             animations::TargetProperties& rCurrProps( aRes[ nCurrIndex++ ] );
457 
458             if( aCurr->first.mnParagraphIndex == -1 )
459             {
460                 rCurrProps.Target = uno::makeAny( aCurr->first.mxRef );
461             }
462             else
463             {
464                 rCurrProps.Target = uno::makeAny(
465                     presentation::ParagraphTarget(
466                         aCurr->first.mxRef,
467                         aCurr->first.mnParagraphIndex ) );
468             }
469 
470             rCurrProps.Properties = ::comphelper::containerToSequence( aCurr->second );
471 
472             ++aCurr;
473         }
474 
475         return aRes;
476     }
477 
478     // XServiceInfo
getImplementationName()479     ::rtl::OUString SAL_CALL TargetPropertiesCreator::getImplementationName() throw( uno::RuntimeException )
480     {
481         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) );
482     }
483 
supportsService(const::rtl::OUString & ServiceName)484     sal_Bool SAL_CALL TargetPropertiesCreator::supportsService( const ::rtl::OUString& ServiceName ) throw( uno::RuntimeException )
485     {
486         return ServiceName.equalsIgnoreAsciiCaseAscii( SERVICE_NAME );
487     }
488 
getSupportedServiceNames()489     uno::Sequence< ::rtl::OUString > SAL_CALL TargetPropertiesCreator::getSupportedServiceNames()  throw( uno::RuntimeException )
490     {
491         uno::Sequence< ::rtl::OUString > aRet(1);
492         aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) );
493 
494         return aRet;
495     }
496 
497     // XServiceName
getServiceName()498     ::rtl::OUString SAL_CALL TargetPropertiesCreator::getServiceName(  ) throw (uno::RuntimeException)
499     {
500         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
501     }
502 
503 } // namespace animcore
504