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