Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 969 insertions, 0 deletions

diff --git a/sdext/source/presenter/PresenterSlideShowView.cxx b/sdext/source/presenter/PresenterSlideShowView.cxx
new file mode 100644
index 000000000..609b2d856
--- /dev/null
+++ b/sdext/source/presenter/PresenterSlideShowView.cxx
@@ -0,0 +1,969 @@
+
+/* -*- 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 .
+ */
+
+#include "PresenterSlideShowView.hxx"
+#include "PresenterCanvasHelper.hxx"
+#include "PresenterGeometryHelper.hxx"
+#include "PresenterHelper.hxx"
+#include "PresenterPaneContainer.hxx"
+#include <com/sun/star/awt/InvalidateStyle.hpp>
+#include <com/sun/star/awt/PosSize.hpp>
+#include <com/sun/star/awt/Pointer.hpp>
+#include <com/sun/star/awt/Toolkit.hpp>
+#include <com/sun/star/awt/WindowAttribute.hpp>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/awt/XWindowPeer.hpp>
+#include <com/sun/star/drawing/XPresenterHelper.hpp>
+#include <com/sun/star/drawing/framework/XControllerManager.hpp>
+#include <com/sun/star/drawing/framework/XConfigurationController.hpp>
+#include <com/sun/star/rendering/CompositeOperation.hpp>
+#include <com/sun/star/rendering/TextDirection.hpp>
+#include <com/sun/star/rendering/TexturingMode.hpp>
+#include <osl/mutex.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::drawing::framework;
+
+namespace sdext::presenter {
+
+//===== PresenterSlideShowView ================================================
+
+PresenterSlideShowView::PresenterSlideShowView (
+    const css::uno::Reference<css::uno::XComponentContext>& rxContext,
+    const css::uno::Reference<css::drawing::framework::XResourceId>& rxViewId,
+    const css::uno::Reference<css::frame::XController>& rxController,
+    const ::rtl::Reference<PresenterController>& rpPresenterController)
+    : PresenterSlideShowViewInterfaceBase(m_aMutex),
+      mxComponentContext(rxContext),
+      mpPresenterController(rpPresenterController),
+      mxViewId(rxViewId),
+      mxController(rxController),
+      mxSlideShowController(PresenterHelper::GetSlideShowController(rxController)),
+      mxSlideShow(),
+      mxCanvas(),
+      mxViewCanvas(),
+      mxPointer(),
+      mxWindow(),
+      mxViewWindow(),
+      mxTopPane(),
+      mxPresenterHelper(),
+      mxBackgroundPolygon1(),
+      mxBackgroundPolygon2(),
+      mbIsViewAdded(false),
+      mnPageAspectRatio(28.0/21.0),
+      maBroadcaster(m_aMutex),
+      mpBackground(),
+      mbIsForcedPaintPending(false),
+      mbIsPaintPending(true),
+      msClickToExitPresentationText(),
+      msClickToExitPresentationTitle(),
+      msTitleTemplate(),
+      mbIsEndSlideVisible(false),
+      mxCurrentSlide()
+{
+    if (mpPresenterController.get() != nullptr)
+    {
+        mnPageAspectRatio = mpPresenterController->GetSlideAspectRatio();
+        mpBackground = mpPresenterController->GetViewBackground(mxViewId->getResourceURL());
+    }
+}
+
+void PresenterSlideShowView::LateInit()
+{
+    mxSlideShow.set( mxSlideShowController->getSlideShow(), UNO_SET_THROW);
+    Reference<lang::XComponent> xSlideShowComponent (mxSlideShow, UNO_QUERY);
+    xSlideShowComponent->addEventListener(static_cast<awt::XWindowListener*>(this));
+
+    Reference<lang::XMultiComponentFactory> xFactory (
+        mxComponentContext->getServiceManager(), UNO_SET_THROW);
+    mxPresenterHelper.set (xFactory->createInstanceWithContext(
+                   "com.sun.star.comp.Draw.PresenterHelper",
+                   mxComponentContext),
+               UNO_QUERY_THROW);
+
+    // Use view id and controller to retrieve window and canvas from
+    // configuration controller.
+    Reference<XControllerManager> xCM (mxController, UNO_QUERY_THROW);
+    Reference<XConfigurationController> xCC (xCM->getConfigurationController());
+
+    if (xCC.is())
+    {
+        mxTopPane.set(xCC->getResource(mxViewId->getAnchor()->getAnchor()), UNO_QUERY);
+
+        Reference<XPane> xPane (xCC->getResource(mxViewId->getAnchor()), UNO_QUERY_THROW);
+
+        mxWindow = xPane->getWindow();
+        mxCanvas = xPane->getCanvas();
+
+        if (mxWindow.is())
+        {
+            mxWindow->addPaintListener(this);
+            mxWindow->addWindowListener(this);
+        }
+
+        // The window does not have to paint a background.  We do
+        // that ourself.
+        Reference<awt::XWindowPeer> xPeer (mxWindow, UNO_QUERY);
+        if (xPeer.is())
+            xPeer->setBackground(util::Color(0xff000000));
+    }
+
+    // Create a window for the actual slide show view.  It is places
+    // centered and with maximal size inside the pane.
+    mxViewWindow = CreateViewWindow(mxWindow);
+
+    mxViewCanvas = CreateViewCanvas(mxViewWindow);
+
+    if (mxViewWindow.is())
+    {
+        // Register listeners at window.
+        mxViewWindow->addPaintListener(this);
+        mxViewWindow->addMouseListener(this);
+        mxViewWindow->addMouseMotionListener(this);
+    }
+
+    if (mxViewWindow.is())
+        Resize();
+
+    if (mxWindow.is())
+        mxWindow->setVisible(true);
+
+    // Add the new slide show view to the slide show.
+    if (mxSlideShow.is() && ! mbIsViewAdded)
+    {
+        impl_addAndConfigureView();
+        mbIsViewAdded = true;
+    }
+
+    // Read text for one past last slide.
+    PresenterConfigurationAccess aConfiguration (
+        mxComponentContext,
+        PresenterConfigurationAccess::msPresenterScreenRootName,
+        PresenterConfigurationAccess::READ_ONLY);
+    aConfiguration.GetConfigurationNode(
+        "Presenter/Views/CurrentSlidePreview/"
+        "Strings/ClickToExitPresentationText/String")
+        >>= msClickToExitPresentationText;
+    aConfiguration.GetConfigurationNode(
+        "Presenter/Views/CurrentSlidePreview/"
+        "Strings/ClickToExitPresentationTitle/String")
+        >>= msClickToExitPresentationTitle;
+}
+
+PresenterSlideShowView::~PresenterSlideShowView()
+{
+}
+
+void PresenterSlideShowView::disposing()
+{
+    // Tell all listeners that we are disposed.
+    lang::EventObject aEvent;
+    aEvent.Source = static_cast<XWeak*>(this);
+
+    ::cppu::OInterfaceContainerHelper* pIterator
+          = maBroadcaster.getContainer(cppu::UnoType<lang::XEventListener>::get());
+    if (pIterator != nullptr)
+        pIterator->disposeAndClear(aEvent);
+
+    // Do this for
+    // XPaintListener, XModifyListener,XMouseListener,XMouseMotionListener,XWindowListener?
+
+    if (mxWindow.is())
+    {
+        mxWindow->removePaintListener(this);
+        mxWindow->removeMouseListener(this);
+        mxWindow->removeMouseMotionListener(this);
+        mxWindow->removeWindowListener(this);
+        mxWindow = nullptr;
+    }
+    mxSlideShowController = nullptr;
+    mxSlideShow = nullptr;
+    if (mxViewCanvas.is())
+    {
+        Reference<XComponent> xComponent (mxViewCanvas, UNO_QUERY);
+        mxViewCanvas = nullptr;
+        if (xComponent.is())
+            xComponent->dispose();
+    }
+    if (mxViewWindow.is())
+    {
+        Reference<XComponent> xComponent = mxViewWindow;
+        mxViewWindow = nullptr;
+        if (xComponent.is())
+            xComponent->dispose();
+    }
+    if (mxPointer.is())
+    {
+        Reference<XComponent> xComponent (mxPointer, UNO_QUERY);
+        mxPointer = nullptr;
+        if (xComponent.is())
+            xComponent->dispose();
+    }
+    if (mxBackgroundPolygon1.is())
+    {
+        Reference<XComponent> xComponent (mxBackgroundPolygon1, UNO_QUERY);
+        mxBackgroundPolygon1 = nullptr;
+        if (xComponent.is())
+            xComponent->dispose();
+    }
+    if (mxBackgroundPolygon2.is())
+    {
+        Reference<XComponent> xComponent (mxBackgroundPolygon2, UNO_QUERY);
+        mxBackgroundPolygon2 = nullptr;
+        if (xComponent.is())
+            xComponent->dispose();
+    }
+
+    mxComponentContext = nullptr;
+    mpPresenterController = nullptr;
+    mxViewId = nullptr;
+    mxController = nullptr;
+    mxCanvas = nullptr;
+    mpBackground.reset();
+    msClickToExitPresentationText.clear();
+    msClickToExitPresentationTitle.clear();
+    msTitleTemplate.clear();
+    mxCurrentSlide = nullptr;
+}
+
+//----- XDrawView -------------------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::setCurrentPage (
+    const css::uno::Reference<css::drawing::XDrawPage>& rxSlide)
+{
+    mxCurrentSlide = rxSlide;
+    if (mpPresenterController.get() != nullptr
+        && mxSlideShowController.is()
+        && ! mpPresenterController->GetCurrentSlide().is()
+        && ! mxSlideShowController->isPaused())
+    {
+        mbIsEndSlideVisible = true;
+        Reference<awt::XWindowPeer> xPeer (mxViewWindow, UNO_QUERY);
+        if (xPeer.is())
+            xPeer->invalidate(awt::InvalidateStyle::NOTRANSPARENT);
+
+        // For the end slide we use a special title, without the (n of m)
+        // part.  Save the title template for the case that the user goes
+        // backwards.
+        PresenterPaneContainer::SharedPaneDescriptor pDescriptor (
+            mpPresenterController->GetPaneContainer()->FindViewURL(mxViewId->getResourceURL()));
+        if (pDescriptor.get() != nullptr)
+        {
+            msTitleTemplate = pDescriptor->msTitleTemplate;
+            pDescriptor->msTitleTemplate = msClickToExitPresentationTitle;
+            mpPresenterController->UpdatePaneTitles();
+        }
+    }
+    else if (mbIsEndSlideVisible)
+    {
+        mbIsEndSlideVisible = false;
+
+        // Restore the title template.
+        PresenterPaneContainer::SharedPaneDescriptor pDescriptor (
+            mpPresenterController->GetPaneContainer()->FindViewURL(mxViewId->getResourceURL()));
+        if (pDescriptor.get() != nullptr)
+        {
+            pDescriptor->msTitleTemplate = msTitleTemplate;
+            pDescriptor->msTitle.clear();
+            mpPresenterController->UpdatePaneTitles();
+        }
+    }
+}
+
+css::uno::Reference<css::drawing::XDrawPage> SAL_CALL PresenterSlideShowView::getCurrentPage()
+{
+    return mxCurrentSlide;
+}
+
+//----- CachablePresenterView -------------------------------------------------
+
+void PresenterSlideShowView::ReleaseView()
+{
+    if (mxSlideShow.is() && mbIsViewAdded)
+    {
+        mxSlideShow->removeView(this);
+        mbIsViewAdded = false;
+    }
+}
+
+//----- XSlideShowView --------------------------------------------------------
+
+Reference<rendering::XSpriteCanvas> SAL_CALL PresenterSlideShowView::getCanvas()
+{
+    ThrowIfDisposed();
+
+    return Reference<rendering::XSpriteCanvas>(mxViewCanvas, UNO_QUERY);
+}
+
+void SAL_CALL PresenterSlideShowView::clear()
+{
+    ThrowIfDisposed();
+    mbIsForcedPaintPending = false;
+    mbIsPaintPending = false;
+
+    if (!(mxViewCanvas.is() && mxViewWindow.is()))
+        return;
+
+    // Create a polygon for the window outline.
+    awt::Rectangle aViewWindowBox (mxViewWindow->getPosSize());
+    Reference<rendering::XPolyPolygon2D> xPolygon (PresenterGeometryHelper::CreatePolygon(
+        awt::Rectangle(0,0, aViewWindowBox.Width,aViewWindowBox.Height),
+        mxViewCanvas->getDevice()));
+
+    rendering::ViewState aViewState (
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        nullptr);
+    double const aColor[4] = {0,0,0,0};
+    rendering::RenderState aRenderState(
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        nullptr,
+        Sequence<double>(aColor,4),
+        rendering::CompositeOperation::SOURCE);
+    mxViewCanvas->fillPolyPolygon(xPolygon, aViewState, aRenderState);
+}
+
+geometry::AffineMatrix2D SAL_CALL PresenterSlideShowView::getTransformation()
+{
+    ThrowIfDisposed();
+
+    if (mxViewWindow.is())
+    {
+        // When the mbIsInModifyNotification is set then a slightly modified
+        // version of the transformation is returned in order to get past
+        // optimizations the avoid updates when the transformation is
+        // unchanged (when the window size changes then due to the constant
+        // aspect ratio the size of the preview may remain the same while
+        // the position changes.  The position, however, is represented by
+        // the position of the view window.  This transformation is given
+        // relative to the view window and therefore does not contain the
+        // position.)
+        const awt::Rectangle aWindowBox = mxViewWindow->getPosSize();
+        return geometry::AffineMatrix2D(
+            aWindowBox.Width-1, 0, 0,
+            0, aWindowBox.Height-1, 0);
+    }
+    else
+    {
+        return geometry::AffineMatrix2D(1,0,0, 0,1,0);
+    }
+}
+
+geometry::IntegerSize2D SAL_CALL PresenterSlideShowView::getTranslationOffset()
+{
+    ThrowIfDisposed();
+    return geometry::IntegerSize2D(0,0);
+}
+
+void SAL_CALL PresenterSlideShowView::addTransformationChangedListener(
+    const Reference<util::XModifyListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.addListener(
+        cppu::UnoType<util::XModifyListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::removeTransformationChangedListener(
+    const Reference<util::XModifyListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.removeListener(
+        cppu::UnoType<util::XModifyListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::addPaintListener(
+    const Reference<awt::XPaintListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.addListener(
+        cppu::UnoType<awt::XPaintListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::removePaintListener(
+    const Reference<awt::XPaintListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.removeListener(
+        cppu::UnoType<awt::XPaintListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::addMouseListener(
+    const Reference<awt::XMouseListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.addListener(
+        cppu::UnoType<awt::XMouseListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::removeMouseListener(
+    const Reference<awt::XMouseListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.removeListener(
+        cppu::UnoType<awt::XMouseListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::addMouseMotionListener(
+    const Reference<awt::XMouseMotionListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.addListener(
+        cppu::UnoType<awt::XMouseMotionListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::removeMouseMotionListener(
+    const Reference<awt::XMouseMotionListener>& rxListener)
+{
+    ThrowIfDisposed();
+    maBroadcaster.removeListener(
+        cppu::UnoType<awt::XMouseMotionListener>::get(),
+        rxListener);
+}
+
+void SAL_CALL PresenterSlideShowView::setMouseCursor(::sal_Int16 nPointerShape)
+{
+    ThrowIfDisposed();
+
+    // Create a pointer when it does not yet exist.
+    if ( ! mxPointer.is())
+    {
+        mxPointer = awt::Pointer::create(mxComponentContext);
+    }
+
+    // Set the pointer to the given shape and the window(peer) to the
+    // pointer.
+    Reference<awt::XWindowPeer> xPeer (mxViewWindow, UNO_QUERY);
+    if (mxPointer.is() && xPeer.is())
+    {
+        mxPointer->setType(nPointerShape);
+        xPeer->setPointer(mxPointer);
+    }
+}
+
+awt::Rectangle SAL_CALL PresenterSlideShowView::getCanvasArea(  )
+{
+    if( mxViewWindow.is() && mxTopPane.is() )
+        return mxPresenterHelper->getWindowExtentsRelative( mxViewWindow, mxTopPane->getWindow() );
+
+    awt::Rectangle aRectangle;
+
+    aRectangle.X = aRectangle.Y = aRectangle.Width = aRectangle.Height = 0;
+
+    return aRectangle;
+}
+
+//----- lang::XEventListener --------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::disposing (const lang::EventObject& rEvent)
+{
+    if (rEvent.Source == mxViewWindow)
+        mxViewWindow = nullptr;
+    else if (rEvent.Source == mxSlideShow)
+        mxSlideShow = nullptr;
+}
+
+//----- XPaintListener --------------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::windowPaint (const awt::PaintEvent& rEvent)
+{
+    // Deactivated views must not be painted.
+    if ( ! mbIsPresenterViewActive)
+        return;
+
+    awt::Rectangle aViewWindowBox (mxViewWindow->getPosSize());
+    if (aViewWindowBox.Width <= 0 || aViewWindowBox.Height <= 0)
+        return;
+
+    if (rEvent.Source == mxWindow)
+        PaintOuterWindow(rEvent.UpdateRect);
+    else if (mbIsEndSlideVisible)
+        PaintEndSlide(rEvent.UpdateRect);
+    else
+        PaintInnerWindow(rEvent);
+}
+
+//----- XMouseListener --------------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::mousePressed (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseListener::mousePressed, aEvent);
+    }
+
+    // Only when the end slide is displayed we forward the mouse event to
+    // the PresenterController so that it switches to the next slide and
+    // ends the presentation.
+    if (mbIsEndSlideVisible)
+        if (mpPresenterController.get() != nullptr)
+            mpPresenterController->HandleMouseClick(rEvent);
+}
+
+void SAL_CALL PresenterSlideShowView::mouseReleased (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseListener::mouseReleased, aEvent);
+    }
+}
+
+void SAL_CALL PresenterSlideShowView::mouseEntered (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseListener::mouseEntered, aEvent);
+    }
+}
+
+void SAL_CALL PresenterSlideShowView::mouseExited (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseListener::mouseExited, aEvent);
+    }
+}
+
+//----- XMouseMotionListener --------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::mouseDragged (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseMotionListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseMotionListener::mouseDragged, aEvent);
+    }
+}
+
+void SAL_CALL PresenterSlideShowView::mouseMoved (const awt::MouseEvent& rEvent)
+{
+    awt::MouseEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XMouseMotionListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XMouseMotionListener::mouseMoved, aEvent);
+    }
+}
+
+//----- XWindowListener -------------------------------------------------------
+
+void SAL_CALL PresenterSlideShowView::windowResized (const awt::WindowEvent&)
+{
+    ThrowIfDisposed();
+    ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex());
+
+    Resize();
+}
+
+void SAL_CALL PresenterSlideShowView::windowMoved (const awt::WindowEvent&)
+{
+    if ( ! mbIsPaintPending)
+        mbIsForcedPaintPending = true;
+}
+
+void SAL_CALL PresenterSlideShowView::windowShown (const lang::EventObject&)
+{
+    Resize();
+}
+
+void SAL_CALL PresenterSlideShowView::windowHidden (const lang::EventObject&) {}
+
+//----- XView -----------------------------------------------------------------
+
+Reference<XResourceId> SAL_CALL PresenterSlideShowView::getResourceId()
+{
+    return mxViewId;
+}
+
+sal_Bool SAL_CALL PresenterSlideShowView::isAnchorOnly()
+{
+    return false;
+}
+
+//----- CachablePresenterView -------------------------------------------------
+
+void PresenterSlideShowView::ActivatePresenterView()
+{
+    if (mxSlideShow.is() && ! mbIsViewAdded)
+    {
+        impl_addAndConfigureView();
+        mbIsViewAdded = true;
+    }
+}
+
+void PresenterSlideShowView::DeactivatePresenterView()
+{
+    if (mxSlideShow.is() && mbIsViewAdded)
+    {
+        mxSlideShow->removeView(this);
+        mbIsViewAdded = false;
+    }
+}
+
+
+void PresenterSlideShowView::PaintOuterWindow (const awt::Rectangle& rRepaintBox)
+{
+    if ( ! mxCanvas.is())
+        return;
+
+    if (mpBackground.get() == nullptr)
+        return;
+
+    const rendering::ViewState aViewState(
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        PresenterGeometryHelper::CreatePolygon(rRepaintBox, mxCanvas->getDevice()));
+
+    rendering::RenderState aRenderState (
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        nullptr,
+        Sequence<double>(4),
+        rendering::CompositeOperation::SOURCE);
+
+    Reference<rendering::XBitmap> xBackgroundBitmap (mpBackground->GetNormalBitmap());
+    if (xBackgroundBitmap.is())
+    {
+        Sequence<rendering::Texture> aTextures (1);
+        const geometry::IntegerSize2D aBitmapSize(xBackgroundBitmap->getSize());
+        aTextures[0] = rendering::Texture (
+            geometry::AffineMatrix2D(
+                aBitmapSize.Width,0,0,
+                0,aBitmapSize.Height,0),
+            1,
+            0,
+            xBackgroundBitmap,
+            nullptr,
+            nullptr,
+            rendering::StrokeAttributes(),
+            rendering::TexturingMode::REPEAT,
+            rendering::TexturingMode::REPEAT);
+
+        if (mxBackgroundPolygon1.is())
+            mxCanvas->fillTexturedPolyPolygon(
+                mxBackgroundPolygon1,
+                aViewState,
+                aRenderState,
+                aTextures);
+        if (mxBackgroundPolygon2.is())
+            mxCanvas->fillTexturedPolyPolygon(
+                mxBackgroundPolygon2,
+                aViewState,
+                aRenderState,
+                aTextures);
+    }
+    else
+    {
+        PresenterCanvasHelper::SetDeviceColor(aRenderState, mpBackground->maReplacementColor);
+
+        if (mxBackgroundPolygon1.is())
+            mxCanvas->fillPolyPolygon(mxBackgroundPolygon1, aViewState, aRenderState);
+        if (mxBackgroundPolygon2.is())
+            mxCanvas->fillPolyPolygon(mxBackgroundPolygon2, aViewState, aRenderState);
+    }
+}
+
+void PresenterSlideShowView::PaintEndSlide (const awt::Rectangle& rRepaintBox)
+{
+    if ( ! mxCanvas.is())
+        return;
+
+    const rendering::ViewState aViewState(
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        PresenterGeometryHelper::CreatePolygon(rRepaintBox, mxCanvas->getDevice()));
+
+    rendering::RenderState aRenderState (
+        geometry::AffineMatrix2D(1,0,0, 0,1,0),
+        nullptr,
+        Sequence<double>(4),
+        rendering::CompositeOperation::SOURCE);
+    PresenterCanvasHelper::SetDeviceColor(aRenderState, util::Color(0x00000000));
+    mxCanvas->fillPolyPolygon(
+        PresenterGeometryHelper::CreatePolygon(mxViewWindow->getPosSize(), mxCanvas->getDevice()),
+        aViewState,
+        aRenderState);
+
+    do
+    {
+        if (mpPresenterController.get() == nullptr)
+            break;
+        std::shared_ptr<PresenterTheme> pTheme (mpPresenterController->GetTheme());
+        if (pTheme == nullptr)
+            break;
+
+        const OUString sViewStyle (pTheme->GetStyleName(mxViewId->getResourceURL()));
+        PresenterTheme::SharedFontDescriptor pFont (pTheme->GetFont(sViewStyle));
+        if (pFont.get() == nullptr)
+            break;
+
+        /// this is responsible of the " presentation exit " text inside the slide windows
+        PresenterCanvasHelper::SetDeviceColor(aRenderState, util::Color(0x00ffffff));
+        aRenderState.AffineTransform.m02 = 20;
+        aRenderState.AffineTransform.m12 = 40;
+        const rendering::StringContext aContext (
+            msClickToExitPresentationText, 0, msClickToExitPresentationText.getLength());
+        pFont->PrepareFont(mxCanvas);
+        const Reference<rendering::XTextLayout> xLayout (
+            pFont->mxFont->createTextLayout(aContext,rendering::TextDirection::WEAK_LEFT_TO_RIGHT,0));
+        mxCanvas->drawTextLayout(
+            xLayout,
+            aViewState,
+            aRenderState);
+    }
+    while (false);
+
+    // Finally, in double buffered environments, request the changes to be
+    // made visible.
+    Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxCanvas, UNO_QUERY);
+    if (xSpriteCanvas.is())
+        xSpriteCanvas->updateScreen(true);
+}
+
+void PresenterSlideShowView::PaintInnerWindow (const awt::PaintEvent& rEvent)
+{
+    // Forward window paint to listeners.
+    awt::PaintEvent aEvent (rEvent);
+    aEvent.Source = static_cast<XWeak*>(this);
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<awt::XPaintListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&awt::XPaintListener::windowPaint, aEvent);
+    }
+
+    /** The slide show relies on the back buffer of the canvas not being
+        modified.  With a shared canvas there are times when that can not be
+        guaranteed.
+    */
+    if (mbIsForcedPaintPending && mxSlideShow.is() && mbIsViewAdded)
+    {
+        mxSlideShow->removeView(this);
+        impl_addAndConfigureView();
+    }
+
+    // Finally, in double buffered environments, request the changes to be
+    // made visible.
+    Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxCanvas, UNO_QUERY);
+    if (xSpriteCanvas.is())
+        xSpriteCanvas->updateScreen(true);
+}
+
+Reference<awt::XWindow> PresenterSlideShowView::CreateViewWindow (
+    const Reference<awt::XWindow>& rxParentWindow) const
+{
+    Reference<awt::XWindow> xViewWindow;
+    try
+    {
+        Reference<lang::XMultiComponentFactory> xFactory (mxComponentContext->getServiceManager());
+        if ( ! xFactory.is())
+            return xViewWindow;
+
+        Reference<awt::XToolkit2> xToolkit = awt::Toolkit::create(mxComponentContext);
+        awt::WindowDescriptor aWindowDescriptor (
+            awt::WindowClass_CONTAINER,
+            OUString(),
+            Reference<awt::XWindowPeer>(rxParentWindow,UNO_QUERY_THROW),
+            -1, // parent index not available
+            awt::Rectangle(0,0,10,10),
+            awt::WindowAttribute::SIZEABLE
+                | awt::WindowAttribute::MOVEABLE
+                | awt::WindowAttribute::NODECORATION);
+        xViewWindow.set( xToolkit->createWindow(aWindowDescriptor),UNO_QUERY_THROW);
+
+        // Make the background transparent.  The slide show paints its own background.
+        Reference<awt::XWindowPeer> xPeer (xViewWindow, UNO_QUERY_THROW);
+        xPeer->setBackground(0xff000000);
+
+        xViewWindow->setVisible(true);
+    }
+    catch (RuntimeException&)
+    {
+    }
+    return xViewWindow;
+}
+
+Reference<rendering::XCanvas> PresenterSlideShowView::CreateViewCanvas (
+    const Reference<awt::XWindow>& rxViewWindow) const
+{
+    // Create a canvas for the view window.
+    return mxPresenterHelper->createSharedCanvas(
+        Reference<rendering::XSpriteCanvas>(mxTopPane->getCanvas(), UNO_QUERY),
+        mxTopPane->getWindow(),
+        mxTopPane->getCanvas(),
+        mxTopPane->getWindow(),
+        rxViewWindow);
+}
+
+void PresenterSlideShowView::Resize()
+{
+    if ( ! mxWindow.is() || ! mxViewWindow.is())
+        return;
+
+    const awt::Rectangle aWindowBox (mxWindow->getPosSize());
+    awt::Rectangle aViewWindowBox;
+    if (aWindowBox.Height > 0)
+    {
+        const double nWindowAspectRatio (
+            double(aWindowBox.Width) / double(aWindowBox.Height));
+        if (nWindowAspectRatio > mnPageAspectRatio)
+        {
+            // Slides will be painted with the full parent window height.
+            aViewWindowBox.Width = sal_Int32(aWindowBox.Height * mnPageAspectRatio + 0.5);
+            aViewWindowBox.Height = aWindowBox.Height;
+            aViewWindowBox.X = (aWindowBox.Width - aViewWindowBox.Width) / 2;
+            aViewWindowBox.Y = 0;
+        }
+        else
+        {
+            // Slides will be painted with the full parent window width.
+            aViewWindowBox.Width = aWindowBox.Width;
+            aViewWindowBox.Height = sal_Int32(aWindowBox.Width / mnPageAspectRatio + 0.5);
+            aViewWindowBox.X = 0;
+            aViewWindowBox.Y = (aWindowBox.Height - aViewWindowBox.Height) / 2;
+        }
+        mxViewWindow->setPosSize(
+            aViewWindowBox.X,
+            aViewWindowBox.Y,
+            aViewWindowBox.Width,
+            aViewWindowBox.Height,
+            awt::PosSize::POSSIZE);
+    }
+
+    // Clear the background polygon so that on the next paint it is created
+    // for the new size.
+    CreateBackgroundPolygons();
+
+    // Notify listeners that the transformation that maps the view into the
+    // window has changed.
+    lang::EventObject aEvent (static_cast<XWeak*>(this));
+    ::cppu::OInterfaceContainerHelper* pIterator
+        = maBroadcaster.getContainer(cppu::UnoType<util::XModifyListener>::get());
+    if (pIterator != nullptr)
+    {
+        pIterator->notifyEach(&util::XModifyListener::modified, aEvent);
+    }
+
+    // Due to constant aspect ratio resizing may lead a preview that changes
+    // its position but not its size.  This invalidates the back buffer and
+    // we have to enforce a complete repaint.
+    if ( ! mbIsPaintPending)
+        mbIsForcedPaintPending = true;
+}
+
+void PresenterSlideShowView::CreateBackgroundPolygons()
+{
+    const awt::Rectangle aWindowBox (mxWindow->getPosSize());
+    const awt::Rectangle aViewWindowBox (mxViewWindow->getPosSize());
+    if (aWindowBox.Height == aViewWindowBox.Height && aWindowBox.Width == aViewWindowBox.Width)
+    {
+        mxBackgroundPolygon1 = nullptr;
+        mxBackgroundPolygon2 = nullptr;
+    }
+    else if (aWindowBox.Height == aViewWindowBox.Height)
+    {
+        // Paint two boxes to the left and right of the view window.
+        mxBackgroundPolygon1 = PresenterGeometryHelper::CreatePolygon(
+            awt::Rectangle(
+                0,
+                0,
+                aViewWindowBox.X,
+                aWindowBox.Height),
+            mxCanvas->getDevice());
+        mxBackgroundPolygon2 = PresenterGeometryHelper::CreatePolygon(
+            awt::Rectangle(
+                aViewWindowBox.X + aViewWindowBox.Width,
+                0,
+                aWindowBox.Width - aViewWindowBox.X - aViewWindowBox.Width,
+                aWindowBox.Height),
+            mxCanvas->getDevice());
+    }
+    else
+    {
+        // Paint two boxes above and below the view window.
+        mxBackgroundPolygon1 = PresenterGeometryHelper::CreatePolygon(
+            awt::Rectangle(
+                0,
+                0,
+                aWindowBox.Width,
+                aViewWindowBox.Y),
+            mxCanvas->getDevice());
+        mxBackgroundPolygon2 = PresenterGeometryHelper::CreatePolygon(
+            awt::Rectangle(
+                0,
+                aViewWindowBox.Y + aViewWindowBox.Height,
+                aWindowBox.Width,
+                aWindowBox.Height - aViewWindowBox.Y - aViewWindowBox.Height),
+            mxCanvas->getDevice());
+    }
+}
+
+void PresenterSlideShowView::ThrowIfDisposed()
+{
+    if (rBHelper.bDisposed || rBHelper.bInDispose)
+    {
+        throw lang::DisposedException (
+            "PresenterSlideShowView object has already been disposed",
+            static_cast<uno::XWeak*>(this));
+    }
+}
+
+void PresenterSlideShowView::impl_addAndConfigureView()
+{
+    Reference<presentation::XSlideShowView> xView (this);
+    mxSlideShow->addView(xView);
+    // Prevent embedded sounds being played twice at the same time by
+    // disabling sound for the new slide show view.
+    beans::PropertyValue aProperty;
+    aProperty.Name = "IsSoundEnabled";
+    Sequence<Any> aValues (2);
+    aValues[0] <<= xView;
+    aValues[1] <<= false;
+    aProperty.Value <<= aValues;
+    mxSlideShow->setProperty(aProperty);
+}
+
+} // end of namespace ::sd::presenter
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */