| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmloff.hxx" |
| |
| #include <com/sun/star/animations/XAnimateColor.hpp> |
| #include <com/sun/star/animations/XAnimateSet.hpp> |
| #include <com/sun/star/animations/XCommand.hpp> |
| #include <com/sun/star/animations/Timing.hpp> |
| #include <com/sun/star/animations/Event.hpp> |
| #include <com/sun/star/animations/XAnimateMotion.hpp> |
| #include <com/sun/star/animations/XAnimateTransform.hpp> |
| #include <com/sun/star/animations/XTransitionFilter.hpp> |
| #include <com/sun/star/animations/XIterateContainer.hpp> |
| #include <com/sun/star/animations/XAudio.hpp> |
| #include <com/sun/star/animations/AnimationColorSpace.hpp> |
| #include <com/sun/star/animations/AnimationNodeType.hpp> |
| #include <com/sun/star/animations/AnimationRestart.hpp> |
| #include <com/sun/star/animations/EventTrigger.hpp> |
| #include <com/sun/star/animations/AnimationFill.hpp> |
| #include <com/sun/star/animations/AnimationEndSync.hpp> |
| #include <com/sun/star/animations/AnimationNodeType.hpp> |
| #include <com/sun/star/animations/AnimationCalcMode.hpp> |
| #include <com/sun/star/animations/AnimationAdditiveMode.hpp> |
| #include <com/sun/star/animations/AnimationTransformType.hpp> |
| #include <com/sun/star/animations/TransitionType.hpp> |
| #include <com/sun/star/animations/TransitionSubType.hpp> |
| #include <com/sun/star/animations/ValuePair.hpp> |
| #include <com/sun/star/container/XEnumerationAccess.hpp> |
| #include <com/sun/star/beans/NamedValue.hpp> |
| #include <com/sun/star/presentation/EffectNodeType.hpp> |
| #include <com/sun/star/presentation/EffectPresetClass.hpp> |
| #include <com/sun/star/presentation/ParagraphTarget.hpp> |
| #include <com/sun/star/presentation/TextAnimationType.hpp> |
| #include <com/sun/star/presentation/ShapeAnimationSubType.hpp> |
| #include <com/sun/star/presentation/EffectCommands.hpp> |
| #include <com/sun/star/drawing/XShape.hpp> |
| |
| #include <tools/debug.hxx> |
| #include <tools/time.hxx> |
| #include "unointerfacetouniqueidentifiermapper.hxx" |
| #include "sdxmlexp_impl.hxx" |
| #include "sdpropls.hxx" |
| #include <xmloff/xmltoken.hxx> |
| #include "xmloff/xmlnmspe.hxx" |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/xmlexp.hxx> |
| #include <xmloff/xmlement.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/shapeexport.hxx> |
| |
| #include "animations.hxx" |
| #include "animationexport.hxx" |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| |
| using namespace ::std; |
| using namespace ::cppu; |
| using namespace ::com::sun::star::animations; |
| using namespace ::com::sun::star::presentation; |
| using namespace ::com::sun::star::drawing; |
| using namespace ::com::sun::star::beans; |
| using namespace ::xmloff::token; |
| |
| using ::com::sun::star::uno::Any; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::uno::UNO_QUERY_THROW; |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::Sequence; |
| using ::com::sun::star::uno::Exception; |
| using ::com::sun::star::uno::RuntimeException; |
| using ::com::sun::star::uno::XInterface; |
| using ::com::sun::star::beans::NamedValue; |
| using ::com::sun::star::container::XEnumerationAccess; |
| using ::com::sun::star::container::XEnumeration; |
| |
| namespace xmloff |
| { |
| |
| SvXMLEnumMapEntry* getAnimationsEnumMap( sal_uInt16 nMap ) |
| { |
| switch( nMap ) |
| { |
| case Animations_EnumMap_Fill: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_Fill[] = |
| { |
| { XML_DEFAULT, AnimationFill::DEFAULT }, |
| { XML_REMOVE, AnimationFill::REMOVE }, |
| { XML_FREEZE, AnimationFill::FREEZE }, |
| { XML_HOLD, AnimationFill::HOLD }, |
| { XML_TRANSITION, AnimationFill::TRANSITION }, |
| { XML_AUTO, AnimationFill::AUTO }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_Fill; |
| } |
| case Animations_EnumMap_FillDefault: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_Fill[] = |
| { |
| { XML_INHERIT, AnimationFill::INHERIT }, |
| { XML_REMOVE, AnimationFill::REMOVE }, |
| { XML_FREEZE, AnimationFill::FREEZE }, |
| { XML_HOLD, AnimationFill::HOLD }, |
| { XML_TRANSITION, AnimationFill::TRANSITION }, |
| { XML_AUTO, AnimationFill::AUTO }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_Fill; |
| } |
| case Animations_EnumMap_Restart: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_Restart[] = |
| { |
| { XML_DEFAULT, AnimationRestart::DEFAULT }, |
| { XML_ALWAYS, AnimationRestart::ALWAYS }, |
| { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE }, |
| { XML_NEVER, AnimationRestart::NEVER }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_Restart; |
| } |
| case Animations_EnumMap_RestartDefault: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_RestartDefault[] = |
| { |
| { XML_INHERIT, AnimationRestart::INHERIT }, |
| { XML_ALWAYS, AnimationRestart::ALWAYS }, |
| { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE }, |
| { XML_NEVER, AnimationRestart::NEVER }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_RestartDefault; |
| } |
| case Animations_EnumMap_Endsync: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_Endsync[] = |
| { |
| { XML_FIRST, AnimationEndSync::FIRST }, |
| { XML_LAST, AnimationEndSync::LAST }, |
| { XML_ALL, AnimationEndSync::ALL }, |
| { XML_MEDIA, AnimationEndSync::MEDIA }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_Endsync; |
| } |
| case Animations_EnumMap_CalcMode: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_CalcMode[] = |
| { |
| { XML_DISCRETE, AnimationCalcMode::DISCRETE }, |
| { XML_LINEAR, AnimationCalcMode::LINEAR }, |
| { XML_PACED, AnimationCalcMode::PACED }, |
| { XML_SPLINE, AnimationCalcMode::SPLINE }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_CalcMode; |
| } |
| case Animations_EnumMap_AdditiveMode: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_AdditiveMode[] = |
| { |
| { XML_BASE, AnimationAdditiveMode::BASE }, |
| { XML_SUM, AnimationAdditiveMode::SUM }, |
| { XML_REPLACE, AnimationAdditiveMode::REPLACE }, |
| { XML_MULTIPLY, AnimationAdditiveMode::MULTIPLY }, |
| { XML_NONE, AnimationAdditiveMode::NONE }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_AdditiveMode; |
| } |
| case Animations_EnumMap_TransformType: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_TransformType[] = |
| { |
| { XML_TRANSLATE, AnimationTransformType::TRANSLATE }, |
| { XML_SCALE, AnimationTransformType::SCALE }, |
| { XML_ROTATE, AnimationTransformType::ROTATE }, |
| { XML_SKEWX, AnimationTransformType::SKEWX }, |
| { XML_SKEWY, AnimationTransformType::SKEWY }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_TransformType; |
| } |
| case Animations_EnumMap_TransitionType: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_TransitionType[] = |
| { |
| { XML_BARWIPE, TransitionType::BARWIPE }, |
| { XML_BOXWIPE, TransitionType::BOXWIPE }, |
| { XML_FOURBOXWIPE, TransitionType::FOURBOXWIPE }, |
| { XML_BARNDOORWIPE, TransitionType::BARNDOORWIPE }, |
| { XML_DIAGONALWIPE, TransitionType::DIAGONALWIPE }, |
| { XML_BOWTIEWIPE, TransitionType::BOWTIEWIPE }, |
| { XML_MISCDIAGONALWIPE, TransitionType::MISCDIAGONALWIPE }, |
| { XML_VEEWIPE, TransitionType::VEEWIPE }, |
| { XML_BARNVEEWIPE, TransitionType::BARNVEEWIPE }, |
| { XML_ZIGZAGWIPE, TransitionType::ZIGZAGWIPE }, |
| { XML_BARNZIGZAGWIPE, TransitionType::BARNZIGZAGWIPE }, |
| { XML_IRISWIPE, TransitionType::IRISWIPE }, |
| { XML_TRIANGLEWIPE, TransitionType::TRIANGLEWIPE }, |
| { XML_ARROWHEADWIPE, TransitionType::ARROWHEADWIPE }, |
| { XML_PENTAGONWIPE, TransitionType::PENTAGONWIPE }, |
| { XML_HEXAGONWIPE, TransitionType::HEXAGONWIPE }, |
| { XML_ELLIPSEWIPE, TransitionType::ELLIPSEWIPE }, |
| { XML_EYEWIPE, TransitionType::EYEWIPE }, |
| { XML_ROUNDRECTWIPE, TransitionType::ROUNDRECTWIPE }, |
| { XML_STARWIPE, TransitionType::STARWIPE }, |
| { XML_MISCSHAPEWIPE, TransitionType::MISCSHAPEWIPE }, |
| { XML_CLOCKWIPE, TransitionType::CLOCKWIPE }, |
| { XML_PINWHEELWIPE, TransitionType::PINWHEELWIPE }, |
| { XML_SINGLESWEEPWIPE, TransitionType::SINGLESWEEPWIPE }, |
| { XML_FANWIPE, TransitionType::FANWIPE }, |
| { XML_DOUBLEFANWIPE, TransitionType::DOUBLEFANWIPE }, |
| { XML_DOUBLESWEEPWIPE, TransitionType::DOUBLESWEEPWIPE }, |
| { XML_SALOONDOORWIPE, TransitionType::SALOONDOORWIPE }, |
| { XML_WINDSHIELDWIPE, TransitionType::WINDSHIELDWIPE }, |
| { XML_SNAKEWIPE, TransitionType::SNAKEWIPE }, |
| { XML_SPIRALWIPE, TransitionType::SPIRALWIPE }, |
| { XML_PARALLELSNAKESWIPE,TransitionType::PARALLELSNAKESWIPE }, |
| { XML_BOXSNAKESWIPE, TransitionType::BOXSNAKESWIPE }, |
| { XML_WATERFALLWIPE, TransitionType::WATERFALLWIPE }, |
| { XML_PUSHWIPE, TransitionType::PUSHWIPE }, |
| { XML_SLIDEWIPE, TransitionType::SLIDEWIPE }, |
| { XML_FADE, TransitionType::FADE }, |
| { XML_RANDOMBARWIPE, TransitionType::RANDOMBARWIPE }, |
| { XML_CHECKERBOARDWIPE, TransitionType::CHECKERBOARDWIPE }, |
| { XML_DISSOLVE, TransitionType::DISSOLVE }, |
| { XML_BLINDSWIPE, TransitionType::BLINDSWIPE }, |
| { XML_RANDOM, TransitionType::RANDOM }, |
| { XML_ZOOM, TransitionType::ZOOM }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_TransitionType; |
| } |
| case Animations_EnumMap_TransitionSubType: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_TransitionSubType[] = |
| { |
| { XML_DEFAULT, TransitionSubType::DEFAULT }, |
| { XML_LEFTTORIGHT, TransitionSubType::LEFTTORIGHT }, |
| { XML_TOPTOBOTTOM, TransitionSubType::TOPTOBOTTOM }, |
| { XML_TOPLEFT, TransitionSubType::TOPLEFT }, |
| { XML_TOPRIGHT, TransitionSubType::TOPRIGHT }, |
| { XML_BOTTOMRIGHT, TransitionSubType::BOTTOMRIGHT }, |
| { XML_BOTTOMLEFT, TransitionSubType::BOTTOMLEFT }, |
| { XML_TOPCENTER, TransitionSubType::TOPCENTER }, |
| { XML_RIGHTCENTER, TransitionSubType::RIGHTCENTER }, |
| { XML_BOTTOMCENTER, TransitionSubType::BOTTOMCENTER }, |
| { XML_LEFTCENTER, TransitionSubType::LEFTCENTER }, |
| { XML_CORNERSIN, TransitionSubType::CORNERSIN }, |
| { XML_CORNERSOUT, TransitionSubType::CORNERSOUT }, |
| { XML_VERTICAL, TransitionSubType::VERTICAL }, |
| { XML_HORIZONTAL, TransitionSubType::HORIZONTAL }, |
| { XML_DIAGONALBOTTOMLEFT, TransitionSubType::DIAGONALBOTTOMLEFT }, |
| { XML_DIAGONALTOPLEFT, TransitionSubType::DIAGONALTOPLEFT }, |
| { XML_DOUBLEBARNDOOR, TransitionSubType::DOUBLEBARNDOOR }, |
| { XML_DOUBLEDIAMOND, TransitionSubType::DOUBLEDIAMOND }, |
| { XML_DOWN, TransitionSubType::DOWN }, |
| { XML_LEFT, TransitionSubType::LEFT }, |
| { XML_UP, TransitionSubType::UP }, |
| { XML_RIGHT, TransitionSubType::RIGHT }, |
| { XML_RECTANGLE, TransitionSubType::RECTANGLE }, |
| { XML_DIAMOND, TransitionSubType::DIAMOND }, |
| { XML_CIRCLE, TransitionSubType::CIRCLE }, |
| { XML_FOURPOINT, TransitionSubType::FOURPOINT }, |
| { XML_FIVEPOINT, TransitionSubType::FIVEPOINT }, |
| { XML_SIXPOINT, TransitionSubType::SIXPOINT }, |
| { XML_HEART, TransitionSubType::HEART }, |
| { XML_KEYHOLE, TransitionSubType::KEYHOLE }, |
| { XML_CLOCKWISETWELVE, TransitionSubType::CLOCKWISETWELVE }, |
| { XML_CLOCKWISETHREE, TransitionSubType::CLOCKWISETHREE }, |
| { XML_CLOCKWISESIX, TransitionSubType::CLOCKWISESIX }, |
| { XML_CLOCKWISENINE, TransitionSubType::CLOCKWISENINE }, |
| { XML_TWOBLADEVERTICAL, TransitionSubType::TWOBLADEVERTICAL }, |
| { XML_TWOBLADEHORIZONTAL, TransitionSubType::TWOBLADEHORIZONTAL }, |
| { XML_FOURBLADE, TransitionSubType::FOURBLADE }, |
| { XML_CLOCKWISETOP, TransitionSubType::CLOCKWISETOP }, |
| { XML_CLOCKWISERIGHT, TransitionSubType::CLOCKWISERIGHT }, |
| { XML_CLOCKWISEBOTTOM, TransitionSubType::CLOCKWISEBOTTOM }, |
| { XML_CLOCKWISELEFT, TransitionSubType::CLOCKWISELEFT }, |
| { XML_CLOCKWISETOPLEFT, TransitionSubType::CLOCKWISETOPLEFT }, |
| { XML_COUNTERCLOCKWISEBOTTOMLEFT,TransitionSubType::COUNTERCLOCKWISEBOTTOMLEFT }, |
| { XML_CLOCKWISEBOTTOMRIGHT, TransitionSubType::CLOCKWISEBOTTOMRIGHT }, |
| { XML_COUNTERCLOCKWISETOPRIGHT,TransitionSubType::COUNTERCLOCKWISETOPRIGHT }, |
| { XML_CENTERTOP, TransitionSubType::CENTERTOP }, |
| { XML_CENTERRIGHT, TransitionSubType::CENTERRIGHT }, |
| { XML_TOP, TransitionSubType::TOP }, |
| { XML_BOTTOM, TransitionSubType::BOTTOM }, |
| { XML_FANOUTVERTICAL, TransitionSubType::FANOUTVERTICAL }, |
| { XML_FANOUTHORIZONTAL, TransitionSubType::FANOUTHORIZONTAL }, |
| { XML_FANINVERTICAL, TransitionSubType::FANINVERTICAL }, |
| { XML_FANINHORIZONTAL, TransitionSubType::FANINHORIZONTAL }, |
| { XML_PARALLELVERTICAL, TransitionSubType::PARALLELVERTICAL }, |
| { XML_PARALLELDIAGONAL, TransitionSubType::PARALLELDIAGONAL }, |
| { XML_OPPOSITEVERTICAL, TransitionSubType::OPPOSITEVERTICAL }, |
| { XML_OPPOSITEHORIZONTAL, TransitionSubType::OPPOSITEHORIZONTAL }, |
| { XML_PARALLELDIAGONALTOPLEFT,TransitionSubType::PARALLELDIAGONALTOPLEFT }, |
| { XML_PARALLELDIAGONALBOTTOMLEFT,TransitionSubType::PARALLELDIAGONALBOTTOMLEFT }, |
| { XML_TOPLEFTHORIZONTAL, TransitionSubType::TOPLEFTHORIZONTAL }, |
| { XML_TOPLEFTDIAGONAL, TransitionSubType::TOPLEFTDIAGONAL }, |
| { XML_TOPRIGHTDIAGONAL, TransitionSubType::TOPRIGHTDIAGONAL }, |
| { XML_BOTTOMRIGHTDIAGONAL, TransitionSubType::BOTTOMRIGHTDIAGONAL }, |
| { XML_BOTTOMLEFTDIAGONAL, TransitionSubType::BOTTOMLEFTDIAGONAL }, |
| { XML_TOPLEFTCLOCKWISE, TransitionSubType::TOPLEFTCLOCKWISE }, |
| { XML_TOPRIGHTCLOCKWISE, TransitionSubType::TOPRIGHTCLOCKWISE }, |
| { XML_BOTTOMRIGHTCLOCKWISE, TransitionSubType::BOTTOMRIGHTCLOCKWISE }, |
| { XML_BOTTOMLEFTCLOCKWISE, TransitionSubType::BOTTOMLEFTCLOCKWISE }, |
| { XML_TOPLEFTCOUNTERCLOCKWISE,TransitionSubType::TOPLEFTCOUNTERCLOCKWISE }, |
| { XML_TOPRIGHTCOUNTERCLOCKWISE,TransitionSubType::TOPRIGHTCOUNTERCLOCKWISE }, |
| { XML_BOTTOMRIGHTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMRIGHTCOUNTERCLOCKWISE }, |
| { XML_BOTTOMLEFTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMLEFTCOUNTERCLOCKWISE }, |
| { XML_VERTICALTOPSAME, TransitionSubType::VERTICALTOPSAME }, |
| { XML_VERTICALBOTTOMSAME, TransitionSubType::VERTICALBOTTOMSAME }, |
| { XML_VERTICALTOPLEFTOPPOSITE,TransitionSubType::VERTICALTOPLEFTOPPOSITE }, |
| { XML_VERTICALBOTTOMLEFTOPPOSITE,TransitionSubType::VERTICALBOTTOMLEFTOPPOSITE }, |
| { XML_HORIZONTALLEFTSAME, TransitionSubType::HORIZONTALLEFTSAME }, |
| { XML_HORIZONTALRIGHTSAME, TransitionSubType::HORIZONTALRIGHTSAME }, |
| { XML_HORIZONTALTOPLEFTOPPOSITE,TransitionSubType::HORIZONTALTOPLEFTOPPOSITE }, |
| { XML_HORIZONTALTOPRIGHTOPPOSITE,TransitionSubType::HORIZONTALTOPRIGHTOPPOSITE }, |
| { XML_DIAGONALBOTTOMLEFTOPPOSITE,TransitionSubType::DIAGONALBOTTOMLEFTOPPOSITE }, |
| { XML_DIAGONALTOPLEFTOPPOSITE,TransitionSubType::DIAGONALTOPLEFTOPPOSITE }, |
| { XML_TWOBOXTOP, TransitionSubType::TWOBOXTOP }, |
| { XML_TWOBOXBOTTOM, TransitionSubType::TWOBOXBOTTOM }, |
| { XML_TWOBOXLEFT, TransitionSubType::TWOBOXLEFT }, |
| { XML_TWOBOXRIGHT, TransitionSubType::TWOBOXRIGHT }, |
| { XML_FOURBOXVERTICAL, TransitionSubType::FOURBOXVERTICAL }, |
| { XML_FOURBOXHORIZONTAL, TransitionSubType::FOURBOXHORIZONTAL }, |
| { XML_VERTICALLEFT, TransitionSubType::VERTICALLEFT }, |
| { XML_VERTICALRIGHT, TransitionSubType::VERTICALRIGHT }, |
| { XML_HORIZONTALLEFT, TransitionSubType::HORIZONTALLEFT }, |
| { XML_HORIZONTALRIGHT, TransitionSubType::HORIZONTALRIGHT }, |
| { XML_FROMLEFT, TransitionSubType::FROMLEFT }, |
| { XML_FROMTOP, TransitionSubType::FROMTOP }, |
| { XML_FROMRIGHT, TransitionSubType::FROMRIGHT }, |
| { XML_FROMBOTTOM, TransitionSubType::FROMBOTTOM }, |
| { XML_CROSSFADE, TransitionSubType::CROSSFADE }, |
| { XML_FADETOCOLOR, TransitionSubType::FADETOCOLOR }, |
| { XML_FADEFROMCOLOR, TransitionSubType::FADEFROMCOLOR }, |
| { XML_FADEOVERCOLOR, TransitionSubType::FADEOVERCOLOR }, |
| { XML_THREEBLADE, TransitionSubType::THREEBLADE }, |
| { XML_EIGHTBLADE, TransitionSubType::EIGHTBLADE }, |
| { XML_ONEBLADE, TransitionSubType::ONEBLADE }, |
| { XML_ACROSS, TransitionSubType::ACROSS }, |
| { XML_TOPLEFTVERTICAL, TransitionSubType::TOPLEFTVERTICAL }, |
| { XML_COMBHORIZONTAL, TransitionSubType::COMBHORIZONTAL }, |
| { XML_COMBVERTICAL, TransitionSubType::COMBVERTICAL }, |
| { XML_IN, TransitionSubType::IN }, |
| { XML_OUT, TransitionSubType::OUT }, |
| { XML_ROTATEIN, TransitionSubType::ROTATEIN }, |
| { XML_ROTATEOUT, TransitionSubType::ROTATEOUT }, |
| { XML_FROMTOPLEFT, TransitionSubType::FROMTOPLEFT }, |
| { XML_FROMTOPRIGHT, TransitionSubType::FROMTOPRIGHT }, |
| { XML_FROMBOTTOMLEFT, TransitionSubType::FROMBOTTOMLEFT }, |
| { XML_FROMBOTTOMRIGHT, TransitionSubType::FROMBOTTOMRIGHT }, |
| |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_TransitionSubType; |
| } |
| case Animations_EnumMap_EventTrigger: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_EventTrigger[] = |
| { |
| { XML_ONBEGIN, EventTrigger::ON_BEGIN }, |
| { XML_ONEND, EventTrigger::ON_END }, |
| { XML_BEGIN, EventTrigger::BEGIN_EVENT }, |
| { XML_END, EventTrigger::END_EVENT }, |
| { XML_CLICK, EventTrigger::ON_CLICK }, |
| { XML_DOUBLECLICK, EventTrigger::ON_DBL_CLICK }, |
| { XML_MOUSEOVER, EventTrigger::ON_MOUSE_ENTER }, |
| { XML_MOUSEOUT, EventTrigger::ON_MOUSE_LEAVE }, |
| { XML_NEXT, EventTrigger::ON_NEXT }, |
| { XML_PREVIOUS, EventTrigger::ON_PREV }, |
| { XML_STOP_AUDIO, EventTrigger::ON_STOP_AUDIO }, |
| { XML_REPEAT, EventTrigger::REPEAT }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_EventTrigger; |
| } |
| |
| case Animations_EnumMap_EffectPresetClass: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_EffectPresetClass[] = |
| { |
| { XML_CUSTOM, EffectPresetClass::CUSTOM }, |
| { XML_ENTRANCE, EffectPresetClass::ENTRANCE }, |
| { XML_EXIT, EffectPresetClass::EXIT }, |
| { XML_EMPHASIS, EffectPresetClass::EMPHASIS }, |
| { XML_MOTION_PATH, EffectPresetClass::MOTIONPATH }, |
| { XML_OLE_ACTION, EffectPresetClass::OLEACTION }, |
| { XML_MEDIA_CALL, EffectPresetClass::MEDIACALL }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_EffectPresetClass; |
| } |
| |
| case Animations_EnumMap_EffectNodeType: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_EffectNodeType[] = |
| { |
| { XML_DEFAULT, EffectNodeType::DEFAULT }, |
| { XML_ON_CLICK, EffectNodeType::ON_CLICK }, |
| { XML_WITH_PREVIOUS, EffectNodeType::WITH_PREVIOUS }, |
| { XML_AFTER_PREVIOUS, EffectNodeType::AFTER_PREVIOUS }, |
| { XML_MAIN_SEQUENCE, EffectNodeType::MAIN_SEQUENCE }, |
| { XML_TIMING_ROOT, EffectNodeType::TIMING_ROOT }, |
| { XML_INTERACTIVE_SEQUENCE, EffectNodeType::INTERACTIVE_SEQUENCE }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_EffectNodeType; |
| } |
| case Animations_EnumMap_SubItem: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_SubItem[] = |
| { |
| { XML_WHOLE, ShapeAnimationSubType::AS_WHOLE }, |
| { XML_BACKGROUND, ShapeAnimationSubType::ONLY_BACKGROUND }, |
| { XML_TEXT, ShapeAnimationSubType::ONLY_TEXT }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_SubItem; |
| } |
| case Animations_EnumMap_IterateType: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_IterateType[] = |
| { |
| { XML_BY_PARAGRAPH, TextAnimationType::BY_PARAGRAPH }, |
| { XML_BY_WORD, TextAnimationType::BY_WORD }, |
| { XML_BY_LETTER, TextAnimationType::BY_LETTER }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_IterateType; |
| } |
| case Animations_EnumMap_Command: |
| { |
| static SvXMLEnumMapEntry aAnimations_EnumMap_Command[] = |
| { |
| { XML_CUSTOM, EffectCommands::CUSTOM }, |
| { XML_VERB, EffectCommands::VERB }, |
| { XML_PLAY, EffectCommands::PLAY }, |
| { XML_TOGGLE_PAUSE, EffectCommands::TOGGLEPAUSE }, |
| { XML_STOP, EffectCommands::STOP }, |
| { XML_STOP_AUDIO, EffectCommands::STOPAUDIO }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| return aAnimations_EnumMap_Command; |
| } |
| } |
| |
| DBG_ERROR( "xmloff::getAnimationsEnumMap(), invalid map!" ); |
| return NULL; |
| } |
| |
| struct ImplAttributeNameConversion* getAnimationAttributeNamesConversionList() |
| { |
| static struct ImplAttributeNameConversion gImplConversionList[] = |
| { |
| { XML_X, "X" }, |
| { XML_Y, "Y" }, |
| { XML_WIDTH, "Width" }, |
| { XML_HEIGHT, "Height" }, |
| { XML_ROTATE, "Rotate" }, |
| { XML_SKEWX, "SkewX" }, |
| { XML_FILL_COLOR, "FillColor" }, |
| { XML_FILL, "FillStyle" }, |
| { XML_STROKE_COLOR, "LineColor" }, |
| { XML_STROKE, "LineStyle" }, |
| { XML_COLOR, "CharColor" }, |
| { XML_TEXT_ROTATION_ANGLE, "CharRotation" }, |
| { XML_FONT_WEIGHT, "CharWeight" }, |
| { XML_TEXT_UNDERLINE, "CharUnderline" }, |
| { XML_FONT_FAMILY, "CharFontName" }, |
| { XML_FONT_SIZE, "CharHeight" }, |
| { XML_FONT_STYLE, "CharPosture" }, |
| { XML_VISIBILITY, "Visibility" }, |
| { XML_OPACITY, "Opacity" }, |
| { XML_DIM, "DimColor" }, |
| { XML_TOKEN_INVALID, NULL } |
| }; |
| |
| return gImplConversionList; |
| } |
| |
| |
| class AnimationsExporterImpl |
| { |
| public: |
| AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps ); |
| |
| void prepareNode( const Reference< XAnimationNode >& xNode ); |
| void exportNode( const Reference< XAnimationNode >& xNode ); |
| |
| void exportContainer( const Reference< XTimeContainer >& xNode, sal_Int16 nContainerNodeType ); |
| void exportAnimate( const Reference< XAnimate >& xNode ); |
| void exportAudio( const Reference< XAudio >& xAudio ); |
| void exportCommand( const Reference< XCommand >& xCommand ); |
| |
| Reference< XInterface > getParagraphTarget( const ParagraphTarget* pTarget ) const; |
| |
| void convertPath( OUStringBuffer& sTmp, const Any& rPath ); |
| void convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ); |
| void convertTiming( OUStringBuffer& sTmp, const Any& rTiming ); |
| void convertSource( OUStringBuffer& sTmp, const Any& rSource ); |
| void convertTarget( OUStringBuffer& sTmp, const Any& rTarget ); |
| |
| void prepareValue( const Any& rValue ); |
| |
| void exportTransitionNode(); |
| void prepareTransitionNode(); |
| |
| bool mbHasTransition; |
| private: |
| SvXMLExport& mrExport; |
| Reference< XInterface > mxExport; |
| Reference< XPropertySet > mxPageProps; |
| }; |
| |
| AnimationsExporterImpl::AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps ) |
| : mbHasTransition(false) |
| , mrExport( rExport ) |
| , mxPageProps( xPageProps ) |
| { |
| try |
| { |
| mxExport = static_cast< ::com::sun::star::document::XFilter *>(&rExport); |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::AnimationsExporterImpl(), RuntimeException catched!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::exportTransitionNode() |
| { |
| if( mbHasTransition && mxPageProps.is() ) |
| { |
| sal_Int16 nTransition = 0; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionType" ) ) ) >>= nTransition; |
| |
| Any aSound( mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ) ) ); |
| OUString sSoundURL; |
| aSound >>= sSoundURL; |
| sal_Bool bStopSound = sal_False; |
| if( !(aSound >>= bStopSound) ) |
| bStopSound = sal_False; |
| |
| |
| OUStringBuffer sTmp; |
| if( (nTransition != 0) || (sSoundURL.getLength() != 0) || bStopSound ) |
| { |
| Reference< XInterface > xSource( mxPageProps.get() ); |
| Event aEvent; |
| aEvent.Source <<= xSource; |
| aEvent.Trigger = EventTrigger::BEGIN_EVENT; |
| aEvent.Repeat = 0; |
| |
| convertTiming( sTmp, Any( aEvent ) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() ); |
| |
| SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_PAR, sal_True, sal_True ); |
| |
| if( nTransition != 0 ) |
| { |
| sal_Int16 nSubtype = 0; |
| sal_Bool bDirection = sal_False; |
| sal_Int32 nFadeColor = 0; |
| double fDuration = 0.0; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionSubtype" ) ) ) >>= nSubtype; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionDirection" ) ) ) >>= bDirection; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionFadeColor" ) ) ) >>= nFadeColor; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionDuration" ) ) ) >>= fDuration; |
| |
| SvXMLUnitConverter::convertDouble( sTmp, fDuration ); |
| sTmp.append( sal_Unicode('s')); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() ); |
| |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTransition, getAnimationsEnumMap(Animations_EnumMap_TransitionType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() ); |
| |
| if( nSubtype != TransitionSubType::DEFAULT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nSubtype, getAnimationsEnumMap(Animations_EnumMap_TransitionSubType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() ); |
| } |
| |
| if( !bDirection ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE ); |
| |
| if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) )) |
| { |
| SvXMLUnitConverter::convertColor( sTmp, nFadeColor ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() ); |
| } |
| SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_TRANSITIONFILTER, sal_True, sal_True ); |
| } |
| |
| if( bStopSound ) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, XML_STOP_AUDIO ); |
| SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, sal_True, sal_True ); |
| } |
| else if( sSoundURL.getLength() != 0) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference( sSoundURL ) ); |
| |
| sal_Bool bLoopSound = sal_False; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "LoopSound" ) ) ) >>= bLoopSound; |
| |
| if( bLoopSound ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE ); |
| SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, sal_True, sal_True ); |
| } |
| } |
| } |
| } |
| |
| void AnimationsExporterImpl::prepareTransitionNode() |
| { |
| if( mxPageProps.is() ) try |
| { |
| sal_Int16 nTransition = 0; |
| mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionType" ) ) ) >>= nTransition; |
| |
| sal_Bool bStopSound = sal_False; |
| OUString sSoundURL; |
| |
| if( nTransition == 0 ) |
| { |
| Any aSound( mxPageProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ) ) ); |
| aSound >>= sSoundURL; |
| |
| if( !(aSound >>= bStopSound) ) |
| bStopSound = sal_False; |
| } |
| |
| if( (nTransition != 0) || (sSoundURL.getLength() != 0) || bStopSound ) |
| { |
| mbHasTransition = true; |
| Reference< XInterface > xInt( mxPageProps.get() ); |
| mrExport.getInterfaceToIdentifierMapper().registerReference( xInt ); |
| } |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::prepareNode(), Exception caught!" ); |
| } |
| |
| } |
| |
| void AnimationsExporterImpl::prepareNode( const Reference< XAnimationNode >& xNode ) |
| { |
| try |
| { |
| prepareValue( xNode->getBegin() ); |
| prepareValue( xNode->getEnd() ); |
| |
| sal_Int16 nNodeType = xNode->getType(); |
| switch( nNodeType ) |
| { |
| case AnimationNodeType::ITERATE: |
| { |
| Reference< XIterateContainer > xIter( xNode, UNO_QUERY_THROW ); |
| prepareValue( xIter->getTarget() ); |
| } |
| // its intended that here is no break! |
| case AnimationNodeType::PAR: |
| case AnimationNodeType::SEQ: |
| { |
| Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW ); |
| Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW ); |
| while( xEnumeration->hasMoreElements() ) |
| { |
| Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW ); |
| prepareNode( xChildNode ); |
| } |
| } |
| break; |
| |
| case AnimationNodeType::ANIMATE: |
| case AnimationNodeType::SET: |
| case AnimationNodeType::ANIMATEMOTION: |
| case AnimationNodeType::ANIMATECOLOR: |
| case AnimationNodeType::ANIMATETRANSFORM: |
| case AnimationNodeType::TRANSITIONFILTER: |
| { |
| Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW ); |
| prepareValue( xAnimate->getTarget() ); |
| } |
| break; |
| |
| case AnimationNodeType::COMMAND: |
| { |
| Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW ); |
| prepareValue( xCommand->getTarget() ); |
| } |
| break; |
| |
| case AnimationNodeType::AUDIO: |
| { |
| Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW ); |
| prepareValue( xAudio->getSource() ); |
| } |
| break; |
| } |
| |
| Sequence< NamedValue > aUserData( xNode->getUserData() ); |
| if( aUserData.hasElements() ) |
| { |
| const NamedValue* pValue = aUserData.getConstArray(); |
| const sal_Int32 nLength = aUserData.getLength(); |
| sal_Int32 nElement; |
| for( nElement = 0; nElement < nLength; nElement++, pValue++ ) |
| { |
| if( IsXMLToken( pValue->Name, XML_MASTER_ELEMENT ) ) |
| { |
| Reference< XInterface > xMaster; |
| pValue->Value >>= xMaster; |
| if( xMaster.is() ) |
| mrExport.getInterfaceToIdentifierMapper().registerReference( xMaster ); |
| } |
| } |
| } |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::prepareNode(), RuntimeException catched!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::exportNode( const Reference< XAnimationNode >& xNode ) |
| { |
| try |
| { |
| OUStringBuffer sTmp; |
| |
| const OUString& rExportIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xNode ); |
| if( rExportIdentifier.getLength() ) |
| { |
| mrExport.AddAttributeIdLegacy( |
| XML_NAMESPACE_ANIMATION, rExportIdentifier); |
| } |
| |
| Any aTemp( xNode->getBegin() ); |
| if( aTemp.hasValue() ) |
| { |
| convertTiming( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() ); |
| } |
| |
| double fTemp = 0; |
| sal_Int32 nTemp; |
| |
| aTemp = xNode->getDuration(); |
| if( aTemp.hasValue() ) |
| { |
| if( aTemp >>= fTemp ) |
| { |
| SvXMLUnitConverter::convertDouble( sTmp, fTemp ); |
| sTmp.append( sal_Unicode('s')); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() ); |
| } |
| else |
| { |
| Timing eTiming; |
| if( aTemp >>= eTiming ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, eTiming == Timing_INDEFINITE ? XML_INDEFINITE : XML_MEDIA ); |
| } |
| } |
| |
| aTemp = xNode->getEnd(); |
| if( aTemp.hasValue() ) |
| { |
| convertTiming( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_END, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xNode->getFill(); |
| if( nTemp != AnimationFill::DEFAULT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Fill) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FILL, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xNode->getFillDefault(); |
| if( nTemp != AnimationFill::INHERIT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_FillDefault) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FILLDEFAULT, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xNode->getRestart(); |
| if( nTemp != AnimationRestart::DEFAULT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Restart) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_RESTART, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xNode->getRestartDefault(); |
| if( nTemp != AnimationRestart::INHERIT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_RestartDefault) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_RESTARTDEFAULT, sTmp.makeStringAndClear() ); |
| } |
| |
| fTemp = xNode->getAcceleration(); |
| if( fTemp != 0.0 ) |
| { |
| SvXMLUnitConverter::convertDouble( sTmp, fTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ACCELERATE, sTmp.makeStringAndClear() ); |
| } |
| |
| fTemp = xNode->getDecelerate(); |
| if( fTemp != 0.0 ) |
| { |
| SvXMLUnitConverter::convertDouble( sTmp, fTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DECELERATE, sTmp.makeStringAndClear() ); |
| } |
| |
| sal_Bool bTemp = xNode->getAutoReverse(); |
| if( bTemp ) |
| { |
| SvXMLUnitConverter::convertBool( sTmp, bTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_AUTOREVERSE, sTmp.makeStringAndClear() ); |
| } |
| |
| aTemp = xNode->getRepeatCount(); |
| if( aTemp.hasValue() ) |
| { |
| Timing eTiming; |
| if( (aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE ) ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE ); |
| else if( aTemp >>= fTemp ) |
| { |
| SvXMLUnitConverter::convertDouble( sTmp, fTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| aTemp = xNode->getRepeatDuration(); |
| if( aTemp.hasValue() ) |
| { |
| Timing eTiming; |
| if( ( aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE) ) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, XML_INDEFINITE ); |
| } |
| else if( aTemp >>= fTemp ) |
| { |
| SvXMLUnitConverter::convertDouble( sTmp, fTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| aTemp = xNode->getEndSync(); |
| if( aTemp.hasValue() ) |
| { |
| if( aTemp >>= nTemp ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Endsync) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ENDSYNC, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| sal_Int16 nContainerNodeType = EffectNodeType::DEFAULT; |
| OUString aPresetId; |
| Sequence< NamedValue > aUserData( xNode->getUserData() ); |
| if( aUserData.hasElements() ) |
| { |
| const NamedValue* pValue = aUserData.getConstArray(); |
| const sal_Int32 nLength = aUserData.getLength(); |
| sal_Int32 nElement; |
| for( nElement = 0; nElement < nLength; nElement++, pValue++ ) |
| { |
| if( IsXMLToken( pValue->Name, XML_NODE_TYPE ) ) |
| { |
| if( (pValue->Value >>= nContainerNodeType) && (nContainerNodeType != EffectNodeType::DEFAULT) ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nContainerNodeType, getAnimationsEnumMap(Animations_EnumMap_EffectNodeType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_NODE_TYPE, sTmp.makeStringAndClear() ); |
| } |
| } |
| else if( IsXMLToken( pValue->Name, XML_PRESET_ID ) ) |
| { |
| if( pValue->Value >>= aPresetId ) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_ID, aPresetId ); |
| } |
| } |
| else if( IsXMLToken( pValue->Name, XML_PRESET_SUB_TYPE ) ) |
| { |
| OUString aPresetSubType; |
| if( pValue->Value >>= aPresetSubType ) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_SUB_TYPE, aPresetSubType ); |
| } |
| } |
| else if( IsXMLToken( pValue->Name, XML_PRESET_CLASS ) ) |
| { |
| sal_Int16 nEffectPresetClass = sal_Int16(); |
| if( pValue->Value >>= nEffectPresetClass ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nEffectPresetClass, getAnimationsEnumMap(Animations_EnumMap_EffectPresetClass) ); |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_CLASS, sTmp.makeStringAndClear() ); |
| } |
| } |
| else if( IsXMLToken( pValue->Name, XML_MASTER_ELEMENT ) ) |
| { |
| Reference< XInterface > xMaster; |
| pValue->Value >>= xMaster; |
| if( xMaster.is() ) |
| { |
| const OUString& rIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier(xMaster); |
| if( rIdentifier.getLength() ) |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_MASTER_ELEMENT, rIdentifier ); |
| } |
| } |
| else if( IsXMLToken( pValue->Name, XML_GROUP_ID ) ) |
| { |
| sal_Int32 nGroupId = 0; |
| if( pValue->Value >>= nGroupId ) |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_GROUP_ID, OUString::valueOf( nGroupId ) ); |
| } |
| else |
| { |
| OUString aTmp; |
| if( pValue->Value >>= aTmp ) |
| mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, pValue->Name, aTmp ); |
| } |
| } |
| } |
| |
| nTemp = xNode->getType(); |
| switch( nTemp ) |
| { |
| case AnimationNodeType::PAR: |
| case AnimationNodeType::SEQ: |
| case AnimationNodeType::ITERATE: |
| { |
| Reference< XTimeContainer > xContainer( xNode, UNO_QUERY_THROW ); |
| exportContainer( xContainer, nContainerNodeType ); |
| } |
| break; |
| |
| case AnimationNodeType::ANIMATE: |
| case AnimationNodeType::SET: |
| case AnimationNodeType::ANIMATEMOTION: |
| case AnimationNodeType::ANIMATECOLOR: |
| case AnimationNodeType::ANIMATETRANSFORM: |
| case AnimationNodeType::TRANSITIONFILTER: |
| { |
| Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW ); |
| exportAnimate( xAnimate ); |
| } |
| break; |
| case AnimationNodeType::AUDIO: |
| { |
| Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW ); |
| exportAudio( xAudio ); |
| } |
| break; |
| case AnimationNodeType::COMMAND: |
| { |
| Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW ); |
| exportCommand( xCommand ); |
| } |
| break; |
| default: |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportNode(), invalid AnimationNodeType!" ); |
| } |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportNode(), RuntimeException catched!" ); |
| } |
| |
| // if something goes wrong, its always a good idea to clear the attribute list |
| mrExport.ClearAttrList(); |
| } |
| |
| void AnimationsExporterImpl::exportContainer( const Reference< XTimeContainer >& xContainer, sal_Int16 nContainerNodeType ) |
| { |
| try |
| { |
| const sal_Int32 nNodeType = xContainer->getType(); |
| |
| if( nNodeType == AnimationNodeType::ITERATE ) |
| { |
| OUStringBuffer sTmp; |
| Reference< XIterateContainer > xIter( xContainer, UNO_QUERY_THROW ); |
| |
| Any aTemp( xIter->getTarget() ); |
| if( aTemp.hasValue() ) |
| { |
| convertTarget( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() ); |
| } |
| |
| sal_Int16 nTemp = xIter->getSubItem(); |
| if( nTemp ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_SubItem) ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xIter->getIterateType(); |
| if( nTemp ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_IterateType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_TYPE, sTmp.makeStringAndClear() ); |
| } |
| |
| double fTemp = xIter->getIterateInterval(); |
| if( fTemp ) |
| { |
| if( 0 == ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ) ) |
| { |
| // issue 146582 |
| sal_Int32 nSecondsFraction = static_cast<sal_Int32>(fTemp * 1000 ) % 1000; |
| ::Time aTime( static_cast<sal_Int32>( fTemp * 100 ) ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_INTERVAL, SvXMLUnitConverter::convertTimeDuration( aTime, nSecondsFraction ) ); |
| } |
| else |
| { |
| sTmp.append( fTemp ); |
| sTmp.append( (sal_Unicode)'s' ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_INTERVAL, sTmp.makeStringAndClear() ); |
| } |
| } |
| } |
| |
| XMLTokenEnum eElementToken; |
| switch( nNodeType ) |
| { |
| case AnimationNodeType::PAR: eElementToken = XML_PAR; break; |
| case AnimationNodeType::SEQ: eElementToken = XML_SEQ; break; |
| case AnimationNodeType::ITERATE:eElementToken = XML_ITERATE; break; |
| default: |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportContainer(), invalid TimeContainerType!" ); |
| return; |
| } |
| SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, eElementToken, sal_True, sal_True ); |
| |
| if( nContainerNodeType == EffectNodeType::TIMING_ROOT ) |
| exportTransitionNode(); |
| |
| Reference< XEnumerationAccess > xEnumerationAccess( xContainer, UNO_QUERY_THROW ); |
| Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW ); |
| while( xEnumeration->hasMoreElements() ) |
| { |
| Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW ); |
| exportNode( xChildNode ); |
| } |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportContainer(), RuntimeException catched!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::exportAnimate( const Reference< XAnimate >& xAnimate ) |
| { |
| try |
| { |
| const sal_Int16 nNodeType = xAnimate->getType(); |
| |
| OUStringBuffer sTmp; |
| sal_Int32 nTemp; |
| sal_Bool bTemp; |
| |
| Any aTemp( xAnimate->getTarget() ); |
| if( aTemp.hasValue() ) |
| { |
| convertTarget( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() ); |
| } |
| |
| nTemp = xAnimate->getSubItem(); |
| if( nTemp ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_SubItem) ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() ); |
| } |
| |
| XMLTokenEnum eAttributeName = XML_TOKEN_INVALID; |
| |
| if( nNodeType == AnimationNodeType::TRANSITIONFILTER ) |
| { |
| eAttributeName = XML_TRANSITIONFILTER; |
| } |
| else if( nNodeType == AnimationNodeType::ANIMATETRANSFORM ) |
| { |
| eAttributeName = XML_ANIMATETRANSFORM; |
| } |
| else if( nNodeType == AnimationNodeType::ANIMATEMOTION ) |
| { |
| eAttributeName = XML_ANIMATEMOTION; |
| } |
| else |
| { |
| OUString sTemp( xAnimate->getAttributeName() ); |
| if( sTemp.getLength() ) |
| { |
| ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList(); |
| while( p->mpAPIName ) |
| { |
| if( sTemp.compareToAscii( p->mpAPIName ) == 0 ) |
| { |
| sTemp = GetXMLToken( p->meXMLToken ); |
| eAttributeName = p->meXMLToken; |
| break; |
| } |
| |
| p++; |
| } |
| |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, sTemp ); |
| } |
| else |
| { |
| OUString aStr( RTL_CONSTASCII_USTRINGPARAM( "invalid" ) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, aStr ); |
| } |
| } |
| |
| Sequence< Any > aValues( xAnimate->getValues() ); |
| if( aValues.getLength() ) |
| { |
| aTemp <<= aValues; |
| convertValue( eAttributeName, sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_VALUES, sTmp.makeStringAndClear() ); |
| } |
| else |
| { |
| aTemp = xAnimate->getFrom(); |
| if( aTemp.hasValue() ) |
| { |
| convertValue( eAttributeName, sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FROM, sTmp.makeStringAndClear() ); |
| } |
| |
| aTemp = xAnimate->getBy(); |
| if( aTemp.hasValue() ) |
| { |
| convertValue( eAttributeName, sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BY, sTmp.makeStringAndClear() ); |
| } |
| |
| aTemp = xAnimate->getTo(); |
| if( aTemp.hasValue() ) |
| { |
| convertValue( eAttributeName, sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TO, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| if(nNodeType != AnimationNodeType::SET) |
| { |
| Sequence< double > aKeyTimes( xAnimate->getKeyTimes() ); |
| if( aKeyTimes.getLength() ) |
| { |
| sal_Int32 nLength = aKeyTimes.getLength(); |
| const double* p = aKeyTimes.getConstArray(); |
| |
| while( nLength-- ) |
| { |
| if( sTmp.getLength() ) |
| sTmp.append( (sal_Unicode)';' ); |
| |
| sTmp.append( *p++ ); |
| } |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_KEYTIMES, sTmp.makeStringAndClear() ); |
| } |
| |
| OUString sTemp( xAnimate->getFormula() ); |
| if( sTemp.getLength() ) |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_FORMULA, sTemp ); |
| |
| if( (nNodeType != AnimationNodeType::TRANSITIONFILTER) && |
| (nNodeType != AnimationNodeType::AUDIO ) ) |
| { |
| // calcMode = "discrete | linear | paced | spline" |
| nTemp = xAnimate->getCalcMode(); |
| if( ((nNodeType == AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::PACED)) || |
| ((nNodeType != AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::LINEAR)) ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_CalcMode) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_CALCMODE, sTmp.makeStringAndClear() ); |
| } |
| |
| bTemp = xAnimate->getAccumulate(); |
| if( bTemp ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ACCUMULATE, XML_SUM ); |
| |
| nTemp = xAnimate->getAdditive(); |
| if( nTemp != AnimationAdditiveMode::REPLACE ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_AdditiveMode) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ADDITIVE, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| Sequence< TimeFilterPair > aTimeFilter( xAnimate->getTimeFilter() ); |
| if( aTimeFilter.getLength() ) |
| { |
| sal_Int32 nLength = aTimeFilter.getLength(); |
| const TimeFilterPair* p = aTimeFilter.getConstArray(); |
| |
| while( nLength-- ) |
| { |
| if( sTmp.getLength() ) |
| sTmp.append( (sal_Unicode)';' ); |
| |
| sTmp.append( p->Time ); |
| sTmp.append( (sal_Unicode)',' ); |
| sTmp.append( p->Progress ); |
| |
| p++; |
| } |
| |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_KEYSPLINES, sTmp.makeStringAndClear() ); |
| } |
| } |
| |
| XMLTokenEnum eElementToken = XML_ANIMATE; |
| |
| switch( nNodeType ) |
| { |
| case AnimationNodeType::ANIMATE: |
| eElementToken = XML_ANIMATE; |
| break; |
| |
| case AnimationNodeType::SET: |
| eElementToken = XML_SET; |
| break; |
| |
| case AnimationNodeType::ANIMATEMOTION: |
| { |
| eElementToken = XML_ANIMATEMOTION; |
| |
| Reference< XAnimateMotion > xAnimateMotion( xAnimate, UNO_QUERY_THROW ); |
| |
| aTemp = xAnimateMotion->getPath(); |
| if( aTemp.hasValue() ) |
| { |
| convertPath( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_PATH, sTmp.makeStringAndClear() ); |
| } |
| |
| // TODO: origin = ( parent | layout ) |
| aTemp = xAnimateMotion->getOrigin(); |
| } |
| break; |
| |
| case AnimationNodeType::ANIMATECOLOR: |
| { |
| eElementToken = XML_ANIMATECOLOR; |
| |
| Reference< XAnimateColor > xAnimateColor( xAnimate, UNO_QUERY_THROW ); |
| |
| nTemp = xAnimateColor->getColorInterpolation(); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION, (nTemp == AnimationColorSpace::RGB) ? XML_RGB : XML_HSL ); |
| |
| bTemp = xAnimateColor->getDirection(); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION, bTemp ? XML_CLOCKWISE : XML_COUNTER_CLOCKWISE ); |
| } |
| break; |
| |
| case AnimationNodeType::ANIMATETRANSFORM: |
| { |
| eElementToken = XML_ANIMATETRANSFORM; |
| |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, XML_TRANSFORM ); |
| |
| Reference< XAnimateTransform > xTransform( xAnimate, UNO_QUERY_THROW ); |
| nTemp = xTransform->getTransformType(); |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_TransformType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_TYPE, sTmp.makeStringAndClear() ); |
| } |
| break; |
| |
| case AnimationNodeType::TRANSITIONFILTER: |
| { |
| Reference< XTransitionFilter > xTransitionFilter( xAnimate, UNO_QUERY ); |
| eElementToken = XML_TRANSITIONFILTER; |
| |
| sal_Int16 nTransition = xTransitionFilter->getTransition(); |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTransition, getAnimationsEnumMap(Animations_EnumMap_TransitionType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() ); |
| |
| sal_Int16 nSubtype = xTransitionFilter->getSubtype(); |
| if( nSubtype != TransitionSubType::DEFAULT ) |
| { |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nSubtype, getAnimationsEnumMap(Animations_EnumMap_TransitionSubType) ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() ); |
| } |
| |
| bTemp = xTransitionFilter->getMode(); |
| if( !bTemp ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_MODE, XML_OUT ); |
| |
| bTemp = xTransitionFilter->getDirection(); |
| if( !bTemp ) |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE ); |
| |
| if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) )) |
| { |
| nTemp = xTransitionFilter->getFadeColor(); |
| SvXMLUnitConverter::convertColor( sTmp, nTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() ); |
| } |
| } |
| break; |
| } |
| |
| SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, eElementToken, sal_True, sal_True ); |
| |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportAnimate(), Exception cought!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::exportAudio( const Reference< XAudio >& xAudio ) |
| { |
| if( xAudio.is() ) try |
| { |
| OUString aSourceURL; |
| xAudio->getSource() >>= aSourceURL; |
| if( aSourceURL.getLength() ) |
| mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference( aSourceURL ) ); |
| |
| const double fVolume = xAudio->getVolume(); |
| if( fVolume != 1.0 ) |
| { |
| OUStringBuffer sTmp; |
| SvXMLUnitConverter::convertDouble( sTmp, fVolume ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_AUDIO_LEVEL, sTmp.makeStringAndClear() ); |
| } |
| |
| /* todo? |
| sal_Int32 nEndAfterSlide = 0; |
| xAudio->getEndAfterSlide() >>= nEndAfterSlide; |
| if( nEndAfterSlide != 0 ) |
| mrExport.AddAttribute( ); |
| */ |
| SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, sal_True, sal_True ); |
| |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportAudio(), exception caught!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::exportCommand( const Reference< XCommand >& xCommand ) |
| { |
| if( xCommand.is() ) try |
| { |
| OUStringBuffer sTmp; |
| Any aTemp( xCommand->getTarget() ); |
| if( aTemp.hasValue() ) |
| { |
| convertTarget( sTmp, aTemp ); |
| mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() ); |
| } |
| |
| sal_Int16 nCommand = xCommand->getCommand(); |
| SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nCommand, getAnimationsEnumMap(Animations_EnumMap_Command) ); |
| mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, sTmp.makeStringAndClear() ); |
| |
| // todo virtual ::com::sun::star::uno::Any SAL_CALL getParameter() throw (::com::sun::star::uno::RuntimeException) = 0; |
| |
| SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, sal_True, sal_True ); |
| |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::exportCommand(), exception caught!" ); |
| } |
| } |
| |
| Reference< XInterface > AnimationsExporterImpl::getParagraphTarget( const ParagraphTarget* pTarget ) const |
| { |
| if( pTarget ) try |
| { |
| Reference< XEnumerationAccess > xParaEnumAccess( pTarget->Shape, UNO_QUERY_THROW ); |
| |
| Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), UNO_QUERY_THROW ); |
| sal_Int32 nParagraph = pTarget->Paragraph; |
| |
| while( xEnumeration->hasMoreElements() ) |
| { |
| Reference< XInterface > xRef( xEnumeration->nextElement(), UNO_QUERY ); |
| if( nParagraph-- == 0 ) |
| return xRef; |
| } |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::getParagraphTarget(), RuntimeException catched!" ); |
| } |
| |
| Reference< XInterface > xRef; |
| return xRef; |
| } |
| |
| void AnimationsExporterImpl::convertPath( OUStringBuffer& sTmp, const Any& rPath ) |
| { |
| OUString aStr; |
| rPath >>= aStr; |
| |
| sTmp = aStr; |
| } |
| |
| void AnimationsExporterImpl::convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) |
| { |
| if( !rValue.hasValue() ) |
| return; |
| |
| if( rValue.getValueType() == ::getCppuType((const ValuePair*)0) ) |
| { |
| const ValuePair* pValuePair = static_cast< const ValuePair* >( rValue.getValue() ); |
| OUStringBuffer sTmp2; |
| convertValue( eAttributeName, sTmp, pValuePair->First ); |
| sTmp.append( (sal_Unicode)',' ); |
| convertValue( eAttributeName, sTmp2, pValuePair->Second ); |
| sTmp.append( sTmp2.makeStringAndClear() ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((Sequence<Any>*)0) ) |
| { |
| const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() ); |
| const sal_Int32 nLength = pSequence->getLength(); |
| sal_Int32 nElement; |
| const Any* pAny = pSequence->getConstArray(); |
| |
| OUStringBuffer sTmp2; |
| |
| for( nElement = 0; nElement < nLength; nElement++, pAny++ ) |
| { |
| if( sTmp.getLength() ) |
| sTmp.append( (sal_Unicode)';' ); |
| convertValue( eAttributeName, sTmp2, *pAny ); |
| sTmp.append( sTmp2.makeStringAndClear() ); |
| } |
| } |
| else |
| { |
| OUString aString; |
| sal_Int32 nType; |
| |
| switch( eAttributeName ) |
| { |
| case XML_X: |
| case XML_Y: |
| case XML_WIDTH: |
| case XML_HEIGHT: |
| case XML_ANIMATETRANSFORM: |
| case XML_ANIMATEMOTION: |
| { |
| if( rValue >>= aString ) |
| { |
| /* |
| const sal_Char* pSource[] = { "$X", "$Y", "$Width", "$Height", NULL }; |
| const sal_Char* pDest[] = { "$x", "$y", "$width", "$height", NULL }; |
| const sal_Int32 nLength[] = { 2, 2, 6, 7, 0 }; |
| |
| sal_Int32 nIndex = 0; |
| while( (nIndex = aString.indexOf( (sal_Unicode)'$', nIndex )) != -1 ) |
| { |
| const sal_Char** ps = pSource; |
| const sal_Char** pd = pDest; |
| const sal_Int32* pl = nLength; |
| |
| while( *ps ) |
| { |
| if( aString.matchAsciiL( *ps, *pl, nIndex ) ) |
| { |
| const OUString aNew( OUString::createFromAscii( *pd ) ); |
| aString = aString.replaceAt( nIndex, *pl, aNew ); |
| nIndex += aNew.getLength(); |
| break; |
| } |
| |
| ps++; |
| pd++; |
| pl++; |
| } |
| |
| if( *ps == 0 ) |
| nIndex++; |
| } |
| */ |
| sTmp.append( aString ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const double*)0) ) |
| { |
| sTmp.append( *(static_cast< const double* >( rValue.getValue() )) ); |
| } |
| else |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!" ); |
| } |
| return; |
| } |
| |
| case XML_SKEWX: |
| case XML_ROTATE: nType = XML_TYPE_DOUBLE; break; |
| case XML_TEXT_ROTATION_ANGLE: nType = XML_TYPE_NUMBER16; break; |
| case XML_FILL_COLOR: |
| case XML_STROKE_COLOR: |
| case XML_DIM: |
| case XML_COLOR: nType = XML_TYPE_COLOR; break; |
| case XML_FILL: nType = XML_SD_TYPE_FILLSTYLE; break; |
| case XML_STROKE: nType = XML_SD_TYPE_STROKE; break; |
| case XML_FONT_WEIGHT: nType = XML_TYPE_TEXT_WEIGHT; break; |
| case XML_FONT_STYLE: nType = XML_TYPE_TEXT_POSTURE; break; |
| case XML_TEXT_UNDERLINE: nType = XML_TYPE_TEXT_UNDERLINE_STYLE; break; |
| case XML_FONT_SIZE: nType = XML_TYPE_DOUBLE_PERCENT; break; |
| case XML_VISIBILITY: nType = XML_SD_TYPE_PRESPAGE_VISIBILITY; break; |
| case XML_OPACITY: |
| case XML_TRANSITIONFILTER: nType = XML_TYPE_DOUBLE; break; |
| default: |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::convertValue(), invalid AttributeName!" ); |
| nType = XML_TYPE_STRING; |
| } |
| |
| const XMLPropertyHandler* pHandler = static_cast<SdXMLExport*>(&mrExport)->GetSdPropHdlFactory()->GetPropertyHandler( nType ); |
| if( pHandler ) |
| { |
| pHandler->exportXML( aString, rValue, mrExport.GetMM100UnitConverter() ); |
| sTmp.append( aString ); |
| } |
| } |
| |
| /* |
| if( rValue.getValueType() == ::getCppuType((const double*)0) ) |
| { |
| sTmp.append( *(static_cast< const double* >( rValue.getValue() )) ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const OUString*)0) ) |
| { |
| sTmp.append( *(static_cast< const OUString* >( rValue.getValue() )) ); |
| } |
| else |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!" ); |
| } |
| */ |
| } |
| |
| void AnimationsExporterImpl::convertTiming( OUStringBuffer& sTmp, const Any& rValue ) |
| { |
| if( !rValue.hasValue() ) |
| return; |
| |
| if( rValue.getValueType() == ::getCppuType((Sequence<Any>*)0) ) |
| { |
| const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() ); |
| const sal_Int32 nLength = pSequence->getLength(); |
| sal_Int32 nElement; |
| const Any* pAny = pSequence->getConstArray(); |
| |
| OUStringBuffer sTmp2; |
| |
| for( nElement = 0; nElement < nLength; nElement++, pAny++ ) |
| { |
| if( sTmp.getLength() ) |
| sTmp.append( (sal_Unicode)';' ); |
| convertTiming( sTmp2, *pAny ); |
| sTmp.append( sTmp2.makeStringAndClear() ); |
| } |
| } |
| else if( rValue.getValueType() == ::getCppuType((const double*)0) ) |
| { |
| sTmp.append( *(static_cast< const double* >( rValue.getValue() )) ); |
| sTmp.append( sal_Unicode('s')); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const Timing*)0) ) |
| { |
| const Timing* pTiming = static_cast< const Timing* >( rValue.getValue() ); |
| sTmp.append( GetXMLToken( (*pTiming == Timing_MEDIA) ? XML_MEDIA : XML_INDEFINITE ) ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const Event*)0) ) |
| { |
| OUStringBuffer sTmp2; |
| |
| const Event* pEvent = static_cast< const Event* >( rValue.getValue() ); |
| |
| if( pEvent->Trigger != EventTrigger::NONE ) |
| { |
| if( pEvent->Source.hasValue() ) |
| { |
| convertSource( sTmp, pEvent->Source ); |
| sTmp.append( (sal_Unicode)'.' ); |
| } |
| |
| SvXMLUnitConverter::convertEnum( sTmp2, (sal_uInt16)pEvent->Trigger, getAnimationsEnumMap(Animations_EnumMap_EventTrigger) ); |
| |
| sTmp.append( sTmp2.makeStringAndClear() ); |
| } |
| |
| if( pEvent->Offset.hasValue() ) |
| { |
| convertTiming( sTmp2, pEvent->Offset ); |
| |
| if( sTmp.getLength() ) |
| sTmp.append( (sal_Unicode)'+' ); |
| |
| sTmp.append( sTmp2.makeStringAndClear() ); |
| } |
| } |
| else |
| { |
| DBG_ERROR( "xmloff::AnimationsExporterImpl::convertTiming(), invalid value type!" ); |
| } |
| } |
| |
| void AnimationsExporterImpl::convertSource( OUStringBuffer& sTmp, const Any& rSource ) |
| { |
| convertTarget( sTmp, rSource ); |
| } |
| |
| void AnimationsExporterImpl::convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) |
| { |
| if( !rTarget.hasValue() ) |
| return; |
| |
| Reference< XInterface > xRef; |
| |
| if( rTarget.getValueTypeClass() == ::com::sun::star::uno::TypeClass_INTERFACE ) |
| { |
| rTarget >>= xRef; |
| } |
| else if( rTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) ) |
| { |
| xRef = getParagraphTarget( static_cast< const ParagraphTarget* >( rTarget.getValue() ) ); |
| } |
| |
| DBG_ASSERT( xRef.is(), "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!" ); |
| if( xRef.is() ) |
| { |
| const OUString& rIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier(xRef); |
| if( rIdentifier.getLength() ) |
| sTmp.append( rIdentifier ); |
| } |
| } |
| |
| void AnimationsExporterImpl::prepareValue( const Any& rValue ) |
| { |
| if( !rValue.hasValue() ) |
| return; |
| |
| if( rValue.getValueType() == ::getCppuType((const ValuePair*)0) ) |
| { |
| const ValuePair* pValuePair = static_cast< const ValuePair* >( rValue.getValue() ); |
| prepareValue( pValuePair->First ); |
| prepareValue( pValuePair->Second ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((Sequence<Any>*)0) ) |
| { |
| const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() ); |
| const sal_Int32 nLength = pSequence->getLength(); |
| sal_Int32 nElement; |
| const Any* pAny = pSequence->getConstArray(); |
| |
| for( nElement = 0; nElement < nLength; nElement++, pAny++ ) |
| prepareValue( *pAny ); |
| } |
| else if( rValue.getValueTypeClass() == ::com::sun::star::uno::TypeClass_INTERFACE ) |
| { |
| Reference< XInterface> xRef( rValue, UNO_QUERY ); |
| if( xRef.is() ) |
| mrExport.getInterfaceToIdentifierMapper().registerReference( xRef ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const ParagraphTarget*)0) ) |
| { |
| Reference< XInterface> xRef( getParagraphTarget( static_cast< const ParagraphTarget* >( rValue.getValue() ) ) ); |
| if( xRef.is() ) |
| mrExport.getInterfaceToIdentifierMapper().registerReference( xRef ); |
| } |
| else if( rValue.getValueType() == ::getCppuType((const Event*)0) ) |
| { |
| const Event* pEvent = static_cast< const Event* >( rValue.getValue() ); |
| prepareValue( pEvent->Source ); |
| } |
| } |
| |
| AnimationsExporter::AnimationsExporter( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps ) |
| { |
| mpImpl = new AnimationsExporterImpl( rExport, xPageProps ); |
| } |
| |
| AnimationsExporter::~AnimationsExporter() |
| { |
| delete mpImpl; |
| } |
| |
| void AnimationsExporter::prepare( Reference< XAnimationNode > xRootNode ) |
| { |
| try |
| { |
| if( xRootNode.is() ) |
| { |
| mpImpl->prepareTransitionNode(); |
| mpImpl->prepareNode( xRootNode ); |
| } |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporter::prepare(), exception catched" ); |
| } |
| } |
| |
| void AnimationsExporter::exportAnimations( Reference< XAnimationNode > xRootNode ) |
| { |
| try |
| { |
| if( xRootNode.is() ) |
| { |
| bool bHasEffects = mpImpl->mbHasTransition; |
| |
| if( !bHasEffects ) |
| { |
| // first check if there are no animations |
| Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW ); |
| Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW ); |
| if( xEnumeration->hasMoreElements() ) |
| { |
| // first child node may be an empty main sequence, check this |
| Reference< XAnimationNode > xMainNode( xEnumeration->nextElement(), UNO_QUERY_THROW ); |
| Reference< XEnumerationAccess > xMainEnumerationAccess( xMainNode, UNO_QUERY_THROW ); |
| Reference< XEnumeration > xMainEnumeration( xMainEnumerationAccess->createEnumeration(), UNO_QUERY_THROW ); |
| |
| // only export if the main sequence is not empty or if there are additional |
| // trigger sequences |
| bHasEffects = xMainEnumeration->hasMoreElements() || xEnumeration->hasMoreElements(); |
| } |
| } |
| |
| if( bHasEffects ) |
| mpImpl->exportNode( xRootNode ); |
| } |
| } |
| catch( RuntimeException& ) |
| { |
| DBG_ERROR( "xmloff::AnimationsExporter::exportAnimations(), exception catched" ); |
| } |
| } |
| |
| } |