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
  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( "hicontrast", 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( i_imageURL.copy( 0, separatorPos ) );
 121             composer.append( "/hicontrast" );
 122             composer.append( i_imageURL.copy( 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();
 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.push_back( CachedImage( 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 (   ::std::vector< CachedImage >::const_iterator cachedImage = rImageSet.begin();
 251                             cachedImage != rImageSet.end();
 252                             ++cachedImage, ++imageIndex
 253                         )
 254                     {
 255                         lcl_ensureImage_throw( xGraphicProvider, isHighContrast, *cachedImage );
 256                         aImages[ imageIndex ] = Image(cachedImage->xGraphic);
 257                     }
 258                 }
 259                 pThrobber->setImageList( aImages );
 260             }
 261             catch( const Exception& )
 262             {
 263                 DBG_UNHANDLED_EXCEPTION();
 264             }
 265         }
 266
 267
 268         void lcl_updateImageList_nothrow( AnimatedImagesPeer_Data& i_data, const Reference< XAnimatedImages >& i_images )
 269         {
 270             try
 271             {
 272                 const sal_Int32 nImageSetCount = i_images->getImageSetCount();
 273                 i_data.aCachedImageSets.resize(0);
 274                 for ( sal_Int32 set = 0;  set < nImageSetCount; ++set )
 275                 {
 276                     const Sequence< OUString > aImageURLs( i_images->getImageSet( set ) );
 277                     ::std::vector< CachedImage > aImages;
 278                     lcl_init( aImageURLs, aImages );
 279                     i_data.aCachedImageSets.push_back( aImages );
 280                 }
 281
 282                 lcl_updateImageList_nothrow( i_data );
 283             }
 284             catch( const Exception& )
 285             {
 286                 DBG_UNHANDLED_EXCEPTION();
 287             }
 288         }
 289     }
 290
 291
 292     //= AnimatedImagesPeer
 293
 294
 295     AnimatedImagesPeer::AnimatedImagesPeer()
 296         :AnimatedImagesPeer_Base()
 297         ,m_xData( new AnimatedImagesPeer_Data( *this ) )
 298     {
 299     }
 300
 301
 302     AnimatedImagesPeer::~AnimatedImagesPeer()
 303     {
 304     }
 305
 306
 307     void SAL_CALL AnimatedImagesPeer::startAnimation()
 308     {
 309         SolarMutexGuard aGuard;
 310         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 311         if (pThrobber)
 312             pThrobber->start();
 313     }
 314
 315     void SAL_CALL AnimatedImagesPeer::stopAnimation()
 316     {
 317         SolarMutexGuard aGuard;
 318         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 319         if (pThrobber)
 320             pThrobber->stop();
 321     }
 322
 323     sal_Bool SAL_CALL AnimatedImagesPeer::isAnimationRunning()
 324     {
 325         SolarMutexGuard aGuard;
 326         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 327         if (pThrobber)
 328             return pThrobber->isRunning();
 329         return false;
 330     }
 331
 332     void SAL_CALL AnimatedImagesPeer::setProperty( const OUString& i_propertyName, const Any& i_value )
 333     {
 334         SolarMutexGuard aGuard;
 335
 336         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 337         if ( pThrobber )
 338         {
 339             VCLXWindow::setProperty( i_propertyName, i_value );
 340             return;
 341         }
 342
 343         const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
 344         switch ( nPropertyId )
 345         {
 346             case BASEPROPERTY_STEP_TIME:
 347             {
 348                 sal_Int32 nStepTime( 0 );
 349                 if ( i_value >>= nStepTime )
 350                     pThrobber->setStepTime( nStepTime );
 351                 break;
 352             }
 353             case BASEPROPERTY_AUTO_REPEAT:
 354             {
 355                 bool bRepeat( true );
 356                 if ( i_value >>= bRepeat )
 357                     pThrobber->setRepeat( bRepeat );
 358                 break;
 359             }
 360
 361             case BASEPROPERTY_IMAGE_SCALE_MODE:
 362             {
 363                 sal_Int16 nScaleMode( ImageScaleMode::ANISOTROPIC );
 364                 VclPtr<ImageControl> pImageControl = GetAsDynamic< ImageControl >();
 365                 if ( pImageControl && ( i_value >>= nScaleMode ) )
 366                     pImageControl->SetScaleMode( nScaleMode );
 367             }
 368             break;
 369
 370             default:
 371                 AnimatedImagesPeer_Base::setProperty( i_propertyName, i_value );
 372                 break;
 373         }
 374     }
 375
 376
 377     Any SAL_CALL AnimatedImagesPeer::getProperty( const OUString& i_propertyName )
 378     {
 379         SolarMutexGuard aGuard;
 380
 381         Any aReturn;
 382
 383         VclPtr<Throbber> pThrobber = GetAsDynamic<Throbber>();
 384         if ( !pThrobber )
 385             return VCLXWindow::getProperty( i_propertyName );
 386
 387         const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
 388         switch ( nPropertyId )
 389         {
 390         case BASEPROPERTY_STEP_TIME:
 391             aReturn <<= pThrobber->getStepTime();
 392             break;
 393
 394         case BASEPROPERTY_AUTO_REPEAT:
 395             aReturn <<= pThrobber->getRepeat();
 396             break;
 397
 398         case BASEPROPERTY_IMAGE_SCALE_MODE:
 399             {
 400                 VclPtr<ImageControl> pImageControl = GetAsDynamic<ImageControl>();
 401                 aReturn <<= ( pImageControl ? pImageControl->GetScaleMode() : ImageScaleMode::ANISOTROPIC );
 402             }
 403             break;
 404
 405         default:
 406             aReturn = AnimatedImagesPeer_Base::getProperty( i_propertyName );
 407             break;
 408         }
 409
 410         return aReturn;
 411     }
 412
 413
 414     void AnimatedImagesPeer::ProcessWindowEvent( const VclWindowEvent& i_windowEvent )
 415     {
 416         if ( i_windowEvent.GetId() == VclEventId::WindowResize )
 417         {
 418             lcl_updateImageList_nothrow( *m_xData );
 419         }
 420
 421         AnimatedImagesPeer_Base::ProcessWindowEvent( i_windowEvent );
 422     }
 423
 424
 425     void AnimatedImagesPeer::impl_updateImages_nolck( const Reference< XInterface >& i_animatedImages )
 426     {
 427         SolarMutexGuard aGuard;
 428
 429         lcl_updateImageList_nothrow( *m_xData, Reference< XAnimatedImages >( i_animatedImages, UNO_QUERY_THROW ) );
 430     }
 431
 432
 433     void SAL_CALL AnimatedImagesPeer::elementInserted( const ContainerEvent& i_event )
 434     {
 435         SolarMutexGuard aGuard;
 436         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 437
 438         sal_Int32 nPosition(0);
 439         OSL_VERIFY( i_event.Accessor >>= nPosition );
 440         size_t position = size_t( nPosition );
 441         if ( position > m_xData->aCachedImageSets.size() )
 442         {
 443             OSL_ENSURE( false, "AnimatedImagesPeer::elementInserted: illegal accessor/index!" );
 444             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 445         }
 446
 447         Sequence< OUString > aImageURLs;
 448         OSL_VERIFY( i_event.Element >>= aImageURLs );
 449         ::std::vector< CachedImage > aImages;
 450         lcl_init( aImageURLs, aImages );
 451         m_xData->aCachedImageSets.insert( m_xData->aCachedImageSets.begin() + position, aImages );
 452         lcl_updateImageList_nothrow( *m_xData );
 453     }
 454
 455
 456     void SAL_CALL AnimatedImagesPeer::elementRemoved( const ContainerEvent& i_event )
 457     {
 458         SolarMutexGuard aGuard;
 459         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 460
 461         sal_Int32 nPosition(0);
 462         OSL_VERIFY( i_event.Accessor >>= nPosition );
 463         size_t position = size_t( nPosition );
 464         if ( position >= m_xData->aCachedImageSets.size() )
 465         {
 466             OSL_ENSURE( false, "AnimatedImagesPeer::elementRemoved: illegal accessor/index!" );
 467             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 468         }
 469
 470         m_xData->aCachedImageSets.erase( m_xData->aCachedImageSets.begin() + position );
 471         lcl_updateImageList_nothrow( *m_xData );
 472     }
 473
 474
 475     void SAL_CALL AnimatedImagesPeer::elementReplaced( const ContainerEvent& i_event )
 476     {
 477         SolarMutexGuard aGuard;
 478         Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
 479
 480         sal_Int32 nPosition(0);
 481         OSL_VERIFY( i_event.Accessor >>= nPosition );
 482         size_t position = size_t( nPosition );
 483         if ( position >= m_xData->aCachedImageSets.size() )
 484         {
 485             OSL_ENSURE( false, "AnimatedImagesPeer::elementReplaced: illegal accessor/index!" );
 486             lcl_updateImageList_nothrow( *m_xData, xAnimatedImages );
 487         }
 488
 489         Sequence< OUString > aImageURLs;
 490         OSL_VERIFY( i_event.Element >>= aImageURLs );
 491         ::std::vector< CachedImage > aImages;
 492         lcl_init( aImageURLs, aImages );
 493         m_xData->aCachedImageSets[ position ] = aImages;
 494         lcl_updateImageList_nothrow( *m_xData );
 495     }
 496
 497
 498     void SAL_CALL AnimatedImagesPeer::disposing( const EventObject& i_event )
 499     {
 500         VCLXWindow::disposing( i_event );
 501     }
 502
 503
 504     void SAL_CALL AnimatedImagesPeer::modified( const EventObject& i_event )
 505     {
 506         impl_updateImages_nolck( i_event.Source );
 507     }
 508
 509
 510     void SAL_CALL AnimatedImagesPeer::dispose(  )
 511     {
 512         AnimatedImagesPeer_Base::dispose();
 513         SolarMutexGuard aGuard;
 514         m_xData->aCachedImageSets.resize(0);
 515     }
 516
 517
 518 } // namespace toolkit
 519
 520
 521 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */