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