LCOV - code coverage report
Current view: top level - sd/source/ui/slideshow - slideshowimpl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1608 0.0 %
Date: 2014-04-14 Functions: 0 159 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10