sd/source/ui/slideshow/slideshow.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: slideshow.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 //#include <com/sun/star/frame/XController.hpp>
  35 #include <com/sun/star/beans/PropertyAttribute.hpp>
  36 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  37 #include <com/sun/star/container/XIndexAccess.hpp>
  38 #include <com/sun/star/frame/XDispatchProvider.hpp>
  39 #include <com/sun/star/util/URL.hpp>
  40
  41 #include <cppuhelper/bootstrap.hxx>
  42
  43 #include <comphelper/processfactory.hxx>
  44 #include <vos/mutex.hxx>
  45
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/wrkwin.hxx>
  48
  49 #include <svtools/itemprop.hxx>
  50
  51 #include <sfx2/topfrm.hxx>
  52 #include <sfx2/viewfrm.hxx>
  53
  54 #include <toolkit/unohlp.hxx>
  55 #include <svx/unoprov.hxx>
  56
  57 #include "framework/FrameworkHelper.hxx"
  58
  59 #include "FrameView.hxx"
  60 #include "unomodel.hxx"
  61 #include "slideshow.hxx"
  62 #include "slideshowimpl.hxx"
  63 #include "sdattr.hrc"
  64 #include "FactoryIds.hxx"
  65 #include "ViewShell.hxx"
  66 #include "SlideShowRestarter.hxx"
  67 #include <boost/bind.hpp>
  68
  69 using ::com::sun::star::presentation::XSlideShowController;
  70 using ::com::sun::star::container::XIndexAccess;
  71 using ::sd::framework::FrameworkHelper;
  72 using ::rtl::OUString;
  73 using ::com::sun::star::awt::XWindow;
  74 using namespace ::sd;
  75 using namespace ::cppu;
  76 using namespace ::vos;
  77 using namespace ::com::sun::star;
  78 using namespace ::com::sun::star::uno;
  79 using namespace ::com::sun::star::presentation;
  80 using namespace ::com::sun::star::drawing;
  81 using namespace ::com::sun::star::beans;
  82 using namespace ::com::sun::star::lang;
  83 using namespace ::com::sun::star::animations;
  84 using namespace ::com::sun::star::drawing::framework;
  85
  86 extern String getUiNameFromPageApiNameImpl( const ::rtl::OUString& rApiName );
  87
  88 #define C2U(x) OUString( RTL_CONSTASCII_USTRINGPARAM(x) )
  89
  90
  91 namespace {
  92     /** This local version of the work window overloads DataChanged() so that it
  93         can restart the slide show when a displau is added or removed.
  94     */
  95     class FullScreenWorkWindow : public WorkWindow
  96     {
  97     public:
  98         FullScreenWorkWindow (
  99             const ::rtl::Reference<SlideShow>& rpSlideShow,
 100             ViewShellBase* pViewShellBase)
 101             : WorkWindow(NULL, WB_HIDE | WB_CLIPCHILDREN),
 102               mpRestarter(new SlideShowRestarter(rpSlideShow, pViewShellBase))
 103         {}
 104
 105
 106         virtual void DataChanged (const DataChangedEvent& rEvent)
 107         {
 108             if (rEvent.GetType() == DATACHANGED_DISPLAY)
 109             {
 110                 mpRestarter->Restart();
 111             }
 112         }
 113
 114     private:
 115         ::boost::shared_ptr<SlideShowRestarter> mpRestarter;
 116     };
 117 }
 118
 119
 120 //////////////////////////////////////////////////////////////////////////////
 121 // --------------------------------------------------------------------
 122
 123 const SfxItemPropertyMapEntry* ImplGetPresentationPropertyMap()
 124 {
 125     // NOTE: First member must be sorted
 126     static const SfxItemPropertyMapEntry aPresentationPropertyMap_Impl[] =
 127     {
 128         { MAP_CHAR_LEN("AllowAnimations"),                      ATTR_PRESENT_ANIMATION_ALLOWED, &::getBooleanCppuType(),                                0, 0 },
 129         { MAP_CHAR_LEN("CustomShow"),                           ATTR_PRESENT_CUSTOMSHOW,                &::getCppuType((const OUString*)0),             0, 0 },
 130         { MAP_CHAR_LEN("Display"),                                      ATTR_PRESENT_DISPLAY,                   &::getCppuType((const sal_Int32*)0),    0, 0 },
 131         { MAP_CHAR_LEN("FirstPage"),                            ATTR_PRESENT_DIANAME,                   &::getCppuType((const OUString*)0),             0, 0 },
 132         { MAP_CHAR_LEN("IsAlwaysOnTop"),                        ATTR_PRESENT_ALWAYS_ON_TOP,             &::getBooleanCppuType(),                                0, 0 },
 133         { MAP_CHAR_LEN("IsAutomatic"),                          ATTR_PRESENT_MANUEL,                    &::getBooleanCppuType(),                                0, 0 },
 134         { MAP_CHAR_LEN("IsEndless"),                            ATTR_PRESENT_ENDLESS,                   &::getBooleanCppuType(),                                0, 0 },
 135         { MAP_CHAR_LEN("IsFullScreen"),                         ATTR_PRESENT_FULLSCREEN,                &::getBooleanCppuType(),                                0, 0 },
 136         { MAP_CHAR_LEN("IsShowAll"),                            ATTR_PRESENT_ALL,                               &::getBooleanCppuType(),                                0, 0 },
 137         { MAP_CHAR_LEN("IsMouseVisible"),                       ATTR_PRESENT_MOUSE,                             &::getBooleanCppuType(),                                0, 0 },
 138         { MAP_CHAR_LEN("IsShowLogo"),                           ATTR_PRESENT_SHOW_PAUSELOGO,    &::getBooleanCppuType(),                                0, 0 },
 139         { MAP_CHAR_LEN("IsTransitionOnClick"),          ATTR_PRESENT_CHANGE_PAGE,               &::getBooleanCppuType(),                                0, 0 },
 140         { MAP_CHAR_LEN("Pause"),                                        ATTR_PRESENT_PAUSE_TIMEOUT,             &::getCppuType((const sal_Int32*)0),    0, 0 },
 141         { MAP_CHAR_LEN("StartWithNavigator"),           ATTR_PRESENT_NAVIGATOR,                 &::getBooleanCppuType(),                                0, 0 },
 142         { MAP_CHAR_LEN("UsePen"),                                       ATTR_PRESENT_PEN,                               &::getBooleanCppuType(),                                0, 0 },
 143         { 0,0,0,0,0,0}
 144     };
 145
 146     return aPresentationPropertyMap_Impl;
 147 }
 148
 149 //SfxItemPropertyMap map_impl[] = { { 0,0,0,0,0,0 } };
 150
 151 // --------------------------------------------------------------------
 152 // class SlideShow
 153 // --------------------------------------------------------------------
 154
 155 SlideShow::SlideShow( SdDrawDocument* pDoc )
 156 : SlideshowBase( m_aMutex )
 157 , maPropSet(ImplGetPresentationPropertyMap())
 158 , mbIsInStartup(false)
 159 , mpDoc( pDoc )
 160 , mpCurrentViewShellBase( 0 )
 161 , mpFullScreenViewShellBase( 0 )
 162 , mpFullScreenFrameView( 0 )
 163 , mnInPlaceConfigEvent( 0 )
 164 {
 165 }
 166
 167 // --------------------------------------------------------------------
 168
 169 void SlideShow::ThrowIfDisposed() throw (RuntimeException)
 170 {
 171     if( mpDoc == 0 )
 172         throw DisposedException();
 173 }
 174
 175 // --------------------------------------------------------------------
 176
 177 /// used by the model to create a slideshow for it
 178 rtl::Reference< SlideShow > SlideShow::Create( SdDrawDocument* pDoc )
 179 {
 180     return new SlideShow( pDoc );
 181 }
 182
 183 // --------------------------------------------------------------------
 184
 185 rtl::Reference< SlideShow > SlideShow::GetSlideShow( SdDrawDocument* pDocument )
 186 {
 187     rtl::Reference< SlideShow > xRet;
 188
 189     if( pDocument )
 190         xRet = rtl::Reference< SlideShow >( dynamic_cast< SlideShow* >( pDocument->getPresentation().get() ) );
 191
 192     return xRet;
 193 }
 194
 195 // --------------------------------------------------------------------
 196
 197 rtl::Reference< SlideShow > SlideShow::GetSlideShow( ViewShellBase& rBase )
 198 {
 199     return GetSlideShow( rBase.GetDocument() );
 200 }
 201
 202 // --------------------------------------------------------------------
 203
 204 ::com::sun::star::uno::Reference< ::com::sun::star::presentation::XSlideShowController > SlideShow::GetSlideShowController(ViewShellBase& rBase )
 205 {
 206     rtl::Reference< SlideShow > xSlideShow( GetSlideShow( rBase ) );
 207
 208     Reference< XSlideShowController > xRet;
 209     if( xSlideShow.is() )
 210         xRet = xSlideShow->getController();
 211
 212     return xRet;
 213 }
 214
 215 // --------------------------------------------------------------------
 216
 217 bool SlideShow::StartPreview( ViewShellBase& rBase,
 218     const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xDrawPage,
 219     const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xAnimationNode,
 220     ::Window* pParent /* = 0 */ )
 221 {
 222     rtl::Reference< SlideShow > xSlideShow( GetSlideShow( rBase ) );
 223     if( xSlideShow.is() )
 224         return xSlideShow->startPreview( xDrawPage, xAnimationNode, pParent );
 225
 226     return false;
 227 }
 228
 229 // --------------------------------------------------------------------
 230
 231 void SlideShow::Stop( ViewShellBase& rBase )
 232 {
 233     rtl::Reference< SlideShow > xSlideShow( GetSlideShow( rBase ) );
 234     if( xSlideShow.is() )
 235         xSlideShow->end();
 236 }
 237
 238 // --------------------------------------------------------------------
 239
 240 bool SlideShow::IsRunning( ViewShellBase& rBase )
 241 {
 242     rtl::Reference< SlideShow > xSlideShow( GetSlideShow( rBase ) );
 243     return xSlideShow.is() && xSlideShow->isRunning();
 244 }
 245
 246 // --------------------------------------------------------------------
 247
 248 bool SlideShow::IsRunning( ViewShell& rViewShell )
 249 {
 250     rtl::Reference< SlideShow > xSlideShow( GetSlideShow( rViewShell.GetViewShellBase() ) );
 251     return xSlideShow.is() && xSlideShow->isRunning() && (xSlideShow->mxController->getViewShell() == &rViewShell);
 252 }
 253
 254 // --------------------------------------------------------------------
 255
 256 void SlideShow::CreateController(  ViewShell* pViewSh, ::sd::View* pView, ::Window* pParentWindow )
 257 {
 258     DBG_ASSERT( !mxController.is(), "sd::SlideShow::CreateController(), clean up old controller first!" );
 259
 260     Reference< XPresentation2 > xThis( this );
 261
 262     rtl::Reference<SlideshowImpl> xController (
 263         new SlideshowImpl(xThis, pViewSh, pView, mpDoc, pParentWindow));
 264
 265     // Reset mbIsInStartup.  From here mxController.is() is used to prevent
 266     // multiple slide show instances for one document.
 267     mxController = xController;
 268     mbIsInStartup = false;
 269 }
 270
 271 // --------------------------------------------------------------------
 272 // XServiceInfo
 273 // --------------------------------------------------------------------
 274
 275 OUString SAL_CALL SlideShow::getImplementationName(  ) throw(RuntimeException)
 276 {
 277     return OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.sd.SlideShow") );
 278 }
 279
 280 // --------------------------------------------------------------------
 281
 282 sal_Bool SAL_CALL SlideShow::supportsService( const OUString& ServiceName ) throw(RuntimeException)
 283 {
 284     return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames(  ) );
 285 }
 286
 287 // --------------------------------------------------------------------
 288
 289 Sequence< OUString > SAL_CALL SlideShow::getSupportedServiceNames(  ) throw(RuntimeException)
 290 {
 291     OUString aService( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.Presentation") );
 292     Sequence< OUString > aSeq( &aService, 1 );
 293     return aSeq;
 294 }
 295
 296 // --------------------------------------------------------------------
 297 // XPropertySet
 298 // --------------------------------------------------------------------
 299
 300 Reference< XPropertySetInfo > SAL_CALL SlideShow::getPropertySetInfo() throw(RuntimeException)
 301 {
 302     OGuard aGuard( Application::GetSolarMutex() );
 303     static Reference< XPropertySetInfo > xInfo = maPropSet.getPropertySetInfo();
 304     return xInfo;
 305  }
 306
 307 // --------------------------------------------------------------------
 308
 309 void SAL_CALL SlideShow::setPropertyValue( const OUString& aPropertyName, const Any& aValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 310 {
 311     OGuard aGuard( Application::GetSolarMutex() );
 312     ThrowIfDisposed();
 313
 314     sd::PresentationSettings& rPresSettings = mpDoc->getPresentationSettings();
 315
 316     const SfxItemPropertySimpleEntry* pEntry = maPropSet.getPropertyMapEntry(aPropertyName);
 317
 318     if( pEntry && ((pEntry->nFlags & PropertyAttribute::READONLY) != 0) )
 319         throw PropertyVetoException();
 320
 321     bool bValuesChanged = false;
 322     bool bIllegalArgument = true;
 323
 324     switch( pEntry ? pEntry->nWID : -1 )
 325     {
 326     case ATTR_PRESENT_ALL:
 327     {
 328         sal_Bool bVal = sal_False;
 329
 330         if( aValue >>= bVal )
 331         {
 332             bIllegalArgument = false;
 333
 334             if( rPresSettings.mbAll != bVal )
 335             {
 336                 rPresSettings.mbAll = bVal;
 337                 bValuesChanged = true;
 338                 if( bVal )
 339                     rPresSettings.mbCustomShow = sal_False;
 340             }
 341         }
 342         break;
 343     }
 344     case ATTR_PRESENT_CHANGE_PAGE:
 345     {
 346         sal_Bool bVal = sal_False;
 347
 348         if( aValue >>= bVal )
 349         {
 350             bIllegalArgument = false;
 351
 352             if( bVal == rPresSettings.mbLockedPages )
 353             {
 354                 bValuesChanged = true;
 355                 rPresSettings.mbLockedPages = !bVal;
 356             }
 357         }
 358         break;
 359     }
 360
 361     case ATTR_PRESENT_ANIMATION_ALLOWED:
 362     {
 363         sal_Bool bVal = sal_False;
 364
 365         if( aValue >>= bVal )
 366         {
 367             bIllegalArgument = false;
 368
 369             if(rPresSettings.mbAnimationAllowed != bVal)
 370             {
 371                 bValuesChanged = true;
 372                 rPresSettings.mbAnimationAllowed = bVal;
 373             }
 374         }
 375         break;
 376     }
 377     case ATTR_PRESENT_CUSTOMSHOW:
 378     {
 379         OUString aShow;
 380         if( aValue >>= aShow )
 381         {
 382             bIllegalArgument = false;
 383
 384             const String aShowName( aShow );
 385
 386             List* pCustomShowList = mpDoc->GetCustomShowList(sal_False);
 387             if(pCustomShowList)
 388             {
 389                 SdCustomShow* pCustomShow;
 390                 for( pCustomShow = (SdCustomShow*) pCustomShowList->First(); pCustomShow != NULL; pCustomShow = (SdCustomShow*) pCustomShowList->Next() )
 391                 {
 392                     if( pCustomShow->GetName() == aShowName )
 393                         break;
 394                 }
 395
 396                 rPresSettings.mbCustomShow = sal_True;
 397                 bValuesChanged = true;
 398             }
 399         }
 400         break;
 401     }
 402     case ATTR_PRESENT_ENDLESS:
 403     {
 404         sal_Bool bVal = sal_False;
 405
 406         if( aValue >>= bVal )
 407         {
 408             bIllegalArgument = false;
 409
 410             if( rPresSettings.mbEndless != bVal)
 411             {
 412                 bValuesChanged = true;
 413                 rPresSettings.mbEndless = bVal;
 414             }
 415         }
 416         break;
 417     }
 418     case ATTR_PRESENT_FULLSCREEN:
 419     {
 420         sal_Bool bVal = sal_False;
 421
 422         if( aValue >>= bVal )
 423         {
 424             bIllegalArgument = false;
 425             if( rPresSettings.mbFullScreen != bVal)
 426             {
 427                 bValuesChanged = true;
 428                 rPresSettings.mbFullScreen = bVal;
 429             }
 430         }
 431         break;
 432     }
 433     case ATTR_PRESENT_DIANAME:
 434     {
 435         OUString aPresPage;
 436         aValue >>= aPresPage;
 437         bIllegalArgument = false;
 438         if( (rPresSettings.maPresPage != aPresPage) || !rPresSettings.mbCustomShow || !rPresSettings.mbAll )
 439         {
 440             bValuesChanged = true;
 441             rPresSettings.maPresPage = getUiNameFromPageApiNameImpl(aPresPage);
 442             rPresSettings.mbCustomShow = sal_False;
 443             rPresSettings.mbAll = sal_False;
 444         }
 445         break;
 446     }
 447     case ATTR_PRESENT_MANUEL:
 448     {
 449         sal_Bool bVal = sal_False;
 450
 451         if( aValue >>= bVal )
 452         {
 453             bIllegalArgument = false;
 454
 455             if( rPresSettings.mbManual != bVal)
 456             {
 457                 bValuesChanged = true;
 458                 rPresSettings.mbManual = bVal;
 459             }
 460         }
 461         break;
 462     }
 463     case ATTR_PRESENT_MOUSE:
 464     {
 465         sal_Bool bVal = sal_False;
 466
 467         if( aValue >>= bVal )
 468         {
 469             bIllegalArgument = false;
 470             if( rPresSettings.mbMouseVisible != bVal)
 471             {
 472                 bValuesChanged = true;
 473                 rPresSettings.mbMouseVisible = bVal;
 474             }
 475         }
 476         break;
 477     }
 478     case ATTR_PRESENT_ALWAYS_ON_TOP:
 479     {
 480         sal_Bool bVal = sal_False;
 481
 482         if( aValue >>= bVal )
 483         {
 484             bIllegalArgument = false;
 485
 486             if( rPresSettings.mbAlwaysOnTop != bVal)
 487             {
 488                 bValuesChanged = true;
 489                 rPresSettings.mbAlwaysOnTop = bVal;
 490             }
 491         }
 492         break;
 493     }
 494     case ATTR_PRESENT_NAVIGATOR:
 495     {
 496         sal_Bool bVal = sal_False;
 497
 498         if( aValue >>= bVal )
 499         {
 500             bIllegalArgument = false;
 501
 502             if( rPresSettings.mbStartWithNavigator != bVal)
 503             {
 504                 bValuesChanged = true;
 505                 rPresSettings.mbStartWithNavigator = bVal;
 506             }
 507         }
 508         break;
 509     }
 510     case ATTR_PRESENT_PEN:
 511     {
 512         sal_Bool bVal = sal_False;
 513
 514         if( aValue >>= bVal )
 515         {
 516             bIllegalArgument = false;
 517
 518             if(rPresSettings.mbMouseAsPen != bVal)
 519             {
 520                 bValuesChanged = true;
 521                 rPresSettings.mbMouseAsPen = bVal;
 522             }
 523         }
 524         break;
 525     }
 526     case ATTR_PRESENT_PAUSE_TIMEOUT:
 527     {
 528         sal_Int32 nValue = 0;
 529         if( (aValue >>= nValue) && (nValue >= 0) )
 530         {
 531             bIllegalArgument = false;
 532             if( rPresSettings.mnPauseTimeout != nValue )
 533             {
 534                 bValuesChanged = true;
 535                 rPresSettings.mnPauseTimeout = nValue;
 536             }
 537         }
 538         break;
 539     }
 540     case ATTR_PRESENT_SHOW_PAUSELOGO:
 541     {
 542         sal_Bool bVal = sal_False;
 543
 544         if( aValue >>= bVal )
 545         {
 546             bIllegalArgument = false;
 547
 548             if( rPresSettings.mbShowPauseLogo != bVal )
 549             {
 550                 bValuesChanged = true;
 551                 rPresSettings.mbShowPauseLogo = bVal;
 552             }
 553         }
 554         break;
 555     }
 556     case ATTR_PRESENT_DISPLAY:
 557     {
 558         sal_Int32 nDisplay = 0;
 559         if( aValue >>= nDisplay )
 560         {
 561             bIllegalArgument = false;
 562
 563             SdOptions* pOptions = SD_MOD()->GetSdOptions(DOCUMENT_TYPE_IMPRESS);
 564             pOptions->SetDisplay( nDisplay );
 565         }
 566         break;
 567     }
 568
 569     default:
 570         throw UnknownPropertyException();
 571     }
 572
 573     if( bIllegalArgument )
 574         throw IllegalArgumentException();
 575
 576     if( bValuesChanged )
 577         mpDoc->SetChanged( true );
 578 }
 579
 580 // --------------------------------------------------------------------
 581
 582 Any SAL_CALL SlideShow::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 583 {
 584     OGuard aGuard( Application::GetSolarMutex() );
 585     ThrowIfDisposed();
 586
 587     const sd::PresentationSettings& rPresSettings = mpDoc->getPresentationSettings();
 588
 589     const SfxItemPropertySimpleEntry* pEntry = maPropSet.getPropertyMapEntry(PropertyName);
 590
 591     switch( pEntry ? pEntry->nWID : -1 )
 592     {
 593     case ATTR_PRESENT_ALL:
 594         return Any( (sal_Bool) ( !rPresSettings.mbCustomShow && rPresSettings.mbAll ) );
 595     case ATTR_PRESENT_CHANGE_PAGE:
 596         return Any( (sal_Bool) !rPresSettings.mbLockedPages );
 597     case ATTR_PRESENT_ANIMATION_ALLOWED:
 598         return Any( rPresSettings.mbAnimationAllowed );
 599     case ATTR_PRESENT_CUSTOMSHOW:
 600         {
 601             List* pList = mpDoc->GetCustomShowList(sal_False);
 602             SdCustomShow* pShow = (pList && rPresSettings.mbCustomShow)?(SdCustomShow*)pList->GetCurObject():NULL;
 603             OUString aShowName;
 604
 605             if(pShow)
 606                 aShowName = pShow->GetName();
 607
 608             return Any( aShowName );
 609         }
 610     case ATTR_PRESENT_ENDLESS:
 611         return Any( rPresSettings.mbEndless );
 612     case ATTR_PRESENT_FULLSCREEN:
 613         return Any( rPresSettings.mbFullScreen );
 614     case ATTR_PRESENT_DIANAME:
 615         {
 616             OUString aSlideName;
 617
 618             if( !rPresSettings.mbCustomShow && !rPresSettings.mbAll )
 619                 aSlideName = getPageApiNameFromUiName( rPresSettings.maPresPage );
 620
 621             return Any( aSlideName );
 622         }
 623     case ATTR_PRESENT_MANUEL:
 624         return Any( rPresSettings.mbManual );
 625     case ATTR_PRESENT_MOUSE:
 626         return Any( rPresSettings.mbMouseVisible );
 627     case ATTR_PRESENT_ALWAYS_ON_TOP:
 628         return Any( rPresSettings.mbAlwaysOnTop );
 629     case ATTR_PRESENT_NAVIGATOR:
 630         return Any( rPresSettings.mbStartWithNavigator );
 631     case ATTR_PRESENT_PEN:
 632         return Any( rPresSettings.mbMouseAsPen );
 633     case ATTR_PRESENT_PAUSE_TIMEOUT:
 634         return Any( rPresSettings.mnPauseTimeout );
 635     case ATTR_PRESENT_SHOW_PAUSELOGO:
 636         return Any( rPresSettings.mbShowPauseLogo );
 637     case ATTR_PRESENT_DISPLAY:
 638     {
 639         SdOptions* pOptions = SD_MOD()->GetSdOptions(DOCUMENT_TYPE_IMPRESS);
 640         return Any( pOptions->GetDisplay() );
 641     }
 642
 643     default:
 644         throw UnknownPropertyException();
 645     }
 646 }
 647
 648 // --------------------------------------------------------------------
 649
 650 void SAL_CALL SlideShow::addPropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 651 {
 652 }
 653
 654 // --------------------------------------------------------------------
 655
 656 void SAL_CALL SlideShow::removePropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 657 {
 658 }
 659
 660 // --------------------------------------------------------------------
 661
 662 void SAL_CALL SlideShow::addVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 663 {
 664 }
 665
 666 // --------------------------------------------------------------------
 667
 668 void SAL_CALL SlideShow::removeVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 669 {
 670 }
 671
 672 // --------------------------------------------------------------------
 673 // XPresentation
 674 // --------------------------------------------------------------------
 675
 676 void SAL_CALL SlideShow::start() throw(RuntimeException)
 677 {
 678     const Sequence< PropertyValue > aArguments;
 679     startWithArguments( aArguments );
 680 }
 681
 682 // --------------------------------------------------------------------
 683
 684 void SAL_CALL SlideShow::end() throw(RuntimeException)
 685 {
 686     OGuard aGuard( Application::GetSolarMutex() );
 687
 688     // The mbIsInStartup flag should have been reset during the start of the
 689     // slide show.  Reset it here just in case that something has horribly
 690     // gone wrong.
 691     OSL_ASSERT(!mbIsInStartup);
 692     mbIsInStartup = false;
 693
 694     rtl::Reference< SlideshowImpl > xController( mxController );
 695     if( xController.is() )
 696     {
 697         mxController.clear();
 698
 699         if( mpFullScreenFrameView )
 700         {
 701             delete mpFullScreenFrameView;
 702             mpFullScreenFrameView = 0;
 703         }
 704
 705         ViewShellBase* pFullScreenViewShellBase = mpFullScreenViewShellBase;
 706         mpFullScreenViewShellBase = 0;
 707
 708         // dispose before fullscreen window changes screens
 709         // (potentially). If this needs to be moved behind
 710         // pWorkWindow->StartPresentationMode() again, read issue
 711         // pWorkWindow->i94007 & implement the solution outlined
 712         // there.
 713                 xController->dispose();
 714
 715         if( pFullScreenViewShellBase )
 716         {
 717             PresentationViewShell* pShell = dynamic_cast<PresentationViewShell*>(pFullScreenViewShellBase->GetMainViewShell().get());
 718
 719             if( pShell && pShell->GetViewFrame() &&  pShell->GetViewFrame()->GetTopFrame() )
 720             {
 721                 WorkWindow* pWorkWindow = dynamic_cast<WorkWindow*>(pShell->GetViewFrame()->GetTopFrame()->GetWindow().GetParent());
 722                 if( pWorkWindow )
 723                 {
 724                     pWorkWindow->StartPresentationMode( FALSE, isAlwaysOnTop() );
 725                 }
 726             }
 727         }
 728
 729         if( pFullScreenViewShellBase )
 730         {
 731             PresentationViewShell* pShell = NULL;
 732             {
 733                 // Get the shell pointer in its own scope to be sure that
 734                 // the shared_ptr to the shell is released before DoClose()
 735                 // is called.
 736                 ::boost::shared_ptr<ViewShell> pSharedView (pFullScreenViewShellBase->GetMainViewShell());
 737                 pShell = dynamic_cast<PresentationViewShell*>(pSharedView.get());
 738             }
 739             if( pShell && pShell->GetViewFrame() )
 740                 pShell->GetViewFrame()->DoClose();
 741         }
 742         else if( mpCurrentViewShellBase )
 743         {
 744             ViewShell* pViewShell = mpCurrentViewShellBase->GetMainViewShell().get();
 745
 746             if( pViewShell )
 747             {
 748                 FrameView* pFrameView = pViewShell->GetFrameView();
 749
 750                 if( pFrameView && (pFrameView->GetPresentationViewShellId() != SID_VIEWSHELL0) )
 751                 {
 752                     ViewShell::ShellType ePreviousType (pFrameView->GetPreviousViewShellType());
 753                     pFrameView->SetPreviousViewShellType(ViewShell::ST_NONE);
 754
 755                     pFrameView->SetPresentationViewShellId(SID_VIEWSHELL0);
 756                     pFrameView->SetSlotId(SID_OBJECT_SELECT);
 757                     pFrameView->SetPreviousViewShellType(pViewShell->GetShellType());
 758
 759                     framework::FrameworkHelper::Instance(*mpCurrentViewShellBase)->RequestView(
 760                         framework::FrameworkHelper::GetViewURL(ePreviousType),
 761                         framework::FrameworkHelper::msCenterPaneURL);
 762
 763                     pViewShell->GetViewFrame()->GetBindings().InvalidateAll( TRUE );
 764                 }
 765             }
 766         }
 767
 768         if( mpCurrentViewShellBase )
 769         {
 770             ViewShell* pViewShell = mpCurrentViewShellBase->GetMainViewShell().get();
 771             if( pViewShell )
 772             {
 773                 // invalidate the view shell so the presentation slot will be re-enabled
 774                 // and the rehersing will be updated
 775                 pViewShell->Invalidate();
 776
 777                 if( xController->meAnimationMode ==ANIMATIONMODE_SHOW )
 778                 {
 779                     // switch to the previously visible Slide
 780                     DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>( pViewShell );
 781                     if( pDrawViewShell )
 782                         pDrawViewShell->SwitchPage( (USHORT)xController->getRestoreSlide() );
 783                 }
 784
 785                 if( pViewShell->GetDoc()->IsStartWithPresentation() )
 786                 {
 787                     pViewShell->GetDoc()->SetStartWithPresentation( false );
 788
 789                     Reference<frame::XDispatchProvider> xProvider(pViewShell->GetViewShellBase().GetController()->getFrame(),
 790                                                                   UNO_QUERY);
 791                     if( xProvider.is() )
 792                     {
 793                         util::URL aURL;
 794                         aURL.Complete = ::rtl::OUString::createFromAscii(".uno:CloseFrame");
 795
 796                         uno::Reference< frame::XDispatch > xDispatch(
 797                             xProvider->queryDispatch(
 798                                 aURL, ::rtl::OUString(), 0));
 799                         if( xDispatch.is() )
 800                         {
 801                             xDispatch->dispatch(aURL,
 802                                                 uno::Sequence< beans::PropertyValue >());
 803                         }
 804                     }
 805                 }
 806             }
 807         }
 808         mpCurrentViewShellBase = 0;
 809     }
 810 }
 811
 812 // --------------------------------------------------------------------
 813
 814 void SAL_CALL SlideShow::rehearseTimings() throw(RuntimeException)
 815 {
 816     Sequence< PropertyValue > aArguments(1);
 817     aArguments[0].Name = C2U("RehearseTimings");
 818     aArguments[0].Value <<= sal_True;
 819     startWithArguments( aArguments );
 820 }
 821
 822 // --------------------------------------------------------------------
 823 // XPresentation2
 824 // --------------------------------------------------------------------
 825
 826 void SAL_CALL SlideShow::startWithArguments( const Sequence< PropertyValue >& rArguments ) throw (RuntimeException)
 827 {
 828     OGuard aGuard( Application::GetSolarMutex() );
 829     ThrowIfDisposed();
 830
 831     // Stop a running show before starting a new one.
 832     if( mxController.is() )
 833     {
 834         OSL_ASSERT(!mbIsInStartup);
 835         end();
 836     }
 837     else if (mbIsInStartup)
 838     {
 839         // We are already somewhere in process of starting a slide show but
 840         // have not yet got to the point where mxController is set.  There
 841         // is not yet a slide show to end so return silently.
 842         return;
 843     }
 844
 845     // Prevent multiple instance of the SlideShow class for one document.
 846     mbIsInStartup = true;
 847
 848     mxCurrentSettings.reset( new PresentationSettingsEx( mpDoc->getPresentationSettings() ) );
 849     mxCurrentSettings->SetArguments( rArguments );
 850
 851     // if there is no view shell base set, use the current one or the first using this document
 852     if( mpCurrentViewShellBase == 0 )
 853     {
 854         // first check current
 855         ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase( SfxViewFrame::Current() );
 856         if( pBase && pBase->GetDocument() == mpDoc )
 857         {
 858             mpCurrentViewShellBase = pBase;
 859         }
 860         else
 861         {
 862             // current is not ours, so get first from ours
 863             mpCurrentViewShellBase = ::sd::ViewShellBase::GetViewShellBase( SfxViewFrame::GetFirst( mpDoc->GetDocSh() ) );
 864         }
 865     }
 866
 867     // Start either a full-screen or an in-place show.
 868     if(mxCurrentSettings->mbFullScreen && !mxCurrentSettings->mbPreview)
 869         StartFullscreenPresentation();
 870     else
 871         StartInPlacePresentation();
 872 }
 873
 874 // --------------------------------------------------------------------
 875
 876 ::sal_Bool SAL_CALL SlideShow::isRunning(  ) throw (RuntimeException)
 877 {
 878     OGuard aGuard( Application::GetSolarMutex() );
 879     return mxController.is() && mxController->isRunning();
 880 }
 881
 882 // --------------------------------------------------------------------
 883
 884 Reference< XSlideShowController > SAL_CALL SlideShow::getController(  ) throw (RuntimeException)
 885 {
 886     ThrowIfDisposed();
 887
 888     Reference< XSlideShowController > xController( mxController.get() );
 889     return xController;
 890 }
 891
 892 // --------------------------------------------------------------------
 893 // XComponent
 894 // --------------------------------------------------------------------
 895
 896 void SAL_CALL SlideShow::disposing (void)
 897 {
 898     OGuard aGuard( Application::GetSolarMutex() );
 899
 900     if( mnInPlaceConfigEvent )
 901     {
 902         Application::RemoveUserEvent( mnInPlaceConfigEvent );
 903         mnInPlaceConfigEvent = 0;
 904     }
 905
 906     if( mxController.is() )
 907     {
 908         mxController->dispose();
 909         mxController.clear();
 910     }
 911
 912     mpCurrentViewShellBase = 0;
 913     mpFullScreenViewShellBase = 0;
 914     mpDoc = 0;
 915 }
 916
 917 // ---------------------------------------------------------
 918
 919 bool SlideShow::startPreview( const Reference< XDrawPage >& xDrawPage, const Reference< XAnimationNode >& xAnimationNode, ::Window* pParent )
 920 {
 921     Sequence< PropertyValue > aArguments(4);
 922
 923     aArguments[0].Name = C2U("Preview");
 924     aArguments[0].Value <<= sal_True;
 925
 926     aArguments[1].Name = C2U("FirstPage");
 927     aArguments[1].Value <<= xDrawPage;
 928
 929     aArguments[2].Name = C2U("AnimationNode");
 930     aArguments[2].Value <<= xAnimationNode;
 931
 932     Reference< XWindow > xParentWindow;
 933     if( pParent )
 934         xParentWindow = VCLUnoHelper::GetInterface( pParent );
 935
 936     aArguments[3].Name = C2U("ParentWindow");
 937     aArguments[3].Value <<= xParentWindow;
 938
 939     startWithArguments( aArguments );
 940
 941     return true;
 942 }
 943
 944 // ---------------------------------------------------------
 945
 946 ShowWindow* SlideShow::getShowWindow()
 947 {
 948     return mxController.is() ? mxController->mpShowWindow : 0;
 949 }
 950
 951 // ---------------------------------------------------------
 952
 953 int SlideShow::getAnimationMode()
 954 {
 955     return mxController.is() ? mxController->meAnimationMode : ANIMATIONMODE_SHOW;
 956 }
 957
 958 // ---------------------------------------------------------
 959
 960 void SlideShow::jumpToPageIndex( sal_Int32 nPageIndex )
 961 {
 962     if( mxController.is() )
 963         mxController->displaySlideIndex( nPageIndex );
 964 }
 965
 966 // ---------------------------------------------------------
 967
 968 void SlideShow::jumpToPageNumber( sal_Int32 nPageNumber )
 969 {
 970     if( mxController.is() )
 971         mxController->displaySlideNumber( nPageNumber );
 972 }
 973
 974 // ---------------------------------------------------------
 975
 976 sal_Int32 SlideShow::getCurrentPageNumber()
 977 {
 978     return mxController.is() ? mxController->getCurrentSlideNumber() : 0;
 979 }
 980
 981 // ---------------------------------------------------------
 982
 983 sal_Int32 SlideShow::getCurrentPageIndex()
 984 {
 985     return mxController.is() ? mxController->getCurrentSlideIndex() : 0;
 986 }
 987
 988 // ---------------------------------------------------------
 989
 990 void SlideShow::jumpToBookmark( const OUString& sBookmark )
 991 {
 992     if( mxController.is() )
 993         mxController->jumpToBookmark( sBookmark );
 994 }
 995
 996 // ---------------------------------------------------------
 997
 998 bool SlideShow::isFullScreen()
 999 {
1000     return mxController.is() ? mxController->maPresSettings.mbFullScreen : false;
1001 }
1002
1003 // ---------------------------------------------------------
1004
1005 void SlideShow::resize( const Size &rSize )
1006 {
1007     if( mxController.is() )
1008         mxController->resize( rSize );
1009 }
1010
1011 // ---------------------------------------------------------
1012
1013 void SlideShow::activate( ViewShellBase& rBase )
1014 {
1015     if( (mpFullScreenViewShellBase == &rBase) && !mxController.is() )
1016     {
1017         ::boost::shared_ptr<PresentationViewShell> pShell = ::boost::dynamic_pointer_cast<PresentationViewShell>(rBase.GetMainViewShell());
1018         if(pShell.get() != NULL)
1019         {
1020             pShell->FinishInitialization( mpFullScreenFrameView );
1021             mpFullScreenFrameView = 0;
1022
1023             CreateController( pShell.get(), pShell->GetView(), rBase.GetViewWindow() );
1024
1025             if( mxController->startShow(mxCurrentSettings.get()) )
1026             {
1027                 pShell->Resize();
1028             }
1029             else
1030             {
1031                 end();
1032                 return;
1033             }
1034         }
1035     }
1036
1037     if( mxController.is() )
1038         mxController->activate();
1039 }
1040
1041 // ---------------------------------------------------------
1042
1043 void SlideShow::deactivate( ViewShellBase& /*rBase*/ )
1044 {
1045     mxController->deactivate();
1046 }
1047
1048 // ---------------------------------------------------------
1049
1050 bool SlideShow::keyInput(const KeyEvent& rKEvt)
1051 {
1052     return mxController.is() ? mxController->keyInput(rKEvt) : false;
1053 }
1054
1055 // ---------------------------------------------------------
1056
1057 void SlideShow::paint( const Rectangle& rRect )
1058 {
1059     if( mxController.is() )
1060         mxController->paint( rRect );
1061 }
1062
1063 // ---------------------------------------------------------
1064
1065 bool SlideShow::isAlwaysOnTop()
1066 {
1067     return mxController.is() ? mxController->maPresSettings.mbAlwaysOnTop : false;
1068 }
1069
1070 // ---------------------------------------------------------
1071
1072 bool SlideShow::pause( bool bPause )
1073 {
1074     if( mxController.is() )
1075     {
1076         if( bPause )
1077             mxController->pause();
1078         else
1079             mxController->resume();
1080     }
1081     return true;
1082 }
1083
1084 // ---------------------------------------------------------
1085
1086 void SlideShow::receiveRequest(SfxRequest& rReq)
1087 {
1088     if( mxController.is() )
1089         mxController->receiveRequest( rReq );
1090 }
1091
1092 // ---------------------------------------------------------
1093
1094 sal_Int32 SlideShow::getFirstPageNumber()
1095 {
1096     return mxController.is() ? mxController->getFirstSlideNumber() : 0;
1097 }
1098
1099 // ---------------------------------------------------------
1100
1101 sal_Int32 SlideShow::getLastPageNumber()
1102 {
1103     return mxController.is() ? mxController->getLastSlideNumber() : 0;
1104 }
1105
1106 // ---------------------------------------------------------
1107
1108 bool SlideShow::isEndless()
1109 {
1110     return mxController.is() ? mxController->isEndless() : false;
1111 }
1112
1113 // ---------------------------------------------------------
1114
1115 bool SlideShow::isDrawingPossible()
1116 {
1117     return mxController.is() ? mxController->getUsePen() : false;
1118 }
1119
1120 // ---------------------------------------------------------
1121
1122 void SlideShow::StartInPlacePresentationConfigurationCallback()
1123 {
1124     if( mnInPlaceConfigEvent != 0 )
1125         Application::RemoveUserEvent( mnInPlaceConfigEvent );
1126
1127     mnInPlaceConfigEvent = Application::PostUserEvent( LINK( this, SlideShow, StartInPlacePresentationConfigurationHdl ) );
1128 }
1129
1130 // ---------------------------------------------------------
1131
1132 IMPL_LINK( SlideShow, StartInPlacePresentationConfigurationHdl, void *, EMPTYARG )
1133 {
1134     mnInPlaceConfigEvent = 0;
1135     StartInPlacePresentation();
1136     return 0;
1137 }
1138
1139 // ---------------------------------------------------------
1140
1141 void SlideShow::StartInPlacePresentation()
1142 {
1143     if( mpCurrentViewShellBase )
1144     {
1145         // Save the current view shell type so that it can be restored after the
1146         // show has ended.  If there already is a saved shell type then that is
1147         // not overwritten.
1148
1149         ViewShell::ShellType eShell = ViewShell::ST_NONE;
1150
1151         ::boost::shared_ptr<FrameworkHelper> pHelper(FrameworkHelper::Instance(*mpCurrentViewShellBase));
1152         ::boost::shared_ptr<ViewShell> pMainViewShell(pHelper->GetViewShell(FrameworkHelper::msCenterPaneURL));
1153
1154         if( pMainViewShell.get() )
1155             eShell = pMainViewShell->GetShellType();
1156
1157         if( eShell != ViewShell::ST_IMPRESS )
1158         {
1159             // Switch temporary to a DrawViewShell which supports the in-place presentation.
1160
1161             if( pMainViewShell.get() )
1162             {
1163                 FrameView* pFrameView = pMainViewShell->GetFrameView();
1164                 pFrameView->SetPresentationViewShellId(SID_VIEWSHELL1);
1165                 pFrameView->SetPreviousViewShellType (pMainViewShell->GetShellType());
1166                 pFrameView->SetPageKind (PK_STANDARD);
1167             }
1168
1169             pHelper->RequestView( FrameworkHelper::msImpressViewURL, FrameworkHelper::msCenterPaneURL );
1170             pHelper->RunOnConfigurationEvent( FrameworkHelper::msConfigurationUpdateEndEvent, ::boost::bind(&SlideShow::StartInPlacePresentationConfigurationCallback, this) );
1171             return;
1172         }
1173         else
1174         {
1175             ::Window* pParentWindow = mxCurrentSettings->mpParentWindow;
1176             if( pParentWindow == 0 )
1177                 pParentWindow = mpCurrentViewShellBase->GetViewWindow();
1178
1179             CreateController( pMainViewShell.get(), pMainViewShell->GetView(), pParentWindow );
1180         }
1181     }
1182     else if( mxCurrentSettings->mpParentWindow )
1183     {
1184         // no current view shell, but parent window
1185         CreateController( 0, 0, mxCurrentSettings->mpParentWindow );
1186     }
1187
1188     if( mxController.is() )
1189     {
1190         sal_Bool bSuccess = sal_False;
1191         if( mxCurrentSettings.get() && mxCurrentSettings->mbPreview )
1192         {
1193             bSuccess = mxController->startPreview(mxCurrentSettings->mxStartPage, mxCurrentSettings->mxAnimationNode, mxCurrentSettings->mpParentWindow );
1194         }
1195         else
1196         {
1197             bSuccess = mxController->startShow(mxCurrentSettings.get());
1198         }
1199
1200         if( !bSuccess )
1201             end();
1202     }
1203 }
1204
1205 // ---------------------------------------------------------
1206
1207 void SlideShow::StartFullscreenPresentation( )
1208 {
1209     // Create the top level window in which the PresentationViewShell(Base)
1210     // will be created.  This is done here explicitly so that we can make it
1211     // fullscreen.
1212     const sal_Int32 nDisplay (GetDisplay());
1213     WorkWindow* pWorkWindow = new FullScreenWorkWindow(this, mpCurrentViewShellBase);
1214     pWorkWindow->StartPresentationMode( TRUE, mpDoc->getPresentationSettings().mbAlwaysOnTop ? PRESENTATION_HIDEALLAPPS : 0, nDisplay);
1215     //    pWorkWindow->ShowFullScreenMode(FALSE, nDisplay);
1216     pWorkWindow->SetBackground(Wallpaper(COL_BLACK));
1217
1218     if (pWorkWindow->IsVisible())
1219     {
1220         // Initialize the new presentation view shell with a copy of the
1221         // frame view of the current view shell.  This avoids that
1222         // changes made by the presentation have an effect on the other
1223         // view shells.
1224         FrameView* pOriginalFrameView = mpCurrentViewShellBase ? mpCurrentViewShellBase->GetMainViewShell()->GetFrameView() : 0;
1225
1226         if( mpFullScreenFrameView )
1227             delete mpFullScreenFrameView;
1228         mpFullScreenFrameView = new FrameView(mpDoc, pOriginalFrameView);
1229
1230 //          Reference<XController> xController;
1231
1232         // The new frame is created hidden.  To make it visible and activate the
1233         // new view shell--a prerequisite to process slot calls and initialize
1234         // its panes--a GrabFocus() has to be called later on.
1235         SfxTopFrame* pNewFrame = SfxTopFrame::Create( mpDoc->GetDocSh(), pWorkWindow, PRESENTATION_FACTORY_ID, TRUE);
1236         pNewFrame->SetPresentationMode(TRUE);
1237
1238         mpFullScreenViewShellBase = static_cast<ViewShellBase*>(pNewFrame->GetCurrentViewFrame()->GetViewShell());
1239         if(mpFullScreenViewShellBase != NULL)
1240         {
1241             // The following GrabFocus() is responsible for activating the
1242             // new view shell.  Without it the screen remains blank (under
1243             // Windows and some Linux variants.)
1244             mpFullScreenViewShellBase->GetWindow()->GrabFocus();
1245         }
1246     }
1247 }
1248
1249 // ---------------------------------------------------------
1250
1251 sal_Int32 SlideShow::GetDisplay()
1252
1253 {
1254     sal_Int32 nDisplay = 0;
1255
1256     SdOptions* pOptions = SD_MOD()->GetSdOptions(DOCUMENT_TYPE_IMPRESS);
1257     if( pOptions )
1258         nDisplay = pOptions->GetDisplay();
1259
1260     if (nDisplay <= 0 )
1261     {
1262         try
1263         {
1264             Reference<XMultiServiceFactory > xFactory(
1265                 ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW);
1266             Reference<XPropertySet> xMonitorProperties(
1267                 xFactory->createInstance(
1268                     OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.DisplayAccess"))),
1269                 UNO_QUERY_THROW);
1270             const OUString sPropertyName (RTL_CONSTASCII_USTRINGPARAM("DefaultDisplay"));
1271             xMonitorProperties->getPropertyValue(sPropertyName) >>= nDisplay;
1272         }
1273         catch( Exception& )
1274         {
1275         }
1276     }
1277     else
1278     {
1279         nDisplay--;
1280     }
1281
1282     return nDisplay;
1283 }
1284
1285 // ---------------------------------------------------------
1286
1287
1288 bool SlideShow::dependsOn( ViewShellBase* pViewShellBase )
1289 {
1290     return mxController.is() && (pViewShellBase == mpCurrentViewShellBase) && mpFullScreenViewShellBase;
1291 }
1292
1293 // ---------------------------------------------------------
1294
1295 Reference< XPresentation2 > CreatePresentation( const SdDrawDocument& rDocument )
1296 {
1297     return Reference< XPresentation2 >( SlideShow::Create( const_cast< SdDrawDocument* >( &rDocument ) ).get() );
1298 }
1299
1300 // ---------------------------------------------------------
1301