toolkit/source/controls/animatedimages.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 <controls/animatedimages.hxx>
  22 #include <helper/property.hxx>
  23
  24 #include <com/sun/star/lang/DisposedException.hpp>
  25 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  26 #include <com/sun/star/awt/VisualEffect.hpp>
  27 #include <com/sun/star/awt/ImageScaleMode.hpp>
  28 #include <com/sun/star/awt/XAnimation.hpp>
  29 #include <com/sun/star/awt/XAnimatedImages.hpp>
  30 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  31 #include <com/sun/star/container/XContainerListener.hpp>
  32 #include <com/sun/star/uno/XComponentContext.hpp>
  33 #include <com/sun/star/util/XModifyListener.hpp>
  34 #include <o3tl/safeint.hxx>
  35 #include <toolkit/controls/unocontrolbase.hxx>
  36 #include <toolkit/controls/unocontrolmodel.hxx>
  37
  38 #include <cppuhelper/implbase2.hxx>
  39
  40 #include <helper/unopropertyarrayhelper.hxx>
  41
  42 using namespace css::awt;
  43 using namespace css::container;
  44 using namespace css::lang;
  45 using namespace css::uno;
  46
  47 namespace {
  48
  49 typedef ::cppu::AggImplInheritanceHelper2   <   UnoControlBase
  50                                             ,   css::awt::XAnimation
  51                                             ,   css::container::XContainerListener
  52                                             >   AnimatedImagesControl_Base;
  53
  54 class AnimatedImagesControl : public AnimatedImagesControl_Base
  55 {
  56 public:
  57     AnimatedImagesControl();
  58     OUString GetComponentServiceName() const override;
  59
  60     // XAnimation
  61     virtual void SAL_CALL startAnimation(  ) override;
  62     virtual void SAL_CALL stopAnimation(  ) override;
  63     virtual sal_Bool SAL_CALL isAnimationRunning(  ) override;
  64
  65     // XServiceInfo
  66     OUString SAL_CALL getImplementationName(  ) override;
  67     css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
  68
  69     // XControl
  70     sal_Bool SAL_CALL setModel( const css::uno::Reference< css::awt::XControlModel >& i_rModel ) override;
  71     void SAL_CALL createPeer( const css::uno::Reference< css::awt::XToolkit >& i_toolkit, const css::uno::Reference< css::awt::XWindowPeer >& i_parentPeer ) override;
  72
  73
  74     // XContainerListener
  75     virtual void SAL_CALL elementInserted( const css::container::ContainerEvent& Event ) override;
  76     virtual void SAL_CALL elementRemoved( const css::container::ContainerEvent& Event ) override;
  77     virtual void SAL_CALL elementReplaced( const css::container::ContainerEvent& Event ) override;
  78
  79     // XEventListener
  80     virtual void SAL_CALL disposing( const css::lang::EventObject& i_event ) override;
  81 };
  82
  83     AnimatedImagesControl::AnimatedImagesControl()
  84     {
  85     }
  86
  87
  88     OUString AnimatedImagesControl::GetComponentServiceName() const
  89     {
  90         return u"AnimatedImages"_ustr;
  91     }
  92
  93
  94     void SAL_CALL AnimatedImagesControl::startAnimation(  )
  95     {
  96         Reference< XAnimation > xAnimation( getPeer(), UNO_QUERY );
  97         if ( xAnimation.is() )
  98             xAnimation->startAnimation();
  99     }
 100
 101
 102     void SAL_CALL AnimatedImagesControl::stopAnimation(  )
 103     {
 104         Reference< XAnimation > xAnimation( getPeer(), UNO_QUERY );
 105         if ( xAnimation.is() )
 106             xAnimation->stopAnimation();
 107     }
 108
 109
 110     sal_Bool SAL_CALL AnimatedImagesControl::isAnimationRunning(  )
 111     {
 112         Reference< XAnimation > xAnimation( getPeer(), UNO_QUERY );
 113         if ( xAnimation.is() )
 114             return xAnimation->isAnimationRunning();
 115         return false;
 116     }
 117
 118
 119     OUString SAL_CALL AnimatedImagesControl::getImplementationName(  )
 120     {
 121         return u"org.openoffice.comp.toolkit.AnimatedImagesControl"_ustr;
 122     }
 123
 124
 125     Sequence< OUString > SAL_CALL AnimatedImagesControl::getSupportedServiceNames()
 126     {
 127         Sequence< OUString > aServices( AnimatedImagesControl_Base::getSupportedServiceNames() );
 128         aServices.realloc( aServices.getLength() + 1 );
 129         aServices.getArray()[ aServices.getLength() - 1 ] = "com.sun.star.awt.AnimatedImagesControl";
 130         return aServices;
 131     }
 132
 133     void lcl_updatePeer( Reference< XWindowPeer > const& i_peer, Reference< XControlModel > const& i_model )
 134     {
 135         const Reference< css::util::XModifyListener > xPeerModify( i_peer, UNO_QUERY );
 136         if ( xPeerModify.is() )
 137         {
 138             EventObject aEvent;
 139             aEvent.Source = i_model;
 140             xPeerModify->modified( aEvent );
 141         }
 142     }
 143
 144     sal_Bool SAL_CALL AnimatedImagesControl::setModel( const Reference< XControlModel >& i_rModel )
 145     {
 146         const Reference< XAnimatedImages > xOldContainer( getModel(), UNO_QUERY );
 147         const Reference< XAnimatedImages > xNewContainer( i_rModel, UNO_QUERY );
 148
 149         if ( !AnimatedImagesControl_Base::setModel( i_rModel ) )
 150             return false;
 151
 152         if ( xOldContainer.is() )
 153             xOldContainer->removeContainerListener( this );
 154
 155         if ( xNewContainer.is() )
 156             xNewContainer->addContainerListener( this );
 157
 158         lcl_updatePeer( getPeer(), getModel() );
 159
 160         return true;
 161     }
 162
 163
 164     void SAL_CALL AnimatedImagesControl::createPeer( const Reference< XToolkit >& i_toolkit, const Reference< XWindowPeer >& i_parentPeer )
 165     {
 166         AnimatedImagesControl_Base::createPeer( i_toolkit, i_parentPeer );
 167
 168         lcl_updatePeer( getPeer(), getModel() );
 169     }
 170
 171
 172     void SAL_CALL AnimatedImagesControl::elementInserted( const ContainerEvent& i_event )
 173     {
 174         const Reference< XContainerListener > xPeerListener( getPeer(), UNO_QUERY );
 175         if ( xPeerListener.is() )
 176             xPeerListener->elementInserted( i_event );
 177     }
 178
 179
 180     void SAL_CALL AnimatedImagesControl::elementRemoved( const ContainerEvent& i_event )
 181     {
 182         const Reference< XContainerListener > xPeerListener( getPeer(), UNO_QUERY );
 183         if ( xPeerListener.is() )
 184             xPeerListener->elementRemoved( i_event );
 185     }
 186
 187
 188     void SAL_CALL AnimatedImagesControl::elementReplaced( const ContainerEvent& i_event )
 189     {
 190         const Reference< XContainerListener > xPeerListener( getPeer(), UNO_QUERY );
 191         if ( xPeerListener.is() )
 192             xPeerListener->elementReplaced( i_event );
 193     }
 194
 195
 196     void SAL_CALL AnimatedImagesControl::disposing( const EventObject& i_event )
 197     {
 198         UnoControlBase::disposing( i_event );
 199     }
 200
 201 }
 202
 203 namespace toolkit {
 204
 205     namespace
 206     {
 207         void lcl_checkIndex( const std::vector< css::uno::Sequence< OUString > > & rImageSets, const sal_Int32 i_index, const Reference< XInterface >& i_context,
 208             const bool i_forInsert = false )
 209         {
 210             if ( ( i_index < 0 ) || ( o3tl::make_unsigned( i_index ) > rImageSets.size() + ( i_forInsert ? 1 : 0 ) ) )
 211                 throw IndexOutOfBoundsException( OUString(), i_context );
 212         }
 213
 214         void lcl_notify( std::unique_lock<std::mutex>& i_guard, comphelper::OInterfaceContainerHelper4<XContainerListener>& rContainer,
 215             void ( SAL_CALL XContainerListener::*i_notificationMethod )( const ContainerEvent& ),
 216             const sal_Int32 i_accessor, const Sequence< OUString >& i_imageURLs, const Reference< XInterface >& i_context )
 217         {
 218             if ( !rContainer.getLength(i_guard) )
 219                 return;
 220
 221             ContainerEvent aEvent;
 222             aEvent.Source = i_context;
 223             aEvent.Accessor <<= i_accessor;
 224             aEvent.Element <<= i_imageURLs;
 225
 226             rContainer.notifyEach( i_guard, i_notificationMethod, aEvent );
 227         }
 228     }
 229
 230
 231     AnimatedImagesControlModel::AnimatedImagesControlModel( Reference< css::uno::XComponentContext > const & i_factory )
 232         :AnimatedImagesControlModel_Base( i_factory )
 233     {
 234         ImplRegisterProperty( BASEPROPERTY_AUTO_REPEAT );
 235         ImplRegisterProperty( BASEPROPERTY_BORDER );
 236         ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR );
 237         ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
 238         ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
 239         ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
 240         ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
 241         ImplRegisterProperty( BASEPROPERTY_HELPURL );
 242         ImplRegisterProperty( BASEPROPERTY_IMAGE_SCALE_MODE );
 243         ImplRegisterProperty( BASEPROPERTY_STEP_TIME );
 244     }
 245
 246
 247     AnimatedImagesControlModel::AnimatedImagesControlModel( const AnimatedImagesControlModel& i_copySource )
 248         :AnimatedImagesControlModel_Base( i_copySource )
 249         ,maImageSets( i_copySource.maImageSets )
 250     {
 251     }
 252
 253
 254     AnimatedImagesControlModel::~AnimatedImagesControlModel()
 255     {
 256     }
 257
 258
 259     rtl::Reference<UnoControlModel> AnimatedImagesControlModel::Clone() const
 260     {
 261         std::unique_lock aGuard( m_aMutex );
 262         return new AnimatedImagesControlModel( *this );
 263     }
 264
 265
 266     Reference< css::beans::XPropertySetInfo > SAL_CALL AnimatedImagesControlModel::getPropertySetInfo(  )
 267     {
 268         static Reference< css::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 269         return xInfo;
 270     }
 271
 272
 273     OUString SAL_CALL AnimatedImagesControlModel::getServiceName()
 274     {
 275         return u"com.sun.star.awt.AnimatedImagesControlModel"_ustr;
 276     }
 277
 278
 279     OUString SAL_CALL AnimatedImagesControlModel::getImplementationName(  )
 280     {
 281         return u"org.openoffice.comp.toolkit.AnimatedImagesControlModel"_ustr;
 282     }
 283
 284
 285     Sequence< OUString > SAL_CALL AnimatedImagesControlModel::getSupportedServiceNames()
 286     {
 287         return { u"com.sun.star.awt.AnimatedImagesControlModel"_ustr, u"com.sun.star.awt.UnoControlModel"_ustr };
 288     }
 289
 290
 291     void AnimatedImagesControlModel::setFastPropertyValue_NoBroadcast( std::unique_lock<std::mutex>& rGuard, sal_Int32 i_handle, const Any& i_value )
 292     {
 293         switch ( i_handle )
 294         {
 295         case BASEPROPERTY_IMAGE_SCALE_MODE:
 296         {
 297             sal_Int16 nImageScaleMode( ImageScaleMode::ANISOTROPIC );
 298             OSL_VERIFY( i_value >>= nImageScaleMode );  // convertFastPropertyValue ensures that this has the proper type
 299             if  (   ( nImageScaleMode != ImageScaleMode::NONE )
 300                 &&  ( nImageScaleMode != ImageScaleMode::ISOTROPIC )
 301                 &&  ( nImageScaleMode != ImageScaleMode::ANISOTROPIC )
 302                 )
 303                 throw IllegalArgumentException( OUString(), *this, 1 );
 304         }
 305         break;
 306         }
 307
 308         AnimatedImagesControlModel_Base::setFastPropertyValue_NoBroadcast( rGuard, i_handle, i_value );
 309     }
 310
 311
 312     Any AnimatedImagesControlModel::ImplGetDefaultValue( sal_uInt16 i_propertyId ) const
 313     {
 314         switch ( i_propertyId )
 315         {
 316         case BASEPROPERTY_DEFAULTCONTROL:
 317             return Any( u"com.sun.star.awt.AnimatedImagesControl"_ustr );
 318
 319         case BASEPROPERTY_BORDER:
 320             return Any( css::awt::VisualEffect::NONE );
 321
 322         case BASEPROPERTY_STEP_TIME:
 323             return Any( sal_Int32(100) );
 324
 325         case BASEPROPERTY_AUTO_REPEAT:
 326             return Any( true );
 327
 328         case BASEPROPERTY_IMAGE_SCALE_MODE:
 329             return Any( ImageScaleMode::NONE );
 330
 331         default:
 332             return UnoControlModel::ImplGetDefaultValue( i_propertyId );
 333         }
 334     }
 335
 336
 337     ::cppu::IPropertyArrayHelper& AnimatedImagesControlModel::getInfoHelper()
 338     {
 339         static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );
 340         return aHelper;
 341     }
 342
 343
 344     ::sal_Int32 SAL_CALL AnimatedImagesControlModel::getStepTime()
 345     {
 346         sal_Int32 nStepTime( 100 );
 347         OSL_VERIFY( getPropertyValue( GetPropertyName( BASEPROPERTY_STEP_TIME ) ) >>= nStepTime );
 348         return nStepTime;
 349     }
 350
 351
 352     void SAL_CALL AnimatedImagesControlModel::setStepTime( ::sal_Int32 i_stepTime )
 353     {
 354         setPropertyValue( GetPropertyName( BASEPROPERTY_STEP_TIME ), Any( i_stepTime ) );
 355     }
 356
 357
 358     sal_Bool SAL_CALL AnimatedImagesControlModel::getAutoRepeat()
 359     {
 360         bool bAutoRepeat( true );
 361         OSL_VERIFY( getPropertyValue( GetPropertyName( BASEPROPERTY_AUTO_REPEAT ) ) >>= bAutoRepeat );
 362         return bAutoRepeat;
 363     }
 364
 365
 366     void SAL_CALL AnimatedImagesControlModel::setAutoRepeat( sal_Bool i_autoRepeat )
 367     {
 368         setPropertyValue( GetPropertyName( BASEPROPERTY_AUTO_REPEAT ), Any( i_autoRepeat ) );
 369     }
 370
 371
 372     ::sal_Int16 SAL_CALL AnimatedImagesControlModel::getScaleMode()
 373     {
 374         sal_Int16 nImageScaleMode( ImageScaleMode::ANISOTROPIC );
 375         OSL_VERIFY( getPropertyValue( GetPropertyName( BASEPROPERTY_IMAGE_SCALE_MODE ) ) >>= nImageScaleMode );
 376         return nImageScaleMode;
 377     }
 378
 379
 380     void SAL_CALL AnimatedImagesControlModel::setScaleMode( ::sal_Int16 i_scaleMode )
 381     {
 382         setPropertyValue( GetPropertyName( BASEPROPERTY_IMAGE_SCALE_MODE ), Any( i_scaleMode ) );
 383     }
 384
 385
 386     ::sal_Int32 SAL_CALL AnimatedImagesControlModel::getImageSetCount(  )
 387     {
 388         std::unique_lock aGuard( m_aMutex );
 389         if ( m_bDisposed )
 390             throw DisposedException();
 391
 392         return maImageSets.size();
 393     }
 394
 395
 396     Sequence< OUString > SAL_CALL AnimatedImagesControlModel::getImageSet( ::sal_Int32 i_index )
 397     {
 398         std::unique_lock aGuard( m_aMutex );
 399         if ( m_bDisposed )
 400             throw DisposedException();
 401
 402         lcl_checkIndex( maImageSets, i_index, *this );
 403
 404         return maImageSets[ i_index ];
 405     }
 406
 407
 408     void SAL_CALL AnimatedImagesControlModel::insertImageSet( ::sal_Int32 i_index, const Sequence< OUString >& i_imageURLs )
 409     {
 410         std::unique_lock aGuard( m_aMutex );
 411         // sanity checks
 412         if ( m_bDisposed )
 413             throw DisposedException();
 414
 415         lcl_checkIndex( maImageSets, i_index, *this, true );
 416
 417         // actual insertion
 418         maImageSets.insert( maImageSets.begin() + i_index, i_imageURLs );
 419
 420         // listener notification
 421         lcl_notify( aGuard, maContainerListeners, &XContainerListener::elementInserted, i_index, i_imageURLs, *this );
 422     }
 423
 424
 425     void SAL_CALL AnimatedImagesControlModel::replaceImageSet( ::sal_Int32 i_index, const Sequence< OUString >& i_imageURLs )
 426     {
 427         std::unique_lock aGuard( m_aMutex );
 428         // sanity checks
 429         if ( m_bDisposed )
 430             throw DisposedException();
 431
 432         lcl_checkIndex( maImageSets, i_index, *this );
 433
 434         // actual insertion
 435         maImageSets[ i_index ] = i_imageURLs;
 436
 437         // listener notification
 438         lcl_notify( aGuard, maContainerListeners, &XContainerListener::elementReplaced, i_index, i_imageURLs, *this );
 439     }
 440
 441
 442     void SAL_CALL AnimatedImagesControlModel::removeImageSet( ::sal_Int32 i_index )
 443     {
 444         std::unique_lock aGuard( m_aMutex );
 445         // sanity checks
 446         if ( m_bDisposed )
 447             throw DisposedException();
 448
 449         lcl_checkIndex( maImageSets, i_index, *this );
 450
 451         // actual removal
 452         ::std::vector< Sequence< OUString > >::iterator removalPos = maImageSets.begin() + i_index;
 453         Sequence< OUString > aRemovedElement( *removalPos );
 454         maImageSets.erase( removalPos );
 455
 456         // listener notification
 457         lcl_notify( aGuard, maContainerListeners, &XContainerListener::elementRemoved, i_index, aRemovedElement, *this );
 458     }
 459
 460
 461     void SAL_CALL AnimatedImagesControlModel::addContainerListener( const Reference< XContainerListener >& i_listener )
 462     {
 463         std::unique_lock aGuard( m_aMutex );
 464         maContainerListeners.addInterface( aGuard, i_listener );
 465     }
 466
 467
 468     void SAL_CALL AnimatedImagesControlModel::removeContainerListener( const Reference< XContainerListener >& i_listener )
 469     {
 470         std::unique_lock aGuard( m_aMutex );
 471         maContainerListeners.removeInterface( aGuard, i_listener );
 472     }
 473
 474 }
 475
 476 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 477 org_openoffice_comp_toolkit_AnimatedImagesControl_get_implementation(
 478     css::uno::XComponentContext *,
 479     css::uno::Sequence<css::uno::Any> const &)
 480 {
 481     return cppu::acquire(new AnimatedImagesControl());
 482 }
 483
 484 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 485 org_openoffice_comp_toolkit_AnimatedImagesControlModel_get_implementation(
 486     css::uno::XComponentContext *context,
 487     css::uno::Sequence<css::uno::Any> const &)
 488 {
 489     return cppu::acquire(new toolkit::AnimatedImagesControlModel(context));
 490 }
 491
 492 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */