| /************************************************************** |
| * |
| * 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 "oox/ppt/slidetransition.hxx" |
| |
| #include <com/sun/star/uno/Any.hxx> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/presentation/AnimationSpeed.hpp> |
| #include <com/sun/star/animations/TransitionType.hpp> |
| #include <com/sun/star/animations/TransitionSubType.hpp> |
| |
| #include "oox/helper/helper.hxx" |
| #include "oox/helper/propertymap.hxx" |
| #include "oox/token/namespaces.hxx" |
| #include "oox/token/tokens.hxx" |
| #include "pptfilterhelpers.hxx" |
| |
| using rtl::OUString; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::animations; |
| using namespace ::com::sun::star::presentation; |
| |
| namespace oox { namespace ppt { |
| |
| |
| SlideTransition::SlideTransition() |
| : mnTransitionType( 0 ) |
| , mnTransitionSubType( 0 ) |
| , mbTransitionDirectionNormal( true ) |
| , mnAnimationSpeed( AnimationSpeed_FAST ) |
| , mnFadeColor( 0 ) |
| , mbMode( true ) |
| { |
| |
| } |
| |
| |
| SlideTransition::SlideTransition(const OUString & sFilterName) |
| : mnTransitionType( 0 ) |
| , mnTransitionSubType( 0 ) |
| , mbTransitionDirectionNormal( true ) |
| , mnAnimationSpeed( AnimationSpeed_FAST ) |
| , mnFadeColor( 0 ) |
| , mbMode( true ) |
| { |
| const transition *p = transition::find( sFilterName ); |
| if( p ) |
| { |
| mnTransitionType = p->mnType; |
| mnTransitionSubType = p->mnSubType; |
| mbTransitionDirectionNormal = p->mbDirection; |
| } |
| } |
| |
| |
| void SlideTransition::setSlideProperties( PropertyMap & aProps ) |
| { |
| try |
| { |
| aProps[ PROP_TransitionType ] <<= mnTransitionType; |
| aProps[ PROP_TransitionSubtype ] <<= mnTransitionSubType; |
| aProps[ PROP_TransitionDirection ] <<= mbTransitionDirectionNormal; |
| aProps[ PROP_Speed ] <<= mnAnimationSpeed; |
| aProps[ PROP_TransitionFadeColor ] <<= mnFadeColor; |
| } |
| catch( Exception& ) |
| { |
| // should not happen |
| OSL_ENSURE( false, "exception raised" ); |
| } |
| } |
| |
| void SlideTransition::setTransitionFilterProperties( const Reference< XTransitionFilter > & xFilter ) |
| { |
| try |
| { |
| xFilter->setTransition( mnTransitionType ); |
| xFilter->setSubtype( mnTransitionSubType ); |
| xFilter->setDirection( mbTransitionDirectionNormal ); |
| xFilter->setFadeColor( mnFadeColor ); |
| xFilter->setMode( mbMode ); |
| } |
| catch( Exception& ) |
| { |
| // should not happen |
| OSL_ENSURE( false, "exception raised" ); |
| } |
| } |
| |
| |
| void SlideTransition::setOoxTransitionSpeed( sal_Int32 nToken) |
| { |
| switch( nToken ) |
| { |
| /* In case you want to use time values in second, |
| * the speed values are located in the PPT97 importer |
| * sd/source/filter/ppt/ppt97animations.cxx:664 |
| * (void Ppt97Animation::UpdateCacheData() const) |
| */ |
| case XML_fast: |
| mnAnimationSpeed = AnimationSpeed_FAST; |
| break; |
| case XML_med: |
| mnAnimationSpeed = AnimationSpeed_MEDIUM; |
| break; |
| case XML_slow: |
| mnAnimationSpeed = AnimationSpeed_SLOW; |
| break; |
| default: |
| // should not happen. just ignore |
| break; |
| } |
| } |
| |
| |
| |
| sal_Int16 SlideTransition::ooxToOdpEightDirections( ::sal_Int32 nOoxType ) |
| { |
| sal_Int16 nOdpDirection; |
| nOdpDirection = ooxToOdpBorderDirections( nOoxType ); |
| if( nOdpDirection == 0 ) |
| { |
| nOdpDirection = ooxToOdpCornerDirections( nOoxType ); |
| } |
| return nOdpDirection; |
| } |
| |
| |
| sal_Int16 SlideTransition::ooxToOdpBorderDirections( ::sal_Int32 nOoxType ) |
| { |
| sal_Int16 nOdpDirection; |
| switch( nOoxType ) |
| { |
| case XML_d: |
| nOdpDirection = TransitionSubType::FROMTOP; |
| break; |
| case XML_l: |
| nOdpDirection = TransitionSubType::FROMLEFT; |
| break; |
| case XML_r: |
| nOdpDirection = TransitionSubType::FROMRIGHT; |
| break; |
| case XML_u: |
| nOdpDirection = TransitionSubType::FROMBOTTOM; |
| break; |
| default: |
| nOdpDirection= 0; |
| break; |
| } |
| return nOdpDirection; |
| } |
| |
| sal_Int16 SlideTransition::ooxToOdpSideDirections( ::sal_Int32 nOoxType ) |
| { |
| sal_Int16 nOdpDirection; |
| switch( nOoxType ) |
| { |
| case XML_d: |
| case XML_u: |
| nOdpDirection = TransitionSubType::TOPTOBOTTOM; |
| break; |
| case XML_l: |
| case XML_r: |
| nOdpDirection = TransitionSubType::LEFTTORIGHT; |
| break; |
| default: |
| nOdpDirection= 0; |
| break; |
| } |
| return nOdpDirection; |
| } |
| |
| sal_Bool SlideTransition::ooxToOdpSideDirectionsDirectionNormal( ::sal_Int32 nOoxType ) |
| { |
| sal_Bool nOdpDirection = true; |
| switch( nOoxType ) |
| { |
| case XML_u: |
| case XML_l: |
| nOdpDirection = false; |
| break; |
| } |
| return nOdpDirection; |
| } |
| |
| sal_Int16 SlideTransition::ooxToOdpCornerDirections( ::sal_Int32 nOoxType ) |
| { |
| sal_Int16 nOdpDirection; |
| switch( nOoxType ) |
| { |
| case XML_lu: |
| nOdpDirection = TransitionSubType::FROMBOTTOMRIGHT; |
| break; |
| case XML_ru: |
| nOdpDirection = TransitionSubType::FROMBOTTOMLEFT; |
| break; |
| case XML_ld: |
| nOdpDirection = TransitionSubType::FROMTOPRIGHT; |
| break; |
| case XML_rd: |
| nOdpDirection = TransitionSubType::FROMTOPLEFT; |
| break; |
| default: |
| nOdpDirection = 0; |
| break; |
| } |
| return nOdpDirection; |
| } |
| |
| |
| sal_Int16 SlideTransition::ooxToOdpDirection( ::sal_Int32 nOoxType ) |
| { |
| sal_Int16 nOdpDir; |
| switch( nOoxType ) |
| { |
| case XML_vert: |
| nOdpDir = TransitionSubType::VERTICAL; |
| break; |
| case XML_horz: |
| nOdpDir = TransitionSubType::HORIZONTAL; |
| break; |
| default: |
| nOdpDir = 0; |
| break; |
| } |
| return nOdpDir; |
| } |
| |
| void SlideTransition::setOoxTransitionType( ::sal_Int32 OoxType, ::sal_Int32 param1, ::sal_Int32 param2 ) |
| { |
| switch( OoxType ) |
| { |
| case PPT_TOKEN( blinds ): |
| mnTransitionType = TransitionType::BLINDSWIPE; |
| mnTransitionSubType = ooxToOdpDirection( param1 ); |
| break; |
| case PPT_TOKEN( checker ): |
| mnTransitionType = TransitionType::CHECKERBOARDWIPE; |
| switch ( param1 ) |
| { |
| case XML_vert: |
| mnTransitionSubType = TransitionSubType::DOWN; |
| break; |
| case XML_horz: |
| mnTransitionSubType = TransitionSubType::ACROSS; |
| break; |
| default: |
| break; |
| } |
| break; |
| case PPT_TOKEN( comb ): |
| mnTransitionType = TransitionType::PUSHWIPE; |
| switch( param1 ) |
| { |
| case XML_vert: |
| mnTransitionSubType = TransitionSubType::COMBVERTICAL; |
| break; |
| case XML_horz: |
| mnTransitionSubType = TransitionSubType::COMBHORIZONTAL; |
| break; |
| default: |
| break; |
| } |
| break; |
| case PPT_TOKEN( cover ): |
| mnTransitionType = TransitionType::SLIDEWIPE; |
| mnTransitionSubType = ooxToOdpEightDirections( param1 ); |
| break; |
| case PPT_TOKEN( pull ): // uncover |
| mnTransitionType = TransitionType::SLIDEWIPE; |
| mnTransitionSubType = ooxToOdpEightDirections( param1 ); |
| mbTransitionDirectionNormal = false; |
| break; |
| case PPT_TOKEN( cut ): |
| // The binfilter seems to ignore this transition. |
| // Fade to black instead if thrBlk is true. |
| if( param1 ) |
| { |
| mnTransitionType = TransitionType::FADE; |
| mnTransitionSubType = TransitionSubType::FADEOVERCOLOR; |
| } |
| OSL_TRACE( "OOX: cut transition fallback." ); |
| break; |
| case PPT_TOKEN( fade ): |
| mnTransitionType = TransitionType::FADE; |
| if( param1 ) |
| { |
| mnTransitionSubType = TransitionSubType::FADEOVERCOLOR; |
| } |
| else |
| { |
| mnTransitionSubType = TransitionSubType::CROSSFADE; |
| } |
| break; |
| case PPT_TOKEN( push ): |
| mnTransitionType = TransitionType::PUSHWIPE; |
| mnTransitionSubType = ooxToOdpBorderDirections( param1 ); |
| break; |
| case PPT_TOKEN( wipe ): |
| mnTransitionType = TransitionType::BARWIPE; |
| mnTransitionSubType = ooxToOdpSideDirections( param1 ); |
| mbTransitionDirectionNormal = ooxToOdpSideDirectionsDirectionNormal( param1 ); |
| break; |
| case PPT_TOKEN( split ): |
| mnTransitionType = TransitionType::BARNDOORWIPE; |
| mnTransitionSubType = ooxToOdpDirection( param1 ); |
| if( param2 == XML_in ) |
| { |
| // reverse |
| mbTransitionDirectionNormal = false; |
| } |
| break; |
| case PPT_TOKEN( wheel ): |
| mnTransitionType = TransitionType::PINWHEELWIPE; |
| switch( param1 ) |
| { |
| case 1: |
| mnTransitionSubType = TransitionSubType::ONEBLADE; |
| break; |
| case 2: |
| mnTransitionSubType = TransitionSubType::TWOBLADEVERTICAL; |
| break; |
| case 3: |
| mnTransitionSubType = TransitionSubType::THREEBLADE; |
| break; |
| case 4: |
| mnTransitionSubType = TransitionSubType::FOURBLADE; |
| break; |
| case 8: |
| mnTransitionSubType = TransitionSubType::EIGHTBLADE; |
| break; |
| default: |
| OSL_TRACE( "OOX: strange number of blades for thw wheel-wipe %d", param1 ); |
| if( param1 > 8 ) |
| { |
| mnTransitionSubType = TransitionSubType::EIGHTBLADE; |
| } |
| else if( param1 > 4 ) |
| { |
| mnTransitionSubType = TransitionSubType::FOURBLADE; |
| } |
| else if( param1 == 0) |
| { |
| mnTransitionSubType = TransitionSubType::ONEBLADE; |
| } |
| break; |
| } |
| break; |
| case PPT_TOKEN( randomBar ): |
| mnTransitionType = TransitionType::RANDOMBARWIPE; |
| mnTransitionSubType = ooxToOdpDirection( param1 ); |
| break; |
| case PPT_TOKEN( circle ): |
| mnTransitionType = TransitionType::ELLIPSEWIPE; |
| mnTransitionSubType = TransitionSubType::CIRCLE; |
| break; |
| case PPT_TOKEN( diamond ): |
| mnTransitionType = TransitionType::IRISWIPE; |
| mnTransitionSubType = TransitionSubType::DIAMOND; |
| break; |
| case PPT_TOKEN( dissolve ): |
| mnTransitionType = TransitionType::DISSOLVE; |
| mnTransitionSubType = TransitionSubType::DEFAULT; |
| break; |
| case PPT_TOKEN( newsflash ): |
| // this is what the PPT binary filter does.... not sure I agree. |
| mnTransitionType = TransitionType::FOURBOXWIPE; |
| mnTransitionSubType = TransitionSubType::CORNERSOUT; |
| break; |
| case PPT_TOKEN( plus ): |
| mnTransitionType = TransitionType::FOURBOXWIPE; |
| mnTransitionSubType = TransitionSubType::CORNERSOUT; |
| break; |
| case PPT_TOKEN( random ): |
| mnTransitionType = TransitionType::RANDOM; |
| mnTransitionSubType = TransitionSubType::DEFAULT; |
| break; |
| case PPT_TOKEN( wedge ): |
| mnTransitionType = TransitionType::FANWIPE; |
| mnTransitionSubType = TransitionSubType::CENTERTOP; |
| break; |
| case PPT_TOKEN( zoom ): |
| mnTransitionType = TransitionType::ZOOM; |
| mnTransitionSubType = TransitionSubType::DEFAULT; |
| break; |
| default: |
| mnTransitionType = 0; |
| break; |
| } |
| } |
| |
| |
| } } |
