/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
/** During animations the update() method tells its caller to call it as soon as possible. This gives us more time to render the next frame and still maintain a steady frame rate. This class is responsible for synchronizing the display of new frames and thus keeping the frame rate steady.
*/ class FrameSynchronization
{ public: /** Create new object with a predefined duration between two frames. @param nFrameDuration The preferred duration between the display of two frames in seconds.
*/ explicit FrameSynchronization (constdouble nFrameDuration);
/** Set the current time as the time at which the current frame is displayed. From this the target time of the next frame is derived.
*/ void MarkCurrentFrame();
/** When there is time left until the next frame is due then wait. Otherwise return without delay.
*/ void Synchronize();
/** Activate frame synchronization when an animation is active and frames are to be displayed in a steady rate. While active Synchronize() will wait until the frame duration time has passed.
*/ void Activate();
/** Deactivate frame synchronization when no animation is active and the time between frames depends on user actions and other external sources. While deactivated Synchronize() will return without delay.
*/ void Deactivate();
private: /** The timer that is used for synchronization is independent from the one used by SlideShowImpl: it is not paused or modified by animations.
*/
canvas::tools::ElapsedTime maTimer; /** Time between the display of frames. Enforced only when mbIsActive is <TRUE/>.
*/ constdouble mnFrameDuration; /** Time (of maTimer) when the next frame shall be displayed. Synchronize() will wait until this time.
*/ double mnNextFrameTargetTime; /** Synchronize() will wait only when this flag is <TRUE/>. Otherwise it returns immediately.
*/ bool mbIsActive;
};
This class encapsulates the slideshow presentation viewer.
With an instance of this class, it is possible to statically and dynamically show a presentation, as defined by the constructor-provided draw model (represented by a sequence of css::drawing::XDrawPage objects).
It is possible to show the presentation on multiple views simultaneously (e.g. for a multi-monitor setup). Since this class also relies on user interaction, the corresponding XSlideShowView interface provides means to register some UI event listeners (mostly borrowed from awt::XWindow interface).
Since currently (mid 2004), OOo isn't very well suited to multi-threaded rendering, this class relies on <em>very frequent</em> external update() calls, which will render the next frame of animations. This works as follows: after the displaySlide() has been successfully called (which setup and starts an actual slide show), the update() method must be called until it returns false. Effectively, this puts the burden of providing concurrency to the clients of this class, which, as noted above, is currently unavoidable with the current state of affairs (I've actually tried threading here, but failed miserably when using the VCL canvas as the render backend - deadlocked).
class SlideShowImpl : private cppu::BaseMutex, public CursorManager, public MediaFileManager, public SlideShowImplBase
{ public: explicit SlideShowImpl(
uno::Reference<uno::XComponentContext> xContext );
/** Notify that the transition phase of the current slide has ended.
The life of a slide has three phases: the transition phase, when the previous slide vanishes, and the current slide becomes visible, the shape animation phase, when shape effects are running, and the phase after the last shape animation has ended, but before the next slide transition starts.
This method notifies the end of the first phase.
@param bPaintSlide When true, Slide::show() is passed a true as well, denoting explicit paint of slide content. Pass false here, if e.g. a slide transition has already rendered the initial slide image.
*/ void notifySlideTransitionEnded( bool bPaintSlide );
/** Notify that the shape animation phase of the current slide has ended.
The life of a slide has three phases: the transition phase, when the previous slide vanishes, and the current slide becomes visible, the shape animation phase, when shape effects are running, and the phase after the last shape animation has ended, but before the next slide transition starts.
This method notifies the end of the second phase.
*/ void notifySlideAnimationsEnded();
/** Notify that the slide has ended.
The life of a slide has three phases: the transition phase, when the previous slide vanishes, and the current slide becomes visible, the shape animation phase, when shape effects are running, and the phase after the last shape animation has ended, but before the next slide transition starts.
This method notifies the end of the third phase.
*/ void notifySlideEnded (constbool bReverse);
/** Notification from eventmultiplexer that a hyperlink has been clicked.
*/ bool notifyHyperLinkClicked( OUString const& hyperLink );
/** Notification from eventmultiplexer that an animation event has occurred. This will be forwarded to all registered XSlideShowListener
*/ bool handleAnimationEvent( const AnimationNodeSharedPtr& rNode );
/** Obtain a MediaTempFile for the specified url. */ virtual std::shared_ptr<avmedia::MediaTempFile> getMediaTempFile(const OUString& aUrl) override;
/** This is somewhat similar to displaySlide when called for the current slide. It has been simplified to take advantage of that no slide change takes place. Furthermore it does not show the slide transition.
*/ void redisplayCurrentSlide();
/// Resets the current slide transition sound object with a new one:
SoundPlayerSharedPtr resetSlideTransitionSound(
uno::Any const& url, bool bLoopSound );
/// stops the current slide transition sound void stopSlideTransitionSound();
/** Prepare a slide transition
This method registers all necessary events and activities for a slide transition.
@return the slide change activity, or NULL for no transition effect
*/
ActivitySharedPtr createSlideTransition( const uno::Reference< drawing::XDrawPage >& xDrawPage, const SlideSharedPtr& rLeavingSlide, const SlideSharedPtr& rEnteringSlide, const EventSharedPtr& rTransitionEndEvent );
/** Request/release the wait symbol. The wait symbol is displayed when there are more requests then releases. Locking the wait symbol helps to avoid intermediate repaints.
Do not call this method directly. Use WaitSymbolLock instead.
*/ void requestWaitSymbol(); void releaseWaitSymbol();
/// Filter requested cursor shape against hard slideshow cursors (wait, etc.)
sal_Int16 calcActiveCursor( sal_Int16 nCursorShape ) const;
/** This method is called asynchronously to finish the rewinding of an effect to the previous slide that was initiated earlier.
*/ void rewindEffectToPreviousSlide();
/// all registered views
UnoViewContainer maViewContainer;
/// all registered slide show listeners
comphelper::OInterfaceContainerHelper3<presentation::XSlideShowListener> maListenerContainer;
/// map of vectors, containing all registered listeners for a shape
ShapeEventListenerMap maShapeEventListeners; /// map of sal_Int16 values, specifying the mouse cursor for every shape
ShapeCursorMap maShapeCursors;
//map of vector of Polygons, containing polygons drawn on each slide.
PolygonMap maPolygons;
std::optional<RGBColor> maUserPaintColor;
double maUserPaintStrokeWidth;
//changed for the eraser project
std::optional<bool> maEraseAllInk;
std::optional<sal_Int32> maEraseInk; //end changed
/// the previously running slide
SlideSharedPtr mpPreviousSlide; /// the currently running slide
SlideSharedPtr mpCurrentSlide; /// the already prefetched slide: best candidate for upcoming slide
SlideSharedPtr mpPrefetchSlide; /// slide to be prefetched: best candidate for upcoming slide
uno::Reference<drawing::XDrawPage> mxPrefetchSlide; /// save the XDrawPagesSupplier to retrieve polygons
uno::Reference<drawing::XDrawPagesSupplier> mxDrawPagesSupplier; /// Used by MediaFileManager, for media files with package url.
uno::Reference<document::XStorageBasedDocument> mxSBD; /// slide animation to be prefetched:
uno::Reference<animations::XAnimationNode> mxPrefetchAnimationNode;
/** Separate event listener for animation, view and hyperlink events.
This handler is registered for slide animation end, view and hyperlink events at the global EventMultiplexer, and forwards notifications to the SlideShowImpl
*/ struct SlideShowImpl::SeparateListenerImpl : public EventHandler, public ViewRepaintHandler, public HyperlinkHandler, public AnimationEventHandler
{
SlideShowImpl& mrShow;
ScreenUpdater& mrScreenUpdater;
EventQueue& mrEventQueue;
// EventHandler virtualbool handleEvent() override
{ // DON't call notifySlideAnimationsEnded() // directly, but queue an event. handleEvent() // might be called from e.g. // showNext(), and notifySlideAnimationsEnded() must not be called // in recursion. Note that the event is scheduled for the next // frame so that its expensive execution does not come in between // sprite hiding and shape redraw (at the end of the animation of a // shape), which would cause a flicker.
mrEventQueue.addEventForNextRound(
makeEvent( [this] () { this->mrShow.notifySlideAnimationsEnded(); },
u"SlideShowImpl::notifySlideAnimationsEnded"_ustr)); returntrue;
}
if (!url.isEmpty())
{ try
{
mpCurrentSlideTransitionSound = SoundPlayer::create(
maEventMultiplexer, url, mxComponentContext, *this);
mpCurrentSlideTransitionSound->setPlaybackLoop( bLoopSound );
} catch (lang::NoSupportException const&)
{ // catch possible exceptions from SoundPlayer, since // being not able to playback the sound is not a hard // error here (still, the slide transition should be // shown).
}
} return mpCurrentSlideTransitionSound;
}
if( !getPropertyValue( aSound, xPropSet, u"Sound"_ustr) )
SAL_INFO("slideshow", "createSlideTransition(): Could not determine transition sound effect URL from XDrawPage - using no sound" );
if( !getPropertyValue( bLoopSound, xPropSet, u"LoopSound"_ustr ) )
SAL_INFO("slideshow", "createSlideTransition(): Could not get slide property 'LoopSound' - using no sound" );
if( !pTransition ) return ActivitySharedPtr(); // no transition effect has been // generated. Normally, that means // that simply no transition is // set on this slide.
double nTransitionDuration(0.0); if( !getPropertyValue( nTransitionDuration,
xPropSet,
u"TransitionDuration"_ustr) )
{
SAL_INFO("slideshow", "createSlideTransition(): " "Could not extract slide transition duration from XDrawPage - assuming no transition" ); return ActivitySharedPtr();
}
sal_Int32 nMinFrames(5); if( !getPropertyValue( nMinFrames,
xPropSet,
u"MinimalFrameNumber"_ustr) )
{
SAL_INFO("slideshow", "createSlideTransition(): " "No minimal number of frames given - assuming 5" );
}
// prefetch slide transition bitmaps, but postpone it after // displaySlide() has finished - sometimes, view size has not yet // reached final size
maEventQueue.addEvent(
makeEvent( [pTransition] () {
pTransition->prefetch(); },
u"Animation::prefetch"_ustr));
if (mnWaitSymbolRequestCount == 1)
{ if( !mpWaitSymbol )
{ // fall back to cursor
requestCursor(calcActiveCursor(mnCurrentCursor));
} else
mpWaitSymbol->show();
}
}
if (mnWaitSymbolRequestCount == 0)
{ if( !mpWaitSymbol )
{ // fall back to cursor
requestCursor(calcActiveCursor(mnCurrentCursor));
} else
mpWaitSymbol->hide();
}
}
// clear all queues
maEventQueue.clear();
maActivitiesQueue.clear();
// Attention: we MUST clear the user event queue here, // this is because the current slide might have registered // shape events (click or enter/leave), which might // otherwise dangle forever in the queue (because of the // shared ptr nature). If someone needs to change this: // somehow unregister those shapes at the user event queue // on notifySlideEnded().
maUserEventQueue.clear();
// re-enable automatic effect advancement // (maEventQueue.clear() above might have killed // maEventMultiplexer's tick events) if (mbAutomaticAdvancementMode)
{ // toggle automatic mode (enabling just again is // ignored by EventMultiplexer)
maEventMultiplexer.setAutomaticMode( false );
maEventMultiplexer.setAutomaticMode( true );
}
}
stopShow(); // MUST call that: results in // maUserEventQueue.clear(). What's more, // stopShow()'s currSlide->hide() call is // now also required, notifySlideEnded() // relies on that // unconditionally. Otherwise, genuine // shape animations (drawing layer and // GIF) will not be stopped.
// push new transformation to all views, if size changed if( !mpPreviousSlide || oldSlideSize != slideSize )
{ for( constauto& pView : maViewContainer )
pView->setViewSize( slideSize );
// explicitly notify view change here, // because transformation might have changed: // optimization, this->notifyViewChange() would // repaint slide which is not necessary.
maEventMultiplexer.notifyViewsChanged();
}
// create slide transition, and add proper end event // (which then starts the slide effects // via CURRENT_SLIDE.show())
ActivitySharedPtr pSlideChangeActivity (
createSlideTransition(
mpCurrentSlide->getXDrawPage(),
mpPreviousSlide,
mpCurrentSlide,
makeEvent(
[this] () { this->notifySlideTransitionEnded(false); },
u"SlideShowImpl::notifySlideTransitionEnded"_ustr)));
if (bSkipSlideTransition)
{ // The transition activity was created for the side effects // (like sound transitions). Because we want to skip the // actual transition animation we do not need the activity // anymore.
pSlideChangeActivity.reset();
}
if (pSlideChangeActivity)
{ // factory generated a slide transition - activate it!
maActivitiesQueue.addActivity( pSlideChangeActivity );
} else
{ // no transition effect on this slide - schedule slide // effect start event right away.
maEventQueue.addEvent(
makeEvent(
[this] () { this->notifySlideTransitionEnded(true); },
u"SlideShowImpl::notifySlideTransitionEnded"_ustr));
}
}
} // finally
// We are currently rewinding an effect. This lead us from the next // slide to this one. To complete this we have to play back all main // sequence effects on this slide. if (bSkipAllMainSequenceEffects)
maEffectRewinder.skipAllMainSequenceEffects();
}
void SlideShowImpl::rewindEffectToPreviousSlide()
{ // Show the wait symbol now and prevent it from showing temporary slide // content while effects are played back.
WaitSymbolLock aLock (*this);
// A previous call to EffectRewinder::Rewind could not rewind the current // effect because there are no effects on the current slide or none has // yet been displayed. Go to the previous slide.
notifySlideEnded(true);
// Process pending events once more in order to have the following // screen update show the last effect. Not sure whether this should be // necessary.
maEventQueue.forceEmpty();
// We have to call the screen updater before the wait symbol is turned // off. Otherwise the wait symbol would force the display of an // intermediate state of the slide (before the effects are replayed.)
maScreenUpdater.commitUpdates();
}
sal_Bool SlideShowImpl::startShapeActivity(
uno::Reference<drawing::XShape> const& /*xShape*/ )
{ // precondition: must only be called from the main thread!
DBG_TESTSOLARMUTEX();
sal_Bool SlideShowImpl::stopShapeActivity(
uno::Reference<drawing::XShape> const& /*xShape*/ )
{ // precondition: must only be called from the main thread!
DBG_TESTSOLARMUTEX();
// precondition: must only be called from the main thread!
DBG_TESTSOLARMUTEX();
// first of all, check if view has a valid canvas
ENSURE_OR_RETURN_FALSE( xView.is(), "addView(): Invalid view" );
ENSURE_OR_RETURN_FALSE( xView->getCanvas().is(), "addView(): View does not provide a valid canvas" );
drawing::PointSequenceSequence
lcl_createPointSequenceSequenceFromB2DPolygon(const basegfx::B2DPolygon& rPoly)
{
drawing::PointSequenceSequence aRetval; //Create only one sequence for one pen drawing.
aRetval.realloc(1); // Retrieve the sequence of points from aRetval
drawing::PointSequence* pOuterSequence = aRetval.getArray(); // Create points in this sequence from rPoly
pOuterSequence->realloc(rPoly.count()); // Get these points which are in an array
awt::Point* pInnerSequence = pOuterSequence->getArray(); for( sal_uInt32 n = 0; n < rPoly.count(); n++ )
{ //Create a point from the polygon
*pInnerSequence++ = awt::Point(basegfx::fround(rPoly.getB2DPoint(n).getX()),
basegfx::fround(rPoly.getB2DPoint(n).getY()));
} return aRetval;
}
//LineStyle : SOLID by default
drawing::LineStyle eLS;
eLS = drawing::LineStyle_SOLID;
aXPropSet->setPropertyValue(u"LineStyle"_ustr, uno::Any(eLS));
//LineCap : ROUND by default, same as in show mode
drawing::LineCap eLC;
eLC = drawing::LineCap_ROUND;
aXPropSet->setPropertyValue(u"LineCap"_ustr, uno::Any(eLC));
//LineColor
sal_uInt32 nLineColor = 0; if (pCanvasPolyPoly)
nLineColor = pCanvasPolyPoly->getRGBALineColor(); //Transform polygon color from RRGGBBAA to AARRGGBB
aXPropSet->setPropertyValue(u"LineColor"_ustr, uno::Any(RGBAColor2UnoColor(nLineColor)));
void SlideShowImpl::registerUserPaintPolygons( const uno::Reference< lang::XMultiServiceFactory >& xDocFactory )
{ //Retrieve Polygons if user ends presentation by context menu if (mpCurrentSlide)
{ if(findPolygons(mpCurrentSlide->getXDrawPage()) != maPolygons.end())
maPolygons.erase(mpCurrentSlide->getXDrawPage());
// ODF defaults from ctor of SdrLayer are not automatically set on the here // created XLayer. Need to be done explicitly here.
aPropLayer <<= true;
xDrawnInSlideshow->setPropertyValue(u"IsVisible"_ustr, aPropLayer);
xDrawnInSlideshow->setPropertyValue(u"IsPrintable"_ustr, aPropLayer);
aPropLayer <<= false;
xDrawnInSlideshow->setPropertyValue(u"IsLocked"_ustr, aPropLayer);
//Register polygons for each slide // The polygons are simplified using the Ramer-Douglas-Peucker algorithm. // This is the therefore needed tolerance. Ideally the value should be user defined. // For now a suitable value is found experimental.
constexpr double fTolerance(12); for (constauto& rPoly : maPolygons)
{
PolyPolygonVector aPolygons = rPoly.second; if (aPolygons.empty()) continue; //Get shapes for the slide
css::uno::Reference<css::drawing::XShapes> Shapes = rPoly.first;
//Retrieve polygons for one slide // #tdf112687 A pen drawing in slideshow is actually a chain of individual line shapes, where // the end point of one line shape equals the start point of the next line shape. // We collect these points into one B2DPolygon and use that to generate the shape on the // slide.
::basegfx::B2DPolygon aDrawingPoints;
cppcanvas::PolyPolygonSharedPtr pFirstPolyPoly = aPolygons.front(); // for style properties for (constauto& pPolyPoly : aPolygons)
{ if (pPolyPoly->getIsFromPreviousSlideshow()) continue; // Actually, each item in aPolygons has two points, but wrapped in a cppcanvas::PopyPolygon.
::basegfx::B2DPolyPolygon b2DPolyPoly
= ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(
pPolyPoly->getUNOPolyPolygon());
//Normally there is only one polygon for (sal_uInt32 i = 0; i < b2DPolyPoly.count(); i++)
{ const ::basegfx::B2DPolygon& aPoly = b2DPolyPoly.getB2DPolygon(i);
if (aPoly.count() > 1) // otherwise skip it, count should be 2
{ constauto ptCount = aDrawingPoints.count(); if (ptCount == 0)
{
aDrawingPoints.append(aPoly);
pFirstPolyPoly = pPolyPoly; continue;
}
basegfx::B2DPoint aLast
= aDrawingPoints.getB2DPoint(ptCount - 1); if (aPoly.getB2DPoint(0).equal(aLast))
{
aDrawingPoints.append(aPoly, 1); continue;
}
// Put what we have collected to the slide and then start a new pen drawing object //create the PolyLineShape. The points will be in its PolyPolygon property.
uno::Reference<uno::XInterface> polyshape(
xDocFactory->createInstance(u"com.sun.star.drawing.PolyLineShape"_ustr));
uno::Reference<drawing::XShape> rPolyShape(polyshape, uno::UNO_QUERY); //Add the shape to the slide
Shapes->add(rPolyShape); //Construct a sequence of points sequence
aDrawingPoints
= basegfx::utils::createSimplifiedPolygon(aDrawingPoints, fTolerance); const drawing::PointSequenceSequence aRetval
= lcl_createPointSequenceSequenceFromB2DPolygon(aDrawingPoints); //Fill the properties
lcl_setPropertiesToShape(aRetval, pFirstPolyPoly, rPolyShape); // make polygons special
xLayerManager->attachShapeToLayer(rPolyShape, xDrawnInSlideshow); // Start next pen drawing object
aDrawingPoints.clear();
aDrawingPoints.append(aPoly);
pFirstPolyPoly = pPolyPoly;
}
}
} // Bring remaining points to slide if (aDrawingPoints.count() > 1)
{ //create the PolyLineShape. The points will be in its PolyPolygon property.
uno::Reference<uno::XInterface> polyshape(
xDocFactory->createInstance(u"com.sun.star.drawing.PolyLineShape"_ustr));
uno::Reference<drawing::XShape> rPolyShape(polyshape, uno::UNO_QUERY); //Add the shape to the slide
Shapes->add(rPolyShape); //Construct a sequence of points sequence
aDrawingPoints = basegfx::utils::createSimplifiedPolygon(aDrawingPoints, fTolerance);
drawing::PointSequenceSequence aRetval
= lcl_createPointSequenceSequenceFromB2DPolygon(aDrawingPoints); //Fill the properties
lcl_setPropertiesToShape(aRetval, aPolygons.back(), rPolyShape); // make polygons special
xLayerManager->attachShapeToLayer(rPolyShape, xDrawnInSlideshow);
}
}
}
// precondition: must only be called from the main thread!
DBG_TESTSOLARMUTEX();
// tdf#160669 IASS: if hint is about PrefetchSlide, flush it to avoid errors if ( rProperty.Name == "HintSlideChanged" )
{
uno::Reference< drawing::XDrawPage > xDrawPage; if (rProperty.Value >>= xDrawPage)
{ if (xDrawPage == mxPrefetchSlide)
{
mxPrefetchSlide.clear();
mpPrefetchSlide.reset();
}
}
}
//adding support for erasing features in UserPaintOverlay if ( rProperty.Name == "EraseAllInk" )
{ bool bEraseAllInk(false); if (rProperty.Value >>= bEraseAllInk)
{
OSL_ENSURE( mbMouseVisible, "setProperty(): User paint overrides invisible mouse" );
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
