sd/source/ui/slideshow/slideshow.cxx

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