1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  *   Licensed to the Apache Software Foundation (ASF) under one or more
12  *   contributor license agreements. See the NOTICE file distributed
13  *   with this work for additional information regarding copyright
14  *   ownership. The ASF licenses this file to you under the Apache
15  *   License, Version 2.0 (the "License"); you may not use this file
16  *   except in compliance with the License. You may obtain a copy of
17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <oox/ppt/slidetransition.hxx>
21 
22 #include <com/sun/star/beans/XPropertySet.hpp>
23 #include <com/sun/star/animations/TransitionType.hpp>
24 #include <com/sun/star/animations/TransitionSubType.hpp>
25 #include <com/sun/star/animations/XTransitionFilter.hpp>
26 
27 #include <osl/diagnose.h>
28 #include <sal/log.hxx>
29 
30 #include <oox/helper/helper.hxx>
31 #include <oox/helper/propertymap.hxx>
32 #include <oox/token/namespaces.hxx>
33 #include <oox/token/properties.hxx>
34 #include <oox/token/tokens.hxx>
35 #include <oox/ppt/pptfilterhelpers.hxx>
36 
37 using namespace ::com::sun::star::uno;
38 using namespace ::com::sun::star::beans;
39 using namespace ::com::sun::star::animations;
40 using namespace ::com::sun::star::presentation;
41 
42 namespace oox { namespace ppt {
43 
SlideTransition()44     SlideTransition::SlideTransition()
45         : mnTransitionType( 0 )
46         , mnTransitionSubType( 0 )
47         , mbTransitionDirectionNormal( true )
48         , mnAnimationSpeed( AnimationSpeed_FAST )
49         , mfTransitionDurationInSeconds( -1.0 )
50         , mbMode( true )
51         , mnAdvanceTime( -1 )
52     {
53 
54     }
55 
SlideTransition(const OUString & sFilterName)56     SlideTransition::SlideTransition(const OUString & sFilterName)
57         : mnTransitionType( 0 )
58         , mnTransitionSubType( 0 )
59         , mbTransitionDirectionNormal( true )
60         , mnAnimationSpeed( AnimationSpeed_FAST )
61         , mfTransitionDurationInSeconds( -1.0 )
62         , mbMode( true )
63         , mnAdvanceTime( -1 )
64     {
65         const transition *p = transition::find( sFilterName );
66         if( p )
67         {
68             mnTransitionType = p->mnType;
69             mnTransitionSubType = p->mnSubType;
70             mbTransitionDirectionNormal = p->mbDirection;
71         }
72     }
73 
setSlideProperties(PropertyMap & aProps)74     void SlideTransition::setSlideProperties( PropertyMap & aProps )
75     {
76         try
77         {
78             aProps.setProperty( PROP_TransitionType, mnTransitionType);
79             aProps.setProperty( PROP_TransitionSubtype, mnTransitionSubType);
80             aProps.setProperty( PROP_TransitionDirection, mbTransitionDirectionNormal);
81             aProps.setProperty( PROP_Speed, mnAnimationSpeed);
82             if( mfTransitionDurationInSeconds >= 0.0 )
83                 aProps.setProperty( PROP_TransitionDuration, mfTransitionDurationInSeconds);
84             aProps.setProperty( PROP_TransitionFadeColor, sal_Int32(0));
85             if( mnAdvanceTime != -1 ) {
86                 aProps.setProperty( PROP_Duration, mnAdvanceTime/1000);
87                 aProps.setProperty( PROP_Change, static_cast<sal_Int32>(1));
88             }
89         }
90         catch( Exception& )
91         {
92             // should not happen
93             OSL_FAIL( "exception raised" );
94         }
95     }
96 
setTransitionFilterProperties(const Reference<XTransitionFilter> & xFilter)97     void SlideTransition::setTransitionFilterProperties( const Reference< XTransitionFilter > & xFilter )
98     {
99         try
100         {
101             xFilter->setTransition( mnTransitionType );
102             xFilter->setSubtype( mnTransitionSubType );
103             xFilter->setDirection( mbTransitionDirectionNormal );
104             xFilter->setFadeColor( 0 );
105             xFilter->setMode( mbMode );
106         }
107         catch( Exception& )
108         {
109             // should not happen
110             OSL_FAIL( "exception raised" );
111         }
112     }
113 
setOoxTransitionSpeed(sal_Int32 nToken)114     void SlideTransition::setOoxTransitionSpeed( sal_Int32 nToken)
115     {
116         switch( nToken  )
117         {
118             /* the speed values are located in the PPT97 importer
119              * sd/source/filter/ppt/pptin.cxx:1783
120              * (void ImplSdPPTImport::ImportPageEffect)
121              */
122         case XML_fast:
123             mnAnimationSpeed = AnimationSpeed_FAST;
124             mfTransitionDurationInSeconds = 0.5;
125             break;
126         case XML_med:
127             mnAnimationSpeed = AnimationSpeed_MEDIUM;
128             mfTransitionDurationInSeconds = 0.75;
129             break;
130         case XML_slow:
131             mnAnimationSpeed = AnimationSpeed_SLOW;
132             mfTransitionDurationInSeconds = 1.0;
133             break;
134         default:
135             // should not happen. just ignore
136             break;
137         }
138     }
139 
setOoxTransitionSpeed(double fDurationInSeconds)140     void SlideTransition::setOoxTransitionSpeed( double fDurationInSeconds )
141     {
142         // for compatibility
143         mnAnimationSpeed = ( fDurationInSeconds <= 0.5 ) ? AnimationSpeed_FAST
144                                 : ( fDurationInSeconds >= 1.0 ) ? AnimationSpeed_SLOW : AnimationSpeed_MEDIUM;
145         mfTransitionDurationInSeconds = fDurationInSeconds;
146     }
147 
ooxToOdpEightDirections(::sal_Int32 nOoxType)148     sal_Int16 SlideTransition::ooxToOdpEightDirections( ::sal_Int32 nOoxType )
149     {
150         sal_Int16 nOdpDirection;
151         nOdpDirection = ooxToOdpBorderDirections( nOoxType );
152         if( nOdpDirection == 0 )
153         {
154             nOdpDirection = ooxToOdpCornerDirections( nOoxType );
155         }
156         return nOdpDirection;
157     }
158 
ooxToOdpBorderDirections(::sal_Int32 nOoxType)159     sal_Int16 SlideTransition::ooxToOdpBorderDirections( ::sal_Int32 nOoxType )
160     {
161         sal_Int16 nOdpDirection;
162         switch( nOoxType )
163         {
164         case XML_d:
165             nOdpDirection = TransitionSubType::FROMTOP;
166             break;
167         case XML_l:
168             nOdpDirection = TransitionSubType::FROMLEFT;
169             break;
170         case XML_r:
171             nOdpDirection = TransitionSubType::FROMRIGHT;
172             break;
173         case XML_u:
174             nOdpDirection = TransitionSubType::FROMBOTTOM;
175             break;
176         default:
177             nOdpDirection= 0;
178             break;
179         }
180         return nOdpDirection;
181     }
182 
ooxToOdpSideDirections(::sal_Int32 nOoxType)183     sal_Int16 SlideTransition::ooxToOdpSideDirections( ::sal_Int32 nOoxType )
184     {
185         sal_Int16 nOdpDirection;
186         switch( nOoxType )
187         {
188         case XML_d:
189         case XML_u:
190             nOdpDirection = TransitionSubType::TOPTOBOTTOM;
191             break;
192         case XML_l:
193         case XML_r:
194             nOdpDirection = TransitionSubType::LEFTTORIGHT;
195             break;
196         default:
197             nOdpDirection= 0;
198             break;
199         }
200         return nOdpDirection;
201     }
202 
ooxToOdpSideDirectionsDirectionNormal(::sal_Int32 nOoxType)203     bool SlideTransition::ooxToOdpSideDirectionsDirectionNormal( ::sal_Int32 nOoxType )
204     {
205         bool bOdpDirection = true;
206         switch( nOoxType )
207         {
208         case XML_u:
209         case XML_l:
210             bOdpDirection = false;
211             break;
212         }
213         return bOdpDirection;
214     }
215 
ooxToOdpCornerDirections(::sal_Int32 nOoxType)216     sal_Int16 SlideTransition::ooxToOdpCornerDirections( ::sal_Int32 nOoxType )
217     {
218         sal_Int16 nOdpDirection;
219         switch( nOoxType )
220         {
221         case XML_lu:
222             nOdpDirection = TransitionSubType::FROMBOTTOMRIGHT;
223             break;
224         case XML_ru:
225             nOdpDirection = TransitionSubType::FROMBOTTOMLEFT;
226             break;
227         case XML_ld:
228             nOdpDirection = TransitionSubType::FROMTOPRIGHT;
229             break;
230         case XML_rd:
231             nOdpDirection = TransitionSubType::FROMTOPLEFT;
232             break;
233         default:
234             nOdpDirection = 0;
235             break;
236         }
237         return nOdpDirection;
238     }
239 
ooxToOdpDirection(::sal_Int32 nOoxType)240     sal_Int16 SlideTransition::ooxToOdpDirection( ::sal_Int32 nOoxType )
241     {
242         sal_Int16 nOdpDir;
243         switch( nOoxType )
244         {
245         case XML_vert:
246             nOdpDir = TransitionSubType::VERTICAL;
247             break;
248         case XML_horz:
249             nOdpDir = TransitionSubType::HORIZONTAL;
250             break;
251         default:
252             nOdpDir = 0;
253             break;
254         }
255         return nOdpDir;
256     }
257 
setOoxTransitionType(::sal_Int32 OoxType,::sal_Int32 param1,::sal_Int32 param2)258     void SlideTransition::setOoxTransitionType( ::sal_Int32 OoxType, ::sal_Int32 param1, ::sal_Int32 param2 )
259     {
260         switch( OoxType )
261         {
262         case PPT_TOKEN( blinds ):
263             mnTransitionType = TransitionType::BLINDSWIPE;
264             mnTransitionSubType = ooxToOdpDirection( param1 );
265             break;
266         case PPT_TOKEN( checker ):
267             mnTransitionType = TransitionType::CHECKERBOARDWIPE;
268             switch ( param1 )
269             {
270             case XML_vert:
271                 mnTransitionSubType = TransitionSubType::DOWN;
272                 break;
273             case XML_horz:
274                 mnTransitionSubType = TransitionSubType::ACROSS;
275                 break;
276             default:
277                 break;
278             }
279             break;
280         case PPT_TOKEN( comb ):
281             mnTransitionType = TransitionType::PUSHWIPE;
282             switch( param1 )
283             {
284             case XML_vert:
285                 mnTransitionSubType = TransitionSubType::COMBVERTICAL;
286                 break;
287             case XML_horz:
288                 mnTransitionSubType = TransitionSubType::COMBHORIZONTAL;
289                 break;
290             default:
291                 break;
292             }
293             break;
294         case PPT_TOKEN( cover ):
295             mnTransitionType = TransitionType::SLIDEWIPE;
296             mnTransitionSubType = ooxToOdpEightDirections( param1 );
297             break;
298         case PPT_TOKEN( pull ): // uncover
299             mnTransitionType = TransitionType::SLIDEWIPE;
300             mnTransitionSubType = ooxToOdpEightDirections( param1 );
301             mbTransitionDirectionNormal = false;
302             break;
303         case PPT_TOKEN( cut ):
304             if( param1 )
305             {
306                 mnTransitionType = TransitionType::BARWIPE;
307                 mnTransitionSubType = TransitionSubType::FADEOVERCOLOR;
308             }
309             SAL_WARN("oox.ppt", "OOX: cut transition fallback." );
310             break;
311         case PPT_TOKEN( fade ):
312             mnTransitionType = TransitionType::FADE;
313             if( param1 )
314             {
315                 mnTransitionSubType = TransitionSubType::FADEOVERCOLOR;
316             }
317             else
318             {
319                 mnTransitionSubType = TransitionSubType::CROSSFADE;
320             }
321             break;
322         case PPT_TOKEN( push ):
323             mnTransitionType = TransitionType::PUSHWIPE;
324             mnTransitionSubType = ooxToOdpBorderDirections( param1 );
325             break;
326         case PPT_TOKEN( wipe ):
327             mnTransitionType = TransitionType::BARWIPE;
328             mnTransitionSubType = ooxToOdpSideDirections( param1 );
329             mbTransitionDirectionNormal = ooxToOdpSideDirectionsDirectionNormal( param1 );
330             break;
331         case PPT_TOKEN( split ):
332             mnTransitionType = TransitionType::BARNDOORWIPE;
333             mnTransitionSubType = ooxToOdpDirection( param1 );
334             if( param2 == XML_in )
335             {
336                 // reverse
337                 mbTransitionDirectionNormal = false;
338             }
339             break;
340         case PPT_TOKEN( wheel ):
341             mnTransitionType = TransitionType::PINWHEELWIPE;
342             switch( param1 )
343             {
344             case 1:
345                 mnTransitionSubType = TransitionSubType::ONEBLADE;
346                 break;
347             case 2:
348                 mnTransitionSubType = TransitionSubType::TWOBLADEVERTICAL;
349                 break;
350             case 3:
351                 mnTransitionSubType = TransitionSubType::THREEBLADE;
352                 break;
353             case 4:
354                 mnTransitionSubType = TransitionSubType::FOURBLADE;
355                 break;
356             case 8:
357                 mnTransitionSubType = TransitionSubType::EIGHTBLADE;
358                 break;
359             default:
360                 SAL_INFO(
361                     "oox.ppt",
362                     "strange number of blades for the wheel-wipe " << param1);
363                 if( param1 > 8 )
364                 {
365                     mnTransitionSubType = TransitionSubType::EIGHTBLADE;
366                 }
367                 else if( param1 > 4 )
368                 {
369                     mnTransitionSubType = TransitionSubType::FOURBLADE;
370                 }
371                 else if( param1 == 0)
372                 {
373                     mnTransitionSubType = TransitionSubType::ONEBLADE;
374                 }
375                 break;
376             }
377             break;
378         case PPT_TOKEN( randomBar ):
379             mnTransitionType = TransitionType::RANDOMBARWIPE;
380             mnTransitionSubType = ooxToOdpDirection( param1 );
381             break;
382         case PPT_TOKEN( circle ):
383             mnTransitionType = TransitionType::ELLIPSEWIPE;
384             mnTransitionSubType = TransitionSubType::CIRCLE;
385             break;
386         case PPT_TOKEN( diamond ):
387             mnTransitionType = TransitionType::IRISWIPE;
388             mnTransitionSubType = TransitionSubType::DIAMOND;
389             break;
390         case PPT_TOKEN( dissolve ):
391             mnTransitionType = TransitionType::DISSOLVE;
392             mnTransitionSubType = TransitionSubType::DEFAULT;
393             break;
394         case PPT_TOKEN( newsflash ):
395             mnTransitionType = TransitionType::ZOOM;
396             mnTransitionSubType = TransitionSubType::ROTATEIN;
397             break;
398         case PPT_TOKEN( plus ):
399             mnTransitionType = TransitionType::FOURBOXWIPE;
400             mnTransitionSubType = TransitionSubType::CORNERSOUT;
401             break;
402         case PPT_TOKEN( random ):
403             mnTransitionType = TransitionType::RANDOM;
404             mnTransitionSubType = TransitionSubType::DEFAULT;
405             break;
406         case PPT_TOKEN( wedge ):
407             mnTransitionType = TransitionType::FANWIPE;
408             mnTransitionSubType = TransitionSubType::CENTERTOP;
409             break;
410         case PPT_TOKEN( zoom ):
411             mnTransitionType = TransitionType::ZOOM;
412             mnTransitionSubType = TransitionSubType::DEFAULT;
413             break;
414         case P14_TOKEN(prism):
415             mnTransitionType = TransitionType::MISCSHAPEWIPE;
416             if (param1)
417                 mnTransitionSubType = TransitionSubType::CORNERSIN;
418             else
419                 mnTransitionSubType = TransitionSubType::CORNERSOUT;
420             break;
421         case P14_TOKEN(vortex):
422             mnTransitionType = TransitionType::MISCSHAPEWIPE;
423             mnTransitionSubType = TransitionSubType::VERTICAL;
424             break;
425         case P14_TOKEN(ripple):
426             mnTransitionType = TransitionType::MISCSHAPEWIPE;
427             mnTransitionSubType = TransitionSubType::HORIZONTAL;
428             break;
429         case P14_TOKEN(glitter):
430             mnTransitionType = TransitionType::MISCSHAPEWIPE;
431             mnTransitionSubType = TransitionSubType::DIAMOND;
432             break;
433         case P14_TOKEN(honeycomb):
434             mnTransitionType = TransitionType::MISCSHAPEWIPE;
435             mnTransitionSubType = TransitionSubType::HEART;
436             break;
437         default:
438             mnTransitionType = 0;
439             break;
440         }
441     }
442 
setPresetTransition(OUString const & sPresetTransition)443     void SlideTransition::setPresetTransition(OUString const & sPresetTransition)
444     {
445         if (sPresetTransition == "fallOver")
446         {
447             mnTransitionType = TransitionType::MISCSHAPEWIPE;
448             mnTransitionSubType = TransitionSubType::LEFTTORIGHT;
449         }
450         else
451         {
452             mnTransitionType = 0;
453         }
454     }
455 
456 } }
457 
458 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
459