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