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