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