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