summaryrefslogtreecommitdiffstats
path: root/sd/source/core/EffectMigration.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'sd/source/core/EffectMigration.cxx')
-rw-r--r--sd/source/core/EffectMigration.cxx1439
1 files changed, 1439 insertions, 0 deletions
diff --git a/sd/source/core/EffectMigration.cxx b/sd/source/core/EffectMigration.cxx
new file mode 100644
index 000000000..8dd9d0905
--- /dev/null
+++ b/sd/source/core/EffectMigration.cxx
@@ -0,0 +1,1439 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+#include <com/sun/star/presentation/EffectNodeType.hpp>
+#include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
+#include <com/sun/star/presentation/TextAnimationType.hpp>
+#include <com/sun/star/presentation/ParagraphTarget.hpp>
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/animations/AnimationFill.hpp>
+#include <com/sun/star/animations/XAnimate.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <o3tl/string_view.hxx>
+#include <tools/debug.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/svdotext.hxx>
+#include <svx/svdopath.hxx>
+#include <svx/svdogrp.hxx>
+#include <svx/svditer.hxx>
+#include <drawdoc.hxx>
+#include <sdpage.hxx>
+#include <CustomAnimationPreset.hxx>
+#include <TransitionPreset.hxx>
+#include <EffectMigration.hxx>
+#include <anminfo.hxx>
+
+using namespace ::sd;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::animations;
+using namespace ::com::sun::star::presentation;
+using ::com::sun::star::drawing::XShape;
+using ::com::sun::star::lang::XMultiServiceFactory;
+using ::com::sun::star::drawing::XShape;
+using ::com::sun::star::beans::NamedValue;
+
+namespace {
+
+struct deprecated_FadeEffect_conversion_table_entry
+{
+ FadeEffect meFadeEffect;
+ const char* mpPresetId;
+};
+
+}
+
+deprecated_FadeEffect_conversion_table_entry const deprecated_FadeEffect_conversion_table[] =
+{
+// OOo 1.x transitions
+ { FadeEffect_FADE_FROM_LEFT, "wipe-right" },
+ { FadeEffect_FADE_FROM_TOP, "wipe-down" },
+ { FadeEffect_FADE_FROM_RIGHT, "wipe-left" },
+ { FadeEffect_FADE_FROM_BOTTOM, "wipe-up" },
+
+ { FadeEffect_CLOCKWISE, "wheel-clockwise-1-spoke" },
+
+ { FadeEffect_UNCOVER_TO_LEFT, "uncover-left" },
+ { FadeEffect_UNCOVER_TO_UPPERLEFT, "uncover-left-up" },
+ { FadeEffect_UNCOVER_TO_TOP, "uncover-up" },
+ { FadeEffect_UNCOVER_TO_UPPERRIGHT, "uncover-right-up" },
+ { FadeEffect_UNCOVER_TO_RIGHT, "uncover-right" },
+ { FadeEffect_UNCOVER_TO_LOWERRIGHT, "uncover-right-down" },
+ { FadeEffect_UNCOVER_TO_BOTTOM, "uncover-down" },
+ { FadeEffect_UNCOVER_TO_LOWERLEFT, "uncover-left-down" },
+
+ { FadeEffect_VERTICAL_LINES, "random-bars-vertical" },
+ { FadeEffect_HORIZONTAL_LINES, "random-bars-horizontal" },
+
+ { FadeEffect_VERTICAL_CHECKERBOARD, "checkerboard-down" },
+ { FadeEffect_HORIZONTAL_CHECKERBOARD, "checkerboard-across" },
+
+ { FadeEffect_FADE_TO_CENTER, "box-in" },
+ { FadeEffect_FADE_FROM_CENTER, "box-out" },
+
+ { FadeEffect_VERTICAL_STRIPES, "venetian-blinds-vertical" },
+ { FadeEffect_HORIZONTAL_STRIPES, "venetian-blinds-horizontal" },
+
+ { FadeEffect_MOVE_FROM_LEFT, "cover-right" },
+ { FadeEffect_MOVE_FROM_TOP, "cover-down" },
+ { FadeEffect_MOVE_FROM_RIGHT, "cover-left" },
+ { FadeEffect_MOVE_FROM_BOTTOM, "cover-up" },
+ { FadeEffect_MOVE_FROM_UPPERLEFT, "cover-right-down" },
+ { FadeEffect_MOVE_FROM_UPPERRIGHT, "cover-left-down" },
+ { FadeEffect_MOVE_FROM_LOWERRIGHT, "cover-left-up" },
+ { FadeEffect_MOVE_FROM_LOWERLEFT, "cover-right-up" },
+
+ { FadeEffect_DISSOLVE, "dissolve" },
+
+ { FadeEffect_RANDOM, "random-transition" },
+
+ { FadeEffect_ROLL_FROM_LEFT, "push-right" },
+ { FadeEffect_ROLL_FROM_TOP, "push-down" },
+ { FadeEffect_ROLL_FROM_RIGHT, "push-left" },
+ { FadeEffect_ROLL_FROM_BOTTOM, "push-up" },
+
+ { FadeEffect_CLOSE_VERTICAL, "split-horizontal-in" },
+ { FadeEffect_CLOSE_HORIZONTAL, "split-vertical-in" },
+ { FadeEffect_OPEN_VERTICAL, "split-horizontal-out" },
+ { FadeEffect_OPEN_HORIZONTAL, "split-vertical-out" },
+
+ { FadeEffect_FADE_FROM_UPPERLEFT, "diagonal-squares-right-down" },
+ { FadeEffect_FADE_FROM_UPPERRIGHT, "diagonal-squares-left-down" },
+ { FadeEffect_FADE_FROM_LOWERLEFT, "diagonal-squares-right-up" },
+ { FadeEffect_FADE_FROM_LOWERRIGHT, "diagonal-squares-left-up" },
+
+// OOo 1.x transitions not in OOo 2.x
+ { FadeEffect_CLOCKWISE, "clock-wipe-twelve" },
+ { FadeEffect_COUNTERCLOCKWISE, "reverse-clock-wipe-twelve" },
+ { FadeEffect_SPIRALIN_LEFT, "spiral-wipe-top-left-clockwise" },
+ { FadeEffect_SPIRALIN_RIGHT, "spiral-wipe-top-right-counter-clockwise" },
+ { FadeEffect_SPIRALOUT_LEFT, "spiral-wipe-out-to-bottom-right-clockwise" },
+ { FadeEffect_SPIRALOUT_RIGHT, "spiral-wipe-out-to-bottom-left-counter-clockwise" },
+ { FadeEffect_WAVYLINE_FROM_LEFT, "snake-wipe-top-left-vertical" },
+ { FadeEffect_WAVYLINE_FROM_TOP, "snake-wipe-top-left-horizontal" },
+ { FadeEffect_WAVYLINE_FROM_RIGHT, "snake-wipe-bottom-right-vertical" },
+ { FadeEffect_WAVYLINE_FROM_BOTTOM, "snake-wipe-bottom-right-horizontal" },
+ { FadeEffect_STRETCH_FROM_LEFT, "wipe-right" }, // todo
+ { FadeEffect_STRETCH_FROM_TOP, "wipe-down" }, // todo
+ { FadeEffect_STRETCH_FROM_RIGHT, "wipe-left" }, // todo
+ { FadeEffect_STRETCH_FROM_BOTTOM, "wipe-up" }, // todo
+
+// OOo 1.x not available transitions
+
+ { FadeEffect_CLOCKWISE, "wheel-clockwise-2-spokes" },
+ { FadeEffect_CLOCKWISE, "wheel-clockwise-3-spokes" },
+ { FadeEffect_CLOCKWISE, "wheel-clockwise-4-spokes" },
+ { FadeEffect_CLOCKWISE, "wheel-clockwise-8-spokes" },
+
+ { FadeEffect_FADE_FROM_CENTER, "shape-circle" },
+ { FadeEffect_FADE_FROM_CENTER, "shape-diamond" },
+ { FadeEffect_FADE_FROM_CENTER, "shape-plus" },
+
+ { FadeEffect_CLOCKWISE, "wedge" },
+
+ { FadeEffect_DISSOLVE, "fade-through-black" },
+
+ { FadeEffect_CLOCKWISE, "zoom-rotate-in" },
+
+ { FadeEffect_HORIZONTAL_LINES, "comb-horizontal" },
+ { FadeEffect_VERTICAL_LINES, "comb-vertical" },
+
+ { FadeEffect_DISSOLVE, "fade-smoothly" },
+
+ { FadeEffect_NONE, nullptr }
+};
+
+/* todo
+cut cut (same as NONE?)
+cut-through-black cut toBlack
+wedge wedge
+*/
+
+void EffectMigration::SetFadeEffect( SdPage* pPage, css::presentation::FadeEffect eNewEffect)
+{
+ deprecated_FadeEffect_conversion_table_entry const * pEntry = deprecated_FadeEffect_conversion_table;
+ while( (pEntry->meFadeEffect != FadeEffect_NONE) && (pEntry->meFadeEffect != eNewEffect) )
+ pEntry++;
+
+ if( pEntry->mpPresetId )
+ {
+ const OUString aPresetId( OUString::createFromAscii( pEntry->mpPresetId ) );
+
+ const TransitionPresetList& rPresetList = TransitionPreset::getTransitionPresetList();
+
+ auto aIt = std::find_if(rPresetList.begin(), rPresetList.end(),
+ [&aPresetId](const TransitionPresetPtr& rxPreset) { return rxPreset->getPresetId() == aPresetId; });
+ if (aIt != rPresetList.end())
+ {
+ pPage->setTransitionType( (*aIt)->getTransition() );
+ pPage->setTransitionSubtype( (*aIt)->getSubtype() );
+ pPage->setTransitionDirection( (*aIt)->getDirection() );
+ pPage->setTransitionFadeColor( (*aIt)->getFadeColor() );
+ }
+ }
+ else
+ {
+ pPage->setTransitionType( 0 );
+ pPage->setTransitionSubtype( 0 );
+ pPage->setTransitionDirection( false );
+ pPage->setTransitionFadeColor( 0 );
+ }
+}
+
+FadeEffect EffectMigration::GetFadeEffect( const SdPage* pPage )
+{
+ const TransitionPresetList & rPresetList = TransitionPreset::getTransitionPresetList();
+ auto aIt = std::find_if(rPresetList.begin(), rPresetList.end(),
+ [&pPage](const TransitionPresetPtr& rxPreset) {
+ return (rxPreset->getTransition() == pPage->getTransitionType())
+ && (rxPreset->getSubtype() == pPage->getTransitionSubtype())
+ && (rxPreset->getDirection() == pPage->getTransitionDirection())
+ && (rxPreset->getFadeColor() == pPage->getTransitionFadeColor());
+ });
+ if (aIt != rPresetList.end())
+ {
+ const OUString& aPresetId = (*aIt)->getPresetId();
+
+ deprecated_FadeEffect_conversion_table_entry const * pEntry = deprecated_FadeEffect_conversion_table;
+ while( (pEntry->meFadeEffect != FadeEffect_NONE) && (!aPresetId.equalsAscii( pEntry->mpPresetId ) ) )
+ pEntry++;
+
+ return pEntry->meFadeEffect;
+ }
+ return FadeEffect_NONE;
+}
+
+namespace {
+
+struct deprecated_AnimationEffect_conversion_table_entry
+{
+ AnimationEffect meEffect;
+ const char* mpPresetId;
+ const char* mpPresetSubType;
+};
+
+}
+
+deprecated_AnimationEffect_conversion_table_entry const deprecated_AnimationEffect_conversion_table[] =
+{
+// OOo 1.x entrance effects
+ { AnimationEffect_APPEAR, "ooo-entrance-appear",nullptr },
+
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-box","in" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-box","out" },
+
+ { AnimationEffect_VERTICAL_CHECKERBOARD, "ooo-entrance-checkerboard","downward" },
+ { AnimationEffect_HORIZONTAL_CHECKERBOARD, "ooo-entrance-checkerboard","across" },
+
+ { AnimationEffect_FADE_FROM_UPPERLEFT, "ooo-entrance-diagonal-squares","right-to-bottom" },
+ { AnimationEffect_FADE_FROM_UPPERRIGHT, "ooo-entrance-diagonal-squares","left-to-bottom" },
+ { AnimationEffect_FADE_FROM_LOWERLEFT, "ooo-entrance-diagonal-squares","right-to-top" },
+ { AnimationEffect_FADE_FROM_LOWERRIGHT, "ooo-entrance-diagonal-squares","left-to-top" },
+
+ { AnimationEffect_DISSOLVE, "ooo-entrance-dissolve-in",nullptr },
+
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-fly-in","from-left" },
+ { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-fly-in","from-top" },
+ { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-fly-in","from-right" },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-fly-in","from-bottom" },
+ { AnimationEffect_MOVE_FROM_UPPERLEFT, "ooo-entrance-fly-in","from-top-left" },
+ { AnimationEffect_MOVE_FROM_UPPERRIGHT, "ooo-entrance-fly-in","from-top-right" },
+ { AnimationEffect_MOVE_FROM_LOWERRIGHT, "ooo-entrance-fly-in","from-bottom-right" },
+ { AnimationEffect_MOVE_FROM_LOWERLEFT, "ooo-entrance-fly-in","from-bottom-left" },
+
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-fly-in-slow", "from-bottom" },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-fly-in-slow", "from-left" },
+ { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-fly-in-slow", "from-right" },
+ { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-fly-in-slow", "from-top" },
+
+ { AnimationEffect_MOVE_SHORT_FROM_LEFT, "ooo-entrance-peek-in","from-left" },
+ { AnimationEffect_MOVE_SHORT_FROM_TOP, "ooo-entrance-peek-in","from-top" },
+ { AnimationEffect_MOVE_SHORT_FROM_RIGHT, "ooo-entrance-peek-in","from-right" },
+ { AnimationEffect_MOVE_SHORT_FROM_BOTTOM, "ooo-entrance-peek-in","from-bottom" },
+
+ { AnimationEffect_VERTICAL_LINES, "ooo-entrance-random-bars","horizontal" },
+ { AnimationEffect_HORIZONTAL_LINES, "ooo-entrance-random-bars","vertical" },
+
+ { AnimationEffect_RANDOM, "ooo-entrance-random",nullptr },
+
+ { AnimationEffect_CLOSE_VERTICAL, "ooo-entrance-split","horizontal-in" },
+ { AnimationEffect_CLOSE_HORIZONTAL, "ooo-entrance-split","vertical-in" },
+ { AnimationEffect_OPEN_VERTICAL, "ooo-entrance-split","horizontal-out" },
+ { AnimationEffect_OPEN_HORIZONTAL, "ooo-entrance-split","vertical-out" },
+
+ { AnimationEffect_VERTICAL_STRIPES, "ooo-entrance-venetian-blinds","horizontal" },
+ { AnimationEffect_HORIZONTAL_STRIPES, "ooo-entrance-venetian-blinds","vertical" },
+
+ { AnimationEffect_FADE_FROM_LEFT, "ooo-entrance-wipe","from-left" },
+ { AnimationEffect_FADE_FROM_TOP, "ooo-entrance-wipe","from-bottom" },
+ { AnimationEffect_FADE_FROM_RIGHT, "ooo-entrance-wipe","from-right" },
+ { AnimationEffect_FADE_FROM_BOTTOM, "ooo-entrance-wipe","from-top" },
+
+ { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-swivel","vertical" },
+ { AnimationEffect_VERTICAL_ROTATE, "ooo-entrance-swivel","horizontal" },
+
+ { AnimationEffect_STRETCH_FROM_LEFT, "ooo-entrance-stretchy","from-left" },
+ { AnimationEffect_STRETCH_FROM_UPPERLEFT, "ooo-entrance-stretchy","from-top-left" },
+ { AnimationEffect_STRETCH_FROM_TOP, "ooo-entrance-stretchy","from-top" },
+ { AnimationEffect_STRETCH_FROM_UPPERRIGHT, "ooo-entrance-stretchy","from-top-right" },
+ { AnimationEffect_STRETCH_FROM_RIGHT, "ooo-entrance-stretchy","from-right" },
+ { AnimationEffect_STRETCH_FROM_LOWERRIGHT, "ooo-entrance-stretchy","from-bottom-right" },
+ { AnimationEffect_STRETCH_FROM_BOTTOM, "ooo-entrance-stretchy","from-bottom" },
+ { AnimationEffect_STRETCH_FROM_LOWERLEFT, "ooo-entrance-stretchy","from-bottom-left" },
+
+ { AnimationEffect_HORIZONTAL_STRETCH, "ooo-entrance-expand", nullptr },
+
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel","1" },
+ { AnimationEffect_COUNTERCLOCKWISE, "ooo-entrance-clock-wipe","counter-clockwise" },
+
+ { AnimationEffect_SPIRALIN_LEFT, "ooo-entrance-spiral-wipe", "from-top-left-clockwise" },
+ { AnimationEffect_SPIRALIN_RIGHT, "ooo-entrance-spiral-wipe", "from-top-right-counter-clockwise" },
+ { AnimationEffect_SPIRALOUT_LEFT, "ooo-entrance-spiral-wipe", "from-center-clockwise" },
+ { AnimationEffect_SPIRALOUT_RIGHT, "ooo-entrance-spiral-wipe", "from-center-counter-clockwise" },
+
+ { AnimationEffect_WAVYLINE_FROM_LEFT, "ooo-entrance-snake-wipe","from-top-left-vertical" },
+ { AnimationEffect_WAVYLINE_FROM_TOP, "ooo-entrance-snake-wipe","from-top-left-horizontal" },
+ { AnimationEffect_WAVYLINE_FROM_RIGHT, "ooo-entrance-snake-wipe","from-bottom-right-vertical" },
+ { AnimationEffect_WAVYLINE_FROM_BOTTOM, "ooo-entrance-snake-wipe","from-bottom-right-horizontal" },
+
+// ooo 1.x exit effects
+ { AnimationEffect_HIDE, "ooo-exit-disappear",nullptr },
+ { AnimationEffect_MOVE_TO_LEFT, "ooo-exit-fly-out", "from-right" },
+ { AnimationEffect_MOVE_TO_TOP, "ooo-exit-fly-out", "from-bottom" },
+ { AnimationEffect_MOVE_TO_RIGHT, "ooo-exit-fly-out", "from-left" },
+ { AnimationEffect_MOVE_TO_BOTTOM, "ooo-exit-fly-out", "from-top" },
+ { AnimationEffect_MOVE_TO_UPPERLEFT, "ooo-exit-fly-out", "from-top-right" },
+ { AnimationEffect_MOVE_TO_UPPERRIGHT, "ooo-exit-fly-out", "from-top-left" },
+ { AnimationEffect_MOVE_TO_LOWERRIGHT, "ooo-exit-fly-out", "from-bottom-left" },
+ { AnimationEffect_MOVE_TO_LOWERLEFT, "ooo-exit-fly-out", "from-bottom-right" },
+ { AnimationEffect_MOVE_SHORT_TO_LEFT, "ooo-exit-peek-out", "from-right" },
+ { AnimationEffect_MOVE_SHORT_TO_UPPERLEFT, "ooo-exit-peek-out", "from-right" },
+ { AnimationEffect_MOVE_SHORT_TO_TOP, "ooo-exit-peek-out", "from-bottom" },
+ { AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT, "ooo-exit-peek-out", "from-bottom" },
+ { AnimationEffect_MOVE_SHORT_TO_RIGHT, "ooo-exit-peek-out", "from-left" },
+ { AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT, "ooo-exit-peek-out","from-left" },
+ { AnimationEffect_MOVE_SHORT_TO_BOTTOM, "ooo-exit-peek-out", "from-top" },
+ { AnimationEffect_MOVE_SHORT_TO_LOWERLEFT, "ooo-exit-peek-out", "from-top" },
+
+// no matching in OOo 2.x
+ { AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT, "ooo-entrance-peek-in","from-left" },
+ { AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT, "ooo-entrance-peek-in","from-top" },
+ { AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT, "ooo-entrance-peek-in","from-right" },
+ { AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT, "ooo-entrance-peek-in","from-bottom" },
+ { AnimationEffect_LASER_FROM_LEFT, "ooo-entrance-fly-in","from-left" },
+ { AnimationEffect_LASER_FROM_TOP, "ooo-entrance-fly-in","from-top" },
+ { AnimationEffect_LASER_FROM_RIGHT, "ooo-entrance-fly-in","from-right" },
+ { AnimationEffect_LASER_FROM_BOTTOM, "ooo-entrance-fly-in","from-bottom" },
+ { AnimationEffect_LASER_FROM_UPPERLEFT, "ooo-entrance-fly-in","from-top-left" },
+ { AnimationEffect_LASER_FROM_UPPERRIGHT, "ooo-entrance-fly-in","from-top-right" },
+ { AnimationEffect_LASER_FROM_LOWERLEFT, "ooo-entrance-fly-in","from-bottom-left" },
+ { AnimationEffect_LASER_FROM_LOWERRIGHT, "ooo-entrance-fly-in","from-bottom-right" },
+
+// no matching in OOo 1.x
+
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-circle", "in" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-circle", "out" },
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-diamond", "in" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-diamond", "out" },
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-plus", "in" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-plus", "out" },
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wedge", nullptr },
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "2" },
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "3" },
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "4" },
+ { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "8" },
+
+ { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-boomerang", nullptr },
+ { AnimationEffect_MOVE_FROM_UPPERRIGHT, "ooo-entrance-bounce", nullptr },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-curve-up", nullptr },
+ { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-float", nullptr },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-glide", nullptr },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-magnify", nullptr },
+ { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-pinwheel", nullptr },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-breaks", nullptr },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-sling", nullptr },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-spiral-in", nullptr },
+ { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-thread", nullptr },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-ascend", nullptr },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-center-revolve", nullptr },
+ { AnimationEffect_APPEAR, "ooo-entrance-compress", nullptr },
+ { AnimationEffect_MOVE_SHORT_FROM_TOP, "ooo-entrance-descend", nullptr },
+ { AnimationEffect_MOVE_SHORT_FROM_LEFT, "ooo-entrance-ease-in", nullptr },
+ { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-rise-up", nullptr },
+ { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-spin-in", nullptr },
+ { AnimationEffect_STRETCH_FROM_LEFT, "ooo-entrance-stretchy", "across" },
+ { AnimationEffect_STRETCH_FROM_TOP, "ooo-entrance-stretchy", "downward" },
+
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in-slightly" },
+ { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in-from-screen-center" },
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out" },
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out-slightly" },
+ { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out-from-screen-center" },
+
+ { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in", nullptr },
+ { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in-and-zoom", nullptr },
+ { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in-and-swivel", nullptr },
+
+ // still open (no matching effect: AnimationEffect_ZOOM_IN_FROM_*,
+ // AnimationEffect_ZOOM_OUT_FROM_*, AnimationEffect_PATH
+
+ { AnimationEffect_NONE, nullptr, nullptr }
+};
+
+static EffectSequence::iterator ImplFindEffect( MainSequencePtr const & pMainSequence, const Reference< XShape >& rShape, sal_Int16 nSubItem )
+{
+ return std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&rShape, &nSubItem](const CustomAnimationEffectPtr& pEffect) {
+ return (pEffect->getTargetShape() == rShape)
+ && (pEffect->getTargetSubItem() == nSubItem);
+ });
+}
+
+static bool implIsInsideGroup( SdrObject const * pObj )
+{
+ // TTTT for current state of transition, SdrObject has a parent*
+ // to a SdrObjList. That may be a SdrPage or a SdrObjGroup, both
+ // are already derived from SdrObjList. To finally check, use
+ // the method 'getSdrObjectFromSdrObjList' - if it's not a SdrPage,
+ // it will return SdrObjGroup or E3dScene -> SdrObject.
+ // For future states, test for SdrObject. Trying to get the SdrPage
+ // will in the future depend on the Object(this) to be inserted to a
+ // SdrPage, regardless of e.g. being a group member.
+ if(nullptr == pObj)
+ {
+ return false;
+ }
+
+ SdrObjList* pSdrObjList(pObj->getParentSdrObjListFromSdrObject());
+
+ if(nullptr == pSdrObjList)
+ {
+ return false;
+ }
+
+ return (nullptr != pSdrObjList->getSdrObjectFromSdrObjList());
+}
+
+void EffectMigration::SetAnimationEffect( SvxShape* pShape, AnimationEffect eEffect )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ OUString aPresetId;
+ OUString aPresetSubType;
+
+ if( !ConvertAnimationEffect( eEffect, aPresetId, aPresetSubType ) )
+ {
+ OSL_FAIL( "sd::EffectMigration::SetAnimationEffect(), no mapping for given AnimationEffect value" );
+ return;
+ }
+
+ const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets();
+
+ CustomAnimationPresetPtr pPreset( rPresets.getEffectDescriptor( aPresetId ) );
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ if( !(pPreset && pMainSequence) )
+ return;
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIterOnlyBackground( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
+ EffectSequence::iterator aIterAsWhole( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::AS_WHOLE ) );
+ const EffectSequence::iterator aEnd( pMainSequence->getEnd() );
+
+ if( (aIterOnlyBackground == aEnd) && (aIterAsWhole == aEnd) )
+ {
+ bool bEffectCreated = false;
+
+ // check if there is already a text effect for this shape
+ EffectSequence::iterator aIterOnlyText( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
+ if( aIterOnlyText != aEnd )
+ {
+ // check if this is an animation text group
+ sal_Int32 nGroupId = (*aIterOnlyText)->getGroupId();
+ if( nGroupId >= 0 )
+ {
+ CustomAnimationTextGroupPtr pGroup = pMainSequence->findGroup( nGroupId );
+ if( pGroup )
+ {
+ // add an effect to animate the shape
+ pMainSequence->setAnimateForm( pGroup, true );
+
+ // find this effect
+ EffectSequence::iterator aIter( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
+
+ if( aIter != aEnd )
+ {
+ if( ((*aIter)->getPresetId() != aPresetId) ||
+ ((*aIter)->getPresetSubType() != aPresetSubType) )
+ {
+ (*aIter)->replaceNode( pPreset->create( aPresetSubType ) );
+ pMainSequence->rebuild();
+ bEffectCreated = true;
+ }
+ }
+ }
+ }
+ }
+
+ if( !bEffectCreated )
+ {
+ // if there is not yet an effect that target this shape, we generate one
+ // we insert the shape effect before it
+ Reference< XAnimationNode > xNode( pPreset->create( aPresetSubType ) );
+ DBG_ASSERT( xNode.is(), "EffectMigration::SetAnimationEffect(), could not create preset!" );
+ if( xNode.is() )
+ {
+ CustomAnimationEffectPtr pEffect = std::make_shared<CustomAnimationEffect>( xNode );
+ pEffect->setTarget( Any( xShape ) );
+ SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
+ const bool bManual = (pPage == nullptr) || (pPage->GetPresChange() == PresChange::Manual);
+ if( !bManual )
+ pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
+
+ pMainSequence->append( pEffect );
+
+ if( ( pObj->GetObjInventor() == SdrInventor::Default ) && ( pObj->GetObjIdentifier() == SdrObjKind::OutlineText ) )
+ {
+ // special case for outline text, effects are always mapped to text group effect
+ pMainSequence->
+ createTextGroup( pEffect, 10, bManual ? -1 : 0.0, false, false );
+ }
+ }
+ }
+ }
+ else
+ {
+ // if there is already an effect targeting this shape
+ // just replace it
+ CustomAnimationEffectPtr pEffect;
+ if( aIterAsWhole != aEnd )
+ {
+ pEffect = *aIterAsWhole;
+ }
+ else
+ {
+ pEffect = *aIterOnlyBackground;
+ }
+
+ if( pEffect )
+ {
+ if( (pEffect->getPresetId() != aPresetId) ||
+ (pEffect->getPresetSubType() != aPresetSubType) )
+ {
+ pMainSequence->replace( pEffect, pPreset, aPresetSubType, -1.0 );
+ }
+ }
+ }
+}
+
+AnimationEffect EffectMigration::GetAnimationEffect( SvxShape* pShape )
+{
+ OUString aPresetId;
+ OUString aPresetSubType;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ if( pMainSequence )
+ {
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&xShape](const CustomAnimationEffectPtr& pEffect) {
+ return (pEffect->getTargetShape() == xShape)
+ && ((pEffect->getTargetSubItem() == ShapeAnimationSubType::ONLY_BACKGROUND)
+ || (pEffect->getTargetSubItem() == ShapeAnimationSubType::AS_WHOLE))
+ && (pEffect->getDuration() != 0.1); // ignore appear effects created from old text effect import
+ });
+
+ if (aIter != pMainSequence->getEnd())
+ {
+ aPresetId = (*aIter)->getPresetId();
+ aPresetSubType = (*aIter)->getPresetSubType();
+ }
+ }
+
+ // now find old effect
+ AnimationEffect eEffect = AnimationEffect_NONE;
+
+ if( !ConvertPreset( aPresetId, &aPresetSubType, eEffect ) )
+ ConvertPreset( aPresetId, nullptr, eEffect );
+
+ return eEffect;
+}
+
+void EffectMigration::SetTextAnimationEffect( SvxShape* pShape, AnimationEffect eEffect )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ // first map the deprecated AnimationEffect to a preset and subtype
+ OUString aPresetId;
+ OUString aPresetSubType;
+
+ if( !ConvertAnimationEffect( eEffect, aPresetId, aPresetSubType ) )
+ {
+ OSL_FAIL( "sd::EffectMigration::SetAnimationEffect(), no mapping for given AnimationEffect value" );
+ return;
+ }
+
+ SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
+
+ // ignore old text effects on shape without text
+ if( (pTextObj == nullptr) || (!pTextObj->HasText()) )
+ return;
+
+ const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets();
+
+ // create an effect from this preset
+ CustomAnimationPresetPtr pPreset( rPresets.getEffectDescriptor( aPresetId ) );
+
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ if( !(pPreset && pMainSequence) )
+ return;
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIterOnlyText( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
+ const EffectSequence::iterator aEnd( pMainSequence->getEnd() );
+
+ CustomAnimationTextGroupPtr pGroup;
+
+ // is there already an animation text group for this shape?
+ if( aIterOnlyText != aEnd )
+ {
+ const sal_Int32 nGroupId = (*aIterOnlyText)->getGroupId();
+ if( nGroupId >= 0 )
+ pGroup = pMainSequence->findGroup( nGroupId );
+ }
+
+ // if there is not yet a group, create it
+ if( !pGroup )
+ {
+ CustomAnimationEffectPtr pShapeEffect;
+
+ EffectSequence::iterator aIterOnlyBackground( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
+ if( aIterOnlyBackground != aEnd )
+ {
+ pShapeEffect = *aIterOnlyBackground;
+ }
+ else
+ {
+ EffectSequence::iterator aIterAsWhole( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::AS_WHOLE ) );
+ if( aIterAsWhole != aEnd )
+ {
+ pShapeEffect = *aIterAsWhole;
+ }
+ else
+ {
+ Reference< XAnimationNode > xNode( pPreset->create( "" ) );
+ DBG_ASSERT( xNode.is(), "EffectMigration::SetTextAnimationEffect(), could not create preset!" );
+ if( xNode.is() )
+ {
+ pShapeEffect = std::make_shared<CustomAnimationEffect>( xNode );
+ pShapeEffect->setTarget( Any( xShape ) );
+ pShapeEffect->setDuration( 0.1 );
+ pMainSequence->append( pShapeEffect );
+
+ SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
+ if( pPage && pPage->GetPresChange() != PresChange::Manual )
+ pShapeEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
+ }
+ }
+ }
+
+ if( pShapeEffect )
+ {
+ SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
+ const bool bManual = (pPage == nullptr) || (pPage->GetPresChange() == PresChange::Manual);
+
+ // now create effects for each paragraph
+ pGroup =
+ pMainSequence->
+ createTextGroup( pShapeEffect, 10, bManual ? -1 : 0.0, true, false );
+ }
+ }
+
+ if( pGroup )
+ {
+ const bool bLaserEffect = (eEffect >= AnimationEffect_LASER_FROM_LEFT) && (eEffect <= AnimationEffect_LASER_FROM_LOWERRIGHT);
+
+ // now we have a group, so check if all effects are same as we like to have them
+ const EffectSequence& rEffects = pGroup->getEffects();
+
+ for( auto& rxEffect : rEffects )
+ {
+ // only work on paragraph targets
+ if( rxEffect->getTarget().getValueType() == ::cppu::UnoType<ParagraphTarget>::get() )
+ {
+ if( (rxEffect->getPresetId() != aPresetId) ||
+ (rxEffect->getPresetSubType() != aPresetSubType) )
+ {
+ rxEffect->replaceNode( pPreset->create( aPresetSubType ) );
+ }
+
+ if( bLaserEffect )
+ {
+ rxEffect->setIterateType( TextAnimationType::BY_LETTER );
+ rxEffect->setIterateInterval( 0.5 );// TODO:
+ // Determine
+ // interval
+ // according
+ // to
+ // total
+ // effect
+ // duration
+ }
+ }
+ }
+ }
+ pMainSequence->rebuild();
+}
+
+AnimationEffect EffectMigration::GetTextAnimationEffect( SvxShape* pShape )
+{
+ OUString aPresetId;
+ OUString aPresetSubType;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( pObj )
+ {
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ if( pMainSequence )
+ {
+ const Reference< XShape > xShape( pShape );
+ EffectSequence::iterator aIter( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
+ if( aIter != pMainSequence->getEnd() )
+ {
+ aPresetId = (*aIter)->getPresetId();
+ aPresetSubType = (*aIter)->getPresetSubType();
+ }
+ }
+ }
+
+ // now find old effect
+ AnimationEffect eEffect = AnimationEffect_NONE;
+
+ if( !ConvertPreset( aPresetId, &aPresetSubType, eEffect ) )
+ ConvertPreset( aPresetId, nullptr, eEffect );
+
+ return eEffect;
+}
+
+bool EffectMigration::ConvertPreset( std::u16string_view rPresetId, const OUString* pPresetSubType, AnimationEffect& rEffect )
+{
+ rEffect = AnimationEffect_NONE;
+ if( !rPresetId.empty() )
+ {
+ // first try a match for preset id and subtype
+ deprecated_AnimationEffect_conversion_table_entry const * p = deprecated_AnimationEffect_conversion_table;
+ while( p->mpPresetId )
+ {
+ if( o3tl::equalsAscii( rPresetId, p->mpPresetId ) &&
+ (( p->mpPresetSubType == nullptr ) ||
+ ( pPresetSubType == nullptr) ||
+ ( pPresetSubType->equalsAscii( p->mpPresetSubType )) ) )
+ {
+ rEffect = p->meEffect;
+ return true;
+ }
+ p++;
+ }
+ return false;
+ }
+ else
+ {
+ // empty preset id means AnimationEffect_NONE
+ return true;
+ }
+}
+
+bool EffectMigration::ConvertAnimationEffect( const AnimationEffect& rEffect, OUString& rPresetId, OUString& rPresetSubType )
+{
+ deprecated_AnimationEffect_conversion_table_entry const * p = deprecated_AnimationEffect_conversion_table;
+ while( p->mpPresetId )
+ {
+ if( p->meEffect == rEffect )
+ {
+ rPresetId = OUString::createFromAscii( p->mpPresetId );
+ rPresetSubType = OUString::createFromAscii( p->mpPresetSubType );
+ return true;
+ }
+ p++;
+ }
+
+ return false;
+}
+
+double EffectMigration::ConvertAnimationSpeed( AnimationSpeed eSpeed )
+{
+ double fDuration;
+ switch( eSpeed )
+ {
+ case AnimationSpeed_SLOW: fDuration = 2.0; break;
+ case AnimationSpeed_FAST: fDuration = 0.5; break;
+ default:
+ fDuration = 1.0; break;
+ }
+ return fDuration;
+}
+
+void EffectMigration::SetAnimationSpeed( SvxShape* pShape, AnimationSpeed eSpeed )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ double fDuration = ConvertAnimationSpeed( eSpeed );
+
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+ bool bNeedRebuild = false;
+
+ for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ if( pEffect->getDuration() != 0.1 )
+ pEffect->setDuration( fDuration );
+ bNeedRebuild = true;
+ }
+ }
+
+ if( bNeedRebuild )
+ pMainSequence->rebuild();
+}
+
+AnimationSpeed EffectMigration::GetAnimationSpeed( SvxShape* pShape )
+{
+ SdrObject* pObj = pShape->GetSdrObject();
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ double fDuration = 1.0;
+
+ EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&xShape](const CustomAnimationEffectPtr& pEffect) {
+ return (pEffect->getTargetShape() == xShape)
+ && (pEffect->getDuration() != 0.1);
+ });
+ if (aIter != pMainSequence->getEnd())
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ fDuration = pEffect->getDuration();
+ }
+
+ return ConvertDuration( fDuration );
+}
+
+AnimationSpeed EffectMigration::ConvertDuration( double fDuration )
+{
+ AnimationSpeed eSpeed;
+
+ if( fDuration < 1.0 )
+ eSpeed = AnimationSpeed_FAST;
+ else if( fDuration > 1.5 )
+ eSpeed = AnimationSpeed_SLOW;
+ else
+ eSpeed = AnimationSpeed_MEDIUM;
+
+ return eSpeed;
+}
+
+void EffectMigration::SetDimColor( SvxShape* pShape, sal_Int32 nColor )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+ bool bNeedRebuild = false;
+
+ for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ pEffect->setHasAfterEffect( true );
+ pEffect->setDimColor( Any( nColor ) );
+ pEffect->setAfterEffectOnNext( true );
+ bNeedRebuild = true;
+ }
+ }
+
+ if( bNeedRebuild )
+ pMainSequence->rebuild();
+}
+
+sal_Int32 EffectMigration::GetDimColor( SvxShape* pShape )
+{
+ sal_Int32 nColor = 0;
+ if( pShape )
+ {
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( pObj && pObj->getSdrPageFromSdrObject() )
+ {
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+ EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&xShape](const CustomAnimationEffectPtr& pEffect) {
+ return (pEffect->getTargetShape() == xShape)
+ && pEffect->getDimColor().hasValue()
+ && pEffect->hasAfterEffect();
+ });
+ if (aIter != pMainSequence->getEnd())
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ pEffect->getDimColor() >>= nColor;
+ }
+ }
+ }
+
+ return nColor;
+}
+
+void EffectMigration::SetDimHide( SvxShape* pShape, bool bDimHide )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+ bool bNeedRebuild = false;
+
+ for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ pEffect->setHasAfterEffect( bDimHide );
+ if( bDimHide ) {
+ Any aEmpty;
+ pEffect->setDimColor( aEmpty );
+ }
+ pEffect->setAfterEffectOnNext( false );
+ bNeedRebuild = true;
+ }
+ }
+
+ if( bNeedRebuild )
+ pMainSequence->rebuild();
+}
+
+bool EffectMigration::GetDimHide( SvxShape* pShape )
+{
+ bool bRet = false;
+ if( pShape )
+ {
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( pObj && pObj->getSdrPageFromSdrObject() )
+ {
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&xShape](const CustomAnimationEffectPtr& pEffect) { return pEffect->getTargetShape() == xShape; });
+ if (aIter != pMainSequence->getEnd())
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ bRet = pEffect->hasAfterEffect() &&
+ !pEffect->getDimColor().hasValue() &&
+ (!pEffect->IsAfterEffectOnNext());
+ }
+ }
+ }
+
+ return bRet;
+}
+
+void EffectMigration::SetDimPrevious( SvxShape* pShape, bool bDimPrevious )
+{
+ DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
+ "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( implIsInsideGroup( pObj ) )
+ return;
+
+ Any aColor;
+
+ if( bDimPrevious )
+ aColor <<= COL_LIGHTGRAY;
+
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+ bool bNeedRebuild = false;
+
+ for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ pEffect->setHasAfterEffect( bDimPrevious );
+ if( !bDimPrevious || !pEffect->getDimColor().hasValue() )
+ pEffect->setDimColor( aColor );
+ pEffect->setAfterEffectOnNext( true );
+ bNeedRebuild = true;
+ }
+ }
+
+ if( bNeedRebuild )
+ pMainSequence->rebuild();
+}
+
+bool EffectMigration::GetDimPrevious( SvxShape* pShape )
+{
+ bool bRet = false;
+ if( pShape )
+ {
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( pObj && pObj->getSdrPageFromSdrObject() )
+ {
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
+ [&xShape](const CustomAnimationEffectPtr& pEffect) { return pEffect->getTargetShape() == xShape; });
+ if (aIter != pMainSequence->getEnd())
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ bRet = pEffect->hasAfterEffect() &&
+ pEffect->getDimColor().hasValue() &&
+ pEffect->IsAfterEffectOnNext();
+ }
+ }
+ }
+
+ return bRet;
+}
+
+void EffectMigration::SetPresentationOrder( SvxShape* pShape, sal_Int32 nNewPos )
+{
+ if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ EffectSequence& rSequence = pMainSequence->getSequence();
+ sal_Int32 nPos;
+ sal_Int32 nCurrentPos = -1;
+ std::vector< std::vector< EffectSequence::iterator > > aEffectVector(1);
+
+ if( !rSequence.empty() )
+ {
+ Reference< XShape > xThis( pShape );
+ Reference< XShape > xCurrent;
+
+ EffectSequence::iterator aIter( rSequence.begin() );
+ EffectSequence::iterator aEnd( rSequence.end() );
+ for( nPos = 0; aIter != aEnd; ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect = *aIter;
+
+ if( !xCurrent.is() )
+ {
+ xCurrent = pEffect->getTargetShape();
+ }
+ else if( pEffect->getTargetShape() != xCurrent )
+ {
+ nPos++;
+ xCurrent = pEffect->getTargetShape();
+ aEffectVector.resize( nPos+1 );
+ }
+
+ // is this the first effect for xThis shape?
+ if(( nCurrentPos == -1 ) && ( xCurrent == xThis ) )
+ {
+ nCurrentPos = nPos;
+ }
+
+ aEffectVector[nPos].push_back( aIter );
+ }
+ }
+
+ // check if there is at least one effect for xThis
+ if( nCurrentPos == -1 )
+ {
+ OSL_FAIL("sd::EffectMigration::SetPresentationOrder() failed cause this shape has no effect" );
+ return;
+ }
+
+ // check trivial case
+ if( nCurrentPos == nNewPos )
+ return;
+
+ std::vector< CustomAnimationEffectPtr > aEffects;
+
+ for( const auto& rIter : aEffectVector[nCurrentPos] )
+ {
+ aEffects.push_back( *rIter );
+ rSequence.erase( rIter );
+ }
+
+ if( nNewPos > nCurrentPos )
+ nNewPos++;
+
+ if( nNewPos == static_cast<sal_Int32>(aEffectVector.size()) )
+ {
+ rSequence.insert( rSequence.end(), aEffects.begin(), aEffects.end() );
+ }
+ else
+ {
+ EffectSequence::iterator aPos( aEffectVector[nNewPos][0] );
+ for( const auto& rEffect : aEffects )
+ {
+ rSequence.insert( aPos, rEffect );
+ }
+ }
+}
+
+/** Returns the position of the given SdrObject in the Presentation order.
+ * This function returns -1 if the SdrObject is not in the Presentation order
+ * or if it's the path-object.
+ */
+sal_Int32 EffectMigration::GetPresentationOrder( SvxShape* pShape )
+{
+ sal_Int32 nPos = -1, nFound = -1;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ EffectSequence& rSequence = pMainSequence->getSequence();
+
+ Reference< XShape > xThis( pShape );
+ Reference< XShape > xCurrent;
+
+ for( const CustomAnimationEffectPtr& pEffect : rSequence )
+ {
+ if( !xCurrent.is() || pEffect->getTargetShape() != xCurrent )
+ {
+ nPos++;
+ xCurrent = pEffect->getTargetShape();
+
+ // is this the first effect for xThis shape?
+ if( xCurrent == xThis )
+ {
+ nFound = nPos;
+ break;
+ }
+ }
+ }
+
+ return nFound;
+}
+
+void EffectMigration::UpdateSoundEffect( SvxShape* pShape, SdAnimationInfo const * pInfo )
+{
+ if( !pInfo )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+ bool bNeedRebuild = false;
+
+ OUString aSoundFile;
+ if( pInfo->mbSoundOn )
+ aSoundFile = pInfo->maSoundFile;
+
+ for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ if( !aSoundFile.isEmpty() )
+ {
+ pEffect->createAudio( Any( aSoundFile ) );
+ }
+ else
+ {
+ pEffect->removeAudio();
+ }
+ bNeedRebuild = true;
+ }
+ }
+
+ if( bNeedRebuild )
+ pMainSequence->rebuild();
+}
+
+OUString EffectMigration::GetSoundFile( SvxShape* pShape )
+{
+ OUString aSoundFile;
+
+ if( pShape )
+ {
+ SdrObject* pObj = pShape->GetSdrObject();
+ if( pObj && pObj->getSdrPageFromSdrObject() )
+ {
+ sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
+
+ const Reference< XShape > xShape( pShape );
+
+ EffectSequence::iterator aIter;
+
+ for( aIter = pMainSequence->getBegin();
+ (aSoundFile.isEmpty()) && (aIter != pMainSequence->getEnd());
+ ++aIter )
+ {
+ CustomAnimationEffectPtr pEffect( *aIter );
+ if( pEffect->getTargetShape() == xShape )
+ {
+ if( pEffect->getAudio().is() )
+ pEffect->getAudio()->getSource() >>= aSoundFile;
+ }
+ }
+ }
+ }
+ return aSoundFile;
+}
+
+bool EffectMigration::GetSoundOn( SvxShape* pShape )
+{
+ return !GetSoundFile( pShape ).isEmpty();
+}
+
+void EffectMigration::SetAnimationPath( SvxShape* pShape, SdrPathObj const * pPathObj )
+{
+ if( !(pShape && pPathObj) )
+ return;
+
+ SdrObject* pObj = pShape->GetSdrObject();
+
+ if( pObj )
+ {
+ const Reference< XShape > xShape( pShape );
+ SdPage* pPage = dynamic_cast< SdPage* >(pPathObj->getSdrPageFromSdrObject());
+ if( pPage )
+ {
+ std::shared_ptr< sd::MainSequence > pMainSequence( pPage->getMainSequence() );
+ if( pMainSequence )
+ pMainSequence->append( *pPathObj, Any( xShape ), -1.0, "" );
+ }
+ }
+}
+
+// #i42894# helper which creates the needed XAnimate for changing visibility and all the (currently) needed embeddings
+static void createVisibilityOnOffNode(Reference< XTimeContainer > const & rxParentContainer, SdrObject& rCandidate, bool bVisible, bool bOnClick, double fDuration)
+{
+ Reference< XMultiServiceFactory > xMsf(::comphelper::getProcessServiceFactory());
+
+ // create par container node
+ Reference< XAnimationNode > xOuterSeqTimeContainer(xMsf->createInstance("com.sun.star.animations.ParallelTimeContainer"), UNO_QUERY_THROW);
+
+ // set begin
+ xOuterSeqTimeContainer->setBegin(Any(0.0));
+
+ // set fill
+ xOuterSeqTimeContainer->setFill(AnimationFill::HOLD);
+
+ // set named values
+ Sequence< NamedValue > aUserDataSequence{
+ { /* Name */ "node-type",
+ /* Value */ Any(bOnClick ? EffectNodeType::ON_CLICK : EffectNodeType::AFTER_PREVIOUS) }
+ };
+
+ xOuterSeqTimeContainer->setUserData(aUserDataSequence);
+
+ // create animate set to change visibility for rCandidate
+ Reference< XAnimationNode > xAnimateSetForLast(xMsf->createInstance("com.sun.star.animations.AnimateSet"), UNO_QUERY_THROW);
+
+ // set begin
+ xAnimateSetForLast->setBegin(Any(0.0));
+
+ // set duration
+ xAnimateSetForLast->setDuration(Any(fDuration));
+
+ // set fill
+ xAnimateSetForLast->setFill(AnimationFill::HOLD);
+
+ // set target
+ Reference< XAnimate > xAnimate(xAnimateSetForLast, UNO_QUERY);
+ Reference< XShape > xTargetShape(rCandidate.getUnoShape(), UNO_QUERY);
+ xAnimate->setTarget(Any(xTargetShape));
+
+ // set AttributeName
+ xAnimate->setAttributeName("Visibility");
+
+ // set attribute value
+ xAnimate->setTo(Any(bVisible));
+
+ // ad set node to par node
+ Reference< XTimeContainer > xParentContainer(xOuterSeqTimeContainer, UNO_QUERY_THROW);
+ xParentContainer->appendChild(xAnimateSetForLast);
+
+ // add node
+ rxParentContainer->appendChild(xOuterSeqTimeContainer);
+}
+
+// #i42894# older native formats supported animated group objects, that means all members of the group
+// were shown animated by showing one after the other. This is no longer supported, but the following
+// fallback will create the needed SMIL animation stuff. Unfortunately the members of the group
+// have to be moved directly to the page, else the (explained to be generic, thus I expected this to
+// work) animations will not work in slideshow
+void EffectMigration::CreateAnimatedGroup(SdrObjGroup const & rGroupObj, SdPage& rPage)
+{
+ // aw080 will give a vector immediately
+ SdrObjListIter aIter(rGroupObj);
+
+ if(!aIter.Count())
+ return;
+
+ std::shared_ptr< sd::MainSequence > pMainSequence(rPage.getMainSequence());
+
+ if(!pMainSequence)
+ return;
+
+ std::vector< SdrObject* > aObjects;
+ aObjects.reserve(aIter.Count());
+
+ while(aIter.IsMore())
+ {
+ // do move to page rough with old/current stuff, will be different in aw080 anyways
+ SdrObject* pCandidate = aIter.Next();
+ rGroupObj.GetSubList()->NbcRemoveObject(pCandidate->GetOrdNum());
+ rPage.NbcInsertObject(pCandidate);
+ aObjects.push_back(pCandidate);
+ }
+
+ // create main node
+ Reference< XMultiServiceFactory > xMsf(::comphelper::getProcessServiceFactory());
+ Reference< XAnimationNode > xOuterSeqTimeContainer(xMsf->createInstance("com.sun.star.animations.ParallelTimeContainer"), UNO_QUERY_THROW);
+
+ // set begin
+ xOuterSeqTimeContainer->setBegin(Any(0.0));
+
+ // prepare parent container
+ Reference< XTimeContainer > xParentContainer(xOuterSeqTimeContainer, UNO_QUERY_THROW);
+
+ // prepare loop over objects
+ SdrObject* pNext = nullptr;
+ const double fDurationShow(0.2);
+ const double fDurationHide(0.001);
+
+ for(size_t a(0); a < aObjects.size(); a++)
+ {
+ SdrObject* pLast = pNext;
+ pNext = aObjects[a];
+
+ // create node
+ if(pLast)
+ {
+ createVisibilityOnOffNode(xParentContainer, *pLast, false, false, fDurationHide);
+ }
+
+ if(pNext)
+ {
+ createVisibilityOnOffNode(xParentContainer, *pNext, true, !a, fDurationShow);
+ }
+ }
+
+ // create end node
+ if(pNext)
+ {
+ createVisibilityOnOffNode(xParentContainer, *pNext, false, false, fDurationHide);
+ }
+
+ // add to main sequence and rebuild
+ pMainSequence->createEffects(xOuterSeqTimeContainer);
+ pMainSequence->rebuild();
+}
+
+void EffectMigration::DocumentLoaded(SdDrawDocument & rDoc)
+{
+ if (DocumentType::Draw == rDoc.GetDocumentType())
+ return; // no animations in Draw
+ for (sal_uInt16 n = 0; n < rDoc.GetSdPageCount(PageKind::Standard); ++n)
+ {
+ SdPage *const pPage = rDoc.GetSdPage(n, PageKind::Standard);
+ if (pPage->hasAnimationNode())
+ {
+ // this will force the equivalent of the MainSequence::onTimerHdl
+ // so that the animations are present in export-able representation
+ // *before* the import is finished
+ pPage->getMainSequence()->getRootNode();
+ }
+ }
+ for (sal_uInt16 n = 0; n < rDoc.GetMasterSdPageCount(PageKind::Standard); ++n)
+ {
+ SdPage *const pPage = rDoc.GetMasterSdPage(n, PageKind::Standard);
+ if (pPage->hasAnimationNode())
+ {
+ pPage->getMainSequence()->getRootNode();
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */