sd/source/ui/slideshow/slideshow.cxx

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