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