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