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