toolkit/source/awt/animatedimagespeer.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
  21 #include <toolkit/awt/animatedimagespeer.hxx>
  22 #include <toolkit/helper/property.hxx>
  23
  24 #include <com/sun/star/awt/XAnimatedImages.hpp>
  25 #include <com/sun/star/awt/Size.hpp>
  26 #include <com/sun/star/graphic/GraphicProvider.hpp>
  27 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/graphic/XGraphic.hpp>
  30 #include <com/sun/star/awt/ImageScaleMode.hpp>
  31
  32 #include <comphelper/namedvaluecollection.hxx>
  33 #include <comphelper/processfactory.hxx>
  34 #include <rtl/ustrbuf.hxx>
  35 #include <tools/diagnose_ex.h>
  36 #include <tools/urlobj.hxx>
  37 #include <vcl/throbber.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/settings.hxx>
  40
  41 #include <limits>
  42 #include <string_view>
  43
  44 namespace toolkit
  45 {
  46
  47
  48     using ::com::sun::star::uno::XComponentContext;
  49     using ::com::sun::star::uno::Reference;
  50     using ::com::sun::star::uno::XInterface;
  51     using ::com::sun::star::uno::UNO_QUERY;
  52     using ::com::sun::star::uno::UNO_QUERY_THROW;
  53     using ::com::sun::star::uno::Exception;
  54     using ::com::sun::star::uno::RuntimeException;
  55     using ::com::sun::star::uno::Any;
  56     using ::com::sun::star::uno::Sequence;
  57     using ::com::sun::star::lang::EventObject;
  58     using ::com::sun::star::container::ContainerEvent;
  59     using ::com::sun::star::awt::XAnimatedImages;
  60     using ::com::sun::star::awt::Size;
  61     using ::com::sun::star::graphic::XGraphicProvider;
  62     using ::com::sun::star::beans::XPropertySet;
  63     using ::com::sun::star::graphic::XGraphic;
  64
  65     namespace ImageScaleMode = ::com::sun::star::awt::ImageScaleMode;
  66
  67
  68     //= AnimatedImagesPeer_Data
  69
  70     struct CachedImage
  71     {
  72         OUString                 sImageURL;
  73         mutable Reference< XGraphic >   xGraphic;
  74
  75         CachedImage()
  76             :sImageURL()
  77             ,xGraphic()
  78         {
  79         }
  80
  81         explicit CachedImage( OUString const& i_imageURL )
  82             :sImageURL( i_imageURL )
  83             ,xGraphic()
  84         {
  85         }
  86     };
  87
  88     struct AnimatedImagesPeer_Data
  89     {
  90         AnimatedImagesPeer&                             rAntiImpl;
  91         ::std::vector< ::std::vector< CachedImage > >   aCachedImageSets;
  92
  93         explicit AnimatedImagesPeer_Data( AnimatedImagesPeer& i_antiImpl )
  94             :rAntiImpl( i_antiImpl )
  95             ,aCachedImageSets()
  96         {
  97         }
  98     };
  99
 100
 101     //= helper
 102
 103     namespace
 104     {
 105
 106         OUString lcl_getHighContrastURL( OUString const& i_imageURL )
 107         {
 108             INetURLObject aURL( i_imageURL );
 109             if ( aURL.GetProtocol() != INetProtocol::PrivSoffice )
 110             {
 111                 OSL_VERIFY( aURL.insertName( "sifr", false, 0 ) );
 112                 return aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 113             }
 114             // the private: scheme is not considered to be hierarchical by INetURLObject, so manually insert the
 115             // segment
 116             const sal_Int32 separatorPos = i_imageURL.indexOf( '/' );
 117             ENSURE_OR_RETURN( separatorPos != -1, "lcl_getHighContrastURL: unsupported URL scheme - cannot automatically determine HC version!", i_imageURL );
 118
 119             OUStringBuffer composer;
 120             composer.append( std::u16string_view(i_imageURL).substr(0, separatorPos) );
 121             composer.append( "/sifr" );
 122             composer.append( std::u16string_view(i_imageURL).substr(separatorPos) );
 123             return composer.makeStringAndClear();
 124         }
 125
 126
 127         bool lcl_ensureImage_throw( Reference< XGraphicProvider > const& i_graphicProvider, const bool i_isHighContrast, const CachedImage& i_cachedImage )
 128         {
 129             if ( !i_cachedImage.xGraphic.is() )
 130             {
 131                 ::comphelper::NamedValueCollection aMediaProperties;
 132                 if ( i_isHighContrast )
 133                 {
 134                     // try (to find) the high-contrast version of the graphic first
 135                     aMediaProperties.put( "URL", lcl_getHighContrastURL( i_cachedImage.sImageURL ) );
 136                     i_cachedImage.xGraphic.set( i_graphicProvider->queryGraphic( aMediaProperties.getPropertyValues() ), UNO_QUERY );
 137                 }
 138                 if ( !i_cachedImage.xGraphic.is() )
 139                 {
 140                     aMediaProperties.put( "URL", i_cachedImage.sImageURL );
 141                     i_cachedImage.xGraphic.set( i_graphicProvider->queryGraphic( aMediaProperties.getPropertyValues() ), UNO_QUERY );
 142                 }
 143             }
 144             return i_cachedImage.xGraphic.is();
 145         }
 146
 147
 148         Size lcl_getGraphicSizePixel( Reference< XGraphic > const& i_graphic )
 149         {
 150             Size aSizePixel;
 151             try
 152             {
 153                 if ( i_graphic.is() )
 154                 {
 155                     const Reference< XPropertySet > xGraphicProps( i_graphic, UNO_QUERY_THROW );
 156                     OSL_VERIFY( xGraphicProps->getPropertyValue("SizePixel") >>= aSizePixel );
 157                 }
 158             }
 159             catch( const Exception& )
 160             {
 161                 DBG_UNHANDLED_EXCEPTION("toolkit");
 162             }
 163             return aSizePixel;
 164         }
 165
 166
 167         void lcl_init( Sequence< OUString > const& i_imageURLs, ::std::vector< CachedImage >& o_images )
 168         {
 169             o_images.resize(0);
 170             size_t count = size_t( i_imageURLs.getLength() );
 171             o_images.reserve( count );
 172             for ( size_t i = 0; i < count; ++i )
 173             {
 174                 o_images.emplace_back( i_imageURLs[i] );
 175             }
 176         }
 177
 178
 179         void lcl_updateImageList_nothrow( AnimatedImagesPeer_Data& i_data )
 180         {
 181             VclPtr<Throbber> pThrobber = i_data.rAntiImpl.GetAsDynamic<Throbber>();
 182             if ( !pThrobber )
 183                 return;
 184
 185             try
 186             {
 187                 // collect the image sizes of the different image sets
 188                 const Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
 189                 const Reference< XGraphicProvider > xGraphicProvider( css::graphic::GraphicProvider::create(xContext) );
 190
 191                 const bool isHighContrast = pThrobber->GetSettings().GetStyleSettings().GetHighContrastMode();
 192
 193                 sal_Int32 nPreferredSet = -1;
 194                 const size_t nImageSetCount = i_data.aCachedImageSets.size();
 195                 if ( nImageSetCount < 2 )
 196                 {
 197                     nPreferredSet = sal_Int32( nImageSetCount ) - 1;
 198                 }
 199                 else
 200                 {
 201                     ::std::vector< Size > aImageSizes( nImageSetCount );
 202                     for ( size_t nImageSet = 0; nImageSet < nImageSetCount; ++nImageSet )
 203                     {
 204                         ::std::vector< CachedImage > const& rImageSet( i_data.aCachedImageSets[ nImageSet ] );
 205                         if  (   ( rImageSet.empty() )
 206                             ||  ( !lcl_ensureImage_throw( xGraphicProvider, isHighContrast, rImageSet[0] ) )
 207                             )
 208                         {
 209                             aImageSizes[ nImageSet ] = Size( SAL_MAX_INT32, SAL_MAX_INT32 );
 210                         }
 211                         else
 212                         {
 213                             aImageSizes[ nImageSet ] = lcl_getGraphicSizePixel( rImageSet[0].xGraphic );
 214                         }
 215                     }
 216
 217                     // find the set with the smallest difference between window size and image size
 218                     const ::Size aWindowSizePixel = pThrobber->GetSizePixel();
 219                     long nMinimalDistance = ::std::numeric_limits< long >::max();
 220                     for (   ::std::vector< Size >::const_iterator check = aImageSizes.begin();
 221                             check != aImageSizes.end();
 222                             ++check
 223                         )
 224                     {
 225                         if  (   ( check->Width > aWindowSizePixel.Width() )
 226                             ||  ( check->Height > aWindowSizePixel.Height() )
 227                             )
 228                             // do not use an image set which doesn't fit into the window
 229                             continue;
 230
 231                         const sal_Int64 distance =
 232                                 ( aWindowSizePixel.Width() - check->Width ) * ( aWindowSizePixel.Width() - check->Width )
 233                             +   ( aWindowSizePixel.Height() - check->Height ) * ( aWindowSizePixel.Height() - check->Height );
 234                         if ( distance < nMinimalDistance )
 235                         {
 236                             nMinimalDistance = distance;
 237                             nPreferredSet = check - aImageSizes.begin();
 238                         }
 239                     }
 240                 }
 241
 242                 // found a set?
 243                 std::vector< Image > aImages;
 244                 if ( ( nPreferredSet >= 0 ) && ( size_t( nPreferredSet ) < nImageSetCount ) )
 245                 {
 246                     // => set the images
 247                     ::std::vector< CachedImage > const& rImageSet( i_data.aCachedImageSets[ nPreferredSet ] );
 248                     aImages.resize( rImageSet.size() );
 249                     sal_Int32 imageIndex = 0;
 250                     for ( const auto& rCachedImage : rImageSet )
 251                     {
 252                         lcl_ensureImage_throw( xGraphicProvider, isHighContrast, rCachedImage );
 253                         aImages[ imageIndex++ ] = Image(rCachedImage.xGraphic);
 254                     }
 255                 }
 256                 pThrobber->setImageList( aImages );
 257             }
 258             catch( const Exception& )
 259             {
 260                 DBG_UNHANDLED_EXCEPTION("toolkit");
 261             }
 262         }
 263
 264
 265         void lcl_updateImageList_nothrow( AnimatedImagesPeer_Data& i_data, const Reference< XAnimatedImages >& i_images )
 266         {
 267             try
 268             {
 269                 const sal_Int32 nImageSetCount = i_images->getImageSetCount();
 270                 i_data.aCachedImageSets.resize(0);
 271                 for ( sal_Int32 set = 0;  set < nImageSetCount; ++set )
 272                 {
 273                     const Sequence< OUString > aImageURLs( i_images->getImageSet( set ) );
 274                     ::std::vector< CachedImage > aImages;
 275                     lcl_init( aImageURLs, aImages );
 276                     i_data.aCachedImageSets.push_back( aImages );
 277                 }
 278
 279                 lcl_updateImageList_nothrow( i_data );
 280             }
 281             catch( const Exception& )
 282             {
 283                 DBG_UNHANDLED_EXCEPTION("toolkit");
 284             }
 285         }
 286     }
 287
 288
 289     //= AnimatedImagesPeer
 290
 291
 292     AnimatedImagesPeer::AnimatedImagesPeer()
 293         :AnimatedImagesPeer_Base()
 294         ,m_xData( new AnimatedImagesPeer_Data( *this ) )
 295     {
 296     }
 297
 298
 299     AnimatedImagesPeer::~AnimatedImagesPeer()
 300     {
 301     }
 302
 303
 304     void SAL_CALL AnimatedImagesPeer::startAnimation()
 305     {
 306         SolarMutexGuard aGuard;
 307         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 308         if (pThrobber)
 309             pThrobber->start();
 310     }
 311
 312     void SAL_CALL AnimatedImagesPeer::stopAnimation()
 313     {
 314         SolarMutexGuard aGuard;
 315         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 316         if (pThrobber)
 317             pThrobber->stop();
 318     }
 319
 320     sal_Bool SAL_CALL AnimatedImagesPeer::isAnimationRunning()
 321     {
 322         SolarMutexGuard aGuard;
 323         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 324         if (pThrobber)
 325             return pThrobber->isRunning();
 326         return false;
 327     }
 328
 329     void SAL_CALL AnimatedImagesPeer::setProperty( const OUString& i_propertyName, const Any& i_value )
 330     {
 331         SolarMutexGuard aGuard;
 332
 333         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 334         if ( pThrobber )
 335         {
 336             VCLXWindow::setProperty( i_propertyName, i_value );
 337             return;
 338         }
 339
 340         const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
 341         switch ( nPropertyId )
 342         {
 343             case BASEPROPERTY_STEP_TIME:
 344             {
 345                 sal_Int32 nStepTime( 0 );
 346                 if ( i_value >>= nStepTime )
 347                     pThrobber->setStepTime( nStepTime );
 348                 break;
 349             }
 350             case BASEPROPERTY_AUTO_REPEAT:
 351             {
 352                 bool bRepeat( true );
 353                 if ( i_value >>= bRepeat )
 354                     pThrobber->setRepeat( bRepeat );
 355                 break;
 356             }
 357
 358             case BASEPROPERTY_IMAGE_SCALE_MODE:
 359             {
 360                 sal_Int16 nScaleMode( ImageScaleMode::ANISOTROPIC );
 361                 VclPtr<ImageControl> pImageControl = GetAsDynamic< ImageControl >();
 362                 if ( pImageControl && ( i_value >>= nScaleMode ) )
 363                     pImageControl->SetScaleMode( nScaleMode );
 364             }
 365             break;
 366
 367             default:
 368                 AnimatedImagesPeer_Base::setProperty( i_propertyName, i_value );
 369                 break;
 370         }
 371     }
 372
 373
 374     Any SAL_CALL AnimatedImagesPeer::getProperty( const OUString& i_propertyName )
 375     {
 376         SolarMutexGuard aGuard;
 377
 378         Any aReturn;
 379
 380         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 381         if ( !pThrobber )
 382             return VCLXWindow::getProperty( i_propertyName );
 383
 384         const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
 385         switch ( nPropertyId )
 386         {
 387         case BASEPROPERTY_STEP_TIME:
 388             aReturn <<= pThrobber->getStepTime();
 389             break;
 390
 391         case BASEPROPERTY_AUTO_REPEAT:
 392             aReturn <<= pThrobber->getRepeat();
 393             break;
 394
 395         case BASEPROPERTY_IMAGE_SCALE_MODE:
 396             {
 397                 VclPtr<ImageControl> pImageControl = GetAsDynamic<ImageControl>();
 398                 aReturn <<= ( pImageControl ? pImageControl->GetScaleMode() : ImageScaleMode::ANISOTROPIC );
 399             }
 400             break;
 401
 402         default:
 403             aReturn = AnimatedImagesPeer_Base::getProperty( i_propertyName );
 404             break;
 405         }
 406
 407         return aReturn;
 408     }
 409
 410
 411     void AnimatedImagesPeer::ProcessWindowEvent( const VclWindowEvent& i_windowEvent )
 412     {
 413         if ( i_windowEvent.GetId() == VclEventId::WindowResize )
 414         {
 415             lcl_updateImageList_nothrow( *m_xData );
 416         }
 417
 418         AnimatedImagesPeer_Base::ProcessWindowEvent( i_windowEvent );
 419     }
 420
 421
 422     void AnimatedImagesPeer::impl_updateImages_nolck( const Reference< XInterface >& i_animatedImages )
 423     {
 424         SolarMutexGuard aGuard;
 425
 426         lcl_updateImageList_nothrow( *m_xData, Reference< XAnimatedImages >( i_animatedImages, UNO_QUERY_THROW ) );
 427     }
 428
 429
 430     void SAL_CALL AnimatedImagesPeer::elementInserted( const ContainerEvent& i_event )
 431     {
 432         SolarMutexGuard aGuard;
 433         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 434
 435         sal_Int32 nPosition(0);
 436         OSL_VERIFY( i_event.Accessor >>= nPosition );
 437         size_t position = size_t( nPosition );
 438         if ( position > m_xData->aCachedImageSets.size() )
 439         {
 440             OSL_ENSURE( false, "AnimatedImagesPeer::elementInserted: illegal accessor/index!" );
 441             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 442         }
 443
 444         Sequence< OUString > aImageURLs;
 445         OSL_VERIFY( i_event.Element >>= aImageURLs );
 446         ::std::vector< CachedImage > aImages;
 447         lcl_init( aImageURLs, aImages );
 448         m_xData->aCachedImageSets.insert( m_xData->aCachedImageSets.begin() + position, aImages );
 449         lcl_updateImageList_nothrow( *m_xData );
 450     }
 451
 452
 453     void SAL_CALL AnimatedImagesPeer::elementRemoved( const ContainerEvent& i_event )
 454     {
 455         SolarMutexGuard aGuard;
 456         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 457
 458         sal_Int32 nPosition(0);
 459         OSL_VERIFY( i_event.Accessor >>= nPosition );
 460         size_t position = size_t( nPosition );
 461         if ( position >= m_xData->aCachedImageSets.size() )
 462         {
 463             OSL_ENSURE( false, "AnimatedImagesPeer::elementRemoved: illegal accessor/index!" );
 464             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 465         }
 466
 467         m_xData->aCachedImageSets.erase( m_xData->aCachedImageSets.begin() + position );
 468         lcl_updateImageList_nothrow( *m_xData );
 469     }
 470
 471
 472     void SAL_CALL AnimatedImagesPeer::elementReplaced( const ContainerEvent& i_event )
 473     {
 474         SolarMutexGuard aGuard;
 475         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 476
 477         sal_Int32 nPosition(0);
 478         OSL_VERIFY( i_event.Accessor >>= nPosition );
 479         size_t position = size_t( nPosition );
 480         if ( position >= m_xData->aCachedImageSets.size() )
 481         {
 482             OSL_ENSURE( false, "AnimatedImagesPeer::elementReplaced: illegal accessor/index!" );
 483             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 484         }
 485
 486         Sequence< OUString > aImageURLs;
 487         OSL_VERIFY( i_event.Element >>= aImageURLs );
 488         ::std::vector< CachedImage > aImages;
 489         lcl_init( aImageURLs, aImages );
 490         m_xData->aCachedImageSets[ position ] = aImages;
 491         lcl_updateImageList_nothrow( *m_xData );
 492     }
 493
 494
 495     void SAL_CALL AnimatedImagesPeer::disposing( const EventObject& i_event )
 496     {
 497         VCLXWindow::disposing( i_event );
 498     }
 499
 500
 501     void SAL_CALL AnimatedImagesPeer::modified( const EventObject& i_event )
 502     {
 503         impl_updateImages_nolck( i_event.Source );
 504     }
 505
 506
 507     void SAL_CALL AnimatedImagesPeer::dispose(  )
 508     {
 509         AnimatedImagesPeer_Base::dispose();
 510         SolarMutexGuard aGuard;
 511         m_xData->aCachedImageSets.resize(0);
 512     }
 513
 514
 515 } // namespace toolkit
 516
 517
 518 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */