sd/source/core/EffectMigration.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/presentation/EffectNodeType.hpp>
  21 #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
  22 #include <com/sun/star/presentation/TextAnimationType.hpp>
  23 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  24 #include <comphelper/processfactory.hxx>
  25 #include <com/sun/star/animations/AnimationFill.hpp>
  26 #include <com/sun/star/animations/XAnimate.hpp>
  27 #include <com/sun/star/beans/NamedValue.hpp>
  28 #include <tools/debug.hxx>
  29 #include <svx/unoshape.hxx>
  30 #include <svx/svdotext.hxx>
  31 #include <svx/svdopath.hxx>
  32 #include <svx/svdogrp.hxx>
  33 #include <svx/svditer.hxx>
  34 #include <drawdoc.hxx>
  35 #include <sdpage.hxx>
  36 #include <CustomAnimationPreset.hxx>
  37 #include <TransitionPreset.hxx>
  38 #include <EffectMigration.hxx>
  39 #include <anminfo.hxx>
  40
  41 using namespace ::sd;
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::animations;
  44 using namespace ::com::sun::star::presentation;
  45 using ::com::sun::star::drawing::XShape;
  46 using ::com::sun::star::lang::XMultiServiceFactory;
  47 using ::com::sun::star::drawing::XShape;
  48 using ::com::sun::star::beans::NamedValue;
  49
  50 namespace {
  51
  52 struct deprecated_FadeEffect_conversion_table_entry
  53 {
  54     FadeEffect  meFadeEffect;
  55     const char* mpPresetId;
  56 };
  57
  58 }
  59
  60 deprecated_FadeEffect_conversion_table_entry const deprecated_FadeEffect_conversion_table[] =
  61 {
  62 // OOo 1.x transitions
  63     { FadeEffect_FADE_FROM_LEFT,            "wipe-right" },
  64     { FadeEffect_FADE_FROM_TOP,             "wipe-down" },
  65     { FadeEffect_FADE_FROM_RIGHT,           "wipe-left" },
  66     { FadeEffect_FADE_FROM_BOTTOM,          "wipe-up" },
  67
  68     { FadeEffect_CLOCKWISE,                 "wheel-clockwise-1-spoke" },
  69
  70     { FadeEffect_UNCOVER_TO_LEFT,           "uncover-left" },
  71     { FadeEffect_UNCOVER_TO_UPPERLEFT,      "uncover-left-up" },
  72     { FadeEffect_UNCOVER_TO_TOP,            "uncover-up" },
  73     { FadeEffect_UNCOVER_TO_UPPERRIGHT,     "uncover-right-up" },
  74     { FadeEffect_UNCOVER_TO_RIGHT,          "uncover-right" },
  75     { FadeEffect_UNCOVER_TO_LOWERRIGHT,     "uncover-right-down" },
  76     { FadeEffect_UNCOVER_TO_BOTTOM,         "uncover-down" },
  77     { FadeEffect_UNCOVER_TO_LOWERLEFT,      "uncover-left-down" },
  78
  79     { FadeEffect_VERTICAL_LINES,            "random-bars-vertical" },
  80     { FadeEffect_HORIZONTAL_LINES,          "random-bars-horizontal" },
  81
  82     { FadeEffect_VERTICAL_CHECKERBOARD,     "checkerboard-down" },
  83     { FadeEffect_HORIZONTAL_CHECKERBOARD,   "checkerboard-across" },
  84
  85     { FadeEffect_FADE_TO_CENTER,            "box-in" },
  86     { FadeEffect_FADE_FROM_CENTER,          "box-out" },
  87
  88     { FadeEffect_VERTICAL_STRIPES,          "venetian-blinds-vertical" },
  89     { FadeEffect_HORIZONTAL_STRIPES,        "venetian-blinds-horizontal" },
  90
  91     { FadeEffect_MOVE_FROM_LEFT,            "cover-right" },
  92     { FadeEffect_MOVE_FROM_TOP,             "cover-down" },
  93     { FadeEffect_MOVE_FROM_RIGHT,           "cover-left" },
  94     { FadeEffect_MOVE_FROM_BOTTOM,          "cover-up" },
  95     { FadeEffect_MOVE_FROM_UPPERLEFT,       "cover-right-down" },
  96     { FadeEffect_MOVE_FROM_UPPERRIGHT,      "cover-left-down" },
  97     { FadeEffect_MOVE_FROM_LOWERRIGHT,      "cover-left-up" },
  98     { FadeEffect_MOVE_FROM_LOWERLEFT,       "cover-right-up" },
  99
 100     { FadeEffect_DISSOLVE,                  "dissolve" },
 101
 102     { FadeEffect_RANDOM,                    "random-transition" },
 103
 104     { FadeEffect_ROLL_FROM_LEFT,            "push-right" },
 105     { FadeEffect_ROLL_FROM_TOP,             "push-down" },
 106     { FadeEffect_ROLL_FROM_RIGHT,           "push-left" },
 107     { FadeEffect_ROLL_FROM_BOTTOM,          "push-up" },
 108
 109     { FadeEffect_CLOSE_VERTICAL,            "split-horizontal-in" },
 110     { FadeEffect_CLOSE_HORIZONTAL,          "split-vertical-in" },
 111     { FadeEffect_OPEN_VERTICAL,             "split-horizontal-out" },
 112     { FadeEffect_OPEN_HORIZONTAL,           "split-vertical-out" },
 113
 114     { FadeEffect_FADE_FROM_UPPERLEFT,       "diagonal-squares-right-down" },
 115     { FadeEffect_FADE_FROM_UPPERRIGHT,      "diagonal-squares-left-down" },
 116     { FadeEffect_FADE_FROM_LOWERLEFT,       "diagonal-squares-right-up" },
 117     { FadeEffect_FADE_FROM_LOWERRIGHT,      "diagonal-squares-left-up" },
 118
 119 // OOo 1.x transitions not in OOo 2.x
 120     { FadeEffect_CLOCKWISE,                 "clock-wipe-twelve" },
 121     { FadeEffect_COUNTERCLOCKWISE,          "reverse-clock-wipe-twelve" },
 122     { FadeEffect_SPIRALIN_LEFT,             "spiral-wipe-top-left-clockwise" },
 123     { FadeEffect_SPIRALIN_RIGHT,            "spiral-wipe-top-right-counter-clockwise" },
 124     { FadeEffect_SPIRALOUT_LEFT,            "spiral-wipe-out-to-bottom-right-clockwise" },
 125     { FadeEffect_SPIRALOUT_RIGHT,           "spiral-wipe-out-to-bottom-left-counter-clockwise" },
 126     { FadeEffect_WAVYLINE_FROM_LEFT,        "snake-wipe-top-left-vertical" },
 127     { FadeEffect_WAVYLINE_FROM_TOP,         "snake-wipe-top-left-horizontal" },
 128     { FadeEffect_WAVYLINE_FROM_RIGHT,       "snake-wipe-bottom-right-vertical" },
 129     { FadeEffect_WAVYLINE_FROM_BOTTOM,      "snake-wipe-bottom-right-horizontal" },
 130     { FadeEffect_STRETCH_FROM_LEFT,         "wipe-right" }, // todo
 131     { FadeEffect_STRETCH_FROM_TOP,          "wipe-down" },  // todo
 132     { FadeEffect_STRETCH_FROM_RIGHT,        "wipe-left" },  // todo
 133     { FadeEffect_STRETCH_FROM_BOTTOM,       "wipe-up" },    // todo
 134
 135 // OOo 1.x not available transitions
 136
 137     { FadeEffect_CLOCKWISE,                 "wheel-clockwise-2-spokes" },
 138     { FadeEffect_CLOCKWISE,                 "wheel-clockwise-3-spokes" },
 139     { FadeEffect_CLOCKWISE,                 "wheel-clockwise-4-spokes" },
 140     { FadeEffect_CLOCKWISE,                 "wheel-clockwise-8-spokes" },
 141
 142     { FadeEffect_FADE_FROM_CENTER,          "shape-circle" },
 143     { FadeEffect_FADE_FROM_CENTER,          "shape-diamond" },
 144     { FadeEffect_FADE_FROM_CENTER,          "shape-plus" },
 145
 146     { FadeEffect_CLOCKWISE,                 "wedge" },
 147
 148     { FadeEffect_DISSOLVE,                  "fade-through-black" },
 149
 150     { FadeEffect_CLOCKWISE,                 "zoom-rotate-in" },
 151
 152     { FadeEffect_HORIZONTAL_LINES,          "comb-horizontal" },
 153     { FadeEffect_VERTICAL_LINES,            "comb-vertical" },
 154
 155     { FadeEffect_DISSOLVE,                  "fade-smoothly" },
 156
 157     { FadeEffect_NONE, nullptr }
 158 };
 159
 160 /* todo
 161 cut                             cut                                 (same as NONE?)
 162 cut-through-black               cut         toBlack
 163 wedge                           wedge
 164 */
 165
 166 void EffectMigration::SetFadeEffect( SdPage* pPage, css::presentation::FadeEffect eNewEffect)
 167 {
 168     deprecated_FadeEffect_conversion_table_entry const * pEntry = deprecated_FadeEffect_conversion_table;
 169     while( (pEntry->meFadeEffect != FadeEffect_NONE) && (pEntry->meFadeEffect != eNewEffect) )
 170         pEntry++;
 171
 172     if( pEntry->mpPresetId )
 173     {
 174         const OUString aPresetId( OUString::createFromAscii( pEntry->mpPresetId ) );
 175
 176         const TransitionPresetList& rPresetList = TransitionPreset::getTransitionPresetList();
 177
 178         auto aIt = std::find_if(rPresetList.begin(), rPresetList.end(),
 179             [&aPresetId](const TransitionPresetPtr& rxPreset) { return rxPreset->getPresetId() == aPresetId; });
 180         if (aIt != rPresetList.end())
 181         {
 182             pPage->setTransitionType( (*aIt)->getTransition() );
 183             pPage->setTransitionSubtype( (*aIt)->getSubtype() );
 184             pPage->setTransitionDirection( (*aIt)->getDirection() );
 185             pPage->setTransitionFadeColor( (*aIt)->getFadeColor() );
 186         }
 187     }
 188     else
 189     {
 190         pPage->setTransitionType( 0 );
 191         pPage->setTransitionSubtype( 0 );
 192         pPage->setTransitionDirection( false );
 193         pPage->setTransitionFadeColor( 0 );
 194     }
 195 }
 196
 197 FadeEffect EffectMigration::GetFadeEffect( const SdPage* pPage )
 198 {
 199     const TransitionPresetList & rPresetList = TransitionPreset::getTransitionPresetList();
 200     auto aIt = std::find_if(rPresetList.begin(), rPresetList.end(),
 201         [&pPage](const TransitionPresetPtr& rxPreset) {
 202             return (rxPreset->getTransition() == pPage->getTransitionType())
 203                 && (rxPreset->getSubtype() == pPage->getTransitionSubtype())
 204                 && (rxPreset->getDirection() == pPage->getTransitionDirection())
 205                 && (rxPreset->getFadeColor() == pPage->getTransitionFadeColor());
 206         });
 207     if (aIt != rPresetList.end())
 208     {
 209         const OUString& aPresetId = (*aIt)->getPresetId();
 210
 211         deprecated_FadeEffect_conversion_table_entry const * pEntry = deprecated_FadeEffect_conversion_table;
 212         while( (pEntry->meFadeEffect != FadeEffect_NONE) && (!aPresetId.equalsAscii( pEntry->mpPresetId ) ) )
 213             pEntry++;
 214
 215         return pEntry->meFadeEffect;
 216     }
 217     return FadeEffect_NONE;
 218 }
 219
 220 namespace {
 221
 222 struct deprecated_AnimationEffect_conversion_table_entry
 223 {
 224     AnimationEffect meEffect;
 225     const char* mpPresetId;
 226     const char* mpPresetSubType;
 227 };
 228
 229 }
 230
 231 deprecated_AnimationEffect_conversion_table_entry const deprecated_AnimationEffect_conversion_table[] =
 232 {
 233 // OOo 1.x entrance effects
 234     { AnimationEffect_APPEAR, "ooo-entrance-appear",nullptr },
 235
 236     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-box","in" },
 237     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-box","out" },
 238
 239     { AnimationEffect_VERTICAL_CHECKERBOARD, "ooo-entrance-checkerboard","downward" },
 240     { AnimationEffect_HORIZONTAL_CHECKERBOARD, "ooo-entrance-checkerboard","across" },
 241
 242     { AnimationEffect_FADE_FROM_UPPERLEFT, "ooo-entrance-diagonal-squares","right-to-bottom" },
 243     { AnimationEffect_FADE_FROM_UPPERRIGHT, "ooo-entrance-diagonal-squares","left-to-bottom" },
 244     { AnimationEffect_FADE_FROM_LOWERLEFT, "ooo-entrance-diagonal-squares","right-to-top" },
 245     { AnimationEffect_FADE_FROM_LOWERRIGHT, "ooo-entrance-diagonal-squares","left-to-top" },
 246
 247     { AnimationEffect_DISSOLVE, "ooo-entrance-dissolve-in",nullptr },
 248
 249     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-fly-in","from-left" },
 250     { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-fly-in","from-top" },
 251     { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-fly-in","from-right" },
 252     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-fly-in","from-bottom" },
 253     { AnimationEffect_MOVE_FROM_UPPERLEFT, "ooo-entrance-fly-in","from-top-left" },
 254     { AnimationEffect_MOVE_FROM_UPPERRIGHT, "ooo-entrance-fly-in","from-top-right" },
 255     { AnimationEffect_MOVE_FROM_LOWERRIGHT, "ooo-entrance-fly-in","from-bottom-right" },
 256     { AnimationEffect_MOVE_FROM_LOWERLEFT, "ooo-entrance-fly-in","from-bottom-left" },
 257
 258     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-fly-in-slow", "from-bottom" },
 259     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-fly-in-slow", "from-left" },
 260     { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-fly-in-slow", "from-right" },
 261     { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-fly-in-slow", "from-top" },
 262
 263     { AnimationEffect_MOVE_SHORT_FROM_LEFT, "ooo-entrance-peek-in","from-left" },
 264     { AnimationEffect_MOVE_SHORT_FROM_TOP, "ooo-entrance-peek-in","from-top" },
 265     { AnimationEffect_MOVE_SHORT_FROM_RIGHT, "ooo-entrance-peek-in","from-right" },
 266     { AnimationEffect_MOVE_SHORT_FROM_BOTTOM, "ooo-entrance-peek-in","from-bottom" },
 267
 268     { AnimationEffect_VERTICAL_LINES, "ooo-entrance-random-bars","horizontal" },
 269     { AnimationEffect_HORIZONTAL_LINES, "ooo-entrance-random-bars","vertical" },
 270
 271     { AnimationEffect_RANDOM, "ooo-entrance-random",nullptr },
 272
 273     { AnimationEffect_CLOSE_VERTICAL, "ooo-entrance-split","horizontal-in" },
 274     { AnimationEffect_CLOSE_HORIZONTAL, "ooo-entrance-split","vertical-in" },
 275     { AnimationEffect_OPEN_VERTICAL, "ooo-entrance-split","horizontal-out" },
 276     { AnimationEffect_OPEN_HORIZONTAL, "ooo-entrance-split","vertical-out" },
 277
 278     { AnimationEffect_VERTICAL_STRIPES, "ooo-entrance-venetian-blinds","horizontal" },
 279     { AnimationEffect_HORIZONTAL_STRIPES, "ooo-entrance-venetian-blinds","vertical" },
 280
 281     { AnimationEffect_FADE_FROM_LEFT, "ooo-entrance-wipe","from-left" },
 282     { AnimationEffect_FADE_FROM_TOP, "ooo-entrance-wipe","from-bottom" },
 283     { AnimationEffect_FADE_FROM_RIGHT, "ooo-entrance-wipe","from-right" },
 284     { AnimationEffect_FADE_FROM_BOTTOM, "ooo-entrance-wipe","from-top" },
 285
 286     { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-swivel","vertical" },
 287     { AnimationEffect_VERTICAL_ROTATE, "ooo-entrance-swivel","horizontal" },
 288
 289     { AnimationEffect_STRETCH_FROM_LEFT, "ooo-entrance-stretchy","from-left" },
 290     { AnimationEffect_STRETCH_FROM_UPPERLEFT, "ooo-entrance-stretchy","from-top-left" },
 291     { AnimationEffect_STRETCH_FROM_TOP, "ooo-entrance-stretchy","from-top" },
 292     { AnimationEffect_STRETCH_FROM_UPPERRIGHT, "ooo-entrance-stretchy","from-top-right" },
 293     { AnimationEffect_STRETCH_FROM_RIGHT, "ooo-entrance-stretchy","from-right" },
 294     { AnimationEffect_STRETCH_FROM_LOWERRIGHT, "ooo-entrance-stretchy","from-bottom-right" },
 295     { AnimationEffect_STRETCH_FROM_BOTTOM, "ooo-entrance-stretchy","from-bottom" },
 296     { AnimationEffect_STRETCH_FROM_LOWERLEFT, "ooo-entrance-stretchy","from-bottom-left" },
 297
 298     { AnimationEffect_HORIZONTAL_STRETCH, "ooo-entrance-expand", nullptr },
 299
 300     { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel","1" },
 301     { AnimationEffect_COUNTERCLOCKWISE, "ooo-entrance-clock-wipe","counter-clockwise" },
 302
 303     { AnimationEffect_SPIRALIN_LEFT, "ooo-entrance-spiral-wipe", "from-top-left-clockwise" },
 304     { AnimationEffect_SPIRALIN_RIGHT, "ooo-entrance-spiral-wipe", "from-top-right-counter-clockwise" },
 305     { AnimationEffect_SPIRALOUT_LEFT, "ooo-entrance-spiral-wipe", "from-center-clockwise" },
 306     { AnimationEffect_SPIRALOUT_RIGHT, "ooo-entrance-spiral-wipe", "from-center-counter-clockwise" },
 307
 308     { AnimationEffect_WAVYLINE_FROM_LEFT, "ooo-entrance-snake-wipe","from-top-left-vertical" },
 309     { AnimationEffect_WAVYLINE_FROM_TOP, "ooo-entrance-snake-wipe","from-top-left-horizontal" },
 310     { AnimationEffect_WAVYLINE_FROM_RIGHT, "ooo-entrance-snake-wipe","from-bottom-right-vertical" },
 311     { AnimationEffect_WAVYLINE_FROM_BOTTOM, "ooo-entrance-snake-wipe","from-bottom-right-horizontal" },
 312
 313 // ooo 1.x exit effects
 314     { AnimationEffect_HIDE, "ooo-exit-disappear",nullptr },
 315     { AnimationEffect_MOVE_TO_LEFT, "ooo-exit-fly-out", "from-right" },
 316     { AnimationEffect_MOVE_TO_TOP, "ooo-exit-fly-out", "from-bottom" },
 317     { AnimationEffect_MOVE_TO_RIGHT, "ooo-exit-fly-out", "from-left" },
 318     { AnimationEffect_MOVE_TO_BOTTOM, "ooo-exit-fly-out", "from-top" },
 319     { AnimationEffect_MOVE_TO_UPPERLEFT, "ooo-exit-fly-out", "from-top-right" },
 320     { AnimationEffect_MOVE_TO_UPPERRIGHT, "ooo-exit-fly-out", "from-top-left" },
 321     { AnimationEffect_MOVE_TO_LOWERRIGHT, "ooo-exit-fly-out", "from-bottom-left" },
 322     { AnimationEffect_MOVE_TO_LOWERLEFT, "ooo-exit-fly-out", "from-bottom-right" },
 323     { AnimationEffect_MOVE_SHORT_TO_LEFT, "ooo-exit-peek-out", "from-right" },
 324     { AnimationEffect_MOVE_SHORT_TO_UPPERLEFT, "ooo-exit-peek-out", "from-right" },
 325     { AnimationEffect_MOVE_SHORT_TO_TOP, "ooo-exit-peek-out", "from-bottom" },
 326     { AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT, "ooo-exit-peek-out", "from-bottom" },
 327     { AnimationEffect_MOVE_SHORT_TO_RIGHT, "ooo-exit-peek-out", "from-left" },
 328     { AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT, "ooo-exit-peek-out","from-left" },
 329     { AnimationEffect_MOVE_SHORT_TO_BOTTOM, "ooo-exit-peek-out", "from-top" },
 330     { AnimationEffect_MOVE_SHORT_TO_LOWERLEFT, "ooo-exit-peek-out", "from-top" },
 331
 332 // no matching in OOo 2.x
 333     { AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT, "ooo-entrance-peek-in","from-left" },
 334     { AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT, "ooo-entrance-peek-in","from-top" },
 335     { AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT, "ooo-entrance-peek-in","from-right" },
 336     { AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT, "ooo-entrance-peek-in","from-bottom" },
 337     { AnimationEffect_LASER_FROM_LEFT, "ooo-entrance-fly-in","from-left" },
 338     { AnimationEffect_LASER_FROM_TOP, "ooo-entrance-fly-in","from-top" },
 339     { AnimationEffect_LASER_FROM_RIGHT, "ooo-entrance-fly-in","from-right" },
 340     { AnimationEffect_LASER_FROM_BOTTOM, "ooo-entrance-fly-in","from-bottom" },
 341     { AnimationEffect_LASER_FROM_UPPERLEFT, "ooo-entrance-fly-in","from-top-left" },
 342     { AnimationEffect_LASER_FROM_UPPERRIGHT, "ooo-entrance-fly-in","from-top-right" },
 343     { AnimationEffect_LASER_FROM_LOWERLEFT, "ooo-entrance-fly-in","from-bottom-left" },
 344     { AnimationEffect_LASER_FROM_LOWERRIGHT, "ooo-entrance-fly-in","from-bottom-right" },
 345
 346 // no matching in OOo 1.x
 347
 348     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-circle", "in" },
 349     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-circle", "out" },
 350     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-diamond", "in" },
 351     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-diamond", "out" },
 352     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-plus", "in" },
 353     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-plus", "out" },
 354     { AnimationEffect_CLOCKWISE, "ooo-entrance-wedge", nullptr },
 355     { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "2" },
 356     { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "3" },
 357     { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "4" },
 358     { AnimationEffect_CLOCKWISE, "ooo-entrance-wheel", "8" },
 359
 360     { AnimationEffect_MOVE_FROM_RIGHT, "ooo-entrance-boomerang", nullptr },
 361     { AnimationEffect_MOVE_FROM_UPPERRIGHT, "ooo-entrance-bounce", nullptr },
 362     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-curve-up", nullptr },
 363     { AnimationEffect_MOVE_FROM_TOP, "ooo-entrance-float", nullptr },
 364     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-glide", nullptr },
 365     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-magnify", nullptr },
 366     { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-pinwheel", nullptr },
 367     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-breaks", nullptr },
 368     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-sling", nullptr },
 369     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-spiral-in", nullptr },
 370     { AnimationEffect_MOVE_FROM_LEFT, "ooo-entrance-thread", nullptr },
 371     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-ascend", nullptr },
 372     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-center-revolve", nullptr },
 373     { AnimationEffect_APPEAR, "ooo-entrance-compress", nullptr },
 374     { AnimationEffect_MOVE_SHORT_FROM_TOP, "ooo-entrance-descend", nullptr },
 375     { AnimationEffect_MOVE_SHORT_FROM_LEFT, "ooo-entrance-ease-in", nullptr },
 376     { AnimationEffect_MOVE_FROM_BOTTOM, "ooo-entrance-rise-up", nullptr },
 377     { AnimationEffect_HORIZONTAL_ROTATE, "ooo-entrance-spin-in", nullptr },
 378     { AnimationEffect_STRETCH_FROM_LEFT, "ooo-entrance-stretchy", "across" },
 379     { AnimationEffect_STRETCH_FROM_TOP, "ooo-entrance-stretchy", "downward" },
 380
 381     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in" },
 382     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in-slightly" },
 383     { AnimationEffect_FADE_FROM_CENTER, "ooo-entrance-zoom","in-from-screen-center" },
 384     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out" },
 385     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out-slightly" },
 386     { AnimationEffect_FADE_TO_CENTER, "ooo-entrance-zoom","out-from-screen-center" },
 387
 388     { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in", nullptr },
 389     { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in-and-zoom", nullptr },
 390     { AnimationEffect_DISSOLVE, "ooo-entrance-fade-in-and-swivel", nullptr },
 391
 392     // still open (no matching effect: AnimationEffect_ZOOM_IN_FROM_*,
 393     // AnimationEffect_ZOOM_OUT_FROM_*, AnimationEffect_PATH
 394
 395     { AnimationEffect_NONE, nullptr, nullptr }
 396 };
 397
 398 static EffectSequence::iterator ImplFindEffect( MainSequencePtr const & pMainSequence, const Reference< XShape >& rShape, sal_Int16 nSubItem )
 399 {
 400     return std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
 401         [&rShape, &nSubItem](const CustomAnimationEffectPtr& pEffect) {
 402             return (pEffect->getTargetShape() == rShape)
 403                 && (pEffect->getTargetSubItem() == nSubItem);
 404         });
 405 }
 406
 407 static bool implIsInsideGroup( SdrObject const * pObj )
 408 {
 409     // TTTT for current state of transition, SdrObject has a parent*
 410     // to a SdrObjList. That may be a SdrPage or a SdrObjGroup, both
 411     // are already derived from SdrObjList. To finally check, use
 412     // the method 'getSdrObjectFromSdrObjList' - if it's not a SdrPage,
 413     // it will return SdrObjGroup or E3dScene -> SdrObject.
 414     // For future states, test for SdrObject. Trying to get the SdrPage
 415     // will in the future depend on the Object(this) to be inserted to a
 416     // SdrPage, regardless of e.g. being a group member.
 417     if(nullptr == pObj)
 418     {
 419         return false;
 420     }
 421
 422     SdrObjList* pSdrObjList(pObj->getParentSdrObjListFromSdrObject());
 423
 424     if(nullptr == pSdrObjList)
 425     {
 426         return false;
 427     }
 428
 429     return (nullptr != pSdrObjList->getSdrObjectFromSdrObjList());
 430 }
 431
 432 void EffectMigration::SetAnimationEffect( SvxShape* pShape, AnimationEffect eEffect )
 433 {
 434     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
 435                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
 436     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
 437         return;
 438
 439     SdrObject* pObj = pShape->GetSdrObject();
 440     if( implIsInsideGroup( pObj ) )
 441         return;
 442
 443     OUString aPresetId;
 444     OUString aPresetSubType;
 445
 446     if( !ConvertAnimationEffect( eEffect, aPresetId, aPresetSubType ) )
 447     {
 448         OSL_FAIL( "sd::EffectMigration::SetAnimationEffect(), no mapping for given AnimationEffect value" );
 449         return;
 450     }
 451
 452     const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets();
 453
 454     CustomAnimationPresetPtr pPreset( rPresets.getEffectDescriptor( aPresetId ) );
 455     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 456
 457     if( !(pPreset && pMainSequence) )
 458         return;
 459
 460     const Reference< XShape > xShape( pShape );
 461
 462     EffectSequence::iterator aIterOnlyBackground( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
 463     EffectSequence::iterator aIterAsWhole( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::AS_WHOLE ) );
 464     const EffectSequence::iterator aEnd( pMainSequence->getEnd() );
 465
 466     if( (aIterOnlyBackground == aEnd) && (aIterAsWhole == aEnd) )
 467     {
 468         bool bEffectCreated = false;
 469
 470         // check if there is already a text effect for this shape
 471         EffectSequence::iterator aIterOnlyText( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
 472         if( aIterOnlyText != aEnd )
 473         {
 474             // check if this is an animation text group
 475             sal_Int32 nGroupId = (*aIterOnlyText)->getGroupId();
 476             if( nGroupId >= 0 )
 477             {
 478                 CustomAnimationTextGroupPtr pGroup = pMainSequence->findGroup( nGroupId );
 479                 if( pGroup )
 480                 {
 481                     // add an effect to animate the shape
 482                     pMainSequence->setAnimateForm( pGroup, true );
 483
 484                     // find this effect
 485                     EffectSequence::iterator aIter( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
 486
 487                     if( aIter != aEnd )
 488                     {
 489                         if( ((*aIter)->getPresetId() != aPresetId) ||
 490                             ((*aIter)->getPresetSubType() != aPresetSubType) )
 491                         {
 492                             (*aIter)->replaceNode( pPreset->create( aPresetSubType ) );
 493                             pMainSequence->rebuild();
 494                             bEffectCreated = true;
 495                         }
 496                     }
 497                 }
 498             }
 499         }
 500
 501         if( !bEffectCreated )
 502         {
 503             // if there is not yet an effect that target this shape, we generate one
 504             // we insert the shape effect before it
 505             Reference< XAnimationNode > xNode( pPreset->create( aPresetSubType ) );
 506             DBG_ASSERT( xNode.is(), "EffectMigration::SetAnimationEffect(), could not create preset!" );
 507             if( xNode.is() )
 508             {
 509                 CustomAnimationEffectPtr pEffect = std::make_shared<CustomAnimationEffect>( xNode );
 510                 pEffect->setTarget( makeAny( xShape ) );
 511                 SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
 512                 const bool bManual = (pPage == nullptr) || (pPage->GetPresChange() == PresChange::Manual);
 513                 if( !bManual )
 514                     pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
 515
 516                 pMainSequence->append( pEffect );
 517
 518                 if( ( pObj->GetObjInventor() == SdrInventor::Default ) && ( pObj->GetObjIdentifier() == OBJ_OUTLINETEXT ) )
 519                 {
 520                     // special case for outline text, effects are always mapped to text group effect
 521                     pMainSequence->
 522                         createTextGroup( pEffect, 10, bManual ? -1 : 0.0, false, false );
 523                 }
 524             }
 525         }
 526     }
 527     else
 528     {
 529         // if there is already an effect targeting this shape
 530         // just replace it
 531         CustomAnimationEffectPtr pEffect;
 532         if( aIterAsWhole != aEnd )
 533         {
 534             pEffect = *aIterAsWhole;
 535         }
 536         else
 537         {
 538             pEffect = *aIterOnlyBackground;
 539         }
 540
 541         if( pEffect )
 542         {
 543             if( (pEffect->getPresetId() != aPresetId) ||
 544                 (pEffect->getPresetSubType() != aPresetSubType) )
 545             {
 546                 pMainSequence->replace( pEffect, pPreset, aPresetSubType, -1.0 );
 547             }
 548         }
 549     }
 550 }
 551
 552 AnimationEffect EffectMigration::GetAnimationEffect( SvxShape* pShape )
 553 {
 554     OUString aPresetId;
 555     OUString aPresetSubType;
 556
 557     SdrObject* pObj = pShape->GetSdrObject();
 558     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 559
 560     if( pMainSequence )
 561     {
 562         const Reference< XShape > xShape( pShape );
 563
 564         EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
 565             [&xShape](const CustomAnimationEffectPtr& pEffect) {
 566                 return (pEffect->getTargetShape() == xShape)
 567                     && ((pEffect->getTargetSubItem() == ShapeAnimationSubType::ONLY_BACKGROUND)
 568                         || (pEffect->getTargetSubItem() == ShapeAnimationSubType::AS_WHOLE))
 569                     && (pEffect->getDuration() != 0.1); // ignore appear effects created from old text effect import
 570             });
 571
 572         if (aIter != pMainSequence->getEnd())
 573         {
 574             aPresetId = (*aIter)->getPresetId();
 575             aPresetSubType = (*aIter)->getPresetSubType();
 576         }
 577     }
 578
 579     // now find old effect
 580     AnimationEffect eEffect = AnimationEffect_NONE;
 581
 582     if( !ConvertPreset( aPresetId, &aPresetSubType, eEffect ) )
 583         ConvertPreset( aPresetId, nullptr, eEffect );
 584
 585     return eEffect;
 586 }
 587
 588 void EffectMigration::SetTextAnimationEffect( SvxShape* pShape, AnimationEffect eEffect )
 589 {
 590     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
 591                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
 592     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
 593         return;
 594
 595     SdrObject* pObj = pShape->GetSdrObject();
 596     if( implIsInsideGroup( pObj ) )
 597         return;
 598
 599     // first map the deprecated AnimationEffect to a preset and subtype
 600     OUString aPresetId;
 601     OUString aPresetSubType;
 602
 603     if( !ConvertAnimationEffect( eEffect, aPresetId, aPresetSubType ) )
 604     {
 605         OSL_FAIL( "sd::EffectMigration::SetAnimationEffect(), no mapping for given AnimationEffect value" );
 606         return;
 607     }
 608
 609     SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
 610
 611     // ignore old text effects on shape without text
 612     if( (pTextObj == nullptr) || (!pTextObj->HasText()) )
 613         return;
 614
 615     const CustomAnimationPresets& rPresets = CustomAnimationPresets::getCustomAnimationPresets();
 616
 617     // create an effect from this preset
 618     CustomAnimationPresetPtr pPreset( rPresets.getEffectDescriptor( aPresetId ) );
 619
 620     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 621
 622     if( !(pPreset && pMainSequence) )
 623         return;
 624
 625     const Reference< XShape > xShape( pShape );
 626
 627     EffectSequence::iterator aIterOnlyText( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
 628     const EffectSequence::iterator aEnd( pMainSequence->getEnd() );
 629
 630     CustomAnimationTextGroupPtr pGroup;
 631
 632     // is there already an animation text group for this shape?
 633     if( aIterOnlyText != aEnd )
 634     {
 635         const sal_Int32 nGroupId = (*aIterOnlyText)->getGroupId();
 636         if( nGroupId >= 0 )
 637             pGroup = pMainSequence->findGroup( nGroupId );
 638     }
 639
 640     // if there is not yet a group, create it
 641     if( !pGroup )
 642     {
 643         CustomAnimationEffectPtr pShapeEffect;
 644
 645         EffectSequence::iterator aIterOnlyBackground( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_BACKGROUND ) );
 646         if( aIterOnlyBackground != aEnd )
 647         {
 648             pShapeEffect = *aIterOnlyBackground;
 649         }
 650         else
 651         {
 652             EffectSequence::iterator aIterAsWhole( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::AS_WHOLE ) );
 653             if( aIterAsWhole != aEnd )
 654             {
 655                 pShapeEffect = *aIterAsWhole;
 656             }
 657             else
 658             {
 659                 Reference< XAnimationNode > xNode( pPreset->create( "" ) );
 660                 DBG_ASSERT( xNode.is(), "EffectMigration::SetTextAnimationEffect(), could not create preset!" );
 661                 if( xNode.is() )
 662                 {
 663                     pShapeEffect = std::make_shared<CustomAnimationEffect>( xNode );
 664                     pShapeEffect->setTarget( makeAny( xShape ) );
 665                     pShapeEffect->setDuration( 0.1 );
 666                     pMainSequence->append( pShapeEffect );
 667
 668                     SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
 669                     if( pPage && pPage->GetPresChange() != PresChange::Manual )
 670                         pShapeEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
 671                 }
 672             }
 673         }
 674
 675         if( pShapeEffect )
 676         {
 677             SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
 678             const bool bManual = (pPage == nullptr) || (pPage->GetPresChange() == PresChange::Manual);
 679
 680             // now create effects for each paragraph
 681             pGroup =
 682                 pMainSequence->
 683                     createTextGroup( pShapeEffect, 10, bManual ? -1 : 0.0, true, false );
 684         }
 685     }
 686
 687     if( pGroup )
 688     {
 689         const bool bLaserEffect = (eEffect >= AnimationEffect_LASER_FROM_LEFT) && (eEffect <= AnimationEffect_LASER_FROM_LOWERRIGHT);
 690
 691         // now we have a group, so check if all effects are same as we like to have them
 692         const EffectSequence& rEffects = pGroup->getEffects();
 693
 694         for( auto& rxEffect : rEffects )
 695         {
 696             // only work on paragraph targets
 697             if( rxEffect->getTarget().getValueType() == ::cppu::UnoType<ParagraphTarget>::get() )
 698             {
 699                 if( (rxEffect->getPresetId() != aPresetId) ||
 700                     (rxEffect->getPresetSubType() != aPresetSubType) )
 701                 {
 702                     rxEffect->replaceNode( pPreset->create( aPresetSubType ) );
 703                 }
 704
 705                 if( bLaserEffect )
 706                 {
 707                     rxEffect->setIterateType( TextAnimationType::BY_LETTER );
 708                     rxEffect->setIterateInterval( 0.5 );// TODO:
 709                                                          // Determine
 710                                                          // interval
 711                                                          // according
 712                                                          // to
 713                                                          // total
 714                                                          // effect
 715                                                          // duration
 716                 }
 717             }
 718         }
 719     }
 720     pMainSequence->rebuild();
 721 }
 722
 723 AnimationEffect EffectMigration::GetTextAnimationEffect( SvxShape* pShape )
 724 {
 725     OUString aPresetId;
 726     OUString aPresetSubType;
 727
 728     SdrObject* pObj = pShape->GetSdrObject();
 729     if( pObj )
 730     {
 731         sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 732
 733         if( pMainSequence )
 734         {
 735             const Reference< XShape > xShape( pShape );
 736             EffectSequence::iterator aIter( ImplFindEffect( pMainSequence, xShape, ShapeAnimationSubType::ONLY_TEXT ) );
 737             if( aIter != pMainSequence->getEnd() )
 738             {
 739                 aPresetId = (*aIter)->getPresetId();
 740                 aPresetSubType = (*aIter)->getPresetSubType();
 741             }
 742         }
 743     }
 744
 745     // now find old effect
 746     AnimationEffect eEffect = AnimationEffect_NONE;
 747
 748     if( !ConvertPreset( aPresetId, &aPresetSubType, eEffect ) )
 749         ConvertPreset( aPresetId, nullptr, eEffect );
 750
 751     return eEffect;
 752 }
 753
 754 bool EffectMigration::ConvertPreset( const OUString& rPresetId, const OUString* pPresetSubType, AnimationEffect& rEffect )
 755 {
 756     rEffect = AnimationEffect_NONE;
 757     if( !rPresetId.isEmpty() )
 758     {
 759         // first try a match for preset id and subtype
 760         deprecated_AnimationEffect_conversion_table_entry const * p = deprecated_AnimationEffect_conversion_table;
 761         while( p->mpPresetId )
 762         {
 763             if( rPresetId.equalsAscii( p->mpPresetId ) &&
 764                 (( p->mpPresetSubType == nullptr ) ||
 765                  ( pPresetSubType == nullptr) ||
 766                  ( pPresetSubType->equalsAscii( p->mpPresetSubType )) ) )
 767             {
 768                 rEffect = p->meEffect;
 769                 return true;
 770             }
 771             p++;
 772         }
 773         return false;
 774     }
 775     else
 776     {
 777         // empty preset id means AnimationEffect_NONE
 778         return true;
 779     }
 780 }
 781
 782 bool EffectMigration::ConvertAnimationEffect( const AnimationEffect& rEffect, OUString& rPresetId, OUString& rPresetSubType )
 783 {
 784     deprecated_AnimationEffect_conversion_table_entry const * p = deprecated_AnimationEffect_conversion_table;
 785     while( p->mpPresetId )
 786     {
 787         if( p->meEffect == rEffect )
 788         {
 789             rPresetId = OUString::createFromAscii( p->mpPresetId );
 790             rPresetSubType = OUString::createFromAscii( p->mpPresetSubType );
 791             return true;
 792         }
 793         p++;
 794     }
 795
 796     return false;
 797 }
 798
 799 double EffectMigration::ConvertAnimationSpeed( AnimationSpeed eSpeed )
 800 {
 801     double fDuration;
 802     switch( eSpeed )
 803     {
 804     case AnimationSpeed_SLOW: fDuration = 2.0; break;
 805     case AnimationSpeed_FAST: fDuration = 0.5; break;
 806     default:
 807         fDuration = 1.0; break;
 808     }
 809     return fDuration;
 810 }
 811
 812 void EffectMigration::SetAnimationSpeed( SvxShape* pShape, AnimationSpeed eSpeed )
 813 {
 814     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
 815                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
 816     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
 817         return;
 818
 819     SdrObject* pObj = pShape->GetSdrObject();
 820     if( implIsInsideGroup( pObj ) )
 821         return;
 822
 823     double fDuration = ConvertAnimationSpeed( eSpeed );
 824
 825     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 826
 827     const Reference< XShape > xShape( pShape );
 828
 829     EffectSequence::iterator aIter;
 830     bool bNeedRebuild = false;
 831
 832     for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
 833     {
 834         CustomAnimationEffectPtr pEffect( *aIter );
 835         if( pEffect->getTargetShape() == xShape )
 836         {
 837             if( pEffect->getDuration() != 0.1 )
 838                 pEffect->setDuration( fDuration );
 839             bNeedRebuild = true;
 840         }
 841     }
 842
 843     if( bNeedRebuild )
 844         pMainSequence->rebuild();
 845 }
 846
 847 AnimationSpeed EffectMigration::GetAnimationSpeed( SvxShape* pShape )
 848 {
 849     SdrObject* pObj = pShape->GetSdrObject();
 850     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 851
 852     const Reference< XShape > xShape( pShape );
 853
 854     double fDuration = 1.0;
 855
 856     EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
 857         [&xShape](const CustomAnimationEffectPtr& pEffect) {
 858             return (pEffect->getTargetShape() == xShape)
 859                 && (pEffect->getDuration() != 0.1);
 860         });
 861     if (aIter != pMainSequence->getEnd())
 862     {
 863         CustomAnimationEffectPtr pEffect( *aIter );
 864         fDuration = pEffect->getDuration();
 865     }
 866
 867     return ConvertDuration( fDuration );
 868 }
 869
 870 AnimationSpeed EffectMigration::ConvertDuration( double fDuration )
 871 {
 872     AnimationSpeed eSpeed;
 873
 874     if( fDuration < 1.0 )
 875         eSpeed = AnimationSpeed_FAST;
 876     else if( fDuration > 1.5 )
 877         eSpeed = AnimationSpeed_SLOW;
 878     else
 879         eSpeed = AnimationSpeed_MEDIUM;
 880
 881     return eSpeed;
 882 }
 883
 884 void EffectMigration::SetDimColor( SvxShape* pShape, sal_Int32 nColor )
 885 {
 886     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
 887                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
 888     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
 889         return;
 890
 891     SdrObject* pObj = pShape->GetSdrObject();
 892     if( implIsInsideGroup( pObj ) )
 893         return;
 894
 895     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 896
 897     const Reference< XShape > xShape( pShape );
 898
 899     EffectSequence::iterator aIter;
 900     bool bNeedRebuild = false;
 901
 902     for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
 903     {
 904         CustomAnimationEffectPtr pEffect( *aIter );
 905         if( pEffect->getTargetShape() == xShape )
 906         {
 907             pEffect->setHasAfterEffect( true );
 908             pEffect->setDimColor( makeAny( nColor ) );
 909             pEffect->setAfterEffectOnNext( true );
 910             bNeedRebuild = true;
 911         }
 912     }
 913
 914     if( bNeedRebuild )
 915         pMainSequence->rebuild();
 916 }
 917
 918 sal_Int32 EffectMigration::GetDimColor( SvxShape* pShape )
 919 {
 920     sal_Int32 nColor = 0;
 921     if( pShape )
 922     {
 923         SdrObject* pObj = pShape->GetSdrObject();
 924         if( pObj && pObj->getSdrPageFromSdrObject() )
 925         {
 926             sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 927
 928             const Reference< XShape > xShape( pShape );
 929             EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
 930                 [&xShape](const CustomAnimationEffectPtr& pEffect) {
 931                     return (pEffect->getTargetShape() == xShape)
 932                         && pEffect->getDimColor().hasValue()
 933                         && pEffect->hasAfterEffect();
 934                 });
 935             if (aIter != pMainSequence->getEnd())
 936             {
 937                 CustomAnimationEffectPtr pEffect( *aIter );
 938                 pEffect->getDimColor() >>= nColor;
 939             }
 940         }
 941     }
 942
 943     return nColor;
 944 }
 945
 946 void EffectMigration::SetDimHide( SvxShape* pShape, bool bDimHide )
 947 {
 948     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
 949                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
 950     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
 951         return;
 952
 953     SdrObject* pObj = pShape->GetSdrObject();
 954     if( implIsInsideGroup( pObj ) )
 955         return;
 956
 957     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 958
 959     const Reference< XShape > xShape( pShape );
 960
 961     EffectSequence::iterator aIter;
 962     bool bNeedRebuild = false;
 963
 964     for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
 965     {
 966         CustomAnimationEffectPtr pEffect( *aIter );
 967         if( pEffect->getTargetShape() == xShape )
 968         {
 969             pEffect->setHasAfterEffect( bDimHide );
 970             if( bDimHide ) {
 971                 Any aEmpty;
 972                 pEffect->setDimColor( aEmpty );
 973             }
 974             pEffect->setAfterEffectOnNext( false );
 975             bNeedRebuild = true;
 976         }
 977     }
 978
 979     if( bNeedRebuild )
 980         pMainSequence->rebuild();
 981 }
 982
 983 bool EffectMigration::GetDimHide( SvxShape* pShape )
 984 {
 985     bool bRet = false;
 986     if( pShape )
 987     {
 988         SdrObject* pObj = pShape->GetSdrObject();
 989         if( pObj && pObj->getSdrPageFromSdrObject() )
 990         {
 991             sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
 992
 993             const Reference< XShape > xShape( pShape );
 994
 995             EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
 996                 [&xShape](const CustomAnimationEffectPtr& pEffect) { return pEffect->getTargetShape() == xShape; });
 997             if (aIter != pMainSequence->getEnd())
 998             {
 999                 CustomAnimationEffectPtr pEffect( *aIter );
1000                 bRet = pEffect->hasAfterEffect() &&
1001                         !pEffect->getDimColor().hasValue() &&
1002                         (!pEffect->IsAfterEffectOnNext());
1003             }
1004         }
1005     }
1006
1007     return bRet;
1008 }
1009
1010 void EffectMigration::SetDimPrevious( SvxShape* pShape, bool bDimPrevious )
1011 {
1012     DBG_ASSERT( pShape && pShape->GetSdrObject() && pShape->GetSdrObject()->getSdrPageFromSdrObject(),
1013                 "sd::EffectMigration::SetAnimationEffect(), invalid argument!" );
1014     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
1015         return;
1016
1017     SdrObject* pObj = pShape->GetSdrObject();
1018     if( implIsInsideGroup( pObj ) )
1019         return;
1020
1021     Any aColor;
1022
1023     if( bDimPrevious )
1024         aColor <<= COL_LIGHTGRAY;
1025
1026     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1027
1028     const Reference< XShape > xShape( pShape );
1029
1030     EffectSequence::iterator aIter;
1031     bool bNeedRebuild = false;
1032
1033     for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
1034     {
1035         CustomAnimationEffectPtr pEffect( *aIter );
1036         if( pEffect->getTargetShape() == xShape )
1037         {
1038             pEffect->setHasAfterEffect( bDimPrevious );
1039             if( !bDimPrevious || !pEffect->getDimColor().hasValue() )
1040                 pEffect->setDimColor( aColor );
1041             pEffect->setAfterEffectOnNext( true );
1042             bNeedRebuild = true;
1043         }
1044     }
1045
1046     if( bNeedRebuild )
1047         pMainSequence->rebuild();
1048 }
1049
1050 bool EffectMigration::GetDimPrevious( SvxShape* pShape )
1051 {
1052     bool bRet = false;
1053     if( pShape )
1054     {
1055         SdrObject* pObj = pShape->GetSdrObject();
1056         if( pObj && pObj->getSdrPageFromSdrObject() )
1057         {
1058             sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1059
1060             const Reference< XShape > xShape( pShape );
1061
1062             EffectSequence::iterator aIter = std::find_if(pMainSequence->getBegin(), pMainSequence->getEnd(),
1063                 [&xShape](const CustomAnimationEffectPtr& pEffect) { return pEffect->getTargetShape() == xShape; });
1064             if (aIter != pMainSequence->getEnd())
1065             {
1066                 CustomAnimationEffectPtr pEffect( *aIter );
1067                 bRet = pEffect->hasAfterEffect() &&
1068                         pEffect->getDimColor().hasValue() &&
1069                         pEffect->IsAfterEffectOnNext();
1070             }
1071         }
1072     }
1073
1074     return bRet;
1075 }
1076
1077 void EffectMigration::SetPresentationOrder( SvxShape* pShape, sal_Int32 nNewPos )
1078 {
1079     if( !pShape || !pShape->GetSdrObject() || !pShape->GetSdrObject()->getSdrPageFromSdrObject() )
1080         return;
1081
1082     SdrObject* pObj = pShape->GetSdrObject();
1083     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1084
1085     EffectSequence& rSequence = pMainSequence->getSequence();
1086     sal_Int32 nPos;
1087     sal_Int32 nCurrentPos = -1;
1088     std::vector< std::vector< EffectSequence::iterator > > aEffectVector(1);
1089
1090     if( !rSequence.empty() )
1091     {
1092         Reference< XShape > xThis( pShape );
1093         Reference< XShape > xCurrent;
1094
1095         EffectSequence::iterator aIter( rSequence.begin() );
1096         EffectSequence::iterator aEnd( rSequence.end() );
1097         for( nPos = 0; aIter != aEnd; ++aIter )
1098         {
1099             CustomAnimationEffectPtr pEffect = *aIter;
1100
1101             if( !xCurrent.is() )
1102             {
1103                 xCurrent = pEffect->getTargetShape();
1104             }
1105             else if( pEffect->getTargetShape() != xCurrent )
1106             {
1107                 nPos++;
1108                 xCurrent = pEffect->getTargetShape();
1109                 aEffectVector.resize( nPos+1 );
1110             }
1111
1112             // is this the first effect for xThis shape?
1113             if(( nCurrentPos == -1 ) && ( xCurrent == xThis ) )
1114             {
1115                 nCurrentPos = nPos;
1116             }
1117
1118             aEffectVector[nPos].push_back( aIter );
1119         }
1120     }
1121
1122     // check if there is at least one effect for xThis
1123     if( nCurrentPos == -1 )
1124     {
1125         OSL_FAIL("sd::EffectMigration::SetPresentationOrder() failed cause this shape has no effect" );
1126         return;
1127     }
1128
1129     // check trivial case
1130     if( nCurrentPos == nNewPos )
1131         return;
1132
1133     std::vector< CustomAnimationEffectPtr > aEffects;
1134
1135     for( const auto& rIter : aEffectVector[nCurrentPos] )
1136     {
1137         aEffects.push_back( *rIter );
1138         rSequence.erase( rIter );
1139     }
1140
1141     if( nNewPos > nCurrentPos )
1142         nNewPos++;
1143
1144     if( nNewPos == static_cast<sal_Int32>(aEffectVector.size()) )
1145     {
1146         rSequence.insert( rSequence.end(), aEffects.begin(), aEffects.end() );
1147     }
1148     else
1149     {
1150         EffectSequence::iterator aPos( aEffectVector[nNewPos][0] );
1151         for( const auto& rEffect : aEffects )
1152         {
1153             rSequence.insert( aPos, rEffect );
1154         }
1155     }
1156 }
1157
1158 /** Returns the position of the given SdrObject in the Presentation order.
1159  *  This function returns -1 if the SdrObject is not in the Presentation order
1160  *  or if it's the path-object.
1161  */
1162 sal_Int32 EffectMigration::GetPresentationOrder( SvxShape* pShape )
1163 {
1164     sal_Int32 nPos = -1, nFound = -1;
1165
1166     SdrObject* pObj = pShape->GetSdrObject();
1167     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1168
1169     EffectSequence& rSequence = pMainSequence->getSequence();
1170
1171     Reference< XShape > xThis( pShape );
1172     Reference< XShape > xCurrent;
1173
1174     for( const CustomAnimationEffectPtr& pEffect : rSequence )
1175     {
1176         if( !xCurrent.is() || pEffect->getTargetShape() != xCurrent )
1177         {
1178             nPos++;
1179             xCurrent = pEffect->getTargetShape();
1180
1181             // is this the first effect for xThis shape?
1182             if( xCurrent == xThis )
1183             {
1184                 nFound = nPos;
1185                 break;
1186             }
1187         }
1188     }
1189
1190     return nFound;
1191 }
1192
1193 void EffectMigration::UpdateSoundEffect( SvxShape* pShape, SdAnimationInfo const * pInfo )
1194 {
1195     if( !pInfo )
1196         return;
1197
1198     SdrObject* pObj = pShape->GetSdrObject();
1199     sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1200
1201     const Reference< XShape > xShape( pShape );
1202
1203     EffectSequence::iterator aIter;
1204     bool bNeedRebuild = false;
1205
1206     OUString aSoundFile;
1207     if( pInfo->mbSoundOn )
1208         aSoundFile = pInfo->maSoundFile;
1209
1210     for( aIter = pMainSequence->getBegin(); aIter != pMainSequence->getEnd(); ++aIter )
1211     {
1212         CustomAnimationEffectPtr pEffect( *aIter );
1213         if( pEffect->getTargetShape() == xShape )
1214         {
1215             if( !aSoundFile.isEmpty() )
1216             {
1217                 pEffect->createAudio( makeAny( aSoundFile ) );
1218             }
1219             else
1220             {
1221                 pEffect->removeAudio();
1222             }
1223             bNeedRebuild = true;
1224         }
1225     }
1226
1227     if( bNeedRebuild )
1228         pMainSequence->rebuild();
1229 }
1230
1231 OUString EffectMigration::GetSoundFile( SvxShape* pShape )
1232 {
1233     OUString aSoundFile;
1234
1235     if( pShape )
1236     {
1237         SdrObject* pObj = pShape->GetSdrObject();
1238         if( pObj && pObj->getSdrPageFromSdrObject() )
1239         {
1240             sd::MainSequencePtr pMainSequence = static_cast<SdPage*>(pObj->getSdrPageFromSdrObject())->getMainSequence();
1241
1242             const Reference< XShape > xShape( pShape );
1243
1244             EffectSequence::iterator aIter;
1245
1246             for(    aIter = pMainSequence->getBegin();
1247                     (aSoundFile.isEmpty()) && (aIter != pMainSequence->getEnd());
1248                     ++aIter )
1249             {
1250                 CustomAnimationEffectPtr pEffect( *aIter );
1251                 if( pEffect->getTargetShape() == xShape )
1252                 {
1253                     if( pEffect->getAudio().is() )
1254                         pEffect->getAudio()->getSource() >>= aSoundFile;
1255                 }
1256             }
1257         }
1258     }
1259     return aSoundFile;
1260 }
1261
1262 bool EffectMigration::GetSoundOn( SvxShape* pShape )
1263 {
1264     return !GetSoundFile( pShape ).isEmpty();
1265 }
1266
1267 void EffectMigration::SetAnimationPath( SvxShape* pShape, SdrPathObj const * pPathObj )
1268 {
1269     if( !(pShape && pPathObj) )
1270         return;
1271
1272     SdrObject* pObj = pShape->GetSdrObject();
1273
1274     if( pObj )
1275     {
1276         const Reference< XShape > xShape( pShape );
1277         SdPage* pPage = dynamic_cast< SdPage* >(pPathObj->getSdrPageFromSdrObject());
1278         if( pPage )
1279         {
1280             std::shared_ptr< sd::MainSequence > pMainSequence( pPage->getMainSequence() );
1281             if( pMainSequence )
1282                 pMainSequence->append( *pPathObj, makeAny( xShape ), -1.0, "" );
1283         }
1284     }
1285 }
1286
1287 // #i42894# helper which creates the needed XAnimate for changing visibility and all the (currently) needed embeddings
1288 static void createVisibilityOnOffNode(Reference< XTimeContainer > const & rxParentContainer, SdrObject& rCandidate, bool bVisible, bool bOnClick, double fDuration)
1289 {
1290     Reference< XMultiServiceFactory > xMsf(::comphelper::getProcessServiceFactory());
1291
1292     // create par container node
1293     Reference< XAnimationNode > xOuterSeqTimeContainer(xMsf->createInstance("com.sun.star.animations.ParallelTimeContainer"), UNO_QUERY_THROW);
1294
1295     // set begin
1296     xOuterSeqTimeContainer->setBegin(Any(0.0));
1297
1298     // set fill
1299     xOuterSeqTimeContainer->setFill(AnimationFill::HOLD);
1300
1301     // set named values
1302     Sequence< NamedValue > aUserDataSequence;
1303     aUserDataSequence.realloc(1);
1304
1305     aUserDataSequence[0].Name = "node-type";
1306     aUserDataSequence[0].Value <<= bOnClick ? EffectNodeType::ON_CLICK : EffectNodeType::AFTER_PREVIOUS;
1307
1308     xOuterSeqTimeContainer->setUserData(aUserDataSequence);
1309
1310     // create animate set to change visibility for rCandidate
1311     Reference< XAnimationNode > xAnimateSetForLast(xMsf->createInstance("com.sun.star.animations.AnimateSet"), UNO_QUERY_THROW);
1312
1313     // set begin
1314     xAnimateSetForLast->setBegin(Any(0.0));
1315
1316     // set duration
1317     xAnimateSetForLast->setDuration(Any(fDuration));
1318
1319     // set fill
1320     xAnimateSetForLast->setFill(AnimationFill::HOLD);
1321
1322     // set target
1323     Reference< XAnimate > xAnimate(xAnimateSetForLast, UNO_QUERY);
1324     Reference< XShape > xTargetShape(rCandidate.getUnoShape(), UNO_QUERY);
1325     xAnimate->setTarget(Any(xTargetShape));
1326
1327     // set AttributeName
1328     xAnimate->setAttributeName("Visibility");
1329
1330     // set attribute value
1331     xAnimate->setTo(Any(bVisible));
1332
1333     // ad set node to par node
1334     Reference< XTimeContainer > xParentContainer(xOuterSeqTimeContainer, UNO_QUERY_THROW);
1335     xParentContainer->appendChild(xAnimateSetForLast);
1336
1337     // add node
1338     rxParentContainer->appendChild(xOuterSeqTimeContainer);
1339 }
1340
1341 // #i42894# older native formats supported animated group objects, that means all members of the group
1342 // were shown animated by showing one after the other. This is no longer supported, but the following
1343 // fallback will create the needed SMIL animation stuff. Unfortunately the members of the group
1344 // have to be moved directly to the page, else the (explained to be generic, thus I expected this to
1345 // work) animations will not work in slideshow
1346 void EffectMigration::CreateAnimatedGroup(SdrObjGroup const & rGroupObj, SdPage& rPage)
1347 {
1348     // aw080 will give a vector immediately
1349     SdrObjListIter aIter(rGroupObj);
1350
1351     if(!aIter.Count())
1352         return;
1353
1354     std::shared_ptr< sd::MainSequence > pMainSequence(rPage.getMainSequence());
1355
1356     if(!pMainSequence)
1357         return;
1358
1359     std::vector< SdrObject* > aObjects;
1360     aObjects.reserve(aIter.Count());
1361
1362     while(aIter.IsMore())
1363     {
1364         // do move to page rough with old/current stuff, will be different in aw080 anyways
1365         SdrObject* pCandidate = aIter.Next();
1366         rGroupObj.GetSubList()->NbcRemoveObject(pCandidate->GetOrdNum());
1367         rPage.NbcInsertObject(pCandidate);
1368         aObjects.push_back(pCandidate);
1369     }
1370
1371     // create main node
1372     Reference< XMultiServiceFactory > xMsf(::comphelper::getProcessServiceFactory());
1373     Reference< XAnimationNode > xOuterSeqTimeContainer(xMsf->createInstance("com.sun.star.animations.ParallelTimeContainer"), UNO_QUERY_THROW);
1374
1375     // set begin
1376     xOuterSeqTimeContainer->setBegin(Any(0.0));
1377
1378     // prepare parent container
1379     Reference< XTimeContainer > xParentContainer(xOuterSeqTimeContainer, UNO_QUERY_THROW);
1380
1381     // prepare loop over objects
1382     SdrObject* pNext = nullptr;
1383     const double fDurationShow(0.2);
1384     const double fDurationHide(0.001);
1385
1386     for(size_t a(0); a < aObjects.size(); a++)
1387     {
1388         SdrObject* pLast = pNext;
1389         pNext = aObjects[a];
1390
1391         // create node
1392         if(pLast)
1393         {
1394             createVisibilityOnOffNode(xParentContainer, *pLast, false, false, fDurationHide);
1395         }
1396
1397         if(pNext)
1398         {
1399             createVisibilityOnOffNode(xParentContainer, *pNext, true, !a, fDurationShow);
1400         }
1401     }
1402
1403     // create end node
1404     if(pNext)
1405     {
1406         createVisibilityOnOffNode(xParentContainer, *pNext, false, false, fDurationHide);
1407     }
1408
1409     // add to main sequence and rebuild
1410     pMainSequence->createEffects(xOuterSeqTimeContainer);
1411     pMainSequence->rebuild();
1412 }
1413
1414 void EffectMigration::DocumentLoaded(SdDrawDocument & rDoc)
1415 {
1416     if (DocumentType::Draw == rDoc.GetDocumentType())
1417         return; // no animations in Draw
1418     for (sal_uInt16 n = 0; n < rDoc.GetSdPageCount(PageKind::Standard); ++n)
1419     {
1420         SdPage *const pPage = rDoc.GetSdPage(n, PageKind::Standard);
1421         if (pPage->hasAnimationNode())
1422         {
1423             // this will force the equivalent of the MainSequence::onTimerHdl
1424             // so that the animations are present in export-able representation
1425             // *before* the import is finished
1426             pPage->getMainSequence()->getRootNode();
1427         }
1428     }
1429     for (sal_uInt16 n = 0; n < rDoc.GetMasterSdPageCount(PageKind::Standard); ++n)
1430     {
1431         SdPage *const pPage = rDoc.GetMasterSdPage(n, PageKind::Standard);
1432         if (pPage->hasAnimationNode())
1433         {
1434             pPage->getMainSequence()->getRootNode();
1435         }
1436     }
1437 }
1438
1439 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */