sd/source/ui/func/fuoaprms.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 <fuoaprms.hxx>
  21
  22 #include <sdattr.hxx>
  23 #include <svx/svdpagv.hxx>
  24 #include <editeng/colritem.hxx>
  25 #include <svx/svdundo.hxx>
  26 #include <vcl/group.hxx>
  27 #include <vcl/fixed.hxx>
  28 #include <sfx2/objsh.hxx>
  29 #include <sfx2/request.hxx>
  30 #include <sfx2/viewfrm.hxx>
  31 #include <svl/aeitem.hxx>
  32 #include <svx/xtable.hxx>
  33
  34 #include <strings.hrc>
  35 #include <drawdoc.hxx>
  36 #include <ViewShell.hxx>
  37 #include <ViewShellBase.hxx>
  38 #include <anminfo.hxx>
  39 #include <unoaprms.hxx>
  40 #include <sdundogr.hxx>
  41 #include <View.hxx>
  42 #include <Window.hxx>
  43 #include <sdabstdlg.hxx>
  44 #include <sdresid.hxx>
  45 #include <tools/helpers.hxx>
  46 #include <basegfx/polygon/b2dpolygon.hxx>
  47 #include <memory>
  48
  49 using namespace ::com::sun::star;
  50
  51 namespace sd {
  52
  53
  54 #define ATTR_MISSING    0       ///< Attribute missing
  55 #define ATTR_MIXED      1       ///< Attribute ambiguous (on multi-selection)
  56 #define ATTR_SET        2       ///< Attribute unique
  57
  58 FuObjectAnimationParameters::FuObjectAnimationParameters (
  59     ViewShell*   pViewSh,
  60     ::sd::Window*        pWin,
  61     ::sd::View*      pView,
  62     SdDrawDocument* pDoc,
  63     SfxRequest&  rReq)
  64     : FuPoor(pViewSh, pWin, pView, pDoc, rReq)
  65 {
  66 }
  67
  68 rtl::Reference<FuPoor> FuObjectAnimationParameters::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
  69 {
  70     rtl::Reference<FuPoor> xFunc( new FuObjectAnimationParameters( pViewSh, pWin, pView, pDoc, rReq ) );
  71     xFunc->DoExecute(rReq);
  72     return xFunc;
  73 }
  74
  75 void FuObjectAnimationParameters::DoExecute( SfxRequest& rReq )
  76 {
  77     ::svl::IUndoManager* pUndoMgr = mpViewShell->GetViewFrame()->GetObjectShell()->GetUndoManager();
  78
  79     const SdrMarkList& rMarkList  = mpView->GetMarkedObjectList();
  80     const size_t nCount = rMarkList.GetMarkCount();
  81
  82     short nAnimationSet     = ATTR_MISSING;
  83     short nEffectSet        = ATTR_MISSING;
  84     short nTextEffectSet    = ATTR_MISSING;
  85     short nSpeedSet         = ATTR_MISSING;
  86     short nFadeColorSet     = ATTR_MISSING;
  87     short nFadeOutSet       = ATTR_MISSING;
  88     short nInvisibleSet     = ATTR_MISSING;
  89     short nSoundOnSet       = ATTR_MISSING;
  90     short nSoundFileSet     = ATTR_MISSING;
  91     short nPlayFullSet      = ATTR_MISSING;
  92     short nClickActionSet   = ATTR_MISSING;
  93     short nBookmarkSet      = ATTR_MISSING;
  94
  95     short nSecondEffectSet      = ATTR_MISSING;
  96     short nSecondSpeedSet       = ATTR_MISSING;
  97     short nSecondSoundOnSet     = ATTR_MISSING;
  98     short nSecondPlayFullSet    = ATTR_MISSING;
  99
 100     // defaults (for Undo-Action)
 101     presentation::AnimationEffect eEffect         = presentation::AnimationEffect_NONE;
 102     presentation::AnimationEffect eTextEffect     = presentation::AnimationEffect_NONE;
 103     presentation::AnimationSpeed  eSpeed          = presentation::AnimationSpeed_MEDIUM;
 104     bool            bActive         = false;
 105     bool            bFadeOut        = false;
 106     Color           aFadeColor      = COL_LIGHTGRAY;
 107     bool            bInvisible      = false;
 108     bool            bSoundOn        = false;
 109     OUString        aSound;
 110     bool            bPlayFull       = false;
 111     presentation::ClickAction     eClickAction    = presentation::ClickAction_NONE;
 112     OUString        aBookmark;
 113
 114     presentation::AnimationEffect eSecondEffect   = presentation::AnimationEffect_NONE;
 115     presentation::AnimationSpeed  eSecondSpeed    = presentation::AnimationSpeed_MEDIUM;
 116     bool            bSecondSoundOn  = false;
 117     bool            bSecondPlayFull = false;
 118
 119     SdAnimationInfo* pInfo;
 120     SdrMark* pMark;
 121
 122     // inspect first object
 123     pMark = rMarkList.GetMark(0);
 124     pInfo = SdDrawDocument::GetAnimationInfo(pMark->GetMarkedSdrObj());
 125     if( pInfo )
 126     {
 127         bActive             = pInfo->mbActive;
 128         nAnimationSet       = ATTR_SET;
 129
 130         eEffect             = pInfo->meEffect;
 131         nEffectSet          = ATTR_SET;
 132
 133         eTextEffect         = pInfo->meTextEffect;
 134         nTextEffectSet      = ATTR_SET;
 135
 136         eSpeed              = pInfo->meSpeed;
 137         nSpeedSet           = ATTR_SET;
 138
 139         bFadeOut            = pInfo->mbDimPrevious;
 140         nFadeOutSet         = ATTR_SET;
 141
 142         aFadeColor          = pInfo->maDimColor;
 143         nFadeColorSet       = ATTR_SET;
 144
 145         bInvisible          = pInfo->mbDimHide;
 146         nInvisibleSet       = ATTR_SET;
 147
 148         bSoundOn            = pInfo->mbSoundOn;
 149         nSoundOnSet         = ATTR_SET;
 150
 151         aSound              = pInfo->maSoundFile;
 152         nSoundFileSet       = ATTR_SET;
 153
 154         bPlayFull           = pInfo->mbPlayFull;
 155         nPlayFullSet        = ATTR_SET;
 156
 157         eClickAction        = pInfo->meClickAction;
 158         nClickActionSet     = ATTR_SET;
 159
 160         aBookmark           = pInfo->GetBookmark();
 161         nBookmarkSet        = ATTR_SET;
 162
 163         eSecondEffect       = pInfo->meSecondEffect;
 164         nSecondEffectSet    = ATTR_SET;
 165
 166         eSecondSpeed        = pInfo->meSecondSpeed;
 167         nSecondSpeedSet     = ATTR_SET;
 168
 169         bSecondSoundOn      = pInfo->mbSecondSoundOn;
 170         nSecondSoundOnSet   = ATTR_SET;
 171
 172         bSecondPlayFull     = pInfo->mbSecondPlayFull;
 173         nSecondPlayFullSet  = ATTR_SET;
 174     }
 175
 176     // if necessary, inspect more objects
 177     for( size_t nObject = 1; nObject < nCount; ++nObject )
 178     {
 179         pMark = rMarkList.GetMark( nObject );
 180         SdrObject* pObject = pMark->GetMarkedSdrObj();
 181         pInfo = SdDrawDocument::GetAnimationInfo(pObject);
 182         if( pInfo )
 183         {
 184             if( bActive != pInfo->mbActive )
 185                 nAnimationSet = ATTR_MIXED;
 186
 187             if( eEffect != pInfo->meEffect )
 188                 nEffectSet = ATTR_MIXED;
 189
 190             if( eTextEffect != pInfo->meTextEffect )
 191                 nTextEffectSet = ATTR_MIXED;
 192
 193             if( eSpeed != pInfo->meSpeed )
 194                 nSpeedSet = ATTR_MIXED;
 195
 196             if( bFadeOut != pInfo->mbDimPrevious )
 197                 nFadeOutSet = ATTR_MIXED;
 198
 199             if( aFadeColor != pInfo->maDimColor )
 200                 nFadeColorSet = ATTR_MIXED;
 201
 202             if( bInvisible != pInfo->mbDimHide )
 203                 nInvisibleSet = ATTR_MIXED;
 204
 205             if( bSoundOn != pInfo->mbSoundOn )
 206                 nSoundOnSet = ATTR_MIXED;
 207
 208             if( aSound != pInfo->maSoundFile )
 209                 nSoundFileSet = ATTR_MIXED;
 210
 211             if( bPlayFull != pInfo->mbPlayFull )
 212                 nPlayFullSet = ATTR_MIXED;
 213
 214             if( eClickAction != pInfo->meClickAction )
 215                 nClickActionSet = ATTR_MIXED;
 216
 217             if( aBookmark != pInfo->GetBookmark() )
 218                 nBookmarkSet = ATTR_MIXED;
 219
 220             if( eSecondEffect != pInfo->meSecondEffect )
 221                 nSecondEffectSet = ATTR_MIXED;
 222
 223             if( eSecondSpeed != pInfo->meSecondSpeed )
 224                 nSecondSpeedSet = ATTR_MIXED;
 225
 226             if( bSecondSoundOn != pInfo->mbSecondSoundOn )
 227                 nSecondSoundOnSet = ATTR_MIXED;
 228
 229             if( bSecondPlayFull != pInfo->mbSecondPlayFull )
 230                 nSecondPlayFullSet = ATTR_MIXED;
 231         }
 232         else
 233         {
 234             if (nAnimationSet == ATTR_SET && bActive)
 235                 nAnimationSet = ATTR_MIXED;
 236
 237             if (nEffectSet == ATTR_SET && eEffect != presentation::AnimationEffect_NONE)
 238                 nEffectSet = ATTR_MIXED;
 239
 240             if (nTextEffectSet == ATTR_SET && eTextEffect != presentation::AnimationEffect_NONE)
 241                 nTextEffectSet = ATTR_MIXED;
 242
 243             if (nSpeedSet == ATTR_SET)
 244                 nSpeedSet = ATTR_MIXED;
 245
 246             if (nFadeOutSet == ATTR_SET && bFadeOut)
 247                 nFadeOutSet = ATTR_MIXED;
 248
 249             if (nFadeColorSet == ATTR_SET)
 250                 nFadeColorSet = ATTR_MIXED;
 251
 252             if (nInvisibleSet == ATTR_SET && bInvisible)
 253                 nInvisibleSet = ATTR_MIXED;
 254
 255             if (nSoundOnSet == ATTR_SET && bSoundOn)
 256                 nSoundOnSet = ATTR_MIXED;
 257
 258             if (nSoundFileSet == ATTR_SET)
 259                 nSoundFileSet = ATTR_MIXED;
 260
 261             if (nPlayFullSet == ATTR_SET && bPlayFull)
 262                 nPlayFullSet = ATTR_MIXED;
 263
 264             if (nClickActionSet == ATTR_SET && eClickAction != presentation::ClickAction_NONE)
 265                 nClickActionSet = ATTR_MIXED;
 266
 267             if (nBookmarkSet == ATTR_SET)
 268                 nBookmarkSet = ATTR_MIXED;
 269
 270             if (nSecondEffectSet == ATTR_SET && eSecondEffect != presentation::AnimationEffect_NONE)
 271                 nSecondEffectSet = ATTR_MIXED;
 272
 273             if (nSecondSpeedSet == ATTR_SET)
 274                 nSecondSpeedSet = ATTR_MIXED;
 275
 276             if (nSecondSoundOnSet == ATTR_SET && bSecondSoundOn)
 277                 nSecondSoundOnSet = ATTR_MIXED;
 278
 279             if (nSecondPlayFullSet == ATTR_SET && bSecondPlayFull)
 280                 nSecondPlayFullSet = ATTR_MIXED;
 281         }
 282     }
 283
 284     /* Exactly two objects with path effect?
 285        Then, only the animation info at the moved object is valid. */
 286     if (nCount == 2)
 287     {
 288         SdrObject* pObject1 = rMarkList.GetMark(0)->GetMarkedSdrObj();
 289         SdrObject* pObject2 = rMarkList.GetMark(1)->GetMarkedSdrObj();
 290         SdrObjKind eKind1   = static_cast<SdrObjKind>(pObject1->GetObjIdentifier());
 291         SdrObjKind eKind2   = static_cast<SdrObjKind>(pObject2->GetObjIdentifier());
 292         SdAnimationInfo* pInfo1 = SdDrawDocument::GetAnimationInfo(pObject1);
 293         SdAnimationInfo* pInfo2 = SdDrawDocument::GetAnimationInfo(pObject2);
 294         pInfo  = nullptr;
 295
 296         if (pObject1->GetObjInventor() == SdrInventor::Default &&
 297             ((eKind1 == OBJ_LINE) ||                        // 2 point line
 298              (eKind1 == OBJ_PLIN) ||                        // Polygon
 299              (eKind1 == OBJ_PATHLINE))                &&    // Bezier curve
 300              (pInfo2 && pInfo2->meEffect == presentation::AnimationEffect_PATH))
 301         {
 302             pInfo = pInfo2;
 303         }
 304
 305         if (pObject2->GetObjInventor() == SdrInventor::Default &&
 306             ((eKind2 == OBJ_LINE) ||                        // 2 point line
 307              (eKind2 == OBJ_PLIN) ||                        // Polygon
 308              (eKind2 == OBJ_PATHLINE))                &&    // Bezier curve
 309             (pInfo1 && pInfo1->meEffect == presentation::AnimationEffect_PATH))
 310         {
 311             pInfo = pInfo1;
 312         }
 313
 314         if (pInfo)
 315         {
 316             bActive         = pInfo->mbActive;          nAnimationSet       = ATTR_SET;
 317             eEffect         = pInfo->meEffect;          nEffectSet          = ATTR_SET;
 318             eTextEffect     = pInfo->meTextEffect;      nTextEffectSet      = ATTR_SET;
 319             eSpeed          = pInfo->meSpeed;           nSpeedSet           = ATTR_SET;
 320             bFadeOut        = pInfo->mbDimPrevious;     nFadeOutSet         = ATTR_SET;
 321             aFadeColor      = pInfo->maDimColor;        nFadeColorSet       = ATTR_SET;
 322             bInvisible      = pInfo->mbDimHide;         nInvisibleSet       = ATTR_SET;
 323             bSoundOn        = pInfo->mbSoundOn;         nSoundOnSet         = ATTR_SET;
 324             aSound          = pInfo->maSoundFile;       nSoundFileSet       = ATTR_SET;
 325             bPlayFull       = pInfo->mbPlayFull;        nPlayFullSet        = ATTR_SET;
 326             eClickAction    = pInfo->meClickAction;     nClickActionSet     = ATTR_SET;
 327             aBookmark       = pInfo->GetBookmark();     nBookmarkSet        = ATTR_SET;
 328             eSecondEffect   = pInfo->meSecondEffect;    nSecondEffectSet    = ATTR_SET;
 329             eSecondSpeed    = pInfo->meSecondSpeed;     nSecondSpeedSet     = ATTR_SET;
 330             bSecondSoundOn  = pInfo->mbSecondSoundOn;   nSecondSoundOnSet   = ATTR_SET;
 331             bSecondPlayFull = pInfo->mbSecondPlayFull;  nSecondPlayFullSet  = ATTR_SET;
 332         }
 333     }
 334
 335     const SfxItemSet* pArgs = rReq.GetArgs();
 336
 337     if(!pArgs)
 338     {
 339         // fill ItemSet for dialog
 340         SfxItemSet aSet(mpDoc->GetPool(), svl::Items<ATTR_ANIMATION_START, ATTR_ACTION_END>{});
 341
 342         // fill the set
 343         if (nAnimationSet == ATTR_SET)
 344             aSet.Put( SfxBoolItem( ATTR_ANIMATION_ACTIVE, bActive));
 345         else if (nAnimationSet == ATTR_MIXED)
 346             aSet.InvalidateItem(ATTR_ANIMATION_ACTIVE);
 347         else
 348             aSet.Put(SfxBoolItem(ATTR_ANIMATION_ACTIVE, false));
 349
 350         if (nEffectSet == ATTR_SET)
 351             aSet.Put(SfxAllEnumItem(ATTR_ANIMATION_EFFECT, static_cast<sal_uInt16>(eEffect)));
 352         else if (nEffectSet == ATTR_MIXED)
 353             aSet.InvalidateItem( ATTR_ANIMATION_EFFECT );
 354         else
 355             aSet.Put(SfxAllEnumItem(ATTR_ANIMATION_EFFECT, sal_uInt16(presentation::AnimationEffect_NONE)));
 356
 357         if (nTextEffectSet == ATTR_SET)
 358             aSet.Put(SfxAllEnumItem(ATTR_ANIMATION_TEXTEFFECT, static_cast<sal_uInt16>(eTextEffect)));
 359         else if (nTextEffectSet == ATTR_MIXED)
 360             aSet.InvalidateItem( ATTR_ANIMATION_TEXTEFFECT );
 361         else
 362             aSet.Put(SfxAllEnumItem(ATTR_ANIMATION_TEXTEFFECT, sal_uInt16(presentation::AnimationEffect_NONE)));
 363
 364         if (nSpeedSet == ATTR_SET)
 365             aSet.Put(SfxAllEnumItem(ATTR_ANIMATION_SPEED, static_cast<sal_uInt16>(eSpeed)));
 366         else
 367             aSet.InvalidateItem(ATTR_ANIMATION_SPEED);
 368
 369         if (nFadeOutSet == ATTR_SET)
 370             aSet.Put(SfxBoolItem(ATTR_ANIMATION_FADEOUT, bFadeOut));
 371         else if (nFadeOutSet == ATTR_MIXED)
 372             aSet.InvalidateItem(ATTR_ANIMATION_FADEOUT);
 373         else
 374             aSet.Put(SfxBoolItem(ATTR_ANIMATION_FADEOUT, false));
 375
 376         if (nFadeColorSet == ATTR_SET)
 377             aSet.Put(SvxColorItem(aFadeColor, ATTR_ANIMATION_COLOR));
 378         else if (nFadeColorSet == ATTR_MIXED)
 379             aSet.InvalidateItem(ATTR_ANIMATION_COLOR);
 380         else
 381             aSet.Put(SvxColorItem(COL_LIGHTGRAY, ATTR_ANIMATION_COLOR));
 382
 383         if (nInvisibleSet == ATTR_SET)
 384             aSet.Put(SfxBoolItem(ATTR_ANIMATION_INVISIBLE, bInvisible));
 385         else if (nInvisibleSet == ATTR_MIXED)
 386             aSet.InvalidateItem(ATTR_ANIMATION_INVISIBLE);
 387         else
 388             aSet.Put(SfxBoolItem(ATTR_ANIMATION_INVISIBLE, false));
 389
 390         if (nSoundOnSet == ATTR_SET)
 391             aSet.Put(SfxBoolItem(ATTR_ANIMATION_SOUNDON, bSoundOn));
 392         else if (nSoundOnSet == ATTR_MIXED)
 393             aSet.InvalidateItem(ATTR_ANIMATION_SOUNDON);
 394         else
 395             aSet.Put(SfxBoolItem(ATTR_ANIMATION_SOUNDON, false));
 396
 397         if (nSoundFileSet == ATTR_SET)
 398             aSet.Put(SfxStringItem(ATTR_ANIMATION_SOUNDFILE, aSound));
 399         else
 400             aSet.InvalidateItem(ATTR_ANIMATION_SOUNDFILE);
 401
 402         if (nPlayFullSet == ATTR_SET)
 403             aSet.Put(SfxBoolItem(ATTR_ANIMATION_PLAYFULL, bPlayFull));
 404         else if (nPlayFullSet == ATTR_MIXED)
 405             aSet.InvalidateItem(ATTR_ANIMATION_PLAYFULL);
 406         else
 407             aSet.Put(SfxBoolItem(ATTR_ANIMATION_PLAYFULL, false));
 408
 409         if (nClickActionSet == ATTR_SET)
 410             aSet.Put(SfxAllEnumItem(ATTR_ACTION, static_cast<sal_uInt16>(eClickAction)));
 411         else if (nClickActionSet == ATTR_MIXED)
 412             aSet.InvalidateItem(ATTR_ACTION);
 413         else
 414             aSet.Put(SfxAllEnumItem(ATTR_ACTION, sal_uInt16(presentation::ClickAction_NONE)));
 415
 416         if (nBookmarkSet == ATTR_SET)
 417             aSet.Put(SfxStringItem(ATTR_ACTION_FILENAME, aBookmark));
 418         else
 419             aSet.InvalidateItem(ATTR_ACTION_FILENAME);
 420
 421         if (nSecondEffectSet == ATTR_SET)
 422             aSet.Put(SfxAllEnumItem(ATTR_ACTION_EFFECT, static_cast<sal_uInt16>(eSecondEffect)));
 423         else if (nSecondEffectSet == ATTR_MIXED)
 424             aSet.InvalidateItem( ATTR_ACTION_EFFECT );
 425         else
 426             aSet.Put(SfxAllEnumItem(ATTR_ACTION_EFFECT, sal_uInt16(presentation::AnimationEffect_NONE)));
 427
 428         if (nSecondSpeedSet == ATTR_SET)
 429             aSet.Put(SfxAllEnumItem(ATTR_ACTION_EFFECTSPEED, static_cast<sal_uInt16>(eSecondSpeed)));
 430         else
 431             aSet.InvalidateItem(ATTR_ACTION_EFFECTSPEED);
 432
 433         if (nSecondSoundOnSet == ATTR_SET)
 434             aSet.Put(SfxBoolItem(ATTR_ACTION_SOUNDON, bSecondSoundOn));
 435         else if (nSecondSoundOnSet == ATTR_MIXED)
 436             aSet.InvalidateItem(ATTR_ACTION_SOUNDON);
 437         else
 438             aSet.Put(SfxBoolItem(ATTR_ACTION_SOUNDON, false));
 439
 440         if (nSecondPlayFullSet == ATTR_SET)
 441             aSet.Put(SfxBoolItem(ATTR_ACTION_PLAYFULL, bSecondPlayFull));
 442         else if (nSecondPlayFullSet == ATTR_MIXED)
 443             aSet.InvalidateItem(ATTR_ACTION_PLAYFULL);
 444         else
 445             aSet.Put(SfxBoolItem(ATTR_ACTION_PLAYFULL, false));
 446
 447         SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 448         ScopedVclPtr<SfxAbstractDialog> pDlg(pFact ? pFact->CreatSdActionDialog(mpViewShell->GetActiveWindow(), &aSet, mpView) : nullptr);
 449
 450         short nResult = pDlg ? pDlg->Execute() : static_cast<short>(RET_CANCEL);
 451
 452         if( nResult == RET_OK )
 453         {
 454             rReq.Done( *( pDlg->GetOutputItemSet() ) );
 455             pArgs = rReq.GetArgs();
 456         }
 457
 458         if( nResult != RET_OK )
 459             return;
 460     }
 461
 462     // evaluation of the ItemSets
 463     if (pArgs->GetItemState(ATTR_ANIMATION_ACTIVE) == SfxItemState::SET)
 464     {
 465         bActive = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ANIMATION_ACTIVE)).GetValue();
 466         nAnimationSet = ATTR_SET;
 467     }
 468     else
 469         nAnimationSet = ATTR_MISSING;
 470
 471     if (pArgs->GetItemState(ATTR_ANIMATION_EFFECT) == SfxItemState::SET)
 472     {
 473         eEffect = static_cast<presentation::AnimationEffect>(static_cast<const SfxAllEnumItem&>( pArgs->
 474                     Get(ATTR_ANIMATION_EFFECT)).GetValue());
 475         nEffectSet = ATTR_SET;
 476     }
 477     else
 478         nEffectSet = ATTR_MISSING;
 479
 480     if (pArgs->GetItemState(ATTR_ANIMATION_TEXTEFFECT) == SfxItemState::SET)
 481     {
 482         eTextEffect = static_cast<presentation::AnimationEffect>(static_cast<const SfxAllEnumItem&>( pArgs->
 483                         Get(ATTR_ANIMATION_TEXTEFFECT)).GetValue());
 484         nTextEffectSet = ATTR_SET;
 485     }
 486     else
 487         nTextEffectSet = ATTR_MISSING;
 488
 489     if (pArgs->GetItemState(ATTR_ANIMATION_SPEED) == SfxItemState::SET)
 490     {
 491         eSpeed  = static_cast<presentation::AnimationSpeed>(static_cast<const SfxAllEnumItem&>( pArgs->
 492                     Get(ATTR_ANIMATION_SPEED)).GetValue());
 493         nSpeedSet = ATTR_SET;
 494     }
 495     else
 496         nSpeedSet = ATTR_MISSING;
 497
 498     if (pArgs->GetItemState(ATTR_ANIMATION_FADEOUT) == SfxItemState::SET)
 499     {
 500         bFadeOut = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ANIMATION_FADEOUT)).GetValue();
 501         nFadeOutSet = ATTR_SET;
 502     }
 503     else
 504         nFadeOutSet = ATTR_MISSING;
 505
 506     if (pArgs->GetItemState(ATTR_ANIMATION_INVISIBLE) == SfxItemState::SET)
 507     {
 508         bInvisible = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ANIMATION_INVISIBLE)).GetValue();
 509         nInvisibleSet = ATTR_SET;
 510     }
 511     else
 512         nInvisibleSet = ATTR_MISSING;
 513
 514     if (pArgs->GetItemState(ATTR_ANIMATION_SOUNDON) == SfxItemState::SET)
 515     {
 516         bSoundOn = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ANIMATION_SOUNDON)).GetValue();
 517         nSoundOnSet = ATTR_SET;
 518     }
 519     else
 520         nSoundOnSet = ATTR_MISSING;
 521
 522     if (pArgs->GetItemState(ATTR_ANIMATION_SOUNDFILE) == SfxItemState::SET)
 523     {
 524         aSound = static_cast<const SfxStringItem&>(pArgs->Get(ATTR_ANIMATION_SOUNDFILE)).GetValue();
 525         nSoundFileSet = ATTR_SET;
 526     }
 527     else
 528         nSoundFileSet = ATTR_MISSING;
 529
 530     if (pArgs->GetItemState(ATTR_ANIMATION_COLOR) == SfxItemState::SET)
 531     {
 532         aFadeColor = static_cast<const SvxColorItem&>(pArgs->Get(ATTR_ANIMATION_COLOR)).GetValue();
 533         nFadeColorSet = ATTR_SET;
 534     }
 535     else
 536         nFadeColorSet = ATTR_MISSING;
 537
 538     if (pArgs->GetItemState(ATTR_ANIMATION_PLAYFULL) == SfxItemState::SET)
 539     {
 540         bPlayFull = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ANIMATION_PLAYFULL)).GetValue();
 541         nPlayFullSet = ATTR_SET;
 542     }
 543     else
 544         nPlayFullSet = ATTR_MISSING;
 545
 546     if (pArgs->GetItemState(ATTR_ACTION) == SfxItemState::SET)
 547     {
 548         eClickAction = static_cast<presentation::ClickAction>(static_cast<const SfxAllEnumItem&>(pArgs->
 549                     Get(ATTR_ACTION)).GetValue());
 550         nClickActionSet = ATTR_SET;
 551     }
 552     else
 553         nClickActionSet = ATTR_MISSING;
 554
 555     if (pArgs->GetItemState(ATTR_ACTION_FILENAME) == SfxItemState::SET)
 556     {
 557         aBookmark = static_cast<const SfxStringItem&>(pArgs->
 558                         Get(ATTR_ACTION_FILENAME)).GetValue();
 559         nBookmarkSet = ATTR_SET;
 560     }
 561     else
 562         nBookmarkSet = ATTR_MISSING;
 563
 564     if (pArgs->GetItemState(ATTR_ACTION_EFFECT) == SfxItemState::SET)
 565     {
 566         eSecondEffect = static_cast<presentation::AnimationEffect>(static_cast<const SfxAllEnumItem&>( pArgs->
 567                     Get(ATTR_ACTION_EFFECT)).GetValue());
 568         nSecondEffectSet = ATTR_SET;
 569     }
 570     else
 571         nSecondEffectSet = ATTR_MISSING;
 572
 573     if (pArgs->GetItemState(ATTR_ACTION_EFFECTSPEED) == SfxItemState::SET)
 574     {
 575         eSecondSpeed  = static_cast<presentation::AnimationSpeed>(static_cast<const SfxAllEnumItem&>( pArgs->
 576                     Get(ATTR_ACTION_EFFECTSPEED)).GetValue());
 577         nSecondSpeedSet = ATTR_SET;
 578     }
 579     else
 580         nSecondSpeedSet = ATTR_MISSING;
 581
 582     if (pArgs->GetItemState(ATTR_ACTION_SOUNDON) == SfxItemState::SET)
 583     {
 584         bSecondSoundOn = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ACTION_SOUNDON)).GetValue();
 585         nSecondSoundOnSet = ATTR_SET;
 586     }
 587     else
 588         nSecondSoundOnSet = ATTR_MISSING;
 589
 590     if (pArgs->GetItemState(ATTR_ACTION_PLAYFULL) == SfxItemState::SET)
 591     {
 592         bSecondPlayFull = static_cast<const SfxBoolItem&>(pArgs->Get(ATTR_ACTION_PLAYFULL)).GetValue();
 593         nSecondPlayFullSet = ATTR_SET;
 594     }
 595     else
 596         nSecondPlayFullSet = ATTR_MISSING;
 597
 598     // if any attribute is chosen
 599     if (nEffectSet         == ATTR_SET  ||
 600         nTextEffectSet     == ATTR_SET  ||
 601         nSpeedSet          == ATTR_SET  ||
 602         nAnimationSet      == ATTR_SET  ||
 603         nFadeOutSet        == ATTR_SET  ||
 604         nFadeColorSet      == ATTR_SET  ||
 605         nInvisibleSet      == ATTR_SET  ||
 606         nSoundOnSet        == ATTR_SET  ||
 607         nSoundFileSet      == ATTR_SET  ||
 608         nPlayFullSet       == ATTR_SET  ||
 609         nClickActionSet    == ATTR_SET  ||
 610         nBookmarkSet       == ATTR_SET  ||
 611         nSecondEffectSet   == ATTR_SET  ||
 612         nSecondSpeedSet    == ATTR_SET  ||
 613         nSecondSoundOnSet  == ATTR_SET  ||
 614         nSecondPlayFullSet == ATTR_SET)
 615     {
 616         // String for undo-group and list-action
 617         OUString aComment(SdResId(STR_UNDO_ANIMATION));
 618
 619         // with 'following curves', we have an additional UndoAction
 620         // therefore cling? here
 621         pUndoMgr->EnterListAction(aComment, aComment, 0, mpViewShell->GetViewShellBase().GetViewShellId());
 622
 623         // create undo group
 624         SdUndoGroup* pUndoGroup = new SdUndoGroup(mpDoc);
 625         pUndoGroup->SetComment(aComment);
 626
 627         // for the path effect, remember some stuff
 628         SdrPathObj* pPath       = nullptr;
 629         if (eEffect == presentation::AnimationEffect_PATH && nEffectSet == ATTR_SET)
 630         {
 631             DBG_ASSERT(nCount == 2, "This effect expects two selected objects");
 632             SdrObject* pObject1 = rMarkList.GetMark(0)->GetMarkedSdrObj();
 633             SdrObject* pObject2 = rMarkList.GetMark(1)->GetMarkedSdrObj();
 634             SdrObjKind eKind1   = static_cast<SdrObjKind>(pObject1->GetObjIdentifier());
 635             SdrObjKind eKind2   = static_cast<SdrObjKind>(pObject2->GetObjIdentifier());
 636             SdrObject* pRunningObj = nullptr;
 637
 638             if (pObject1->GetObjInventor() == SdrInventor::Default &&
 639                 ((eKind1 == OBJ_LINE) ||        // 2 point line
 640                  (eKind1 == OBJ_PLIN) ||        // Polygon
 641                  (eKind1 == OBJ_PATHLINE)))     // Bezier curve
 642             {
 643                 pPath = static_cast<SdrPathObj*>(pObject1);
 644                 pRunningObj = pObject2;
 645             }
 646
 647             if (pObject2->GetObjInventor() == SdrInventor::Default &&
 648                 ((eKind2 == OBJ_LINE) ||        // 2 point line
 649                  (eKind2 == OBJ_PLIN) ||        // Polygon
 650                  (eKind2 == OBJ_PATHLINE)))     // Bezier curve
 651             {
 652                 pPath = static_cast<SdrPathObj*>(pObject2);
 653                 pRunningObj = pObject1;
 654             }
 655
 656             assert(pRunningObj && pPath && "no curve found");
 657
 658             // push the running object to the end of the curve
 659             if (pRunningObj)
 660             {
 661                 ::tools::Rectangle aCurRect(pRunningObj->GetLogicRect());
 662                 Point     aCurCenter(aCurRect.Center());
 663                 const ::basegfx::B2DPolyPolygon& rPolyPolygon = pPath->GetPathPoly();
 664                 sal_uInt32 nNoOfPolygons(rPolyPolygon.count());
 665                 const ::basegfx::B2DPolygon aPolygon(rPolyPolygon.getB2DPolygon(nNoOfPolygons - 1));
 666                 sal_uInt32 nPoints(aPolygon.count());
 667                 const ::basegfx::B2DPoint aNewB2DCenter(aPolygon.getB2DPoint(nPoints - 1));
 668                 const Point aNewCenter(FRound(aNewB2DCenter.getX()), FRound(aNewB2DCenter.getY()));
 669                 Size aDistance(aNewCenter.X() - aCurCenter.X(), aNewCenter.Y() - aCurCenter.Y());
 670                 pRunningObj->Move(aDistance);
 671
 672                 pUndoMgr->AddUndoAction(mpDoc->GetSdrUndoFactory().CreateUndoMoveObject( *pRunningObj, aDistance));
 673             }
 674         }
 675
 676         for (size_t nObject = 0; nObject < nCount; ++nObject)
 677         {
 678             SdrObject* pObject = rMarkList.GetMark(nObject)->GetMarkedSdrObj();
 679
 680             pInfo = SdDrawDocument::GetAnimationInfo(pObject);
 681
 682             bool bCreated = false;
 683             if( !pInfo )
 684             {
 685                 pInfo = SdDrawDocument::GetShapeUserData(*pObject,true);
 686                 bCreated = true;
 687             }
 688
 689             // path object for 'following curves'?
 690             if (eEffect == presentation::AnimationEffect_PATH && pObject == pPath)
 691             {
 692                 SdAnimationPrmsUndoAction* pAction = new SdAnimationPrmsUndoAction
 693                                                 (mpDoc, pObject, bCreated);
 694                 pAction->SetActive(pInfo->mbActive, pInfo->mbActive);
 695                 pAction->SetEffect(pInfo->meEffect, pInfo->meEffect);
 696                 pAction->SetTextEffect(pInfo->meTextEffect, pInfo->meTextEffect);
 697                 pAction->SetSpeed(pInfo->meSpeed, pInfo->meSpeed);
 698                 pAction->SetDim(pInfo->mbDimPrevious, pInfo->mbDimPrevious);
 699                 pAction->SetDimColor(pInfo->maDimColor, pInfo->maDimColor);
 700                 pAction->SetDimHide(pInfo->mbDimHide, pInfo->mbDimHide);
 701                 pAction->SetSoundOn(pInfo->mbSoundOn, pInfo->mbSoundOn);
 702                 pAction->SetSound(pInfo->maSoundFile, pInfo->maSoundFile);
 703                 pAction->SetPlayFull(pInfo->mbPlayFull, pInfo->mbPlayFull);
 704                 pAction->SetClickAction(pInfo->meClickAction, pInfo->meClickAction);
 705                 pAction->SetBookmark(pInfo->GetBookmark(), pInfo->GetBookmark());
 706                 pAction->SetVerb(pInfo->mnVerb, pInfo->mnVerb);
 707                 pAction->SetSecondEffect(pInfo->meSecondEffect, pInfo->meSecondEffect);
 708                 pAction->SetSecondSpeed(pInfo->meSecondSpeed, pInfo->meSecondSpeed);
 709                 pAction->SetSecondSoundOn(pInfo->mbSecondSoundOn, pInfo->mbSecondSoundOn);
 710                 pAction->SetSecondPlayFull(pInfo->mbSecondPlayFull, pInfo->mbSecondPlayFull);
 711                 pUndoGroup->AddAction(pAction);
 712
 713             }
 714             else
 715             {
 716
 717                 // create undo action with old and new sizes
 718                 SdAnimationPrmsUndoAction* pAction = new SdAnimationPrmsUndoAction
 719                                                 (mpDoc, pObject, bCreated);
 720                 pAction->SetActive(pInfo->mbActive, bActive);
 721                 pAction->SetEffect(pInfo->meEffect, eEffect);
 722                 pAction->SetTextEffect(pInfo->meTextEffect, eTextEffect);
 723                 pAction->SetSpeed(pInfo->meSpeed, eSpeed);
 724                 pAction->SetDim(pInfo->mbDimPrevious, bFadeOut);
 725                 pAction->SetDimColor(pInfo->maDimColor, aFadeColor);
 726                 pAction->SetDimHide(pInfo->mbDimHide, bInvisible);
 727                 pAction->SetSoundOn(pInfo->mbSoundOn, bSoundOn);
 728                 pAction->SetSound(pInfo->maSoundFile, aSound);
 729                 pAction->SetPlayFull(pInfo->mbPlayFull, bPlayFull);
 730                 pAction->SetClickAction(pInfo->meClickAction, eClickAction);
 731                 pAction->SetBookmark(pInfo->GetBookmark(), aBookmark);
 732                 pAction->SetVerb(pInfo->mnVerb, static_cast<sal_uInt16>(pInfo->GetBookmark().toInt32()) );
 733                 pAction->SetSecondEffect(pInfo->meSecondEffect, eSecondEffect);
 734                 pAction->SetSecondSpeed(pInfo->meSecondSpeed, eSecondSpeed);
 735                 pAction->SetSecondSoundOn(pInfo->mbSecondSoundOn, bSecondSoundOn);
 736                 pAction->SetSecondPlayFull(pInfo->mbSecondPlayFull,bSecondPlayFull);
 737                 pUndoGroup->AddAction(pAction);
 738
 739                 // insert new values at info block of the object
 740                 if (nAnimationSet == ATTR_SET)
 741                     pInfo->mbActive = bActive;
 742
 743                 if (nEffectSet == ATTR_SET)
 744                     pInfo->meEffect = eEffect;
 745
 746                 if (nTextEffectSet == ATTR_SET)
 747                     pInfo->meTextEffect = eTextEffect;
 748
 749                 if (nSpeedSet == ATTR_SET)
 750                     pInfo->meSpeed = eSpeed;
 751
 752                 if (nFadeOutSet == ATTR_SET)
 753                     pInfo->mbDimPrevious = bFadeOut;
 754
 755                 if (nFadeColorSet == ATTR_SET)
 756                     pInfo->maDimColor = aFadeColor;
 757
 758                 if (nInvisibleSet == ATTR_SET)
 759                     pInfo->mbDimHide = bInvisible;
 760
 761                 if (nSoundOnSet == ATTR_SET)
 762                     pInfo->mbSoundOn = bSoundOn;
 763
 764                 if (nSoundFileSet == ATTR_SET)
 765                     pInfo->maSoundFile = aSound;
 766
 767                 if (nPlayFullSet == ATTR_SET)
 768                     pInfo->mbPlayFull = bPlayFull;
 769
 770                 if (nClickActionSet == ATTR_SET)
 771                     pInfo->meClickAction = eClickAction;
 772
 773                 if (nBookmarkSet == ATTR_SET)
 774                     pInfo->SetBookmark( aBookmark );
 775
 776                 if (nSecondEffectSet == ATTR_SET)
 777                     pInfo->meSecondEffect = eSecondEffect;
 778
 779                 if (nSecondSpeedSet == ATTR_SET)
 780                     pInfo->meSecondSpeed = eSecondSpeed;
 781
 782                 if (nSecondSoundOnSet == ATTR_SET)
 783                     pInfo->mbSecondSoundOn = bSecondSoundOn;
 784
 785                 if (nSecondPlayFullSet == ATTR_SET)
 786                     pInfo->mbSecondPlayFull = bSecondPlayFull;
 787
 788                 if (eClickAction == presentation::ClickAction_VERB)
 789                     pInfo->mnVerb = static_cast<sal_uInt16>(aBookmark.toInt32());
 790             }
 791         }
 792         // Set the Undo Group in of the Undo Manager
 793         pUndoMgr->AddUndoAction(pUndoGroup);
 794         pUndoMgr->LeaveListAction();
 795
 796         // Model changed
 797         mpDoc->SetChanged();
 798     }
 799     // not seen, therefore we do not need to invalidate at the bindings
 800 }
 801
 802 } // end of namespace sd
 803
 804 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */