sd/source/ui/slideshow/slideshowviewimpl.cxx

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