/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sfx2.hxx"
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/embed/XVisualObject.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/XComponentSupplier.hpp>
#include <com/sun/star/embed/XWindowSupplier.hpp>
#include <com/sun/star/embed/XEmbedPersist.hpp>
#include <com/sun/star/embed/EmbedVerbs.hpp>
#include <com/sun/star/container/XChild.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/XInitialization.hpp>
#include <com/sun/star/task/XStatusIndicatorFactory.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 <sfx2/dispatch.hxx>
#include "workwin.hxx"
#include "guisaveas.hxx"
#include <sfx2/viewfrm.hxx>
#include <cppuhelper/implbase5.hxx>
#include <vcl/salbtype.hxx>
#include <svtools/ehdl.hxx>
#include <vcl/timer.hxx>
#include <vcl/window.hxx>
#include <toolkit/awt/vclxwindow.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <toolkit/helper/convert.hxx>
#include <tools/fract.hxx>
#include <tools/gen.hxx>
#include <svl/rectitem.hxx>
#include <svtools/soerr.hxx>
#include <comphelper/processfactory.hxx>
#define SFX_CLIENTACTIVATE_TIMEOUT 100
using namespace com::sun::star;
//====================================================================
// SfxEmbedResizeGuard
class SfxBooleanFlagGuard
{
sal_Bool& m_rFlag;
sal_Bool m_bLifeValue;
public:
SfxBooleanFlagGuard( sal_Bool& bFlag, sal_Bool bLifeValue )
: m_rFlag( bFlag )
, m_bLifeValue( bLifeValue )
{
m_rFlag = m_bLifeValue;
}
~SfxBooleanFlagGuard()
{
m_rFlag = !m_bLifeValue;
}
};
//====================================================================
// SfxInPlaceClient_Impl
//--------------------------------------------------------------------
class SfxInPlaceClient_Impl : public ::cppu::WeakImplHelper5< embed::XEmbeddedClient,
embed::XInplaceClient,
document::XEventListener,
embed::XStateChangeListener,
embed::XWindowSupplier >
{
public:
Timer m_aTimer; // activation timeout, starts after object connection
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
Rectangle m_aLastObjAreaPixel; // area of object in coordinate system of the container (without scaling)
sal_Bool m_bStoreObject;
sal_Bool m_bUIActive; // set and cleared when notification for UI (de)activation is sent
sal_Bool m_bResizeNoScale;
uno::Reference < embed::XEmbeddedObject > m_xObject;
uno::Reference < embed::XEmbeddedClient > m_xClient;
SfxInPlaceClient_Impl()
: m_pClient( NULL )
, m_nAspect( 0 )
, m_bStoreObject( sal_True )
, m_bUIActive( sal_False )
, m_bResizeNoScale( sal_False )
{}
~SfxInPlaceClient_Impl();
void SizeHasChanged();
DECL_LINK (TimerHdl, Timer*);
uno::Reference < frame::XFrame > GetFrame() const;
// XEmbeddedClient
virtual void SAL_CALL saveObject() throw ( embed::ObjectSaveVetoException, uno::Exception, uno::RuntimeException );
virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) throw ( embed::WrongStateException, uno::RuntimeException );
// XInplaceClient
virtual sal_Bool SAL_CALL canInplaceActivate() throw ( uno::RuntimeException );
virtual void SAL_CALL activatingInplace() throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL activatingUI() throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL deactivatedInplace() throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL deactivatedUI() throw ( embed::WrongStateException, uno::RuntimeException );
virtual uno::Reference< ::com::sun::star::frame::XLayoutManager > SAL_CALL getLayoutManager() throw ( embed::WrongStateException, uno::RuntimeException );
virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() throw ( embed::WrongStateException, uno::RuntimeException );
virtual awt::Rectangle SAL_CALL getPlacement() throw ( embed::WrongStateException, uno::RuntimeException );
virtual awt::Rectangle SAL_CALL getClipRectangle() throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) throw ( embed::WrongStateException, uno::RuntimeException );
virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) throw ( embed::WrongStateException, uno::Exception, uno::RuntimeException );
// XComponentSupplier
virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() throw ( uno::RuntimeException );
// XWindowSupplier
virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() throw ( uno::RuntimeException );
// document::XEventListener
virtual void SAL_CALL notifyEvent( const document::EventObject& aEvent ) throw( uno::RuntimeException );
// XStateChangeListener
virtual void SAL_CALL changingState( const ::com::sun::star::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (::com::sun::star::embed::WrongStateException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL stateChanged( const ::com::sun::star::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException);
};
SfxInPlaceClient_Impl::~SfxInPlaceClient_Impl()
{
}
void SAL_CALL SfxInPlaceClient_Impl::changingState(
const ::com::sun::star::lang::EventObject& /*aEvent*/,
::sal_Int32 /*nOldState*/,
::sal_Int32 /*nNewState*/ )
throw (::com::sun::star::embed::WrongStateException, ::com::sun::star::uno::RuntimeException)
{
}
void SAL_CALL SfxInPlaceClient_Impl::stateChanged(
const ::com::sun::star::lang::EventObject& /*aEvent*/,
::sal_Int32 nOldState,
::sal_Int32 nNewState )
throw (::com::sun::star::uno::RuntimeException)
{
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 );
}
else if ( m_pClient && nNewState == embed::EmbedStates::UI_ACTIVE )
{
/*
uno::Reference < lang::XUnoTunnel > xObj( m_xObject->getComponent(), uno::UNO_QUERY );
uno::Sequence < sal_Int8 > aSeq( SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence() );
sal_Int64 nHandle = xObj.is() ? xObj->getSomething( aSeq ) : 0;
if ( nHandle )
{
// currently needs SFX code
SfxObjectShell* pDoc = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDoc );
SfxWorkWindow *pWorkWin = pFrame->GetFrame().GetWorkWindow_Impl();
pWorkWin->UpdateObjectBars_Impl();
}
*/
}
}
void SAL_CALL SfxInPlaceClient_Impl::notifyEvent( const document::EventObject& aEvent ) throw( uno::RuntimeException )
{
::vos::OGuard aGuard( Application::GetSolarMutex() );
if ( m_pClient && aEvent.EventName.equalsAscii("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 ::com::sun::star::lang::EventObject& /*aEvent*/ )
throw (::com::sun::star::uno::RuntimeException)
{
DELETEZ( m_pClient );
}
// XEmbeddedClient
//--------------------------------------------------------------------
uno::Reference < frame::XFrame > SfxInPlaceClient_Impl::GetFrame() const
{
if ( !m_pClient )
throw uno::RuntimeException();
return m_pClient->GetViewShell()->GetViewFrame()->GetFrame().GetFrameInterface();
}
void SAL_CALL SfxInPlaceClient_Impl::saveObject()
throw ( embed::ObjectSaveVetoException,
uno::Exception,
uno::RuntimeException )
{
if ( !m_bStoreObject )
// 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 );
if ( !xPersist.is() )
throw uno::RuntimeException();
uno::Reference< frame::XFrame > xFrame;
uno::Reference< task::XStatusIndicator > xStatusIndicator;
uno::Reference< frame::XModel > xModel( m_xObject->getComponent(), uno::UNO_QUERY );
uno::Reference< lang::XMultiServiceFactory > xSrvMgr( ::comphelper::getProcessServiceFactory() );
if ( xModel.is() )
{
uno::Reference< frame::XController > xController = xModel->getCurrentController();
if ( xController.is() )
xFrame = xController->getFrame();
}
if ( xSrvMgr.is() && xFrame.is() )
{
// set non-reschedule progress to prevent problems when asynchronous calls are made
// during storing of the embedded object
uno::Reference< lang::XInitialization > xInit(
xSrvMgr->createInstance(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.framework.StatusIndicatorFactory" ))),
uno::UNO_QUERY_THROW );
beans::PropertyValue aProperty;
uno::Sequence< uno::Any > aArgs( 2 );
aProperty.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DisableReschedule" ));
aProperty.Value = uno::makeAny( sal_True );
aArgs[0] = uno::makeAny( aProperty );
aProperty.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" ));
aProperty.Value = uno::makeAny( xFrame );
aArgs[1] = uno::makeAny( aProperty );
xInit->initialize( aArgs );
uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
if ( xPropSet.is() )
{
try
{
uno::Reference< task::XStatusIndicatorFactory > xStatusIndicatorFactory( xInit, uno::UNO_QUERY_THROW );
xStatusIndicator = xStatusIndicatorFactory->createStatusIndicator();
xPropSet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IndicatorInterception" )), uno::makeAny( xStatusIndicator ));
}
catch ( uno::RuntimeException& e )
{
throw e;
}
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( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IndicatorInterception" )), uno::makeAny( xStatusIndicator ));
}
}
catch ( uno::RuntimeException& e )
{
throw e;
}
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( sal_True );
//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 )
throw ( embed::WrongStateException,
uno::RuntimeException )
{
::vos::OGuard aGuard( Application::GetSolarMutex() );
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
m_pClient->GetViewShell()->OutplaceActivated( bVisible, m_pClient );
m_pClient->Invalidate();
}
// XInplaceClient
//--------------------------------------------------------------------
sal_Bool SAL_CALL SfxInPlaceClient_Impl::canInplaceActivate()
throw ( uno::RuntimeException )
{
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 sal_False;
return sal_True;
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::activatingInplace()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
m_pClient->GetViewShell()->InplaceActivating( m_pClient );
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::activatingUI()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
m_pClient->GetViewShell()->ResetAllClients_Impl(m_pClient);
m_bUIActive = sal_True;
m_pClient->GetViewShell()->UIActivating( m_pClient );
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::deactivatedInplace()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
m_pClient->GetViewShell()->InplaceDeactivated( m_pClient );
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::deactivatedUI()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
m_pClient->GetViewShell()->UIDeactivated( m_pClient );
m_bUIActive = sal_False;
}
//--------------------------------------------------------------------
uno::Reference< ::com::sun::star::frame::XLayoutManager > SAL_CALL SfxInPlaceClient_Impl::getLayoutManager()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
uno::Reference < beans::XPropertySet > xFrame( GetFrame(), uno::UNO_QUERY );
if ( !xFrame.is() )
throw uno::RuntimeException();
uno::Reference< ::com::sun::star::frame::XLayoutManager > xMan;
try
{
uno::Any aAny = xFrame->getPropertyValue( ::rtl::OUString::createFromAscii("LayoutManager") );
aAny >>= xMan;
}
catch ( uno::Exception& )
{
throw uno::RuntimeException();
}
return xMan;
}
//--------------------------------------------------------------------
uno::Reference< frame::XDispatchProvider > SAL_CALL SfxInPlaceClient_Impl::getInplaceDispatchProvider()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
return uno::Reference < frame::XDispatchProvider >( GetFrame(), uno::UNO_QUERY_THROW );
}
//--------------------------------------------------------------------
awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getPlacement()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
// apply scaling to object area and convert to pixels
Rectangle aRealObjArea( m_aObjArea );
aRealObjArea.SetSize( Size( Fraction( aRealObjArea.GetWidth() ) * m_aScaleWidth,
Fraction( aRealObjArea.GetHeight() ) * m_aScaleHeight ) );
aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
return AWTRectangle( aRealObjArea );
}
//--------------------------------------------------------------------
awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getClipRectangle()
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
// currently(?) same as placement
Rectangle aRealObjArea( m_aObjArea );
aRealObjArea.SetSize( Size( Fraction( aRealObjArea.GetWidth() ) * m_aScaleWidth,
Fraction( aRealObjArea.GetHeight() ) * m_aScaleHeight ) );
aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
return AWTRectangle( aRealObjArea );
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ )
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
// TODO/MBA: keyboard accelerators
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::scrollObject( const awt::Size& /*aOffset*/ )
throw ( embed::WrongStateException,
uno::RuntimeException )
{
if ( !m_pClient || !m_pClient->GetViewShell() )
throw uno::RuntimeException();
}
//--------------------------------------------------------------------
void SAL_CALL SfxInPlaceClient_Impl::changedPlacement( const awt::Rectangle& aPosRect )
throw ( embed::WrongStateException,
uno::Exception,
uno::RuntimeException )
{
uno::Reference< embed::XInplaceObject > xInplace( m_xObject, uno::UNO_QUERY );
if ( !xInplace.is() || !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();
Rectangle aNewPixelRect = VCLRectangle( aPosRect );
Rectangle aOldPixelRect = VCLRectangle( aOldRect );
if ( aOldPixelRect == aNewPixelRect )
// nothing has changed
return;
// new scaled object area
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, sal_True );
// new size of the object area without scaling
Size aNewObjSize( Fraction( aNewLogicRect.GetWidth() ) / m_aScaleWidth,
Fraction( aNewLogicRect.GetHeight() ) / m_aScaleHeight );
// now remove scaling from new placement and keep this a 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()
throw ( uno::RuntimeException )
{
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 );
if ( !xComp.is() )
throw uno::RuntimeException();
return xComp;
}
// XWindowSupplier
//--------------------------------------------------------------------
uno::Reference< awt::XWindow > SAL_CALL SfxInPlaceClient_Impl::getWindow()
throw ( uno::RuntimeException )
{
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 );
if ( !xInplace.is() )
throw uno::RuntimeException();
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( SfxInPlaceClient_Impl, TimerHdl, Timer*, EMPTYARG )
{
if ( m_pClient && m_xObject.is() )
m_pClient->GetViewShell()->CheckIPClient_Impl( m_pClient, m_pClient->GetViewShell()->GetObjectShell()->GetVisArea() );
return 0;
}
//====================================================================
// SfxInPlaceClient
//--------------------------------------------------------------------
SfxInPlaceClient::SfxInPlaceClient( SfxViewShell* pViewShell, Window *pDraw, sal_Int64 nAspect ) :
m_pImp( new SfxInPlaceClient_Impl ),
m_pViewSh( pViewShell ),
m_pEditWin( pDraw )
{
m_pImp->acquire();
m_pImp->m_pClient = this;
m_pImp->m_nAspect = nAspect;
m_pImp->m_aScaleWidth = m_pImp->m_aScaleHeight = Fraction(1,1);
m_pImp->m_xClient = static_cast< embed::XEmbeddedClient* >( m_pImp );
pViewShell->NewIPClient_Impl(this);
m_pImp->m_aTimer.SetTimeout( SFX_CLIENTACTIVATE_TIMEOUT );
m_pImp->m_aTimer.SetTimeoutHdl( LINK( m_pImp, SfxInPlaceClient_Impl, TimerHdl ) );
}
//--------------------------------------------------------------------
SfxInPlaceClient::~SfxInPlaceClient()
{
m_pViewSh->IPClientGone_Impl(this);
// deleting the client before storing the object means discarding all changes
m_pImp->m_bStoreObject = sal_False;
SetObject(0);
m_pImp->m_pClient = NULL;
// the next call will destroy m_pImp if no other reference to it exists
m_pImp->m_xClient = uno::Reference < embed::XEmbeddedClient >();
m_pImp->release();
// 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() )
{
if ( m_pImp->m_nAspect == embed::Aspects::MSOLE_ICON
&& ( nState == embed::EmbedStates::UI_ACTIVE || nState == embed::EmbedStates::INPLACE_ACTIVE ) )
{
OSL_ENSURE( sal_False, "Iconified object should not be activated inplace!\n" );
return;
}
try
{
GetObject()->changeState( nState );
}
catch ( uno::Exception& )
{}
}
}
//--------------------------------------------------------------------
sal_Int64 SfxInPlaceClient::GetObjectMiscStatus() const
{
if ( GetObject().is() )
return GetObject()->getStatus( m_pImp->m_nAspect );
return 0;
}
//--------------------------------------------------------------------
uno::Reference < embed::XEmbeddedObject > SfxInPlaceClient::GetObject() const
{
return m_pImp->m_xObject;
}
//--------------------------------------------------------------------
void SfxInPlaceClient::SetObject( const uno::Reference < embed::XEmbeddedObject >& rObject )
{
if ( m_pImp->m_xObject.is() && rObject != m_pImp->m_xObject )
{
DBG_ASSERT( GetObject()->getClientSite() == m_pImp->m_xClient, "Wrong ClientSite!" );
if ( GetObject()->getClientSite() == m_pImp->m_xClient )
{
if ( GetObject()->getCurrentState() != embed::EmbedStates::LOADED )
SetObjectState( embed::EmbedStates::RUNNING );
m_pImp->m_xObject->removeEventListener( uno::Reference < document::XEventListener >( m_pImp->m_xClient, uno::UNO_QUERY ) );
m_pImp->m_xObject->removeStateChangeListener( uno::Reference < embed::XStateChangeListener >( m_pImp->m_xClient, uno::UNO_QUERY ) );
try
{
m_pImp->m_xObject->setClientSite( 0 );
}
catch( uno::Exception& )
{
OSL_ENSURE( sal_False, "Can not clean the client site!\n" );
}
}
}
if ( !m_pViewSh || m_pViewSh->GetViewFrame()->GetFrame().IsClosing_Impl() )
// sometimes applications reconnect clients on shutting down because it happens in their Paint methods
return;
m_pImp->m_xObject = rObject;
if ( rObject.is() )
{
// as soon as an object was connected to a client it has to be checked wether the object wants
// to be activated
rObject->addStateChangeListener( uno::Reference < embed::XStateChangeListener >( m_pImp->m_xClient, uno::UNO_QUERY ) );
rObject->addEventListener( uno::Reference < document::XEventListener >( m_pImp->m_xClient, uno::UNO_QUERY ) );
try
{
rObject->setClientSite( m_pImp->m_xClient );
}
catch( uno::Exception& )
{
OSL_ENSURE( sal_False, "Can not set the client site!\n" );
}
m_pImp->m_aTimer.Start();
}
else
m_pImp->m_aTimer.Stop();
}
//--------------------------------------------------------------------
sal_Bool SfxInPlaceClient::SetObjArea( const Rectangle& rArea )
{
if( rArea != m_pImp->m_aObjArea )
{
m_pImp->m_aObjArea = rArea;
m_pImp->SizeHasChanged();
Invalidate();
return sal_True;
}
return sal_False;
}
//--------------------------------------------------------------------
Rectangle SfxInPlaceClient::GetObjArea() const
{
return m_pImp->m_aObjArea;
}
Rectangle SfxInPlaceClient::GetScaledObjArea() const
{
Rectangle aRealObjArea( m_pImp->m_aObjArea );
aRealObjArea.SetSize( Size( Fraction( aRealObjArea.GetWidth() ) * m_pImp->m_aScaleWidth,
Fraction( aRealObjArea.GetHeight() ) * m_pImp->m_aScaleHeight ) );
return aRealObjArea;
}
//--------------------------------------------------------------------
void SfxInPlaceClient::SetSizeScale( const Fraction & rScaleWidth, const Fraction & rScaleHeight )
{
if ( m_pImp->m_aScaleWidth != rScaleWidth || m_pImp->m_aScaleHeight != rScaleHeight )
{
m_pImp->m_aScaleWidth = rScaleWidth;
m_pImp->m_aScaleHeight = rScaleHeight;
m_pImp->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();
}
}
//--------------------------------------------------------------------
sal_Bool SfxInPlaceClient::SetObjAreaAndScale( const Rectangle& rArea, const Fraction& rScaleWidth, const Fraction& rScaleHeight )
{
if( rArea != m_pImp->m_aObjArea || m_pImp->m_aScaleWidth != rScaleWidth || m_pImp->m_aScaleHeight != rScaleHeight )
{
m_pImp->m_aObjArea = rArea;
m_pImp->m_aScaleWidth = rScaleWidth;
m_pImp->m_aScaleHeight = rScaleHeight;
m_pImp->SizeHasChanged();
Invalidate();
return sal_True;
}
return sal_False;
}
//--------------------------------------------------------------------
const Fraction& SfxInPlaceClient::GetScaleWidth() const
{
return m_pImp->m_aScaleWidth;
}
//--------------------------------------------------------------------
const Fraction& SfxInPlaceClient::GetScaleHeight() const
{
return m_pImp->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
Rectangle aRealObjArea( m_pImp->m_aObjArea );
aRealObjArea.SetSize( Size( Fraction( aRealObjArea.GetWidth() ) * m_pImp->m_aScaleWidth,
Fraction( aRealObjArea.GetHeight() ) * m_pImp->m_aScaleHeight ) );
m_pEditWin->Invalidate( aRealObjArea );
ViewChanged();
}
//--------------------------------------------------------------------
sal_Bool SfxInPlaceClient::IsObjectUIActive() const
{
try {
return ( m_pImp->m_xObject.is() && ( m_pImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE ) );
}
catch( uno::Exception& )
{}
return sal_False;
}
//--------------------------------------------------------------------
sal_Bool SfxInPlaceClient::IsObjectInPlaceActive() const
{
try {
return(
(
m_pImp->m_xObject.is() &&
(m_pImp->m_xObject->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE)
) ||
(
m_pImp->m_xObject.is() &&
(m_pImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE)
)
);
}
catch( uno::Exception& )
{}
return sal_False;
}
//--------------------------------------------------------------------
sal_Bool SfxInPlaceClient::IsObjectActive() const
{
try {
return ( m_pImp->m_xObject.is() && ( m_pImp->m_xObject->getCurrentState() == embed::EmbedStates::ACTIVE ) );
}
catch( uno::Exception& )
{}
return sal_False;
}
//--------------------------------------------------------------------
Window* SfxInPlaceClient::GetActiveWindow( SfxObjectShell* pDoc, const com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject >& xObject )
{
SfxInPlaceClient* pClient = GetClient( pDoc, xObject );
if ( pClient )
return pClient->GetEditWin();
return NULL;
}
//--------------------------------------------------------------------
SfxInPlaceClient* SfxInPlaceClient::GetClient( SfxObjectShell* pDoc, const com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject >& xObject )
{
for ( SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDoc); pFrame; pFrame=SfxViewFrame::GetNext(*pFrame,pDoc) )
{
if( pFrame->GetViewShell() )
{
SfxInPlaceClient* pClient = pFrame->GetViewShell()->FindIPClient( xObject, NULL );
if ( pClient )
return pClient;
}
}
return NULL;
}
sal_Int64 SfxInPlaceClient::GetAspect() const
{
return m_pImp->m_nAspect;
}
ErrCode SfxInPlaceClient::DoVerb( long nVerb )
{
SfxErrorContext aEc( ERRCTX_SO_DOVERB, m_pViewSh->GetWindow(), RID_SO_ERRCTX );
ErrCode nError = ERRCODE_NONE;
if ( m_pImp->m_xObject.is() )
{
sal_Bool bSaveCopyAs = sal_False;
if ( nVerb == -8 ) // "Save Copy as..."
{
svt::EmbeddedObjectRef::TryRunningState( m_pImp->m_xObject );
// TODO/LATER: this special verb should disappear when outplace activation is completely available
uno::Reference< frame::XModel > xEmbModel( m_pImp->m_xObject->getComponent(), uno::UNO_QUERY );
if ( xEmbModel.is() )
{
bSaveCopyAs = sal_True;
try
{
uno::Reference< lang::XMultiServiceFactory > xEmptyFactory;
SfxStoringHelper aHelper( xEmptyFactory );
uno::Sequence< beans::PropertyValue > aDispatchArgs( 1 );
aDispatchArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SaveTo" ) );
aDispatchArgs[0].Value <<= (sal_Bool)sal_True;
aHelper.GUIStoreModel( xEmbModel,
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SaveAs" ) ),
aDispatchArgs,
sal_False,
::rtl::OUString() );
}
catch( task::ErrorCodeIOException& aErrorEx )
{
nError = (sal_uInt32)aErrorEx.ErrCode;
}
catch( uno::Exception& )
{
nError = ERRCODE_IO_GENERAL;
// TODO/LATER: better error handling
}
}
}
if ( !bSaveCopyAs )
{
if ( m_pImp->m_nAspect == embed::Aspects::MSOLE_ICON )
{
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 )
{
if ( m_pViewSh )
m_pViewSh->GetViewFrame()->GetTopFrame().LockResize_Impl(sal_True);
try
{
m_pImp->m_xObject->setClientSite( m_pImp->m_xClient );
m_pImp->m_xObject->doVerb( nVerb );
}
catch ( embed::UnreachableStateException& )
{
if ( nVerb == 0 || nVerb == embed::EmbedVerbs::MS_OLEVERB_OPEN )
{
// a workaround for the default verb, usually makes sence for alien objects
try
{
m_pImp->m_xObject->doVerb( -9 ); // open own view, a workaround verb that is not visible
if ( m_pImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE )
{
// the object was converted to OOo object
awt::Size aSize = m_pImp->m_xObject->getVisualAreaSize( m_pImp->m_nAspect );
MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( m_pImp->m_xObject->getMapUnit( m_pImp->m_nAspect ) ) );
MapMode aClientMap( GetEditWin()->GetMapMode().GetMapUnit() );
Size aNewSize = GetEditWin()->LogicToLogic( Size( aSize.Width, aSize.Height ), &aObjectMap, &aClientMap );
Rectangle aScaledArea = GetScaledObjArea();
m_pImp->m_aObjArea.SetSize( aNewSize );
m_pImp->m_aScaleWidth = Fraction( aScaledArea.GetWidth(), aNewSize.Width() );
m_pImp->m_aScaleHeight = Fraction( aScaledArea.GetHeight(), aNewSize.Height() );
}
}
catch ( uno::Exception& )
{
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& )
{
nError = ERRCODE_SO_GENERALERROR;
//TODO/LATER: better error handling
}
if ( m_pViewSh )
{
SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
pFrame->GetTopFrame().LockResize_Impl(sal_False);
pFrame->GetTopFrame().Resize();
}
}
}
}
if( nError )
ErrorHandler::HandleError( nError );
return nError;
}
void SfxInPlaceClient::VisAreaChanged()
{
uno::Reference < embed::XInplaceObject > xObj( m_pImp->m_xObject, uno::UNO_QUERY );
uno::Reference < embed::XInplaceClient > xClient( m_pImp->m_xClient, uno::UNO_QUERY );
if ( xObj.is() && xClient.is() )
m_pImp->SizeHasChanged();
}
void SfxInPlaceClient::ObjectAreaChanged()
{
// dummy implementation
}
void SfxInPlaceClient::RequestNewObjectArea( Rectangle& )
{
// dummy implementation
}
void SfxInPlaceClient::ViewChanged()
{
// dummy implementation
}
void SfxInPlaceClient::MakeVisible()
{
// dummy implementation
}
void SfxInPlaceClient::FormatChanged()
{
// dummy implementation
}
void SfxInPlaceClient::DeactivateObject()
{
if ( GetObject().is() )
{
try
{
m_pImp->m_bUIActive = sal_False;
sal_Bool bHasFocus = sal_False;
uno::Reference< frame::XModel > xModel( m_pImp->m_xObject->getComponent(), uno::UNO_QUERY );
if ( xModel.is() )
{
uno::Reference< frame::XController > xController = xModel->getCurrentController();
if ( xController.is() )
{
Window* pWindow = VCLUnoHelper::GetWindow( xController->getFrame()->getContainerWindow() );
bHasFocus = pWindow->HasChildPathFocus( sal_True );
}
}
if ( m_pViewSh )
m_pViewSh->GetViewFrame()->GetTopFrame().LockResize_Impl(sal_True);
if ( m_pImp->m_xObject->getStatus( m_pImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
{
m_pImp->m_xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
if ( bHasFocus && m_pViewSh )
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_pImp->m_xObject, uno::UNO_QUERY );
if ( xLink.is() && xLink->isLink() )
m_pImp->m_xObject->changeState( embed::EmbedStates::LOADED );
else
m_pImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
}
if ( m_pViewSh )
{
SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
SfxViewFrame::SetViewFrame( pFrame );
pFrame->GetTopFrame().LockResize_Impl(sal_False);
pFrame->GetTopFrame().Resize();
}
}
catch (com::sun::star::uno::Exception& )
{}
}
}
void SfxInPlaceClient::ResetObject()
{
if ( GetObject().is() )
{
try
{
m_pImp->m_bUIActive = sal_False;
if ( m_pImp->m_xObject->getStatus( m_pImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
m_pImp->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_pImp->m_xObject, uno::UNO_QUERY );
if ( xLink.is() && xLink->isLink() )
m_pImp->m_xObject->changeState( embed::EmbedStates::LOADED );
else
m_pImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
}
}
catch (com::sun::star::uno::Exception& )
{}
}
}
sal_Bool SfxInPlaceClient::IsUIActive()
{
return m_pImp->m_bUIActive;
}