sd/source/ui/slideshow/slideshowimpl.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: slideshowimpl.cxx,v $
  10  * $Revision: 1.57.10.1 $
  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
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sd.hxx"
  34
  35 #include <boost/scoped_ptr.hpp>
  36
  37 #include <com/sun/star/lang/XInitialization.hpp>
  38 #include <com/sun/star/document/XEventsSupplier.hpp>
  39 #include <com/sun/star/drawing/XMasterPageTarget.hpp>
  40 #include <com/sun/star/container/XNameReplace.hpp>
  41 #include <com/sun/star/beans/PropertyValue.hpp>
  42 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  43 #include <com/sun/star/beans/XPropertySet.hpp>
  44 #include <com/sun/star/awt/SystemPointer.hpp>
  45 #include <com/sun/star/util/XURLTransformer.hpp>
  46 #include <com/sun/star/frame/XDispatch.hpp>
  47 #include <com/sun/star/frame/XLayoutManager.hpp>
  48 #include <vos/process.hxx>
  49 #include <svtools/aeitem.hxx>
  50 #include <svtools/urihelper.hxx>
  51
  52 #include <toolkit/unohlp.hxx>
  53
  54 #include <sfx2/imagemgr.hxx>
  55 #include <sfx2/request.hxx>
  56 #include "sfx2/docfile.hxx"
  57 #include <svx/unoapi.hxx>
  58 #include <svx/svdoole2.hxx>
  59
  60 // for child window ids
  61 #include <sfx2/templdlg.hxx>
  62 #include <svx/f3dchild.hxx>
  63 #include <svx/imapdlg.hxx>
  64 #include <svx/fontwork.hxx>
  65 #include <svx/colrctrl.hxx>
  66 #include <svx/bmpmask.hxx>
  67 #include <svx/srchdlg.hxx>
  68 #include <svx/hyprlink.hxx>
  69 #include <svx/hyperdlg.hxx>
  70 #include <svx/galbrws.hxx>
  71 #include "NavigatorChildWindow.hxx"
  72 #include "AnimationChildWindow.hxx"
  73 #include <slideshowimpl.hxx>
  74 #include <slideshowviewimpl.hxx>
  75 #include <pgjump.hxx>
  76 #include "PaneHider.hxx"
  77
  78 #include "glob.hrc"
  79 #include "res_bmp.hrc"
  80 #include "sdresid.hxx"
  81 #include "vcl/canvastools.hxx"
  82 #include "comphelper/anytostring.hxx"
  83 #include "cppuhelper/exc_hlp.hxx"
  84 #include "rtl/ref.hxx"
  85 #include "slideshow.hrc"
  86 #include "canvas/elapsedtime.hxx"
  87 #include "canvas/prioritybooster.hxx"
  88 #include "avmedia/mediawindow.hxx"
  89 #include  "svtools/colrdlg.hxx"
  90
  91 #include <boost/noncopyable.hpp>
  92 #include <boost/bind.hpp>
  93
  94 using ::rtl::OUString;
  95 using ::rtl::OString;
  96 using ::cppu::OInterfaceContainerHelper;
  97 using ::comphelper::ImplementationReference;
  98 using ::com::sun::star::animations::XAnimationNode;
  99 using ::com::sun::star::animations::XAnimationListener;
 100 using ::com::sun::star::awt::XWindow;
 101 using namespace ::com::sun::star;
 102 using namespace ::com::sun::star::lang;
 103 using namespace ::com::sun::star::uno;
 104 using namespace ::com::sun::star::drawing;
 105 using namespace ::com::sun::star::container;
 106 using namespace ::com::sun::star::document;
 107 using namespace ::com::sun::star::presentation;
 108 using namespace ::com::sun::star::drawing;
 109 using namespace ::com::sun::star::beans;
 110
 111 extern void NotifyDocumentEvent( SdDrawDocument* pDocument, const rtl::OUString& rEventName );
 112 extern String getUiNameFromPageApiNameImpl( const OUString& rApiName );
 113
 114 namespace sd
 115 {
 116 ///////////////////////////////////////////////////////////////////////
 117
 118 // Slots, welche im Sfx verwaltet werden und in der SlideShow disabled
 119 // werden sollen (muss in Reihenfolge der SIDs geordnet sein)
 120 static USHORT __READONLY_DATA pAllowed[] =
 121 {
 122     SID_OPENDOC                                                         , //     5501   // damit interne Spruenge klappen
 123     SID_JUMPTOMARK                                                      , //     5598
 124 //      SID_SHOWPOPUPS                                                  , //     5929
 125 //    SID_GALLERY                             , //     5960
 126     SID_OPENHYPERLINK                                           , //     6676
 127 //    SID_GALLERY_FORMATS                     , //    10280
 128     SID_NAVIGATOR                                                       , //    10366
 129 //      SID_FM_DESIGN_MODE                                              , //    10629
 130     SID_PRESENTATION_END                                        , //    27218
 131     SID_NAVIGATOR_PAGENAME                                      , //    27287
 132     SID_NAVIGATOR_STATE                                         , //    27288
 133     SID_NAVIGATOR_INIT                                          , //    27289
 134     SID_NAVIGATOR_PEN                                           , //    27291
 135     SID_NAVIGATOR_PAGE                                          , //    27292
 136     SID_NAVIGATOR_OBJECT                                          //    27293
 137 };
 138
 139 ///////////////////////////////////////////////////////////////////////
 140
 141 ///////////////////////////////////////////////////////////////////////
 142 // AnimationSlideController
 143 ///////////////////////////////////////////////////////////////////////
 144
 145 class AnimationSlideController
 146 {
 147 public:
 148     enum Mode { ALL, FROM, CUSTOM, PREVIEW };
 149
 150 public:
 151     AnimationSlideController( Reference< XIndexAccess > xSlides, Mode eMode );
 152
 153     void setStartSlideNumber( sal_Int32 nSlideNumber ) { mnStartSlideNumber = nSlideNumber; }
 154     sal_Int32 getStartSlideIndex() const;
 155
 156     sal_Int32 getCurrentSlideNumber() const;
 157     sal_Int32 getCurrentSlideIndex() const;
 158
 159     sal_Int32 getSlideIndexCount() const { return maSlideNumbers.size(); }
 160     sal_Int32 getSlideNumberCount() const { return mnSlideCount; }
 161
 162     sal_Int32 getSlideNumber( sal_Int32 nSlideIndex ) const;
 163
 164     void insertSlideNumber( sal_Int32 nSlideNumber, bool bVisible = true );
 165     void setPreviewNode( const Reference< XAnimationNode >& xPreviewNode );
 166
 167     bool jumpToSlideIndex( sal_Int32 nNewSlideIndex );
 168     bool jumpToSlideNumber( sal_Int32 nNewSlideIndex );
 169
 170     bool nextSlide();
 171     bool previousSlide();
 172
 173         void displayCurrentSlide(
 174         const Reference< XSlideShow >& xShow,
 175         const bool bSkipAllMainSequenceEffects);
 176
 177     sal_Int32 getNextSlideIndex() const;
 178     sal_Int32 getPreviousSlideIndex() const;
 179
 180     bool isVisibleSlideNumber( sal_Int32 nSlideNumber ) const;
 181
 182     Reference< XDrawPage > getSlideByNumber( sal_Int32 nSlideNumber ) const;
 183
 184     sal_Int32 getNextSlideNumber() const;
 185
 186     bool hasSlides() const { return !maSlideNumbers.empty(); }
 187
 188 private:
 189     bool getSlideAPI( sal_Int32 nSlideNumber, Reference< XDrawPage >& xSlide, Reference< XAnimationNode >& xAnimNode );
 190     sal_Int32 findSlideIndex( sal_Int32 nSlideNumber ) const;
 191
 192     bool isValidIndex( sal_Int32 nIndex ) const { return (nIndex >= 0) && (nIndex < (sal_Int32)maSlideNumbers.size()); }
 193     bool isValidSlideNumber( sal_Int32 nSlideNumber ) const { return (nSlideNumber >= 0) && (nSlideNumber < mnSlideCount); }
 194
 195 private:
 196     Mode meMode;
 197     sal_Int32 mnStartSlideNumber;
 198     std::vector< sal_Int32 > maSlideNumbers;
 199     std::vector< bool > maSlideVisible;
 200     std::vector< bool > maSlideVisited;
 201     Reference< XAnimationNode > mxPreviewNode;
 202     sal_Int32 mnSlideCount;
 203     sal_Int32 mnCurrentSlideIndex;
 204     sal_Int32 mnHiddenSlideNumber;
 205     Reference< XIndexAccess > mxSlides;
 206 };
 207
 208 Reference< XDrawPage > AnimationSlideController::getSlideByNumber( sal_Int32 nSlideNumber ) const
 209 {
 210     Reference< XDrawPage > xSlide;
 211     if( mxSlides.is() && (nSlideNumber >= 0) && (nSlideNumber < mxSlides->getCount()) )
 212         mxSlides->getByIndex( nSlideNumber ) >>= xSlide;
 213     return xSlide;
 214 }
 215
 216 bool AnimationSlideController::isVisibleSlideNumber( sal_Int32 nSlideNumber ) const
 217 {
 218     sal_Int32 nIndex = findSlideIndex( nSlideNumber );
 219
 220     if( nIndex != -1 )
 221         return maSlideVisible[ nIndex ];
 222     else
 223         return false;
 224 }
 225
 226
 227 void AnimationSlideController::setPreviewNode( const Reference< XAnimationNode >& xPreviewNode )
 228 {
 229     mxPreviewNode = xPreviewNode;
 230 }
 231
 232 AnimationSlideController::AnimationSlideController( Reference< XIndexAccess > xSlides, Mode eMode  )
 233 :       meMode( eMode )
 234 ,       mnStartSlideNumber(-1)
 235 ,       mnSlideCount( 0 )
 236 ,       mnCurrentSlideIndex(0)
 237 ,       mnHiddenSlideNumber( -1 )
 238 ,       mxSlides( xSlides )
 239 {
 240     if( mxSlides.is() )
 241         mnSlideCount = xSlides->getCount();
 242 }
 243
 244 sal_Int32 AnimationSlideController::getStartSlideIndex() const
 245 {
 246     if( mnStartSlideNumber >= 0 )
 247     {
 248         sal_Int32 nIndex;
 249         const sal_Int32 nCount = maSlideNumbers.size();
 250
 251         for( nIndex = 0; nIndex < nCount; nIndex++ )
 252         {
 253             if( maSlideNumbers[nIndex] == mnStartSlideNumber )
 254                 return nIndex;
 255         }
 256     }
 257
 258     return 0;
 259 }
 260
 261 sal_Int32 AnimationSlideController::getCurrentSlideNumber() const
 262 {
 263     if( mnHiddenSlideNumber != -1 )
 264         return mnHiddenSlideNumber;
 265     else if( !maSlideNumbers.empty() )
 266         return maSlideNumbers[mnCurrentSlideIndex];
 267     else
 268         return 0;
 269 }
 270
 271 sal_Int32 AnimationSlideController::getCurrentSlideIndex() const
 272 {
 273     if( mnHiddenSlideNumber != -1 )
 274         return -1;
 275     else
 276         return mnCurrentSlideIndex;
 277 }
 278
 279 bool AnimationSlideController::jumpToSlideIndex( sal_Int32 nNewSlideIndex )
 280 {
 281     if( isValidIndex( nNewSlideIndex ) )
 282     {
 283         mnCurrentSlideIndex = nNewSlideIndex;
 284         mnHiddenSlideNumber = -1;
 285         maSlideVisited[mnCurrentSlideIndex] = true;
 286         return true;
 287     }
 288     else
 289     {
 290         return false;
 291     }
 292 }
 293
 294 bool AnimationSlideController::jumpToSlideNumber( sal_Int32 nNewSlideNumber )
 295 {
 296     sal_Int32 nIndex = findSlideIndex( nNewSlideNumber );
 297     if( isValidIndex( nIndex ) )
 298     {
 299         return jumpToSlideIndex( nIndex );
 300     }
 301     else if( (nNewSlideNumber >= 0) && (nNewSlideNumber < mnSlideCount) )
 302     {
 303         // jump to a hidden slide
 304         mnHiddenSlideNumber = nNewSlideNumber;
 305         return true;
 306     }
 307     else
 308     {
 309         return false;
 310     }
 311 }
 312
 313 sal_Int32 AnimationSlideController::getSlideNumber( sal_Int32 nSlideIndex ) const
 314 {
 315     if( isValidIndex( nSlideIndex ) )
 316         return maSlideNumbers[nSlideIndex];
 317     else
 318         return -1;
 319 }
 320
 321 void AnimationSlideController::insertSlideNumber( sal_Int32 nSlideNumber, bool bVisible /* = true */ )
 322 {
 323     DBG_ASSERT( isValidSlideNumber( nSlideNumber ), "sd::AnimationSlideController::insertSlideNumber(), illegal index" );
 324     if( isValidSlideNumber( nSlideNumber ) )
 325     {
 326         maSlideNumbers.push_back( nSlideNumber );
 327         maSlideVisible.push_back( bVisible );
 328         maSlideVisited.push_back( false );
 329     }
 330 }
 331
 332 bool AnimationSlideController::getSlideAPI( sal_Int32 nSlideNumber, Reference< XDrawPage >& xSlide, Reference< XAnimationNode >& xAnimNode )
 333 {
 334     if( isValidSlideNumber( nSlideNumber ) ) try
 335     {
 336         xSlide = Reference< XDrawPage >( mxSlides->getByIndex(nSlideNumber), UNO_QUERY_THROW );
 337
 338         if( meMode == PREVIEW )
 339         {
 340             xAnimNode = mxPreviewNode;
 341         }
 342         else
 343         {
 344                Reference< animations::XAnimationNodeSupplier > xAnimNodeSupplier( xSlide, UNO_QUERY_THROW );
 345             xAnimNode = xAnimNodeSupplier->getAnimationNode();
 346         }
 347
 348         return true;
 349     }
 350     catch( Exception& e )
 351     {
 352         (void)e;
 353         DBG_ERROR(
 354             (OString("sd::AnimationSlideController::getSlideAPI(), "
 355                     "exception caught: ") +
 356             rtl::OUStringToOString(
 357                 comphelper::anyToString( cppu::getCaughtException() ),
 358                 RTL_TEXTENCODING_UTF8 )).getStr() );
 359
 360     }
 361
 362     return false;
 363 }
 364
 365 sal_Int32 AnimationSlideController::findSlideIndex( sal_Int32 nSlideNumber ) const
 366 {
 367     sal_Int32 nIndex;
 368     const sal_Int32 nCount = maSlideNumbers.size();
 369
 370     for( nIndex = 0; nIndex < nCount; nIndex++ )
 371     {
 372         if( maSlideNumbers[nIndex] == nSlideNumber )
 373             return nIndex;
 374     }
 375
 376     return -1;
 377 }
 378
 379 sal_Int32 AnimationSlideController::getNextSlideIndex() const
 380 {
 381     switch( meMode )
 382     {
 383     case ALL:
 384         {
 385             sal_Int32 nNewSlideIndex = mnCurrentSlideIndex + 1;
 386             if( isValidIndex( nNewSlideIndex ) )
 387             {
 388                 // if the current slide is not excluded, make sure the
 389                 // next slide is also not excluded.
 390                 // if the current slide is excluded, we want to go
 391                 // to the next slide, even if this is also excluded.
 392                 if( maSlideVisible[mnCurrentSlideIndex] )
 393                 {
 394                     while( isValidIndex( nNewSlideIndex ) )
 395                     {
 396                         if( maSlideVisible[nNewSlideIndex] )
 397                             break;
 398
 399                         nNewSlideIndex++;
 400                     }
 401                 }
 402             }
 403             return isValidIndex( nNewSlideIndex ) ? nNewSlideIndex : -1;
 404         }
 405
 406     case FROM:
 407     case CUSTOM:
 408         return mnHiddenSlideNumber == -1 ? mnCurrentSlideIndex + 1 : mnCurrentSlideIndex;
 409
 410     default:
 411     case PREVIEW:
 412         return -1;
 413
 414     }
 415 }
 416
 417 sal_Int32 AnimationSlideController::getNextSlideNumber() const
 418 {
 419     sal_Int32 nNextSlideIndex = getNextSlideIndex();
 420     if( isValidIndex( nNextSlideIndex ) )
 421     {
 422         return maSlideNumbers[nNextSlideIndex];
 423     }
 424     else
 425     {
 426         return -1;
 427     }
 428 }
 429
 430
 431 bool AnimationSlideController::nextSlide()
 432 {
 433     return jumpToSlideIndex( getNextSlideIndex() );
 434 }
 435
 436 sal_Int32 AnimationSlideController::getPreviousSlideIndex() const
 437 {
 438     sal_Int32 nNewSlideIndex = mnCurrentSlideIndex - 1;
 439
 440     switch( meMode )
 441     {
 442         case ALL:
 443         {
 444             // make sure the previous slide is visible
 445             // or was already visited
 446             while( isValidIndex( nNewSlideIndex ) )
 447             {
 448                 if( maSlideVisible[nNewSlideIndex] || maSlideVisited[nNewSlideIndex] )
 449                     break;
 450
 451                 nNewSlideIndex--;
 452             }
 453
 454             break;
 455         }
 456
 457         case PREVIEW:
 458             return -1;
 459
 460         default:
 461             break;
 462     }
 463
 464     return nNewSlideIndex;
 465 }
 466
 467 bool AnimationSlideController::previousSlide()
 468 {
 469     return jumpToSlideIndex( getPreviousSlideIndex() );
 470 }
 471
 472 void AnimationSlideController::displayCurrentSlide(
 473     const Reference< XSlideShow >& xShow,
 474     const bool bSkipAllMainSequenceEffects)
 475 {
 476     const sal_Int32 nCurrentSlideNumber = getCurrentSlideNumber();
 477
 478     if( xShow.is() && (nCurrentSlideNumber != -1 ) )
 479     {
 480         Reference< XDrawPage > xSlide;
 481         Reference< XAnimationNode > xAnimNode;
 482         ::std::vector<PropertyValue> aProperties;
 483
 484         const sal_Int32 nNextSlideNumber = getNextSlideNumber();
 485         if( getSlideAPI( nNextSlideNumber, xSlide, xAnimNode )  )
 486         {
 487             Sequence< Any > aValue(2);
 488             aValue[0] <<= xSlide;
 489             aValue[1] <<= xAnimNode;
 490                         aProperties.push_back(
 491                 PropertyValue(
 492                     OUString( RTL_CONSTASCII_USTRINGPARAM( "Prefetch" ) ),
 493                     -1,
 494                     Any(aValue),
 495                     PropertyState_DIRECT_VALUE));
 496         }
 497         if (bSkipAllMainSequenceEffects)
 498         {
 499             // Add one property that prevents the slide transition from being
 500             // shown (to speed up the transition to the previous slide) and
 501             // one to show all main sequence effects so that the user can
 502             // continue to undo effects.
 503             aProperties.push_back(
 504                 PropertyValue(
 505                     OUString( RTL_CONSTASCII_USTRINGPARAM("SkipAllMainSequenceEffects")),
 506                     -1,
 507                     Any(sal_True),
 508                     PropertyState_DIRECT_VALUE));
 509             aProperties.push_back(
 510                 PropertyValue(
 511                     OUString( RTL_CONSTASCII_USTRINGPARAM("SkipSlideTransition")),
 512                     -1,
 513                     Any(sal_True),
 514                     PropertyState_DIRECT_VALUE));
 515         }
 516
 517         // Convert vector into uno Sequence.
 518                 Sequence< PropertyValue > aPropertySequence (aProperties.size());
 519         for (int nIndex=0,nCount=aProperties.size();nIndex<nCount; ++nIndex)
 520             aPropertySequence[nIndex] = aProperties[nIndex];
 521
 522         if( getSlideAPI( nCurrentSlideNumber, xSlide, xAnimNode ) )
 523                         xShow->displaySlide( xSlide, xAnimNode, aPropertySequence );
 524     }
 525 }
 526
 527 ///////////////////////////////////////////////////////////////////////
 528 // class SlideshowImpl
 529 ///////////////////////////////////////////////////////////////////////
 530
 531 SlideshowImpl::SlideshowImpl( const Reference< XPresentation2 >& xPresentation, ViewShell* pViewSh, ::sd::View* pView, SdDrawDocument* pDoc, ::Window* pParentWindow )
 532 : SlideshowImplBase( m_aMutex )
 533 , mxModel(pDoc->getUnoModel(),UNO_QUERY_THROW)
 534 , mpView(pView)
 535 , mpViewShell(pViewSh)
 536 , mpDocSh(pDoc->GetDocSh())
 537 , mpDoc(pDoc)
 538 , mpNewAttr(0)
 539 , mpParentWindow(pParentWindow)
 540 , mpShowWindow(0)
 541 , mpTimeButton(0)
 542 , mnRestoreSlide(0)
 543 , maPresSize( -1, -1 )
 544 , meAnimationMode(ANIMATIONMODE_SHOW)
 545 , mpOldActiveWindow(0)
 546 , mnChildMask( 0 )
 547 , mbGridVisible(false)
 548 , mbBordVisible(false)
 549 , mbSlideBorderVisible(false)
 550 , mbSetOnlineSpelling(false)
 551 , mbDisposed(false)
 552 , mbRehearseTimings(false)
 553 , mbDesignMode(false)
 554 , mbIsPaused(false)
 555 , mbInputFreeze(false)
 556 , mbActive(sal_False)
 557 , maPresSettings( pDoc->getPresentationSettings() )
 558 , mnUserPaintColor( 0x00000000L )
 559 , mdUserPaintStrokeWidth ( 4.0 )
 560 , mnEntryCounter(0)
 561 , mnLastSlideNumber(-1)
 562 , msOnClick( RTL_CONSTASCII_USTRINGPARAM("OnClick") )
 563 , msBookmark( RTL_CONSTASCII_USTRINGPARAM("Bookmark") )
 564 , msVerb( RTL_CONSTASCII_USTRINGPARAM("Verb") )
 565 , mnEndShowEvent(0)
 566 , mnContextMenuEvent(0)
 567 , mnUpdateEvent(0)
 568 , mxPresentation( xPresentation )
 569 {
 570     if( mpViewShell )
 571         mpOldActiveWindow = mpViewShell->GetActiveWindow();
 572
 573     maUpdateTimer.SetTimeoutHdl(LINK(this, SlideshowImpl, updateHdl));
 574
 575     maDeactivateTimer.SetTimeoutHdl(LINK(this, SlideshowImpl, deactivateHdl));
 576     maDeactivateTimer.SetTimeout( 20 );
 577
 578     maInputFreezeTimer.SetTimeoutHdl( LINK( this, SlideshowImpl, ReadyForNextInputHdl ) );
 579     maInputFreezeTimer.SetTimeout( 20 );
 580
 581     SvtSaveOptions aOptions;
 582
 583         // no autosave during show
 584     if( aOptions.IsAutoSave() )
 585         mbAutoSaveWasOn = true;
 586
 587     Application::AddEventListener( LINK( this, SlideshowImpl, EventListenerHdl ) );
 588 }
 589
 590 SlideshowImpl::~SlideshowImpl()
 591 {
 592     Application::RemoveEventListener( LINK( this, SlideshowImpl, EventListenerHdl ) );
 593
 594     maDeactivateTimer.Stop();
 595
 596     if( !mbDisposed )
 597     {
 598         DBG_ERROR("SlideshowImpl::~SlideshowImpl(), component was not disposed!");
 599         disposing();
 600     }
 601 }
 602
 603 void SAL_CALL SlideshowImpl::disposing()
 604 {
 605     if( mxShow.is() && mpDoc )
 606         NotifyDocumentEvent( mpDoc, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("OnEndPresentation") ) );
 607
 608     if( mbAutoSaveWasOn )
 609         setAutoSaveState( true );
 610
 611     if( mnEndShowEvent )
 612         Application::RemoveUserEvent( mnEndShowEvent );
 613     if( mnContextMenuEvent )
 614         Application::RemoveUserEvent( mnContextMenuEvent );
 615
 616     maInputFreezeTimer.Stop();
 617
 618     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 619
 620     if( !mxShow.is() )
 621         return;
 622
 623     if( mxPresentation.is() )
 624         mxPresentation->end();
 625
 626     maUpdateTimer.Stop();
 627
 628     if( mnUpdateEvent )
 629     {
 630         Application::RemoveUserEvent( mnUpdateEvent );
 631         mnUpdateEvent = 0;
 632     }
 633
 634     removeShapeEvents();
 635
 636     if( mxListenerProxy.is() )
 637         mxListenerProxy->removeAsSlideShowListener();
 638
 639     try
 640     {
 641         if( mxView.is() )
 642             mxShow->removeView( mxView.getRef() );
 643
 644         Reference< XComponent > xComponent( mxShow, UNO_QUERY );
 645         if( xComponent.is() )
 646             xComponent->dispose();
 647
 648         if( mxView.is() )
 649             mxView->dispose();
 650     }
 651     catch( Exception& e )
 652     {
 653         static_cast<void>(e);
 654         DBG_ERROR(
 655             (OString("sd::SlideshowImpl::stop(), "
 656                     "exception caught: ") +
 657             rtl::OUStringToOString(
 658                 comphelper::anyToString( cppu::getCaughtException() ),
 659                 RTL_TEXTENCODING_UTF8 )).getStr() );
 660
 661     }
 662
 663     mxShow.clear();
 664     mxView.reset();
 665     mxListenerProxy.clear();
 666     mpSlideController.reset();
 667
 668     // der DrawView das Praesentationfenster wegnehmen und ihr dafuer ihre alten Fenster wiedergeben
 669     if( mpShowWindow && mpView )
 670         mpView->DeleteWindowFromPaintView( mpShowWindow );
 671
 672     if( mpView )
 673         mpView->SetAnimationPause( FALSE );
 674
 675     if( mpViewShell )
 676     {
 677         mpViewShell->SetActiveWindow(mpOldActiveWindow);
 678         mpShowWindow->SetViewShell( NULL );
 679     }
 680
 681     if( mpView )
 682         mpView->InvalidateAllWin();
 683
 684     if( maPresSettings.mbFullScreen )
 685     {
 686         // restore StarBASICErrorHdl
 687         StarBASIC::SetGlobalErrorHdl(maStarBASICGlobalErrorHdl);
 688         maStarBASICGlobalErrorHdl = Link();
 689     }
 690     else
 691     {
 692         if( mpShowWindow )
 693             mpShowWindow->Hide();
 694     }
 695
 696     if( meAnimationMode == ANIMATIONMODE_SHOW )
 697     {
 698         mpDocSh->SetSlotFilter();
 699         mpDocSh->ApplySlotFilter();
 700
 701         Help::EnableContextHelp();
 702         Help::EnableExtHelp();
 703
 704         showChildWindows();
 705         mnChildMask = 0UL;
 706     }
 707
 708     // aktuelle Fenster wieder einblenden
 709     if( mpViewShell && !mpViewShell->ISA(PresentationViewShell))
 710     {
 711         if( meAnimationMode == ANIMATIONMODE_SHOW )
 712         {
 713             mpViewShell->GetViewShellBase().ShowUIControls (true);
 714             mpPaneHider.reset();
 715         }
 716         else if( meAnimationMode == ANIMATIONMODE_PREVIEW )
 717         {
 718             mpViewShell->ShowUIControls (true);
 719         }
 720     }
 721
 722     if( mpTimeButton )
 723     {
 724         mpTimeButton->Hide();
 725         delete mpTimeButton;
 726         mpTimeButton = 0;
 727     }
 728
 729     if( mpShowWindow )
 730         mpShowWindow->Hide();
 731
 732     if ( mpViewShell )
 733     {
 734         if( meAnimationMode == ANIMATIONMODE_SHOW )
 735         {
 736             ::sd::Window* pActWin = mpViewShell->GetActiveWindow();
 737
 738             if (pActWin)
 739             {
 740                 Size aVisSizePixel = pActWin->GetOutputSizePixel();
 741                 Rectangle aVisAreaWin = pActWin->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
 742                 mpViewShell->VisAreaChanged(aVisAreaWin);
 743                 mpView->VisAreaChanged(pActWin);
 744                 pActWin->GrabFocus();
 745             }
 746         }
 747
 748         // restart the custom show dialog if he started us
 749         if( mpViewShell->IsStartShowWithDialog() && getDispatcher() )
 750         {
 751             mpViewShell->SetStartShowWithDialog( FALSE );
 752             getDispatcher()->Execute( SID_CUSTOMSHOW_DLG, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
 753         }
 754
 755         mpViewShell->GetViewShellBase().UpdateBorder(true);
 756     }
 757
 758     if( mpShowWindow )
 759     {
 760         delete mpShowWindow;
 761         mpShowWindow = 0;
 762     }
 763
 764     setActiveXToolbarsVisible( sal_True );
 765
 766     mbDisposed = true;
 767 }
 768
 769 bool SlideshowImpl::startPreview(
 770         const Reference< XDrawPage >& xDrawPage,
 771         const Reference< XAnimationNode >& xAnimationNode,
 772         ::Window* pParent )
 773 {
 774     bool bRet = false;
 775
 776     try
 777     {
 778         const Reference<lang::XServiceInfo> xServiceInfo( xDrawPage, UNO_QUERY );
 779         if (xServiceInfo.is()) {
 780             const Sequence<OUString> supportedServices(
 781                 xServiceInfo->getSupportedServiceNames() );
 782             for ( sal_Int32 pos = supportedServices.getLength(); pos--; ) {
 783                 if (supportedServices[pos].equalsAsciiL(
 784                         RTL_CONSTASCII_STRINGPARAM(
 785                             "com.sun.star.drawing.MasterPage") )) {
 786                     DBG_ERROR("sd::SlideshowImpl::startPreview() "
 787                               "not allowed on master page!");
 788                     return false;
 789                 }
 790             }
 791         }
 792
 793         mxPreviewDrawPage = xDrawPage;
 794         mxPreviewAnimationNode = xAnimationNode;
 795         meAnimationMode = ANIMATIONMODE_PREVIEW;
 796
 797         maPresSettings.mbAll = sal_False;
 798         maPresSettings.mbEndless = sal_False;
 799         maPresSettings.mbCustomShow = sal_False;
 800         maPresSettings.mbManual = sal_False;
 801         maPresSettings.mbMouseVisible = sal_False;
 802         maPresSettings.mbMouseAsPen = sal_False;
 803         maPresSettings.mbLockedPages = sal_False;
 804         maPresSettings.mbAlwaysOnTop = sal_False;
 805         maPresSettings.mbFullScreen = sal_False;
 806         maPresSettings.mbAnimationAllowed = sal_True;
 807         maPresSettings.mnPauseTimeout = 0;
 808         maPresSettings.mbShowPauseLogo = sal_False;
 809         maPresSettings.mbStartWithNavigator = sal_False;
 810
 811         Reference< XDrawPagesSupplier > xDrawPages( mpDoc->getUnoModel(), UNO_QUERY_THROW );
 812         Reference< XIndexAccess > xSlides( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
 813         mpSlideController.reset( new AnimationSlideController( xSlides, AnimationSlideController::PREVIEW ) );
 814
 815         sal_Int32 nSlideNumber = 0;
 816         Reference< XPropertySet > xSet( mxPreviewDrawPage, UNO_QUERY_THROW );
 817         xSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Number" ) ) ) >>= nSlideNumber;
 818         mpSlideController->insertSlideNumber( nSlideNumber-1 );
 819         mpSlideController->setPreviewNode( xAnimationNode );
 820
 821         mpShowWindow = new ShowWindow( this, ((pParent == 0) && mpViewShell) ?  mpParentWindow : pParent );
 822         if( mpViewShell )
 823         {
 824             mpViewShell->SetActiveWindow( mpShowWindow );
 825             mpShowWindow->SetViewShell (mpViewShell);
 826             mpViewShell->ShowUIControls (false);
 827         }
 828
 829         if( mpView )
 830         {
 831             mpView->AddWindowToPaintView( mpShowWindow );
 832             mpView->SetAnimationPause( TRUE );
 833         }
 834
 835         // call resize handler
 836         if( pParent )
 837         {
 838             maPresSize = pParent->GetSizePixel();
 839         }
 840         else if( mpViewShell )
 841         {
 842             Rectangle aContentRect (mpViewShell->GetViewShellBase().getClientRectangle());
 843             if (Application::GetSettings().GetLayoutRTL())
 844             {
 845                 aContentRect.nLeft = aContentRect.nRight;
 846                 aContentRect.nRight += aContentRect.nRight;
 847             }
 848             maPresSize = aContentRect.GetSize();
 849             mpShowWindow->SetPosPixel( aContentRect.TopLeft() );
 850         }
 851         else
 852         {
 853             DBG_ERROR("sd::SlideshowImpl::startPreview(), I need either a parent window or a viewshell!");
 854         }
 855         resize( maPresSize );
 856
 857         sal_Int32 nPropertyCount = 1;
 858         if( mxPreviewAnimationNode.is() )
 859             nPropertyCount++;
 860
 861         Sequence< beans::PropertyValue > aProperties(nPropertyCount);
 862         aProperties[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM("AutomaticAdvancement") );
 863         aProperties[0].Value = uno::makeAny( (double)1.0 ); // one second timeout
 864
 865         if( mxPreviewAnimationNode.is() )
 866         {
 867             aProperties[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM("NoSlideTransitions") );
 868             aProperties[1].Value = uno::makeAny( sal_True );
 869         }
 870
 871         bRet = startShowImpl( aProperties );
 872
 873         if( mpShowWindow != 0 && meAnimationMode == ANIMATIONMODE_PREVIEW )
 874             mpShowWindow->SetPreviewMode();
 875
 876     }
 877     catch( Exception& e )
 878     {
 879         (void)e;
 880         DBG_ERROR(
 881             (OString("sd::SlideshowImpl::startPreview(), "
 882                      "exception caught: ") +
 883              rtl::OUStringToOString(
 884                  comphelper::anyToString( cppu::getCaughtException() ),
 885                  RTL_TEXTENCODING_UTF8 )).getStr() );
 886         bRet = false;
 887     }
 888
 889     return bRet;
 890 }
 891
 892 bool SlideshowImpl::startShow( PresentationSettingsEx* pPresSettings )
 893 {
 894     const rtl::Reference<SlideshowImpl> this_(this);
 895
 896     DBG_ASSERT( !mxShow.is(), "sd::SlideshowImpl::startShow(), called twice!" );
 897     if( mxShow.is() )
 898         return true;
 899     DBG_ASSERT( mpParentWindow!=NULL, "sd::SlideshowImpl::startShow() called without parent window" );
 900     if (mpParentWindow == NULL)
 901         return false;
 902
 903     bool bRet = false;
 904
 905     try
 906     {
 907         if( pPresSettings )
 908         {
 909             maPresSettings = *pPresSettings;
 910             mbRehearseTimings = pPresSettings->mbRehearseTimings;
 911         }
 912
 913         // ---
 914
 915         String  aPresSlide( maPresSettings.maPresPage );
 916         SdPage* pStartPage = mpViewShell ? mpViewShell->GetActualPage() : 0;
 917         bool    bStartWithActualSlide =  pStartPage &&
 918                                         ( (meAnimationMode != ANIMATIONMODE_SHOW) ||
 919                                            SD_MOD()->GetSdOptions( mpDoc->GetDocumentType() )->IsStartWithActualPage() );
 920
 921         // sollen Zeiten gestoppt werden?
 922         if( mbRehearseTimings )
 923         {
 924             maPresSettings.mbEndless = sal_False;
 925             maPresSettings.mbManual = sal_True;
 926             maPresSettings.mbMouseVisible = sal_True;
 927             maPresSettings.mbMouseAsPen = sal_False;
 928             maPresSettings.mnPauseTimeout = 0;
 929             maPresSettings.mbShowPauseLogo = sal_False;
 930             maPresSettings.mbStartWithNavigator = sal_False;
 931         }
 932
 933         if( pStartPage )
 934         {
 935             if( pStartPage->GetPageKind() == PK_NOTES )
 936             {
 937                 // we are in notes page mode, so get
 938                 // the corresponding draw page
 939                 const USHORT nPgNum = ( pStartPage->GetPageNum() - 2 ) >> 1;
 940                 pStartPage = mpDoc->GetSdPage( nPgNum, PK_STANDARD );
 941             }
 942         }
 943
 944         if( bStartWithActualSlide )
 945         {
 946             if( meAnimationMode != ANIMATIONMODE_SHOW )
 947             {
 948                 if( pStartPage->GetPageKind() == PK_STANDARD )
 949                 {
 950                     aPresSlide = pStartPage->GetName();
 951                     maPresSettings.mbAll = false;
 952                 }
 953                 else
 954                 {
 955                     bStartWithActualSlide = false;
 956                 }
 957             }
 958         }
 959         else
 960         {
 961             if( pStartPage->GetPageKind() != PK_STANDARD )
 962             {
 963                 bStartWithActualSlide = false;
 964             }
 965         }
 966
 967         // build page list
 968         createSlideList( maPresSettings.mbAll, false, aPresSlide );
 969
 970         if( bStartWithActualSlide )
 971         {
 972             sal_Int32 nSlideNum = ( pStartPage->GetPageNum() - 1 ) >> 1;
 973
 974             if( !maPresSettings.mbAll && !maPresSettings.mbCustomShow )
 975             {
 976                 // its start from dia, find out if it is located before our current Slide
 977                 const sal_Int32 nSlideCount = mpDoc->GetSdPageCount( PK_STANDARD );
 978                 sal_Int32 nSlide;
 979                 for( nSlide = 0; (nSlide < nSlideCount); nSlide++ )
 980                 {
 981                     if( mpDoc->GetSdPage( (USHORT) nSlide, PK_STANDARD )->GetName() == aPresSlide )
 982                         break;
 983                 }
 984
 985                 if( nSlide > nSlideNum )
 986                     nSlideNum = -1;
 987             }
 988
 989             if( nSlideNum != -1 )
 990                 mpSlideController->setStartSlideNumber( nSlideNum );
 991         }
 992
 993         // remember Slide number from where the show was started
 994         if( pStartPage )
 995             mnRestoreSlide = ( pStartPage->GetPageNum() - 1 ) / 2;
 996
 997         if( mpSlideController->hasSlides() )
 998         {
 999             // hide child windows
1000             hideChildWindows();
1001
1002             mpShowWindow = new ShowWindow( this, mpParentWindow );
1003             mpShowWindow->SetMouseAutoHide( !maPresSettings.mbMouseVisible );
1004             if( mpViewShell )
1005             {
1006                 mpViewShell->SetActiveWindow( mpShowWindow );
1007                 mpShowWindow->SetViewShell (mpViewShell);
1008                 mpViewShell->GetViewShellBase().ShowUIControls (false);
1009                 // Hide the side panes for in-place presentations.
1010                 if ( ! maPresSettings.mbFullScreen)
1011                     mpPaneHider.reset(new PaneHider(*mpViewShell,this));
1012
1013                 if( getViewFrame() )
1014                     getViewFrame()->SetChildWindow( SID_NAVIGATOR, maPresSettings.mbStartWithNavigator );
1015             }
1016
1017             // these Slots are forbiden in other views for this document
1018             if( mpDocSh )
1019             {
1020                 mpDocSh->SetSlotFilter( TRUE, sizeof( pAllowed ) / sizeof( USHORT ), pAllowed );
1021                 mpDocSh->ApplySlotFilter();
1022             }
1023
1024             Help::DisableContextHelp();
1025             Help::DisableExtHelp();
1026
1027         //      mpTimeButton = new PushButton( mpShowWindow, SdResId( RID_TIME_BUTTON ) );
1028         //      maPencil = Pointer( POINTER_PEN );
1029         //      mpTimeButton->Hide();
1030
1031             if( maPresSettings.mbFullScreen )
1032             {
1033                 // disable basic ide error handling
1034                 maStarBASICGlobalErrorHdl = StarBASIC::GetGlobalErrorHdl();
1035                 StarBASIC::SetGlobalErrorHdl( Link() );
1036             }
1037
1038             // call resize handler
1039             maPresSize = mpParentWindow->GetSizePixel();
1040             if( !maPresSettings.mbFullScreen && mpViewShell )
1041             {
1042                 const Rectangle& aClientRect = mpViewShell->GetViewShellBase().getClientRectangle();
1043                 maPresSize = aClientRect.GetSize();
1044                 mpShowWindow->SetPosPixel( aClientRect.TopLeft() );
1045                 resize( maPresSize );
1046             }
1047
1048             // #i41824#
1049             // Note: In FullScreen Mode the OS (window manager) sends a resize to
1050             // the WorkWindow once it actually resized it to full size.  The
1051             // WorkWindow propagates the resize to the DrawViewShell which calls
1052             // resize() at the SlideShow (this).  Calling resize here results in a
1053             // temporary display of a black window in the window's default size
1054
1055 /*
1056             if ( mbRehearseTimings )
1057             {
1058                 Size  aButtonSizePixel( pTimeButton->GetSizePixel() );
1059                 Point aButtonPosPixel( aButtonSizePixel.Width() >> 1, pShowWindow->GetSizePixel().Height() - aButtonSizePixel.Height() * 5 / 2);
1060
1061                 pTimeButton->SetPosPixel( aButtonPosPixel );
1062                 aTimer.SetTimeoutHdl( LINK( this,FuSlideShow, TimeButtonTimeOutHdl ) );
1063                 pTimeButton->SetClickHdl( LINK( this, FuSlideShow, TimeButtonHdl ) );
1064             }
1065 */
1066
1067             if( mpView )
1068             {
1069                 mpView->AddWindowToPaintView( mpShowWindow );
1070                 mpView->SetAnimationPause( TRUE );
1071             }
1072
1073             SfxBindings* pBindings = getBindings();
1074             if( pBindings )
1075             {
1076                 pBindings->Invalidate( SID_PRESENTATION );
1077                 pBindings->Invalidate( SID_REHEARSE_TIMINGS );
1078             }
1079
1080             mpShowWindow->GrabFocus();
1081
1082             std::vector<beans::PropertyValue> aProperties;
1083             aProperties.reserve( 4 );
1084
1085             aProperties.push_back(
1086                 beans::PropertyValue(
1087                     OUString( RTL_CONSTASCII_USTRINGPARAM("AdvanceOnClick") ),
1088                     -1, Any( ! (maPresSettings.mbLockedPages != sal_False) ),
1089                     beans::PropertyState_DIRECT_VALUE ) );
1090
1091             aProperties.push_back(
1092                 beans::PropertyValue(
1093                     OUString( RTL_CONSTASCII_USTRINGPARAM("ImageAnimationsAllowed") ),
1094                     -1, Any( maPresSettings.mbAnimationAllowed != sal_False ),
1095                     beans::PropertyState_DIRECT_VALUE ) );
1096
1097             const sal_Bool bZOrderEnabled(
1098                 SD_MOD()->GetSdOptions( mpDoc->GetDocumentType() )->IsSlideshowRespectZOrder() );
1099             aProperties.push_back(
1100                 beans::PropertyValue(
1101                     OUString( RTL_CONSTASCII_USTRINGPARAM("DisableAnimationZOrder") ),
1102                     -1, Any( bZOrderEnabled == sal_False ),
1103                     beans::PropertyState_DIRECT_VALUE ) );
1104
1105 /*
1106             aProperties.push_back(
1107                 beans::PropertyValue(
1108                     OUString( RTL_CONSTASCII_USTRINGPARAM("MouseVisible") ),
1109                     -1, Any( maPresSettings.mbMouseVisible != sal_False ),
1110                     beans::PropertyState_DIRECT_VALUE ) );
1111 */
1112             aProperties.push_back(
1113                 beans::PropertyValue(
1114                     OUString( RTL_CONSTASCII_USTRINGPARAM("ForceManualAdvance") ),
1115                     -1, Any( maPresSettings.mbManual != sal_False ),
1116                     beans::PropertyState_DIRECT_VALUE ) );
1117
1118             if( maPresSettings.mbMouseAsPen )
1119              {
1120                 aProperties.push_back(
1121                     beans::PropertyValue(
1122                         OUString( RTL_CONSTASCII_USTRINGPARAM("UserPaintColor") ),
1123                         -1, Any( static_cast<sal_Int32>(0x0000FF00L) ),
1124                         beans::PropertyState_DIRECT_VALUE ) );
1125             }
1126
1127             if (mbRehearseTimings) {
1128                 aProperties.push_back(
1129                     beans::PropertyValue(
1130                         OUString( RTL_CONSTASCII_USTRINGPARAM("RehearseTimings") ),
1131                         -1, Any(true), beans::PropertyState_DIRECT_VALUE ) );
1132             }
1133
1134             bRet = startShowImpl( Sequence<beans::PropertyValue>(
1135                                       &aProperties[0], aProperties.size() ) );
1136
1137         }
1138
1139         setActiveXToolbarsVisible( sal_False );
1140     }
1141     catch( Exception& e )
1142     {
1143         (void)e;
1144         DBG_ERROR(
1145             (OString("sd::SlideshowImpl::startShow(), "
1146                      "exception caught: ") +
1147              rtl::OUStringToOString(
1148                  comphelper::anyToString( cppu::getCaughtException() ),
1149                  RTL_TEXTENCODING_UTF8 )).getStr() );
1150         bRet = false;
1151     }
1152
1153     return bRet;
1154 }
1155
1156 bool SlideshowImpl::startShowImpl( const Sequence< beans::PropertyValue >& aProperties )
1157 {
1158     try
1159     {
1160         mxShow = Reference< XSlideShow >( createSlideShow(), UNO_QUERY_THROW );
1161         mxView = mxView.createFromQuery( new SlideShowView(
1162                                              *mpShowWindow,
1163                                              mpDoc,
1164                                              meAnimationMode,
1165                                              this,
1166                                              maPresSettings.mbFullScreen) );
1167
1168         // try add wait symbol to properties:
1169         const Reference<rendering::XSpriteCanvas> xSpriteCanvas(
1170             mxView->getCanvas() );
1171         if (xSpriteCanvas.is())
1172         {
1173             BitmapEx waitSymbolBitmap( SdResId(BMP_WAIT_ICON) );
1174             const Reference<rendering::XBitmap> xBitmap(
1175                 vcl::unotools::xBitmapFromBitmapEx(
1176                     xSpriteCanvas->getDevice(), waitSymbolBitmap ) );
1177             if (xBitmap.is())
1178             {
1179                 mxShow->setProperty(
1180                     beans::PropertyValue(
1181                         OUString( RTL_CONSTASCII_USTRINGPARAM("WaitSymbolBitmap") ),
1182                         -1,
1183                         makeAny( xBitmap ),
1184                         beans::PropertyState_DIRECT_VALUE ) );
1185             }
1186         }
1187
1188         const sal_Int32 nCount = aProperties.getLength();
1189         sal_Int32 nIndex;
1190         for( nIndex = 0; nIndex < nCount; nIndex++ )
1191             mxShow->setProperty( aProperties[nIndex] );
1192
1193         mxShow->addView( mxView.getRef() );
1194
1195         mxListenerProxy.set( new SlideShowListenerProxy( this, mxShow ) );
1196         mxListenerProxy->addAsSlideShowListener();
1197
1198
1199         NotifyDocumentEvent( mpDoc, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("OnStartPresentation") ) );
1200         displaySlideIndex( mpSlideController->getStartSlideIndex() );
1201
1202         return true;
1203     }
1204     catch( Exception& e )
1205     {
1206         (void)e;
1207         DBG_ERROR(
1208             (OString("sd::SlideshowImpl::startShowImpl(), "
1209                      "exception caught: ") +
1210              rtl::OUStringToOString(
1211                  comphelper::anyToString( cppu::getCaughtException() ),
1212                  RTL_TEXTENCODING_UTF8 )).getStr() );
1213         return false;
1214     }
1215 }
1216
1217 /** called only by the slideshow view when the first paint event occurs.
1218     This actually starts the slideshow. */
1219 void SlideshowImpl::onFirstPaint()
1220 {
1221     if( mpShowWindow )
1222     {
1223         mpShowWindow->SetBackground( Wallpaper( Color( COL_BLACK ) ) );
1224         mpShowWindow->Erase();
1225         mpShowWindow->SetBackground();
1226     }
1227
1228     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1229     maUpdateTimer.SetTimeout( (ULONG)100 );
1230     maUpdateTimer.Start();
1231 }
1232
1233 void SlideshowImpl::paint( const Rectangle& /* rRect */ )
1234 {
1235     if( mxView.is() ) try
1236     {
1237         awt::PaintEvent aEvt;
1238         // aEvt.UpdateRect = TODO
1239         mxView->paint( aEvt );
1240     }
1241     catch( Exception& e )
1242     {
1243         static_cast<void>(e);
1244         DBG_ERROR(
1245             (OString("sd::SlideshowImpl::paint(), "
1246                     "exception caught: ") +
1247             rtl::OUStringToOString(
1248                 comphelper::anyToString( cppu::getCaughtException() ),
1249                 RTL_TEXTENCODING_UTF8 )).getStr() );
1250     }
1251 }
1252
1253 // --------------------------------------------------------------------
1254
1255 void SAL_CALL SlideshowImpl::addSlideShowListener( const Reference< XSlideShowListener >& xListener ) throw (RuntimeException)
1256 {
1257     if( mxListenerProxy.is() )
1258         mxListenerProxy->addSlideShowListener( xListener );
1259 }
1260
1261 // --------------------------------------------------------------------
1262
1263 void SAL_CALL SlideshowImpl::removeSlideShowListener( const Reference< XSlideShowListener >& xListener ) throw (RuntimeException)
1264 {
1265     if( mxListenerProxy.is() )
1266         mxListenerProxy->removeSlideShowListener( xListener );
1267 }
1268
1269 // ---------------------------------------------------------
1270
1271 void SlideshowImpl::slideEnded(const bool bReverse)
1272 {
1273     if (bReverse)
1274         gotoPreviousSlide(true);
1275     else
1276         gotoNextSlide();
1277 }
1278
1279 // ---------------------------------------------------------
1280
1281 void SlideshowImpl::removeShapeEvents()
1282 {
1283     if( mxShow.is() && mxListenerProxy.is() ) try
1284     {
1285         WrappedShapeEventImplMap::iterator aIter;
1286         const WrappedShapeEventImplMap::iterator aEnd( maShapeEventMap.end() );
1287
1288         for( aIter = maShapeEventMap.begin(); aIter != aEnd; aIter++ )
1289         {
1290             mxListenerProxy->removeShapeEventListener( (*aIter).first );
1291             mxShow->setShapeCursor( (*aIter).first, awt::SystemPointer::ARROW );
1292         }
1293
1294         maShapeEventMap.clear();
1295     }
1296     catch( Exception& e )
1297     {
1298         (void)e;
1299         DBG_ERROR(
1300             (OString("sd::SlideshowImpl::removeShapeEvents(), "
1301                      "exception caught: ") +
1302              rtl::OUStringToOString(
1303                  comphelper::anyToString( cppu::getCaughtException() ),
1304                  RTL_TEXTENCODING_UTF8 )).getStr() );
1305     }
1306 }
1307
1308 // ---------------------------------------------------------
1309
1310 void SlideshowImpl::registerShapeEvents(sal_Int32 nSlideNumber)
1311 {
1312     if( nSlideNumber >= 0 ) try
1313     {
1314         Reference< XDrawPagesSupplier > xDrawPages( mxModel, UNO_QUERY_THROW );
1315         Reference< XIndexAccess > xPages( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
1316
1317         Reference< XShapes > xDrawPage;
1318         xPages->getByIndex(nSlideNumber) >>= xDrawPage;
1319
1320         if( xDrawPage.is() )
1321         {
1322             Reference< XMasterPageTarget > xMasterPageTarget( xDrawPage, UNO_QUERY );
1323             if( xMasterPageTarget.is() )
1324             {
1325                 Reference< XShapes > xMasterPage( xMasterPageTarget->getMasterPage(), UNO_QUERY );
1326                 if( xMasterPage.is() )
1327                     registerShapeEvents( xMasterPage );
1328             }
1329             registerShapeEvents( xDrawPage );
1330         }
1331     }
1332     catch( Exception& e )
1333     {
1334         (void)e;
1335         DBG_ERROR(
1336             (OString("sd::SlideshowImpl::registerShapeEvents(), "
1337                      "exception caught: ") +
1338              rtl::OUStringToOString(
1339                  comphelper::anyToString( cppu::getCaughtException() ),
1340                  RTL_TEXTENCODING_UTF8 )).getStr() );
1341     }
1342 }
1343
1344 // ---------------------------------------------------------
1345
1346 void SlideshowImpl::registerShapeEvents( Reference< XShapes >& xShapes ) throw( Exception )
1347 {
1348     try
1349     {
1350         const sal_Int32 nShapeCount = xShapes->getCount();
1351         sal_Int32 nShape;
1352         for( nShape = 0; nShape < nShapeCount; nShape++ )
1353         {
1354             Reference< XShape > xShape;
1355             xShapes->getByIndex( nShape ) >>= xShape;
1356
1357             if( xShape.is() &&
1358                 xShape->getShapeType().equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.GroupShape") ) )
1359             {
1360                 Reference< XShapes > xSubShapes( xShape, UNO_QUERY );
1361                 if( xSubShapes.is() )
1362                     registerShapeEvents( xSubShapes );
1363             }
1364
1365             Reference< XPropertySet > xSet( xShape, UNO_QUERY );
1366             if( !xSet.is() )
1367                 continue;
1368
1369             Reference< XPropertySetInfo > xSetInfo( xSet->getPropertySetInfo() );
1370             if( !xSetInfo.is() || !xSetInfo->hasPropertyByName( msOnClick ) )
1371                 continue;
1372
1373             WrappedShapeEventImplPtr pEvent( new WrappedShapeEventImpl );
1374             xSet->getPropertyValue( msOnClick ) >>= pEvent->meClickAction;
1375
1376             switch( pEvent->meClickAction )
1377             {
1378             case ClickAction_PREVPAGE:
1379             case ClickAction_NEXTPAGE:
1380             case ClickAction_FIRSTPAGE:
1381             case ClickAction_LASTPAGE:
1382             case ClickAction_STOPPRESENTATION:
1383                 break;
1384             case ClickAction_BOOKMARK:
1385                 if( xSetInfo->hasPropertyByName( msBookmark ) )
1386                     xSet->getPropertyValue( msBookmark ) >>= pEvent->maStrBookmark;
1387                 if( getSlideNumberForBookmark( pEvent->maStrBookmark ) == -1 )
1388                     continue;
1389                 break;
1390             case ClickAction_DOCUMENT:
1391             case ClickAction_SOUND:
1392             case ClickAction_PROGRAM:
1393             case ClickAction_MACRO:
1394                 if( xSetInfo->hasPropertyByName( msBookmark ) )
1395                     xSet->getPropertyValue( msBookmark ) >>= pEvent->maStrBookmark;
1396                 break;
1397             case ClickAction_VERB:
1398                 if( xSetInfo->hasPropertyByName( msVerb ) )
1399                     xSet->getPropertyValue( msVerb ) >>= pEvent->mnVerb;
1400                 break;
1401             default:
1402                 continue; // skip all others
1403             }
1404
1405             maShapeEventMap[ xShape ] = pEvent;
1406
1407             if( mxListenerProxy.is() )
1408                 mxListenerProxy->addShapeEventListener( xShape );
1409             mxShow->setShapeCursor( xShape, awt::SystemPointer::REFHAND );
1410         }
1411     }
1412     catch( Exception& e )
1413     {
1414         static_cast<void>(e);
1415         DBG_ERROR(
1416             (OString("sd::SlideshowImpl::registerShapeEvents(), "
1417                     "exception caught: ") +
1418             rtl::OUStringToOString(
1419                 comphelper::anyToString( cppu::getCaughtException() ),
1420                 RTL_TEXTENCODING_UTF8 )).getStr() );
1421     }
1422 }
1423
1424 // ---------------------------------------------------------
1425
1426 void SlideshowImpl::displayCurrentSlide (const bool bSkipAllMainSequenceEffects)
1427 {
1428     stopSound();
1429     removeShapeEvents();
1430
1431     if( mpSlideController.get() && mxShow.is() )
1432     {
1433                 mpSlideController->displayCurrentSlide( mxShow, bSkipAllMainSequenceEffects );
1434         registerShapeEvents(mpSlideController->getCurrentSlideNumber());
1435         update();
1436
1437         SfxBindings* pBindings = getBindings();
1438         if( pBindings )
1439         {
1440             pBindings->Invalidate( SID_NAVIGATOR_STATE );
1441             pBindings->Invalidate( SID_NAVIGATOR_PAGENAME );
1442         }
1443     }
1444 }
1445
1446 // ---------------------------------------------------------
1447
1448 void SlideshowImpl::endPresentation()
1449 {
1450     if( !mnEndShowEvent )
1451         mnEndShowEvent = Application::PostUserEvent( LINK(this, SlideshowImpl, endPresentationHdl) );
1452 }
1453
1454 // ---------------------------------------------------------
1455
1456 IMPL_LINK( SlideshowImpl, endPresentationHdl, void*, EMPTYARG )
1457 {
1458     mnEndShowEvent = 0;
1459
1460     if( mxPresentation.is() )
1461         mxPresentation->end();
1462     return 0;
1463 }
1464
1465 // ---------------------------------------------------------
1466
1467 void SAL_CALL SlideshowImpl::pause() throw (RuntimeException)
1468 {
1469     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1470
1471     if( !mbIsPaused ) try
1472     {
1473         mbIsPaused = sal_True;
1474         if( mxShow.is() )
1475         {
1476             mxShow->pause(sal_True);
1477
1478             if( mxListenerProxy.is() )
1479                 mxListenerProxy->paused();
1480         }
1481     }
1482     catch( Exception& e )
1483     {
1484         static_cast<void>(e);
1485         DBG_ERROR(
1486             (OString("sd::SlideshowImpl::pause(), "
1487                     "exception caught: ") +
1488             rtl::OUStringToOString(
1489                 comphelper::anyToString( cppu::getCaughtException() ),
1490                 RTL_TEXTENCODING_UTF8 )).getStr() );
1491     }
1492 }
1493
1494 // ---------------------------------------------------------
1495
1496 void SAL_CALL SlideshowImpl::resume() throw (RuntimeException)
1497 {
1498     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1499
1500     if( mbIsPaused ) try
1501     {
1502         if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
1503         {
1504             mpShowWindow->RestartShow();
1505         }
1506         else
1507         {
1508             mbIsPaused = sal_False;;
1509             if( mxShow.is() )
1510             {
1511                 mxShow->pause(sal_False);
1512                 update();
1513
1514                 if( mxListenerProxy.is() )
1515                     mxListenerProxy->resumed();
1516             }
1517         }
1518     }
1519     catch( Exception& e )
1520     {
1521         static_cast<void>(e);
1522         DBG_ERROR(
1523             (OString("sd::SlideshowImpl::resume(), "
1524                     "exception caught: ") +
1525             rtl::OUStringToOString(
1526                 comphelper::anyToString( cppu::getCaughtException() ),
1527                 RTL_TEXTENCODING_UTF8 )).getStr() );
1528     }
1529 }
1530
1531 // ---------------------------------------------------------
1532
1533 sal_Bool SAL_CALL SlideshowImpl::isPaused() throw (RuntimeException)
1534 {
1535     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1536     return mbIsPaused;
1537 }
1538
1539 // ---------------------------------------------------------
1540
1541 void SAL_CALL SlideshowImpl::blankScreen( sal_Int32 nColor ) throw (RuntimeException)
1542 {
1543     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1544
1545     if( mpShowWindow && mpSlideController )
1546     {
1547         if( mpShowWindow->SetBlankMode( mpSlideController->getCurrentSlideIndex(), nColor ) )
1548         {
1549             pause();
1550         }
1551     }
1552 }
1553
1554 // ---------------------------------------------------------
1555 // XShapeEventListener
1556 // ---------------------------------------------------------
1557
1558 void SlideshowImpl::click( const Reference< XShape >& xShape, const ::com::sun::star::awt::MouseEvent& /* aOriginalEvent */ )
1559 {
1560     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1561
1562     WrappedShapeEventImplPtr pEvent = maShapeEventMap[xShape];
1563     if( !pEvent.get() )
1564         return;
1565
1566     switch( pEvent->meClickAction )
1567     {
1568     case ClickAction_PREVPAGE:                  gotoPreviousSlide();            break;
1569     case ClickAction_NEXTPAGE:                  gotoNextSlide();                        break;
1570     case ClickAction_FIRSTPAGE:                 gotoFirstSlide();                       break;
1571     case ClickAction_LASTPAGE:                  gotoLastSlide();                        break;
1572     case ClickAction_STOPPRESENTATION:  endPresentation();                      break;
1573     case ClickAction_BOOKMARK:
1574     {
1575         gotoBookmark( pEvent->maStrBookmark );
1576     }
1577     break;
1578     case ClickAction_SOUND:
1579     {
1580         try
1581         {
1582             mxPlayer.set(avmedia::MediaWindow::createPlayer(pEvent->maStrBookmark), uno::UNO_QUERY_THROW );
1583             mxPlayer->start();
1584         }
1585         catch( uno::Exception& e )
1586         {
1587             (void)e;
1588             DBG_ERROR("sd::SlideshowImpl::click(), exception caught!" );
1589         }
1590     }
1591     break;
1592
1593     case ClickAction_DOCUMENT:
1594     {
1595         OUString aBookmark( pEvent->maStrBookmark );
1596
1597         sal_Int32 nPos = aBookmark.indexOf( sal_Unicode('#') );
1598         if( nPos >= 0 )
1599         {
1600             OUString aURL( aBookmark.copy( 0, nPos+1 ) );
1601             OUString aName( aBookmark.copy( nPos+1 ) );
1602             aURL += getUiNameFromPageApiNameImpl( aName );
1603             aBookmark = aURL;
1604         }
1605
1606         mpDocSh->OpenBookmark( aBookmark );
1607     }
1608     break;
1609
1610     case ClickAction_PROGRAM:
1611     {
1612         INetURLObject aURL(
1613             ::URIHelper::SmartRel2Abs(
1614                 INetURLObject(mpDocSh->GetMedium()->GetBaseURL()),
1615                 pEvent->maStrBookmark, ::URIHelper::GetMaybeFileHdl(), true,
1616                 false, INetURLObject::WAS_ENCODED,
1617                 INetURLObject::DECODE_UNAMBIGUOUS ) );
1618
1619         if( INET_PROT_FILE == aURL.GetProtocol() )
1620         {
1621             SfxStringItem aUrl( SID_FILE_NAME, aURL.GetMainURL( INetURLObject::NO_DECODE ) );
1622             SfxBoolItem aBrowsing( SID_BROWSE, TRUE );
1623
1624             SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1625             if (pViewFrm)
1626                 pViewFrm->GetDispatcher()->Execute( SID_OPENDOC,
1627                                               SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
1628                                             &aUrl,
1629                                             &aBrowsing,
1630                                             0L );
1631         }
1632     }
1633     break;
1634
1635     case presentation::ClickAction_MACRO:
1636     {
1637         const String aMacro( pEvent->maStrBookmark );
1638
1639         if ( SfxApplication::IsXScriptURL( aMacro ) )
1640         {
1641             Any aRet;
1642             Sequence< sal_Int16 > aOutArgsIndex;
1643             Sequence< Any > aOutArgs;
1644             Sequence< Any >* pInArgs = new Sequence< Any >(0);
1645             mpDocSh->CallXScript( aMacro, *pInArgs, aRet, aOutArgsIndex, aOutArgs);
1646         }
1647         else
1648         {
1649             // aMacro has the following syntax:
1650             // "Macroname.Modulname.Libname.Dokumentname" or
1651             // "Macroname.Modulname.Libname.Applikationsname"
1652             String aMacroName = aMacro.GetToken(0, sal_Unicode('.'));
1653             String aModulName = aMacro.GetToken(1, sal_Unicode('.'));
1654             String aLibName   = aMacro.GetToken(2, sal_Unicode('.'));
1655             String aDocName   = aMacro.GetToken(3, sal_Unicode('.'));
1656
1657             // todo: is the limitation still given that only
1658             // Modulname+Macroname can be used here?
1659             String aExecMacro(aModulName);
1660             aExecMacro.Append( sal_Unicode('.') );
1661             aExecMacro.Append( aMacroName );
1662             mpDocSh->GetBasic()->Call(aExecMacro);
1663         }
1664     }
1665     break;
1666
1667     case ClickAction_VERB:
1668     {
1669         // todo, better do it async?
1670         SdrObject* pObj = GetSdrObjectFromXShape( xShape );
1671         SdrOle2Obj* pOleObject = PTR_CAST(SdrOle2Obj, pObj);
1672         if (pOleObject && mpViewShell )
1673             mpViewShell->ActivateObject(pOleObject, pEvent->mnVerb);
1674     }
1675     break;
1676     default:
1677         break;
1678     }
1679 }
1680
1681 // ---------------------------------------------------------
1682
1683 sal_Int32 SlideshowImpl::getSlideNumberForBookmark( const OUString& rStrBookmark )
1684 {
1685     BOOL bIsMasterPage;
1686     OUString aBookmark = getUiNameFromPageApiNameImpl( rStrBookmark );
1687     USHORT nPgNum = mpDoc->GetPageByName( aBookmark, bIsMasterPage );
1688
1689     if( nPgNum == SDRPAGE_NOTFOUND )
1690     {
1691         // Ist das Bookmark ein Objekt?
1692         SdrObject* pObj = mpDoc->GetObj( aBookmark );
1693
1694         if( pObj )
1695         {
1696             nPgNum = pObj->GetPage()->GetPageNum();
1697             bIsMasterPage = (BOOL)pObj->GetPage()->IsMasterPage();
1698         }
1699     }
1700
1701     if( (nPgNum == SDRPAGE_NOTFOUND) || bIsMasterPage || static_cast<SdPage*>(mpDoc->GetPage(nPgNum))->GetPageKind() != PK_STANDARD )
1702         return -1;
1703
1704     return ( nPgNum - 1) >> 1;
1705 }
1706
1707 // ---------------------------------------------------------
1708
1709 void SlideshowImpl::hyperLinkClicked( rtl::OUString const& aHyperLink ) throw (RuntimeException)
1710 {
1711     OUString aBookmark( aHyperLink );
1712
1713     sal_Int32 nPos = aBookmark.indexOf( sal_Unicode('#') );
1714     if( nPos >= 0 )
1715     {
1716         OUString aURL( aBookmark.copy( 0, nPos+1 ) );
1717         OUString aName( aBookmark.copy( nPos+1 ) );
1718         aURL += getUiNameFromPageApiNameImpl( aName );
1719         aBookmark = aURL;
1720     }
1721
1722     mpDocSh->OpenBookmark( aBookmark );
1723 }
1724
1725 // ---------------------------------------------------------
1726
1727 void SlideshowImpl::displaySlideNumber( sal_Int32 nSlideNumber )
1728 {
1729     if( mpSlideController.get() )
1730     {
1731         if( mpSlideController->jumpToSlideNumber( nSlideNumber ) )
1732         {
1733             displayCurrentSlide();
1734         }
1735     }
1736 }
1737
1738 // ---------------------------------------------------------
1739
1740 /** nSlideIndex == -1 displays current slide again */
1741 void SlideshowImpl::displaySlideIndex( sal_Int32 nSlideIndex )
1742 {
1743     if( mpSlideController.get() )
1744     {
1745         if( (nSlideIndex == -1) || mpSlideController->jumpToSlideIndex( nSlideIndex ) )
1746         {
1747             displayCurrentSlide();
1748         }
1749     }
1750 }
1751
1752 // ---------------------------------------------------------
1753
1754 void SlideshowImpl::jumpToBookmark( const String& sBookmark )
1755 {
1756     sal_Int32 nSlideNumber = getSlideNumberForBookmark( sBookmark );
1757     if( nSlideNumber != -1 )
1758         displaySlideNumber( nSlideNumber );
1759 }
1760
1761 // ---------------------------------------------------------
1762
1763 sal_Int32 SlideshowImpl::getCurrentSlideNumber()
1764 {
1765     return mpSlideController.get() ? mpSlideController->getCurrentSlideNumber() : -1;
1766 }
1767
1768 // ---------------------------------------------------------
1769
1770 sal_Int32 SlideshowImpl::getFirstSlideNumber()
1771 {
1772     sal_Int32 nRet = 0;
1773     if( mpSlideController.get() )
1774     {
1775         sal_Int32 nSlideIndexCount = mpSlideController->getSlideIndexCount() - 1;
1776         if( nSlideIndexCount >= 0 )
1777         {
1778             nRet = mpSlideController->getSlideNumber( nSlideIndexCount );
1779             while( nSlideIndexCount-- )
1780             {
1781                 sal_Int32 nTemp = mpSlideController->getSlideNumber( nSlideIndexCount );
1782                 if( nRet > nTemp )
1783                     nRet = nTemp;
1784             }
1785         }
1786     }
1787
1788     return nRet;
1789 }
1790
1791 // ---------------------------------------------------------
1792
1793 sal_Int32 SlideshowImpl::getLastSlideNumber()
1794 {
1795     sal_Int32 nRet = 0;
1796     if( mpSlideController.get() )
1797     {
1798         sal_Int32 nSlideIndexCount = mpSlideController->getSlideIndexCount() - 1;
1799         if( nSlideIndexCount >= 0 )
1800         {
1801             nRet = mpSlideController->getSlideNumber( nSlideIndexCount );
1802             while( nSlideIndexCount-- )
1803             {
1804                 sal_Int32 nTemp = mpSlideController->getSlideNumber( nSlideIndexCount );
1805                 if( nRet < nTemp )
1806                     nRet = nTemp;
1807             }
1808         }
1809     }
1810
1811     return nRet;
1812 }
1813
1814 // ---------------------------------------------------------
1815
1816 sal_Bool SAL_CALL SlideshowImpl::isEndless() throw( RuntimeException )
1817 {
1818     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1819     return maPresSettings.mbEndless;
1820 }
1821
1822 // ---------------------------------------------------------
1823
1824 double SlideshowImpl::update()
1825 {
1826     startUpdateTimer();
1827     return -1;
1828 }
1829
1830 // ---------------------------------------------------------
1831
1832 void SlideshowImpl::startUpdateTimer()
1833 {
1834     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1835     maUpdateTimer.SetTimeout( 0 );
1836     maUpdateTimer.Start();
1837 }
1838
1839 // ---------------------------------------------------------
1840
1841 /** this timer is called 20ms after a new slide was displayed.
1842     This is used to unfreeze user input that was disabled after
1843     slide change to skip input that was buffered during slide
1844     transition preperation */
1845 IMPL_LINK( SlideshowImpl, ReadyForNextInputHdl, Timer*, EMPTYARG )
1846 {
1847     mbInputFreeze = false;
1848     return 0;
1849 }
1850
1851 // ---------------------------------------------------------
1852
1853 /** if I catch someone someday who calls this method by hand
1854     and not by using the timer, I will personaly punish this
1855     person seriously, even if this person is me.
1856 */
1857 IMPL_LINK( SlideshowImpl, updateHdl, Timer*, EMPTYARG )
1858 {
1859     mnUpdateEvent = 0;
1860
1861     // doing some nMagic
1862     const rtl::Reference<SlideshowImpl> this_(this);
1863
1864     Reference< XSlideShow > xShow( mxShow );
1865     if( xShow.is() ) try
1866     {
1867         // TODO(Q3): Evaluate under various systems and setups,
1868         // whether this is really necessary. Under WinXP and Matrox
1869         // G550, the frame rates were much more steadier with this
1870         // tweak, although.
1871
1872 // currently no solution, because this kills sound (at least on Windows)
1873 //         // Boost our prio, as long as we're in the render loop
1874 //         ::canvas::tools::PriorityBooster aBooster(2);
1875
1876         double fUpdate = 0.0;
1877         if( !xShow->update(fUpdate) )
1878             fUpdate = -1.0;
1879
1880         if( mxShow.is() && ( fUpdate >= 0.0 ) )
1881         {
1882 /*
1883             if( fUpdate < 0.25 )
1884             {
1885                 mnUpdateEvent = Application::PostUserEvent(LINK(this, SlideshowImpl, updateHdl));
1886             }
1887             else
1888 */
1889             {
1890                 // Avoid busy loop when the previous call to update()
1891                 // returns 0.  The minimum value is small enough to allow
1892                 // high frame rates.  Values larger than 0 are typically
1893                 // also larger then the small minimum value and thus are
1894                 // used to determine the frame rate.
1895                 const float MIN_UPDATE = 0.01f; // 10ms corresponds to 100 frames per second.
1896                 if( fUpdate < MIN_UPDATE )
1897                     fUpdate = MIN_UPDATE;
1898                 else
1899                 {
1900                     const float MAX_UPDATE = 4.0f; // do not wait longer than 4 seconds for next refresh, because dilbert said so
1901                     if( fUpdate > MAX_UPDATE )
1902                         fUpdate = MAX_UPDATE;
1903                 }
1904                 maUpdateTimer.SetTimeout(
1905                     ::std::max( 1UL, static_cast<ULONG>(fUpdate * 1000.0) ) );
1906                 maUpdateTimer.Start();
1907             }
1908         }
1909     }
1910     catch( Exception& e )
1911     {
1912         static_cast<void>(e);
1913         DBG_ERROR(
1914             (OString("sd::SlideshowImpl::updateHdl(), "
1915                      "exception caught: ") +
1916              rtl::OUStringToOString(
1917                  comphelper::anyToString( cppu::getCaughtException() ),
1918                  RTL_TEXTENCODING_UTF8 )).getStr() );
1919     }
1920     return 0;
1921 }
1922
1923 // ---------------------------------------------------------
1924
1925 bool SlideshowImpl::keyInput(const KeyEvent& rKEvt)
1926 {
1927     if( !mxShow.is() || mbInputFreeze )
1928         return false;
1929
1930     bool bRet = true;
1931
1932     try
1933     {
1934         const int nKeyCode = rKEvt.GetKeyCode().GetCode();
1935         switch( nKeyCode )
1936         {
1937             case awt::Key::CONTEXTMENU:
1938                 if( !mnContextMenuEvent )
1939                 {
1940                     if( mpShowWindow )
1941                         maPopupMousePos = mpShowWindow->GetPointerState().maPos;
1942                     mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
1943                 }
1944                 break;
1945
1946             // cancel show
1947             case KEY_ESCAPE:
1948             case KEY_SUBTRACT:
1949                 // in case the user cancels the presentation, switch to current slide
1950                 // in edit mode
1951                 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
1952                 {
1953                     if( mpSlideController->getCurrentSlideNumber() != -1 )
1954                         mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
1955                 }
1956                 endPresentation();
1957                 break;
1958
1959             // advance show
1960             case KEY_PAGEDOWN:
1961                 if(rKEvt.GetKeyCode().IsMod2())
1962                 {
1963                     gotoNextSlide();
1964                     break;
1965                 }
1966                 // warning, fall through!
1967             case KEY_SPACE:
1968             case KEY_RIGHT:
1969             case KEY_DOWN:
1970             case KEY_N:
1971                 gotoNextEffect();
1972                 break;
1973
1974             case KEY_RETURN:
1975             {
1976                 if( maCharBuffer.Len() )
1977                 {
1978                     if( mpSlideController.get() )
1979                     {
1980                         if( mpSlideController->jumpToSlideNumber( maCharBuffer.ToInt32() - 1 ) )
1981                             displayCurrentSlide();
1982                     }
1983                     maCharBuffer.Erase();
1984                 }
1985                 else
1986                 {
1987                     gotoNextEffect();
1988                 }
1989             }
1990             break;
1991
1992             // numeric: add to buffer
1993             case KEY_0:
1994             case KEY_1:
1995             case KEY_2:
1996             case KEY_3:
1997             case KEY_4:
1998             case KEY_5:
1999             case KEY_6:
2000             case KEY_7:
2001             case KEY_8:
2002             case KEY_9:
2003                 maCharBuffer.Append( rKEvt.GetCharCode() );
2004                 break;
2005
2006             case KEY_PAGEUP:
2007                                 if(rKEvt.GetKeyCode().IsMod2())
2008                                 {
2009                                         gotoPreviousSlide();
2010                                         break;
2011                                 }
2012                                 // warning, fall through!
2013             case KEY_LEFT:
2014             case KEY_UP:
2015             case KEY_P:
2016             case KEY_BACKSPACE:
2017                                 gotoPreviousEffect();
2018                 break;
2019
2020             case KEY_HOME:
2021                 gotoFirstSlide();
2022                 break;
2023
2024             case KEY_END:
2025                 gotoLastSlide();
2026                 break;
2027
2028             case KEY_B:
2029             case KEY_W:
2030             case KEY_POINT:
2031             case KEY_COMMA:
2032             {
2033                 blankScreen( ((nKeyCode == KEY_W ) || (nKeyCode == KEY_COMMA)) ? 0x00ffffff : 0x00000000 );
2034             }
2035             break;
2036
2037             default:
2038                 bRet = false;
2039             break;
2040         }
2041     }
2042     catch( Exception& e )
2043     {
2044         bRet = false;
2045         static_cast<void>(e);
2046         DBG_ERROR(
2047             (OString("sd::SlideshowImpl::keyInput(), "
2048                     "exception caught: ") +
2049             rtl::OUStringToOString(
2050                 comphelper::anyToString( cppu::getCaughtException() ),
2051                 RTL_TEXTENCODING_UTF8 )).getStr() );
2052     }
2053
2054     return bRet;
2055 }
2056
2057 IMPL_LINK( SlideshowImpl, EventListenerHdl, VclSimpleEvent*, pEvent )
2058 {
2059     if( !mxShow.is() || mbInputFreeze )
2060         return 0;
2061
2062     if( pEvent && (pEvent->GetId() == VCLEVENT_WINDOW_COMMAND) && static_cast<VclWindowEvent*>(pEvent)->GetData() )
2063     {
2064         const CommandEvent& rEvent = *(const CommandEvent*)static_cast<VclWindowEvent*>(pEvent)->GetData();
2065
2066         if( rEvent.GetCommand() == COMMAND_MEDIA )
2067         {
2068             switch( rEvent.GetMediaCommand() )
2069             {
2070 #if defined( QUARTZ )
2071             case MEDIA_COMMAND_MENU:
2072                 if( !mnContextMenuEvent )
2073                 {
2074                 if( mpShowWindow )
2075                     maPopupMousePos = mpShowWindow->GetPointerState().maPos;
2076                 mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
2077                 }
2078                 break;
2079             case MEDIA_COMMAND_VOLUME_DOWN:
2080                 gotoPreviousSlide();
2081                 break;
2082             case MEDIA_COMMAND_VOLUME_UP:
2083                 gotoNextEffect();
2084                 break;
2085 #endif
2086             case MEDIA_COMMAND_NEXTTRACK:
2087                 gotoNextEffect();
2088                 break;
2089             case MEDIA_COMMAND_PAUSE:
2090                 if( !mbIsPaused )
2091                     blankScreen(0);
2092                 break;
2093             case MEDIA_COMMAND_PLAY:
2094                 if( mbIsPaused )
2095                     resume();
2096                 break;
2097
2098             case MEDIA_COMMAND_PLAY_PAUSE:
2099                 if( mbIsPaused )
2100                     resume();
2101                 else
2102                     blankScreen(0);
2103                 break;
2104             case MEDIA_COMMAND_PREVIOUSTRACK:
2105                 gotoPreviousSlide();
2106                 break;
2107             case MEDIA_COMMAND_NEXTTRACK_HOLD:
2108                 gotoLastSlide();
2109                 break;
2110
2111             case MEDIA_COMMAND_REWIND:
2112                 gotoFirstSlide();
2113                 break;
2114             case MEDIA_COMMAND_STOP:
2115                 // in case the user cancels the presentation, switch to current slide
2116                 // in edit mode
2117                 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
2118                 {
2119                     if( mpSlideController->getCurrentSlideNumber() != -1 )
2120                         mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
2121                 }
2122                 endPresentation();
2123                 break;
2124             }
2125         }
2126     }
2127
2128     return 0;
2129 }
2130
2131 // ---------------------------------------------------------
2132
2133 void SlideshowImpl::mouseButtonUp(const MouseEvent& rMEvt)
2134 {
2135     if( rMEvt.IsRight() && !mnContextMenuEvent )
2136     {
2137         maPopupMousePos = rMEvt.GetPosPixel();
2138         mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
2139     }
2140 }
2141
2142 // ---------------------------------------------------------
2143
2144 IMPL_LINK( SlideshowImpl, ContextMenuHdl, void*, EMPTYARG )
2145 {
2146     mnContextMenuEvent = 0;
2147
2148     if( mpSlideController.get() == 0 )
2149         return 0;
2150
2151     mbWasPaused = mbIsPaused;
2152     if( !mbWasPaused )
2153         pause();
2154
2155     PopupMenu* pMenu = new PopupMenu( SdResId( RID_SLIDESHOW_CONTEXTMENU ) );
2156
2157         pMenu->EnableItem( CM_COLOR_PEN, (maPresSettings.mbMouseAsPen));
2158
2159     const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2160     pMenu->EnableItem( CM_NEXT_SLIDE, ( mpSlideController->getNextSlideIndex() != -1 ) );
2161     pMenu->EnableItem( CM_PREV_SLIDE, ( mpSlideController->getPreviousSlideIndex() != -1 ) || (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) );
2162
2163     PopupMenu* pPageMenu = pMenu->GetPopupMenu( CM_GOTO );
2164
2165     SfxViewFrame* pViewFrame = getViewFrame();
2166     if( pViewFrame && pViewFrame->GetFrame() )
2167     {
2168         Reference< ::com::sun::star::frame::XFrame > xFrame( pViewFrame->GetFrame()->GetFrameInterface() );
2169         if( xFrame.is() )
2170         {
2171             pMenu->SetItemImage( CM_NEXT_SLIDE, GetImage( xFrame, OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:10617") ), FALSE, FALSE ) );
2172             pMenu->SetItemImage( CM_PREV_SLIDE, GetImage( xFrame, OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:10618") ), FALSE, FALSE ) );
2173
2174             if( pPageMenu )
2175             {
2176                 pPageMenu->SetItemImage( CM_FIRST_SLIDE, GetImage( xFrame, OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:10616") ), FALSE, FALSE ) );
2177                 pPageMenu->SetItemImage( CM_LAST_SLIDE, GetImage( xFrame, OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:10619") ), FALSE, FALSE ) );
2178             }
2179         }
2180     }
2181
2182     // populate slide goto list
2183     if( pPageMenu )
2184     {
2185         const sal_Int32 nPageNumberCount = mpSlideController->getSlideNumberCount();
2186         if( nPageNumberCount <= 1 )
2187         {
2188             pMenu->EnableItem( CM_GOTO, FALSE );
2189         }
2190         else
2191         {
2192             sal_Int32 nCurrentSlideNumber = mpSlideController->getCurrentSlideNumber();
2193             if( (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2194                 nCurrentSlideNumber = -1;
2195
2196             pPageMenu->EnableItem( CM_FIRST_SLIDE, ( mpSlideController->getSlideNumber(0) != nCurrentSlideNumber ) );
2197             pPageMenu->EnableItem( CM_LAST_SLIDE, ( mpSlideController->getSlideNumber( mpSlideController->getSlideIndexCount() - 1) != nCurrentSlideNumber ) );
2198
2199             sal_Int32 nPageNumber;
2200
2201             for( nPageNumber = 0; nPageNumber < nPageNumberCount; nPageNumber++ )
2202             {
2203                 if( mpSlideController->isVisibleSlideNumber( nPageNumber ) )
2204                 {
2205                     SdPage* pPage = mpDoc->GetSdPage((USHORT)nPageNumber, PK_STANDARD);
2206                     if (pPage)
2207                     {
2208                         pPageMenu->InsertItem( (USHORT)(CM_SLIDES + nPageNumber), pPage->GetName() );
2209                         if( nPageNumber == nCurrentSlideNumber )
2210                             pPageMenu->CheckItem( (USHORT)(CM_SLIDES + nPageNumber) );
2211                     }
2212                 }
2213             }
2214         }
2215     }
2216
2217     if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
2218     {
2219         PopupMenu* pBlankMenu = pMenu->GetPopupMenu( CM_SCREEN );
2220         if( pBlankMenu )
2221         {
2222             pBlankMenu->CheckItem( ( mpShowWindow->GetBlankColor() == Color( COL_WHITE ) ) ? CM_SCREEN_WHITE : CM_SCREEN_BLACK  );
2223         }
2224     }
2225
2226
2227         PopupMenu* pWidthMenu = pMenu->GetPopupMenu( CM_WIDTH_PEN);
2228
2229         // populate color width list
2230         if( pWidthMenu )
2231         {
2232                 if(! maPresSettings.mbMouseAsPen)
2233                 {
2234                         pMenu->EnableItem( CM_WIDTH_PEN, FALSE );
2235                 }
2236                 else
2237                 {
2238                         sal_Int32 nIterator;
2239                         double nWidth;
2240
2241
2242
2243                         nWidth = 4.0;
2244                         for( nIterator = 1; nIterator < 6; nIterator++)
2245                         {
2246                                 switch(nIterator)
2247                                 {
2248                                         case 1:
2249                                                 nWidth = 4.0;
2250                                                 break;
2251                                         case 2:
2252                                                 nWidth = 100.0;
2253                                                 break;
2254                                         case 3:
2255                                                 nWidth = 150.0;
2256                                                 break;
2257                                         case 4:
2258                                                 nWidth = 200.0;
2259                                                 break;
2260                                         case 5:
2261                                                 nWidth = 400.0;
2262                                                 break;
2263                                         default:
2264                                                 break;
2265                                 }
2266
2267                                 pWidthMenu->EnableItem( (USHORT)(CM_WIDTH_PEN + nIterator), TRUE);
2268                                                 if( nWidth ==  mdUserPaintStrokeWidth)
2269                                                         pWidthMenu->CheckItem( (USHORT)(CM_WIDTH_PEN + nIterator) );
2270
2271                         }
2272                 }
2273         }
2274
2275     pMenu->SetSelectHdl( LINK( this, SlideshowImpl, ContextMenuSelectHdl ) );
2276     pMenu->Execute( mpShowWindow, maPopupMousePos );
2277     delete pMenu;
2278
2279     if( mxView.is() )
2280         mxView->ignoreNextMouseReleased();
2281
2282     if( !mbWasPaused )
2283         resume();
2284     return 0;
2285 }
2286
2287 // ---------------------------------------------------------
2288
2289 IMPL_LINK( SlideshowImpl, ContextMenuSelectHdl, Menu *, pMenu )
2290 {
2291     if( pMenu )
2292     {
2293         sal_uInt16 nMenuId = pMenu->GetCurItemId();
2294
2295         switch( nMenuId )
2296         {
2297         case CM_PREV_SLIDE:
2298             gotoPreviousSlide();
2299             mbWasPaused = false;
2300             break;
2301         case CM_NEXT_SLIDE:
2302             gotoNextSlide();
2303             mbWasPaused = false;
2304             break;
2305         case CM_FIRST_SLIDE:
2306             gotoFirstSlide();
2307             mbWasPaused = false;
2308             break;
2309         case CM_LAST_SLIDE:
2310             gotoLastSlide();
2311             mbWasPaused = false;
2312             break;
2313         case CM_SCREEN_BLACK:
2314         case CM_SCREEN_WHITE:
2315         {
2316             const Color aBlankColor( (nMenuId == CM_SCREEN_WHITE) ? COL_WHITE : COL_BLACK );
2317             if( mbWasPaused )
2318             {
2319                 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
2320                 {
2321                     if( mpShowWindow->GetBlankColor() == aBlankColor )
2322                     {
2323                         mbWasPaused = false;
2324                         mpShowWindow->RestartShow();
2325                         break;
2326                     }
2327                 }
2328                 mpShowWindow->RestartShow();
2329             }
2330             if( mpShowWindow->SetBlankMode( mpSlideController->getCurrentSlideIndex(), aBlankColor ) )
2331             {
2332                 pause();
2333                 mbWasPaused = true;
2334             }
2335         }
2336         break;
2337
2338                 case CM_COLOR_PEN:
2339                          if( maPresSettings.mbMouseAsPen ){
2340
2341                                 //Open a color picker based on SvColorDialog
2342                                 ::Color aColor( mnUserPaintColor );
2343                                 SvColorDialog aColorDlg( mpShowWindow);
2344                                 aColorDlg.SetColor( aColor );
2345
2346                                 if (aColorDlg.Execute() )
2347                                 {
2348                                         aColor = aColorDlg.GetColor();
2349                                         mnUserPaintColor = aColor.GetColor();
2350                                         setPenColor(mnUserPaintColor);
2351                                 }
2352                                 mbWasPaused = false;
2353                         }
2354                         break;
2355
2356                 case CM_WIDTH_PEN_VERY_THIN:
2357                          if( maPresSettings.mbMouseAsPen ){
2358                                 setPenWidth(4.0);
2359                                 mbWasPaused = false;
2360                         }
2361                         break;
2362
2363                 case CM_WIDTH_PEN_THIN:
2364                          if( maPresSettings.mbMouseAsPen ){
2365                                 setPenWidth(100.0);
2366                                 mbWasPaused = false;
2367                         }
2368                         break;
2369
2370                 case CM_WIDTH_PEN_NORMAL:
2371                          if( maPresSettings.mbMouseAsPen ){
2372                                 setPenWidth(150.0);
2373                                 mbWasPaused = false;
2374                         }
2375                         break;
2376
2377                 case CM_WIDTH_PEN_THICK:
2378                          if( maPresSettings.mbMouseAsPen ){
2379                                 setPenWidth(200.0);
2380                                 mbWasPaused = false;
2381                         }
2382                         break;
2383
2384                 case CM_WIDTH_PEN_VERY_THICK:
2385                          if( maPresSettings.mbMouseAsPen ){
2386                                 setPenWidth(400.0);
2387                                 mbWasPaused = false;
2388                         }
2389                         break;
2390
2391         case CM_ENDSHOW:
2392             // in case the user cancels the presentation, switch to current slide
2393             // in edit mode
2394             if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
2395             {
2396                 if( mpSlideController->getCurrentSlideNumber() != -1 )
2397                 {
2398                     mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
2399                 }
2400             }
2401             endPresentation();
2402             break;
2403         default:
2404             sal_Int32 nPageNumber = nMenuId - CM_SLIDES;
2405             const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2406             if( (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2407             {
2408                 mpShowWindow->RestartShow( nPageNumber );
2409             }
2410             else if( nPageNumber != mpSlideController->getCurrentSlideNumber() )
2411             {
2412                 displaySlideNumber( nPageNumber );
2413             }
2414             mbWasPaused = false;
2415             break;
2416         }
2417     }
2418
2419     return 0;
2420 }
2421
2422 // ---------------------------------------------------------
2423
2424 Reference< XSlideShow > SlideshowImpl::createSlideShow() const
2425 {
2426     Reference< XSlideShow > xShow;
2427
2428     try
2429     {
2430         Reference< lang::XMultiServiceFactory > xFactory(
2431             ::comphelper::getProcessServiceFactory(),
2432             UNO_QUERY_THROW );
2433
2434         Reference< XInterface > xInt( xFactory->createInstance(
2435                 OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.SlideShow")) ) );
2436
2437         xShow.set( xInt, UNO_QUERY_THROW );
2438     }
2439     catch( uno::Exception& e )
2440     {
2441         (void)e;
2442         DBG_ERROR(
2443             (OString("sd::SlideshowImpl::createSlideShow(), "
2444                      "exception caught: ") +
2445              rtl::OUStringToOString(
2446                  comphelper::anyToString( cppu::getCaughtException() ),
2447                  RTL_TEXTENCODING_UTF8 )).getStr() );
2448     }
2449
2450     return xShow;
2451 }
2452
2453 // ---------------------------------------------------------
2454
2455 void SlideshowImpl::createSlideList( bool bAll, bool bStartWithActualSlide, const String& rPresSlide )
2456 {
2457     const long nSlideCount = mpDoc->GetSdPageCount( PK_STANDARD );
2458
2459     if( nSlideCount )
2460     {
2461         SdCustomShow*   pCustomShow;
2462
2463         if( !bStartWithActualSlide && mpDoc->GetCustomShowList() && maPresSettings.mbCustomShow )
2464             pCustomShow = (SdCustomShow*) mpDoc->GetCustomShowList()->GetCurObject();
2465         else
2466             pCustomShow = NULL;
2467
2468         // create animation slide controller
2469         AnimationSlideController::Mode eMode =
2470             ( pCustomShow && pCustomShow->Count() ) ? AnimationSlideController::CUSTOM :
2471                 (bAll ? AnimationSlideController::ALL : AnimationSlideController::FROM);
2472
2473         Reference< XDrawPagesSupplier > xDrawPages( mpDoc->getUnoModel(), UNO_QUERY_THROW );
2474         Reference< XIndexAccess > xSlides( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
2475         mpSlideController.reset( new AnimationSlideController( xSlides, eMode ) );
2476
2477         if( eMode != AnimationSlideController::CUSTOM )
2478         {
2479             sal_Int32 nFirstSlide = 0;
2480
2481             // normale Praesentation
2482             if( eMode == AnimationSlideController::FROM )
2483             {
2484                 if( rPresSlide.Len() )
2485                 {
2486                     sal_Int32 nSlide;
2487                     BOOL bTakeNextAvailable = FALSE;
2488
2489                     for( nSlide = 0, nFirstSlide = -1; ( nSlide < nSlideCount ) && ( -1 == nFirstSlide ); nSlide++ )
2490                     {
2491                         SdPage* pTestSlide = mpDoc->GetSdPage( (USHORT)nSlide, PK_STANDARD );
2492
2493                         if( pTestSlide->GetName() == rPresSlide )
2494                         {
2495                             if( pTestSlide->IsExcluded() )
2496                                 bTakeNextAvailable = TRUE;
2497                             else
2498                                 nFirstSlide = nSlide;
2499                         }
2500                         else if( bTakeNextAvailable && !pTestSlide->IsExcluded() )
2501                             nFirstSlide = nSlide;
2502                     }
2503
2504                     if( -1 == nFirstSlide )
2505                         nFirstSlide = 0;
2506                 }
2507             }
2508
2509             for( sal_Int32 i = 0; i < nSlideCount; i++ )
2510             {
2511                 bool bVisible = ( mpDoc->GetSdPage( (USHORT)i, PK_STANDARD ) )->IsExcluded() ? false : true;
2512                 if( bVisible || (eMode == AnimationSlideController::ALL) )
2513                     mpSlideController->insertSlideNumber( i, bVisible );
2514             }
2515
2516             mpSlideController->setStartSlideNumber( nFirstSlide );
2517         }
2518         else
2519         {
2520             if( meAnimationMode != ANIMATIONMODE_SHOW && rPresSlide.Len() )
2521             {
2522                 sal_Int32 nSlide;
2523                 for( nSlide = 0; nSlide < nSlideCount; nSlide++ )
2524                     if( rPresSlide == mpDoc->GetSdPage( (USHORT) nSlide, PK_STANDARD )->GetName() )
2525                         break;
2526
2527                 if( nSlide < nSlideCount )
2528                     mpSlideController->insertSlideNumber( (USHORT) nSlide );
2529             }
2530
2531             void* pCustomSlide;
2532             sal_Int32 nSlideIndex;
2533             for( pCustomSlide = pCustomShow->First(),nSlideIndex=0; pCustomSlide; pCustomSlide = pCustomShow->Next(), nSlideIndex++ )
2534             {
2535                 const USHORT nSdSlide = ( ( (SdPage*) pCustomSlide )->GetPageNum() - 1 ) / 2;
2536                 mpSlideController->insertSlideNumber( nSdSlide );
2537             }
2538         }
2539     }
2540 }
2541
2542 // ---------------------------------------------------------
2543
2544 typedef USHORT (*FncGetChildWindowId)();
2545
2546 FncGetChildWindowId aShowChilds[] =
2547 {
2548     &AnimationChildWindow::GetChildWindowId,
2549     &Svx3DChildWindow::GetChildWindowId,
2550     &SvxFontWorkChildWindow::GetChildWindowId,
2551     &SvxColorChildWindow::GetChildWindowId,
2552     &SvxSearchDialogWrapper::GetChildWindowId,
2553     &SvxBmpMaskChildWindow::GetChildWindowId,
2554     &SvxIMapDlgChildWindow::GetChildWindowId,
2555     &SvxHyperlinkDlgWrapper::GetChildWindowId,
2556     &SvxHlinkDlgWrapper::GetChildWindowId,
2557     &SfxTemplateDialogWrapper::GetChildWindowId,
2558     &GalleryChildWindow::GetChildWindowId
2559 };
2560
2561 #define NAVIGATOR_CHILD_MASK        0x80000000UL
2562
2563 void SlideshowImpl::hideChildWindows()
2564 {
2565     mnChildMask = 0UL;
2566
2567     if( ANIMATIONMODE_SHOW == meAnimationMode )
2568     {
2569         SfxViewFrame* pViewFrame = getViewFrame();
2570
2571         if( pViewFrame )
2572         {
2573             if( pViewFrame->GetChildWindow( SID_NAVIGATOR ) != NULL )
2574                 mnChildMask |= NAVIGATOR_CHILD_MASK;
2575
2576             for( ULONG i = 0, nCount = sizeof( aShowChilds ) / sizeof( FncGetChildWindowId ); i < nCount; i++ )
2577             {
2578                 const USHORT nId = ( *aShowChilds[ i ] )();
2579
2580                 if( pViewFrame->GetChildWindow( nId ) )
2581                 {
2582                     pViewFrame->SetChildWindow( nId, FALSE );
2583                     mnChildMask |= 1 << i;
2584                 }
2585             }
2586         }
2587     }
2588 }
2589
2590 // ---------------------------------------------------------
2591
2592 void SlideshowImpl::showChildWindows()
2593 {
2594     if( ANIMATIONMODE_SHOW == meAnimationMode )
2595     {
2596         SfxViewFrame* pViewFrame = getViewFrame();
2597         if( pViewFrame )
2598         {
2599             pViewFrame->SetChildWindow( SID_NAVIGATOR, ( mnChildMask & NAVIGATOR_CHILD_MASK ) != 0 );
2600
2601             for( ULONG i = 0, nCount = sizeof( aShowChilds ) / sizeof( FncGetChildWindowId ); i < nCount; i++ )
2602             {
2603                 if( mnChildMask & ( 1 << i ) )
2604                     pViewFrame->SetChildWindow( ( *aShowChilds[ i ] )(), TRUE );
2605             }
2606         }
2607     }
2608 }
2609
2610 // ---------------------------------------------------------
2611
2612 SfxViewFrame* SlideshowImpl::getViewFrame() const
2613 {
2614     return mpViewShell ? mpViewShell->GetViewFrame() : 0;
2615 }
2616
2617 // ---------------------------------------------------------
2618
2619 SfxDispatcher* SlideshowImpl::getDispatcher() const
2620 {
2621     return (mpViewShell && mpViewShell->GetViewFrame()) ? mpViewShell->GetViewFrame()->GetDispatcher() : 0;
2622 }
2623
2624 // ---------------------------------------------------------
2625
2626 SfxBindings* SlideshowImpl::getBindings() const
2627 {
2628     return (mpViewShell && mpViewShell->GetViewFrame()) ? &mpViewShell->GetViewFrame()->GetBindings() : 0;
2629 }
2630
2631 // ---------------------------------------------------------
2632
2633 void SlideshowImpl::resize( const Size& rSize )
2634 {
2635     maPresSize = rSize;
2636
2637     if( mpShowWindow && (ANIMATIONMODE_VIEW != meAnimationMode) )
2638     {
2639         mpShowWindow->SetSizePixel( maPresSize );
2640         mpShowWindow->Show();
2641
2642         // Call ToTop() to bring the window to top if
2643         // a) the old size is not degenerate (then the window will be closed
2644         // soon) and
2645         // b) the animation mode is not that of a preview (on the one hand
2646         // this leaves the old behaviour for the slide show mode unmodified
2647         // and on the other hand does not move the focus from the document
2648         // to the (preview) window; the ToTop() seems not to be necessary at
2649         // least for the preview).
2650 //        if( !aOldSize.Width() && !aOldSize.Height() )
2651 //                      mpShowWindow->ToTop();
2652     }
2653
2654     if( mxView.is() ) try
2655     {
2656         awt::WindowEvent aEvt;
2657         mxView->windowResized(aEvt);
2658     }
2659     catch( Exception& e )
2660     {
2661         static_cast<void>(e);
2662         DBG_ERROR(
2663             (OString("sd::SlideshowImpl::resize(), "
2664                     "exception caught: ") +
2665             rtl::OUStringToOString(
2666                 comphelper::anyToString( cppu::getCaughtException() ),
2667                 RTL_TEXTENCODING_UTF8 )).getStr() );
2668     }
2669 }
2670
2671 // -----------------------------------------------------------------------------
2672
2673 void SlideshowImpl::setActiveXToolbarsVisible( sal_Bool bVisible )
2674 {
2675     // in case of ActiveX control the toolbars should not be visible if slide show runs in window mode
2676     // actually it runs always in window mode in case of ActiveX control
2677     if ( !maPresSettings.mbFullScreen && mpDocSh && mpDocSh->GetMedium() )
2678     {
2679         SFX_ITEMSET_ARG( mpDocSh->GetMedium()->GetItemSet(), pItem, SfxBoolItem, SID_VIEWONLY, sal_False );
2680         if ( pItem && pItem->GetValue() )
2681         {
2682             // this is a plugin/activex mode, no toolbars should be visible during slide show
2683             // after the end of slide show they should be visible again
2684             SfxViewFrame* pViewFrame = getViewFrame();
2685             if( pViewFrame && pViewFrame->GetFrame() && pViewFrame->GetFrame()->GetTopFrame() )
2686             {
2687                 try
2688                 {
2689                     Reference< frame::XLayoutManager > xLayoutManager;
2690                     Reference< beans::XPropertySet > xFrameProps( pViewFrame->GetFrame()->GetTopFrame()->GetFrameInterface(), UNO_QUERY_THROW );
2691                     if ( ( xFrameProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ) ) )
2692                                 >>= xLayoutManager )
2693                       && xLayoutManager.is() )
2694                     {
2695                         xLayoutManager->setVisible( bVisible );
2696                     }
2697                 }
2698                 catch( uno::Exception& )
2699                 {}
2700             }
2701         }
2702     }
2703 }
2704
2705 // -----------------------------------------------------------------------------
2706
2707 void SAL_CALL SlideshowImpl::activate() throw (RuntimeException)
2708 {
2709     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2710
2711     maDeactivateTimer.Stop();
2712
2713     if( !mbActive && mxShow.is() )
2714     {
2715         mbActive = sal_True;
2716
2717         if( ANIMATIONMODE_SHOW == meAnimationMode )
2718         {
2719             if( mbAutoSaveWasOn )
2720                 setAutoSaveState( false );
2721
2722             if( mpShowWindow )
2723             {
2724                 SfxViewFrame* pViewFrame = getViewFrame();
2725                 SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : 0;
2726
2727                 hideChildWindows();
2728
2729                 if( pDispatcher )
2730                 {
2731                     // filter all forbiden slots
2732                     pDispatcher->SetSlotFilter( TRUE, sizeof(pAllowed) / sizeof(USHORT), pAllowed );
2733                 }
2734
2735                 if( getBindings() )
2736                     getBindings()->InvalidateAll(TRUE);
2737
2738                 mpShowWindow->GrabFocus();
2739             }
2740         }
2741
2742         resume();
2743     }
2744 }
2745
2746 // -----------------------------------------------------------------------------
2747
2748 void SAL_CALL SlideshowImpl::deactivate() throw (RuntimeException)
2749 {
2750     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2751
2752     if( mbActive && mxShow.is() )
2753     {
2754         maDeactivateTimer.Start();
2755     }
2756 }
2757
2758 // -----------------------------------------------------------------------------
2759
2760 IMPL_LINK( SlideshowImpl, deactivateHdl, Timer*, EMPTYARG )
2761 {
2762     if( mbActive && mxShow.is() )
2763     {
2764         mbActive = sal_False;
2765
2766         pause();
2767
2768         if( ANIMATIONMODE_SHOW == meAnimationMode )
2769         {
2770             if( mbAutoSaveWasOn )
2771                 setAutoSaveState( true );
2772
2773             if( mpShowWindow )
2774             {
2775                 showChildWindows();
2776             }
2777         }
2778     }
2779     return 0;
2780 }
2781
2782 // ---------------------------------------------------------
2783
2784 sal_Bool SAL_CALL SlideshowImpl::isActive() throw (RuntimeException)
2785 {
2786     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2787     return mbActive;
2788 }
2789
2790 // -----------------------------------------------------------------------------
2791
2792 void SlideshowImpl::receiveRequest(SfxRequest& rReq)
2793 {
2794     const SfxItemSet* pArgs      = rReq.GetArgs();
2795
2796     switch ( rReq.GetSlot() )
2797     {
2798         case SID_NAVIGATOR_PEN:
2799             setUsePen(!maPresSettings.mbMouseAsPen);
2800         break;
2801
2802         case SID_NAVIGATOR_PAGE:
2803         {
2804             PageJump    eJump = (PageJump)((SfxAllEnumItem&) pArgs->Get(SID_NAVIGATOR_PAGE)).GetValue();
2805             switch( eJump )
2806             {
2807                 case PAGE_FIRST:                gotoFirstSlide(); break;
2808                 case PAGE_LAST:                 gotoLastSlide(); break;
2809                 case PAGE_NEXT:                 gotoNextSlide(); break;
2810                 case PAGE_PREVIOUS:             gotoPreviousSlide(); break;
2811                 case PAGE_NONE:                 break;
2812             }
2813         }
2814         break;
2815
2816         case SID_NAVIGATOR_OBJECT:
2817         {
2818             const String aTarget( ((SfxStringItem&) pArgs->Get(SID_NAVIGATOR_OBJECT)).GetValue() );
2819
2820             // is the bookmark a Slide?
2821             BOOL        bIsMasterPage;
2822             USHORT          nPgNum = mpDoc->GetPageByName( aTarget, bIsMasterPage );
2823             SdrObject*  pObj   = NULL;
2824
2825             if( nPgNum == SDRPAGE_NOTFOUND )
2826             {
2827                 // is the bookmark an object?
2828                 pObj = mpDoc->GetObj( aTarget );
2829
2830                 if( pObj )
2831                     nPgNum = pObj->GetPage()->GetPageNum();
2832             }
2833
2834             if( nPgNum != SDRPAGE_NOTFOUND )
2835             {
2836                 nPgNum = ( nPgNum - 1 ) >> 1;
2837                 displaySlideNumber( nPgNum );
2838             }
2839         }
2840         break;
2841     }
2842 }
2843
2844 // ---------------------------------------------------------
2845
2846 void SlideshowImpl::setAutoSaveState( bool bOn)
2847 {
2848     try
2849     {
2850         uno::Reference<lang::XMultiServiceFactory> xFac( ::comphelper::getProcessServiceFactory() );
2851
2852         uno::Reference< util::XURLTransformer > xParser(
2853             xFac->createInstance( OUString::createFromAscii("com.sun.star.util.URLTransformer" ) ),
2854                 uno::UNO_QUERY_THROW);
2855         util::URL aURL;
2856         aURL.Complete = OUString::createFromAscii("vnd.sun.star.autorecovery:/setAutoSaveState");
2857         xParser->parseStrict(aURL);
2858
2859         Sequence< beans::PropertyValue > aArgs(1);
2860         aArgs[0].Name = OUString::createFromAscii("AutoSaveState");
2861         aArgs[0].Value <<= bOn ? sal_True : sal_False;
2862
2863         uno::Reference< frame::XDispatch > xAutoSave(
2864             xFac->createInstance(OUString::createFromAscii("com.sun.star.frame.AutoRecovery")),
2865             uno::UNO_QUERY_THROW);
2866         xAutoSave->dispatch(aURL, aArgs);
2867     }
2868     catch( Exception& )
2869     {
2870         DBG_ERROR("sd::SlideshowImpl::setAutoSaveState(), exception caught!");
2871     }
2872 }
2873
2874 // ---------------------------------------------------------
2875
2876 Reference< XDrawPage > SAL_CALL SlideshowImpl::getCurrentSlide() throw (RuntimeException)
2877 {
2878     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2879
2880     Reference< XDrawPage > xSlide;
2881     if( mxShow.is() && mpSlideController.get() )
2882     {
2883         sal_Int32 nSlide = getCurrentSlideNumber();
2884         if( (nSlide >= 0) && (nSlide < mpSlideController->getSlideNumberCount() ) )
2885             xSlide = mpSlideController->getSlideByNumber( nSlide );
2886     }
2887
2888     return xSlide;
2889 }
2890
2891 // ---------------------------------------------------------
2892
2893 sal_Int32 SAL_CALL SlideshowImpl::getNextSlideIndex() throw (RuntimeException)
2894 {
2895     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2896
2897     if( mxShow.is() )
2898     {
2899         return mpSlideController->getNextSlideIndex();
2900     }
2901     else
2902     {
2903         return -1;
2904     }
2905 }
2906
2907 // ---------------------------------------------------------
2908
2909 sal_Int32 SAL_CALL SlideshowImpl::getCurrentSlideIndex() throw (RuntimeException)
2910 {
2911     return mpSlideController.get() ? mpSlideController->getCurrentSlideIndex() : -1;
2912 }
2913
2914 // --------------------------------------------------------------------
2915 // ::com::sun::star::presentation::XSlideShowController:
2916 // --------------------------------------------------------------------
2917
2918 ::sal_Int32 SAL_CALL SlideshowImpl::getSlideCount() throw (RuntimeException)
2919 {
2920     return mpSlideController.get() ? mpSlideController->getSlideIndexCount() : 0;
2921 }
2922
2923 // --------------------------------------------------------------------
2924
2925 Reference< XDrawPage > SAL_CALL SlideshowImpl::getSlideByIndex(::sal_Int32 Index) throw (RuntimeException, css::lang::IndexOutOfBoundsException)
2926 {
2927     if( (mpSlideController.get() == 0 ) || (Index < 0) || (Index >= mpSlideController->getSlideIndexCount() ) )
2928         throw IndexOutOfBoundsException();
2929
2930     return mpSlideController->getSlideByNumber( mpSlideController->getSlideNumber( Index ) );
2931 }
2932
2933 sal_Bool SAL_CALL SlideshowImpl::getAlwaysOnTop() throw (RuntimeException)
2934 {
2935     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2936     return maPresSettings.mbAlwaysOnTop;
2937 }
2938
2939 // --------------------------------------------------------------------
2940
2941 void SAL_CALL SlideshowImpl::setAlwaysOnTop( sal_Bool bAlways ) throw (RuntimeException)
2942 {
2943     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2944     if( maPresSettings.mbAlwaysOnTop != bAlways )
2945     {
2946         maPresSettings.mbAlwaysOnTop = bAlways;
2947         // todo, can this be changed while running?
2948     }
2949 }
2950
2951 // --------------------------------------------------------------------
2952
2953 sal_Bool SAL_CALL SlideshowImpl::isFullScreen() throw (RuntimeException)
2954 {
2955     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2956     return maPresSettings.mbFullScreen;
2957 }
2958
2959 // --------------------------------------------------------------------
2960
2961 sal_Bool SAL_CALL SlideshowImpl::getMouseVisible() throw (RuntimeException)
2962 {
2963     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2964     return maPresSettings.mbMouseVisible;
2965 }
2966
2967 // --------------------------------------------------------------------
2968
2969 void SAL_CALL SlideshowImpl::setMouseVisible( sal_Bool bVisible ) throw (RuntimeException)
2970 {
2971     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2972     if( maPresSettings.mbMouseVisible != bVisible )
2973     {
2974         maPresSettings.mbMouseVisible = bVisible;
2975         if( mpShowWindow )
2976             mpShowWindow->SetMouseAutoHide( !maPresSettings.mbMouseVisible );
2977     }
2978 }
2979
2980 // --------------------------------------------------------------------
2981
2982 sal_Bool SAL_CALL SlideshowImpl::getUsePen() throw (RuntimeException)
2983 {
2984     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2985     return maPresSettings.mbMouseAsPen;
2986 }
2987
2988 // --------------------------------------------------------------------
2989
2990 void SAL_CALL SlideshowImpl::setUsePen( sal_Bool bMouseAsPen ) throw (RuntimeException)
2991 {
2992     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2993     maPresSettings.mbMouseAsPen = bMouseAsPen;
2994     if( mxShow.is() ) try
2995     {
2996         Any aValue;
2997         if( maPresSettings.mbMouseAsPen )
2998             // todo: take color from configuration
2999             aValue <<= mnUserPaintColor;
3000
3001         beans::PropertyValue aPenProp;
3002         aPenProp.Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "UserPaintColor" ));
3003         aPenProp.Value = aValue;
3004
3005         mxShow->setProperty( aPenProp );
3006
3007         //for StrokeWidth :
3008         Any aValueWidth;
3009         if( maPresSettings.mbMouseAsPen )
3010             aValueWidth <<= mdUserPaintStrokeWidth;
3011
3012         beans::PropertyValue aPenPropWidth;
3013         aPenPropWidth.Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "UserPaintStrokeWidth" ));
3014         aPenPropWidth.Value = aValueWidth;
3015
3016         mxShow->setProperty( aPenPropWidth );
3017     }
3018     catch( Exception& e )
3019     {
3020         static_cast<void>(e);
3021         DBG_ERROR(
3022             (OString("sd::SlideshowImpl::setUsePen(), "
3023                     "exception caught: ") +
3024             rtl::OUStringToOString(
3025                 comphelper::anyToString( cppu::getCaughtException() ),
3026                 RTL_TEXTENCODING_UTF8 )).getStr() );
3027     }
3028 }
3029
3030
3031 // --------------------------------------------------------------------
3032
3033 double SAL_CALL SlideshowImpl::getPenWidth() throw (RuntimeException)
3034 {
3035         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3036         return mdUserPaintStrokeWidth;
3037 }
3038
3039
3040 // --------------------------------------------------------------------
3041
3042 void SAL_CALL SlideshowImpl::setPenWidth( double dStrokeWidth ) throw (RuntimeException)
3043 {
3044         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3045         mdUserPaintStrokeWidth = dStrokeWidth;
3046         if( maPresSettings.mbMouseAsPen )
3047                 setUsePen( sal_True ); // update color and width
3048 }
3049
3050
3051 // --------------------------------------------------------------------
3052
3053 sal_Int32 SAL_CALL SlideshowImpl::getPenColor() throw (RuntimeException)
3054 {
3055     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3056     return mnUserPaintColor;
3057 }
3058
3059
3060 // --------------------------------------------------------------------
3061
3062 void SAL_CALL SlideshowImpl::setPenColor( sal_Int32 nColor ) throw (RuntimeException)
3063 {
3064     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3065     mnUserPaintColor = nColor;
3066     if( maPresSettings.mbMouseAsPen )
3067                 setUsePen( sal_True ); // update color and width
3068 }
3069
3070 // --------------------------------------------------------------------
3071 // XSlideShowController Methods
3072 // --------------------------------------------------------------------
3073
3074 sal_Bool SAL_CALL SlideshowImpl::isRunning(  ) throw (RuntimeException)
3075 {
3076     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3077     return mxShow.is();
3078 }
3079
3080 // --------------------------------------------------------------------
3081
3082 void SAL_CALL SlideshowImpl::gotoNextEffect(  ) throw (RuntimeException)
3083 {
3084     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3085
3086     if( mxShow.is() && mpSlideController.get() && mpShowWindow )
3087     {
3088         if( mbIsPaused )
3089             resume();
3090
3091         const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
3092         if( eMode == SHOWWINDOWMODE_END )
3093         {
3094             endPresentation();
3095         }
3096         else if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
3097         {
3098             mpShowWindow->RestartShow();
3099         }
3100         else
3101         {
3102             mxShow->nextEffect();
3103             update();
3104         }
3105     }
3106 }
3107
3108 // --------------------------------------------------------------------
3109
3110 void SAL_CALL SlideshowImpl::gotoPreviousEffect(  ) throw (RuntimeException)
3111 {
3112         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3113
3114         if( mxShow.is() && mpSlideController.get() && mpShowWindow )
3115         {
3116                 if( mbIsPaused )
3117                         resume();
3118
3119                 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
3120                 if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
3121                 {
3122                         mpShowWindow->RestartShow();
3123                 }
3124                 else
3125                 {
3126                         mxShow->previousEffect();
3127                         update();
3128                 }
3129         }
3130 }
3131
3132 // --------------------------------------------------------------------
3133
3134 void SAL_CALL SlideshowImpl::gotoFirstSlide(  ) throw (RuntimeException)
3135 {
3136     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3137
3138     if( mpShowWindow && mpSlideController.get() )
3139     {
3140         if( mbIsPaused )
3141             resume();
3142
3143         if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_END )
3144         {
3145             if( mpSlideController->getSlideIndexCount() )
3146                 mpShowWindow->RestartShow( 0);
3147         }
3148         else
3149         {
3150             displaySlideIndex( 0 );
3151         }
3152     }
3153 }
3154
3155 // --------------------------------------------------------------------
3156
3157 void SAL_CALL SlideshowImpl::gotoNextSlide(  ) throw (RuntimeException)
3158 {
3159     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3160
3161     if( mbIsPaused )
3162         resume();
3163
3164     const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
3165     if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
3166     {
3167         mpShowWindow->RestartShow();
3168     }
3169     else
3170     {
3171         // if this is a show, ignore user inputs and
3172         // start 20ms timer to reenable inputs to fiter
3173         // buffered inputs during slide transition
3174         if( meAnimationMode == ANIMATIONMODE_SHOW )
3175         {
3176             mbInputFreeze = true;
3177             maInputFreezeTimer.Start();
3178         }
3179
3180         if( mpSlideController.get() )
3181         {
3182             if( mpSlideController->nextSlide() )
3183             {
3184                 displayCurrentSlide();
3185             }
3186             else
3187             {
3188                 stopSound();
3189
3190                 if( meAnimationMode == ANIMATIONMODE_PREVIEW )
3191                 {
3192                     endPresentation();
3193                 }
3194                 else if( maPresSettings.mbEndless )
3195                 {
3196                     if( maPresSettings.mnPauseTimeout )
3197                     {
3198                         boost::scoped_ptr< Graphic > pGraphic;
3199
3200                         if( maPresSettings.mbShowPauseLogo )
3201                         {
3202                             // load about image from module path
3203                             String aBmpFileName( RTL_CONSTASCII_USTRINGPARAM("about.bmp") );
3204                             INetURLObject aObj( SvtPathOptions().GetModulePath(), INET_PROT_FILE );
3205                             aObj.insertName( aBmpFileName );
3206                             SvFileStream aStrm( aObj.PathToFileName(), STREAM_STD_READ );
3207                             if ( !aStrm.GetError() )
3208                             {
3209                                 Bitmap aBmp;
3210                                 aStrm >> aBmp;
3211                                 pGraphic.reset( new Graphic(aBmp) );
3212                                 pGraphic->SetPrefMapMode(MAP_PIXEL);
3213                             }
3214                             else
3215                             {
3216                                 //if no image is located in the module path
3217                                 //use default logo from iso resource:
3218
3219                                 String aMgrName( RTL_CONSTASCII_USTRINGPARAM( "iso" ) );
3220                                 boost::scoped_ptr< ResMgr > pResMgr( ResMgr::CreateResMgr( U2S( aMgrName )) );
3221                                 DBG_ASSERT(pResMgr,"No ResMgr found");
3222                                 if(pResMgr.get())
3223                                 {
3224                                     pGraphic.reset( new Graphic( Bitmap( ResId( RID_DEFAULT_ABOUT_BMP_LOGO, *pResMgr ) ) ) );
3225                                     pGraphic->SetPrefMapMode(MAP_PIXEL);
3226                                 }
3227                             }
3228                         }
3229                         if( mpShowWindow )
3230                             mpShowWindow->SetPauseMode( 0, maPresSettings.mnPauseTimeout, pGraphic.get() );
3231                     }
3232                     else
3233                     {
3234                         displaySlideIndex( 0 );
3235                     }
3236                 }
3237                 else
3238                 {
3239                     if( mpShowWindow )
3240                     {
3241                         mpShowWindow->SetEndMode();
3242                         pause();
3243                     }
3244                 }
3245             }
3246         }
3247     }
3248 }
3249
3250 // --------------------------------------------------------------------
3251
3252 void SAL_CALL SlideshowImpl::gotoPreviousSlide(  ) throw (RuntimeException)
3253 {
3254     gotoPreviousSlide(false);
3255 }
3256
3257 void SlideshowImpl::gotoPreviousSlide (const bool bSkipAllMainSequenceEffects)
3258 {
3259     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3260
3261     if( mxShow.is() && mpSlideController.get() ) try
3262     {
3263         if( mbIsPaused )
3264             resume();
3265
3266         const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
3267         if( eMode == SHOWWINDOWMODE_END )
3268         {
3269             const sal_Int32 nLastSlideIndex = mpSlideController->getSlideIndexCount() - 1;
3270             if( nLastSlideIndex >= 0 )
3271                 mpShowWindow->RestartShow( nLastSlideIndex );
3272         }
3273         else if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
3274         {
3275             mpShowWindow->RestartShow();
3276         }
3277         else
3278         {
3279             if( mpSlideController->previousSlide())
3280                 displayCurrentSlide(bSkipAllMainSequenceEffects);
3281             else if (bSkipAllMainSequenceEffects)
3282             {
3283                 // We could not go to the previous slide (probably because
3284                 // the current slide is already the first one).  We still
3285                 // have to call displayCurrentSlide because the calling
3286                 // slideshow can not determine whether there is a previous
3287                 // slide or not and has already prepared for a slide change.
3288                 // This slide change has to be completed now, even when
3289                 // changing to the same slide.
3290                 // Note that in this special case we do NOT pass
3291                 // bSkipAllMainSequenceEffects because we display the same
3292                 // slide as before and do not want to show all its effects.
3293                                 displayCurrentSlide(false);
3294             }
3295         }
3296     }
3297     catch( Exception& e )
3298     {
3299         static_cast<void>(e);
3300         DBG_ERROR(
3301             (OString("sd::SlideshowImpl::gotoPreviousSlide(), "
3302                     "exception caught: ") +
3303             rtl::OUStringToOString(
3304                 comphelper::anyToString( cppu::getCaughtException() ),
3305                 RTL_TEXTENCODING_UTF8 )).getStr() );
3306     }
3307 }
3308
3309 // --------------------------------------------------------------------
3310
3311 void SAL_CALL SlideshowImpl::gotoLastSlide() throw (RuntimeException)
3312 {
3313     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3314
3315     if( mpSlideController.get() )
3316     {
3317         if( mbIsPaused )
3318             resume();
3319
3320         const sal_Int32 nLastSlideIndex = mpSlideController->getSlideIndexCount() - 1;
3321         if( nLastSlideIndex >= 0 )
3322         {
3323             if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_END )
3324             {
3325                 mpShowWindow->RestartShow( nLastSlideIndex );
3326             }
3327             else
3328             {
3329                 displaySlideIndex( nLastSlideIndex );
3330             }
3331         }
3332     }
3333 }
3334
3335 // --------------------------------------------------------------------
3336
3337 void SAL_CALL SlideshowImpl::gotoBookmark( const OUString& rBookmark ) throw (RuntimeException)
3338 {
3339     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3340
3341     if( mbIsPaused )
3342         resume();
3343
3344     sal_Int32 nSlideNumber = getSlideNumberForBookmark( rBookmark );
3345     if( nSlideNumber != -1 )
3346         displaySlideNumber( nSlideNumber );
3347 }
3348
3349 // --------------------------------------------------------------------
3350
3351 void SAL_CALL SlideshowImpl::gotoSlide( const Reference< XDrawPage >& xSlide )
3352     throw(IllegalArgumentException, RuntimeException)
3353 {
3354     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3355
3356     if( mpSlideController.get() && xSlide.is() )
3357     {
3358         if( mbIsPaused )
3359             resume();
3360
3361         const sal_Int32 nSlideCount = mpSlideController->getSlideNumberCount();
3362         for( sal_Int32 nSlide = 0; nSlide < nSlideCount; nSlide++ )
3363         {
3364             if( mpSlideController->getSlideByNumber( nSlide ) == xSlide )
3365             {
3366                 displaySlideNumber( nSlide );
3367             }
3368         }
3369     }
3370 }
3371
3372 // --------------------------------------------------------------------
3373
3374 void SAL_CALL SlideshowImpl::gotoSlideIndex( sal_Int32 nIndex ) throw (RuntimeException)
3375 {
3376     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3377
3378     if( mbIsPaused )
3379         resume();
3380
3381     displaySlideIndex( nIndex );
3382 }
3383
3384 // --------------------------------------------------------------------
3385
3386 void SAL_CALL SlideshowImpl::stopSound(  ) throw (RuntimeException)
3387 {
3388     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3389
3390     try
3391     {
3392         if( mxPlayer.is() )
3393         {
3394             mxPlayer->stop();
3395             mxPlayer.clear();
3396         }
3397     }
3398     catch( Exception& e )
3399     {
3400         static_cast<void>(e);
3401         DBG_ERROR(
3402             (OString("sd::SlideshowImpl::stopSound(), "
3403                     "exception caught: ") +
3404             rtl::OUStringToOString(
3405                 comphelper::anyToString( cppu::getCaughtException() ),
3406                 RTL_TEXTENCODING_UTF8 )).getStr() );
3407     }
3408 }
3409
3410 // --------------------------------------------------------------------
3411 // XIndexAccess
3412 // --------------------------------------------------------------------
3413
3414 ::sal_Int32 SAL_CALL SlideshowImpl::getCount(  ) throw (::com::sun::star::uno::RuntimeException)
3415 {
3416     return getSlideCount();
3417 }
3418
3419 // --------------------------------------------------------------------
3420
3421 ::com::sun::star::uno::Any SAL_CALL SlideshowImpl::getByIndex( ::sal_Int32 Index ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
3422 {
3423     return Any( getSlideByIndex( Index ) );
3424 }
3425
3426 // --------------------------------------------------------------------
3427
3428 ::com::sun::star::uno::Type SAL_CALL SlideshowImpl::getElementType(  ) throw (::com::sun::star::uno::RuntimeException)
3429 {
3430     return XDrawPage::static_type();
3431 }
3432
3433 // --------------------------------------------------------------------
3434
3435 ::sal_Bool SAL_CALL SlideshowImpl::hasElements(  ) throw (::com::sun::star::uno::RuntimeException)
3436 {
3437     return getSlideCount() != 0;
3438 }
3439
3440 // --------------------------------------------------------------------
3441
3442 Reference< XSlideShow > SAL_CALL SlideshowImpl::getSlideShow() throw (RuntimeException)
3443 {
3444     return mxShow;
3445 }
3446
3447 // --------------------------------------------------------------------
3448
3449
3450 PresentationSettingsEx::PresentationSettingsEx()
3451 : mbRehearseTimings(sal_False)
3452 , mbPreview(sal_False)
3453 , mpParentWindow( 0 )
3454 {
3455 }
3456
3457 PresentationSettingsEx::PresentationSettingsEx( PresentationSettingsEx& r )
3458 : PresentationSettings( r )
3459 , mbRehearseTimings(r.mbRehearseTimings)
3460 , mbPreview(r.mbPreview)
3461 , mpParentWindow( 0 )
3462 {
3463 }
3464
3465 PresentationSettingsEx::PresentationSettingsEx( PresentationSettings& r )
3466 : PresentationSettings( r )
3467 , mbRehearseTimings(sal_False)
3468 , mbPreview(sal_False)
3469 , mpParentWindow(0)
3470 {
3471 }
3472
3473 void PresentationSettingsEx::SetArguments( const Sequence< PropertyValue >& rArguments ) throw (IllegalArgumentException)
3474 {
3475     sal_Int32 nArguments = rArguments.getLength();
3476     const PropertyValue* pValue = rArguments.getConstArray();
3477
3478     while( nArguments-- )
3479     {
3480         SetPropertyValue( pValue->Name, pValue->Value );
3481         pValue++;
3482     }
3483 }
3484
3485 void PresentationSettingsEx::SetPropertyValue( const OUString& rProperty, const Any& rValue ) throw (IllegalArgumentException)
3486 {
3487     if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("RehearseTimings") ) )
3488     {
3489         if( rValue >>= mbRehearseTimings )
3490             return;
3491     }
3492     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("Preview") ) )
3493     {
3494         if( rValue >>= mbPreview )
3495             return;
3496     }
3497     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("AnimationNode") ) )
3498     {
3499         if( rValue >>= mxAnimationNode )
3500             return;
3501     }
3502     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("ParentWindow") ) )
3503     {
3504         Reference< XWindow > xWindow;
3505         if( rValue >>= xWindow )
3506         {
3507             mpParentWindow = xWindow.is() ? VCLUnoHelper::GetWindow( xWindow ) : 0;
3508             return;
3509         }
3510     }
3511     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("AllowAnimations") ) )
3512     {
3513         if( rValue >>= mbAnimationAllowed )
3514             return;
3515     }
3516     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("AllowAnimations") ) )
3517     {
3518         if( rValue >>= mbAnimationAllowed )
3519             return;
3520     }
3521     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("FirstPage") ) )
3522     {
3523         OUString aPresPage;
3524         if( rValue >>= aPresPage )
3525         {
3526             maPresPage = getUiNameFromPageApiNameImpl(aPresPage);
3527             mbCustomShow = sal_False;
3528             mbAll = sal_False;
3529             return;
3530         }
3531         else
3532         {
3533             if( rValue >>= mxStartPage )
3534                 return;
3535         }
3536     }
3537     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("IsAlwaysOnTop") ) )
3538     {
3539         if( rValue >>= mbAlwaysOnTop )
3540             return;
3541     }
3542     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("IsAutomatic") ) )
3543     {
3544         if( rValue >>= mbManual )
3545             return;
3546     }
3547     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("IsEndless") ) )
3548     {
3549         if( rValue >>= mbEndless )
3550             return;
3551     }
3552     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("IsFullScreen") ) )
3553     {
3554         if( rValue >>= mbFullScreen )
3555             return;
3556     }
3557     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("IsMouseVisible") ) )
3558     {
3559         if( rValue >>= mbMouseVisible )
3560             return;
3561     }
3562     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("Pause") ) )
3563     {
3564         sal_Int32 nPause = -1;
3565         if( (rValue >>= nPause) && (nPause >= 0) )
3566         {
3567             mnPauseTimeout = nPause;
3568             return;
3569         }
3570     }
3571     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("StartWithNavigator") ) )
3572     {
3573         if( rValue >>= mbStartWithNavigator )
3574             return;
3575     }
3576     else if( rProperty.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("UsePen") ) )
3577     {
3578         if( rValue >>= mbMouseAsPen )
3579             return;
3580     }
3581     throw IllegalArgumentException();
3582 }
3583
3584 ////////////////////////////////
3585
3586 // ---------------------------------------------------------
3587 // XAnimationListener
3588 // ---------------------------------------------------------
3589
3590 SlideShowListenerProxy::SlideShowListenerProxy( const rtl::Reference< SlideshowImpl >& xController, const css::uno::Reference< css::presentation::XSlideShow >& xSlideShow )
3591 : maListeners( m_aMutex )
3592 , mxController( xController )
3593 , mxSlideShow( xSlideShow )
3594 {
3595 }
3596
3597 // ---------------------------------------------------------
3598
3599 SlideShowListenerProxy::~SlideShowListenerProxy()
3600 {
3601 }
3602
3603 // ---------------------------------------------------------
3604
3605 void SlideShowListenerProxy::addAsSlideShowListener()
3606 {
3607     if( mxSlideShow.is() )
3608     {
3609         Reference< XSlideShowListener > xSlideShowListener( this );
3610         mxSlideShow->addSlideShowListener( xSlideShowListener );
3611     }
3612 }
3613
3614 // ---------------------------------------------------------
3615
3616 void SlideShowListenerProxy::removeAsSlideShowListener()
3617 {
3618     if( mxSlideShow.is() )
3619     {
3620         Reference< XSlideShowListener > xSlideShowListener( this );
3621         mxSlideShow->removeSlideShowListener( xSlideShowListener );
3622     }
3623 }
3624
3625 // ---------------------------------------------------------
3626
3627 void SlideShowListenerProxy::addShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape )
3628 {
3629     if( mxSlideShow.is() )
3630     {
3631         Reference< XShapeEventListener > xListener( this );
3632         mxSlideShow->addShapeEventListener( xListener, xShape );
3633     }
3634 }
3635
3636 // ---------------------------------------------------------
3637
3638 void SlideShowListenerProxy::removeShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape )
3639 {
3640     if( mxSlideShow.is() )
3641     {
3642         Reference< XShapeEventListener > xListener( this );
3643         mxSlideShow->removeShapeEventListener( xListener, xShape );
3644     }
3645 }
3646
3647 // ---------------------------------------------------------
3648
3649 void SlideShowListenerProxy::addSlideShowListener( const css::uno::Reference< css::presentation::XSlideShowListener >& xListener )
3650 {
3651     maListeners.addInterface(xListener);
3652 }
3653
3654 // ---------------------------------------------------------
3655
3656 void SlideShowListenerProxy::removeSlideShowListener( const css::uno::Reference< css::presentation::XSlideShowListener >& xListener )
3657 {
3658     maListeners.removeInterface(xListener);
3659 }
3660
3661 // ---------------------------------------------------------
3662
3663 void SAL_CALL SlideShowListenerProxy::beginEvent( const Reference< XAnimationNode >& xNode ) throw (RuntimeException)
3664 {
3665     ::osl::MutexGuard aGuard( m_aMutex );
3666
3667     if( maListeners.getLength() >= 0 )
3668         maListeners.forEach<XSlideShowListener>( boost::bind( &XAnimationListener::beginEvent, _1,  boost::cref(xNode) ));
3669 }
3670
3671 // ---------------------------------------------------------
3672
3673 void SAL_CALL SlideShowListenerProxy::endEvent( const Reference< XAnimationNode >& xNode ) throw (RuntimeException)
3674 {
3675     ::osl::MutexGuard aGuard( m_aMutex );
3676
3677     if( maListeners.getLength() >= 0 )
3678         maListeners.forEach<XSlideShowListener>( boost::bind( &XAnimationListener::endEvent, _1, boost::cref(xNode) ));
3679 }
3680
3681 // ---------------------------------------------------------
3682
3683 void SAL_CALL SlideShowListenerProxy::repeat( const Reference< XAnimationNode >& xNode, ::sal_Int32 nRepeat ) throw (RuntimeException)
3684 {
3685     ::osl::MutexGuard aGuard( m_aMutex );
3686
3687     if( maListeners.getLength() >= 0 )
3688         maListeners.forEach<XSlideShowListener>( boost::bind( &XAnimationListener::repeat, _1,  boost::cref(xNode), boost::cref(nRepeat) ));
3689 }
3690
3691 // ---------------------------------------------------------
3692 // ::com::sun::star::presentation::XSlideShowListener:
3693 // ---------------------------------------------------------
3694
3695 void SAL_CALL SlideShowListenerProxy::paused(  ) throw (::com::sun::star::uno::RuntimeException)
3696 {
3697     ::osl::MutexGuard aGuard( m_aMutex );
3698
3699     if( maListeners.getLength() >= 0 )
3700         maListeners.forEach<XSlideShowListener>( boost::mem_fn( &XSlideShowListener::paused ) );
3701 }
3702
3703 // ---------------------------------------------------------
3704
3705 void SAL_CALL SlideShowListenerProxy::resumed(  ) throw (::com::sun::star::uno::RuntimeException)
3706 {
3707     ::osl::MutexGuard aGuard( m_aMutex );
3708
3709     if( maListeners.getLength() >= 0 )
3710         maListeners.forEach<XSlideShowListener>( boost::mem_fn( &XSlideShowListener::resumed ) );
3711 }
3712
3713 // ---------------------------------------------------------
3714
3715 void SAL_CALL SlideShowListenerProxy::slideTransitionStarted( ) throw (RuntimeException)
3716 {
3717     ::osl::MutexGuard aGuard( m_aMutex );
3718
3719     if( maListeners.getLength() >= 0 )
3720         maListeners.forEach<XSlideShowListener>( boost::mem_fn( &XSlideShowListener::slideTransitionStarted ) );
3721 }
3722
3723 // ---------------------------------------------------------
3724
3725 void SAL_CALL SlideShowListenerProxy::slideTransitionEnded( ) throw (::com::sun::star::uno::RuntimeException)
3726 {
3727     ::osl::MutexGuard aGuard( m_aMutex );
3728
3729     if( maListeners.getLength() >= 0 )
3730         maListeners.forEach<XSlideShowListener>( boost::mem_fn( &XSlideShowListener::slideTransitionEnded ) );
3731 }
3732
3733 // ---------------------------------------------------------
3734
3735 void SAL_CALL SlideShowListenerProxy::slideAnimationsEnded(  ) throw (::com::sun::star::uno::RuntimeException)
3736 {
3737     ::osl::MutexGuard aGuard( m_aMutex );
3738
3739     if( maListeners.getLength() >= 0 )
3740         maListeners.forEach<XSlideShowListener>( boost::mem_fn( &XSlideShowListener::slideAnimationsEnded ) );
3741 }
3742
3743 // ---------------------------------------------------------
3744
3745 void SlideShowListenerProxy::slideEnded(sal_Bool bReverse) throw (RuntimeException)
3746 {
3747     {
3748         ::osl::MutexGuard aGuard( m_aMutex );
3749
3750         if( maListeners.getLength() >= 0 )
3751                         maListeners.forEach<XSlideShowListener>(
3752                 boost::bind( &XSlideShowListener::slideEnded, _1, bReverse) );
3753     }
3754
3755     {
3756         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3757         if( mxController.is() )
3758                         mxController->slideEnded(bReverse);
3759     }
3760 }
3761
3762 // ---------------------------------------------------------
3763
3764 void SlideShowListenerProxy::hyperLinkClicked( rtl::OUString const& aHyperLink ) throw (RuntimeException)
3765 {
3766     {
3767         ::osl::MutexGuard aGuard( m_aMutex );
3768
3769         if( maListeners.getLength() >= 0 )
3770             maListeners.forEach<XSlideShowListener>( boost::bind( &XSlideShowListener::hyperLinkClicked, _1, boost::cref(aHyperLink) ));
3771     }
3772
3773     {
3774         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3775         if( mxController.is() )
3776             mxController->hyperLinkClicked(aHyperLink);
3777     }
3778 }
3779
3780 // ---------------------------------------------------------
3781 // XEventListener
3782 // ---------------------------------------------------------
3783
3784 void SAL_CALL SlideShowListenerProxy::disposing( const ::com::sun::star::lang::EventObject& aDisposeEvent ) throw (RuntimeException)
3785 {
3786     maListeners.disposeAndClear( aDisposeEvent );
3787     mxController.clear();
3788     mxSlideShow.clear();
3789 }
3790
3791 // ---------------------------------------------------------
3792 // XShapeEventListener
3793 // ---------------------------------------------------------
3794
3795 void SAL_CALL SlideShowListenerProxy::click( const Reference< XShape >& xShape, const ::com::sun::star::awt::MouseEvent& aOriginalEvent ) throw (RuntimeException)
3796 {
3797     ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
3798     if( mxController.is() )
3799         mxController->click(xShape, aOriginalEvent );
3800 }
3801
3802 } // namespace ::sd