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

diff --git a/svx/source/svdraw/svdouno.cxx b/svx/source/svdraw/svdouno.cxx
new file mode 100644
index 000000000..49cea290a
--- /dev/null
+++ b/svx/source/svdraw/svdouno.cxx
@@ -0,0 +1,510 @@
+/* -*- 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 <sdr/contact/viewcontactofunocontrol.hxx>
+#include <sdr/contact/viewobjectcontactofunocontrol.hxx>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/util/XCloneable.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <comphelper/processfactory.hxx>
+#include <svx/svdouno.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/strings.hrc>
+#include <svx/svdview.hxx>
+#include <svx/svdorect.hxx>
+#include <svx/svdviter.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ref.hxx>
+#include <svx/sdrpagewindow.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/debug.hxx>
+#include <o3tl/sorted_vector.hxx>
+
+using namespace ::com::sun::star;
+using namespace sdr::contact;
+
+
+//   Defines
+
+
+//   Helper class SdrControlEventListenerImpl
+
+#include <com/sun/star/lang/XEventListener.hpp>
+
+#include <cppuhelper/implbase.hxx>
+
+
+class SdrControlEventListenerImpl : public ::cppu::WeakImplHelper< css::lang::XEventListener >
+{
+protected:
+    SdrUnoObj*                  pObj;
+
+public:
+    explicit SdrControlEventListenerImpl(SdrUnoObj* _pObj)
+    :   pObj(_pObj)
+    {}
+
+    // XEventListener
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+
+    void StopListening(const uno::Reference< lang::XComponent >& xComp);
+    void StartListening(const uno::Reference< lang::XComponent >& xComp);
+};
+
+// XEventListener
+void SAL_CALL SdrControlEventListenerImpl::disposing( const css::lang::EventObject& /*Source*/)
+{
+    if (pObj)
+    {
+        pObj->xUnoControlModel = nullptr;
+    }
+}
+
+void SdrControlEventListenerImpl::StopListening(const uno::Reference< lang::XComponent >& xComp)
+{
+    if (xComp.is())
+        xComp->removeEventListener(this);
+}
+
+void SdrControlEventListenerImpl::StartListening(const uno::Reference< lang::XComponent >& xComp)
+{
+    if (xComp.is())
+        xComp->addEventListener(this);
+}
+
+
+struct SdrUnoObjDataHolder
+{
+    mutable ::rtl::Reference< SdrControlEventListenerImpl >
+                                    pEventListener;
+};
+
+
+namespace
+{
+    void lcl_ensureControlVisibility( SdrView const * _pView, const SdrUnoObj* _pObject, bool _bVisible )
+    {
+        OSL_PRECOND( _pObject, "lcl_ensureControlVisibility: no object -> no survival!" );
+
+        SdrPageView* pPageView = _pView ? _pView->GetSdrPageView() : nullptr;
+        DBG_ASSERT( pPageView, "lcl_ensureControlVisibility: no view found!" );
+        if ( !pPageView )
+            return;
+
+        ViewContact& rUnoControlContact( _pObject->GetViewContact() );
+
+        for ( sal_uInt32 i = 0; i < pPageView->PageWindowCount(); ++i )
+        {
+            SdrPageWindow* pPageWindow = pPageView->GetPageWindow( i );
+            DBG_ASSERT( pPageWindow, "lcl_ensureControlVisibility: invalid PageViewWindow!" );
+            if ( !pPageWindow )
+                continue;
+
+            if ( !pPageWindow->HasObjectContact() )
+                continue;
+
+            ObjectContact& rPageViewContact( pPageWindow->GetObjectContact() );
+            const ViewObjectContact& rViewObjectContact( rUnoControlContact.GetViewObjectContact( rPageViewContact ) );
+            const ViewObjectContactOfUnoControl* pUnoControlContact = dynamic_cast< const ViewObjectContactOfUnoControl* >( &rViewObjectContact );
+            DBG_ASSERT( pUnoControlContact, "lcl_ensureControlVisibility: wrong ViewObjectContact type!" );
+            if ( !pUnoControlContact )
+                continue;
+
+            pUnoControlContact->ensureControlVisibility( _bVisible );
+        }
+    }
+}
+
+SdrUnoObj::SdrUnoObj(
+    SdrModel& rSdrModel,
+    const OUString& rModelName)
+:   SdrRectObj(rSdrModel),
+    m_pImpl( new SdrUnoObjDataHolder )
+{
+    bIsUnoObj = true;
+
+    m_pImpl->pEventListener = new SdrControlEventListenerImpl(this);
+
+    // only an owner may create independently
+    if (!rModelName.isEmpty())
+        CreateUnoControlModel(rModelName);
+}
+
+SdrUnoObj::SdrUnoObj(
+    SdrModel& rSdrModel,
+    const OUString& rModelName,
+    const uno::Reference< lang::XMultiServiceFactory >& rxSFac)
+:   SdrRectObj(rSdrModel),
+    m_pImpl( new SdrUnoObjDataHolder )
+{
+    bIsUnoObj = true;
+
+    m_pImpl->pEventListener = new SdrControlEventListenerImpl(this);
+
+    // only an owner may create independently
+    if (!rModelName.isEmpty())
+        CreateUnoControlModel(rModelName,rxSFac);
+}
+
+SdrUnoObj::~SdrUnoObj()
+{
+    try
+    {
+        // clean up the control model
+        uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY);
+        if (xComp.is())
+        {
+            // is the control model owned by its environment?
+            uno::Reference< container::XChild > xContent(xUnoControlModel, uno::UNO_QUERY);
+            if (xContent.is() && !xContent->getParent().is())
+                xComp->dispose();
+            else
+                m_pImpl->pEventListener->StopListening(xComp);
+        }
+    }
+    catch( const uno::Exception& )
+    {
+        TOOLS_WARN_EXCEPTION( "svx", "SdrUnoObj::~SdrUnoObj" );
+    }
+}
+
+void SdrUnoObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
+{
+    rInfo.bRotateFreeAllowed        =   false;
+    rInfo.bRotate90Allowed          =   false;
+    rInfo.bMirrorFreeAllowed        =   false;
+    rInfo.bMirror45Allowed          =   false;
+    rInfo.bMirror90Allowed          =   false;
+    rInfo.bTransparenceAllowed = false;
+    rInfo.bShearAllowed             =   false;
+    rInfo.bEdgeRadiusAllowed        =   false;
+    rInfo.bNoOrthoDesired           =   false;
+    rInfo.bCanConvToPath            =   false;
+    rInfo.bCanConvToPoly            =   false;
+    rInfo.bCanConvToPathLineToArea  =   false;
+    rInfo.bCanConvToPolyLineToArea  =   false;
+    rInfo.bCanConvToContour = false;
+}
+
+sal_uInt16 SdrUnoObj::GetObjIdentifier() const
+{
+    return sal_uInt16(OBJ_UNO);
+}
+
+void SdrUnoObj::SetContextWritingMode( const sal_Int16 _nContextWritingMode )
+{
+    try
+    {
+        uno::Reference< beans::XPropertySet > xModelProperties( GetUnoControlModel(), uno::UNO_QUERY_THROW );
+        xModelProperties->setPropertyValue( "ContextWritingMode", uno::makeAny( _nContextWritingMode ) );
+    }
+    catch( const uno::Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("svx");
+    }
+}
+
+OUString SdrUnoObj::TakeObjNameSingul() const
+{
+    OUStringBuffer sName(SvxResId(STR_ObjNameSingulUno));
+
+    OUString aName(GetName());
+    if (!aName.isEmpty())
+    {
+        sName.append(' ');
+        sName.append('\'');
+        sName.append(aName);
+        sName.append('\'');
+    }
+
+    return sName.makeStringAndClear();
+}
+
+OUString SdrUnoObj::TakeObjNamePlural() const
+{
+    return SvxResId(STR_ObjNamePluralUno);
+}
+
+SdrUnoObj* SdrUnoObj::CloneSdrObject(SdrModel& rTargetModel) const
+{
+    return CloneHelper< SdrUnoObj >(rTargetModel);
+}
+
+SdrUnoObj& SdrUnoObj::operator= (const SdrUnoObj& rObj)
+{
+    if( this == &rObj )
+        return *this;
+    SdrRectObj::operator= (rObj);
+
+    // release the reference to the current control model
+    SetUnoControlModel( nullptr );
+
+    aUnoControlModelTypeName = rObj.aUnoControlModelTypeName;
+    aUnoControlTypeName = rObj.aUnoControlTypeName;
+
+    // copy the uno control model
+    const uno::Reference< awt::XControlModel > xSourceControlModel = rObj.GetUnoControlModel();
+    if ( xSourceControlModel.is() )
+    {
+        try
+        {
+            uno::Reference< util::XCloneable > xClone( xSourceControlModel, uno::UNO_QUERY_THROW );
+            xUnoControlModel.set( xClone->createClone(), uno::UNO_QUERY_THROW );
+        }
+        catch( const uno::Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+    }
+
+    // get service name of the control from the control model
+    uno::Reference< beans::XPropertySet > xSet(xUnoControlModel, uno::UNO_QUERY);
+    if (xSet.is())
+    {
+        uno::Any aValue( xSet->getPropertyValue("DefaultControl") );
+        OUString aStr;
+
+        if( aValue >>= aStr )
+            aUnoControlTypeName = aStr;
+    }
+
+    uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY);
+    if (xComp.is())
+        m_pImpl->pEventListener->StartListening(xComp);
+    return *this;
+}
+
+void SdrUnoObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
+{
+    SdrRectObj::NbcResize(rRef,xFact,yFact);
+
+    if (aGeo.nShearAngle!=0 || aGeo.nRotationAngle!=0)
+    {
+        // small correctors
+        if (aGeo.nRotationAngle>=9000 && aGeo.nRotationAngle<27000)
+        {
+            maRect.Move(maRect.Left()-maRect.Right(),maRect.Top()-maRect.Bottom());
+        }
+
+        aGeo.nRotationAngle  = 0;
+        aGeo.nShearAngle = 0;
+        aGeo.nSin       = 0.0;
+        aGeo.nCos       = 1.0;
+        aGeo.nTan       = 0.0;
+        SetRectsDirty();
+    }
+}
+
+
+bool SdrUnoObj::hasSpecialDrag() const
+{
+    // no special drag; we have no rounding rect and
+    // do want frame handles
+    return false;
+}
+
+void SdrUnoObj::NbcSetLayer( SdrLayerID _nLayer )
+{
+    if ( GetLayer() == _nLayer )
+    {   // redundant call -> not interested in doing anything here
+        SdrRectObj::NbcSetLayer( _nLayer );
+        return;
+    }
+
+    // we need some special handling here in case we're moved from an invisible layer
+    // to a visible one, or vice versa
+    // (relative to a layer. Remember that the visibility of a layer is a view attribute
+    // - the same layer can be visible in one view, and invisible in another view, at the
+    // same time)
+
+    // collect all views in which our old layer is visible
+    o3tl::sorted_vector< SdrView* > aPreviouslyVisible;
+
+    {
+        SdrViewIter aIter( this );
+        for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
+            aPreviouslyVisible.insert( pView );
+    }
+
+    SdrRectObj::NbcSetLayer( _nLayer );
+
+    // collect all views in which our new layer is visible
+    o3tl::sorted_vector< SdrView* > aNewlyVisible;
+
+    {
+        SdrViewIter aIter( this );
+        for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
+        {
+            if ( aPreviouslyVisible.erase(pView) == 0 )
+            {
+                // in pView, we were visible _before_ the layer change, and are
+                // _not_ visible after the layer change
+                // => remember this view, as our visibility there changed
+                aNewlyVisible.insert( pView );
+            }
+        }
+    }
+
+    // now aPreviouslyVisible contains all views where we became invisible
+    for (const auto& rpView : aPreviouslyVisible)
+    {
+        lcl_ensureControlVisibility( rpView, this, false );
+    }
+
+    // and aNewlyVisible all views where we became visible
+    for (const auto& rpView : aNewlyVisible)
+    {
+        lcl_ensureControlVisibility( rpView, this, true );
+    }
+}
+
+void SdrUnoObj::CreateUnoControlModel(const OUString& rModelName)
+{
+    DBG_ASSERT(!xUnoControlModel.is(), "model already exists");
+
+    aUnoControlModelTypeName = rModelName;
+
+    uno::Reference< awt::XControlModel >   xModel;
+    uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+    if (!aUnoControlModelTypeName.isEmpty() )
+    {
+        xModel.set(xContext->getServiceManager()->createInstanceWithContext(
+            aUnoControlModelTypeName, xContext), uno::UNO_QUERY);
+
+        if (xModel.is())
+            SetChanged();
+    }
+
+    SetUnoControlModel(xModel);
+}
+
+void SdrUnoObj::CreateUnoControlModel(const OUString& rModelName,
+                                      const uno::Reference< lang::XMultiServiceFactory >& rxSFac)
+{
+    DBG_ASSERT(!xUnoControlModel.is(), "model already exists");
+
+    aUnoControlModelTypeName = rModelName;
+
+    uno::Reference< awt::XControlModel >   xModel;
+    if (!aUnoControlModelTypeName.isEmpty() && rxSFac.is() )
+    {
+        xModel.set(rxSFac->createInstance(aUnoControlModelTypeName), uno::UNO_QUERY);
+
+        if (xModel.is())
+            SetChanged();
+    }
+
+    SetUnoControlModel(xModel);
+}
+
+void SdrUnoObj::SetUnoControlModel( const uno::Reference< awt::XControlModel >& xModel)
+{
+    if (xUnoControlModel.is())
+    {
+        uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY);
+        if (xComp.is())
+            m_pImpl->pEventListener->StopListening(xComp);
+    }
+
+    xUnoControlModel = xModel;
+
+    // control model has to contain service name of the control
+    if (xUnoControlModel.is())
+    {
+        uno::Reference< beans::XPropertySet > xSet(xUnoControlModel, uno::UNO_QUERY);
+        if (xSet.is())
+        {
+            uno::Any aValue( xSet->getPropertyValue("DefaultControl") );
+            OUString aStr;
+            if( aValue >>= aStr )
+                aUnoControlTypeName = aStr;
+        }
+
+        uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY);
+        if (xComp.is())
+            m_pImpl->pEventListener->StartListening(xComp);
+    }
+
+    // invalidate all ViewObject contacts
+    ViewContactOfUnoControl* pVC = nullptr;
+    if ( impl_getViewContact( pVC ) )
+    {
+        // flushViewObjectContacts() removes all existing VOCs for the local DrawHierarchy. This
+        // is always allowed since they will be re-created on demand (and with the changed model)
+        GetViewContact().flushViewObjectContacts();
+    }
+}
+
+
+uno::Reference< awt::XControl > SdrUnoObj::GetUnoControl(const SdrView& _rView, const OutputDevice& _rOut) const
+{
+    uno::Reference< awt::XControl > xControl;
+
+    SdrPageView* pPageView = _rView.GetSdrPageView();
+    OSL_ENSURE( pPageView && getSdrPageFromSdrObject() == pPageView->GetPage(), "SdrUnoObj::GetUnoControl: This object is not displayed in that particular view!" );
+    if ( !pPageView || getSdrPageFromSdrObject() != pPageView->GetPage() )
+        return nullptr;
+
+    SdrPageWindow* pPageWindow = pPageView->FindPageWindow( _rOut );
+    OSL_ENSURE( pPageWindow, "SdrUnoObj::GetUnoControl: did not find my SdrPageWindow!" );
+    if ( !pPageWindow )
+        return nullptr;
+
+    ViewObjectContact& rViewObjectContact( GetViewContact().GetViewObjectContact( pPageWindow->GetObjectContact() ) );
+    ViewObjectContactOfUnoControl* pUnoContact = dynamic_cast< ViewObjectContactOfUnoControl* >( &rViewObjectContact );
+    OSL_ENSURE( pUnoContact, "SdrUnoObj::GetUnoControl: wrong contact type!" );
+    if ( pUnoContact )
+        xControl = pUnoContact->getControl();
+
+    return xControl;
+}
+
+
+uno::Reference< awt::XControl > SdrUnoObj::GetTemporaryControlForWindow(
+    const vcl::Window& _rWindow, uno::Reference< awt::XControlContainer >& _inout_ControlContainer ) const
+{
+    uno::Reference< awt::XControl > xControl;
+
+    ViewContactOfUnoControl* pVC = nullptr;
+    if ( impl_getViewContact( pVC ) )
+        xControl = pVC->getTemporaryControlForWindow( _rWindow, _inout_ControlContainer );
+
+    return xControl;
+}
+
+
+bool SdrUnoObj::impl_getViewContact( ViewContactOfUnoControl*& _out_rpContact ) const
+{
+    ViewContact& rViewContact( GetViewContact() );
+    _out_rpContact = dynamic_cast< ViewContactOfUnoControl* >( &rViewContact );
+    DBG_ASSERT( _out_rpContact, "SdrUnoObj::impl_getViewContact: could not find my ViewContact!" );
+    return ( _out_rpContact != nullptr );
+}
+
+
+std::unique_ptr<sdr::contact::ViewContact> SdrUnoObj::CreateObjectSpecificViewContact()
+{
+  return std::make_unique<sdr::contact::ViewContactOfUnoControl>( *this );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */