?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 6.1.0.2, tag libreoffice-6.1.0.2
[LibreOffice.git] / sd / source / ui / slideshow / slideshowimpl.cxx
blob0ab2165262e3a51efa0892b03cdb0b258be792de
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 <config_features.h>
21
22 #include <com/sun/star/frame/theAutoRecovery.hpp>
23 #include <com/sun/star/lang/XInitialization.hpp>
24 #include <com/sun/star/document/XEventsSupplier.hpp>
25 #include <com/sun/star/drawing/XMasterPageTarget.hpp>
26 #include <com/sun/star/container/XNameReplace.hpp>
27 #include <com/sun/star/beans/PropertyValue.hpp>
28 #include <com/sun/star/beans/XPropertySetInfo.hpp>
29 #include <com/sun/star/beans/XPropertySet.hpp>
30 #include <com/sun/star/awt/SystemPointer.hpp>
31 #include <com/sun/star/util/URLTransformer.hpp>
32 #include <com/sun/star/util/XURLTransformer.hpp>
33 #include <com/sun/star/frame/XDispatch.hpp>
34 #include <com/sun/star/frame/XLayoutManager.hpp>
35 #include <com/sun/star/presentation/SlideShow.hpp>
36 #include <svl/aeitem.hxx>
37 #include <svl/urihelper.hxx>
38
39 #include <toolkit/helper/vclunohelper.hxx>
40
41 #include <sfx2/infobar.hxx>
42 #include <sfx2/request.hxx>
43 #include <sfx2/docfile.hxx>
44 #include <sfx2/app.hxx>
45 #include <svx/unoapi.hxx>
46 #include <svx/svdoole2.hxx>
47 #include <sfx2/templdlg.hxx>
48 #include <svx/f3dchild.hxx>
49 #include <svx/imapdlg.hxx>
50 #include <svx/fontwork.hxx>
51 #include <svx/SvxColorChildWindow.hxx>
52 #include <svx/bmpmask.hxx>
53 #include <svx/srchdlg.hxx>
54 #include <svx/hyperdlg.hxx>
55 #include <AnimationChildWindow.hxx>
56 #include <notifydocumentevent.hxx>
57 #include "slideshowimpl.hxx"
58 #include "slideshowviewimpl.hxx"
59 #include <pgjump.hxx>
60 #include "PaneHider.hxx"
61
62 #include <bitmaps.hlst>
63 #include <vcl/canvastools.hxx>
64 #include <vcl/commandinfoprovider.hxx>
65 #include <vcl/settings.hxx>
66
67 #include <comphelper/anytostring.hxx>
68 #include <cppuhelper/exc_hlp.hxx>
69 #include <rtl/ref.hxx>
70 #include <canvas/elapsedtime.hxx>
71 #include <avmedia/mediawindow.hxx>
72 #include <svtools/colrdlg.hxx>
73 #include <RemoteServer.hxx>
74 #include <customshowlist.hxx>
75 #include <unopage.hxx>
76
77 #define CM_SLIDES 21
78
79 using ::com::sun::star::animations::XAnimationNode;
80 using ::com::sun::star::animations::XAnimationListener;
81 using ::com::sun::star::awt::XWindow;
82 using namespace ::com::sun::star;
83 using namespace ::com::sun::star::lang;
84 using namespace ::com::sun::star::uno;
85 using namespace ::com::sun::star::drawing;
86 using namespace ::com::sun::star::container;
87 using namespace ::com::sun::star::document;
88 using namespace ::com::sun::star::presentation;
89 using namespace ::com::sun::star::beans;
90
91 namespace sd
92 {
93 /** Slots, which will be disabled in the slide show and are managed by Sfx.
94 Have to be sorted in the order of the SIDs */
95 static sal_uInt16 const pAllowed[] =
96 {
97 SID_OPENDOC , // 5501 ///< that internally jumps work
98 SID_JUMPTOMARK , // 5598
99 SID_OPENHYPERLINK , // 6676
100 SID_PRESENTATION_END // 27218
101 };
102
103 class AnimationSlideController
104 {
105 public:
106 enum Mode { ALL, FROM, CUSTOM, PREVIEW };
107
108 public:
109 AnimationSlideController( Reference< XIndexAccess > const & xSlides, Mode eMode );
110
111 void setStartSlideNumber( sal_Int32 nSlideNumber ) { mnStartSlideNumber = nSlideNumber; }
112 sal_Int32 getStartSlideIndex() const;
113
114 sal_Int32 getCurrentSlideNumber() const;
115 sal_Int32 getCurrentSlideIndex() const;
116
117 sal_Int32 getSlideIndexCount() const { return maSlideNumbers.size(); }
118 sal_Int32 getSlideNumberCount() const { return mnSlideCount; }
119
120 sal_Int32 getSlideNumber( sal_Int32 nSlideIndex ) const;
121
122 void insertSlideNumber( sal_Int32 nSlideNumber, bool bVisible = true );
123 void setPreviewNode( const Reference< XAnimationNode >& xPreviewNode );
124
125 bool jumpToSlideIndex( sal_Int32 nNewSlideIndex );
126 bool jumpToSlideNumber( sal_Int32 nNewSlideIndex );
127
128 bool nextSlide();
129 bool previousSlide();
130
131 void displayCurrentSlide( const Reference< XSlideShow >& xShow,
132 const Reference< XDrawPagesSupplier>& xDrawPages,
133 const bool bSkipAllMainSequenceEffects );
134
135 sal_Int32 getNextSlideIndex() const;
136 sal_Int32 getPreviousSlideIndex() const;
137
138 bool isVisibleSlideNumber( sal_Int32 nSlideNumber ) const;
139
140 Reference< XDrawPage > getSlideByNumber( sal_Int32 nSlideNumber ) const;
141
142 sal_Int32 getNextSlideNumber() const;
143
144 bool hasSlides() const { return !maSlideNumbers.empty(); }
145
146 private:
147 bool getSlideAPI( sal_Int32 nSlideNumber, Reference< XDrawPage >& xSlide, Reference< XAnimationNode >& xAnimNode );
148 sal_Int32 findSlideIndex( sal_Int32 nSlideNumber ) const;
149
150 bool isValidIndex( sal_Int32 nIndex ) const { return (nIndex >= 0) && (nIndex < static_cast<sal_Int32>(maSlideNumbers.size())); }
151 bool isValidSlideNumber( sal_Int32 nSlideNumber ) const { return (nSlideNumber >= 0) && (nSlideNumber < mnSlideCount); }
152
153 private:
154 Mode meMode;
155 sal_Int32 mnStartSlideNumber;
156 std::vector< sal_Int32 > maSlideNumbers;
157 std::vector< bool > maSlideVisible;
158 std::vector< bool > maSlideVisited;
159 Reference< XAnimationNode > mxPreviewNode;
160 sal_Int32 mnSlideCount;
161 sal_Int32 mnCurrentSlideIndex;
162 sal_Int32 mnHiddenSlideNumber;
163 Reference< XIndexAccess > mxSlides;
164 };
165
166 Reference< XDrawPage > AnimationSlideController::getSlideByNumber( sal_Int32 nSlideNumber ) const
167 {
168 Reference< XDrawPage > xSlide;
169 if( mxSlides.is() && (nSlideNumber >= 0) && (nSlideNumber < mxSlides->getCount()) )
170 mxSlides->getByIndex( nSlideNumber ) >>= xSlide;
171 return xSlide;
172 }
173
174 bool AnimationSlideController::isVisibleSlideNumber( sal_Int32 nSlideNumber ) const
175 {
176 sal_Int32 nIndex = findSlideIndex( nSlideNumber );
177
178 if( nIndex != -1 )
179 return maSlideVisible[ nIndex ];
180 else
181 return false;
182 }
183
184 void AnimationSlideController::setPreviewNode( const Reference< XAnimationNode >& xPreviewNode )
185 {
186 mxPreviewNode = xPreviewNode;
187 }
188
189 AnimationSlideController::AnimationSlideController( Reference< XIndexAccess > const & xSlides, Mode eMode )
190 : meMode( eMode )
191 , mnStartSlideNumber(-1)
192 , mnSlideCount( 0 )
193 , mnCurrentSlideIndex(0)
194 , mnHiddenSlideNumber( -1 )
195 , mxSlides( xSlides )
196 {
197 if( mxSlides.is() )
198 mnSlideCount = xSlides->getCount();
199 }
200
201 sal_Int32 AnimationSlideController::getStartSlideIndex() const
202 {
203 if( mnStartSlideNumber >= 0 )
204 {
205 sal_Int32 nIndex;
206 const sal_Int32 nCount = maSlideNumbers.size();
207
208 for( nIndex = 0; nIndex < nCount; nIndex++ )
209 {
210 if( maSlideNumbers[nIndex] == mnStartSlideNumber )
211 return nIndex;
212 }
213 }
214
215 return 0;
216 }
217
218 sal_Int32 AnimationSlideController::getCurrentSlideNumber() const
219 {
220 if( mnHiddenSlideNumber != -1 )
221 return mnHiddenSlideNumber;
222 else if( !maSlideNumbers.empty() )
223 return maSlideNumbers[mnCurrentSlideIndex];
224 else
225 return 0;
226 }
227
228 sal_Int32 AnimationSlideController::getCurrentSlideIndex() const
229 {
230 if( mnHiddenSlideNumber != -1 )
231 return -1;
232 else
233 return mnCurrentSlideIndex;
234 }
235
236 bool AnimationSlideController::jumpToSlideIndex( sal_Int32 nNewSlideIndex )
237 {
238 if( isValidIndex( nNewSlideIndex ) )
239 {
240 mnCurrentSlideIndex = nNewSlideIndex;
241 mnHiddenSlideNumber = -1;
242 maSlideVisited[mnCurrentSlideIndex] = true;
243 return true;
244 }
245 else
246 {
247 return false;
248 }
249 }
250
251 bool AnimationSlideController::jumpToSlideNumber( sal_Int32 nNewSlideNumber )
252 {
253 sal_Int32 nIndex = findSlideIndex( nNewSlideNumber );
254 if( isValidIndex( nIndex ) )
255 {
256 return jumpToSlideIndex( nIndex );
257 }
258 else if( (nNewSlideNumber >= 0) && (nNewSlideNumber < mnSlideCount) )
259 {
260 // jump to a hidden slide
261 mnHiddenSlideNumber = nNewSlideNumber;
262 return true;
263 }
264 else
265 {
266 return false;
267 }
268 }
269
270 sal_Int32 AnimationSlideController::getSlideNumber( sal_Int32 nSlideIndex ) const
271 {
272 if( isValidIndex( nSlideIndex ) )
273 return maSlideNumbers[nSlideIndex];
274 else
275 return -1;
276 }
277
278 void AnimationSlideController::insertSlideNumber( sal_Int32 nSlideNumber, bool bVisible /* = true */ )
279 {
280 DBG_ASSERT( isValidSlideNumber( nSlideNumber ), "sd::AnimationSlideController::insertSlideNumber(), illegal index" );
281 if( isValidSlideNumber( nSlideNumber ) )
282 {
283 maSlideNumbers.push_back( nSlideNumber );
284 maSlideVisible.push_back( bVisible );
285 maSlideVisited.push_back( false );
286 }
287 }
288
289 bool AnimationSlideController::getSlideAPI( sal_Int32 nSlideNumber, Reference< XDrawPage >& xSlide, Reference< XAnimationNode >& xAnimNode )
290 {
291 if( isValidSlideNumber( nSlideNumber ) ) try
292 {
293 xSlide.set( mxSlides->getByIndex(nSlideNumber), UNO_QUERY_THROW );
294
295 if( meMode == PREVIEW )
296 {
297 xAnimNode = mxPreviewNode;
298 }
299 else
300 {
301 Reference< animations::XAnimationNodeSupplier > xAnimNodeSupplier( xSlide, UNO_QUERY_THROW );
302 xAnimNode = xAnimNodeSupplier->getAnimationNode();
303 }
304
305 return true;
306 }
307 catch( Exception& )
308 {
309 SAL_WARN( "sd", "sd::AnimationSlideController::getSlideAPI(), "
310 "exception caught: "
311 << comphelper::anyToString( cppu::getCaughtException() ) );
312 }
313
314 return false;
315 }
316
317 sal_Int32 AnimationSlideController::findSlideIndex( sal_Int32 nSlideNumber ) const
318 {
319 sal_Int32 nIndex;
320 const sal_Int32 nCount = maSlideNumbers.size();
321
322 for( nIndex = 0; nIndex < nCount; nIndex++ )
323 {
324 if( maSlideNumbers[nIndex] == nSlideNumber )
325 return nIndex;
326 }
327
328 return -1;
329 }
330
331 sal_Int32 AnimationSlideController::getNextSlideIndex() const
332 {
333 switch( meMode )
334 {
335 case ALL:
336 {
337 sal_Int32 nNewSlideIndex = mnCurrentSlideIndex + 1;
338 if( isValidIndex( nNewSlideIndex ) )
339 {
340 // if the current slide is not excluded, make sure the
341 // next slide is also not excluded.
342 // if the current slide is excluded, we want to go
343 // to the next slide, even if this is also excluded.
344 if( maSlideVisible[mnCurrentSlideIndex] )
345 {
346 while( isValidIndex( nNewSlideIndex ) )
347 {
348 if( maSlideVisible[nNewSlideIndex] )
349 break;
350
351 nNewSlideIndex++;
352 }
353 }
354 }
355 return isValidIndex( nNewSlideIndex ) ? nNewSlideIndex : -1;
356 }
357
358 case FROM:
359 case CUSTOM:
360 return mnHiddenSlideNumber == -1 ? mnCurrentSlideIndex + 1 : mnCurrentSlideIndex;
361
362 default:
363 case PREVIEW:
364 return -1;
365
366 }
367 }
368
369 sal_Int32 AnimationSlideController::getNextSlideNumber() const
370 {
371 sal_Int32 nNextSlideIndex = getNextSlideIndex();
372 if( isValidIndex( nNextSlideIndex ) )
373 {
374 return maSlideNumbers[nNextSlideIndex];
375 }
376 else
377 {
378 return -1;
379 }
380 }
381
382 bool AnimationSlideController::nextSlide()
383 {
384 return jumpToSlideIndex( getNextSlideIndex() );
385 }
386
387 sal_Int32 AnimationSlideController::getPreviousSlideIndex() const
388 {
389 sal_Int32 nNewSlideIndex = mnCurrentSlideIndex - 1;
390
391 switch( meMode )
392 {
393 case ALL:
394 {
395 // make sure the previous slide is visible
396 // or was already visited
397 while( isValidIndex( nNewSlideIndex ) )
398 {
399 if( maSlideVisible[nNewSlideIndex] || maSlideVisited[nNewSlideIndex] )
400 break;
401
402 nNewSlideIndex--;
403 }
404
405 break;
406 }
407
408 case PREVIEW:
409 return -1;
410
411 default:
412 break;
413 }
414
415 return nNewSlideIndex;
416 }
417
418 bool AnimationSlideController::previousSlide()
419 {
420 return jumpToSlideIndex( getPreviousSlideIndex() );
421 }
422
423 void AnimationSlideController::displayCurrentSlide( const Reference< XSlideShow >& xShow,
424 const Reference< XDrawPagesSupplier>& xDrawPages,
425 const bool bSkipAllMainSequenceEffects )
426 {
427 const sal_Int32 nCurrentSlideNumber = getCurrentSlideNumber();
428
429 if( xShow.is() && (nCurrentSlideNumber != -1 ) )
430 {
431 Reference< XDrawPage > xSlide;
432 Reference< XAnimationNode > xAnimNode;
433 ::std::vector<PropertyValue> aProperties;
434
435 const sal_Int32 nNextSlideNumber = getNextSlideNumber();
436 if( getSlideAPI( nNextSlideNumber, xSlide, xAnimNode ) )
437 {
438 Sequence< Any > aValue(2);
439 aValue[0] <<= xSlide;
440 aValue[1] <<= xAnimNode;
441 aProperties.emplace_back( "Prefetch" ,
442 -1,
443 Any(aValue),
444 PropertyState_DIRECT_VALUE);
445 }
446 if (bSkipAllMainSequenceEffects)
447 {
448 // Add one property that prevents the slide transition from being
449 // shown (to speed up the transition to the previous slide) and
450 // one to show all main sequence effects so that the user can
451 // continue to undo effects.
452 aProperties.emplace_back( "SkipAllMainSequenceEffects",
453 -1,
454 Any(true),
455 PropertyState_DIRECT_VALUE);
456 aProperties.emplace_back("SkipSlideTransition",
457 -1,
458 Any(true),
459 PropertyState_DIRECT_VALUE);
460 }
461
462 if( getSlideAPI( nCurrentSlideNumber, xSlide, xAnimNode ) )
463 xShow->displaySlide( xSlide, xDrawPages, xAnimNode, comphelper::containerToSequence(aProperties) );
464 }
465 }
466
467 SlideshowImpl::SlideshowImpl( const Reference< XPresentation2 >& xPresentation, ViewShell* pViewSh, ::sd::View* pView, SdDrawDocument* pDoc, vcl::Window* pParentWindow )
468 : SlideshowImplBase( m_aMutex )
469 , mxModel(pDoc->getUnoModel(),UNO_QUERY_THROW)
470 , mpView(pView)
471 , mpViewShell(pViewSh)
472 , mpDocSh(pDoc->GetDocSh())
473 , mpDoc(pDoc)
474 , mpParentWindow(pParentWindow)
475 , mpShowWindow(nullptr)
476 , mpTimeButton(nullptr)
477 , mnRestoreSlide(0)
478 , maPresSize( -1, -1 )
479 , meAnimationMode(ANIMATIONMODE_SHOW)
480 , mpOldActiveWindow(nullptr)
481 , mnChildMask( 0 )
482 , mbDisposed(false)
483 , mbAutoSaveWasOn(false)
484 , mbRehearseTimings(false)
485 , mbIsPaused(false)
486 , mbWasPaused(false)
487 , mbInputFreeze(false)
488 , mbActive(false)
489 , maPresSettings( pDoc->getPresentationSettings() )
490 , mnUserPaintColor( 0x80ff0000L )
491 , mbUsePen(false)
492 , mdUserPaintStrokeWidth ( 150.0 )
493 , msOnClick( "OnClick" )
494 , msBookmark( "Bookmark" )
495 , msVerb( "Verb" )
496 , mnEndShowEvent(nullptr)
497 , mnContextMenuEvent(nullptr)
498 , mxPresentation( xPresentation )
499 {
500 if( mpViewShell )
501 mpOldActiveWindow = mpViewShell->GetActiveWindow();
502
503 maUpdateTimer.SetInvokeHandler(LINK(this, SlideshowImpl, updateHdl));
504 // Priority must not be too high or we'll starve input handling etc.
505 maUpdateTimer.SetPriority(TaskPriority::REPAINT);
506
507 maDeactivateTimer.SetInvokeHandler(LINK(this, SlideshowImpl, deactivateHdl));
508 maDeactivateTimer.SetTimeout( 20 );
509
510 maInputFreezeTimer.SetInvokeHandler( LINK( this, SlideshowImpl, ReadyForNextInputHdl ) );
511 maInputFreezeTimer.SetTimeout( 20 );
512
513 SvtSaveOptions aOptions;
514
515 // no autosave during show
516 if( aOptions.IsAutoSave() )
517 mbAutoSaveWasOn = true;
518
519 Application::AddEventListener( LINK( this, SlideshowImpl, EventListenerHdl ) );
520
521 mbUsePen = maPresSettings.mbMouseAsPen;
522
523 SdOptions* pOptions = SD_MOD()->GetSdOptions(DocumentType::Impress);
524 if( pOptions )
525 {
526 mnUserPaintColor = pOptions->GetPresentationPenColor();
527 mdUserPaintStrokeWidth = pOptions->GetPresentationPenWidth();
528 }
529 }
530
531 SlideshowImpl::~SlideshowImpl()
532 {
533 SdModule *pModule = SD_MOD();
534 //rhbz#806663 SlideshowImpl can outlive SdModule
535 SdOptions* pOptions = pModule ?
536 pModule->GetSdOptions(DocumentType::Impress) : nullptr;
537 if( pOptions )
538 {
539 pOptions->SetPresentationPenColor(mnUserPaintColor);
540 pOptions->SetPresentationPenWidth(mdUserPaintStrokeWidth);
541 }
542
543 Application::RemoveEventListener( LINK( this, SlideshowImpl, EventListenerHdl ) );
544
545 maDeactivateTimer.Stop();
546
547 if( !mbDisposed )
548 {
549 OSL_FAIL("SlideshowImpl::~SlideshowImpl(), component was not disposed!");
550 disposing();
551 }
552 }
553
554 void SAL_CALL SlideshowImpl::disposing()
555 {
556 #ifdef ENABLE_SDREMOTE
557 RemoteServer::presentationStopped();
558 #endif
559 if( mxShow.is() && mpDoc )
560 NotifyDocumentEvent(
561 *mpDoc,
562 "OnEndPresentation" );
563
564 if( mbAutoSaveWasOn )
565 setAutoSaveState( true );
566
567 if( mnEndShowEvent )
568 Application::RemoveUserEvent( mnEndShowEvent );
569 if( mnContextMenuEvent )
570 Application::RemoveUserEvent( mnContextMenuEvent );
571
572 maInputFreezeTimer.Stop();
573
574 SolarMutexGuard aSolarGuard;
575
576 if( !mxShow.is() )
577 return;
578
579 if( mxPresentation.is() )
580 mxPresentation->end();
581
582 maUpdateTimer.Stop();
583
584 removeShapeEvents();
585
586 if( mxListenerProxy.is() )
587 mxListenerProxy->removeAsSlideShowListener();
588
589 try
590 {
591 if( mxView.is() )
592 mxShow->removeView( mxView.get() );
593
594 Reference< XComponent > xComponent( mxShow, UNO_QUERY );
595 if( xComponent.is() )
596 xComponent->dispose();
597
598 if( mxView.is() )
599 mxView->dispose();
600 }
601 catch( Exception& )
602 {
603 SAL_WARN( "sd", "sd::SlideshowImpl::stop(), exception caught: "
604 << comphelper::anyToString( cppu::getCaughtException() ) );
605 }
606
607 mxShow.clear();
608 mxView.clear();
609 mxListenerProxy.clear();
610 mpSlideController.reset();
611
612 // take DrawView from presentation window, but give the old window back
613 if( mpShowWindow && mpView )
614 mpView->DeleteWindowFromPaintView( mpShowWindow );
615
616 if( mpView )
617 mpView->SetAnimationPause( false );
618
619 if( mpViewShell )
620 {
621 mpViewShell->SetActiveWindow(mpOldActiveWindow);
622 if (mpShowWindow)
623 mpShowWindow->SetViewShell( nullptr );
624 }
625
626 if( mpView )
627 mpView->InvalidateAllWin();
628
629 if( maPresSettings.mbFullScreen )
630 {
631 #if HAVE_FEATURE_SCRIPTING
632 // restore StarBASICErrorHdl
633 StarBASIC::SetGlobalErrorHdl(maStarBASICGlobalErrorHdl);
634 maStarBASICGlobalErrorHdl = Link<StarBASIC*,bool>();
635 #endif
636 }
637 else
638 {
639 if( mpShowWindow )
640 mpShowWindow->Hide();
641 }
642
643 if( meAnimationMode == ANIMATIONMODE_SHOW )
644 {
645 mpDocSh->SetSlotFilter();
646 mpDocSh->ApplySlotFilter();
647
648 Help::EnableContextHelp();
649 Help::EnableExtHelp();
650
651 showChildWindows();
652 mnChildMask = 0;
653 }
654
655 // show current window again
656 if( mpViewShell && dynamic_cast< PresentationViewShell *>( mpViewShell ) == nullptr)
657 {
658 if( meAnimationMode == ANIMATIONMODE_SHOW )
659 {
660 mpViewShell->GetViewShellBase().ShowUIControls (true);
661 mpPaneHider.reset();
662 }
663 else if( meAnimationMode == ANIMATIONMODE_PREVIEW )
664 {
665 mpViewShell->ShowUIControls(true);
666 }
667 }
668
669 if( mpTimeButton )
670 mpTimeButton->Hide();
671 mpTimeButton.disposeAndClear();
672
673 if( mpShowWindow )
674 mpShowWindow->Hide();
675 mpShowWindow.disposeAndClear();
676
677 if ( mpViewShell )
678 {
679 if( meAnimationMode == ANIMATIONMODE_SHOW )
680 {
681 ::sd::Window* pActWin = mpViewShell->GetActiveWindow();
682
683 if (pActWin)
684 {
685 Size aVisSizePixel = pActWin->GetOutputSizePixel();
686 ::tools::Rectangle aVisAreaWin = pActWin->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
687 mpViewShell->VisAreaChanged(aVisAreaWin);
688 if (mpView)
689 mpView->VisAreaChanged(pActWin);
690 pActWin->GrabFocus();
691 }
692 }
693
694 // restart the custom show dialog if he started us
695 if( mpViewShell->IsStartShowWithDialog() && getDispatcher() )
696 {
697 mpViewShell->SetStartShowWithDialog( false );
698 getDispatcher()->Execute( SID_CUSTOMSHOW_DLG, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
699 }
700
701 mpViewShell->GetViewShellBase().UpdateBorder(true);
702 }
703
704 if( mpShowWindow )
705 {
706 mpShowWindow.disposeAndClear();
707 }
708
709 setActiveXToolbarsVisible( true );
710
711 mbDisposed = true;
712 }
713
714 bool SlideshowImpl::startPreview(
715 const Reference< XDrawPage >& xDrawPage,
716 const Reference< XAnimationNode >& xAnimationNode,
717 vcl::Window * pParent )
718 {
719 bool bRet = false;
720
721 try
722 {
723 const Reference<lang::XServiceInfo> xServiceInfo( xDrawPage, UNO_QUERY );
724 if (xServiceInfo.is()) {
725 const Sequence<OUString> supportedServices(
726 xServiceInfo->getSupportedServiceNames() );
727 for ( sal_Int32 pos = supportedServices.getLength(); pos--; ) {
728 if ( supportedServices[pos] == "com.sun.star.drawing.MasterPage" ) {
729 OSL_FAIL("sd::SlideshowImpl::startPreview() "
730 "not allowed on master page!");
731 return false;
732 }
733 }
734 }
735
736 mxPreviewDrawPage = xDrawPage;
737 mxPreviewAnimationNode = xAnimationNode;
738 meAnimationMode = ANIMATIONMODE_PREVIEW;
739
740 maPresSettings.mbAll = false;
741 maPresSettings.mbEndless = false;
742 maPresSettings.mbCustomShow = false;
743 maPresSettings.mbManual = false;
744 maPresSettings.mbMouseVisible = false;
745 maPresSettings.mbMouseAsPen = false;
746 maPresSettings.mbLockedPages = false;
747 maPresSettings.mbAlwaysOnTop = false;
748 maPresSettings.mbFullScreen = false;
749 maPresSettings.mbAnimationAllowed = true;
750 maPresSettings.mnPauseTimeout = 0;
751 maPresSettings.mbShowPauseLogo = false;
752
753 Reference< XDrawPagesSupplier > xDrawPages( mpDoc->getUnoModel(), UNO_QUERY_THROW );
754 Reference< XIndexAccess > xSlides( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
755 mpSlideController.reset( new AnimationSlideController( xSlides, AnimationSlideController::PREVIEW ) );
756
757 sal_Int32 nSlideNumber = 0;
758 Reference< XPropertySet > xSet( mxPreviewDrawPage, UNO_QUERY_THROW );
759 xSet->getPropertyValue( "Number" ) >>= nSlideNumber;
760 mpSlideController->insertSlideNumber( nSlideNumber-1 );
761 mpSlideController->setPreviewNode( xAnimationNode );
762
763 mpShowWindow = VclPtr<ShowWindow>::Create( this, ((pParent == nullptr) && mpViewShell) ? mpParentWindow.get() : pParent );
764 if( mpViewShell )
765 {
766 mpViewShell->SetActiveWindow( mpShowWindow );
767 mpShowWindow->SetViewShell (mpViewShell);
768 mpViewShell->ShowUIControls (false);
769 }
770
771 if( mpView )
772 {
773 mpView->AddWindowToPaintView( mpShowWindow, nullptr );
774 mpView->SetAnimationPause( true );
775 }
776
777 // call resize handler
778 if( pParent )
779 {
780 maPresSize = pParent->GetSizePixel();
781 }
782 else if( mpViewShell )
783 {
784 ::tools::Rectangle aContentRect (mpViewShell->GetViewShellBase().getClientRectangle());
785 if (AllSettings::GetLayoutRTL())
786 {
787 aContentRect.SetLeft( aContentRect.Right() );
788 aContentRect.AdjustRight(aContentRect.Right() );
789 }
790 maPresSize = aContentRect.GetSize();
791 mpShowWindow->SetPosPixel( aContentRect.TopLeft() );
792 }
793 else
794 {
795 OSL_FAIL("sd::SlideshowImpl::startPreview(), I need either a parent window or a viewshell!");
796 }
797 resize( maPresSize );
798
799 sal_Int32 nPropertyCount = 1;
800 if( mxPreviewAnimationNode.is() )
801 nPropertyCount++;
802
803 Sequence< beans::PropertyValue > aProperties(nPropertyCount);
804 aProperties[0].Name = "AutomaticAdvancement";
805 aProperties[0].Value <<= 1.0; // one second timeout
806
807 if( mxPreviewAnimationNode.is() )
808 {
809 aProperties[1].Name = "NoSlideTransitions";
810 aProperties[1].Value <<= true;
811 }
812
813 bRet = startShowImpl( aProperties );
814
815 if( mpShowWindow != nullptr && meAnimationMode == ANIMATIONMODE_PREVIEW )
816 mpShowWindow->SetPreviewMode();
817
818 }
819 catch( Exception& )
820 {
821 SAL_WARN( "sd", "sd::SlideshowImpl::startPreview(), exception caught: "
822 << comphelper::anyToString( cppu::getCaughtException() ) );
823 bRet = false;
824 }
825
826 return bRet;
827 }
828
829 bool SlideshowImpl::startShow( PresentationSettingsEx const * pPresSettings )
830 {
831 const rtl::Reference<SlideshowImpl> this_(this);
832
833 DBG_ASSERT( !mxShow.is(), "sd::SlideshowImpl::startShow(), called twice!" );
834 if( mxShow.is() )
835 return true;
836 DBG_ASSERT( mpParentWindow!=nullptr, "sd::SlideshowImpl::startShow() called without parent window" );
837 if (mpParentWindow == nullptr)
838 return false;
839
840 // Autoplay (pps/ppsx)
841 if (mpViewShell->GetDoc()->IsStartWithPresentation()){
842 mpViewShell->GetDoc()->SetExitAfterPresenting(true);
843 }
844
845 bool bRet = false;
846
847 try
848 {
849 if( pPresSettings )
850 {
851 maPresSettings = *pPresSettings;
852 mbRehearseTimings = pPresSettings->mbRehearseTimings;
853 }
854
855 OUString aPresSlide( maPresSettings.maPresPage );
856 SdPage* pStartPage = mpViewShell->GetActualPage();
857 bool bStartWithActualSlide = pStartPage;
858
859 // times should be measured?
860 if( mbRehearseTimings )
861 {
862 maPresSettings.mbEndless = false;
863 maPresSettings.mbManual = true;
864 maPresSettings.mbMouseVisible = true;
865 maPresSettings.mbMouseAsPen = false;
866 maPresSettings.mnPauseTimeout = 0;
867 maPresSettings.mbShowPauseLogo = false;
868 }
869
870 if( pStartPage )
871 {
872 if( pStartPage->GetPageKind() == PageKind::Notes )
873 {
874 // we are in notes page mode, so get
875 // the corresponding draw page
876 const sal_uInt16 nPgNum = ( pStartPage->GetPageNum() - 2 ) >> 1;
877 pStartPage = mpDoc->GetSdPage( nPgNum, PageKind::Standard );
878 }
879 }
880
881 if( bStartWithActualSlide )
882 {
883 if ( aPresSlide.isEmpty())
884 {
885 // no preset slide yet, so pick current on one
886 aPresSlide = pStartPage->GetName();
887 // if the starting slide is hidden, we can't set slide controller to ALL mode
888 maPresSettings.mbAll = !pStartPage->IsExcluded();
889 }
890
891 if( meAnimationMode != ANIMATIONMODE_SHOW )
892 {
893 if( pStartPage->GetPageKind() == PageKind::Standard )
894 {
895 maPresSettings.mbAll = false;
896 }
897 }
898 }
899
900 // build page list
901 createSlideList( maPresSettings.mbAll, aPresSlide );
902
903 // remember Slide number from where the show was started
904 if( pStartPage )
905 mnRestoreSlide = ( pStartPage->GetPageNum() - 1 ) / 2;
906
907 if( mpSlideController->hasSlides() )
908 {
909 // hide child windows
910 hideChildWindows();
911
912 mpShowWindow = VclPtr<ShowWindow>::Create( this, mpParentWindow );
913 mpShowWindow->SetMouseAutoHide( !maPresSettings.mbMouseVisible );
914 mpViewShell->SetActiveWindow( mpShowWindow );
915 mpShowWindow->SetViewShell (mpViewShell);
916 mpViewShell->GetViewShellBase().ShowUIControls (false);
917 // Hide the side panes for in-place presentations.
918 if ( ! maPresSettings.mbFullScreen)
919 mpPaneHider.reset(new PaneHider(*mpViewShell,this));
920
921 // these Slots are forbidden in other views for this document
922 if( mpDocSh )
923 {
924 mpDocSh->SetSlotFilter( true, pAllowed );
925 mpDocSh->ApplySlotFilter();
926 }
927
928 Help::DisableContextHelp();
929 Help::DisableExtHelp();
930
931 if( maPresSettings.mbFullScreen )
932 {
933 #if HAVE_FEATURE_SCRIPTING
934 // disable basic ide error handling
935 maStarBASICGlobalErrorHdl = StarBASIC::GetGlobalErrorHdl();
936 StarBASIC::SetGlobalErrorHdl( Link<StarBASIC*,bool>() );
937 #endif
938 }
939
940 // call resize handler
941 maPresSize = mpParentWindow->GetSizePixel();
942 if (!maPresSettings.mbFullScreen)
943 {
944 const ::tools::Rectangle& aClientRect = mpViewShell->GetViewShellBase().getClientRectangle();
945 maPresSize = aClientRect.GetSize();
946 mpShowWindow->SetPosPixel( aClientRect.TopLeft() );
947 resize( maPresSize );
948 }
949
950 // #i41824#
951 // Note: In FullScreen Mode the OS (window manager) sends a resize to
952 // the WorkWindow once it actually resized it to full size. The
953 // WorkWindow propagates the resize to the DrawViewShell which calls
954 // resize() at the SlideShow (this). Calling resize here results in a
955 // temporary display of a black window in the window's default size
956
957 if( mpView )
958 {
959 mpView->AddWindowToPaintView( mpShowWindow, nullptr );
960 mpView->SetAnimationPause( true );
961 }
962
963 SfxBindings* pBindings = getBindings();
964 if( pBindings )
965 {
966 pBindings->Invalidate( SID_PRESENTATION );
967 pBindings->Invalidate( SID_REHEARSE_TIMINGS );
968 }
969
970 // Defer the sd::ShowWindow's GrabFocus to SlideShow::activate. so that the accessible event can be fired correctly.
971 //mpShowWindow->GrabFocus();
972
973 std::vector<beans::PropertyValue> aProperties;
974 aProperties.reserve( 4 );
975
976 aProperties.emplace_back( "AdvanceOnClick" ,
977 -1, Any( !maPresSettings.mbLockedPages ),
978 beans::PropertyState_DIRECT_VALUE );
979
980 aProperties.emplace_back( "ImageAnimationsAllowed" ,
981 -1, Any( maPresSettings.mbAnimationAllowed ),
982 beans::PropertyState_DIRECT_VALUE );
983
984 const bool bZOrderEnabled(
985 SD_MOD()->GetSdOptions( mpDoc->GetDocumentType() )->IsSlideshowRespectZOrder() );
986 aProperties.emplace_back( "DisableAnimationZOrder" ,
987 -1, Any( !bZOrderEnabled ),
988 beans::PropertyState_DIRECT_VALUE );
989
990 aProperties.emplace_back( "ForceManualAdvance" ,
991 -1, Any( maPresSettings.mbManual ),
992 beans::PropertyState_DIRECT_VALUE );
993
994 if( mbUsePen )
995 {
996 aProperties.emplace_back( "UserPaintColor" ,
997 // User paint color is black by default.
998 -1, Any( mnUserPaintColor ),
999 beans::PropertyState_DIRECT_VALUE );
1000
1001 aProperties.emplace_back( "UserPaintStrokeWidth" ,
1002 // User paint color is black by default.
1003 -1, Any( mdUserPaintStrokeWidth ),
1004 beans::PropertyState_DIRECT_VALUE );
1005 }
1006
1007 if (mbRehearseTimings) {
1008 aProperties.emplace_back( "RehearseTimings" ,
1009 -1, Any(true), beans::PropertyState_DIRECT_VALUE );
1010 }
1011
1012 bRet = startShowImpl( Sequence<beans::PropertyValue>(
1013 &aProperties[0], aProperties.size() ) );
1014
1015 }
1016
1017 setActiveXToolbarsVisible( false );
1018 }
1019 catch (const Exception&)
1020 {
1021 SAL_WARN( "sd", "sd::SlideshowImpl::startShow(), exception caught: "
1022 << comphelper::anyToString( cppu::getCaughtException() ) );
1023 bRet = false;
1024 }
1025
1026 return bRet;
1027 }
1028
1029 bool SlideshowImpl::startShowImpl( const Sequence< beans::PropertyValue >& aProperties )
1030 {
1031 try
1032 {
1033 mxShow.set( createSlideShow(), UNO_QUERY_THROW );
1034
1035 mxView = new SlideShowView(
1036 *mpShowWindow,
1037 mpDoc,
1038 meAnimationMode,
1039 this,
1040 maPresSettings.mbFullScreen);
1041
1042 // try add wait symbol to properties:
1043 const Reference<rendering::XSpriteCanvas> xSpriteCanvas(
1044 mxView->getCanvas() );
1045 if (xSpriteCanvas.is())
1046 {
1047 BitmapEx waitSymbolBitmap(BMP_WAIT_ICON);
1048 const Reference<rendering::XBitmap> xBitmap(
1049 vcl::unotools::xBitmapFromBitmapEx( waitSymbolBitmap ) );
1050 if (xBitmap.is())
1051 {
1052 mxShow->setProperty(
1053 beans::PropertyValue( "WaitSymbolBitmap" ,
1054 -1,
1055 makeAny( xBitmap ),
1056 beans::PropertyState_DIRECT_VALUE ) );
1057 }
1058
1059 BitmapEx pointerSymbolBitmap(BMP_POINTER_ICON);
1060 const Reference<rendering::XBitmap> xPointerBitmap(
1061 vcl::unotools::xBitmapFromBitmapEx( pointerSymbolBitmap ) );
1062 if (xPointerBitmap.is())
1063 {
1064 mxShow->setProperty(
1065 beans::PropertyValue( "PointerSymbolBitmap" ,
1066 -1,
1067 makeAny( xPointerBitmap ),
1068 beans::PropertyState_DIRECT_VALUE ) );
1069 }
1070 }
1071
1072 const sal_Int32 nCount = aProperties.getLength();
1073 sal_Int32 nIndex;
1074 for( nIndex = 0; nIndex < nCount; nIndex++ )
1075 mxShow->setProperty( aProperties[nIndex] );
1076
1077 mxShow->addView( mxView.get() );
1078
1079 mxListenerProxy.set( new SlideShowListenerProxy( this, mxShow ) );
1080 mxListenerProxy->addAsSlideShowListener();
1081
1082 NotifyDocumentEvent(
1083 *mpDoc,
1084 "OnStartPresentation");
1085 displaySlideIndex( mpSlideController->getStartSlideIndex() );
1086
1087 return true;
1088 }
1089 catch( Exception& )
1090 {
1091 SAL_WARN( "sd", "sd::SlideshowImpl::startShowImpl(), exception caught: "
1092 << comphelper::anyToString( cppu::getCaughtException() ) );
1093 return false;
1094 }
1095 }
1096
1097 /** called only by the slideshow view when the first paint event occurs.
1098 This actually starts the slideshow. */
1099 void SlideshowImpl::onFirstPaint()
1100 {
1101 if( mpShowWindow )
1102 {
1103 /*
1104 mpShowWindow->SetBackground( Wallpaper( COL_BLACK ) );
1105 mpShowWindow->Erase();
1106 mpShowWindow->SetBackground();
1107 */
1108 }
1109
1110 SolarMutexGuard aSolarGuard;
1111 maUpdateTimer.SetTimeout( sal_uLong(100) );
1112 maUpdateTimer.Start();
1113 }
1114
1115 void SlideshowImpl::paint()
1116 {
1117 if( mxView.is() ) try
1118 {
1119 awt::PaintEvent aEvt;
1120 // aEvt.UpdateRect = TODO
1121 mxView->paint( aEvt );
1122 }
1123 catch( Exception& )
1124 {
1125 SAL_WARN( "sd", "sd::SlideshowImpl::paint(), exception caught: "
1126 << comphelper::anyToString( cppu::getCaughtException() ) );
1127 }
1128 }
1129
1130 void SAL_CALL SlideshowImpl::addSlideShowListener( const Reference< XSlideShowListener >& xListener )
1131 {
1132 if( mxListenerProxy.is() )
1133 mxListenerProxy->addSlideShowListener( xListener );
1134 }
1135
1136 void SAL_CALL SlideshowImpl::removeSlideShowListener( const Reference< XSlideShowListener >& xListener )
1137 {
1138 if( mxListenerProxy.is() )
1139 mxListenerProxy->removeSlideShowListener( xListener );
1140 }
1141
1142 void SlideshowImpl::slideEnded(const bool bReverse)
1143 {
1144 if (bReverse)
1145 gotoPreviousSlide(true);
1146 else
1147 gotoNextSlide();
1148 }
1149
1150 bool SlideshowImpl::swipe(const CommandSwipeData &rSwipeData)
1151 {
1152 if (mbUsePen || mnContextMenuEvent)
1153 return false;
1154 double nVelocityX = rSwipeData.getVelocityX();
1155 // tdf#108475 make it swipe only if some reasonable movement was involved
1156 if (fabs(nVelocityX) < 50)
1157 return false;
1158 if (nVelocityX > 0)
1159 {
1160 gotoPreviousSlide();
1161 }
1162 else
1163 {
1164 gotoNextEffect();
1165 }
1166 //a swipe is followed by a mouse up, tell the view to ignore that mouse up as we've reacted
1167 //to the swipe instead
1168 mxView->ignoreNextMouseReleased();
1169 return true;
1170 }
1171
1172 bool SlideshowImpl::longpress(const CommandLongPressData &rLongPressData)
1173 {
1174 if (mnContextMenuEvent)
1175 return false;
1176
1177 maPopupMousePos = Point(rLongPressData.getX(), rLongPressData.getY());
1178 mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
1179
1180 return true;
1181 }
1182
1183 void SlideshowImpl::removeShapeEvents()
1184 {
1185 if( mxShow.is() && mxListenerProxy.is() ) try
1186 {
1187 WrappedShapeEventImplMap::iterator aIter;
1188 const WrappedShapeEventImplMap::iterator aEnd( maShapeEventMap.end() );
1189
1190 for( aIter = maShapeEventMap.begin(); aIter != aEnd; ++aIter )
1191 {
1192 mxListenerProxy->removeShapeEventListener( (*aIter).first );
1193 mxShow->setShapeCursor( (*aIter).first, awt::SystemPointer::ARROW );
1194 }
1195
1196 maShapeEventMap.clear();
1197 }
1198 catch( Exception& )
1199 {
1200 SAL_WARN( "sd", "sd::SlideshowImpl::removeShapeEvents(), exception caught: "
1201 << comphelper::anyToString( cppu::getCaughtException() ) );
1202 }
1203 }
1204
1205 void SlideshowImpl::registerShapeEvents(sal_Int32 nSlideNumber)
1206 {
1207 if( nSlideNumber >= 0 ) try
1208 {
1209 Reference< XDrawPagesSupplier > xDrawPages( mxModel, UNO_QUERY_THROW );
1210 Reference< XIndexAccess > xPages( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
1211
1212 Reference< XShapes > xDrawPage;
1213 xPages->getByIndex(nSlideNumber) >>= xDrawPage;
1214
1215 if( xDrawPage.is() )
1216 {
1217 Reference< XMasterPageTarget > xMasterPageTarget( xDrawPage, UNO_QUERY );
1218 if( xMasterPageTarget.is() )
1219 {
1220 Reference< XShapes > xMasterPage( xMasterPageTarget->getMasterPage(), UNO_QUERY );
1221 if( xMasterPage.is() )
1222 registerShapeEvents( xMasterPage );
1223 }
1224 registerShapeEvents( xDrawPage );
1225 }
1226 }
1227 catch( Exception& )
1228 {
1229 SAL_WARN( "sd", "sd::SlideshowImpl::registerShapeEvents(), exception caught: "
1230 << comphelper::anyToString( cppu::getCaughtException() ) );
1231 }
1232 }
1233
1234 void SlideshowImpl::registerShapeEvents( Reference< XShapes > const & xShapes )
1235 {
1236 try
1237 {
1238 const sal_Int32 nShapeCount = xShapes->getCount();
1239 sal_Int32 nShape;
1240 for( nShape = 0; nShape < nShapeCount; nShape++ )
1241 {
1242 Reference< XShape > xShape;
1243 xShapes->getByIndex( nShape ) >>= xShape;
1244
1245 if( xShape.is() && xShape->getShapeType() == "com.sun.star.drawing.GroupShape" )
1246 {
1247 Reference< XShapes > xSubShapes( xShape, UNO_QUERY );
1248 if( xSubShapes.is() )
1249 registerShapeEvents( xSubShapes );
1250 }
1251
1252 Reference< XPropertySet > xSet( xShape, UNO_QUERY );
1253 if( !xSet.is() )
1254 continue;
1255
1256 Reference< XPropertySetInfo > xSetInfo( xSet->getPropertySetInfo() );
1257 if( !xSetInfo.is() || !xSetInfo->hasPropertyByName( msOnClick ) )
1258 continue;
1259
1260 WrappedShapeEventImplPtr pEvent( new WrappedShapeEventImpl );
1261 xSet->getPropertyValue( msOnClick ) >>= pEvent->meClickAction;
1262
1263 switch( pEvent->meClickAction )
1264 {
1265 case ClickAction_PREVPAGE:
1266 case ClickAction_NEXTPAGE:
1267 case ClickAction_FIRSTPAGE:
1268 case ClickAction_LASTPAGE:
1269 case ClickAction_STOPPRESENTATION:
1270 break;
1271 case ClickAction_BOOKMARK:
1272 if( xSetInfo->hasPropertyByName( msBookmark ) )
1273 xSet->getPropertyValue( msBookmark ) >>= pEvent->maStrBookmark;
1274 if( getSlideNumberForBookmark( pEvent->maStrBookmark ) == -1 )
1275 continue;
1276 break;
1277 case ClickAction_DOCUMENT:
1278 case ClickAction_SOUND:
1279 case ClickAction_PROGRAM:
1280 case ClickAction_MACRO:
1281 if( xSetInfo->hasPropertyByName( msBookmark ) )
1282 xSet->getPropertyValue( msBookmark ) >>= pEvent->maStrBookmark;
1283 break;
1284 case ClickAction_VERB:
1285 if( xSetInfo->hasPropertyByName( msVerb ) )
1286 xSet->getPropertyValue( msVerb ) >>= pEvent->mnVerb;
1287 break;
1288 default:
1289 continue; // skip all others
1290 }
1291
1292 maShapeEventMap[ xShape ] = pEvent;
1293
1294 if( mxListenerProxy.is() )
1295 mxListenerProxy->addShapeEventListener( xShape );
1296 mxShow->setShapeCursor( xShape, awt::SystemPointer::REFHAND );
1297 }
1298 }
1299 catch( Exception& )
1300 {
1301 SAL_WARN( "sd", "sd::SlideshowImpl::registerShapeEvents(), exception caught: "
1302 << comphelper::anyToString( cppu::getCaughtException() ) );
1303 }
1304 }
1305
1306 void SlideshowImpl::displayCurrentSlide (const bool bSkipAllMainSequenceEffects)
1307 {
1308 stopSound();
1309 removeShapeEvents();
1310
1311 if( mpSlideController.get() && mxShow.is() )
1312 {
1313 Reference< XDrawPagesSupplier > xDrawPages( mpDoc->getUnoModel(),
1314 UNO_QUERY_THROW );
1315 mpSlideController->displayCurrentSlide( mxShow, xDrawPages, bSkipAllMainSequenceEffects );
1316 registerShapeEvents(mpSlideController->getCurrentSlideNumber());
1317 update();
1318
1319 }
1320 // send out page change event and notify to update all acc info for current page
1321 if (mpViewShell)
1322 {
1323 sal_Int32 currentPageIndex = getCurrentSlideIndex();
1324 mpViewShell->fireSwitchCurrentPage(currentPageIndex);
1325 mpViewShell->NotifyAccUpdate();
1326 }
1327 }
1328
1329 void SlideshowImpl::endPresentation()
1330 {
1331 if( maPresSettings.mbMouseAsPen)
1332 {
1333 Reference< XMultiServiceFactory > xDocFactory(mpDoc->getUnoModel(), UNO_QUERY );
1334 if( xDocFactory.is() )
1335 mxShow->registerUserPaintPolygons(xDocFactory);
1336 }
1337
1338 if( !mnEndShowEvent )
1339 mnEndShowEvent = Application::PostUserEvent( LINK(this, SlideshowImpl, endPresentationHdl) );
1340 }
1341
1342 IMPL_LINK_NOARG(SlideshowImpl, endPresentationHdl, void*, void)
1343 {
1344 mnEndShowEvent = nullptr;
1345
1346 if( mxPresentation.is() )
1347 mxPresentation->end();
1348 }
1349
1350 void SAL_CALL SlideshowImpl::pause()
1351 {
1352 SolarMutexGuard aSolarGuard;
1353
1354 if( !mbIsPaused ) try
1355 {
1356 mbIsPaused = true;
1357 if( mxShow.is() )
1358 {
1359 mxShow->pause(true);
1360
1361 if( mxListenerProxy.is() )
1362 mxListenerProxy->paused();
1363 }
1364 }
1365 catch( Exception& )
1366 {
1367 SAL_WARN( "sd", "sd::SlideshowImpl::pause(), exception caught: "
1368 << comphelper::anyToString( cppu::getCaughtException() ) );
1369 }
1370 }
1371
1372 void SAL_CALL SlideshowImpl::resume()
1373 {
1374 SolarMutexGuard aSolarGuard;
1375
1376 if( mbIsPaused ) try
1377 {
1378 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
1379 {
1380 mpShowWindow->RestartShow();
1381 }
1382 else
1383 {
1384 mbIsPaused = false;
1385 if( mxShow.is() )
1386 {
1387 mxShow->pause(false);
1388 update();
1389
1390 if( mxListenerProxy.is() )
1391 mxListenerProxy->resumed();
1392 }
1393 }
1394 }
1395 catch( Exception& )
1396 {
1397 SAL_WARN( "sd", "sd::SlideshowImpl::resume(), exception caught: "
1398 << comphelper::anyToString( cppu::getCaughtException() ) );
1399 }
1400 #ifdef ENABLE_SDREMOTE
1401 RemoteServer::presentationStarted( this );
1402 #endif
1403 }
1404
1405 sal_Bool SAL_CALL SlideshowImpl::isPaused()
1406 {
1407 SolarMutexGuard aSolarGuard;
1408 return mbIsPaused;
1409 }
1410
1411 void SAL_CALL SlideshowImpl::blankScreen( sal_Int32 nColor )
1412 {
1413 SolarMutexGuard aSolarGuard;
1414
1415 if( mpShowWindow && mpSlideController )
1416 {
1417 if( mpShowWindow->SetBlankMode( mpSlideController->getCurrentSlideIndex(), Color(nColor) ) )
1418 {
1419 pause();
1420 }
1421 }
1422 }
1423
1424 // XShapeEventListener
1425
1426 void SlideshowImpl::click( const Reference< XShape >& xShape )
1427 {
1428 SolarMutexGuard aSolarGuard;
1429
1430 WrappedShapeEventImplPtr pEvent = maShapeEventMap[xShape];
1431 if( !pEvent.get() )
1432 return;
1433
1434 switch( pEvent->meClickAction )
1435 {
1436 case ClickAction_PREVPAGE: gotoPreviousSlide(); break;
1437 case ClickAction_NEXTPAGE: gotoNextSlide(); break;
1438 case ClickAction_FIRSTPAGE: gotoFirstSlide(); break;
1439 case ClickAction_LASTPAGE: gotoLastSlide(); break;
1440 case ClickAction_STOPPRESENTATION: endPresentation(); break;
1441 case ClickAction_BOOKMARK:
1442 {
1443 gotoBookmark( pEvent->maStrBookmark );
1444 }
1445 break;
1446 case ClickAction_SOUND:
1447 {
1448 #if HAVE_FEATURE_AVMEDIA
1449 try
1450 {
1451 mxPlayer.set(avmedia::MediaWindow::createPlayer(pEvent->maStrBookmark, ""/*TODO?*/), uno::UNO_QUERY_THROW );
1452 mxPlayer->start();
1453 }
1454 catch( uno::Exception& )
1455 {
1456 OSL_FAIL("sd::SlideshowImpl::click(), exception caught!" );
1457 }
1458 #endif
1459 }
1460 break;
1461
1462 case ClickAction_DOCUMENT:
1463 {
1464 OUString aBookmark( pEvent->maStrBookmark );
1465
1466 sal_Int32 nPos = aBookmark.indexOf( '#' );
1467 if( nPos >= 0 )
1468 {
1469 OUString aURL( aBookmark.copy( 0, nPos+1 ) );
1470 OUString aName( aBookmark.copy( nPos+1 ) );
1471 aURL += getUiNameFromPageApiNameImpl( aName );
1472 aBookmark = aURL;
1473 }
1474
1475 mpDocSh->OpenBookmark( aBookmark );
1476 }
1477 break;
1478
1479 case ClickAction_PROGRAM:
1480 {
1481 INetURLObject aURL(
1482 ::URIHelper::SmartRel2Abs(
1483 INetURLObject(mpDocSh->GetMedium()->GetBaseURL()),
1484 pEvent->maStrBookmark, ::URIHelper::GetMaybeFileHdl(), true,
1485 false, INetURLObject::EncodeMechanism::WasEncoded,
1486 INetURLObject::DecodeMechanism::Unambiguous ) );
1487
1488 if( INetProtocol::File == aURL.GetProtocol() )
1489 {
1490 SfxStringItem aUrl( SID_FILE_NAME, aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
1491 SfxBoolItem aBrowsing( SID_BROWSE, true );
1492
1493 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1494 if (pViewFrm)
1495 {
1496 pViewFrm->GetDispatcher()->ExecuteList( SID_OPENDOC,
1497 SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
1498 { &aUrl, &aBrowsing });
1499 }
1500 }
1501 }
1502 break;
1503
1504 case presentation::ClickAction_MACRO:
1505 {
1506 const OUString aMacro( pEvent->maStrBookmark );
1507
1508 if ( SfxApplication::IsXScriptURL( aMacro ) )
1509 {
1510 Any aRet;
1511 Sequence< sal_Int16 > aOutArgsIndex;
1512 Sequence< Any > aOutArgs;
1513 Sequence< Any >* pInArgs = new Sequence< Any >(0);
1514 mpDocSh->CallXScript( aMacro, *pInArgs, aRet, aOutArgsIndex, aOutArgs);
1515 }
1516 else
1517 {
1518 // aMacro has the following syntax:
1519 // "Macroname.Modulname.Libname.Documentname" or
1520 // "Macroname.Modulname.Libname.Applicationname"
1521 OUString aMacroName = aMacro.getToken(0, '.');
1522 OUString aModulName = aMacro.getToken(1, '.');
1523
1524 // todo: is the limitation still given that only
1525 // Modulname+Macroname can be used here?
1526 OUString aExecMacro = aModulName + "." + aMacroName;
1527 mpDocSh->GetBasic()->Call(aExecMacro);
1528 }
1529 }
1530 break;
1531
1532 case ClickAction_VERB:
1533 {
1534 // todo, better do it async?
1535 SdrObject* pObj = GetSdrObjectFromXShape( xShape );
1536 SdrOle2Obj* pOleObject = dynamic_cast< SdrOle2Obj* >(pObj);
1537 if (pOleObject && mpViewShell )
1538 mpViewShell->ActivateObject(pOleObject, pEvent->mnVerb);
1539 }
1540 break;
1541 default:
1542 break;
1543 }
1544 }
1545
1546 sal_Int32 SlideshowImpl::getSlideNumberForBookmark( const OUString& rStrBookmark )
1547 {
1548 bool bIsMasterPage;
1549 OUString aBookmark = getUiNameFromPageApiNameImpl( rStrBookmark );
1550 sal_uInt16 nPgNum = mpDoc->GetPageByName( aBookmark, bIsMasterPage );
1551
1552 if( nPgNum == SDRPAGE_NOTFOUND )
1553 {
1554 // Is the bookmark an object?
1555 SdrObject* pObj = mpDoc->GetObj( aBookmark );
1556
1557 if( pObj )
1558 {
1559 nPgNum = pObj->GetPage()->GetPageNum();
1560 bIsMasterPage = pObj->GetPage()->IsMasterPage();
1561 }
1562 }
1563
1564 if( (nPgNum == SDRPAGE_NOTFOUND) || bIsMasterPage || static_cast<SdPage*>(mpDoc->GetPage(nPgNum))->GetPageKind() != PageKind::Standard )
1565 return -1;
1566
1567 return ( nPgNum - 1) >> 1;
1568 }
1569
1570 void SlideshowImpl::hyperLinkClicked( OUString const& aHyperLink )
1571 {
1572 OUString aBookmark( aHyperLink );
1573
1574 sal_Int32 nPos = aBookmark.indexOf( '#' );
1575 if( nPos >= 0 )
1576 {
1577 OUString aURL( aBookmark.copy( 0, nPos+1 ) );
1578 OUString aName( aBookmark.copy( nPos+1 ) );
1579 aURL += getUiNameFromPageApiNameImpl( aName );
1580 aBookmark = aURL;
1581 }
1582
1583 mpDocSh->OpenBookmark( aBookmark );
1584 }
1585
1586 void SlideshowImpl::displaySlideNumber( sal_Int32 nSlideNumber )
1587 {
1588 if( mpSlideController.get() )
1589 {
1590 if( mpSlideController->jumpToSlideNumber( nSlideNumber ) )
1591 {
1592 displayCurrentSlide();
1593 }
1594 }
1595 }
1596
1597 /** nSlideIndex == -1 displays current slide again */
1598 void SlideshowImpl::displaySlideIndex( sal_Int32 nSlideIndex )
1599 {
1600 if( mpSlideController.get() )
1601 {
1602 if( (nSlideIndex == -1) || mpSlideController->jumpToSlideIndex( nSlideIndex ) )
1603 {
1604 displayCurrentSlide();
1605 }
1606 }
1607 }
1608
1609 void SlideshowImpl::jumpToBookmark( const OUString& sBookmark )
1610 {
1611 sal_Int32 nSlideNumber = getSlideNumberForBookmark( sBookmark );
1612 if( nSlideNumber != -1 )
1613 displaySlideNumber( nSlideNumber );
1614 }
1615
1616 sal_Int32 SlideshowImpl::getCurrentSlideNumber()
1617 {
1618 return mpSlideController.get() ? mpSlideController->getCurrentSlideNumber() : -1;
1619 }
1620
1621 sal_Bool SAL_CALL SlideshowImpl::isEndless()
1622 {
1623 SolarMutexGuard aSolarGuard;
1624 return maPresSettings.mbEndless;
1625 }
1626
1627 void SlideshowImpl::update()
1628 {
1629 startUpdateTimer();
1630 }
1631
1632 void SlideshowImpl::startUpdateTimer()
1633 {
1634 SolarMutexGuard aSolarGuard;
1635 maUpdateTimer.SetTimeout( 0 );
1636 maUpdateTimer.Start();
1637 }
1638
1639 /** this timer is called 20ms after a new slide was displayed.
1640 This is used to unfreeze user input that was disabled after
1641 slide change to skip input that was buffered during slide
1642 transition preparation */
1643 IMPL_LINK_NOARG(SlideshowImpl, ReadyForNextInputHdl, Timer *, void)
1644 {
1645 mbInputFreeze = false;
1646 }
1647
1648 /** if I catch someone someday who calls this method by hand
1649 and not by using the timer, I will personally punish this
1650 person seriously, even if this person is me.
1651 */
1652 IMPL_LINK_NOARG(SlideshowImpl, updateHdl, Timer *, void)
1653 {
1654 updateSlideShow();
1655 }
1656
1657 void SlideshowImpl::updateSlideShow()
1658 {
1659 // prevent me from deletion when recursing (App::EnableYieldMode does)
1660 const rtl::Reference<SlideshowImpl> this_(this);
1661
1662 Reference< XSlideShow > xShow( mxShow );
1663 if ( ! xShow.is())
1664 return;
1665
1666 try
1667 {
1668 double fUpdate = 0.0;
1669 if( !xShow->update(fUpdate) )
1670 fUpdate = -1.0;
1671
1672 if (mxShow.is() && (fUpdate >= 0.0))
1673 {
1674 if (!::basegfx::fTools::equalZero(fUpdate))
1675 {
1676 // Avoid busy loop when the previous call to update()
1677 // returns a small positive number but not 0 (which is
1678 // handled above). Also, make sure that calls to update()
1679 // have a minimum frequency.
1680 // => Allow up to 60 frames per second. Call at least once
1681 // every 4 seconds.
1682 const static sal_Int32 nMaximumFrameCount (60);
1683 const static double nMinimumTimeout (1.0 / nMaximumFrameCount);
1684 const static double nMaximumTimeout (4.0);
1685 fUpdate = ::basegfx::clamp(fUpdate, nMinimumTimeout, nMaximumTimeout);
1686
1687 // Make sure that the maximum frame count has not been set
1688 // too high (only then conversion to milliseconds and long
1689 // integer may lead to zero value.)
1690 OSL_ASSERT(static_cast<sal_uLong>(fUpdate * 1000.0) > 0);
1691 }
1692
1693 // Use our high resolution timers for the asynchronous callback.
1694 maUpdateTimer.SetTimeout(static_cast<sal_uLong>(fUpdate * 1000.0));
1695 maUpdateTimer.Start();
1696 }
1697 }
1698 catch( Exception& )
1699 {
1700 SAL_WARN( "sd", "sd::SlideshowImpl::updateSlideShow(), exception caught: "
1701 << comphelper::anyToString( cppu::getCaughtException() ) );
1702 }
1703 }
1704
1705 bool SlideshowImpl::keyInput(const KeyEvent& rKEvt)
1706 {
1707 if( !mxShow.is() || mbInputFreeze )
1708 return false;
1709
1710 bool bRet = true;
1711
1712 try
1713 {
1714 const int nKeyCode = rKEvt.GetKeyCode().GetCode();
1715 switch( nKeyCode )
1716 {
1717 case awt::Key::CONTEXTMENU:
1718 if( !mnContextMenuEvent )
1719 {
1720 if( mpShowWindow )
1721 maPopupMousePos = mpShowWindow->GetPointerState().maPos;
1722 mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
1723 }
1724 break;
1725
1726 // cancel show
1727 case KEY_ESCAPE:
1728 case KEY_SUBTRACT:
1729 // in case the user cancels the presentation, switch to current slide
1730 // in edit mode
1731 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
1732 {
1733 if( mpSlideController->getCurrentSlideNumber() != -1 )
1734 mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
1735 }
1736 endPresentation();
1737 break;
1738
1739 // advance show
1740 case KEY_PAGEDOWN:
1741 if(rKEvt.GetKeyCode().IsMod2())
1742 {
1743 gotoNextSlide();
1744 break;
1745 }
1746 SAL_FALLTHROUGH;
1747 case KEY_SPACE:
1748 case KEY_RIGHT:
1749 case KEY_DOWN:
1750 case KEY_N:
1751 gotoNextEffect();
1752 break;
1753
1754 case KEY_RETURN:
1755 {
1756 if( !maCharBuffer.isEmpty() )
1757 {
1758 if( mpSlideController.get() )
1759 {
1760 if( mpSlideController->jumpToSlideNumber( maCharBuffer.toInt32() - 1 ) )
1761 displayCurrentSlide();
1762 }
1763 maCharBuffer.clear();
1764 }
1765 else
1766 {
1767 gotoNextEffect();
1768 }
1769 }
1770 break;
1771
1772 // numeric: add to buffer
1773 case KEY_0:
1774 case KEY_1:
1775 case KEY_2:
1776 case KEY_3:
1777 case KEY_4:
1778 case KEY_5:
1779 case KEY_6:
1780 case KEY_7:
1781 case KEY_8:
1782 case KEY_9:
1783 maCharBuffer += OUStringLiteral1( rKEvt.GetCharCode() );
1784 break;
1785
1786 case KEY_PAGEUP:
1787 if(rKEvt.GetKeyCode().IsMod2())
1788 {
1789 gotoPreviousSlide();
1790 break;
1791 }
1792 SAL_FALLTHROUGH;
1793 case KEY_LEFT:
1794 case KEY_UP:
1795 case KEY_P:
1796 case KEY_BACKSPACE:
1797 gotoPreviousEffect();
1798 break;
1799
1800 case KEY_HOME:
1801 gotoFirstSlide();
1802 break;
1803
1804 case KEY_END:
1805 gotoLastSlide();
1806 break;
1807
1808 case KEY_B:
1809 case KEY_W:
1810 case KEY_POINT:
1811 case KEY_COMMA:
1812 {
1813 blankScreen( ((nKeyCode == KEY_W ) || (nKeyCode == KEY_COMMA)) ? 0x00ffffff : 0x00000000 );
1814 }
1815 break;
1816
1817 default:
1818 bRet = false;
1819 break;
1820 }
1821 }
1822 catch( Exception& )
1823 {
1824 bRet = false;
1825 SAL_WARN( "sd", "sd::SlideshowImpl::keyInput(), exception caught: "
1826 << comphelper::anyToString( cppu::getCaughtException() ) );
1827 }
1828
1829 return bRet;
1830 }
1831
1832 IMPL_LINK( SlideshowImpl, EventListenerHdl, VclSimpleEvent&, rSimpleEvent, void )
1833 {
1834 if( !mxShow.is() || mbInputFreeze )
1835 return;
1836
1837 if( (rSimpleEvent.GetId() == VclEventId::WindowCommand) && static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData() )
1838 {
1839 const CommandEvent& rEvent = *static_cast<const CommandEvent*>(static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData());
1840
1841 if( rEvent.GetCommand() == CommandEventId::Media )
1842 {
1843 CommandMediaData* pMediaData = rEvent.GetMediaData();
1844 pMediaData->SetPassThroughToOS(false);
1845 switch (pMediaData->GetMediaId())
1846 {
1847 #if defined( MACOSX )
1848 case MediaCommand::Menu:
1849 if( !mnContextMenuEvent )
1850 {
1851 if( mpShowWindow )
1852 maPopupMousePos = mpShowWindow->GetPointerState().maPos;
1853 mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
1854 }
1855 break;
1856 case MediaCommand::VolumeDown:
1857 gotoPreviousSlide();
1858 break;
1859 case MediaCommand::VolumeUp:
1860 gotoNextEffect();
1861 break;
1862 #endif
1863 case MediaCommand::NextTrack:
1864 gotoNextEffect();
1865 break;
1866 case MediaCommand::Pause:
1867 if( !mbIsPaused )
1868 blankScreen(0);
1869 break;
1870 case MediaCommand::Play:
1871 if( mbIsPaused )
1872 resume();
1873 break;
1874
1875 case MediaCommand::PlayPause:
1876 if( mbIsPaused )
1877 resume();
1878 else
1879 blankScreen(0);
1880 break;
1881 case MediaCommand::PreviousTrack:
1882 gotoPreviousSlide();
1883 break;
1884 case MediaCommand::NextTrackHold:
1885 gotoLastSlide();
1886 break;
1887
1888 case MediaCommand::Rewind:
1889 gotoFirstSlide();
1890 break;
1891 case MediaCommand::Stop:
1892 // in case the user cancels the presentation, switch to current slide
1893 // in edit mode
1894 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
1895 {
1896 if( mpSlideController->getCurrentSlideNumber() != -1 )
1897 mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
1898 }
1899 endPresentation();
1900 break;
1901 default:
1902 pMediaData->SetPassThroughToOS(true);
1903 break;
1904 }
1905 }
1906 }
1907 }
1908
1909 void SlideshowImpl::mouseButtonUp(const MouseEvent& rMEvt)
1910 {
1911 if( rMEvt.IsRight() && !mnContextMenuEvent )
1912 {
1913 maPopupMousePos = rMEvt.GetPosPixel();
1914 mnContextMenuEvent = Application::PostUserEvent( LINK( this, SlideshowImpl, ContextMenuHdl ) );
1915 }
1916 }
1917
1918 IMPL_LINK_NOARG(SlideshowImpl, ContextMenuHdl, void*, void)
1919 {
1920 mnContextMenuEvent = nullptr;
1921
1922 if( mpSlideController.get() == nullptr )
1923 return;
1924
1925 mbWasPaused = mbIsPaused;
1926 if( !mbWasPaused )
1927 pause();
1928
1929 VclBuilder aBuilder(nullptr, VclBuilderContainer::getUIRootDir(), "modules/simpress/ui/slidecontextmenu.ui", "");
1930 VclPtr<PopupMenu> pMenu(aBuilder.get_menu("menu"));
1931
1932 // Adding button to display if in Pen mode
1933 pMenu->CheckItem("pen", mbUsePen);
1934
1935 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
1936 pMenu->EnableItem(pMenu->GetItemId("next"), mpSlideController->getNextSlideIndex() != -1);
1937 pMenu->EnableItem(pMenu->GetItemId("prev"), (mpSlideController->getPreviousSlideIndex() != -1 ) || (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK));
1938 pMenu->EnableItem(pMenu->GetItemId("edit"), mpViewShell->GetDoc()->IsStartWithPresentation());
1939
1940 PopupMenu* pPageMenu = pMenu->GetPopupMenu(pMenu->GetItemId("goto"));
1941
1942 SfxViewFrame* pViewFrame = getViewFrame();
1943 if( pViewFrame )
1944 {
1945 Reference< css::frame::XFrame > xFrame( pViewFrame->GetFrame().GetFrameInterface() );
1946 if( xFrame.is() )
1947 {
1948 pMenu->SetItemImage(pMenu->GetItemId("next"), vcl::CommandInfoProvider::GetImageForCommand(".uno:NextRecord", xFrame));
1949 pMenu->SetItemImage(pMenu->GetItemId("prev"), vcl::CommandInfoProvider::GetImageForCommand(".uno:PrevRecord", xFrame));
1950
1951 if( pPageMenu )
1952 {
1953 pPageMenu->SetItemImage(pPageMenu->GetItemId("first"), vcl::CommandInfoProvider::GetImageForCommand(".uno:FirstRecord", xFrame));
1954 pPageMenu->SetItemImage(pPageMenu->GetItemId("last"), vcl::CommandInfoProvider::GetImageForCommand(".uno:LastRecord", xFrame));
1955 }
1956 }
1957 }
1958
1959 // populate slide goto list
1960 if( pPageMenu )
1961 {
1962 const sal_Int32 nPageNumberCount = mpSlideController->getSlideNumberCount();
1963 if( nPageNumberCount <= 1 )
1964 {
1965 pMenu->EnableItem(pMenu->GetItemId("goto"), false);
1966 }
1967 else
1968 {
1969 sal_Int32 nCurrentSlideNumber = mpSlideController->getCurrentSlideNumber();
1970 if( (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
1971 nCurrentSlideNumber = -1;
1972
1973 pPageMenu->EnableItem(pPageMenu->GetItemId("first"), mpSlideController->getSlideNumber(0) != nCurrentSlideNumber);
1974 pPageMenu->EnableItem(pPageMenu->GetItemId("last"), mpSlideController->getSlideNumber(mpSlideController->getSlideIndexCount() - 1) != nCurrentSlideNumber);
1975
1976 sal_Int32 nPageNumber;
1977
1978 for( nPageNumber = 0; nPageNumber < nPageNumberCount; nPageNumber++ )
1979 {
1980 if( mpSlideController->isVisibleSlideNumber( nPageNumber ) )
1981 {
1982 SdPage* pPage = mpDoc->GetSdPage(static_cast<sal_uInt16>(nPageNumber), PageKind::Standard);
1983 if (pPage)
1984 {
1985 pPageMenu->InsertItem( static_cast<sal_uInt16>(CM_SLIDES + nPageNumber), pPage->GetName() );
1986 if( nPageNumber == nCurrentSlideNumber )
1987 pPageMenu->CheckItem( static_cast<sal_uInt16>(CM_SLIDES + nPageNumber) );
1988 }
1989 }
1990 }
1991 }
1992 }
1993
1994 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
1995 {
1996 PopupMenu* pBlankMenu = pMenu->GetPopupMenu(pMenu->GetItemId("screen"));
1997 if( pBlankMenu )
1998 {
1999 pBlankMenu->CheckItem((mpShowWindow->GetBlankColor() == COL_WHITE) ? "white" : "black");
2000 }
2001 }
2002
2003 PopupMenu* pWidthMenu = pMenu->GetPopupMenu(pMenu->GetItemId("width"));
2004
2005 // populate color width list
2006 if( pWidthMenu )
2007 {
2008 sal_Int32 nIterator;
2009 double nWidth;
2010
2011 nWidth = 4.0;
2012 for( nIterator = 1; nIterator < 6; nIterator++)
2013 {
2014 switch(nIterator)
2015 {
2016 case 1:
2017 nWidth = 4.0;
2018 break;
2019 case 2:
2020 nWidth = 100.0;
2021 break;
2022 case 3:
2023 nWidth = 150.0;
2024 break;
2025 case 4:
2026 nWidth = 200.0;
2027 break;
2028 case 5:
2029 nWidth = 400.0;
2030 break;
2031 default:
2032 break;
2033 }
2034
2035 if (nWidth == mdUserPaintStrokeWidth)
2036 pWidthMenu->CheckItem(pWidthMenu->GetItemId(OString::number(nWidth)));
2037 }
2038 }
2039
2040 pMenu->SetSelectHdl( LINK( this, SlideshowImpl, ContextMenuSelectHdl ) );
2041 pMenu->Execute( mpShowWindow, maPopupMousePos );
2042
2043 if( mxView.is() )
2044 mxView->ignoreNextMouseReleased();
2045
2046 if( !mbWasPaused )
2047 resume();
2048 }
2049
2050 IMPL_LINK( SlideshowImpl, ContextMenuSelectHdl, Menu *, pMenu, bool )
2051 {
2052 if (!pMenu)
2053 return false;
2054
2055 OString sMenuId = pMenu->GetCurItemIdent();
2056
2057 if (sMenuId == "prev")
2058 {
2059 gotoPreviousSlide();
2060 mbWasPaused = false;
2061 }
2062 else if(sMenuId == "next")
2063 {
2064 gotoNextSlide();
2065 mbWasPaused = false;
2066 }
2067 else if (sMenuId == "first")
2068 {
2069 gotoFirstSlide();
2070 mbWasPaused = false;
2071 }
2072 else if (sMenuId == "last")
2073 {
2074 gotoLastSlide();
2075 mbWasPaused = false;
2076 }
2077 else if (sMenuId == "black" || sMenuId == "white")
2078 {
2079 const Color aBlankColor(sMenuId == "white" ? COL_WHITE : COL_BLACK);
2080 if( mbWasPaused )
2081 {
2082 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_BLANK )
2083 {
2084 if( mpShowWindow->GetBlankColor() == aBlankColor )
2085 {
2086 mbWasPaused = false;
2087 mpShowWindow->RestartShow();
2088 return false;
2089 }
2090 }
2091 mpShowWindow->RestartShow();
2092 }
2093 if( mpShowWindow->SetBlankMode( mpSlideController->getCurrentSlideIndex(), aBlankColor ) )
2094 {
2095 pause();
2096 mbWasPaused = true;
2097 }
2098 }
2099 else if (sMenuId == "color")
2100 {
2101 //Open a color picker based on SvColorDialog
2102 ::Color aColor( mnUserPaintColor );
2103 SvColorDialog aColorDlg;
2104 aColorDlg.SetColor( aColor );
2105
2106 if (aColorDlg.Execute(mpShowWindow->GetFrameWeld()))
2107 {
2108 aColor = aColorDlg.GetColor();
2109 setPenColor(sal_Int32(aColor));
2110 }
2111 mbWasPaused = false;
2112 }
2113 else if (sMenuId == "4")
2114 {
2115 setPenWidth(4.0);
2116 mbWasPaused = false;
2117 }
2118 else if (sMenuId == "100")
2119 {
2120 setPenWidth(100.0);
2121 mbWasPaused = false;
2122 }
2123 else if (sMenuId == "150")
2124 {
2125 setPenWidth(150.0);
2126 mbWasPaused = false;
2127 }
2128 else if (sMenuId == "200")
2129 {
2130 setPenWidth(200.0);
2131 mbWasPaused = false;
2132 }
2133 else if (sMenuId == "400")
2134 {
2135 setPenWidth(400.0);
2136 mbWasPaused = false;
2137 }
2138 else if (sMenuId == "erase")
2139 {
2140 setEraseAllInk(true);
2141 mbWasPaused = false;
2142 }
2143 else if (sMenuId == "pen")
2144 {
2145 setUsePen(!mbUsePen);
2146 mbWasPaused = false;
2147 }
2148 else if (sMenuId == "edit")
2149 {
2150 // When in autoplay mode (pps/ppsx), offer editing of the presentation
2151 // Turn autostart off, else Impress will close when exiting the Presentation
2152 mpViewShell->GetDoc()->SetExitAfterPresenting(false);
2153 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
2154 {
2155 if( mpSlideController->getCurrentSlideNumber() != -1 )
2156 {
2157 mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
2158 }
2159 }
2160 endPresentation();
2161 }
2162 else if (sMenuId == "end")
2163 {
2164 // in case the user cancels the presentation, switch to current slide
2165 // in edit mode
2166 if( mpSlideController.get() && (ANIMATIONMODE_SHOW == meAnimationMode) )
2167 {
2168 if( mpSlideController->getCurrentSlideNumber() != -1 )
2169 {
2170 mnRestoreSlide = mpSlideController->getCurrentSlideNumber();
2171 }
2172 }
2173 endPresentation();
2174 }
2175 else
2176 {
2177 sal_Int32 nPageNumber = pMenu->GetCurItemId() - CM_SLIDES;
2178 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2179 if( (eMode == SHOWWINDOWMODE_END) || (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2180 {
2181 mpShowWindow->RestartShow( nPageNumber );
2182 }
2183 else if( nPageNumber != mpSlideController->getCurrentSlideNumber() )
2184 {
2185 displaySlideNumber( nPageNumber );
2186 }
2187 mbWasPaused = false;
2188 }
2189
2190 return false;
2191 }
2192
2193 Reference< XSlideShow > SlideshowImpl::createSlideShow()
2194 {
2195 Reference< XSlideShow > xShow;
2196
2197 try
2198 {
2199 Reference< uno::XComponentContext > xContext =
2200 ::comphelper::getProcessComponentContext();
2201
2202 xShow.set( presentation::SlideShow::create(xContext), UNO_QUERY_THROW );
2203 }
2204 catch( uno::Exception& )
2205 {
2206 SAL_WARN( "sd", "sd::SlideshowImpl::createSlideShow(), exception caught: "
2207 << comphelper::anyToString( cppu::getCaughtException() ) );
2208 }
2209
2210 return xShow;
2211 }
2212
2213 void SlideshowImpl::createSlideList( bool bAll, const OUString& rPresSlide )
2214 {
2215 const sal_uInt16 nSlideCount = mpDoc->GetSdPageCount( PageKind::Standard );
2216
2217 if( nSlideCount )
2218 {
2219 SdCustomShow* pCustomShow;
2220
2221 if( mpDoc->GetCustomShowList() && maPresSettings.mbCustomShow )
2222 pCustomShow = mpDoc->GetCustomShowList()->GetCurObject();
2223 else
2224 pCustomShow = nullptr;
2225
2226 // create animation slide controller
2227 AnimationSlideController::Mode eMode =
2228 ( pCustomShow && pCustomShow->PagesVector().size() ) ? AnimationSlideController::CUSTOM :
2229 (bAll ? AnimationSlideController::ALL : AnimationSlideController::FROM);
2230
2231 Reference< XDrawPagesSupplier > xDrawPages( mpDoc->getUnoModel(), UNO_QUERY_THROW );
2232 Reference< XIndexAccess > xSlides( xDrawPages->getDrawPages(), UNO_QUERY_THROW );
2233 mpSlideController.reset( new AnimationSlideController( xSlides, eMode ) );
2234
2235 if( eMode != AnimationSlideController::CUSTOM )
2236 {
2237 sal_Int32 nFirstVisibleSlide = 0;
2238
2239 // normal presentation
2240 if( !rPresSlide.isEmpty() )
2241 {
2242 sal_Int32 nSlide;
2243 bool bTakeNextAvailable = false;
2244
2245 for( nSlide = 0, nFirstVisibleSlide = -1;
2246 ( nSlide < nSlideCount ) && ( -1 == nFirstVisibleSlide ); nSlide++ )
2247 {
2248 SdPage* pTestSlide = mpDoc->GetSdPage( static_cast<sal_uInt16>(nSlide), PageKind::Standard );
2249
2250 if( pTestSlide->GetName() == rPresSlide )
2251 {
2252 if( pTestSlide->IsExcluded() )
2253 bTakeNextAvailable = true;
2254 else
2255 nFirstVisibleSlide = nSlide;
2256 }
2257 else if( bTakeNextAvailable && !pTestSlide->IsExcluded() )
2258 nFirstVisibleSlide = nSlide;
2259 }
2260
2261 if( -1 == nFirstVisibleSlide )
2262 nFirstVisibleSlide = 0;
2263 }
2264
2265 for( sal_Int32 i = 0; i < nSlideCount; i++ )
2266 {
2267 bool bVisible = ! mpDoc->GetSdPage( static_cast<sal_uInt16>(i), PageKind::Standard )->IsExcluded();
2268 if( bVisible || (eMode == AnimationSlideController::ALL) )
2269 mpSlideController->insertSlideNumber( i, bVisible );
2270 }
2271
2272 mpSlideController->setStartSlideNumber( nFirstVisibleSlide );
2273 }
2274 else
2275 {
2276 if( meAnimationMode != ANIMATIONMODE_SHOW && !rPresSlide.isEmpty() )
2277 {
2278 sal_Int32 nSlide;
2279 for( nSlide = 0; nSlide < nSlideCount; nSlide++ )
2280 if( rPresSlide == mpDoc->GetSdPage( static_cast<sal_uInt16>(nSlide), PageKind::Standard )->GetName() )
2281 break;
2282
2283 if( nSlide < nSlideCount )
2284 mpSlideController->insertSlideNumber( static_cast<sal_uInt16>(nSlide) );
2285 }
2286
2287 sal_Int32 nSlideIndex = 0;
2288 for( SdCustomShow::PageVec::iterator it = pCustomShow->PagesVector().begin();
2289 it != pCustomShow->PagesVector().end(); ++it, nSlideIndex++ )
2290 {
2291 const sal_uInt16 nSdSlide = ( (*it)->GetPageNum() - 1 ) / 2;
2292
2293 if( ! mpDoc->GetSdPage( nSdSlide, PageKind::Standard )->IsExcluded())
2294 mpSlideController->insertSlideNumber( nSdSlide );
2295 }
2296 }
2297 }
2298 }
2299
2300 typedef sal_uInt16 (*FncGetChildWindowId)();
2301
2302 static const FncGetChildWindowId aShowChildren[] =
2303 {
2304 &AnimationChildWindow::GetChildWindowId,
2305 &Svx3DChildWindow::GetChildWindowId,
2306 &SvxFontWorkChildWindow::GetChildWindowId,
2307 &SvxColorChildWindow::GetChildWindowId,
2308 &SvxSearchDialogWrapper::GetChildWindowId,
2309 &SvxBmpMaskChildWindow::GetChildWindowId,
2310 &SvxIMapDlgChildWindow::GetChildWindowId,
2311 &SvxHlinkDlgWrapper::GetChildWindowId,
2312 &SfxInfoBarContainerChild::GetChildWindowId
2313 };
2314
2315 void SlideshowImpl::hideChildWindows()
2316 {
2317 mnChildMask = 0;
2318
2319 if( ANIMATIONMODE_SHOW == meAnimationMode )
2320 {
2321 SfxViewFrame* pViewFrame = getViewFrame();
2322
2323 if( pViewFrame )
2324 {
2325 for( sal_uLong i = 0; i < SAL_N_ELEMENTS( aShowChildren ); i++ )
2326 {
2327 const sal_uInt16 nId = ( *aShowChildren[ i ] )();
2328
2329 if( pViewFrame->GetChildWindow( nId ) )
2330 {
2331 pViewFrame->SetChildWindow( nId, false );
2332 mnChildMask |= 1 << i;
2333 }
2334 }
2335 }
2336 }
2337 }
2338
2339 void SlideshowImpl::showChildWindows()
2340 {
2341 if( ANIMATIONMODE_SHOW == meAnimationMode )
2342 {
2343 SfxViewFrame* pViewFrame = getViewFrame();
2344 if( pViewFrame )
2345 {
2346 for( sal_uLong i = 0; i < SAL_N_ELEMENTS(aShowChildren); i++ )
2347 {
2348 if( mnChildMask & ( 1 << i ) )
2349 pViewFrame->SetChildWindow( ( *aShowChildren[ i ] )(), true );
2350 }
2351 }
2352 }
2353 }
2354
2355 SfxViewFrame* SlideshowImpl::getViewFrame() const
2356 {
2357 return mpViewShell ? mpViewShell->GetViewFrame() : nullptr;
2358 }
2359
2360 SfxDispatcher* SlideshowImpl::getDispatcher() const
2361 {
2362 return (mpViewShell && mpViewShell->GetViewFrame()) ? mpViewShell->GetViewFrame()->GetDispatcher() : nullptr;
2363 }
2364
2365 SfxBindings* SlideshowImpl::getBindings() const
2366 {
2367 return (mpViewShell && mpViewShell->GetViewFrame()) ? &mpViewShell->GetViewFrame()->GetBindings() : nullptr;
2368 }
2369
2370 void SlideshowImpl::resize( const Size& rSize )
2371 {
2372 maPresSize = rSize;
2373
2374 if(mpShowWindow)
2375 {
2376 mpShowWindow->SetSizePixel( maPresSize );
2377 mpShowWindow->Show();
2378 }
2379
2380 if( mxView.is() ) try
2381 {
2382 awt::WindowEvent aEvt;
2383 mxView->windowResized(aEvt);
2384 }
2385 catch( Exception& )
2386 {
2387 SAL_WARN( "sd", "sd::SlideshowImpl::resize(), exception caught: "
2388 << comphelper::anyToString( cppu::getCaughtException() ) );
2389 }
2390 }
2391
2392 void SlideshowImpl::setActiveXToolbarsVisible( bool bVisible )
2393 {
2394 // in case of ActiveX control the toolbars should not be visible if slide show runs in window mode
2395 // actually it runs always in window mode in case of ActiveX control
2396 if ( !maPresSettings.mbFullScreen && mpDocSh && mpDocSh->GetMedium() )
2397 {
2398 const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(mpDocSh->GetMedium()->GetItemSet(), SID_VIEWONLY, false);
2399 if ( pItem && pItem->GetValue() )
2400 {
2401 // this is a plugin/activex mode, no toolbars should be visible during slide show
2402 // after the end of slide show they should be visible again
2403 SfxViewFrame* pViewFrame = getViewFrame();
2404 if( pViewFrame )
2405 {
2406 try
2407 {
2408 Reference< frame::XLayoutManager > xLayoutManager;
2409 Reference< beans::XPropertySet > xFrameProps( pViewFrame->GetFrame().GetFrameInterface(), UNO_QUERY_THROW );
2410 if ( ( xFrameProps->getPropertyValue( "LayoutManager" )
2411 >>= xLayoutManager )
2412 && xLayoutManager.is() )
2413 {
2414 xLayoutManager->setVisible( bVisible );
2415 }
2416 }
2417 catch( uno::Exception& )
2418 {}
2419 }
2420 }
2421 }
2422 }
2423
2424 void SAL_CALL SlideshowImpl::activate()
2425 {
2426 SolarMutexGuard aSolarGuard;
2427
2428 maDeactivateTimer.Stop();
2429
2430 if( !mbActive && mxShow.is() )
2431 {
2432 mbActive = true;
2433
2434 if( ANIMATIONMODE_SHOW == meAnimationMode )
2435 {
2436 if( mbAutoSaveWasOn )
2437 setAutoSaveState( false );
2438
2439 if( mpShowWindow )
2440 {
2441 SfxViewFrame* pViewFrame = getViewFrame();
2442 SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : nullptr;
2443
2444 hideChildWindows();
2445
2446 if( pDispatcher )
2447 {
2448 // filter all forbidden slots
2449 pDispatcher->SetSlotFilter( SfxSlotFilterState::ENABLED, pAllowed );
2450 }
2451
2452 if( getBindings() )
2453 getBindings()->InvalidateAll(true);
2454
2455 mpShowWindow->GrabFocus();
2456 }
2457 }
2458
2459 resume();
2460 }
2461 }
2462
2463 void SAL_CALL SlideshowImpl::deactivate()
2464 {
2465 SolarMutexGuard aSolarGuard;
2466
2467 if( mbActive && mxShow.is() )
2468 {
2469 maDeactivateTimer.Start();
2470 }
2471 }
2472
2473 IMPL_LINK_NOARG(SlideshowImpl, deactivateHdl, Timer *, void)
2474 {
2475 if( mbActive && mxShow.is() )
2476 {
2477 mbActive = false;
2478
2479 pause();
2480
2481 if( ANIMATIONMODE_SHOW == meAnimationMode )
2482 {
2483 if( mbAutoSaveWasOn )
2484 setAutoSaveState( true );
2485
2486 if( mpShowWindow )
2487 {
2488 showChildWindows();
2489 }
2490 }
2491 }
2492 }
2493
2494 sal_Bool SAL_CALL SlideshowImpl::isActive()
2495 {
2496 SolarMutexGuard aSolarGuard;
2497 return mbActive;
2498 }
2499
2500 void SlideshowImpl::setAutoSaveState( bool bOn)
2501 {
2502 try
2503 {
2504 uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
2505
2506 uno::Reference< util::XURLTransformer > xParser(util::URLTransformer::create(xContext));
2507 util::URL aURL;
2508 aURL.Complete = "vnd.sun.star.autorecovery:/setAutoSaveState";
2509 xParser->parseStrict(aURL);
2510
2511 Sequence< beans::PropertyValue > aArgs(1);
2512 aArgs[0].Name = "AutoSaveState";
2513 aArgs[0].Value <<= bOn;
2514
2515 uno::Reference< frame::XDispatch > xAutoSave = frame::theAutoRecovery::get(xContext);
2516 xAutoSave->dispatch(aURL, aArgs);
2517 }
2518 catch( Exception& )
2519 {
2520 OSL_FAIL("sd::SlideshowImpl::setAutoSaveState(), exception caught!");
2521 }
2522 }
2523
2524 Reference< XDrawPage > SAL_CALL SlideshowImpl::getCurrentSlide()
2525 {
2526 SolarMutexGuard aSolarGuard;
2527
2528 Reference< XDrawPage > xSlide;
2529 if( mxShow.is() && mpSlideController.get() )
2530 {
2531 sal_Int32 nSlide = getCurrentSlideNumber();
2532 if( (nSlide >= 0) && (nSlide < mpSlideController->getSlideNumberCount() ) )
2533 xSlide = mpSlideController->getSlideByNumber( nSlide );
2534 }
2535
2536 return xSlide;
2537 }
2538
2539 sal_Int32 SAL_CALL SlideshowImpl::getNextSlideIndex()
2540 {
2541 SolarMutexGuard aSolarGuard;
2542
2543 if( mxShow.is() )
2544 {
2545 return mpSlideController->getNextSlideIndex();
2546 }
2547 else
2548 {
2549 return -1;
2550 }
2551 }
2552
2553 sal_Int32 SAL_CALL SlideshowImpl::getCurrentSlideIndex()
2554 {
2555 return mpSlideController.get() ? mpSlideController->getCurrentSlideIndex() : -1;
2556 }
2557
2558 // css::presentation::XSlideShowController:
2559
2560 ::sal_Int32 SAL_CALL SlideshowImpl::getSlideCount()
2561 {
2562 return mpSlideController.get() ? mpSlideController->getSlideIndexCount() : 0;
2563 }
2564
2565 Reference< XDrawPage > SAL_CALL SlideshowImpl::getSlideByIndex(::sal_Int32 Index)
2566 {
2567 if( (mpSlideController.get() == nullptr ) || (Index < 0) || (Index >= mpSlideController->getSlideIndexCount() ) )
2568 throw IndexOutOfBoundsException();
2569
2570 return mpSlideController->getSlideByNumber( mpSlideController->getSlideNumber( Index ) );
2571 }
2572
2573 sal_Bool SAL_CALL SlideshowImpl::getAlwaysOnTop()
2574 {
2575 SolarMutexGuard aSolarGuard;
2576 return maPresSettings.mbAlwaysOnTop;
2577 }
2578
2579 void SAL_CALL SlideshowImpl::setAlwaysOnTop( sal_Bool bAlways )
2580 {
2581 SolarMutexGuard aSolarGuard;
2582 if( maPresSettings.mbAlwaysOnTop != bool(bAlways) )
2583 {
2584 maPresSettings.mbAlwaysOnTop = bAlways;
2585 // todo, can this be changed while running?
2586 }
2587 }
2588
2589 sal_Bool SAL_CALL SlideshowImpl::isFullScreen()
2590 {
2591 SolarMutexGuard aSolarGuard;
2592 return maPresSettings.mbFullScreen;
2593 }
2594
2595 sal_Bool SAL_CALL SlideshowImpl::getMouseVisible()
2596 {
2597 SolarMutexGuard aSolarGuard;
2598 return maPresSettings.mbMouseVisible;
2599 }
2600
2601 void SAL_CALL SlideshowImpl::setMouseVisible( sal_Bool bVisible )
2602 {
2603 SolarMutexGuard aSolarGuard;
2604 if( maPresSettings.mbMouseVisible != bool(bVisible) )
2605 {
2606 maPresSettings.mbMouseVisible = bVisible;
2607 if( mpShowWindow )
2608 mpShowWindow->SetMouseAutoHide( !maPresSettings.mbMouseVisible );
2609 }
2610 }
2611
2612 sal_Bool SAL_CALL SlideshowImpl::getUsePen()
2613 {
2614 SolarMutexGuard aSolarGuard;
2615 return mbUsePen;
2616 }
2617
2618 void SAL_CALL SlideshowImpl::setUsePen( sal_Bool bMouseAsPen )
2619 {
2620 SolarMutexGuard aSolarGuard;
2621 mbUsePen = bMouseAsPen;
2622 if( mxShow.is() ) try
2623 {
2624 // For Pencolor;
2625 Any aValue;
2626 if( mbUsePen )
2627 aValue <<= mnUserPaintColor;
2628 beans::PropertyValue aPenProp;
2629 aPenProp.Name = "UserPaintColor";
2630 aPenProp.Value = aValue;
2631 mxShow->setProperty( aPenProp );
2632
2633 //for StrokeWidth :
2634 if( mbUsePen )
2635 {
2636 beans::PropertyValue aPenPropWidth;
2637 aPenPropWidth.Name = "UserPaintStrokeWidth";
2638 aPenPropWidth.Value <<= mdUserPaintStrokeWidth;
2639 mxShow->setProperty( aPenPropWidth );
2640
2641 // for Pen Mode
2642 beans::PropertyValue aPenPropSwitchPenMode;
2643 aPenPropSwitchPenMode.Name = "SwitchPenMode";
2644 aPenPropSwitchPenMode.Value <<= true;
2645 mxShow->setProperty( aPenPropSwitchPenMode );
2646 }
2647 }
2648 catch( Exception& )
2649 {
2650 SAL_WARN( "sd", "sd::SlideshowImpl::setUsePen(), exception caught: "
2651 << comphelper::anyToString( cppu::getCaughtException() ) );
2652 }
2653 }
2654
2655 double SAL_CALL SlideshowImpl::getPenWidth()
2656 {
2657 SolarMutexGuard aSolarGuard;
2658 return mdUserPaintStrokeWidth;
2659 }
2660
2661 void SAL_CALL SlideshowImpl::setPenWidth( double dStrokeWidth )
2662 {
2663 SolarMutexGuard aSolarGuard;
2664 mdUserPaintStrokeWidth = dStrokeWidth;
2665 setUsePen( true ); // enable pen mode, update color and width
2666 }
2667
2668 sal_Int32 SAL_CALL SlideshowImpl::getPenColor()
2669 {
2670 SolarMutexGuard aSolarGuard;
2671 return mnUserPaintColor;
2672 }
2673
2674 void SAL_CALL SlideshowImpl::setPenColor( sal_Int32 nColor )
2675 {
2676 SolarMutexGuard aSolarGuard;
2677 mnUserPaintColor = nColor;
2678 setUsePen( true ); // enable pen mode, update color
2679 }
2680
2681 void SlideshowImpl::setEraseAllInk(bool bEraseAllInk)
2682 {
2683 if( bEraseAllInk )
2684 {
2685 SolarMutexGuard aSolarGuard;
2686 if( mxShow.is() ) try
2687 {
2688 beans::PropertyValue aPenPropEraseAllInk;
2689 aPenPropEraseAllInk.Name = "EraseAllInk";
2690 aPenPropEraseAllInk.Value <<= bEraseAllInk;
2691 mxShow->setProperty( aPenPropEraseAllInk );
2692 }
2693 catch( Exception& )
2694 {
2695 SAL_WARN( "sd.slideshow", "sd::SlideshowImpl::setEraseAllInk(), "
2696 "exception caught: " << comphelper::anyToString( cppu::getCaughtException() ));
2697 }
2698 }
2699 }
2700
2701 // XSlideShowController Methods
2702 sal_Bool SAL_CALL SlideshowImpl::isRunning( )
2703 {
2704 SolarMutexGuard aSolarGuard;
2705 return mxShow.is();
2706 }
2707
2708 void SAL_CALL SlideshowImpl::gotoNextEffect( )
2709 {
2710 SolarMutexGuard aSolarGuard;
2711
2712 if( mxShow.is() && mpSlideController.get() && mpShowWindow )
2713 {
2714 if( mbIsPaused )
2715 resume();
2716
2717 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2718 if( eMode == SHOWWINDOWMODE_END )
2719 {
2720 endPresentation();
2721 }
2722 else if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2723 {
2724 mpShowWindow->RestartShow();
2725 }
2726 else
2727 {
2728 mxShow->nextEffect();
2729 update();
2730 }
2731 }
2732 }
2733
2734 void SAL_CALL SlideshowImpl::gotoPreviousEffect( )
2735 {
2736 SolarMutexGuard aSolarGuard;
2737
2738 if( mxShow.is() && mpSlideController.get() && mpShowWindow )
2739 {
2740 if( mbIsPaused )
2741 resume();
2742
2743 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2744 if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2745 {
2746 mpShowWindow->RestartShow();
2747 }
2748 else
2749 {
2750 mxShow->previousEffect();
2751 update();
2752 }
2753 }
2754 }
2755
2756 void SAL_CALL SlideshowImpl::gotoFirstSlide( )
2757 {
2758 SolarMutexGuard aSolarGuard;
2759
2760 if( mpShowWindow && mpSlideController.get() )
2761 {
2762 if( mbIsPaused )
2763 resume();
2764
2765 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_END )
2766 {
2767 if( mpSlideController->getSlideIndexCount() )
2768 mpShowWindow->RestartShow( 0);
2769 }
2770 else
2771 {
2772 displaySlideIndex( 0 );
2773 }
2774 }
2775 }
2776
2777 void SAL_CALL SlideshowImpl::gotoNextSlide( )
2778 {
2779 SolarMutexGuard aSolarGuard;
2780
2781 if( mbIsPaused )
2782 resume();
2783
2784 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2785 if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2786 {
2787 mpShowWindow->RestartShow();
2788 }
2789 else
2790 {
2791 // if this is a show, ignore user inputs and
2792 // start 20ms timer to reenable inputs to filter
2793 // buffered inputs during slide transition
2794 if( meAnimationMode == ANIMATIONMODE_SHOW )
2795 {
2796 mbInputFreeze = true;
2797 maInputFreezeTimer.Start();
2798 }
2799
2800 if( mpSlideController.get() )
2801 {
2802 if( mpSlideController->nextSlide() )
2803 {
2804 displayCurrentSlide();
2805 }
2806 else
2807 {
2808 stopSound();
2809
2810 if( meAnimationMode == ANIMATIONMODE_PREVIEW )
2811 {
2812 endPresentation();
2813 }
2814 else if( maPresSettings.mbEndless )
2815 {
2816 if( maPresSettings.mnPauseTimeout )
2817 {
2818 if( mpShowWindow )
2819 {
2820 if ( maPresSettings.mbShowPauseLogo )
2821 {
2822 Graphic aGraphic(SfxApplication::GetApplicationLogo(360));
2823 mpShowWindow->SetPauseMode( maPresSettings.mnPauseTimeout, &aGraphic );
2824 }
2825 else
2826 mpShowWindow->SetPauseMode( maPresSettings.mnPauseTimeout );
2827 }
2828 }
2829 else
2830 {
2831 displaySlideIndex( 0 );
2832 }
2833 }
2834 else
2835 {
2836 if( mpShowWindow )
2837 {
2838 mpShowWindow->SetEndMode();
2839 if( !mpViewShell->GetDoc()->IsStartWithPresentation() )
2840 pause();
2841 }
2842 }
2843 }
2844 }
2845 }
2846 }
2847
2848 void SAL_CALL SlideshowImpl::gotoPreviousSlide( )
2849 {
2850 gotoPreviousSlide(false);
2851 }
2852
2853 void SlideshowImpl::gotoPreviousSlide (const bool bSkipAllMainSequenceEffects)
2854 {
2855 SolarMutexGuard aSolarGuard;
2856
2857 if( mxShow.is() && mpSlideController.get() ) try
2858 {
2859 if( mbIsPaused )
2860 resume();
2861
2862 const ShowWindowMode eMode = mpShowWindow->GetShowWindowMode();
2863 if( eMode == SHOWWINDOWMODE_END )
2864 {
2865 mpShowWindow->RestartShow( mpSlideController->getCurrentSlideIndex() );
2866 }
2867 else if( (eMode == SHOWWINDOWMODE_PAUSE) || (eMode == SHOWWINDOWMODE_BLANK) )
2868 {
2869 mpShowWindow->RestartShow();
2870 }
2871 else
2872 {
2873 if( mpSlideController->previousSlide())
2874 displayCurrentSlide(bSkipAllMainSequenceEffects);
2875 else if (bSkipAllMainSequenceEffects)
2876 {
2877 // We could not go to the previous slide (probably because
2878 // the current slide is already the first one). We still
2879 // have to call displayCurrentSlide because the calling
2880 // slideshow can not determine whether there is a previous
2881 // slide or not and has already prepared for a slide change.
2882 // This slide change has to be completed now, even when
2883 // changing to the same slide.
2884 // Note that in this special case we do NOT pass
2885 // bSkipAllMainSequenceEffects because we display the same
2886 // slide as before and do not want to show all its effects.
2887 displayCurrentSlide();
2888 }
2889 }
2890 }
2891 catch( Exception& )
2892 {
2893 SAL_WARN( "sd", "sd::SlideshowImpl::gotoPreviousSlide(), exception caught: "
2894 << comphelper::anyToString( cppu::getCaughtException() ) );
2895 }
2896 }
2897
2898 void SAL_CALL SlideshowImpl::gotoLastSlide()
2899 {
2900 SolarMutexGuard aSolarGuard;
2901
2902 if( mpSlideController.get() )
2903 {
2904 if( mbIsPaused )
2905 resume();
2906
2907 const sal_Int32 nLastSlideIndex = mpSlideController->getSlideIndexCount() - 1;
2908 if( nLastSlideIndex >= 0 )
2909 {
2910 if( mpShowWindow->GetShowWindowMode() == SHOWWINDOWMODE_END )
2911 {
2912 mpShowWindow->RestartShow( nLastSlideIndex );
2913 }
2914 else
2915 {
2916 displaySlideIndex( nLastSlideIndex );
2917 }
2918 }
2919 }
2920 }
2921
2922 void SAL_CALL SlideshowImpl::gotoBookmark( const OUString& rBookmark )
2923 {
2924 SolarMutexGuard aSolarGuard;
2925
2926 if( mbIsPaused )
2927 resume();
2928
2929 sal_Int32 nSlideNumber = getSlideNumberForBookmark( rBookmark );
2930 if( nSlideNumber != -1 )
2931 displaySlideNumber( nSlideNumber );
2932 }
2933
2934 void SAL_CALL SlideshowImpl::gotoSlide( const Reference< XDrawPage >& xSlide )
2935 {
2936 SolarMutexGuard aSolarGuard;
2937
2938 if( mpSlideController.get() && xSlide.is() )
2939 {
2940 if( mbIsPaused )
2941 resume();
2942
2943 const sal_Int32 nSlideCount = mpSlideController->getSlideNumberCount();
2944 for( sal_Int32 nSlide = 0; nSlide < nSlideCount; nSlide++ )
2945 {
2946 if( mpSlideController->getSlideByNumber( nSlide ) == xSlide )
2947 {
2948 displaySlideNumber( nSlide );
2949 }
2950 }
2951 }
2952 }
2953
2954 void SAL_CALL SlideshowImpl::gotoSlideIndex( sal_Int32 nIndex )
2955 {
2956 SolarMutexGuard aSolarGuard;
2957
2958 if( mbIsPaused )
2959 resume();
2960
2961 displaySlideIndex( nIndex );
2962 }
2963
2964 void SAL_CALL SlideshowImpl::stopSound( )
2965 {
2966 SolarMutexGuard aSolarGuard;
2967
2968 try
2969 {
2970 if( mxPlayer.is() )
2971 {
2972 mxPlayer->stop();
2973 mxPlayer.clear();
2974 }
2975 }
2976 catch( Exception& )
2977 {
2978 SAL_WARN( "sd", "sd::SlideshowImpl::stopSound(), exception caught: "
2979 << comphelper::anyToString( cppu::getCaughtException() ) );
2980 }
2981 }
2982
2983 // XIndexAccess
2984
2985 ::sal_Int32 SAL_CALL SlideshowImpl::getCount( )
2986 {
2987 return getSlideCount();
2988 }
2989
2990 css::uno::Any SAL_CALL SlideshowImpl::getByIndex( ::sal_Int32 Index )
2991 {
2992 return Any( getSlideByIndex( Index ) );
2993 }
2994
2995 css::uno::Type SAL_CALL SlideshowImpl::getElementType( )
2996 {
2997 return cppu::UnoType<XDrawPage>::get();
2998 }
2999
3000 sal_Bool SAL_CALL SlideshowImpl::hasElements( )
3001 {
3002 return getSlideCount() != 0;
3003 }
3004
3005 Reference< XSlideShow > SAL_CALL SlideshowImpl::getSlideShow()
3006 {
3007 return mxShow;
3008 }
3009
3010 PresentationSettingsEx::PresentationSettingsEx( const PresentationSettingsEx& r )
3011 : PresentationSettings( r )
3012 , mbRehearseTimings(r.mbRehearseTimings)
3013 , mbPreview(r.mbPreview)
3014 , mpParentWindow( nullptr )
3015 {
3016 }
3017
3018 PresentationSettingsEx::PresentationSettingsEx( PresentationSettings const & r )
3019 : PresentationSettings( r )
3020 , mbRehearseTimings(false)
3021 , mbPreview(false)
3022 , mpParentWindow(nullptr)
3023 {
3024 }
3025
3026 void PresentationSettingsEx::SetArguments( const Sequence< PropertyValue >& rArguments )
3027 {
3028 sal_Int32 nArguments = rArguments.getLength();
3029 const PropertyValue* pValue = rArguments.getConstArray();
3030
3031 while( nArguments-- )
3032 {
3033 SetPropertyValue( pValue->Name, pValue->Value );
3034 pValue++;
3035 }
3036 }
3037
3038 void PresentationSettingsEx::SetPropertyValue( const OUString& rProperty, const Any& rValue )
3039 {
3040 if ( rProperty == "RehearseTimings" )
3041 {
3042 if( rValue >>= mbRehearseTimings )
3043 return;
3044 }
3045 else if ( rProperty == "Preview" )
3046 {
3047 if( rValue >>= mbPreview )
3048 return;
3049 }
3050 else if ( rProperty == "AnimationNode" )
3051 {
3052 if( rValue >>= mxAnimationNode )
3053 return;
3054 }
3055 else if ( rProperty == "ParentWindow" )
3056 {
3057 Reference< XWindow > xWindow;
3058 if( rValue >>= xWindow )
3059 {
3060 mpParentWindow = xWindow.is() ? VCLUnoHelper::GetWindow( xWindow )
3061 : VclPtr<vcl::Window>();
3062 return;
3063 }
3064 }
3065 else if ( rProperty == "AllowAnimations" )
3066 {
3067 if( rValue >>= mbAnimationAllowed )
3068 return;
3069 }
3070 else if ( rProperty == "FirstPage" )
3071 {
3072 OUString aPresPage;
3073 if( rValue >>= aPresPage )
3074 {
3075 maPresPage = getUiNameFromPageApiNameImpl(aPresPage);
3076 mbCustomShow = false;
3077 mbAll = false;
3078 return;
3079 }
3080 else
3081 {
3082 if( rValue >>= mxStartPage )
3083 return;
3084 }
3085 }
3086 else if ( rProperty == "IsAlwaysOnTop" )
3087 {
3088 if( rValue >>= mbAlwaysOnTop )
3089 return;
3090 }
3091 else if ( rProperty == "IsAutomatic" )
3092 {
3093 if( rValue >>= mbManual )
3094 return;
3095 }
3096 else if ( rProperty == "IsEndless" )
3097 {
3098 if( rValue >>= mbEndless )
3099 return;
3100 }
3101 else if ( rProperty == "IsFullScreen" )
3102 {
3103 if( rValue >>= mbFullScreen )
3104 return;
3105 }
3106 else if ( rProperty == "IsMouseVisible" )
3107 {
3108 if( rValue >>= mbMouseVisible )
3109 return;
3110 }
3111 else if ( rProperty == "Pause" )
3112 {
3113 sal_Int32 nPause = -1;
3114 if( (rValue >>= nPause) && (nPause >= 0) )
3115 {
3116 mnPauseTimeout = nPause;
3117 return;
3118 }
3119 }
3120 else if ( rProperty == "UsePen" )
3121 {
3122 if( rValue >>= mbMouseAsPen )
3123 return;
3124 }
3125 throw IllegalArgumentException();
3126 }
3127
3128 // XAnimationListener
3129
3130 SlideShowListenerProxy::SlideShowListenerProxy( const rtl::Reference< SlideshowImpl >& xController, const css::uno::Reference< css::presentation::XSlideShow >& xSlideShow )
3131 : maListeners( m_aMutex )
3132 , mxController( xController )
3133 , mxSlideShow( xSlideShow )
3134 {
3135 }
3136
3137 SlideShowListenerProxy::~SlideShowListenerProxy()
3138 {
3139 }
3140
3141 void SlideShowListenerProxy::addAsSlideShowListener()
3142 {
3143 if( mxSlideShow.is() )
3144 {
3145 Reference< XSlideShowListener > xSlideShowListener( this );
3146 mxSlideShow->addSlideShowListener( xSlideShowListener );
3147 }
3148 }
3149
3150 void SlideShowListenerProxy::removeAsSlideShowListener()
3151 {
3152 if( mxSlideShow.is() )
3153 {
3154 Reference< XSlideShowListener > xSlideShowListener( this );
3155 mxSlideShow->removeSlideShowListener( xSlideShowListener );
3156 }
3157 }
3158
3159 void SlideShowListenerProxy::addShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape )
3160 {
3161 if( mxSlideShow.is() )
3162 {
3163 Reference< XShapeEventListener > xListener( this );
3164 mxSlideShow->addShapeEventListener( xListener, xShape );
3165 }
3166 }
3167
3168 void SlideShowListenerProxy::removeShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape )
3169 {
3170 if( mxSlideShow.is() )
3171 {
3172 Reference< XShapeEventListener > xListener( this );
3173 mxSlideShow->removeShapeEventListener( xListener, xShape );
3174 }
3175 }
3176
3177 void SlideShowListenerProxy::addSlideShowListener( const css::uno::Reference< css::presentation::XSlideShowListener >& xListener )
3178 {
3179 maListeners.addInterface(xListener);
3180 }
3181
3182 void SlideShowListenerProxy::removeSlideShowListener( const css::uno::Reference< css::presentation::XSlideShowListener >& xListener )
3183 {
3184 maListeners.removeInterface(xListener);
3185 }
3186
3187 void SAL_CALL SlideShowListenerProxy::beginEvent( const Reference< XAnimationNode >& xNode )
3188 {
3189 ::osl::MutexGuard aGuard( m_aMutex );
3190
3191 if( maListeners.getLength() >= 0 )
3192 {
3193 maListeners.forEach<XSlideShowListener>(
3194 [&] (Reference<XAnimationListener> const& xListener) {
3195 return xListener->beginEvent(xNode);
3196 } );
3197 }
3198 }
3199
3200 void SAL_CALL SlideShowListenerProxy::endEvent( const Reference< XAnimationNode >& xNode )
3201 {
3202 ::osl::MutexGuard aGuard( m_aMutex );
3203
3204 if( maListeners.getLength() >= 0 )
3205 {
3206 maListeners.forEach<XSlideShowListener>(
3207 [&] (Reference<XAnimationListener> const& xListener) {
3208 return xListener->endEvent(xNode);
3209 } );
3210 }
3211 }
3212
3213 void SAL_CALL SlideShowListenerProxy::repeat( const Reference< XAnimationNode >& xNode, ::sal_Int32 nRepeat )
3214 {
3215 ::osl::MutexGuard aGuard( m_aMutex );
3216
3217 if( maListeners.getLength() >= 0 )
3218 {
3219 maListeners.forEach<XSlideShowListener>(
3220 [&] (Reference<XAnimationListener> const& xListener) {
3221 return xListener->repeat(xNode, nRepeat);
3222 } );
3223 }
3224 }
3225
3226 // css::presentation::XSlideShowListener:
3227
3228 void SAL_CALL SlideShowListenerProxy::paused( )
3229 {
3230 ::osl::MutexGuard aGuard( m_aMutex );
3231
3232 maListeners.forEach<XSlideShowListener>(
3233 [](uno::Reference<presentation::XSlideShowListener> const& xListener)
3234 {
3235 xListener->paused();
3236 });
3237 }
3238
3239 void SAL_CALL SlideShowListenerProxy::resumed( )
3240 {
3241 ::osl::MutexGuard aGuard( m_aMutex );
3242
3243 maListeners.forEach<XSlideShowListener>(
3244 [](uno::Reference<presentation::XSlideShowListener> const& xListener)
3245 {
3246 xListener->resumed();
3247 });
3248 }
3249
3250 void SAL_CALL SlideShowListenerProxy::slideTransitionStarted( )
3251 {
3252 ::osl::MutexGuard aGuard( m_aMutex );
3253
3254 maListeners.forEach<XSlideShowListener>(
3255 [](uno::Reference<presentation::XSlideShowListener> const& xListener)
3256 {
3257 xListener->slideTransitionStarted();
3258 });
3259 }
3260
3261 void SAL_CALL SlideShowListenerProxy::slideTransitionEnded( )
3262 {
3263 ::osl::MutexGuard aGuard( m_aMutex );
3264
3265 maListeners.forEach<XSlideShowListener>(
3266 [](uno::Reference<presentation::XSlideShowListener> const& xListener)
3267 {
3268 xListener->slideTransitionEnded ();
3269 });
3270 }
3271
3272 void SAL_CALL SlideShowListenerProxy::slideAnimationsEnded( )
3273 {
3274 ::osl::MutexGuard aGuard( m_aMutex );
3275
3276 maListeners.forEach<XSlideShowListener>(
3277 [](uno::Reference<presentation::XSlideShowListener> const& xListener)
3278 {
3279 xListener->slideAnimationsEnded ();
3280 });
3281 }
3282
3283 void SlideShowListenerProxy::slideEnded(sal_Bool bReverse)
3284 {
3285 {
3286 ::osl::MutexGuard aGuard( m_aMutex );
3287
3288 if( maListeners.getLength() >= 0 )
3289 {
3290 maListeners.forEach<XSlideShowListener>(
3291 [&] (Reference<XSlideShowListener> const& xListener) {
3292 return xListener->slideEnded(bReverse);
3293 } );
3294 }
3295 }
3296
3297 {
3298 SolarMutexGuard aSolarGuard;
3299 if( mxController.is() )
3300 mxController->slideEnded(bReverse);
3301 }
3302 }
3303
3304 void SlideShowListenerProxy::hyperLinkClicked( OUString const& aHyperLink )
3305 {
3306 {
3307 ::osl::MutexGuard aGuard( m_aMutex );
3308
3309 if( maListeners.getLength() >= 0 )
3310 {
3311 maListeners.forEach<XSlideShowListener>(
3312 [&] (Reference<XSlideShowListener> const& xListener) {
3313 return xListener->hyperLinkClicked(aHyperLink);
3314 } );
3315 }
3316 }
3317
3318 {
3319 SolarMutexGuard aSolarGuard;
3320 if( mxController.is() )
3321 mxController->hyperLinkClicked(aHyperLink);
3322 }
3323 }
3324
3325 // XEventListener
3326
3327 void SAL_CALL SlideShowListenerProxy::disposing( const css::lang::EventObject& aDisposeEvent )
3328 {
3329 maListeners.disposeAndClear( aDisposeEvent );
3330 mxController.clear();
3331 mxSlideShow.clear();
3332 }
3333
3334 // XShapeEventListener
3335
3336 void SAL_CALL SlideShowListenerProxy::click( const Reference< XShape >& xShape, const css::awt::MouseEvent& /*aOriginalEvent*/ )
3337 {
3338 SolarMutexGuard aSolarGuard;
3339 if( mxController.is() )
3340 mxController->click(xShape );
3341 }
3342
3343 } // namespace ::sd
3344
3345 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE