sd/source/ui/slideshow/slideshowviewimpl.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 "slideshowviewimpl.hxx"
  21 #include "slideshowimpl.hxx"
  22 #include <osl/mutex.hxx>
  23
  24 #include <com/sun/star/awt/Pointer.hpp>
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26
  27 #include <basegfx/polygon/b2dpolygon.hxx>
  28 #include <basegfx/polygon/b2dpolygontools.hxx>
  29 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  30
  31 #include <cppcanvas/vclfactory.hxx>
  32 #include <cppcanvas/basegfxfactory.hxx>
  33
  34 #include <toolkit/helper/vclunohelper.hxx>
  35
  36 using ::com::sun::star::uno::Reference;
  37 using ::com::sun::star::uno::WeakReference;
  38 using ::com::sun::star::uno::RuntimeException;
  39 using ::com::sun::star::uno::Exception;
  40 using ::com::sun::star::presentation::XSlideShowView;
  41
  42 using namespace ::com::sun::star;
  43
  44 namespace sd
  45 {
  46
  47 // SlideShowViewListeners
  48 SlideShowViewListeners::SlideShowViewListeners( ::osl::Mutex& rMutex )
  49 :   mrMutex( rMutex )
  50 {
  51 }
  52
  53 void SlideShowViewListeners::addListener( const Reference< util::XModifyListener >& _rxListener )
  54 {
  55     ::osl::MutexGuard aGuard( mrMutex );
  56
  57     WeakReference< util::XModifyListener > xWeak( _rxListener );
  58     if( std::find( maListeners.begin(), maListeners.end(), xWeak ) == maListeners.end() )
  59         maListeners.push_back( xWeak );
  60 }
  61
  62 void SlideShowViewListeners::removeListener( const Reference< util::XModifyListener >& _rxListener )
  63 {
  64     ::osl::MutexGuard aGuard( mrMutex );
  65
  66     WeakReference< util::XModifyListener > xWeak( _rxListener );
  67     ViewListenerVector::iterator aIter( std::find( maListeners.begin(), maListeners.end(), xWeak ) );
  68     if( aIter != maListeners.end() )
  69         maListeners.erase( aIter );
  70 }
  71
  72 void SlideShowViewListeners::notify( const lang::EventObject& _rEvent )
  73 {
  74     ::osl::MutexGuard aGuard( mrMutex );
  75
  76     ViewListenerVector::iterator aIter( maListeners.begin() );
  77     while( aIter != maListeners.end() )
  78     {
  79         Reference< util::XModifyListener > xListener( (*aIter) );
  80         if( xListener.is() )
  81         {
  82             xListener->modified( _rEvent );
  83             ++aIter;
  84         }
  85         else
  86         {
  87             aIter = maListeners.erase( aIter );
  88         }
  89     }
  90 }
  91
  92 void SlideShowViewListeners::disposing( const lang::EventObject& _rEventSource )
  93 {
  94     ::osl::MutexGuard aGuard( mrMutex );
  95
  96     ViewListenerVector::iterator aIter( maListeners.begin() );
  97     while( aIter != maListeners.end() )
  98     {
  99         Reference< util::XModifyListener > xListener( (*aIter++) );
 100         if( xListener.is() )
 101             xListener->disposing( _rEventSource );
 102     }
 103
 104     maListeners.clear();
 105 }
 106
 107 // SlideShowViewPaintListeners
 108 SlideShowViewPaintListeners::SlideShowViewPaintListeners( ::osl::Mutex& rMutex )
 109 :   SlideShowViewPaintListeners_Base( rMutex )
 110 {
 111 }
 112
 113 bool SlideShowViewPaintListeners::implTypedNotify( const Reference< awt::XPaintListener >& rListener,
 114                                               const awt::PaintEvent&                  rEvent )
 115 {
 116     rListener->windowPaint( rEvent );
 117     return true; // continue calling listeners
 118 }
 119
 120 // SlideShowViewMouseListeners
 121 SlideShowViewMouseListeners::SlideShowViewMouseListeners( ::osl::Mutex& rMutex ) :
 122     SlideShowViewMouseListeners_Base( rMutex )
 123 {
 124 }
 125
 126 bool SlideShowViewMouseListeners::implTypedNotify( const Reference< awt::XMouseListener >&  rListener,
 127                                               const WrappedMouseEvent&                  rEvent )
 128 {
 129     switch( rEvent.meType )
 130     {
 131         case WrappedMouseEvent::PRESSED:
 132             rListener->mousePressed( rEvent.maEvent );
 133             break;
 134
 135         case WrappedMouseEvent::RELEASED:
 136             rListener->mouseReleased( rEvent.maEvent );
 137             break;
 138
 139         case WrappedMouseEvent::ENTERED:
 140             rListener->mouseEntered( rEvent.maEvent );
 141             break;
 142
 143         case WrappedMouseEvent::EXITED:
 144             rListener->mouseExited( rEvent.maEvent );
 145             break;
 146     }
 147
 148     return true; // continue calling listeners
 149 }
 150
 151 // SlideShowViewMouseMotionListeners
 152 SlideShowViewMouseMotionListeners::SlideShowViewMouseMotionListeners( ::osl::Mutex& rMutex ) :
 153     SlideShowViewMouseMotionListeners_Base( rMutex )
 154 {
 155 }
 156
 157 bool SlideShowViewMouseMotionListeners::implTypedNotify( const Reference< awt::XMouseMotionListener >&  rListener,
 158                                                     const WrappedMouseMotionEvent&                  rEvent )
 159 {
 160     switch( rEvent.meType )
 161     {
 162         case WrappedMouseMotionEvent::DRAGGED:
 163             rListener->mouseDragged( rEvent.maEvent );
 164             break;
 165
 166         case WrappedMouseMotionEvent::MOVED:
 167             rListener->mouseMoved( rEvent.maEvent );
 168             break;
 169     }
 170
 171     return true; // continue calling listeners
 172 }
 173
 174 // SlideShowView
 175 SlideShowView::SlideShowView( ShowWindow&     rOutputWindow,
 176                               SdDrawDocument* pDoc,
 177                               AnimationMode   eAnimationMode,
 178                               SlideshowImpl*  pSlideShow,
 179                               bool            bFullScreen )
 180 :   SlideShowView_Base( m_aMutex ),
 181     mpCanvas( ::cppcanvas::VCLFactory::createSpriteCanvas( rOutputWindow ) ),
 182     mxWindow( VCLUnoHelper::GetInterface( &rOutputWindow ), uno::UNO_QUERY_THROW ),
 183     mxWindowPeer( mxWindow, uno::UNO_QUERY_THROW ),
 184     mxPointer(),
 185     mpSlideShow( pSlideShow ),
 186     mrOutputWindow( rOutputWindow ),
 187     mpViewListeners( new SlideShowViewListeners( m_aMutex ) ),
 188     mpPaintListeners( new SlideShowViewPaintListeners( m_aMutex ) ),
 189     mpMouseListeners( new SlideShowViewMouseListeners( m_aMutex ) ),
 190     mpMouseMotionListeners( new SlideShowViewMouseMotionListeners( m_aMutex ) ),
 191     mpDoc( pDoc ),
 192     mbIsMouseMotionListener( false ),
 193     meAnimationMode( eAnimationMode ),
 194     mbFirstPaint( true ),
 195     mbFullScreen( bFullScreen ),
 196     mbMousePressedEaten( false )
 197 {
 198     init();
 199
 200     mTranslationOffset.Width = 0;
 201     mTranslationOffset.Height = 0;
 202 }
 203
 204 // Dispose all internal references
 205 void SAL_CALL SlideShowView::dispose()
 206 {
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208
 209     mpSlideShow = nullptr;
 210
 211     // deregister listeners
 212     if( mxWindow.is() )
 213     {
 214         mxWindow->removeWindowListener( this );
 215         mxWindow->removeMouseListener( this );
 216
 217         if( mbIsMouseMotionListener )
 218             mxWindow->removeMouseMotionListener( this );
 219     }
 220
 221     mpCanvas.reset();
 222     mxWindow.clear();
 223
 224     // clear all listener containers
 225     disposing( lang::EventObject() );
 226
 227     // call base
 228     WeakComponentImplHelperBase::dispose();
 229 }
 230
 231 // Disposing our broadcaster
 232 void SAL_CALL SlideShowView::disposing( const lang::EventObject& )
 233 {
 234     ::osl::MutexGuard aGuard( m_aMutex );
 235
 236     // notify all listeners that _we_ are going down (send a disposing()),
 237     // then delete listener containers:
 238     lang::EventObject const evt( static_cast<OWeakObject *>(this) );
 239     if (mpViewListeners.get() != nullptr) {
 240         mpViewListeners->disposing( evt );
 241         mpViewListeners.reset();
 242     }
 243     if (mpPaintListeners.get() != nullptr) {
 244         mpPaintListeners->disposing( evt );
 245         mpPaintListeners.reset();
 246     }
 247     if (mpMouseListeners.get() != nullptr) {
 248         mpMouseListeners->disposing( evt );
 249         mpMouseListeners.reset();
 250     }
 251     if (mpMouseMotionListeners.get() != nullptr) {
 252         mpMouseMotionListeners->disposing( evt );
 253         mpMouseMotionListeners.reset();
 254     }
 255 }
 256
 257 void SlideShowView::paint( const awt::PaintEvent& e )
 258 {
 259     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 260
 261     if( mbFirstPaint )
 262     {
 263         mbFirstPaint = false;
 264         SlideshowImpl* pSlideShow = mpSlideShow;
 265         aGuard.clear();
 266         if( pSlideShow )
 267             pSlideShow->onFirstPaint();
 268     }
 269     else
 270     {
 271         // Change event source, to enable listeners to match event
 272         // with view
 273         awt::PaintEvent aEvent( e );
 274         aEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 275         mpPaintListeners->notify( aEvent );
 276         updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 277     }
 278 }
 279
 280 // XSlideShowView methods
 281 Reference< rendering::XSpriteCanvas > SAL_CALL SlideShowView::getCanvas(  )
 282 {
 283     ::osl::MutexGuard aGuard( m_aMutex );
 284
 285     return mpCanvas.get() ? mpCanvas->getUNOSpriteCanvas() : Reference< rendering::XSpriteCanvas >();
 286 }
 287
 288 void SAL_CALL SlideShowView::clear()
 289 {
 290     // paint background in black
 291     ::osl::MutexGuard aGuard( m_aMutex );
 292     SolarMutexGuard aSolarGuard;
 293
 294     // fill the bounds rectangle in black
 295
 296     const Size aWindowSize( mrOutputWindow.GetSizePixel() );
 297
 298     ::basegfx::B2DPolygon aPoly( ::basegfx::utils::createPolygonFromRect(
 299                                      ::basegfx::B2DRectangle(0.0,0.0,
 300                                                              aWindowSize.Width(),
 301                                                              aWindowSize.Height() ) ) );
 302     ::cppcanvas::PolyPolygonSharedPtr pPolyPoly(
 303         ::cppcanvas::BaseGfxFactory::createPolyPolygon( mpCanvas, aPoly ) );
 304
 305     if( pPolyPoly.get() )
 306     {
 307         pPolyPoly->setRGBAFillColor( 0x000000FFU );
 308         pPolyPoly->draw();
 309     }
 310 }
 311
 312 geometry::IntegerSize2D SAL_CALL SlideShowView::getTranslationOffset( )
 313 {
 314         return mTranslationOffset;
 315 }
 316
 317 geometry::AffineMatrix2D SAL_CALL SlideShowView::getTransformation(  )
 318 {
 319     ::osl::MutexGuard aGuard( m_aMutex );
 320     SolarMutexGuard aSolarGuard;
 321
 322     const Size& rTmpSize( mrOutputWindow.GetSizePixel() );
 323
 324     if (rTmpSize.Width()<=0 || rTmpSize.Height()<=0)
 325     {
 326         return geometry::AffineMatrix2D (1,0,0,0,1,0);
 327     }
 328
 329     const Size aWindowSize( mrOutputWindow.GetSizePixel() );
 330     Size aOutputSize( aWindowSize );
 331
 332     if( meAnimationMode != ANIMATIONMODE_SHOW )
 333     {
 334         aOutputSize.setWidth( static_cast<long>( aOutputSize.Width() / 1.03 ) );
 335         aOutputSize.setHeight( static_cast<long>( aOutputSize.Height() / 1.03 ) );
 336     }
 337
 338     SdPage* pP = mpDoc->GetSdPage( 0, PageKind::Standard );
 339     Size aPageSize( pP->GetSize() );
 340
 341     const double page_ratio = static_cast<double>(aPageSize.Width()) / static_cast<double>(aPageSize.Height());
 342     const double output_ratio = static_cast<double>(aOutputSize.Width()) / static_cast<double>(aOutputSize.Height());
 343
 344     if( page_ratio > output_ratio )
 345     {
 346         aOutputSize.setHeight( ( aOutputSize.Width() * aPageSize.Height() ) / aPageSize.Width() );
 347     }
 348     else if( page_ratio < output_ratio )
 349     {
 350         aOutputSize.setWidth( ( aOutputSize.Height() * aPageSize.Width() ) / aPageSize.Height() );
 351     }
 352
 353     Point aOutputOffset( ( aWindowSize.Width() - aOutputSize.Width() ) >> 1,
 354                             ( aWindowSize.Height() - aOutputSize.Height() ) >> 1 );
 355
 356     // Reduce available width by one, as the slides might actually
 357     // render one pixel wider and higher as aPageSize below specifies
 358     // (when shapes of page size have visible border lines)
 359     aOutputSize.AdjustWidth( -1 );
 360     aOutputSize.AdjustHeight( -1 );
 361
 362     // Record mTranslationOffset
 363     mTranslationOffset.Height = aOutputOffset.Y();
 364     mTranslationOffset.Width = aOutputOffset.X();
 365
 366     maPresentationArea = ::tools::Rectangle( aOutputOffset, aOutputSize );
 367     mrOutputWindow.SetPresentationArea( maPresentationArea );
 368
 369     // scale presentation into available window rect (minus 10%); center in the window
 370     const basegfx::B2DHomMatrix aMatrix(basegfx::utils::createScaleTranslateB2DHomMatrix(
 371         aOutputSize.Width(), aOutputSize.Height(), aOutputOffset.X(), aOutputOffset.Y()));
 372
 373     geometry::AffineMatrix2D aRes;
 374
 375     return ::basegfx::unotools::affineMatrixFromHomMatrix( aRes, aMatrix );
 376 }
 377
 378 void SAL_CALL SlideShowView::addTransformationChangedListener( const Reference< util::XModifyListener >& xListener )
 379 {
 380     ::osl::MutexGuard aGuard( m_aMutex );
 381
 382     if( mpViewListeners.get() )
 383         mpViewListeners->addListener( xListener );
 384 }
 385
 386 void SAL_CALL SlideShowView::removeTransformationChangedListener( const Reference< util::XModifyListener >& xListener )
 387 {
 388     ::osl::MutexGuard aGuard( m_aMutex );
 389
 390     if( mpViewListeners.get() )
 391         mpViewListeners->removeListener( xListener );
 392 }
 393
 394 void SAL_CALL SlideShowView::addPaintListener( const Reference< awt::XPaintListener >& xListener )
 395 {
 396     ::osl::MutexGuard aGuard( m_aMutex );
 397
 398     if( mpPaintListeners.get() )
 399         mpPaintListeners->addTypedListener( xListener );
 400 }
 401
 402 void SAL_CALL SlideShowView::removePaintListener( const Reference< awt::XPaintListener >& xListener )
 403 {
 404     ::osl::MutexGuard aGuard( m_aMutex );
 405
 406     if( mpPaintListeners.get() )
 407         mpPaintListeners->removeTypedListener( xListener );
 408 }
 409
 410 void SAL_CALL SlideShowView::addMouseListener( const Reference< awt::XMouseListener >& xListener )
 411 {
 412     ::osl::MutexGuard aGuard( m_aMutex );
 413
 414     if( mpMouseListeners.get() )
 415         mpMouseListeners->addTypedListener( xListener );
 416 }
 417
 418 void SAL_CALL SlideShowView::removeMouseListener( const Reference< awt::XMouseListener >& xListener )
 419 {
 420     ::osl::MutexGuard aGuard( m_aMutex );
 421
 422     if( mpMouseListeners.get() )
 423         mpMouseListeners->removeTypedListener( xListener );
 424 }
 425
 426 void SAL_CALL SlideShowView::addMouseMotionListener( const Reference< awt::XMouseMotionListener >& xListener )
 427 {
 428     ::osl::MutexGuard aGuard( m_aMutex );
 429
 430     if( !mbIsMouseMotionListener && mxWindow.is() )
 431     {
 432         // delay motion event registration, until we really
 433         // need it
 434         mbIsMouseMotionListener = true;
 435         mxWindow->addMouseMotionListener( this );
 436     }
 437
 438     if( mpMouseMotionListeners.get() )
 439         mpMouseMotionListeners->addTypedListener( xListener );
 440 }
 441
 442 void SAL_CALL SlideShowView::removeMouseMotionListener( const Reference< awt::XMouseMotionListener >& xListener )
 443 {
 444     ::osl::MutexGuard aGuard( m_aMutex );
 445
 446     if( mpMouseMotionListeners.get() )
 447         mpMouseMotionListeners->removeTypedListener( xListener );
 448
 449     // TODO(P1): Might be nice to deregister for mouse motion
 450     // events, when the last listener is gone.
 451 }
 452
 453 void SAL_CALL SlideShowView::setMouseCursor( sal_Int16 nPointerShape )
 454 {
 455     ::osl::MutexGuard aGuard( m_aMutex );
 456
 457     // forward to window
 458     if( mxPointer.is() )
 459         mxPointer->setType( nPointerShape );
 460
 461     if( mxWindowPeer.is() )
 462         mxWindowPeer->setPointer( mxPointer );
 463 }
 464
 465 awt::Rectangle SAL_CALL SlideShowView::getCanvasArea(  )
 466 {
 467     awt::Rectangle aRectangle;
 468
 469     if( mxWindow.is() )
 470         return mxWindow->getPosSize();
 471
 472     aRectangle.X = aRectangle.Y = aRectangle.Width = aRectangle.Height = 0;
 473
 474     return aRectangle;
 475 }
 476
 477 void SlideShowView::updateimpl( ::osl::ClearableMutexGuard& rGuard, SlideshowImpl* pSlideShow )
 478 {
 479     if( pSlideShow )
 480     {
 481         ::rtl::Reference< SlideshowImpl > aSLGuard( pSlideShow );
 482
 483         if( mbFirstPaint )
 484         {
 485             mbFirstPaint = false;
 486             SlideshowImpl* pTmpSlideShow = mpSlideShow;
 487             rGuard.clear();
 488             if( pTmpSlideShow )
 489                 pTmpSlideShow->onFirstPaint();
 490         } else
 491             rGuard.clear();
 492
 493         pSlideShow->startUpdateTimer();
 494     }
 495 }
 496
 497 // XWindowListener methods
 498 void SAL_CALL SlideShowView::windowResized( const awt::WindowEvent& e )
 499 {
 500     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 501
 502     if( mpViewListeners.get() )
 503     {
 504         // Change event source, to enable listeners to match event
 505         // with view
 506         awt::WindowEvent aEvent( e );
 507         aEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 508
 509         mpViewListeners->notify( aEvent );
 510         updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 511     }
 512 }
 513
 514 void SAL_CALL SlideShowView::windowMoved( const awt::WindowEvent& )
 515 {
 516     // ignored
 517 }
 518
 519 void SAL_CALL SlideShowView::windowShown( const lang::EventObject& )
 520 {
 521     // ignored
 522 }
 523
 524 void SAL_CALL SlideShowView::windowHidden( const lang::EventObject& )
 525 {
 526     // ignored
 527 }
 528
 529 // XMouseListener implementation
 530 void SAL_CALL SlideShowView::mousePressed( const awt::MouseEvent& e )
 531 {
 532     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 533     if( mpSlideShow && mpSlideShow->isInputFreezed() )
 534     {
 535         mbMousePressedEaten = true;
 536     }
 537     else
 538     {
 539         mbMousePressedEaten = false;
 540
 541         // Change event source, to enable listeners to match event
 542         // with view
 543         WrappedMouseEvent aEvent;
 544         aEvent.meType = WrappedMouseEvent::PRESSED;
 545         aEvent.maEvent = e;
 546         aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 547
 548         if( mpMouseListeners.get() )
 549             mpMouseListeners->notify( aEvent );
 550         updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 551     }
 552 }
 553
 554 void SAL_CALL SlideShowView::mouseReleased( const awt::MouseEvent& e )
 555 {
 556     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 557     if( mbMousePressedEaten )
 558     {
 559         // if mouse button down was ignored, also ignore mouse button up
 560         mbMousePressedEaten = false;
 561     }
 562     else if( mpSlideShow && !mpSlideShow->isInputFreezed() )
 563     {
 564         // Change event source, to enable listeners to match event
 565         // with view
 566         WrappedMouseEvent aEvent;
 567         aEvent.meType = WrappedMouseEvent::RELEASED;
 568         aEvent.maEvent = e;
 569         aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 570
 571         if( mpMouseListeners.get() )
 572             mpMouseListeners->notify( aEvent );
 573         updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 574     }
 575 }
 576
 577 void SAL_CALL SlideShowView::mouseEntered( const awt::MouseEvent& e )
 578 {
 579     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 580
 581     // Change event source, to enable listeners to match event
 582     // with view
 583     WrappedMouseEvent aEvent;
 584     aEvent.meType = WrappedMouseEvent::ENTERED;
 585     aEvent.maEvent = e;
 586     aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 587
 588     if( mpMouseListeners.get() )
 589         mpMouseListeners->notify( aEvent );
 590     updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 591 }
 592
 593 void SAL_CALL SlideShowView::mouseExited( const awt::MouseEvent& e )
 594 {
 595     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 596
 597     // Change event source, to enable listeners to match event
 598     // with view
 599     WrappedMouseEvent aEvent;
 600     aEvent.meType = WrappedMouseEvent::EXITED;
 601     aEvent.maEvent = e;
 602     aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 603
 604     if( mpMouseListeners.get() )
 605         mpMouseListeners->notify( aEvent );
 606     updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 607 }
 608
 609 // XMouseMotionListener implementation
 610 void SAL_CALL SlideShowView::mouseDragged( const awt::MouseEvent& e )
 611 {
 612     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 613
 614     // Change event source, to enable listeners to match event
 615     // with view
 616     WrappedMouseMotionEvent aEvent;
 617     aEvent.meType = WrappedMouseMotionEvent::DRAGGED;
 618     aEvent.maEvent = e;
 619     aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 620
 621     if( mpMouseMotionListeners.get() )
 622         mpMouseMotionListeners->notify( aEvent );
 623     updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 624 }
 625
 626 void SAL_CALL SlideShowView::mouseMoved( const awt::MouseEvent& e )
 627 {
 628     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 629
 630     // Change event source, to enable listeners to match event
 631     // with view
 632     WrappedMouseMotionEvent aEvent;
 633     aEvent.meType = WrappedMouseMotionEvent::MOVED;
 634     aEvent.maEvent = e;
 635     aEvent.maEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 636
 637     if( mpMouseMotionListeners.get() )
 638         mpMouseMotionListeners->notify( aEvent );
 639     updateimpl( aGuard, mpSlideShow ); // warning: clears guard!
 640 }
 641
 642 void SlideShowView::init()
 643 {
 644     mxWindow->addWindowListener( this );
 645     mxWindow->addMouseListener( this );
 646
 647     mxPointer = awt::Pointer::create( ::comphelper::getProcessComponentContext() );
 648
 649     getTransformation();
 650
 651     // #i48939# only switch on kind of hacky scroll optimization, when
 652     // running fullscreen. this minimizes the probability that other
 653     // windows partially cover the show.
 654     if( mbFullScreen )
 655     {
 656         try
 657         {
 658             Reference< beans::XPropertySet > xCanvasProps( getCanvas(),
 659                                                            uno::UNO_QUERY_THROW );
 660             xCanvasProps->setPropertyValue("UnsafeScrolling",
 661                 uno::makeAny( true ) );
 662         }
 663         catch( uno::Exception& )
 664         {
 665         }
 666     }
 667 }
 668
 669 } // namespace ::sd
 670
 671 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */