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