/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "workwin.hxx" #include "guisaveas.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 sense 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; }