sd/source/core/CustomAnimationPreset.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 <sal/config.h>
  21
  22 #include <com/sun/star/io/IOException.hpp>
  23 #include <com/sun/star/util/XCloneable.hpp>
  24 #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
  25 #include <com/sun/star/container/XNameAccess.hpp>
  26 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  27 #include <com/sun/star/xml/sax/InputSource.hpp>
  28 #include <com/sun/star/xml/sax/Parser.hpp>
  29 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  30 #include <com/sun/star/presentation/EffectPresetClass.hpp>
  31 #include <com/sun/star/beans/NamedValue.hpp>
  32 #include <osl/diagnose.h>
  33 #include <unotools/streamwrap.hxx>
  34 #include <comphelper/getexpandeduri.hxx>
  35 #include <comphelper/processfactory.hxx>
  36 #include <comphelper/propertysequence.hxx>
  37 #include <comphelper/random.hxx>
  38 #include <comphelper/lok.hxx>
  39 #include <unotools/pathoptions.hxx>
  40 #include <unotools/syslocaleoptions.hxx>
  41 #include <tools/stream.hxx>
  42
  43 #include <tools/debug.hxx>
  44 #include <vcl/svapp.hxx>
  45 #include <unotools/ucbstreamhelper.hxx>
  46 #include <CustomAnimationPreset.hxx>
  47
  48 #include <algorithm>
  49 #include <vector>
  50
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::com::sun::star::animations;
  54 using namespace ::com::sun::star::presentation;
  55
  56 using ::com::sun::star::io::XInputStream;
  57 using ::com::sun::star::lang::XMultiServiceFactory;
  58 using ::com::sun::star::container::XNameAccess;
  59 using ::com::sun::star::util::XCloneable;
  60 using ::com::sun::star::beans::NamedValue;
  61
  62 namespace sd {
  63
  64 static Reference< XNameAccess > getNodeAccess( const Reference< XMultiServiceFactory >& xConfigProvider, const OUString& rNodePath )
  65 {
  66     Reference< XNameAccess > xConfigAccess;
  67
  68     try
  69     {
  70         Sequence<Any> aArgs(comphelper::InitAnyPropertySequence(
  71         {
  72             {"nodepath", uno::Any(rNodePath)}
  73         }));
  74
  75         xConfigAccess.set(
  76             xConfigProvider->createInstanceWithArguments( "com.sun.star.configuration.ConfigurationAccess", aArgs ),
  77             UNO_QUERY);
  78     }
  79     catch (const Exception&)
  80     {
  81         OSL_FAIL( "sd::getNodeAccess(), Exception caught!" );
  82     }
  83
  84     return xConfigAccess;
  85 }
  86
  87 void implImportLabels( const Reference< XMultiServiceFactory >& xConfigProvider, const OUString& rNodePath, UStringMap& rStringMap )
  88 {
  89     try
  90     {
  91         Reference< XNameAccess > xConfigAccess( getNodeAccess( xConfigProvider, rNodePath ) );
  92         if( xConfigAccess.is() )
  93         {
  94             Reference< XNameAccess > xNameAccess;
  95             const Sequence< OUString > aNames( xConfigAccess->getElementNames() );
  96             for(const OUString& rName : aNames)
  97             {
  98                 xConfigAccess->getByName( rName ) >>= xNameAccess;
  99                 if( xNameAccess.is() )
 100                 {
 101                     OUString aUIName;
 102                     xNameAccess->getByName( "Label" ) >>= aUIName;
 103                     if( !aUIName.isEmpty() )
 104                     {
 105                         rStringMap[ rName ] = aUIName;
 106                     }
 107                 }
 108             }
 109         }
 110     }
 111     catch (const lang::WrappedTargetException&)
 112     {
 113         OSL_FAIL( "sd::implImportLabels(), WrappedTargetException caught!" );
 114     }
 115     catch (const Exception&)
 116     {
 117         OSL_FAIL( "sd::implImportLabels(), Exception caught!" );
 118     }
 119 }
 120
 121 CustomAnimationPreset::CustomAnimationPreset( const CustomAnimationEffectPtr& pEffect )
 122 {
 123     maPresetId = pEffect->getPresetId();
 124     maProperty = pEffect->getProperty();
 125
 126     add( pEffect );
 127
 128     mfDuration = pEffect->getDuration();
 129     maDefaultSubTyp = pEffect->getPresetSubType();
 130
 131     Sequence< NamedValue > aUserData( pEffect->getNode()->getUserData() );
 132
 133     mbIsTextOnly = std::any_of(aUserData.begin(), aUserData.end(),
 134         [](const NamedValue& rProp) { return rProp.Name == "text-only"; });
 135 }
 136
 137 void CustomAnimationPreset::add( const CustomAnimationEffectPtr& pEffect )
 138 {
 139     maSubTypes[ pEffect->getPresetSubType() ] = pEffect;
 140 }
 141
 142 std::vector<OUString> CustomAnimationPreset::getSubTypes()
 143 {
 144     std::vector<OUString> aSubTypes;
 145
 146     if( maSubTypes.size() > 1 )
 147     {
 148         std::transform(maSubTypes.begin(), maSubTypes.end(), std::back_inserter(aSubTypes),
 149             [](EffectsSubTypeMap::value_type& rEntry) -> OUString { return rEntry.first; });
 150     }
 151
 152     return aSubTypes;
 153 }
 154
 155 Reference< XAnimationNode > CustomAnimationPreset::create( const OUString& rstrSubType )
 156 {
 157     try
 158     {
 159         OUString strSubType( rstrSubType );
 160         if( strSubType.isEmpty() )
 161             strSubType = maDefaultSubTyp;
 162
 163         CustomAnimationEffectPtr pEffect = maSubTypes[strSubType];
 164         if( pEffect.get() )
 165         {
 166             Reference< XCloneable > xCloneable( pEffect->getNode(), UNO_QUERY_THROW );
 167             Reference< XAnimationNode > xNode( xCloneable->createClone(), UNO_QUERY_THROW );
 168             return xNode;
 169         }
 170     }
 171     catch (const Exception&)
 172     {
 173         OSL_FAIL( "sd::CustomAnimationPresets::create(), exception caught!" );
 174     }
 175
 176     Reference< XAnimationNode > xNode;
 177     return xNode;
 178 }
 179
 180 std::vector<OUString> CustomAnimationPreset::getProperties() const
 181 {
 182     std::vector<OUString> aPropertyList;
 183     if (!maProperty.isEmpty())
 184     {
 185         sal_Int32 nPos = 0;
 186         do
 187         {
 188             aPropertyList.push_back(maProperty.getToken(0, ';', nPos));
 189         }
 190         while (nPos >= 0);
 191     }
 192     return aPropertyList;
 193 }
 194
 195 bool CustomAnimationPreset::hasProperty( const OUString& rProperty )const
 196 {
 197     if (maProperty.isEmpty())
 198         return false;
 199
 200     sal_Int32 nPos = 0;
 201     do
 202     {
 203         if (maProperty.getToken(0, ';', nPos) == rProperty)
 204             return true;
 205     }
 206     while (nPos >= 0);
 207
 208     return false;
 209 }
 210
 211 CustomAnimationPresets::CustomAnimationPresets()
 212 {
 213 }
 214
 215 CustomAnimationPresets::~CustomAnimationPresets()
 216 {
 217 }
 218
 219 Reference< XAnimationNode > implImportEffects( const Reference< XMultiServiceFactory >& xServiceFactory, const OUString& rPath )
 220 {
 221     Reference< XAnimationNode > xRootNode;
 222
 223     try
 224     {
 225         // create stream
 226         std::unique_ptr<SvStream> pIStm = ::utl::UcbStreamHelper::CreateStream( rPath, StreamMode::READ );
 227         Reference<XInputStream> xInputStream( new utl::OInputStreamWrapper( std::move(pIStm) ) );
 228
 229         // prepare ParserInputSrouce
 230         xml::sax::InputSource aParserInput;
 231         aParserInput.sSystemId = rPath;
 232         aParserInput.aInputStream = xInputStream;
 233
 234         // get parser
 235         Reference< xml::sax::XParser > xParser = xml::sax::Parser::create( comphelper::getComponentContext(xServiceFactory) );
 236
 237         // get filter
 238         Reference< xml::sax::XDocumentHandler > xFilter( xServiceFactory->createInstance("com.sun.star.comp.Xmloff.AnimationsImport" ), UNO_QUERY );
 239
 240         DBG_ASSERT( xFilter.is(), "Can't instantiate filter component." );
 241         if( !xFilter.is() )
 242             return xRootNode;
 243
 244         // connect parser and filter
 245         xParser->setDocumentHandler( xFilter );
 246
 247         // finally, parser the stream
 248         xParser->parseStream( aParserInput );
 249
 250         Reference< XAnimationNodeSupplier > xAnimationNodeSupplier( xFilter, UNO_QUERY );
 251         if( xAnimationNodeSupplier.is() )
 252             xRootNode = xAnimationNodeSupplier->getAnimationNode();
 253     }
 254     catch (const xml::sax::SAXParseException&)
 255     {
 256         OSL_FAIL( "sd::implImportEffects(), SAXParseException caught!" );
 257     }
 258     catch (const xml::sax::SAXException&)
 259     {
 260         OSL_FAIL( "sd::implImportEffects(), SAXException caught!" );
 261     }
 262     catch (const io::IOException&)
 263     {
 264         OSL_FAIL( "sd::implImportEffects(), IOException caught!" );
 265     }
 266     catch (const Exception&)
 267     {
 268         OSL_FAIL( "sd::importEffects(), Exception caught!" );
 269     }
 270
 271     return xRootNode;
 272 }
 273
 274 void CustomAnimationPresets::importEffects()
 275 {
 276     try
 277     {
 278         uno::Reference< uno::XComponentContext > xContext(
 279             comphelper::getProcessComponentContext() );
 280         Reference< XMultiServiceFactory > xServiceFactory(
 281             xContext->getServiceManager(), UNO_QUERY_THROW );
 282
 283         Reference< XMultiServiceFactory > xConfigProvider =
 284             configuration::theDefaultProvider::get( xContext );
 285
 286         // read path to transition effects files from config
 287         uno::Sequence<uno::Any> aArgs(comphelper::InitAnyPropertySequence(
 288         {
 289             {"nodepath", uno::Any(OUString("/org.openoffice.Office.Impress/Misc"))}
 290         }));
 291         Reference<container::XNameAccess> xNameAccess(
 292             xConfigProvider->createInstanceWithArguments(
 293                 "com.sun.star.configuration.ConfigurationAccess",
 294                 aArgs ), UNO_QUERY_THROW );
 295         uno::Sequence< OUString > aFiles;
 296         xNameAccess->getByName( "EffectFiles" ) >>= aFiles;
 297
 298         for( const auto& rFile : std::as_const(aFiles) )
 299         {
 300             OUString aURL = comphelper::getExpandedUri(xContext, rFile);
 301
 302             mxRootNode = implImportEffects( xServiceFactory, aURL );
 303
 304             if( mxRootNode.is() )
 305             {
 306                 Reference< XTimeContainer > xRootContainer( mxRootNode, UNO_QUERY_THROW );
 307                 EffectSequenceHelper aSequence( xRootContainer );
 308
 309                 EffectSequence::iterator aIter( aSequence.getBegin() );
 310                 const EffectSequence::iterator aEnd( aSequence.getEnd() );
 311
 312                 while( aIter != aEnd )
 313                 {
 314                     CustomAnimationEffectPtr pEffect = *aIter;
 315
 316                     const OUString aPresetId( pEffect->getPresetId() );
 317                     CustomAnimationPresetPtr pDescriptor = getEffectDescriptor( aPresetId );
 318                     if( pDescriptor.get() )
 319                         pDescriptor->add( pEffect );
 320                     else
 321                     {
 322                         pDescriptor.reset( new CustomAnimationPreset( pEffect ) );
 323                         pDescriptor->maLabel = getUINameForPresetId( pEffect->getPresetId() );
 324                         maEffectDiscriptorMap[aPresetId] = pDescriptor;
 325                     }
 326
 327                     ++aIter;
 328                 }
 329             }
 330         }
 331     }
 332     catch (const xml::sax::SAXParseException&)
 333     {
 334         OSL_FAIL( "sd::CustomAnimationPresets::importEffects(), SAXParseException caught!" );
 335     }
 336     catch (const xml::sax::SAXException&)
 337     {
 338         OSL_FAIL( "sd::CustomAnimationPresets::importEffects(), SAXException caught!" );
 339     }
 340     catch (const io::IOException&)
 341     {
 342         OSL_FAIL( "sd::CustomAnimationPresets::importEffects(), IOException caught!" );
 343     }
 344     catch (const Exception&)
 345     {
 346         OSL_FAIL( "sd::CustomAnimationPresets::importEffects(), Exception caught!" );
 347     }
 348 }
 349
 350 void CustomAnimationPresets::importResources()
 351 {
 352     try
 353     {
 354         // Get service factory
 355         Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
 356
 357         Reference< XMultiServiceFactory > xConfigProvider =
 358              configuration::theDefaultProvider::get( xContext );
 359
 360         const OUString aPropertyPath("/org.openoffice.Office.UI.Effects/UserInterface/Properties" );
 361         implImportLabels( xConfigProvider, aPropertyPath, maPropertyNameMap );
 362
 363         const OUString aEffectsPath( "/org.openoffice.Office.UI.Effects/UserInterface/Effects" );
 364         implImportLabels( xConfigProvider, aEffectsPath, maEffectNameMap );
 365
 366         importEffects();
 367
 368         const OUString aEntrancePath( "/org.openoffice.Office.UI.Effects/Presets/Entrance" );
 369         importPresets( xConfigProvider, aEntrancePath, maEntrancePresets );
 370
 371         const OUString aEmphasisPath( "/org.openoffice.Office.UI.Effects/Presets/Emphasis" );
 372         importPresets( xConfigProvider, aEmphasisPath, maEmphasisPresets );
 373
 374         const OUString aExitPath( "/org.openoffice.Office.UI.Effects/Presets/Exit" );
 375         importPresets( xConfigProvider, aExitPath, maExitPresets );
 376
 377         const OUString aMotionPathsPath( "/org.openoffice.Office.UI.Effects/Presets/MotionPaths" );
 378         importPresets( xConfigProvider, aMotionPathsPath, maMotionPathsPresets );
 379
 380         const OUString aMiscPath( "/org.openoffice.Office.UI.Effects/Presets/Misc" );
 381         importPresets( xConfigProvider, aMiscPath, maMiscPresets );
 382     }
 383     catch (const lang::WrappedTargetException&)
 384     {
 385         OSL_FAIL( "sd::CustomAnimationPresets::importResources(), WrappedTargetException caught!" );
 386     }
 387     catch (const Exception&)
 388     {
 389         OSL_FAIL( "sd::CustomAnimationPresets::importResources(), Exception caught!" );
 390     }
 391 }
 392
 393 void CustomAnimationPresets::importPresets( const Reference< XMultiServiceFactory >& xConfigProvider, const OUString& rNodePath, PresetCategoryList& rPresetMap  )
 394 {
 395 #ifdef DEBUG
 396     OUString aMissedPresetIds;
 397 #endif
 398
 399     try
 400     {
 401         Reference< XNameAccess > xTypeAccess( getNodeAccess( xConfigProvider, rNodePath ) );
 402         if( xTypeAccess.is() )
 403         {
 404             Reference< XNameAccess > xCategoryAccess;
 405
 406             const Sequence< OUString > aNames( xTypeAccess->getElementNames() );
 407             for(const OUString& rName : aNames)
 408             {
 409                 xTypeAccess->getByName( rName ) >>= xCategoryAccess;
 410
 411                 if( xCategoryAccess.is() && xCategoryAccess->hasByName( "Label" ) && xCategoryAccess->hasByName( "Effects" ) )
 412                 {
 413                     OUString aLabel;
 414                     xCategoryAccess->getByName( "Label" ) >>= aLabel;
 415
 416                     Sequence< OUString > aEffects;
 417                     xCategoryAccess->getByName( "Effects" ) >>= aEffects;
 418
 419                     EffectDescriptorList aEffectsList;
 420
 421                     for( const OUString& rEffectName : std::as_const(aEffects) )
 422                     {
 423                         CustomAnimationPresetPtr pEffect = getEffectDescriptor( rEffectName );
 424                         if( pEffect.get() )
 425                         {
 426                             aEffectsList.push_back( pEffect );
 427                         }
 428 #ifdef DEBUG
 429                         else
 430                         {
 431                             aMissedPresetIds += OUString(rEffectName);
 432                             aMissedPresetIds += "\n";
 433                         }
 434 #endif
 435                     }
 436                     rPresetMap.push_back( std::make_shared<PresetCategory>( aLabel, aEffectsList ) );
 437                 }
 438             }
 439         }
 440     }
 441     catch (const Exception&)
 442     {
 443         OSL_FAIL( "sd::CustomAnimationPresets::importPresets(), Exception caught!" );
 444     }
 445
 446 #ifdef DEBUG
 447     SAL_WARN_IF(!aMissedPresetIds.isEmpty(), "sd", "sd::CustomAnimationPresets::importPresets(), invalid preset id: "
 448                     << aMissedPresetIds);
 449 #endif
 450 }
 451
 452 CustomAnimationPresetPtr CustomAnimationPresets::getEffectDescriptor( const OUString& rPresetId ) const
 453 {
 454     EffectDescriptorMap::const_iterator aIter( maEffectDiscriptorMap.find( rPresetId ) );
 455
 456     if( aIter != maEffectDiscriptorMap.end() )
 457     {
 458         return (*aIter).second;
 459     }
 460     else
 461     {
 462         return CustomAnimationPresetPtr(nullptr);
 463     }
 464 }
 465
 466 const OUString& CustomAnimationPresets::getUINameForPresetId( const OUString& rPresetId ) const
 467 {
 468     return translateName( rPresetId, maEffectNameMap );
 469 }
 470
 471 const OUString& CustomAnimationPresets::getUINameForProperty( const OUString& rPresetId ) const
 472 {
 473     return translateName( rPresetId, maPropertyNameMap );
 474 }
 475
 476 const OUString& CustomAnimationPresets::translateName( const OUString& rId, const UStringMap& rNameMap )
 477 {
 478     UStringMap::const_iterator aIter( rNameMap.find( rId ) );
 479
 480     if( aIter != rNameMap.end() )
 481     {
 482         return (*aIter).second;
 483     }
 484     else
 485     {
 486         return rId;
 487     }
 488 }
 489 void CustomAnimationPresets::changePresetSubType( const CustomAnimationEffectPtr& pEffect, const OUString& rPresetSubType ) const
 490 {
 491     if( pEffect.get() && pEffect->getPresetSubType() != rPresetSubType )
 492     {
 493         CustomAnimationPresetPtr pDescriptor( getEffectDescriptor( pEffect->getPresetId() ) );
 494
 495         if( pDescriptor.get() )
 496         {
 497             Reference< XAnimationNode > xNewNode( pDescriptor->create( rPresetSubType ) );
 498             if( xNewNode.is() )
 499                 pEffect->replaceNode( xNewNode );
 500         }
 501     }
 502 }
 503
 504 std::map<OUString, CustomAnimationPresets>  CustomAnimationPresets::mPresetsMap;
 505
 506 const CustomAnimationPresets& CustomAnimationPresets::getCustomAnimationPresets()
 507 {
 508     // Support localization per-view. Currently not useful for Desktop
 509     // but very much critical for LOK. The cache now is per-language.
 510     const OUString aLang = comphelper::LibreOfficeKit::isActive()
 511                                ? comphelper::LibreOfficeKit::getLanguageTag().getLanguage()
 512                                : SvtSysLocaleOptions().GetLanguageTag().getLanguage();
 513
 514     SolarMutexGuard aGuard;
 515     const auto it = mPresetsMap.find(aLang);
 516     if (it != mPresetsMap.end())
 517         return it->second;
 518
 519     CustomAnimationPresets& rPresets = mPresetsMap[aLang];
 520     rPresets.importResources();
 521     return rPresets;
 522 }
 523
 524 Reference< XAnimationNode > CustomAnimationPresets::getRandomPreset( sal_Int16 nPresetClass ) const
 525 {
 526     Reference< XAnimationNode > xNode;
 527
 528     const PresetCategoryList* pCategoryList = nullptr;
 529     switch( nPresetClass )
 530     {
 531     case EffectPresetClass::ENTRANCE:   pCategoryList = &maEntrancePresets; break;
 532     case EffectPresetClass::EXIT:       pCategoryList = &maExitPresets; break;
 533     case EffectPresetClass::EMPHASIS:   pCategoryList = &maEmphasisPresets; break;
 534     case EffectPresetClass::MOTIONPATH: pCategoryList = &maMotionPathsPresets; break;
 535     default:
 536         pCategoryList = nullptr;
 537     }
 538
 539     if( pCategoryList && !pCategoryList->empty() )
 540     {
 541         sal_Int32 nCategory = comphelper::rng::uniform_size_distribution(0, pCategoryList->size()-1);
 542
 543         PresetCategoryPtr pCategory = (*pCategoryList)[nCategory];
 544         if( pCategory.get() && !pCategory->maEffects.empty() )
 545         {
 546             sal_Int32 nDescriptor = comphelper::rng::uniform_size_distribution(0, pCategory->maEffects.size()-1);
 547             CustomAnimationPresetPtr pPreset = pCategory->maEffects[nDescriptor];
 548             if( pPreset.get() )
 549             {
 550                 std::vector<OUString> aSubTypes = pPreset->getSubTypes();
 551
 552                 OUString aSubType;
 553                 if( !aSubTypes.empty() )
 554                 {
 555                     size_t nSubType = comphelper::rng::uniform_size_distribution(0, aSubTypes.size()-1);
 556                     aSubType = aSubTypes[nSubType];
 557                 }
 558                 xNode = pPreset->create( aSubType );
 559             }
 560         }
 561     }
 562
 563     return xNode;
 564 }
 565
 566 }
 567
 568 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */