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, 1147 insertions, 0 deletions

diff --git a/sfx2/source/view/ipclient.cxx b/sfx2/source/view/ipclient.cxx
new file mode 100644
index 000000000..0c3f39b9e
--- /dev/null
+++ b/sfx2/source/view/ipclient.cxx
@@ -0,0 +1,1147 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/awt/XWindowPeer.hpp>
+#include <com/sun/star/embed/Aspects.hpp>
+#include <com/sun/star/embed/EmbedStates.hpp>
+#include <com/sun/star/embed/UnreachableStateException.hpp>
+#include <com/sun/star/embed/XEmbeddedClient.hpp>
+#include <com/sun/star/embed/XInplaceClient.hpp>
+#include <com/sun/star/embed/XInplaceObject.hpp>
+#include <com/sun/star/embed/XWindowSupplier.hpp>
+#include <com/sun/star/embed/EmbedVerbs.hpp>
+#include <com/sun/star/embed/XEmbeddedOleObject.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/embed/XStateChangeListener.hpp>
+#include <com/sun/star/embed/StateChangeInProgressException.hpp>
+#include <com/sun/star/embed/XLinkageSupport.hpp>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/task/ErrorCodeIOException.hpp>
+#include <com/sun/star/task/StatusIndicatorFactory.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+
+#include <com/sun/star/embed/EmbedMisc.hpp>
+#include <svtools/embedhlp.hxx>
+#include <vcl/svapp.hxx>
+
+#include <sfx2/ipclient.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/objsh.hxx>
+#include <guisaveas.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <svtools/ehdl.hxx>
+
+#include <vcl/timer.hxx>
+#include <vcl/window.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <toolkit/helper/convert.hxx>
+#include <tools/debug.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/fract.hxx>
+#include <tools/gen.hxx>
+#include <svtools/soerr.hxx>
+#include <comphelper/lok.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+
+#define SFX_CLIENTACTIVATE_TIMEOUT 100
+
+using namespace com::sun::star;
+
+namespace {
+
+// SfxEmbedResizeGuard
+class SfxBooleanFlagGuard
+{
+    bool& m_rFlag;
+public:
+    explicit SfxBooleanFlagGuard(bool& bFlag)
+        : m_rFlag( bFlag )
+    {
+        m_rFlag = true;
+    }
+
+    ~SfxBooleanFlagGuard()
+    {
+        m_rFlag = false;
+    }
+};
+
+tools::Rectangle lcl_negateRectX(const tools::Rectangle& rRect)
+{
+    return tools::Rectangle(
+        std::max(static_cast<tools::Long>(0l), -rRect.Right()),
+        rRect.Top(),
+        std::max(static_cast<tools::Long>(0l), -rRect.Left()),
+        rRect.Bottom());
+}
+
+}
+
+// SfxInPlaceClient_Impl
+
+
+class SfxInPlaceClient_Impl : public ::cppu::WeakImplHelper< embed::XEmbeddedClient,
+                                                              embed::XInplaceClient,
+                                                              document::XEventListener,
+                                                              embed::XStateChangeListener,
+                                                              embed::XWindowSupplier >
+{
+public:
+    Timer                           m_aTimer { "sfx::SfxInPlaceClient m_xImpl::m_aTimer" }; // activation timeout, starts after object connection
+    tools::Rectangle                       m_aObjArea;             // area of object in coordinate system of the container (without scaling)
+    Fraction                        m_aScaleWidth;          // scaling that was applied to the object when it was not active
+    Fraction                        m_aScaleHeight;
+    SfxInPlaceClient*               m_pClient;
+    sal_Int64                       m_nAspect;              // ViewAspect that is assigned from the container
+    bool                            m_bStoreObject;
+    bool                            m_bUIActive;            // set and cleared when notification for UI (de)activation is sent
+    bool                            m_bResizeNoScale;
+    bool                            m_bNegativeX;
+
+    uno::Reference < embed::XEmbeddedObject > m_xObject;
+
+
+    SfxInPlaceClient_Impl()
+    : m_pClient( nullptr )
+    , m_nAspect( 0 )
+    , m_bStoreObject( true )
+    , m_bUIActive( false )
+    , m_bResizeNoScale( false )
+    , m_bNegativeX( false )
+    {}
+
+    void SizeHasChanged();
+    DECL_LINK(TimerHdl, Timer *, void);
+    uno::Reference < frame::XFrame > const & GetFrame() const;
+
+    // XEmbeddedClient
+    virtual void SAL_CALL saveObject() override;
+    virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) override;
+
+    // XInplaceClient
+    virtual sal_Bool SAL_CALL canInplaceActivate() override;
+    virtual void SAL_CALL activatingInplace() override;
+    virtual void SAL_CALL activatingUI() override;
+    virtual void SAL_CALL deactivatedInplace() override;
+    virtual void SAL_CALL deactivatedUI() override;
+    virtual uno::Reference< css::frame::XLayoutManager > SAL_CALL getLayoutManager() override;
+    virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() override;
+    virtual awt::Rectangle SAL_CALL getPlacement() override;
+    virtual awt::Rectangle SAL_CALL getClipRectangle() override;
+    virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) override;
+    virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) override;
+    virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) override;
+
+    // XComponentSupplier
+    virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() override;
+
+    // XWindowSupplier
+    virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() override;
+
+    // document::XEventListener
+    virtual void SAL_CALL       notifyEvent( const document::EventObject& aEvent ) override;
+
+    // XStateChangeListener
+    virtual void SAL_CALL changingState( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;
+    virtual void SAL_CALL stateChanged( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;
+};
+
+void SAL_CALL SfxInPlaceClient_Impl::changingState(
+    const css::lang::EventObject& /*aEvent*/,
+    ::sal_Int32 /*nOldState*/,
+    ::sal_Int32 /*nNewState*/ )
+{
+}
+
+void SAL_CALL SfxInPlaceClient_Impl::stateChanged(
+    const css::lang::EventObject& /*aEvent*/,
+    ::sal_Int32 nOldState,
+    ::sal_Int32 nNewState )
+{
+    if ( m_pClient && nOldState != embed::EmbedStates::LOADED && nNewState == embed::EmbedStates::RUNNING )
+    {
+        // deactivation of object
+        uno::Reference< frame::XModel > xDocument;
+        if ( m_pClient->GetViewShell()->GetObjectShell() )
+            xDocument = m_pClient->GetViewShell()->GetObjectShell()->GetModel();
+        SfxObjectShell::SetCurrentComponent( xDocument );
+    }
+}
+
+void SAL_CALL SfxInPlaceClient_Impl::notifyEvent( const document::EventObject& aEvent )
+{
+    SolarMutexGuard aGuard;
+
+    if ( m_pClient && aEvent.EventName == "OnVisAreaChanged" && m_nAspect != embed::Aspects::MSOLE_ICON )
+    {
+        m_pClient->FormatChanged(); // for Writer when format of the object is changed with the area
+        m_pClient->ViewChanged();
+        m_pClient->Invalidate();
+    }
+}
+
+void SAL_CALL SfxInPlaceClient_Impl::disposing( const css::lang::EventObject& /*aEvent*/ )
+{
+    delete m_pClient;
+    m_pClient = nullptr;
+}
+
+// XEmbeddedClient
+
+uno::Reference < frame::XFrame > const & SfxInPlaceClient_Impl::GetFrame() const
+{
+    if ( !m_pClient )
+        throw uno::RuntimeException();
+    return m_pClient->GetViewShell()->GetViewFrame()->GetFrame().GetFrameInterface();
+}
+
+void SAL_CALL SfxInPlaceClient_Impl::saveObject()
+{
+    if (!m_bStoreObject || (m_pClient && m_pClient->IsProtected()))
+        // client wants to discard the object (usually it means the container document is closed while an object is active
+        // and the user didn't request saving the changes
+        return;
+
+    // the common persistence is supported by objects and links
+    uno::Reference< embed::XCommonEmbedPersist > xPersist( m_xObject, uno::UNO_QUERY_THROW );
+
+    uno::Reference< frame::XFrame >              xFrame;
+    uno::Reference< task::XStatusIndicator >     xStatusIndicator;
+    uno::Reference< frame::XModel >              xModel( m_xObject->getComponent(), uno::UNO_QUERY );
+    uno::Reference< uno::XComponentContext >     xContext( ::comphelper::getProcessComponentContext() );
+
+    if ( xModel.is() )
+    {
+        uno::Reference< frame::XController > xController = xModel->getCurrentController();
+        if ( xController.is() )
+            xFrame = xController->getFrame();
+    }
+
+    if ( xFrame.is() )
+    {
+        // set non-reschedule progress to prevent problems when asynchronous calls are made
+        // during storing of the embedded object
+        uno::Reference< task::XStatusIndicatorFactory > xStatusIndicatorFactory =
+               task::StatusIndicatorFactory::createWithFrame( xContext, xFrame, true/*DisableReschedule*/, false/*AllowParentShow*/ );
+
+        uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
+        if ( xPropSet.is() )
+        {
+            try
+            {
+                xStatusIndicator = xStatusIndicatorFactory->createStatusIndicator();
+                xPropSet->setPropertyValue( "IndicatorInterception" , uno::Any( xStatusIndicator ));
+            }
+            catch ( const uno::RuntimeException& )
+            {
+                throw;
+            }
+            catch ( uno::Exception& )
+            {
+            }
+        }
+    }
+
+    try
+    {
+        xPersist->storeOwn();
+        m_xObject->update();
+    }
+    catch ( uno::Exception& )
+    {
+        //TODO/LATER: what should happen if object can't be saved?!
+    }
+
+    // reset status indicator interception after storing
+    try
+    {
+        uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
+        if ( xPropSet.is() )
+        {
+            xStatusIndicator.clear();
+            xPropSet->setPropertyValue( "IndicatorInterception" , uno::Any( xStatusIndicator ));
+        }
+    }
+    catch ( const uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch ( uno::Exception& )
+    {
+    }
+
+    // the client can exist only in case there is a view shell
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    SfxObjectShell* pDocShell = m_pClient->GetViewShell()->GetObjectShell();
+    if ( !pDocShell )
+        throw uno::RuntimeException();
+
+    pDocShell->SetModified();
+
+    //TODO/LATER: invalidation might be necessary when object was modified, but is not
+    //saved through this method
+    // m_pClient->Invalidate();
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::visibilityChanged( sal_Bool bVisible )
+{
+    SolarMutexGuard aGuard;
+
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    m_pClient->GetViewShell()->OutplaceActivated( bVisible );
+    if (m_pClient) // it can change in the above code
+        m_pClient->Invalidate();
+}
+
+
+// XInplaceClient
+
+sal_Bool SAL_CALL SfxInPlaceClient_Impl::canInplaceActivate()
+{
+    if ( !m_xObject.is() )
+        throw uno::RuntimeException();
+
+    // we don't want to switch directly from outplace to inplace mode
+    if ( m_xObject->getCurrentState() == embed::EmbedStates::ACTIVE || m_nAspect == embed::Aspects::MSOLE_ICON )
+        return false;
+
+    return true;
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::activatingInplace()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    if ( !comphelper::LibreOfficeKit::isActive() )
+        return;
+
+    if ( SfxViewShell* pViewShell = m_pClient->GetViewShell() )
+    {
+        tools::Rectangle aRect(m_pClient->GetObjArea());
+
+        if (m_pClient->GetEditWin())
+        {
+            if (m_pClient->GetEditWin()->GetMapMode().GetMapUnit() == MapUnit::Map100thMM)
+                aRect = o3tl::convert(aRect, o3tl::Length::mm100, o3tl::Length::twip);
+        }
+
+        OString str = (m_bNegativeX ? lcl_negateRectX(aRect) : aRect).toString() + ", \"INPLACE\"";
+        pViewShell->libreOfficeKitViewCallback( LOK_CALLBACK_GRAPHIC_SELECTION, str.getStr() );
+    }
+
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::activatingUI()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    m_pClient->GetViewShell()->ResetAllClients_Impl(m_pClient);
+    m_bUIActive = true;
+    m_pClient->GetViewShell()->UIActivating( m_pClient );
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::deactivatedInplace()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    if ( comphelper::LibreOfficeKit::isActive() )
+    {
+        if ( SfxViewShell* pViewShell = m_pClient->GetViewShell() ) {
+            pViewShell->libreOfficeKitViewCallback( LOK_CALLBACK_GRAPHIC_SELECTION, "INPLACE EXIT" );
+        }
+    }
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::deactivatedUI()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    m_pClient->GetViewShell()->UIDeactivated( m_pClient );
+    m_bUIActive = false;
+}
+
+
+uno::Reference< css::frame::XLayoutManager > SAL_CALL SfxInPlaceClient_Impl::getLayoutManager()
+{
+    uno::Reference < beans::XPropertySet > xFrame( GetFrame(), uno::UNO_QUERY_THROW );
+
+    uno::Reference< css::frame::XLayoutManager > xMan;
+    try
+    {
+        uno::Any aAny = xFrame->getPropertyValue( "LayoutManager" );
+        aAny >>= xMan;
+    }
+    catch ( uno::Exception& ex )
+    {
+        css::uno::Any anyEx = cppu::getCaughtException();
+        throw css::lang::WrappedTargetRuntimeException( ex.Message,
+                        nullptr, anyEx );
+    }
+
+    return xMan;
+}
+
+
+uno::Reference< frame::XDispatchProvider > SAL_CALL SfxInPlaceClient_Impl::getInplaceDispatchProvider()
+{
+    return uno::Reference < frame::XDispatchProvider >( GetFrame(), uno::UNO_QUERY_THROW );
+}
+
+
+awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getPlacement()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    // apply scaling to object area and convert to pixels
+    tools::Rectangle aRealObjArea( m_aObjArea );
+    aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth() * m_aScaleWidth),
+                                tools::Long( aRealObjArea.GetHeight() * m_aScaleHeight) ) );
+
+    vcl::Window* pEditWin = m_pClient->GetEditWin();
+    // In Writer and Impress the map mode is disabled. So when a chart is
+    // activated (for in place editing) we get the chart win size in 100th mm
+    // and any method that should return pixels returns 100th mm and the chart
+    // window map mode has a ~26.485 scale factor.
+    // All that does not fit with current implementation for handling chart
+    // editing in LOK.
+    if (comphelper::LibreOfficeKit::isActive())
+    {
+        bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
+        if (!bMapModeEnabled)
+            pEditWin->EnableMapMode();
+        aRealObjArea = pEditWin->LogicToPixel(aRealObjArea);
+        if (!bMapModeEnabled && pEditWin->IsMapModeEnabled())
+            pEditWin->EnableMapMode(false);
+    }
+    else
+    {
+        aRealObjArea = pEditWin->LogicToPixel(aRealObjArea);
+    }
+
+    return AWTRectangle( aRealObjArea );
+}
+
+
+awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getClipRectangle()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    // currently(?) same as placement
+    tools::Rectangle aRealObjArea( m_aObjArea );
+    aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth() * m_aScaleWidth),
+                                tools::Long( aRealObjArea.GetHeight() * m_aScaleHeight) ) );
+
+    vcl::Window* pEditWin = m_pClient->GetEditWin();
+    // See comment for SfxInPlaceClient_Impl::getPlacement.
+    if (comphelper::LibreOfficeKit::isActive())
+    {
+        bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
+        if (!bMapModeEnabled)
+            pEditWin->EnableMapMode();
+        aRealObjArea = pEditWin->LogicToPixel(aRealObjArea);
+        if (!bMapModeEnabled && pEditWin->IsMapModeEnabled())
+            pEditWin->EnableMapMode(false);
+    }
+    else
+    {
+        aRealObjArea = pEditWin->LogicToPixel(aRealObjArea);
+    }
+
+    return AWTRectangle( aRealObjArea );
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ )
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    // TODO/MBA: keyboard accelerators
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::scrollObject( const awt::Size& /*aOffset*/ )
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+}
+
+
+void SAL_CALL SfxInPlaceClient_Impl::changedPlacement( const awt::Rectangle& aPosRect )
+{
+    uno::Reference< embed::XInplaceObject > xInplace( m_xObject, uno::UNO_QUERY_THROW );
+    if ( !m_pClient || !m_pClient->GetEditWin() || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    // check if the change is at least one pixel in size
+    awt::Rectangle aOldRect = getPlacement();
+    tools::Rectangle aNewPixelRect = VCLRectangle( aPosRect );
+    tools::Rectangle aOldPixelRect = VCLRectangle( aOldRect );
+    if ( aOldPixelRect == aNewPixelRect )
+        // nothing has changed
+        return;
+
+    // new scaled object area
+    tools::Rectangle aNewLogicRect = m_pClient->GetEditWin()->PixelToLogic( aNewPixelRect );
+
+    // all the size changes in this method should happen without scaling
+    // SfxBooleanFlagGuard aGuard( m_bResizeNoScale, sal_True );
+
+    // allow container to apply restrictions on the requested new area;
+    // the container might change the object view during size calculation;
+    // currently only writer does it
+    m_pClient->RequestNewObjectArea( aNewLogicRect);
+
+    if ( aNewLogicRect != m_pClient->GetScaledObjArea() )
+    {
+        // the calculation of the object area has not changed the object size
+        // it should be done here then
+        SfxBooleanFlagGuard aGuard( m_bResizeNoScale );
+
+        // new size of the object area without scaling
+        Size aNewObjSize( tools::Long( aNewLogicRect.GetWidth()  / m_aScaleWidth ),
+                          tools::Long( aNewLogicRect.GetHeight() / m_aScaleHeight ) );
+
+        // now remove scaling from new placement and keep this at the new object area
+        aNewLogicRect.SetSize( aNewObjSize );
+        m_aObjArea = aNewLogicRect;
+
+        // let the window size be recalculated
+        SizeHasChanged();
+    }
+
+    // notify container view about changes
+    m_pClient->ObjectAreaChanged();
+}
+
+// XComponentSupplier
+
+uno::Reference< util::XCloseable > SAL_CALL SfxInPlaceClient_Impl::getComponent()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    SfxObjectShell* pDocShell = m_pClient->GetViewShell()->GetObjectShell();
+    if ( !pDocShell )
+        throw uno::RuntimeException();
+
+    // all the components must implement XCloseable
+    uno::Reference< util::XCloseable > xComp( pDocShell->GetModel(), uno::UNO_QUERY_THROW );
+    return xComp;
+}
+
+
+// XWindowSupplier
+
+uno::Reference< awt::XWindow > SAL_CALL SfxInPlaceClient_Impl::getWindow()
+{
+    if ( !m_pClient || !m_pClient->GetEditWin() )
+        throw uno::RuntimeException();
+
+    uno::Reference< awt::XWindow > xWin( m_pClient->GetEditWin()->GetComponentInterface(), uno::UNO_QUERY );
+    return xWin;
+}
+
+
+// notification to the client implementation that either the object area or the scaling has been changed
+// as a result the logical size of the window has changed also
+void SfxInPlaceClient_Impl::SizeHasChanged()
+{
+    if ( !m_pClient || !m_pClient->GetViewShell() )
+        throw uno::RuntimeException();
+
+    try {
+        if ( m_xObject.is()
+          && ( m_xObject->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE
+                || m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE ) )
+        {
+            // only possible in active states
+            uno::Reference< embed::XInplaceObject > xInplace( m_xObject, uno::UNO_QUERY_THROW );
+
+            if ( m_bResizeNoScale )
+            {
+                // the resizing should be done without scaling
+                // set the correct size to the object to avoid the scaling
+                MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( m_xObject->getMapUnit( m_nAspect ) ) );
+                MapMode aClientMap( m_pClient->GetEditWin()->GetMapMode().GetMapUnit() );
+
+                // convert to logical coordinates of the embedded object
+                Size aNewSize = m_pClient->GetEditWin()->LogicToLogic( m_aObjArea.GetSize(), &aClientMap, &aObjectMap );
+                m_xObject->setVisualAreaSize( m_nAspect, awt::Size( aNewSize.Width(), aNewSize.Height() ) );
+            }
+
+            xInplace->setObjectRectangles( getPlacement(), getClipRectangle() );
+        }
+    }
+    catch( uno::Exception& )
+    {
+        // TODO/LATER: handle error
+    }
+}
+
+
+IMPL_LINK_NOARG(SfxInPlaceClient_Impl, TimerHdl, Timer *, void)
+{
+    if ( m_pClient && m_xObject.is() )
+    {
+        m_pClient->GetViewShell()->CheckIPClient_Impl(m_pClient,
+                m_pClient->GetViewShell()->GetObjectShell()->GetVisArea());
+    }
+}
+
+
+// SfxInPlaceClient
+
+
+SfxInPlaceClient::SfxInPlaceClient( SfxViewShell* pViewShell, vcl::Window *pDraw, sal_Int64 nAspect ) :
+    m_xImp( new SfxInPlaceClient_Impl ),
+    m_pViewSh( pViewShell ),
+    m_pEditWin( pDraw )
+{
+    m_xImp->m_pClient = this;
+    m_xImp->m_nAspect = nAspect;
+    m_xImp->m_aScaleWidth = m_xImp->m_aScaleHeight = Fraction(1,1);
+    pViewShell->NewIPClient_Impl(this);
+    m_xImp->m_aTimer.SetTimeout( SFX_CLIENTACTIVATE_TIMEOUT );
+    m_xImp->m_aTimer.SetInvokeHandler( LINK( m_xImp.get(), SfxInPlaceClient_Impl, TimerHdl ) );
+}
+
+
+SfxInPlaceClient::~SfxInPlaceClient()
+{
+    m_pViewSh->IPClientGone_Impl(this);
+
+    // deleting the client before storing the object means discarding all changes
+    m_xImp->m_bStoreObject = false;
+    SetObject(nullptr);
+
+    m_xImp->m_pClient = nullptr;
+
+    // the next call will destroy m_xImp if no other reference to it exists
+    m_xImp.clear();
+
+    // TODO/LATER:
+    // the class is not intended to be used in multithreaded environment;
+    // if it will this disconnection and all the parts that use the m_pClient
+    // must be guarded with mutex
+}
+
+
+void SfxInPlaceClient::SetObjectState( sal_Int32 nState )
+{
+    if ( !GetObject().is() )
+        return;
+
+    if ( m_xImp->m_nAspect == embed::Aspects::MSOLE_ICON
+      && ( nState == embed::EmbedStates::UI_ACTIVE || nState == embed::EmbedStates::INPLACE_ACTIVE ) )
+    {
+        OSL_FAIL( "Iconified object should not be activated inplace!" );
+        return;
+    }
+
+    try
+    {
+        GetObject()->changeState( nState );
+    }
+    catch ( uno::Exception& )
+    {}
+}
+
+
+sal_Int64 SfxInPlaceClient::GetObjectMiscStatus() const
+{
+    if ( GetObject().is() )
+        return GetObject()->getStatus( m_xImp->m_nAspect );
+    return 0;
+}
+
+
+const uno::Reference < embed::XEmbeddedObject >& SfxInPlaceClient::GetObject() const
+{
+    return m_xImp->m_xObject;
+}
+
+
+void SfxInPlaceClient::SetObject( const uno::Reference < embed::XEmbeddedObject >& rObject )
+{
+    if ( m_xImp->m_xObject.is() && rObject != m_xImp->m_xObject )
+    {
+        DBG_ASSERT( GetObject()->getClientSite() == static_cast<cppu::OWeakObject*>(m_xImp.get()), "Wrong ClientSite!" );
+        if ( GetObject()->getClientSite() == static_cast<cppu::OWeakObject*>(m_xImp.get()) )
+        {
+            if ( GetObject()->getCurrentState() != embed::EmbedStates::LOADED )
+                SetObjectState( embed::EmbedStates::RUNNING );
+            m_xImp->m_xObject->removeEventListener( m_xImp );
+            m_xImp->m_xObject->removeStateChangeListener( m_xImp );
+            try
+            {
+                m_xImp->m_xObject->setClientSite( nullptr );
+            }
+            catch( uno::Exception& )
+            {
+                OSL_FAIL( "Can not clean the client site!" );
+            }
+        }
+    }
+
+    if ( m_pViewSh->GetViewFrame()->GetFrame().IsClosing_Impl() )
+        // sometimes applications reconnect clients on shutting down because it happens in their Paint methods
+        return;
+
+    m_xImp->m_xObject = rObject;
+
+    if ( rObject.is() )
+    {
+        // as soon as an object was connected to a client it has to be checked whether the object wants
+        // to be activated
+        rObject->addStateChangeListener( m_xImp );
+        rObject->addEventListener( m_xImp );
+
+        try
+        {
+            rObject->setClientSite( m_xImp );
+        }
+        catch( uno::Exception& )
+        {
+            OSL_FAIL( "Can not set the client site!" );
+        }
+
+        m_xImp->m_aTimer.Start();
+    }
+    else
+        m_xImp->m_aTimer.Stop();
+}
+
+
+bool SfxInPlaceClient::SetObjArea( const tools::Rectangle& rArea )
+{
+    if( rArea != m_xImp->m_aObjArea )
+    {
+        m_xImp->m_aObjArea = rArea;
+        m_xImp->SizeHasChanged();
+
+        Invalidate();
+        return true;
+    }
+
+    return false;
+}
+
+
+const tools::Rectangle& SfxInPlaceClient::GetObjArea() const
+{
+    return m_xImp->m_aObjArea;
+}
+
+tools::Rectangle SfxInPlaceClient::GetScaledObjArea() const
+{
+    tools::Rectangle aRealObjArea( m_xImp->m_aObjArea );
+    aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth()  * m_xImp->m_aScaleWidth ),
+                                tools::Long( aRealObjArea.GetHeight() * m_xImp->m_aScaleHeight ) ) );
+    return aRealObjArea;
+}
+
+
+void SfxInPlaceClient::SetSizeScale( const Fraction & rScaleWidth, const Fraction & rScaleHeight )
+{
+    if ( m_xImp->m_aScaleWidth != rScaleWidth || m_xImp->m_aScaleHeight != rScaleHeight )
+    {
+        m_xImp->m_aScaleWidth = rScaleWidth;
+        m_xImp->m_aScaleHeight = rScaleHeight;
+
+        m_xImp->SizeHasChanged();
+
+        // TODO/LATER: Invalidate seems to trigger (wrong) recalculations of the ObjArea, so it's better
+        // not to call it here, but maybe it sounds reasonable to do so.
+        //Invalidate();
+    }
+}
+
+
+void SfxInPlaceClient::SetObjAreaAndScale( const tools::Rectangle& rArea, const Fraction& rScaleWidth, const Fraction& rScaleHeight )
+{
+    if( rArea != m_xImp->m_aObjArea || m_xImp->m_aScaleWidth != rScaleWidth || m_xImp->m_aScaleHeight != rScaleHeight )
+    {
+        m_xImp->m_aObjArea = rArea;
+        m_xImp->m_aScaleWidth = rScaleWidth;
+        m_xImp->m_aScaleHeight = rScaleHeight;
+
+        m_xImp->SizeHasChanged();
+
+        Invalidate();
+    }
+}
+
+
+const Fraction& SfxInPlaceClient::GetScaleWidth() const
+{
+    return m_xImp->m_aScaleWidth;
+}
+
+
+const Fraction& SfxInPlaceClient::GetScaleHeight() const
+{
+    return m_xImp->m_aScaleHeight;
+}
+
+
+void SfxInPlaceClient::Invalidate()
+{
+    // TODO/LATER: do we need both?
+
+    // the object area is provided in logical coordinates of the window but without scaling applied
+    tools::Rectangle aRealObjArea( m_xImp->m_aObjArea );
+    aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth()  * m_xImp->m_aScaleWidth ),
+                                tools::Long( aRealObjArea.GetHeight() * m_xImp->m_aScaleHeight ) ) );
+
+    m_pEditWin->Invalidate( IsNegativeX() ? lcl_negateRectX(aRealObjArea) : aRealObjArea );
+
+    ViewChanged();
+}
+
+
+bool SfxInPlaceClient::IsObjectUIActive() const
+{
+    try {
+        return ( m_xImp->m_xObject.is() && ( m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE ) );
+    }
+    catch( uno::Exception& )
+    {}
+
+    return false;
+}
+
+
+bool SfxInPlaceClient::IsObjectInPlaceActive() const
+{
+    try {
+        return(
+               (
+                m_xImp->m_xObject.is() &&
+                (m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE)
+               ) ||
+               (
+                m_xImp->m_xObject.is() &&
+                (m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE)
+               )
+              );
+    }
+    catch( uno::Exception& )
+    {}
+
+    return false;
+}
+
+
+SfxInPlaceClient* SfxInPlaceClient::GetClient( SfxObjectShell const * pDoc, const css::uno::Reference < css::embed::XEmbeddedObject >& xObject )
+{
+    for ( SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDoc); pFrame; pFrame=SfxViewFrame::GetNext(*pFrame,pDoc) )
+    {
+        if( pFrame->GetViewShell() )
+        {
+            SfxInPlaceClient* pClient = pFrame->GetViewShell()->FindIPClient( xObject, nullptr );
+            if ( pClient )
+                return pClient;
+        }
+    }
+
+    return nullptr;
+}
+
+sal_Int64 SfxInPlaceClient::GetAspect() const
+{
+    return m_xImp->m_nAspect;
+}
+
+ErrCode SfxInPlaceClient::DoVerb(sal_Int32 nVerb)
+{
+    SfxErrorContext aEc(ERRCTX_SO_DOVERB, m_pViewSh->GetFrameWeld(), RID_SO_ERRCTX);
+    ErrCode nError = ERRCODE_NONE;
+
+    if ( m_xImp->m_xObject.is() )
+    {
+        bool bSaveCopyAs = false;
+        if ( nVerb == -8 ) // "Save Copy as..."
+        {
+            svt::EmbeddedObjectRef::TryRunningState( m_xImp->m_xObject );
+            // TODO/LATER: this special verb should disappear when outplace activation is completely available
+            uno::Reference< frame::XModel > xEmbModel( m_xImp->m_xObject->getComponent(), uno::UNO_QUERY );
+            if ( xEmbModel.is() )
+            {
+                bSaveCopyAs = true;
+
+                try
+                {
+                    SfxStoringHelper aHelper;
+                    uno::Sequence< beans::PropertyValue > aDispatchArgs{
+                        comphelper::makePropertyValue("SaveTo", true)
+                    };
+
+                    aHelper.GUIStoreModel( xEmbModel,
+                                            u"SaveAs",
+                                            aDispatchArgs,
+                                            false,
+                                            SignatureState::NOSIGNATURES );
+                }
+                catch( const task::ErrorCodeIOException& aErrorEx )
+                {
+                    nError = ErrCode(aErrorEx.ErrCode);
+                }
+                catch( uno::Exception& )
+                {
+                    nError = ERRCODE_IO_GENERAL;
+                    // TODO/LATER: better error handling
+                }
+            }
+        }
+
+        if ( !bSaveCopyAs )
+        {
+            if ( m_xImp->m_nAspect == embed::Aspects::MSOLE_ICON )
+            {
+                // the common persistence is supported by objects and links
+
+                uno::Reference< embed::XEmbeddedOleObject > xEmbeddedOleObject( m_xImp->m_xObject, uno::UNO_QUERY );
+
+                if ( xEmbeddedOleObject.is() && (nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_OPEN || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW ))
+                    nVerb = embed::EmbedVerbs::MS_OLEVERB_SHOW;
+                else if ( nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW )
+                    nVerb = embed::EmbedVerbs::MS_OLEVERB_OPEN; // outplace activation
+                else if ( nVerb == embed::EmbedVerbs::MS_OLEVERB_UIACTIVATE
+                       || nVerb == embed::EmbedVerbs::MS_OLEVERB_IPACTIVATE )
+                    nError = ERRCODE_SO_GENERALERROR;
+            }
+
+            if ( !nError )
+            {
+                // See comment for SfxInPlaceClient_Impl::getPlacement.
+                vcl::Window* pEditWin = GetEditWin();
+                bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
+                if (comphelper::LibreOfficeKit::isActive() && !bMapModeEnabled)
+                {
+                    pEditWin->EnableMapMode();
+                }
+                m_pViewSh->GetViewFrame()->GetFrame().LockResize_Impl(true);
+                try
+                {
+                    m_xImp->m_xObject->setClientSite( m_xImp );
+
+                    m_xImp->m_xObject->doVerb( nVerb );
+                }
+                catch ( embed::UnreachableStateException& )
+                {
+                    if (nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_OPEN || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW)
+                    {
+                        // a workaround for the default verb, usually makes sense for alien objects
+                        try
+                        {
+                            m_xImp->m_xObject->doVerb( -9 ); // open own view, a workaround verb that is not visible
+
+                            if ( m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE )
+                            {
+                                // the object was converted to OOo object
+                                awt::Size aSize = m_xImp->m_xObject->getVisualAreaSize( m_xImp->m_nAspect );
+                                MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( m_xImp->m_xObject->getMapUnit( m_xImp->m_nAspect ) ) );
+                                MapMode aClientMap( GetEditWin()->GetMapMode().GetMapUnit() );
+                                Size aNewSize = GetEditWin()->LogicToLogic( Size( aSize.Width, aSize.Height ), &aObjectMap, &aClientMap );
+
+                                tools::Rectangle aScaledArea = GetScaledObjArea();
+                                m_xImp->m_aObjArea.SetSize( aNewSize );
+                                m_xImp->m_aScaleWidth = Fraction( aScaledArea.GetWidth(), aNewSize.Width() );
+                                m_xImp->m_aScaleHeight = Fraction( aScaledArea.GetHeight(), aNewSize.Height() );
+                            }
+                        }
+                        catch (uno::Exception const&)
+                        {
+                            TOOLS_WARN_EXCEPTION("embeddedobj", "SfxInPlaceClient::DoVerb: -9 fallback path");
+                            nError = ERRCODE_SO_GENERALERROR;
+                        }
+                    }
+                }
+                catch ( embed::StateChangeInProgressException& )
+                {
+                    // TODO/LATER: it would be nice to be able to provide the current target state outside
+                    nError = ERRCODE_SO_CANNOT_DOVERB_NOW;
+                }
+                catch (uno::Exception const&)
+                {
+                    TOOLS_WARN_EXCEPTION("embeddedobj", "SfxInPlaceClient::DoVerb");
+                    nError = ERRCODE_SO_GENERALERROR;
+                    //TODO/LATER: better error handling
+
+                }
+                if (comphelper::LibreOfficeKit::isActive() && !bMapModeEnabled
+                        && pEditWin->IsMapModeEnabled())
+                {
+                    pEditWin->EnableMapMode(false);
+                }
+                SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
+                pFrame->GetFrame().LockResize_Impl(false);
+                pFrame->GetFrame().Resize();
+            }
+        }
+    }
+
+    if( nError )
+        ErrorHandler::HandleError( nError );
+
+    return nError;
+}
+
+void SfxInPlaceClient::VisAreaChanged()
+{
+    uno::Reference < embed::XInplaceObject > xObj( m_xImp->m_xObject, uno::UNO_QUERY );
+    if ( xObj.is() )
+        m_xImp->SizeHasChanged();
+}
+
+void SfxInPlaceClient::ObjectAreaChanged()
+{
+    // dummy implementation
+}
+
+void SfxInPlaceClient::RequestNewObjectArea( tools::Rectangle& )
+{
+    // dummy implementation
+}
+
+void SfxInPlaceClient::ViewChanged()
+{
+    // dummy implementation
+}
+
+void SfxInPlaceClient::FormatChanged()
+{
+    // dummy implementation
+}
+
+bool SfxInPlaceClient::IsProtected() const { return false; }
+
+void SfxInPlaceClient::DeactivateObject()
+{
+    if ( !GetObject().is() )
+        return;
+
+    try
+    {
+        m_xImp->m_bUIActive = false;
+        bool bHasFocus = false;
+        uno::Reference< frame::XModel > xModel( m_xImp->m_xObject->getComponent(), uno::UNO_QUERY );
+        if ( xModel.is() )
+        {
+            uno::Reference< frame::XController > xController = xModel->getCurrentController();
+            if ( xController.is() )
+            {
+                VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xController->getFrame()->getContainerWindow() );
+                bHasFocus = pWindow->HasChildPathFocus( true );
+            }
+        }
+
+        m_pViewSh->GetViewFrame()->GetFrame().LockResize_Impl(true);
+
+        if ( m_xImp->m_xObject->getStatus( m_xImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
+        {
+            m_xImp->m_xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
+            if (bHasFocus)
+                m_pViewSh->GetWindow()->GrabFocus();
+        }
+        else
+        {
+            // the links should not stay in running state for long time because of locking
+            uno::Reference< embed::XLinkageSupport > xLink( m_xImp->m_xObject, uno::UNO_QUERY );
+            if ( xLink.is() && xLink->isLink() )
+                m_xImp->m_xObject->changeState( embed::EmbedStates::LOADED );
+            else
+                m_xImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
+        }
+
+        SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
+        SfxViewFrame::SetViewFrame( pFrame );
+        pFrame->GetFrame().LockResize_Impl(false);
+        pFrame->GetFrame().Resize();
+    }
+    catch (css::uno::Exception& )
+    {}
+}
+
+void SfxInPlaceClient::ResetObject()
+{
+    if ( !GetObject().is() )
+        return;
+
+    try
+    {
+        m_xImp->m_bUIActive = false;
+        if ( m_xImp->m_xObject->getStatus( m_xImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
+            m_xImp->m_xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
+        else
+        {
+            // the links should not stay in running state for long time because of locking
+            uno::Reference< embed::XLinkageSupport > xLink( m_xImp->m_xObject, uno::UNO_QUERY );
+            if ( xLink.is() && xLink->isLink() )
+                m_xImp->m_xObject->changeState( embed::EmbedStates::LOADED );
+            else
+                m_xImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
+        }
+    }
+    catch (css::uno::Exception& )
+    {}
+}
+
+bool SfxInPlaceClient::IsUIActive() const
+{
+    return m_xImp->m_bUIActive;
+}
+
+void SfxInPlaceClient::SetNegativeX(bool bSet)
+{
+    m_xImp->m_bNegativeX = bSet;
+}
+
+bool SfxInPlaceClient::IsNegativeX() const
+{
+    return m_xImp->m_bNegativeX;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */