Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

1 files changed, 801 insertions, 0 deletions

diff --git a/sdext/source/presenter/PresenterScreen.cxx b/sdext/source/presenter/PresenterScreen.cxx
new file mode 100644
index 000000000..a53f28e86
--- /dev/null
+++ b/sdext/source/presenter/PresenterScreen.cxx
@@ -0,0 +1,801 @@
+/* -*- 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 "PresenterScreen.hxx"
+#include "PresenterConfigurationAccess.hxx"
+#include "PresenterController.hxx"
+#include "PresenterFrameworkObserver.hxx"
+#include "PresenterHelper.hxx"
+#include "PresenterPaneContainer.hxx"
+#include "PresenterPaneFactory.hxx"
+#include "PresenterViewFactory.hxx"
+#include "PresenterWindowManager.hxx"
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/drawing/framework/XControllerManager.hpp>
+#include <com/sun/star/drawing/framework/ResourceId.hpp>
+#include <com/sun/star/drawing/framework/ResourceActivationMode.hpp>
+#include <com/sun/star/presentation/XPresentation2.hpp>
+#include <com/sun/star/presentation/XPresentationSupplier.hpp>
+#include <com/sun/star/document/XEventBroadcaster.hpp>
+#include <cppuhelper/compbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <vcl/svapp.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::presentation;
+using namespace ::com::sun::star::drawing::framework;
+
+namespace sdext::presenter {
+
+namespace {
+    typedef ::cppu::WeakComponentImplHelper <
+        css::document::XEventListener
+        > PresenterScreenListenerInterfaceBase;
+
+    /** One instance of a PresenterScreenListener is registered per Impress
+        document and waits for the full screen slide show to start and to
+        end.
+    */
+    class PresenterScreenListener
+        : private ::cppu::BaseMutex,
+          public PresenterScreenListenerInterfaceBase
+    {
+    public:
+        PresenterScreenListener (
+            const css::uno::Reference<css::uno::XComponentContext>& rxContext,
+            const css::uno::Reference<css::frame::XModel2>& rxModel);
+        PresenterScreenListener(const PresenterScreenListener&) = delete;
+        PresenterScreenListener& operator=(const PresenterScreenListener&) = delete;
+
+        void Initialize();
+        virtual void SAL_CALL disposing() override;
+
+        // document::XEventListener
+
+        virtual void SAL_CALL notifyEvent( const css::document::EventObject& Event ) override;
+
+        // XEventListener
+
+        virtual void SAL_CALL disposing ( const css::lang::EventObject& rEvent) override;
+
+    private:
+        css::uno::Reference<css::frame::XModel2 > mxModel;
+        css::uno::Reference<css::uno::XComponentContext> mxComponentContext;
+        rtl::Reference<PresenterScreen> mpPresenterScreen;
+    };
+}
+
+//----- XServiceInfo ---------------------------------------------------------------
+
+Sequence< OUString > SAL_CALL PresenterScreenJob::getSupportedServiceNames()
+{
+    return {  };
+}
+
+OUString SAL_CALL PresenterScreenJob::getImplementationName()
+{
+    return "org.libreoffice.comp.PresenterScreenJob";
+}
+
+sal_Bool SAL_CALL PresenterScreenJob::supportsService(const OUString& aServiceName)
+{
+    return cppu::supportsService(this, aServiceName);
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+sdext_PresenterScreenJob_get_implementation(
+    css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new PresenterScreenJob(context));
+}
+
+
+//===== PresenterScreenJob ====================================================
+
+PresenterScreenJob::PresenterScreenJob (const Reference<XComponentContext>& rxContext)
+    : PresenterScreenJobInterfaceBase(m_aMutex),
+      mxComponentContext(rxContext)
+{
+}
+
+PresenterScreenJob::~PresenterScreenJob()
+{
+}
+
+void SAL_CALL PresenterScreenJob::disposing()
+{
+    mxComponentContext = nullptr;
+}
+
+//----- XJob -----------------------------------------------------------
+
+Any SAL_CALL PresenterScreenJob::execute(
+    const Sequence< beans::NamedValue >& Arguments )
+{
+    Sequence< beans::NamedValue > lEnv;
+    auto pArg = std::find_if(Arguments.begin(), Arguments.end(),
+        [](const beans::NamedValue& rArg) { return rArg.Name == "Environment"; });
+    if (pArg != Arguments.end())
+        pArg->Value >>= lEnv;
+
+    Reference<frame::XModel2> xModel;
+    auto pProp = std::find_if(std::cbegin(lEnv), std::cend(lEnv),
+        [](const beans::NamedValue& rProp) { return rProp.Name == "Model"; });
+    if (pProp != std::cend(lEnv))
+        pProp->Value >>= xModel;
+
+    Reference< XServiceInfo > xInfo( xModel, UNO_QUERY );
+    if( xInfo.is() && xInfo->supportsService("com.sun.star.presentation.PresentationDocument") )
+    {
+        // Create a new listener that waits for the full screen presentation
+        // to start and to end.  It takes care of its own lifetime.
+        ::rtl::Reference<PresenterScreenListener> pListener (
+            new PresenterScreenListener(mxComponentContext, xModel));
+        pListener->Initialize();
+    }
+
+    return Any();
+}
+
+//===== PresenterScreenListener ===============================================
+
+namespace {
+
+PresenterScreenListener::PresenterScreenListener (
+    const css::uno::Reference<css::uno::XComponentContext>& rxContext,
+    const css::uno::Reference<css::frame::XModel2>& rxModel)
+    : PresenterScreenListenerInterfaceBase(m_aMutex),
+      mxModel(rxModel),
+      mxComponentContext(rxContext)
+{
+}
+
+void PresenterScreenListener::Initialize()
+{
+    Reference< document::XEventListener > xDocListener(this);
+    Reference< document::XEventBroadcaster > xDocBroadcaster( mxModel, UNO_QUERY );
+    if( xDocBroadcaster.is() )
+        xDocBroadcaster->addEventListener(xDocListener);
+}
+
+void SAL_CALL PresenterScreenListener::disposing()
+{
+    Reference< document::XEventBroadcaster > xDocBroadcaster( mxModel, UNO_QUERY );
+    if( xDocBroadcaster.is() )
+        xDocBroadcaster->removeEventListener(
+            Reference<document::XEventListener>(this) );
+
+    if (mpPresenterScreen.is())
+    {
+        mpPresenterScreen->RequestShutdownPresenterScreen();
+        mpPresenterScreen = nullptr;
+    }
+}
+
+// document::XEventListener
+
+void SAL_CALL PresenterScreenListener::notifyEvent( const css::document::EventObject& Event )
+{
+    if (rBHelper.bDisposed || rBHelper.bInDispose)
+    {
+        throw lang::DisposedException (
+            "PresenterScreenListener object has already been disposed",
+            static_cast<uno::XWeak*>(this));
+    }
+
+    if ( Event.EventName == "OnStartPresentation" )
+    {
+        mpPresenterScreen = new PresenterScreen(mxComponentContext, mxModel);
+        if(PresenterScreen::isPresenterScreenEnabled(mxComponentContext))
+            mpPresenterScreen->InitializePresenterScreen();
+    }
+    else if ( Event.EventName == "OnEndPresentation" )
+    {
+        if (mpPresenterScreen.is())
+        {
+            mpPresenterScreen->RequestShutdownPresenterScreen();
+            mpPresenterScreen = nullptr;
+        }
+    }
+}
+
+// XEventListener
+
+void SAL_CALL PresenterScreenListener::disposing (const css::lang::EventObject&)
+{
+    if (mpPresenterScreen.is())
+    {
+        mpPresenterScreen->RequestShutdownPresenterScreen();
+        mpPresenterScreen = nullptr;
+    }
+}
+
+} // end of anonymous namespace
+
+//===== PresenterScreen =======================================================
+
+PresenterScreen::PresenterScreen (
+    const Reference<XComponentContext>& rxContext,
+    const css::uno::Reference<css::frame::XModel2>& rxModel)
+    : PresenterScreenInterfaceBase(m_aMutex),
+      mxModel(rxModel),
+      mxContextWeak(rxContext)
+{
+}
+
+PresenterScreen::~PresenterScreen()
+{
+}
+
+bool PresenterScreen::isPresenterScreenEnabled(const css::uno::Reference<css::uno::XComponentContext>& rxContext)
+{
+        bool dEnablePresenterScreen=true;
+        PresenterConfigurationAccess aConfiguration (
+            rxContext,
+            "/org.openoffice.Office.Impress/",
+            PresenterConfigurationAccess::READ_ONLY);
+        aConfiguration.GetConfigurationNode("Misc/Start/EnablePresenterScreen")
+            >>= dEnablePresenterScreen;
+        return dEnablePresenterScreen;
+}
+void SAL_CALL PresenterScreen::disposing()
+{
+    Reference<XConfigurationController> xCC (mxConfigurationControllerWeak);
+    if (xCC.is() && mxSavedConfiguration.is())
+    {
+        xCC->restoreConfiguration(mxSavedConfiguration);
+    }
+    mxConfigurationControllerWeak = Reference<XConfigurationController>(nullptr);
+
+    Reference<lang::XComponent> xViewFactoryComponent (mxViewFactory, UNO_QUERY);
+    if (xViewFactoryComponent.is())
+       xViewFactoryComponent->dispose();
+    Reference<lang::XComponent> xPaneFactoryComponent (mxPaneFactory, UNO_QUERY);
+    if (xPaneFactoryComponent.is())
+        xPaneFactoryComponent->dispose();
+
+    mxModel = nullptr;
+}
+
+//----- XEventListener --------------------------------------------------------
+
+void SAL_CALL PresenterScreen::disposing (const lang::EventObject& /*rEvent*/)
+{
+    RequestShutdownPresenterScreen();
+}
+
+
+void PresenterScreen::InitializePresenterScreen()
+{
+    try
+    {
+        Reference<XComponentContext> xContext (mxContextWeak);
+        mpPaneContainer = new PresenterPaneContainer(xContext);
+
+        Reference<XPresentationSupplier> xPS ( mxModel, UNO_QUERY_THROW);
+        Reference<XPresentation2> xPresentation(xPS->getPresentation(), UNO_QUERY_THROW);
+        Reference<presentation::XSlideShowController> xSlideShowController( xPresentation->getController() );
+
+        if( !xSlideShowController.is() || !xSlideShowController->isFullScreen() )
+            return;
+
+        // find first controller that is not the current controller (the one with the slideshow
+        mxController = mxModel->getCurrentController();
+        Reference< container::XEnumeration > xEnum( mxModel->getControllers() );
+        if( xEnum.is() )
+        {
+            while( xEnum->hasMoreElements() )
+            {
+                Reference< frame::XController > xC( xEnum->nextElement(), UNO_QUERY );
+                if( xC.is() && (xC != mxController) )
+                {
+                    mxController = xC;
+                    break;
+                }
+            }
+        }
+        // Get the XController from the first argument.
+        Reference<XControllerManager> xCM(mxController, UNO_QUERY_THROW);
+
+        Reference<XConfigurationController> xCC( xCM->getConfigurationController());
+        mxConfigurationControllerWeak = xCC;
+
+        Reference<drawing::framework::XResourceId> xMainPaneId(
+            GetMainPaneId(xPresentation));
+        // An empty reference means that the presenter screen can
+        // not or must not be displayed.
+        if ( ! xMainPaneId.is())
+            return;
+
+        if (xCC.is() && xContext.is())
+        {
+            // Store the current configuration so that we can restore it when
+            // the presenter view is deactivated.
+            mxSavedConfiguration = xCC->getRequestedConfiguration();
+            xCC->lock();
+
+            try
+            {
+                // At the moment the presenter controller is displayed in its
+                // own full screen window that is controlled by the same
+                // configuration controller as the Impress document from
+                // which the presentation was started.  Therefore the main
+                // pane is activated additionally to the already existing
+                // panes and does not replace them.
+                xCC->requestResourceActivation(
+                    xMainPaneId,
+                    ResourceActivationMode_ADD);
+                SetupConfiguration(xContext, xMainPaneId);
+
+                mpPresenterController = new PresenterController(
+                    css::uno::WeakReference<css::lang::XEventListener>(this),
+                    xContext,
+                    mxController,
+                    xSlideShowController,
+                    mpPaneContainer,
+                    xMainPaneId);
+
+                // Create pane and view factories and integrate them into the
+                // drawing framework.
+                SetupPaneFactory(xContext);
+                SetupViewFactory(xContext);
+
+                mpPresenterController->GetWindowManager()->RestoreViewMode();
+            }
+            catch (const RuntimeException&)
+            {
+                xCC->restoreConfiguration(mxSavedConfiguration);
+            }
+            xCC->unlock();
+        }
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+void PresenterScreen::SwitchMonitors()
+{
+    try {
+        Reference<XPresentationSupplier> xPS ( mxModel, UNO_QUERY_THROW);
+        Reference<XPresentation2> xPresentation(xPS->getPresentation(), UNO_QUERY_THROW);
+
+        // Get the existing presenter console screen, we want to switch the
+        // presentation to use that instead.
+        sal_Int32 nNewScreen = GetPresenterScreenNumber (xPresentation);
+        if (nNewScreen < 0)
+            return;
+
+        // Adapt that display number to be the 'default' setting of 0 if it matches
+        sal_Int32 nExternalDisplay = Application::GetDisplayExternalScreen();
+
+        if (nNewScreen == nExternalDisplay)
+            nNewScreen = 0; // screen zero is best == the primary display
+        else
+            nNewScreen++; // otherwise we store screens offset by one.
+
+        // Set the new presentation display
+        Reference<beans::XPropertySet> xProperties (xPresentation, UNO_QUERY_THROW);
+        xProperties->setPropertyValue("Display", Any(nNewScreen));
+    } catch (const uno::Exception &) {
+    }
+}
+
+/**
+ * Return the real VCL screen number to show the presenter console
+ * on or -1 to not show anything.
+ */
+sal_Int32 PresenterScreen::GetPresenterScreenNumber (
+    const Reference<presentation::XPresentation2>& rxPresentation) const
+{
+    sal_Int32 nScreenNumber (0);
+    try
+    {
+        if ( ! rxPresentation.is())
+            return -1;
+
+        // Determine the screen on which the full screen presentation is being
+        // displayed.
+        sal_Int32 nDisplayNumber (-1);
+        if ( ! (rxPresentation->getPropertyValue("Display") >>= nDisplayNumber))
+            return -1;
+        if (nDisplayNumber == -1)
+        {
+            // The special value -1 indicates that the slide show
+            // spans all available displays.  That leaves no room for
+            // the presenter screen.
+            return -1;
+        }
+
+        SAL_INFO("sdext.presenter", "Display number is " << nDisplayNumber);
+
+        if (nDisplayNumber > 0)
+        {
+            nScreenNumber = nDisplayNumber - 1;
+        }
+        else if (nDisplayNumber == 0)
+        {
+            // A display number value of 0 indicates the primary screen.
+            // Find out which screen number that is.
+            nScreenNumber = Application::GetDisplayExternalScreen();
+        }
+
+        // We still have to determine the number of screens to decide
+        // whether the presenter screen may be shown at all.
+        sal_Int32 nScreenCount = Application::GetScreenCount();
+
+        if (nScreenCount < 2 || nDisplayNumber > nScreenCount)
+        {
+            // There is either only one screen or the full screen
+            // presentation spans all available screens.  The presenter
+            // screen is shown only when a special flag in the configuration
+            // is set.
+            Reference<XComponentContext> xContext (mxContextWeak);
+            PresenterConfigurationAccess aConfiguration (
+                xContext,
+                "/org.openoffice.Office.PresenterScreen/",
+                PresenterConfigurationAccess::READ_ONLY);
+            bool bStartAlways (false);
+            if (aConfiguration.GetConfigurationNode(
+                "Presenter/StartAlways") >>= bStartAlways)
+            {
+                if (bStartAlways)
+                    return GetPresenterScreenFromScreen(nScreenNumber);
+            }
+            return -1;
+        }
+    }
+    catch (const beans::UnknownPropertyException&)
+    {
+        OSL_ASSERT(false);
+        // For some reason we can not access the screen number.  Use
+        // the default instead.
+    }
+    SAL_INFO("sdext.presenter", "Get presenter screen for screen " << nScreenNumber);
+    return GetPresenterScreenFromScreen(nScreenNumber);
+}
+
+sal_Int32 PresenterScreen::GetPresenterScreenFromScreen( sal_Int32 nPresentationScreen )
+{
+    // Setup the resource id of the full screen background pane so that
+    // it is displayed on another screen than the presentation.
+    sal_Int32 nPresenterScreenNumber (1);
+    switch (nPresentationScreen)
+    {
+        case 0:
+            nPresenterScreenNumber = 1;
+            break;
+
+        case 1:
+            nPresenterScreenNumber = 0;
+            break;
+
+        default:
+            SAL_INFO("sdext.presenter", "Warning unexpected, out of bound screen "
+                     "mapped to 0" << nPresentationScreen);
+            // When the full screen presentation is displayed on a screen
+            // other than 0 or 1 then place the presenter on the first
+            // available screen.
+            nPresenterScreenNumber = 0;
+            break;
+    }
+    return nPresenterScreenNumber;
+}
+
+Reference<drawing::framework::XResourceId> PresenterScreen::GetMainPaneId (
+    const Reference<presentation::XPresentation2>& rxPresentation) const
+{
+    // A negative value means that the presentation spans all available
+    // displays.  That leaves no room for the presenter.
+    const sal_Int32 nScreen(GetPresenterScreenNumber(rxPresentation));
+    if (nScreen < 0)
+        return nullptr;
+
+    return ResourceId::create(
+        Reference<XComponentContext>(mxContextWeak),
+        PresenterHelper::msFullScreenPaneURL
+                + "?FullScreen=true&ScreenNumber="
+                + OUString::number(nScreen));
+}
+
+void PresenterScreen::RequestShutdownPresenterScreen()
+{
+    // Restore the configuration that was active before the presenter screen
+    // has been activated.  Now, that the presenter screen is displayed in
+    // its own top level window this probably not necessary, but one never knows.
+    Reference<XConfigurationController> xCC (mxConfigurationControllerWeak);
+    if (xCC.is() && mxSavedConfiguration.is())
+    {
+        xCC->restoreConfiguration(mxSavedConfiguration);
+        mxSavedConfiguration = nullptr;
+    }
+
+    if (xCC.is())
+    {
+        // The actual restoration of the configuration takes place
+        // asynchronously.  The view and pane factories can only by disposed
+        // after that.  Therefore, set up a listener and wait for the
+        // restoration.
+        rtl::Reference<PresenterScreen> pSelf (this);
+        PresenterFrameworkObserver::RunOnUpdateEnd(
+            xCC,
+            [pSelf](bool){ return pSelf->ShutdownPresenterScreen(); });
+        xCC->update();
+    }
+}
+
+void PresenterScreen::ShutdownPresenterScreen()
+{
+    Reference<lang::XComponent> xViewFactoryComponent (mxViewFactory, UNO_QUERY);
+    if (xViewFactoryComponent.is())
+        xViewFactoryComponent->dispose();
+    mxViewFactory = nullptr;
+
+    Reference<lang::XComponent> xPaneFactoryComponent (mxPaneFactory, UNO_QUERY);
+    if (xPaneFactoryComponent.is())
+        xPaneFactoryComponent->dispose();
+    mxPaneFactory = nullptr;
+
+    if (mpPresenterController)
+    {
+        mpPresenterController->dispose();
+        mpPresenterController.clear();
+    }
+    mpPaneContainer = new PresenterPaneContainer(Reference<XComponentContext>(mxContextWeak));
+}
+
+void PresenterScreen::SetupPaneFactory (const Reference<XComponentContext>& rxContext)
+{
+    try
+    {
+        if ( ! mxPaneFactory.is())
+            mxPaneFactory = PresenterPaneFactory::Create(
+                rxContext,
+                mxController,
+                mpPresenterController);
+    }
+    catch (const RuntimeException&)
+    {
+        OSL_ASSERT(false);
+    }
+}
+
+void PresenterScreen::SetupViewFactory (const Reference<XComponentContext>& rxContext)
+{
+    try
+    {
+        if ( ! mxViewFactory.is())
+            mxViewFactory = PresenterViewFactory::Create(
+                rxContext,
+                mxController,
+                mpPresenterController);
+    }
+    catch (const RuntimeException&)
+    {
+        OSL_ASSERT(false);
+    }
+}
+
+void PresenterScreen::SetupConfiguration (
+    const Reference<XComponentContext>& rxContext,
+    const Reference<XResourceId>& rxAnchorId)
+{
+    try
+    {
+        PresenterConfigurationAccess aConfiguration (
+            rxContext,
+            "org.openoffice.Office.PresenterScreen",
+            PresenterConfigurationAccess::READ_ONLY);
+        maViewDescriptors.clear();
+        ProcessViewDescriptions(aConfiguration);
+        OUString sLayoutName ("DefaultLayout");
+        aConfiguration.GetConfigurationNode(
+            "Presenter/CurrentLayout") >>= sLayoutName;
+        ProcessLayout(aConfiguration, sLayoutName, rxContext, rxAnchorId);
+    }
+    catch (const RuntimeException&)
+    {
+    }
+}
+
+void PresenterScreen::ProcessLayout (
+    PresenterConfigurationAccess& rConfiguration,
+    std::u16string_view rsLayoutName,
+    const Reference<XComponentContext>& rxContext,
+    const Reference<XResourceId>& rxAnchorId)
+{
+    try
+    {
+        Reference<container::XHierarchicalNameAccess> xLayoutNode (
+            rConfiguration.GetConfigurationNode(
+                OUString::Concat("Presenter/Layouts/")+rsLayoutName),
+            UNO_QUERY_THROW);
+
+        // Read the parent layout first, if one is referenced.
+        OUString sParentLayout;
+        PresenterConfigurationAccess::GetConfigurationNode(
+            xLayoutNode,
+            "ParentLayout") >>= sParentLayout;
+        if (!sParentLayout.isEmpty())
+        {
+            // Prevent infinite recursion.
+            if (rsLayoutName != sParentLayout)
+                ProcessLayout(rConfiguration, sParentLayout, rxContext, rxAnchorId);
+        }
+
+        // Process the actual layout list.
+        Reference<container::XNameAccess> xList (
+            PresenterConfigurationAccess::GetConfigurationNode(
+                xLayoutNode,
+                "Layout"),
+            UNO_QUERY_THROW);
+
+        ::std::vector<OUString> aProperties
+        {
+            "PaneURL",
+            "ViewURL",
+            "RelativeX",
+            "RelativeY",
+            "RelativeWidth",
+            "RelativeHeight"
+        };
+        PresenterConfigurationAccess::ForAll(
+            xList,
+            aProperties,
+            [this, rxContext, rxAnchorId](std::vector<uno::Any> const& rArgs)
+            {
+                this->ProcessComponent(rArgs, rxContext, rxAnchorId);
+            });
+    }
+    catch (const RuntimeException&)
+    {
+    }
+}
+
+void PresenterScreen::ProcessViewDescriptions (
+    PresenterConfigurationAccess& rConfiguration)
+{
+    try
+    {
+        Reference<container::XNameAccess> xViewDescriptionsNode (
+            rConfiguration.GetConfigurationNode("Presenter/Views"),
+            UNO_QUERY_THROW);
+
+        ::std::vector<OUString> aProperties
+        {
+            "ViewURL",
+            "Title",
+            "AccessibleTitle",
+            "IsOpaque"
+        };
+        PresenterConfigurationAccess::ForAll(
+            xViewDescriptionsNode,
+            aProperties,
+            [this](std::vector<uno::Any> const& rArgs)
+            {
+                return this->ProcessViewDescription(rArgs);
+            });
+    }
+    catch (const RuntimeException&)
+    {
+        OSL_ASSERT(false);
+    }
+}
+
+void PresenterScreen::ProcessComponent (
+    const ::std::vector<Any>& rValues,
+    const Reference<XComponentContext>& rxContext,
+    const Reference<XResourceId>& rxAnchorId)
+{
+    if (rValues.size() != 6)
+        return;
+
+    try
+    {
+        OUString sPaneURL;
+        OUString sViewURL;
+        double nX = 0;
+        double nY = 0;
+        double nWidth = 0;
+        double nHeight = 0;
+        rValues[0] >>= sPaneURL;
+        rValues[1] >>= sViewURL;
+        rValues[2] >>= nX;
+        rValues[3] >>= nY;
+        rValues[4] >>= nWidth;
+        rValues[5] >>= nHeight;
+
+        if (nX>=0 && nY>=0 && nWidth>0 && nHeight>0)
+        {
+            SetupView(
+                rxContext,
+                rxAnchorId,
+                sPaneURL,
+                sViewURL,
+                PresenterPaneContainer::ViewInitializationFunction());
+        }
+       }
+    catch (const Exception&)
+    {
+        OSL_ASSERT(false);
+    }
+}
+
+void PresenterScreen::ProcessViewDescription (
+    const ::std::vector<Any>& rValues)
+{
+    if (rValues.size() != 4)
+        return;
+
+    try
+    {
+        ViewDescriptor aViewDescriptor;
+        OUString sViewURL;
+        rValues[0] >>= sViewURL;
+        rValues[1] >>= aViewDescriptor.msTitle;
+        rValues[2] >>= aViewDescriptor.msAccessibleTitle;
+        rValues[3] >>= aViewDescriptor.mbIsOpaque;
+        if (aViewDescriptor.msAccessibleTitle.isEmpty())
+            aViewDescriptor.msAccessibleTitle = aViewDescriptor.msTitle;
+        maViewDescriptors[sViewURL] = aViewDescriptor;
+    }
+    catch (const Exception&)
+    {
+        OSL_ASSERT(false);
+    }
+}
+
+void PresenterScreen::SetupView(
+    const Reference<XComponentContext>& rxContext,
+    const Reference<XResourceId>& rxAnchorId,
+    const OUString& rsPaneURL,
+    const OUString& rsViewURL,
+    const PresenterPaneContainer::ViewInitializationFunction& rViewInitialization)
+{
+    Reference<XConfigurationController> xCC (mxConfigurationControllerWeak);
+    if (!xCC.is())
+        return;
+
+    Reference<XResourceId> xPaneId (ResourceId::createWithAnchor(rxContext,rsPaneURL,rxAnchorId));
+    // Look up the view descriptor.
+    ViewDescriptor aViewDescriptor;
+    ViewDescriptorContainer::const_iterator iDescriptor (maViewDescriptors.find(rsViewURL));
+    if (iDescriptor != maViewDescriptors.end())
+        aViewDescriptor = iDescriptor->second;
+
+    // Prepare the pane.
+    OSL_ASSERT(mpPaneContainer);
+    mpPaneContainer->PreparePane(
+        xPaneId,
+        rsViewURL,
+        aViewDescriptor.msTitle,
+        aViewDescriptor.msAccessibleTitle,
+        aViewDescriptor.mbIsOpaque,
+        rViewInitialization);
+}
+
+} // end of namespace ::sdext::presenter
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */