sfx2/source/view/ipclient.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <com/sun/star/awt/XWindowPeer.hpp>
  23 #include <com/sun/star/embed/Aspects.hpp>
  24 #include <com/sun/star/embed/EmbedStates.hpp>
  25 #include <com/sun/star/embed/UnreachableStateException.hpp>
  26 #include <com/sun/star/embed/XEmbeddedClient.hpp>
  27 #include <com/sun/star/embed/XInplaceClient.hpp>
  28 #include <com/sun/star/embed/XInplaceObject.hpp>
  29 #include <com/sun/star/embed/XWindowSupplier.hpp>
  30 #include <com/sun/star/embed/EmbedVerbs.hpp>
  31 #include <com/sun/star/embed/XEmbeddedOleObject.hpp>
  32 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  33 #include <com/sun/star/beans/XPropertySet.hpp>
  34 #include <com/sun/star/beans/PropertyValue.hpp>
  35 #include <com/sun/star/embed/XStateChangeListener.hpp>
  36 #include <com/sun/star/embed/StateChangeInProgressException.hpp>
  37 #include <com/sun/star/embed/XLinkageSupport.hpp>
  38 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  39 #include <com/sun/star/task/ErrorCodeIOException.hpp>
  40 #include <com/sun/star/task/StatusIndicatorFactory.hpp>
  41 #include <com/sun/star/task/XStatusIndicator.hpp>
  42
  43 #include <com/sun/star/embed/EmbedMisc.hpp>
  44 #include <svtools/embedhlp.hxx>
  45 #include <vcl/svapp.hxx>
  46
  47 #include <sfx2/ipclient.hxx>
  48 #include <sfx2/viewsh.hxx>
  49 #include <sfx2/viewfrm.hxx>
  50 #include <sfx2/objsh.hxx>
  51 #include <guisaveas.hxx>
  52 #include <cppuhelper/implbase.hxx>
  53 #include <svtools/ehdl.hxx>
  54
  55 #include <vcl/timer.hxx>
  56 #include <vcl/window.hxx>
  57 #include <toolkit/helper/vclunohelper.hxx>
  58 #include <toolkit/helper/convert.hxx>
  59 #include <tools/debug.hxx>
  60 #include <tools/diagnose_ex.h>
  61 #include <tools/fract.hxx>
  62 #include <tools/gen.hxx>
  63 #include <svtools/soerr.hxx>
  64 #include <comphelper/lok.hxx>
  65 #include <comphelper/processfactory.hxx>
  66 #include <cppuhelper/exc_hlp.hxx>
  67
  68 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  69
  70 #define SFX_CLIENTACTIVATE_TIMEOUT 100
  71
  72 using namespace com::sun::star;
  73
  74 namespace {
  75
  76 // SfxEmbedResizeGuard
  77 class SfxBooleanFlagGuard
  78 {
  79     bool& m_rFlag;
  80 public:
  81     explicit SfxBooleanFlagGuard(bool& bFlag)
  82         : m_rFlag( bFlag )
  83     {
  84         m_rFlag = true;
  85     }
  86
  87     ~SfxBooleanFlagGuard()
  88     {
  89         m_rFlag = false;
  90     }
  91 };
  92
  93 }
  94
  95 // SfxInPlaceClient_Impl
  96
  97
  98 class SfxInPlaceClient_Impl : public ::cppu::WeakImplHelper< embed::XEmbeddedClient,
  99                                                               embed::XInplaceClient,
 100                                                               document::XEventListener,
 101                                                               embed::XStateChangeListener,
 102                                                               embed::XWindowSupplier >
 103 {
 104 public:
 105     Timer                           m_aTimer;               // activation timeout, starts after object connection
 106     tools::Rectangle                       m_aObjArea;             // area of object in coordinate system of the container (without scaling)
 107     Fraction                        m_aScaleWidth;          // scaling that was applied to the object when it was not active
 108     Fraction                        m_aScaleHeight;
 109     SfxInPlaceClient*               m_pClient;
 110     sal_Int64                       m_nAspect;              // ViewAspect that is assigned from the container
 111     bool                            m_bStoreObject;
 112     bool                            m_bUIActive;            // set and cleared when notification for UI (de)activation is sent
 113     bool                            m_bResizeNoScale;
 114
 115     uno::Reference < embed::XEmbeddedObject > m_xObject;
 116
 117
 118     SfxInPlaceClient_Impl()
 119     : m_pClient( nullptr )
 120     , m_nAspect( 0 )
 121     , m_bStoreObject( true )
 122     , m_bUIActive( false )
 123     , m_bResizeNoScale( false )
 124     {}
 125
 126     void SizeHasChanged();
 127     DECL_LINK(TimerHdl, Timer *, void);
 128     uno::Reference < frame::XFrame > const & GetFrame() const;
 129
 130     // XEmbeddedClient
 131     virtual void SAL_CALL saveObject() override;
 132     virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) override;
 133
 134     // XInplaceClient
 135     virtual sal_Bool SAL_CALL canInplaceActivate() override;
 136     virtual void SAL_CALL activatingInplace() override;
 137     virtual void SAL_CALL activatingUI() override;
 138     virtual void SAL_CALL deactivatedInplace() override;
 139     virtual void SAL_CALL deactivatedUI() override;
 140     virtual uno::Reference< css::frame::XLayoutManager > SAL_CALL getLayoutManager() override;
 141     virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() override;
 142     virtual awt::Rectangle SAL_CALL getPlacement() override;
 143     virtual awt::Rectangle SAL_CALL getClipRectangle() override;
 144     virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) override;
 145     virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) override;
 146     virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) override;
 147
 148     // XComponentSupplier
 149     virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() override;
 150
 151     // XWindowSupplier
 152     virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() override;
 153
 154     // document::XEventListener
 155     virtual void SAL_CALL       notifyEvent( const document::EventObject& aEvent ) override;
 156
 157     // XStateChangeListener
 158     virtual void SAL_CALL changingState( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;
 159     virtual void SAL_CALL stateChanged( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;
 160     virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;
 161 };
 162
 163 void SAL_CALL SfxInPlaceClient_Impl::changingState(
 164     const css::lang::EventObject& /*aEvent*/,
 165     ::sal_Int32 /*nOldState*/,
 166     ::sal_Int32 /*nNewState*/ )
 167 {
 168 }
 169
 170 void SAL_CALL SfxInPlaceClient_Impl::stateChanged(
 171     const css::lang::EventObject& /*aEvent*/,
 172     ::sal_Int32 nOldState,
 173     ::sal_Int32 nNewState )
 174 {
 175     if ( m_pClient && nOldState != embed::EmbedStates::LOADED && nNewState == embed::EmbedStates::RUNNING )
 176     {
 177         // deactivation of object
 178         uno::Reference< frame::XModel > xDocument;
 179         if ( m_pClient->GetViewShell()->GetObjectShell() )
 180             xDocument = m_pClient->GetViewShell()->GetObjectShell()->GetModel();
 181         SfxObjectShell::SetCurrentComponent( xDocument );
 182     }
 183 }
 184
 185 void SAL_CALL SfxInPlaceClient_Impl::notifyEvent( const document::EventObject& aEvent )
 186 {
 187     SolarMutexGuard aGuard;
 188
 189     if ( m_pClient && aEvent.EventName == "OnVisAreaChanged" && m_nAspect != embed::Aspects::MSOLE_ICON )
 190     {
 191         if ( comphelper::LibreOfficeKit::isActive() )
 192         {
 193             if ( SfxViewShell* pViewShell = m_pClient->GetViewShell() )
 194                 pViewShell->libreOfficeKitViewCallback( LOK_CALLBACK_GRAPHIC_SELECTION, "INPLACE" );
 195         }
 196
 197         m_pClient->FormatChanged(); // for Writer when format of the object is changed with the area
 198         m_pClient->ViewChanged();
 199         m_pClient->Invalidate();
 200     }
 201 }
 202
 203 void SAL_CALL SfxInPlaceClient_Impl::disposing( const css::lang::EventObject& /*aEvent*/ )
 204 {
 205     delete m_pClient;
 206     m_pClient = nullptr;
 207 }
 208
 209 // XEmbeddedClient
 210
 211 uno::Reference < frame::XFrame > const & SfxInPlaceClient_Impl::GetFrame() const
 212 {
 213     if ( !m_pClient )
 214         throw uno::RuntimeException();
 215     return m_pClient->GetViewShell()->GetViewFrame()->GetFrame().GetFrameInterface();
 216 }
 217
 218 void SAL_CALL SfxInPlaceClient_Impl::saveObject()
 219 {
 220     if ( !m_bStoreObject )
 221         // client wants to discard the object (usually it means the container document is closed while an object is active
 222         // and the user didn't request saving the changes
 223         return;
 224
 225     // the common persistence is supported by objects and links
 226     uno::Reference< embed::XCommonEmbedPersist > xPersist( m_xObject, uno::UNO_QUERY_THROW );
 227
 228     uno::Reference< frame::XFrame >              xFrame;
 229     uno::Reference< task::XStatusIndicator >     xStatusIndicator;
 230     uno::Reference< frame::XModel >              xModel( m_xObject->getComponent(), uno::UNO_QUERY );
 231     uno::Reference< uno::XComponentContext >     xContext( ::comphelper::getProcessComponentContext() );
 232
 233     if ( xModel.is() )
 234     {
 235         uno::Reference< frame::XController > xController = xModel->getCurrentController();
 236         if ( xController.is() )
 237             xFrame = xController->getFrame();
 238     }
 239
 240     if ( xFrame.is() )
 241     {
 242         // set non-reschedule progress to prevent problems when asynchronous calls are made
 243         // during storing of the embedded object
 244         uno::Reference< task::XStatusIndicatorFactory > xStatusIndicatorFactory =
 245                task::StatusIndicatorFactory::createWithFrame( xContext, xFrame, true/*DisableReschedule*/, false/*AllowParentShow*/ );
 246
 247         uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
 248         if ( xPropSet.is() )
 249         {
 250             try
 251             {
 252                 xStatusIndicator = xStatusIndicatorFactory->createStatusIndicator();
 253                 xPropSet->setPropertyValue( "IndicatorInterception" , uno::makeAny( xStatusIndicator ));
 254             }
 255             catch ( const uno::RuntimeException& )
 256             {
 257                 throw;
 258             }
 259             catch ( uno::Exception& )
 260             {
 261             }
 262         }
 263     }
 264
 265     try
 266     {
 267         xPersist->storeOwn();
 268         m_xObject->update();
 269     }
 270     catch ( uno::Exception& )
 271     {
 272         //TODO/LATER: what should happen if object can't be saved?!
 273     }
 274
 275     // reset status indicator interception after storing
 276     try
 277     {
 278         uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
 279         if ( xPropSet.is() )
 280         {
 281             xStatusIndicator.clear();
 282             xPropSet->setPropertyValue( "IndicatorInterception" , uno::makeAny( xStatusIndicator ));
 283         }
 284     }
 285     catch ( const uno::RuntimeException& )
 286     {
 287         throw;
 288     }
 289     catch ( uno::Exception& )
 290     {
 291     }
 292
 293     // the client can exist only in case there is a view shell
 294     if ( !m_pClient || !m_pClient->GetViewShell() )
 295         throw uno::RuntimeException();
 296
 297     SfxObjectShell* pDocShell = m_pClient->GetViewShell()->GetObjectShell();
 298     if ( !pDocShell )
 299         throw uno::RuntimeException();
 300
 301     pDocShell->SetModified();
 302
 303     //TODO/LATER: invalidation might be necessary when object was modified, but is not
 304     //saved through this method
 305     // m_pClient->Invalidate();
 306 }
 307
 308
 309 void SAL_CALL SfxInPlaceClient_Impl::visibilityChanged( sal_Bool bVisible )
 310 {
 311     SolarMutexGuard aGuard;
 312
 313     if ( !m_pClient || !m_pClient->GetViewShell() )
 314         throw uno::RuntimeException();
 315
 316     m_pClient->GetViewShell()->OutplaceActivated( bVisible );
 317     m_pClient->Invalidate();
 318 }
 319
 320
 321 // XInplaceClient
 322
 323 sal_Bool SAL_CALL SfxInPlaceClient_Impl::canInplaceActivate()
 324 {
 325     if ( !m_xObject.is() )
 326         throw uno::RuntimeException();
 327
 328     // we don't want to switch directly from outplace to inplace mode
 329     if ( m_xObject->getCurrentState() == embed::EmbedStates::ACTIVE || m_nAspect == embed::Aspects::MSOLE_ICON )
 330         return false;
 331
 332     return true;
 333 }
 334
 335
 336 void SAL_CALL SfxInPlaceClient_Impl::activatingInplace()
 337 {
 338     if ( !m_pClient || !m_pClient->GetViewShell() )
 339         throw uno::RuntimeException();
 340
 341     if ( comphelper::LibreOfficeKit::isActive() )
 342     {
 343         if ( SfxViewShell* pViewShell = m_pClient->GetViewShell() )
 344             pViewShell->libreOfficeKitViewCallback( LOK_CALLBACK_GRAPHIC_SELECTION, "INPLACE" );
 345     }
 346
 347 }
 348
 349
 350 void SAL_CALL SfxInPlaceClient_Impl::activatingUI()
 351 {
 352     if ( !m_pClient || !m_pClient->GetViewShell() )
 353         throw uno::RuntimeException();
 354
 355     m_pClient->GetViewShell()->ResetAllClients_Impl(m_pClient);
 356     m_bUIActive = true;
 357     m_pClient->GetViewShell()->UIActivating( m_pClient );
 358 }
 359
 360
 361 void SAL_CALL SfxInPlaceClient_Impl::deactivatedInplace()
 362 {
 363     if ( !m_pClient || !m_pClient->GetViewShell() )
 364         throw uno::RuntimeException();
 365
 366     if ( comphelper::LibreOfficeKit::isActive() )
 367     {
 368         if ( SfxViewShell* pViewShell = m_pClient->GetViewShell() ) {
 369             pViewShell->libreOfficeKitViewCallback( LOK_CALLBACK_GRAPHIC_SELECTION, "INPLACE EXIT" );
 370         }
 371     }
 372 }
 373
 374
 375 void SAL_CALL SfxInPlaceClient_Impl::deactivatedUI()
 376 {
 377     if ( !m_pClient || !m_pClient->GetViewShell() )
 378         throw uno::RuntimeException();
 379
 380     m_pClient->GetViewShell()->UIDeactivated( m_pClient );
 381     m_bUIActive = false;
 382 }
 383
 384
 385 uno::Reference< css::frame::XLayoutManager > SAL_CALL SfxInPlaceClient_Impl::getLayoutManager()
 386 {
 387     uno::Reference < beans::XPropertySet > xFrame( GetFrame(), uno::UNO_QUERY_THROW );
 388
 389     uno::Reference< css::frame::XLayoutManager > xMan;
 390     try
 391     {
 392         uno::Any aAny = xFrame->getPropertyValue( "LayoutManager" );
 393         aAny >>= xMan;
 394     }
 395     catch ( uno::Exception& ex )
 396     {
 397         css::uno::Any anyEx = cppu::getCaughtException();
 398         throw css::lang::WrappedTargetRuntimeException( ex.Message,
 399                         nullptr, anyEx );
 400     }
 401
 402     return xMan;
 403 }
 404
 405
 406 uno::Reference< frame::XDispatchProvider > SAL_CALL SfxInPlaceClient_Impl::getInplaceDispatchProvider()
 407 {
 408     return uno::Reference < frame::XDispatchProvider >( GetFrame(), uno::UNO_QUERY_THROW );
 409 }
 410
 411
 412 awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getPlacement()
 413 {
 414     if ( !m_pClient || !m_pClient->GetViewShell() )
 415         throw uno::RuntimeException();
 416
 417     // apply scaling to object area and convert to pixels
 418     tools::Rectangle aRealObjArea( m_aObjArea );
 419     aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth() * m_aScaleWidth),
 420                                 tools::Long( aRealObjArea.GetHeight() * m_aScaleHeight) ) );
 421
 422     // In Writer and Impress the map mode is disabled. So when a chart is
 423     // activated (for in place editing) we get the chart win size in 100th mm
 424     // and any method that should return pixels returns 100th mm and the chart
 425     // window map mode has a ~26.485 scale factor.
 426     // All that does not fit with current implementation for handling chart
 427     // editing in LOK.
 428     if (comphelper::LibreOfficeKit::isActive())
 429     {
 430         vcl::Window* pEditWin = m_pClient->GetEditWin();
 431         bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
 432         if (!bMapModeEnabled)
 433             pEditWin->EnableMapMode();
 434         aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
 435         if (!bMapModeEnabled && pEditWin->IsMapModeEnabled())
 436             pEditWin->EnableMapMode(false);
 437     }
 438     else
 439     {
 440         aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
 441     }
 442
 443     return AWTRectangle( aRealObjArea );
 444 }
 445
 446
 447 awt::Rectangle SAL_CALL SfxInPlaceClient_Impl::getClipRectangle()
 448 {
 449     if ( !m_pClient || !m_pClient->GetViewShell() )
 450         throw uno::RuntimeException();
 451
 452     // currently(?) same as placement
 453     tools::Rectangle aRealObjArea( m_aObjArea );
 454     aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth() * m_aScaleWidth),
 455                                 tools::Long( aRealObjArea.GetHeight() * m_aScaleHeight) ) );
 456
 457     // See comment for SfxInPlaceClient_Impl::getPlacement.
 458     if (comphelper::LibreOfficeKit::isActive())
 459     {
 460         vcl::Window* pEditWin = m_pClient->GetEditWin();
 461         bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
 462         if (!bMapModeEnabled)
 463             pEditWin->EnableMapMode();
 464         aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
 465         if (!bMapModeEnabled && pEditWin->IsMapModeEnabled())
 466             pEditWin->EnableMapMode(false);
 467     }
 468     else
 469     {
 470         aRealObjArea = m_pClient->GetEditWin()->LogicToPixel( aRealObjArea );
 471     }
 472
 473     return AWTRectangle( aRealObjArea );
 474 }
 475
 476
 477 void SAL_CALL SfxInPlaceClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ )
 478 {
 479     if ( !m_pClient || !m_pClient->GetViewShell() )
 480         throw uno::RuntimeException();
 481
 482     // TODO/MBA: keyboard accelerators
 483 }
 484
 485
 486 void SAL_CALL SfxInPlaceClient_Impl::scrollObject( const awt::Size& /*aOffset*/ )
 487 {
 488     if ( !m_pClient || !m_pClient->GetViewShell() )
 489         throw uno::RuntimeException();
 490 }
 491
 492
 493 void SAL_CALL SfxInPlaceClient_Impl::changedPlacement( const awt::Rectangle& aPosRect )
 494 {
 495     uno::Reference< embed::XInplaceObject > xInplace( m_xObject, uno::UNO_QUERY_THROW );
 496     if ( !m_pClient || !m_pClient->GetEditWin() || !m_pClient->GetViewShell() )
 497         throw uno::RuntimeException();
 498
 499     // check if the change is at least one pixel in size
 500     awt::Rectangle aOldRect = getPlacement();
 501     tools::Rectangle aNewPixelRect = VCLRectangle( aPosRect );
 502     tools::Rectangle aOldPixelRect = VCLRectangle( aOldRect );
 503     if ( aOldPixelRect == aNewPixelRect )
 504         // nothing has changed
 505         return;
 506
 507     // new scaled object area
 508     tools::Rectangle aNewLogicRect = m_pClient->GetEditWin()->PixelToLogic( aNewPixelRect );
 509
 510     // all the size changes in this method should happen without scaling
 511     // SfxBooleanFlagGuard aGuard( m_bResizeNoScale, sal_True );
 512
 513     // allow container to apply restrictions on the requested new area;
 514     // the container might change the object view during size calculation;
 515     // currently only writer does it
 516     m_pClient->RequestNewObjectArea( aNewLogicRect);
 517
 518     if ( aNewLogicRect != m_pClient->GetScaledObjArea() )
 519     {
 520         // the calculation of the object area has not changed the object size
 521         // it should be done here then
 522         SfxBooleanFlagGuard aGuard( m_bResizeNoScale );
 523
 524         // new size of the object area without scaling
 525         Size aNewObjSize( tools::Long( aNewLogicRect.GetWidth()  / m_aScaleWidth ),
 526                           tools::Long( aNewLogicRect.GetHeight() / m_aScaleHeight ) );
 527
 528         // now remove scaling from new placement and keep this at the new object area
 529         aNewLogicRect.SetSize( aNewObjSize );
 530         m_aObjArea = aNewLogicRect;
 531
 532         // let the window size be recalculated
 533         SizeHasChanged();
 534     }
 535
 536     // notify container view about changes
 537     m_pClient->ObjectAreaChanged();
 538 }
 539
 540 // XComponentSupplier
 541
 542 uno::Reference< util::XCloseable > SAL_CALL SfxInPlaceClient_Impl::getComponent()
 543 {
 544     if ( !m_pClient || !m_pClient->GetViewShell() )
 545         throw uno::RuntimeException();
 546
 547     SfxObjectShell* pDocShell = m_pClient->GetViewShell()->GetObjectShell();
 548     if ( !pDocShell )
 549         throw uno::RuntimeException();
 550
 551     // all the components must implement XCloseable
 552     uno::Reference< util::XCloseable > xComp( pDocShell->GetModel(), uno::UNO_QUERY_THROW );
 553     return xComp;
 554 }
 555
 556
 557 // XWindowSupplier
 558
 559 uno::Reference< awt::XWindow > SAL_CALL SfxInPlaceClient_Impl::getWindow()
 560 {
 561     if ( !m_pClient || !m_pClient->GetEditWin() )
 562         throw uno::RuntimeException();
 563
 564     uno::Reference< awt::XWindow > xWin( m_pClient->GetEditWin()->GetComponentInterface(), uno::UNO_QUERY );
 565     return xWin;
 566 }
 567
 568
 569 // notification to the client implementation that either the object area or the scaling has been changed
 570 // as a result the logical size of the window has changed also
 571 void SfxInPlaceClient_Impl::SizeHasChanged()
 572 {
 573     if ( !m_pClient || !m_pClient->GetViewShell() )
 574         throw uno::RuntimeException();
 575
 576     try {
 577         if ( m_xObject.is()
 578           && ( m_xObject->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE
 579                 || m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE ) )
 580         {
 581             // only possible in active states
 582             uno::Reference< embed::XInplaceObject > xInplace( m_xObject, uno::UNO_QUERY_THROW );
 583
 584             if ( m_bResizeNoScale )
 585             {
 586                 // the resizing should be done without scaling
 587                 // set the correct size to the object to avoid the scaling
 588                 MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( m_xObject->getMapUnit( m_nAspect ) ) );
 589                 MapMode aClientMap( m_pClient->GetEditWin()->GetMapMode().GetMapUnit() );
 590
 591                 // convert to logical coordinates of the embedded object
 592                 Size aNewSize = m_pClient->GetEditWin()->LogicToLogic( m_aObjArea.GetSize(), &aClientMap, &aObjectMap );
 593                 m_xObject->setVisualAreaSize( m_nAspect, awt::Size( aNewSize.Width(), aNewSize.Height() ) );
 594             }
 595
 596             xInplace->setObjectRectangles( getPlacement(), getClipRectangle() );
 597         }
 598     }
 599     catch( uno::Exception& )
 600     {
 601         // TODO/LATER: handle error
 602     }
 603 }
 604
 605
 606 IMPL_LINK_NOARG(SfxInPlaceClient_Impl, TimerHdl, Timer *, void)
 607 {
 608     if ( m_pClient && m_xObject.is() )
 609     {
 610         m_pClient->GetViewShell()->CheckIPClient_Impl(m_pClient,
 611                 m_pClient->GetViewShell()->GetObjectShell()->GetVisArea());
 612     }
 613 }
 614
 615
 616 // SfxInPlaceClient
 617
 618
 619 SfxInPlaceClient::SfxInPlaceClient( SfxViewShell* pViewShell, vcl::Window *pDraw, sal_Int64 nAspect ) :
 620     m_xImp( new SfxInPlaceClient_Impl ),
 621     m_pViewSh( pViewShell ),
 622     m_pEditWin( pDraw )
 623 {
 624     m_xImp->m_pClient = this;
 625     m_xImp->m_nAspect = nAspect;
 626     m_xImp->m_aScaleWidth = m_xImp->m_aScaleHeight = Fraction(1,1);
 627     pViewShell->NewIPClient_Impl(this);
 628     m_xImp->m_aTimer.SetDebugName( "sfx::SfxInPlaceClient m_xImpl::m_aTimer" );
 629     m_xImp->m_aTimer.SetTimeout( SFX_CLIENTACTIVATE_TIMEOUT );
 630     m_xImp->m_aTimer.SetInvokeHandler( LINK( m_xImp.get(), SfxInPlaceClient_Impl, TimerHdl ) );
 631 }
 632
 633
 634 SfxInPlaceClient::~SfxInPlaceClient()
 635 {
 636     m_pViewSh->IPClientGone_Impl(this);
 637
 638     // deleting the client before storing the object means discarding all changes
 639     m_xImp->m_bStoreObject = false;
 640     SetObject(nullptr);
 641
 642     m_xImp->m_pClient = nullptr;
 643
 644     // the next call will destroy m_xImp if no other reference to it exists
 645     m_xImp.clear();
 646
 647     // TODO/LATER:
 648     // the class is not intended to be used in multithreaded environment;
 649     // if it will this disconnection and all the parts that use the m_pClient
 650     // must be guarded with mutex
 651 }
 652
 653
 654 void SfxInPlaceClient::SetObjectState( sal_Int32 nState )
 655 {
 656     if ( !GetObject().is() )
 657         return;
 658
 659     if ( m_xImp->m_nAspect == embed::Aspects::MSOLE_ICON
 660       && ( nState == embed::EmbedStates::UI_ACTIVE || nState == embed::EmbedStates::INPLACE_ACTIVE ) )
 661     {
 662         OSL_FAIL( "Iconified object should not be activated inplace!" );
 663         return;
 664     }
 665
 666     try
 667     {
 668         GetObject()->changeState( nState );
 669     }
 670     catch ( uno::Exception& )
 671     {}
 672 }
 673
 674
 675 sal_Int64 SfxInPlaceClient::GetObjectMiscStatus() const
 676 {
 677     if ( GetObject().is() )
 678         return GetObject()->getStatus( m_xImp->m_nAspect );
 679     return 0;
 680 }
 681
 682
 683 const uno::Reference < embed::XEmbeddedObject >& SfxInPlaceClient::GetObject() const
 684 {
 685     return m_xImp->m_xObject;
 686 }
 687
 688
 689 void SfxInPlaceClient::SetObject( const uno::Reference < embed::XEmbeddedObject >& rObject )
 690 {
 691     if ( m_xImp->m_xObject.is() && rObject != m_xImp->m_xObject )
 692     {
 693         DBG_ASSERT( GetObject()->getClientSite() == static_cast<cppu::OWeakObject*>(m_xImp.get()), "Wrong ClientSite!" );
 694         if ( GetObject()->getClientSite() == static_cast<cppu::OWeakObject*>(m_xImp.get()) )
 695         {
 696             if ( GetObject()->getCurrentState() != embed::EmbedStates::LOADED )
 697                 SetObjectState( embed::EmbedStates::RUNNING );
 698             m_xImp->m_xObject->removeEventListener( m_xImp.get() );
 699             m_xImp->m_xObject->removeStateChangeListener( m_xImp.get() );
 700             try
 701             {
 702                 m_xImp->m_xObject->setClientSite( nullptr );
 703             }
 704             catch( uno::Exception& )
 705             {
 706                 OSL_FAIL( "Can not clean the client site!" );
 707             }
 708         }
 709     }
 710
 711     if ( m_pViewSh->GetViewFrame()->GetFrame().IsClosing_Impl() )
 712         // sometimes applications reconnect clients on shutting down because it happens in their Paint methods
 713         return;
 714
 715     m_xImp->m_xObject = rObject;
 716
 717     if ( rObject.is() )
 718     {
 719         // as soon as an object was connected to a client it has to be checked whether the object wants
 720         // to be activated
 721         rObject->addStateChangeListener( m_xImp.get() );
 722         rObject->addEventListener( m_xImp.get() );
 723
 724         try
 725         {
 726             rObject->setClientSite( m_xImp.get() );
 727         }
 728         catch( uno::Exception& )
 729         {
 730             OSL_FAIL( "Can not set the client site!" );
 731         }
 732
 733         m_xImp->m_aTimer.Start();
 734     }
 735     else
 736         m_xImp->m_aTimer.Stop();
 737 }
 738
 739
 740 bool SfxInPlaceClient::SetObjArea( const tools::Rectangle& rArea )
 741 {
 742     if( rArea != m_xImp->m_aObjArea )
 743     {
 744         m_xImp->m_aObjArea = rArea;
 745         m_xImp->SizeHasChanged();
 746
 747         Invalidate();
 748         return true;
 749     }
 750
 751     return false;
 752 }
 753
 754
 755 const tools::Rectangle& SfxInPlaceClient::GetObjArea() const
 756 {
 757     return m_xImp->m_aObjArea;
 758 }
 759
 760 tools::Rectangle SfxInPlaceClient::GetScaledObjArea() const
 761 {
 762     tools::Rectangle aRealObjArea( m_xImp->m_aObjArea );
 763     aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth()  * m_xImp->m_aScaleWidth ),
 764                                 tools::Long( aRealObjArea.GetHeight() * m_xImp->m_aScaleHeight ) ) );
 765     return aRealObjArea;
 766 }
 767
 768
 769 void SfxInPlaceClient::SetSizeScale( const Fraction & rScaleWidth, const Fraction & rScaleHeight )
 770 {
 771     if ( m_xImp->m_aScaleWidth != rScaleWidth || m_xImp->m_aScaleHeight != rScaleHeight )
 772     {
 773         m_xImp->m_aScaleWidth = rScaleWidth;
 774         m_xImp->m_aScaleHeight = rScaleHeight;
 775
 776         m_xImp->SizeHasChanged();
 777
 778         // TODO/LATER: Invalidate seems to trigger (wrong) recalculations of the ObjArea, so it's better
 779         // not to call it here, but maybe it sounds reasonable to do so.
 780         //Invalidate();
 781     }
 782 }
 783
 784
 785 void SfxInPlaceClient::SetObjAreaAndScale( const tools::Rectangle& rArea, const Fraction& rScaleWidth, const Fraction& rScaleHeight )
 786 {
 787     if( rArea != m_xImp->m_aObjArea || m_xImp->m_aScaleWidth != rScaleWidth || m_xImp->m_aScaleHeight != rScaleHeight )
 788     {
 789         m_xImp->m_aObjArea = rArea;
 790         m_xImp->m_aScaleWidth = rScaleWidth;
 791         m_xImp->m_aScaleHeight = rScaleHeight;
 792
 793         m_xImp->SizeHasChanged();
 794
 795         Invalidate();
 796     }
 797 }
 798
 799
 800 const Fraction& SfxInPlaceClient::GetScaleWidth() const
 801 {
 802     return m_xImp->m_aScaleWidth;
 803 }
 804
 805
 806 const Fraction& SfxInPlaceClient::GetScaleHeight() const
 807 {
 808     return m_xImp->m_aScaleHeight;
 809 }
 810
 811
 812 void SfxInPlaceClient::Invalidate()
 813 {
 814     // TODO/LATER: do we need both?
 815
 816     // the object area is provided in logical coordinates of the window but without scaling applied
 817     tools::Rectangle aRealObjArea( m_xImp->m_aObjArea );
 818     aRealObjArea.SetSize( Size( tools::Long( aRealObjArea.GetWidth()  * m_xImp->m_aScaleWidth ),
 819                                 tools::Long( aRealObjArea.GetHeight() * m_xImp->m_aScaleHeight ) ) );
 820     m_pEditWin->Invalidate( aRealObjArea );
 821
 822     ViewChanged();
 823 }
 824
 825
 826 bool SfxInPlaceClient::IsObjectUIActive() const
 827 {
 828     try {
 829         return ( m_xImp->m_xObject.is() && ( m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE ) );
 830     }
 831     catch( uno::Exception& )
 832     {}
 833
 834     return false;
 835 }
 836
 837
 838 bool SfxInPlaceClient::IsObjectInPlaceActive() const
 839 {
 840     try {
 841         return(
 842                (
 843                 m_xImp->m_xObject.is() &&
 844                 (m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE)
 845                ) ||
 846                (
 847                 m_xImp->m_xObject.is() &&
 848                 (m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE)
 849                )
 850               );
 851     }
 852     catch( uno::Exception& )
 853     {}
 854
 855     return false;
 856 }
 857
 858
 859 SfxInPlaceClient* SfxInPlaceClient::GetClient( SfxObjectShell const * pDoc, const css::uno::Reference < css::embed::XEmbeddedObject >& xObject )
 860 {
 861     for ( SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDoc); pFrame; pFrame=SfxViewFrame::GetNext(*pFrame,pDoc) )
 862     {
 863         if( pFrame->GetViewShell() )
 864         {
 865             SfxInPlaceClient* pClient = pFrame->GetViewShell()->FindIPClient( xObject, nullptr );
 866             if ( pClient )
 867                 return pClient;
 868         }
 869     }
 870
 871     return nullptr;
 872 }
 873
 874 sal_Int64 SfxInPlaceClient::GetAspect() const
 875 {
 876     return m_xImp->m_nAspect;
 877 }
 878
 879 ErrCode SfxInPlaceClient::DoVerb( tools::Long nVerb )
 880 {
 881     SfxErrorContext aEc(ERRCTX_SO_DOVERB, m_pViewSh->GetFrameWeld(), RID_SO_ERRCTX);
 882     ErrCode nError = ERRCODE_NONE;
 883
 884     if ( m_xImp->m_xObject.is() )
 885     {
 886         bool bSaveCopyAs = false;
 887         if ( nVerb == -8 ) // "Save Copy as..."
 888         {
 889             svt::EmbeddedObjectRef::TryRunningState( m_xImp->m_xObject );
 890             // TODO/LATER: this special verb should disappear when outplace activation is completely available
 891             uno::Reference< frame::XModel > xEmbModel( m_xImp->m_xObject->getComponent(), uno::UNO_QUERY );
 892             if ( xEmbModel.is() )
 893             {
 894                 bSaveCopyAs = true;
 895
 896                 try
 897                 {
 898                     SfxStoringHelper aHelper;
 899                     uno::Sequence< beans::PropertyValue > aDispatchArgs( 1 );
 900                     aDispatchArgs[0].Name = "SaveTo";
 901                     aDispatchArgs[0].Value <<= true;
 902
 903                     aHelper.GUIStoreModel( xEmbModel,
 904                                             "SaveAs",
 905                                             aDispatchArgs,
 906                                             false,
 907                                             SignatureState::NOSIGNATURES );
 908                 }
 909                 catch( const task::ErrorCodeIOException& aErrorEx )
 910                 {
 911                     nError = ErrCode(aErrorEx.ErrCode);
 912                 }
 913                 catch( uno::Exception& )
 914                 {
 915                     nError = ERRCODE_IO_GENERAL;
 916                     // TODO/LATER: better error handling
 917                 }
 918             }
 919         }
 920
 921         if ( !bSaveCopyAs )
 922         {
 923             if ( m_xImp->m_nAspect == embed::Aspects::MSOLE_ICON )
 924             {
 925                 // the common persistence is supported by objects and links
 926
 927                 uno::Reference< embed::XEmbeddedOleObject > xEmbeddedOleObject( m_xImp->m_xObject, uno::UNO_QUERY );
 928
 929                 if ( xEmbeddedOleObject.is() && (nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_OPEN || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW ))
 930                     nVerb = embed::EmbedVerbs::MS_OLEVERB_SHOW;
 931                 else if ( nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW )
 932                     nVerb = embed::EmbedVerbs::MS_OLEVERB_OPEN; // outplace activation
 933                 else if ( nVerb == embed::EmbedVerbs::MS_OLEVERB_UIACTIVATE
 934                        || nVerb == embed::EmbedVerbs::MS_OLEVERB_IPACTIVATE )
 935                     nError = ERRCODE_SO_GENERALERROR;
 936             }
 937
 938             if ( !nError )
 939             {
 940                 // See comment for SfxInPlaceClient_Impl::getPlacement.
 941                 vcl::Window* pEditWin = GetEditWin();
 942                 bool bMapModeEnabled = pEditWin->IsMapModeEnabled();
 943                 if (comphelper::LibreOfficeKit::isActive() && !bMapModeEnabled)
 944                 {
 945                     pEditWin->EnableMapMode();
 946                 }
 947                 m_pViewSh->GetViewFrame()->GetFrame().LockResize_Impl(true);
 948                 try
 949                 {
 950                     m_xImp->m_xObject->setClientSite( m_xImp.get() );
 951
 952                     m_xImp->m_xObject->doVerb( nVerb );
 953                 }
 954                 catch ( embed::UnreachableStateException& )
 955                 {
 956                     if (nVerb == embed::EmbedVerbs::MS_OLEVERB_PRIMARY || nVerb == embed::EmbedVerbs::MS_OLEVERB_OPEN || nVerb == embed::EmbedVerbs::MS_OLEVERB_SHOW)
 957                     {
 958                         // a workaround for the default verb, usually makes sense for alien objects
 959                         try
 960                         {
 961                             m_xImp->m_xObject->doVerb( -9 ); // open own view, a workaround verb that is not visible
 962
 963                             if ( m_xImp->m_xObject->getCurrentState() == embed::EmbedStates::UI_ACTIVE )
 964                             {
 965                                 // the object was converted to OOo object
 966                                 awt::Size aSize = m_xImp->m_xObject->getVisualAreaSize( m_xImp->m_nAspect );
 967                                 MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( m_xImp->m_xObject->getMapUnit( m_xImp->m_nAspect ) ) );
 968                                 MapMode aClientMap( GetEditWin()->GetMapMode().GetMapUnit() );
 969                                 Size aNewSize = GetEditWin()->LogicToLogic( Size( aSize.Width, aSize.Height ), &aObjectMap, &aClientMap );
 970
 971                                 tools::Rectangle aScaledArea = GetScaledObjArea();
 972                                 m_xImp->m_aObjArea.SetSize( aNewSize );
 973                                 m_xImp->m_aScaleWidth = Fraction( aScaledArea.GetWidth(), aNewSize.Width() );
 974                                 m_xImp->m_aScaleHeight = Fraction( aScaledArea.GetHeight(), aNewSize.Height() );
 975                             }
 976                         }
 977                         catch (uno::Exception const&)
 978                         {
 979                             TOOLS_WARN_EXCEPTION("embeddedobj", "SfxInPlaceClient::DoVerb: -9 fallback path");
 980                             nError = ERRCODE_SO_GENERALERROR;
 981                         }
 982                     }
 983                 }
 984                 catch ( embed::StateChangeInProgressException& )
 985                 {
 986                     // TODO/LATER: it would be nice to be able to provide the current target state outside
 987                     nError = ERRCODE_SO_CANNOT_DOVERB_NOW;
 988                 }
 989                 catch (uno::Exception const&)
 990                 {
 991                     TOOLS_WARN_EXCEPTION("embeddedobj", "SfxInPlaceClient::DoVerb");
 992                     nError = ERRCODE_SO_GENERALERROR;
 993                     //TODO/LATER: better error handling
 994
 995                 }
 996                 if (comphelper::LibreOfficeKit::isActive() && !bMapModeEnabled
 997                         && pEditWin->IsMapModeEnabled())
 998                 {
 999                     pEditWin->EnableMapMode(false);
1000                 }
1001                 SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
1002                 pFrame->GetFrame().LockResize_Impl(false);
1003                 pFrame->GetFrame().Resize();
1004             }
1005         }
1006     }
1007
1008     if( nError )
1009         ErrorHandler::HandleError( nError );
1010
1011     return nError;
1012 }
1013
1014 void SfxInPlaceClient::VisAreaChanged()
1015 {
1016     uno::Reference < embed::XInplaceObject > xObj( m_xImp->m_xObject, uno::UNO_QUERY );
1017     if ( xObj.is() )
1018         m_xImp->SizeHasChanged();
1019 }
1020
1021 void SfxInPlaceClient::ObjectAreaChanged()
1022 {
1023     // dummy implementation
1024 }
1025
1026 void SfxInPlaceClient::RequestNewObjectArea( tools::Rectangle& )
1027 {
1028     // dummy implementation
1029 }
1030
1031 void SfxInPlaceClient::ViewChanged()
1032 {
1033     // dummy implementation
1034 }
1035
1036 void SfxInPlaceClient::FormatChanged()
1037 {
1038     // dummy implementation
1039 }
1040
1041 void SfxInPlaceClient::DeactivateObject()
1042 {
1043     if ( !GetObject().is() )
1044         return;
1045
1046     try
1047     {
1048         m_xImp->m_bUIActive = false;
1049         bool bHasFocus = false;
1050         uno::Reference< frame::XModel > xModel( m_xImp->m_xObject->getComponent(), uno::UNO_QUERY );
1051         if ( xModel.is() )
1052         {
1053             uno::Reference< frame::XController > xController = xModel->getCurrentController();
1054             if ( xController.is() )
1055             {
1056                 VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xController->getFrame()->getContainerWindow() );
1057                 bHasFocus = pWindow->HasChildPathFocus( true );
1058             }
1059         }
1060
1061         m_pViewSh->GetViewFrame()->GetFrame().LockResize_Impl(true);
1062
1063         if ( m_xImp->m_xObject->getStatus( m_xImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
1064         {
1065             m_xImp->m_xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
1066             if (bHasFocus)
1067                 m_pViewSh->GetWindow()->GrabFocus();
1068         }
1069         else
1070         {
1071             // the links should not stay in running state for long time because of locking
1072             uno::Reference< embed::XLinkageSupport > xLink( m_xImp->m_xObject, uno::UNO_QUERY );
1073             if ( xLink.is() && xLink->isLink() )
1074                 m_xImp->m_xObject->changeState( embed::EmbedStates::LOADED );
1075             else
1076                 m_xImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
1077         }
1078
1079         SfxViewFrame* pFrame = m_pViewSh->GetViewFrame();
1080         SfxViewFrame::SetViewFrame( pFrame );
1081         pFrame->GetFrame().LockResize_Impl(false);
1082         pFrame->GetFrame().Resize();
1083     }
1084     catch (css::uno::Exception& )
1085     {}
1086 }
1087
1088 void SfxInPlaceClient::ResetObject()
1089 {
1090     if ( !GetObject().is() )
1091         return;
1092
1093     try
1094     {
1095         m_xImp->m_bUIActive = false;
1096         if ( m_xImp->m_xObject->getStatus( m_xImp->m_nAspect ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )
1097             m_xImp->m_xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
1098         else
1099         {
1100             // the links should not stay in running state for long time because of locking
1101             uno::Reference< embed::XLinkageSupport > xLink( m_xImp->m_xObject, uno::UNO_QUERY );
1102             if ( xLink.is() && xLink->isLink() )
1103                 m_xImp->m_xObject->changeState( embed::EmbedStates::LOADED );
1104             else
1105                 m_xImp->m_xObject->changeState( embed::EmbedStates::RUNNING );
1106         }
1107     }
1108     catch (css::uno::Exception& )
1109     {}
1110 }
1111
1112 bool SfxInPlaceClient::IsUIActive() const
1113 {
1114     return m_xImp->m_bUIActive;
1115 }
1116
1117 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */