oox/source/ppt/slidetransition.cxx

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