embeddedobj/source/general/docholder.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 <com/sun/star/embed/Aspects.hpp>
  21 #include <com/sun/star/frame/TaskCreator.hpp>
  22 #include <com/sun/star/frame/XTitle.hpp>
  23 #include <com/sun/star/frame/TerminationVetoException.hpp>
  24 #include <com/sun/star/frame/XComponentLoader.hpp>
  25 #include <com/sun/star/frame/XSynchronousFrameLoader.hpp>
  26 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  27 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
  28 #include <com/sun/star/util/CloseVetoException.hpp>
  29 #include <com/sun/star/util/XCloseBroadcaster.hpp>
  30 #include <com/sun/star/util/XCloseable.hpp>
  31 #include <com/sun/star/lang/XServiceInfo.hpp>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <com/sun/star/beans/NamedValue.hpp>
  34 #include <com/sun/star/frame/XModel.hpp>
  35 #include <com/sun/star/frame/Desktop.hpp>
  36 #include <com/sun/star/frame/XFramesSupplier.hpp>
  37 #include <com/sun/star/frame/XControllerBorder.hpp>
  38 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  39 #include <com/sun/star/frame/XDispatchProviderInterception.hpp>
  40 #include <com/sun/star/awt/Toolkit.hpp>
  41 #include <com/sun/star/awt/XTopWindow.hpp>
  42 #include <com/sun/star/awt/PosSize.hpp>
  43 #include <com/sun/star/awt/WindowAttribute.hpp>
  44 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
  45 #include <com/sun/star/embed/XHatchWindow.hpp>
  46 #include <com/sun/star/embed/HatchWindowFactory.hpp>
  47 #include <com/sun/star/frame/XLayoutManager.hpp>
  48 #include <com/sun/star/frame/XMenuBarMergingAcceptor.hpp>
  49 #include <com/sun/star/frame/ModuleManager.hpp>
  50 #include <com/sun/star/ui/XDockingAreaAcceptor.hpp>
  51 #include <com/sun/star/ui/XUIElementSettings.hpp>
  52 #include <com/sun/star/ui/XUIConfigurationManager.hpp>
  53 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  54 #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
  55 #include <com/sun/star/embed/StateChangeInProgressException.hpp>
  56
  57 #include <com/sun/star/embed/EmbedMisc.hpp>
  58 #include <com/sun/star/embed/EmbedStates.hpp>
  59 #include <osl/diagnose.h>
  60 #include <utility>
  61 #include <vcl/svapp.hxx>
  62 #include <unotools/resmgr.hxx>
  63 #include <sfx2/strings.hrc>
  64
  65 #include <comphelper/processfactory.hxx>
  66 #include <comphelper/namedvaluecollection.hxx>
  67
  68 #include <docholder.hxx>
  69 #include <commonembobj.hxx>
  70 #include <intercept.hxx>
  71
  72 #define HATCH_BORDER_WIDTH (((m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE) && \
  73                             m_pEmbedObj->getCurrentState()!=embed::EmbedStates::UI_ACTIVE) ? 0 : 4 )
  74
  75 using namespace ::com::sun::star;
  76
  77 namespace {
  78
  79 class IntCounterGuard
  80 {
  81     sal_Int32& m_rFlag;
  82 public:
  83     explicit IntCounterGuard(sal_Int32& rFlag)
  84         : m_rFlag(rFlag)
  85     {
  86         ++m_rFlag;
  87     }
  88
  89     ~IntCounterGuard()
  90     {
  91         if (m_rFlag)
  92             --m_rFlag;
  93     }
  94 };
  95
  96 }
  97
  98 static void InsertMenu_Impl( const uno::Reference< container::XIndexContainer >& xTargetMenu,
  99                             sal_Int32 nTargetIndex,
 100                             const uno::Reference< container::XIndexAccess >& xSourceMenu,
 101                             sal_Int32 nSourceIndex,
 102                             const OUString& aContModuleName,
 103                             const uno::Reference< frame::XDispatchProvider >& xSourceDisp )
 104 {
 105     sal_Int32 nInd = 0;
 106     OUString aModuleIdentPropName( "ModuleIdentifier" );
 107     OUString aDispProvPropName( "DispatchProvider" );
 108     bool bModuleNameSet = false;
 109     bool bDispProvSet = false;
 110
 111     uno::Sequence< beans::PropertyValue > aSourceProps;
 112     xSourceMenu->getByIndex( nSourceIndex ) >>= aSourceProps;
 113     uno::Sequence< beans::PropertyValue > aTargetProps( aSourceProps.getLength() );
 114     auto aTargetPropsRange = asNonConstRange(aTargetProps);
 115     for ( nInd = 0; nInd < aSourceProps.getLength(); nInd++ )
 116     {
 117         aTargetPropsRange[nInd].Name = aSourceProps[nInd].Name;
 118         if ( !aContModuleName.isEmpty() && aTargetProps[nInd].Name == aModuleIdentPropName )
 119         {
 120             aTargetPropsRange[nInd].Value <<= aContModuleName;
 121             bModuleNameSet = true;
 122         }
 123         else if ( aTargetProps[nInd].Name == aDispProvPropName )
 124         {
 125             aTargetPropsRange[nInd].Value <<= xSourceDisp;
 126             bDispProvSet = true;
 127         }
 128         else
 129             aTargetPropsRange[nInd].Value = aSourceProps[nInd].Value;
 130     }
 131
 132     if ( !bModuleNameSet && !aContModuleName.isEmpty() )
 133     {
 134         aTargetProps.realloc( ++nInd );
 135         auto pTargetProps = aTargetProps.getArray();
 136         pTargetProps[nInd-1].Name = aModuleIdentPropName;
 137         pTargetProps[nInd-1].Value <<= aContModuleName;
 138     }
 139
 140     if ( !bDispProvSet && xSourceDisp.is() )
 141     {
 142         aTargetProps.realloc( ++nInd );
 143         auto pTargetProps = aTargetProps.getArray();
 144         pTargetProps[nInd-1].Name = aDispProvPropName;
 145         pTargetProps[nInd-1].Value <<= xSourceDisp;
 146     }
 147
 148     xTargetMenu->insertByIndex( nTargetIndex, uno::Any( aTargetProps ) );
 149 }
 150
 151
 152 DocumentHolder::DocumentHolder( uno::Reference< uno::XComponentContext > xContext,
 153                                 OCommonEmbeddedObject* pEmbObj )
 154 : m_pEmbedObj( pEmbObj ),
 155   m_xContext(std::move( xContext )),
 156   m_bReadOnly( false ),
 157   m_bWaitForClose( false ),
 158   m_bAllowClosing( false ),
 159   m_bDesktopTerminated( false ),
 160   m_nNoBorderResizeReact( 0 ),
 161   m_nNoResizeReact( 0 )
 162 {
 163     uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( m_xContext );
 164     osl_atomic_increment(&m_refCount);
 165     try
 166     {
 167         xDesktop->addTerminateListener( this );
 168     }
 169     catch ( const uno::Exception& )
 170     {
 171     }
 172     osl_atomic_decrement(&m_refCount);
 173
 174     m_aOutplaceFrameProps = { uno::Any(beans::NamedValue{ "TopWindow", uno::Any(true) }),
 175                               uno::Any(beans::NamedValue{ "MakeVisible", uno::Any(false) }),
 176                               //TODO/LATER: should use parent document frame
 177                               uno::Any(beans::NamedValue{ "ParentFrame", uno::Any(xDesktop) }) };
 178 }
 179
 180
 181 DocumentHolder::~DocumentHolder()
 182 {
 183     osl_atomic_increment(&m_refCount); // to allow deregistration as a listener
 184
 185     if( m_xFrame.is() )
 186         CloseFrame();
 187
 188     if ( m_xComponent.is() )
 189     {
 190         try {
 191             CloseDocument( true, false );
 192         } catch( const uno::Exception& ) {}
 193     }
 194
 195     if ( m_xInterceptor.is() )
 196     {
 197         m_xInterceptor->DisconnectDocHolder();
 198         m_xInterceptor.clear();
 199     }
 200
 201     if ( !m_bDesktopTerminated )
 202         FreeOffice();
 203 }
 204
 205
 206 void DocumentHolder::CloseFrame()
 207 {
 208     uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
 209     if ( xCloseBroadcaster.is() )
 210         xCloseBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) );
 211
 212     uno::Reference<util::XCloseable> xCloseable(
 213         m_xFrame,uno::UNO_QUERY );
 214     if( xCloseable.is() )
 215         try {
 216             xCloseable->close( true );
 217         }
 218         catch( const uno::Exception& ) {
 219         }
 220     else {
 221         if( m_xFrame.is() )
 222             m_xFrame->dispose();
 223     }
 224
 225     if ( m_xHatchWindow.is() )
 226         m_xHatchWindow->dispose();
 227
 228     m_xHatchWindow.clear();
 229     m_xOwnWindow.clear();
 230     m_xFrame.clear();
 231 }
 232
 233
 234 void DocumentHolder::FreeOffice()
 235 {
 236     try {
 237         uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( m_xContext );
 238         xDesktop->removeTerminateListener( this );
 239     } catch (const css::uno::DeploymentException&) {
 240         // if this happens, the desktop is already gone
 241     }
 242
 243     // the following code is commented out since for now there is still no completely correct way to detect
 244     // whether the office can be terminated, so it is better to have unnecessary process running than
 245     // to lose any data
 246
 247 //      uno::Reference< frame::XFramesSupplier > xFramesSupplier( xDesktop, uno::UNO_QUERY );
 248 //      if ( xFramesSupplier.is() )
 249 //      {
 250 //          uno::Reference< frame::XFrames > xFrames = xFramesSupplier->getFrames();
 251 //          if ( xFrames.is() && !xFrames->hasElements() )
 252 //          {
 253 //              try
 254 //              {
 255 //                  xDesktop->terminate();
 256 //              }
 257 //              catch( uno::Exception & )
 258 //              {}
 259 //          }
 260 //      }
 261 }
 262
 263
 264 void DocumentHolder::CloseDocument( bool bDeliverOwnership, bool bWaitForClose )
 265 {
 266     if ( m_xComponent.is() )
 267     {
 268         uno::Reference< document::XEventBroadcaster > xEventBroadcaster( m_xComponent, uno::UNO_QUERY );
 269         if ( xEventBroadcaster.is() )
 270             xEventBroadcaster->removeEventListener( static_cast<document::XEventListener*>(this) );
 271         else
 272         {
 273             // the object does not support document::XEventBroadcaster interface
 274             // use the workaround, register for modified events
 275             uno::Reference< util::XModifyBroadcaster > xModifyBroadcaster( m_xComponent, uno::UNO_QUERY );
 276             if ( xModifyBroadcaster.is() )
 277                 xModifyBroadcaster->removeModifyListener( static_cast<util::XModifyListener*>(this) );
 278         }
 279
 280         m_bAllowClosing = true;
 281         m_bWaitForClose = bWaitForClose;
 282         m_xComponent->close( bDeliverOwnership );
 283     }
 284
 285     m_xComponent = nullptr;
 286 }
 287
 288
 289 void DocumentHolder::PlaceFrame( const awt::Rectangle& aNewRect )
 290 {
 291     OSL_ENSURE( m_xFrame.is() && m_xOwnWindow.is(),
 292                 "The object does not have windows required for inplace mode!" );
 293
 294     //TODO: may need mutex locking???
 295     if ( !(m_xFrame.is() && m_xOwnWindow.is()) )
 296         return;
 297
 298     // the frame can be replaced only in inplace mode
 299     frame::BorderWidths aOldWidths;
 300     IntCounterGuard aGuard( m_nNoBorderResizeReact );
 301
 302     do
 303     {
 304         aOldWidths = m_aBorderWidths;
 305
 306         awt::Rectangle aHatchRect = AddBorderToArea( aNewRect );
 307
 308         ResizeWindows_Impl( aHatchRect );
 309
 310     } while ( aOldWidths.Left != m_aBorderWidths.Left
 311            || aOldWidths.Top != m_aBorderWidths.Top
 312            || aOldWidths.Right != m_aBorderWidths.Right
 313            || aOldWidths.Bottom != m_aBorderWidths.Bottom );
 314
 315     m_aObjRect = aNewRect;
 316 }
 317
 318
 319 void DocumentHolder::ResizeWindows_Impl( const awt::Rectangle& aHatchRect )
 320 {
 321     OSL_ENSURE( m_xFrame.is() && m_xOwnWindow.is() /*&& m_xHatchWindow.is()*/,
 322                 "The object does not have windows required for inplace mode!" );
 323     if ( m_xHatchWindow.is() )
 324     {
 325         m_xOwnWindow->setPosSize( HATCH_BORDER_WIDTH,
 326                                   HATCH_BORDER_WIDTH,
 327                                   aHatchRect.Width - 2*HATCH_BORDER_WIDTH,
 328                                   aHatchRect.Height - 2*HATCH_BORDER_WIDTH,
 329                                   awt::PosSize::POSSIZE );
 330
 331
 332         m_xHatchWindow->setPosSize( aHatchRect.X,
 333                                     aHatchRect.Y,
 334                                     aHatchRect.Width,
 335                                     aHatchRect.Height,
 336                                     awt::PosSize::POSSIZE );
 337     }
 338     else
 339         m_xOwnWindow->setPosSize( aHatchRect.X + HATCH_BORDER_WIDTH,
 340                                   aHatchRect.Y + HATCH_BORDER_WIDTH,
 341                                   aHatchRect.Width - 2*HATCH_BORDER_WIDTH,
 342                                   aHatchRect.Height - 2*HATCH_BORDER_WIDTH,
 343                                   awt::PosSize::POSSIZE );
 344 }
 345
 346
 347 bool DocumentHolder::SetFrameLMVisibility( const uno::Reference< frame::XFrame >& xFrame, bool bVisible )
 348 {
 349     bool bResult = false;
 350
 351     try
 352     {
 353         uno::Reference< css::frame::XLayoutManager > xLayoutManager;
 354         uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY_THROW );
 355         xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
 356         if ( xLayoutManager.is() )
 357         {
 358             xLayoutManager->setVisible( bVisible );
 359
 360             // MBA: locking is done only on the container LM, because it is not about hiding windows, it's about
 361             // giving up control over the component window (and stopping to listen for resize events of the container window)
 362             if ( bVisible )
 363                 xLayoutManager->unlock();
 364             else
 365                 xLayoutManager->lock();
 366
 367             bResult = true;
 368         }
 369     }
 370     catch( const uno::Exception& )
 371     {}
 372
 373     return bResult;
 374 }
 375
 376
 377 bool DocumentHolder::ShowInplace( const uno::Reference< awt::XWindowPeer >& xParent,
 378                                       const awt::Rectangle& aRectangleToShow,
 379                                       const uno::Reference< frame::XDispatchProvider >& xContDisp )
 380 {
 381     OSL_ENSURE( !m_xFrame.is(), "A frame exists already!" );
 382
 383     if ( !m_xFrame.is() )
 384     {
 385         uno::Reference < frame::XModel > xModel( GetComponent(), uno::UNO_QUERY );
 386         awt::Rectangle aHatchRectangle = AddBorderToArea( aRectangleToShow );
 387
 388         awt::Rectangle aOwnRectangle(  HATCH_BORDER_WIDTH,
 389                                     HATCH_BORDER_WIDTH,
 390                                     aHatchRectangle.Width - 2*HATCH_BORDER_WIDTH,
 391                                     aHatchRectangle.Height - 2*HATCH_BORDER_WIDTH );
 392         uno::Reference< awt::XWindow > xHWindow;
 393         uno::Reference< awt::XWindowPeer > xMyParent( xParent );
 394
 395         if ( xModel.is() )
 396         {
 397
 398             uno::Reference< embed::XHatchWindowFactory > xHatchFactory =
 399                     embed::HatchWindowFactory::create(m_xContext);
 400
 401             uno::Reference< embed::XHatchWindow > xHatchWindow =
 402                             xHatchFactory->createHatchWindowInstance( xParent,
 403                                                                       aHatchRectangle,
 404                                                                       awt::Size( HATCH_BORDER_WIDTH, HATCH_BORDER_WIDTH ) );
 405
 406             uno::Reference< awt::XWindowPeer > xHatchWinPeer( xHatchWindow, uno::UNO_QUERY );
 407             xHWindow.set( xHatchWinPeer, uno::UNO_QUERY_THROW );
 408
 409             xHatchWindow->setController( uno::Reference< embed::XHatchWindowController >(
 410                                                 static_cast< embed::XHatchWindowController* >( this ) ) );
 411
 412             xMyParent = xHatchWinPeer;
 413         }
 414         else
 415         {
 416             aOwnRectangle.X += aHatchRectangle.X;
 417             aOwnRectangle.Y += aHatchRectangle.Y;
 418         }
 419
 420         awt::WindowDescriptor aOwnWinDescriptor( awt::WindowClass_TOP,
 421                                                 "dockingwindow",
 422                                                 xMyParent,
 423                                                 0,
 424                                                 awt::Rectangle(),//aOwnRectangle,
 425                                                 awt::WindowAttribute::SHOW | awt::VclWindowPeerAttribute::CLIPCHILDREN );
 426
 427         uno::Reference< awt::XToolkit2 > xToolkit = awt::Toolkit::create(m_xContext);
 428
 429         uno::Reference< awt::XWindowPeer > xNewWinPeer = xToolkit->createWindow( aOwnWinDescriptor );
 430         uno::Reference< awt::XWindow > xOwnWindow( xNewWinPeer, uno::UNO_QUERY_THROW );
 431         uno::Reference< frame::XFrame > xContFrame( xContDisp, uno::UNO_QUERY );
 432
 433         // create a frame based on the specified window
 434         uno::Reference< lang::XSingleServiceFactory > xFrameFact = frame::TaskCreator::create(m_xContext);
 435
 436         uno::Sequence< uno::Any > aArgs( xContFrame.is() ? 2 : 1 );
 437         auto pArgs = aArgs.getArray();
 438         beans::NamedValue aArg;
 439
 440         aArg.Name    = "ContainerWindow";
 441         aArg.Value <<= xOwnWindow;
 442         pArgs[0] <<= aArg;
 443
 444         if ( xContFrame.is() )
 445         {
 446             aArg.Name    = "ParentFrame";
 447             aArg.Value <<= xContFrame;
 448             pArgs[1] <<= aArg;
 449         }
 450
 451         // the call will create, initialize the frame, and register it in the parent
 452         m_xFrame.set( xFrameFact->createInstanceWithArguments( aArgs ), uno::UNO_QUERY_THROW );
 453
 454         m_xHatchWindow = xHWindow;
 455         m_xOwnWindow = xOwnWindow;
 456
 457         if ( !SetFrameLMVisibility( m_xFrame, false ) )
 458         {
 459             OSL_FAIL( "Can't deactivate LayoutManager!" );
 460             // TODO/LATER: error handling?
 461         }
 462
 463         // m_bIsInplace = sal_True; TODO: ?
 464
 465         uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
 466         if ( xCloseBroadcaster.is() )
 467             xCloseBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) );
 468
 469         // TODO: some listeners to the frame and the window ( resize for example )
 470     }
 471
 472     if ( !m_xComponent )
 473         return false;
 474
 475     if ( !LoadDocToFrame( true ) )
 476     {
 477         CloseFrame();
 478         return false;
 479     }
 480
 481     uno::Reference< frame::XControllerBorder > xControllerBorder( m_xFrame->getController(), uno::UNO_QUERY );
 482     if ( xControllerBorder.is() )
 483     {
 484         m_aBorderWidths = xControllerBorder->getBorder();
 485         xControllerBorder->addBorderResizeListener( static_cast<frame::XBorderResizeListener*>(this) );
 486     }
 487
 488     PlaceFrame( aRectangleToShow );
 489
 490     if ( m_xHatchWindow.is() )
 491         m_xHatchWindow->setVisible( true );
 492
 493     return true;
 494 }
 495
 496
 497 uno::Reference< container::XIndexAccess > DocumentHolder::RetrieveOwnMenu_Impl()
 498 {
 499     uno::Reference< container::XIndexAccess > xResult;
 500
 501     uno::Reference< css::ui::XUIConfigurationManagerSupplier > xUIConfSupplier(
 502                 m_xComponent,
 503                 uno::UNO_QUERY );
 504     uno::Reference< css::ui::XUIConfigurationManager > xUIConfigManager;
 505     if( xUIConfSupplier.is())
 506     {
 507         xUIConfigManager.set(
 508             xUIConfSupplier->getUIConfigurationManager(),
 509             uno::UNO_SET_THROW );
 510     }
 511
 512     try
 513     {
 514         if( xUIConfigManager.is())
 515         {
 516             xResult = xUIConfigManager->getSettings(
 517                 "private:resource/menubar/menubar",
 518                 false );
 519         }
 520     }
 521     catch( const uno::Exception& )
 522     {}
 523
 524     if ( !xResult.is() )
 525     {
 526         // no internal document configuration, use the one from the module
 527         uno::Reference< frame::XModuleManager2 > xModuleMan = frame::ModuleManager::create(m_xContext);
 528         OUString aModuleIdent =
 529             xModuleMan->identify( uno::Reference< uno::XInterface >( m_xComponent, uno::UNO_QUERY ) );
 530
 531         if ( !aModuleIdent.isEmpty() )
 532         {
 533             uno::Reference< ui::XModuleUIConfigurationManagerSupplier > xModConfSupplier =
 534                     ui::theModuleUIConfigurationManagerSupplier::get(m_xContext);
 535             uno::Reference< css::ui::XUIConfigurationManager > xModUIConfMan(
 536                     xModConfSupplier->getUIConfigurationManager( aModuleIdent ),
 537                     uno::UNO_SET_THROW );
 538             xResult = xModUIConfMan->getSettings(
 539                     "private:resource/menubar/menubar",
 540                     false );
 541         }
 542     }
 543
 544     if ( !xResult.is() )
 545         throw uno::RuntimeException();
 546
 547     return xResult;
 548 }
 549
 550
 551 void DocumentHolder::FindConnectPoints(
 552         const uno::Reference< container::XIndexAccess >& xMenu,
 553         sal_Int32 nConnectPoints[2] )
 554 {
 555     nConnectPoints[0] = -1;
 556     nConnectPoints[1] = -1;
 557     for ( sal_Int32 nInd = 0; nInd < xMenu->getCount(); nInd++ )
 558     {
 559         uno::Sequence< beans::PropertyValue > aProps;
 560         xMenu->getByIndex( nInd ) >>= aProps;
 561         OUString aCommand;
 562         for ( beans::PropertyValue const & prop : std::as_const(aProps) )
 563             if ( prop.Name == "CommandURL" )
 564             {
 565                 prop.Value >>= aCommand;
 566                 break;
 567             }
 568
 569         if ( aCommand.isEmpty() )
 570             throw uno::RuntimeException();
 571
 572         if ( aCommand == ".uno:PickList" )
 573             nConnectPoints[0] = nInd;
 574         else if ( aCommand == ".uno:WindowList" )
 575             nConnectPoints[1] = nInd;
 576     }
 577 }
 578
 579
 580 uno::Reference< container::XIndexAccess > DocumentHolder::MergeMenusForInplace(
 581         const uno::Reference< container::XIndexAccess >& xContMenu,
 582         const uno::Reference< frame::XDispatchProvider >& xContDisp,
 583         const OUString& aContModuleName,
 584         const uno::Reference< container::XIndexAccess >& xOwnMenu,
 585         const uno::Reference< frame::XDispatchProvider >& xOwnDisp )
 586 {
 587     // TODO/LATER: use dispatch providers on merge
 588
 589     sal_Int32 nContPoints[2];
 590     sal_Int32 nOwnPoints[2];
 591
 592     uno::Reference< lang::XSingleComponentFactory > xIndAccessFact( xContMenu, uno::UNO_QUERY_THROW );
 593
 594     uno::Reference< container::XIndexContainer > xMergedMenu(
 595             xIndAccessFact->createInstanceWithContext(
 596                 comphelper::getProcessComponentContext() ),
 597             uno::UNO_QUERY_THROW );
 598
 599     FindConnectPoints( xContMenu, nContPoints );
 600     FindConnectPoints( xOwnMenu, nOwnPoints );
 601
 602     for ( sal_Int32 nInd = 0; nInd < xOwnMenu->getCount(); nInd++ )
 603     {
 604         if ( nOwnPoints[0] == nInd )
 605         {
 606             if ( nContPoints[0] >= 0 && nContPoints[0] < xContMenu->getCount() )
 607             {
 608                 InsertMenu_Impl( xMergedMenu, nInd, xContMenu, nContPoints[0], aContModuleName, xContDisp );
 609             }
 610         }
 611         else if ( nOwnPoints[1] == nInd )
 612         {
 613             if ( nContPoints[1] >= 0 && nContPoints[1] < xContMenu->getCount() )
 614             {
 615                 InsertMenu_Impl( xMergedMenu, nInd, xContMenu, nContPoints[1], aContModuleName, xContDisp );
 616             }
 617         }
 618         else
 619             InsertMenu_Impl( xMergedMenu, nInd, xOwnMenu, nInd, OUString(), xOwnDisp );
 620     }
 621
 622     return uno::Reference< container::XIndexAccess >( xMergedMenu, uno::UNO_QUERY_THROW );
 623 }
 624
 625
 626 bool DocumentHolder::MergeMenus_Impl( const uno::Reference< css::frame::XLayoutManager >& xOwnLM,
 627                                             const uno::Reference< css::frame::XLayoutManager >& xContLM,
 628                                             const uno::Reference< frame::XDispatchProvider >& xContDisp,
 629                                             const OUString& aContModuleName )
 630 {
 631     bool bMenuMerged = false;
 632     try
 633     {
 634         uno::Reference< css::ui::XUIElementSettings > xUISettings(
 635             xContLM->getElement( "private:resource/menubar/menubar" ),
 636             uno::UNO_QUERY_THROW );
 637         uno::Reference< container::XIndexAccess > xContMenu = xUISettings->getSettings( true );
 638         if ( !xContMenu.is() )
 639             throw uno::RuntimeException();
 640
 641         uno::Reference< container::XIndexAccess > xOwnMenu = RetrieveOwnMenu_Impl();
 642         uno::Reference< frame::XDispatchProvider > xOwnDisp( m_xFrame, uno::UNO_QUERY_THROW );
 643
 644         uno::Reference< container::XIndexAccess > xMergedMenu = MergeMenusForInplace( xContMenu, xContDisp, aContModuleName, xOwnMenu, xOwnDisp );
 645         uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM,
 646                                                                                          uno::UNO_QUERY_THROW );
 647         bMenuMerged = xMerge->setMergedMenuBar( xMergedMenu );
 648     }
 649     catch( const uno::Exception& )
 650     {}
 651
 652     return bMenuMerged;
 653 }
 654
 655 bool DocumentHolder::ShowUI( const uno::Reference< css::frame::XLayoutManager >& xContainerLM,
 656                                  const uno::Reference< frame::XDispatchProvider >& xContainerDP,
 657                                  const OUString& aContModuleName )
 658 {
 659     bool bResult = false;
 660     if ( xContainerLM.is() )
 661     {
 662         // the LM of the embedded frame and its current DockingAreaAcceptor
 663         uno::Reference< css::frame::XLayoutManager > xOwnLM;
 664         uno::Reference< css::ui::XDockingAreaAcceptor > xDocAreaAcc;
 665
 666         try
 667         {
 668             uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
 669             xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
 670             xDocAreaAcc = xContainerLM->getDockingAreaAcceptor();
 671         }
 672         catch( const uno::Exception& ){}
 673
 674         if ( xOwnLM.is() && xDocAreaAcc.is() )
 675         {
 676             // make sure that lock state of LM is correct even if an exception is thrown in between
 677             bool bUnlockContainerLM = false;
 678             bool bLockOwnLM = false;
 679             try
 680             {
 681                 // take over the control over the containers window
 682                 // as long as the LM is invisible and locked an empty tool space will be used on resizing
 683                 xOwnLM->setDockingAreaAcceptor( xDocAreaAcc );
 684
 685                 // try to merge menus; don't do anything else if it fails
 686                 if ( MergeMenus_Impl( xOwnLM, xContainerLM, xContainerDP, aContModuleName ) )
 687                 {
 688                     // make sure that the container LM does not control the size of the containers window anymore
 689                     // this must be done after merging menus as we won't get the container menu otherwise
 690                     xContainerLM->setDockingAreaAcceptor( uno::Reference < ui::XDockingAreaAcceptor >() );
 691
 692                     uno::Reference< lang::XServiceInfo> xServiceInfo(m_xComponent, uno::UNO_QUERY);
 693                     if (!xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
 694                     {
 695                         // prevent further changes at this LM
 696                         xContainerLM->setVisible(false);
 697                         xContainerLM->lock();
 698                         bUnlockContainerLM = true;
 699                     }
 700
 701                     // by unlocking the LM each layout change will now resize the containers window; pending layouts will be processed now
 702                     xOwnLM->setVisible( true );
 703
 704                     uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
 705                     if ( xSupp.is() )
 706                         xSupp->setActiveFrame( m_xFrame );
 707
 708                     xOwnLM->unlock();
 709                     bLockOwnLM = true;
 710                     bResult = true;
 711
 712                     // TODO/LATER: The following action should be done only if the window is not hidden
 713                     // otherwise the activation must fail, unfortunately currently it is not possible
 714                     // to detect whether the window is hidden using UNO API
 715                     m_xOwnWindow->setFocus();
 716                 }
 717             }
 718             catch( const uno::Exception& )
 719             {
 720                 // activation failed; reestablish old state
 721                 try
 722                 {
 723                     uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
 724                     if ( xSupp.is() )
 725                         xSupp->setActiveFrame( nullptr );
 726
 727                     // remove control about containers window from own LM
 728                     if (bLockOwnLM)
 729                         xOwnLM->lock();
 730                     xOwnLM->setVisible( false );
 731                     xOwnLM->setDockingAreaAcceptor( uno::Reference< css::ui::XDockingAreaAcceptor >() );
 732
 733                     // unmerge menu
 734                     uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM, uno::UNO_QUERY_THROW );
 735                     xMerge->removeMergedMenuBar();
 736                 }
 737                 catch( const uno::Exception& ) {}
 738
 739                 try
 740                 {
 741                     // reestablish control of containers window
 742                     xContainerLM->setDockingAreaAcceptor( xDocAreaAcc );
 743                     xContainerLM->setVisible( true );
 744                     if (bUnlockContainerLM)
 745                         xContainerLM->unlock();
 746                 }
 747                 catch( const uno::Exception& ) {}
 748             }
 749         }
 750     }
 751
 752     return bResult;
 753 }
 754
 755
 756 bool DocumentHolder::HideUI( const uno::Reference< css::frame::XLayoutManager >& xContainerLM )
 757 {
 758     bool bResult = false;
 759
 760     if ( xContainerLM.is() )
 761     {
 762         uno::Reference< css::frame::XLayoutManager > xOwnLM;
 763
 764         try {
 765             uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
 766             xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
 767         } catch( const uno::Exception& )
 768         {}
 769
 770         if ( xOwnLM.is() )
 771         {
 772             try {
 773                 uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
 774                 if ( xSupp.is() )
 775                     xSupp->setActiveFrame( nullptr );
 776
 777                 uno::Reference< css::ui::XDockingAreaAcceptor > xDocAreaAcc = xOwnLM->getDockingAreaAcceptor();
 778
 779                 xOwnLM->setDockingAreaAcceptor( uno::Reference < ui::XDockingAreaAcceptor >() );
 780                 xOwnLM->lock();
 781                 xOwnLM->setVisible( false );
 782
 783                 uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM, uno::UNO_QUERY_THROW );
 784                 xMerge->removeMergedMenuBar();
 785
 786                 xContainerLM->setDockingAreaAcceptor( xDocAreaAcc );
 787                 uno::Reference< lang::XServiceInfo> xServiceInfo(m_xComponent, uno::UNO_QUERY);
 788                 if (!xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
 789                 {
 790                     xContainerLM->setVisible(true);
 791                     xContainerLM->unlock();
 792                 }
 793
 794                 xContainerLM->doLayout();
 795                 bResult = true;
 796             }
 797             catch( const uno::Exception& )
 798             {
 799                 SetFrameLMVisibility( m_xFrame, true );
 800             }
 801         }
 802     }
 803
 804     return bResult;
 805 }
 806
 807
 808 uno::Reference< frame::XFrame > const & DocumentHolder::GetDocFrame()
 809 {
 810     // the frame for outplace activation
 811     if ( !m_xFrame.is() )
 812     {
 813         uno::Reference< lang::XSingleServiceFactory > xFrameFact = frame::TaskCreator::create(m_xContext);
 814
 815         m_xFrame.set(xFrameFact->createInstanceWithArguments( m_aOutplaceFrameProps ), uno::UNO_QUERY_THROW);
 816
 817         uno::Reference< frame::XDispatchProviderInterception > xInterception( m_xFrame, uno::UNO_QUERY );
 818         if ( xInterception.is() )
 819         {
 820             if ( m_xInterceptor.is() )
 821             {
 822                 m_xInterceptor->DisconnectDocHolder();
 823                 m_xInterceptor.clear();
 824             }
 825
 826             m_xInterceptor = new Interceptor( this );
 827
 828             xInterception->registerDispatchProviderInterceptor( m_xInterceptor );
 829
 830             // register interceptor from outside
 831             if ( m_xOutplaceInterceptor.is() )
 832                 xInterception->registerDispatchProviderInterceptor( m_xOutplaceInterceptor );
 833         }
 834
 835         uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
 836         if ( xCloseBroadcaster.is() )
 837             xCloseBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) );
 838     }
 839
 840     if ( m_xComponent.is() )
 841     {
 842         uno::Reference< css::frame::XLayoutManager > xOwnLM;
 843         try {
 844             uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
 845             xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
 846         } catch( const uno::Exception& )
 847         {}
 848
 849         if ( xOwnLM.is() )
 850             xOwnLM->lock();
 851
 852         // TODO/LATER: get it for the real aspect
 853         awt::Size aSize;
 854         LoadDocToFrame(false);
 855
 856         if ( xOwnLM.is() )
 857         {
 858             xOwnLM->unlock();
 859             xOwnLM->lock();
 860         }
 861
 862         GetExtent(embed::Aspects::MSOLE_CONTENT, &aSize);
 863         SetExtent(embed::Aspects::MSOLE_CONTENT, aSize);
 864
 865         if ( xOwnLM.is() )
 866             xOwnLM->unlock();
 867     }
 868
 869     try
 870     {
 871         uno::Reference< awt::XWindow > xHWindow = m_xFrame->getContainerWindow();
 872
 873         if( xHWindow.is() )
 874         {
 875             sal_Int32 nDisplay = Application::GetDisplayBuiltInScreen();
 876
 877             tools::Rectangle aWorkRect = Application::GetScreenPosSizePixel( nDisplay );
 878             awt::Rectangle aWindowRect = xHWindow->getPosSize();
 879
 880             if (( aWindowRect.Width < aWorkRect.GetWidth()) && ( aWindowRect.Height < aWorkRect.GetHeight() ))
 881             {
 882                 int OffsetX = ( aWorkRect.GetWidth() - aWindowRect.Width ) / 2 + aWorkRect.Left();
 883                 int OffsetY = ( aWorkRect.GetHeight() - aWindowRect.Height ) /2 + aWorkRect.Top();
 884                 xHWindow->setPosSize( OffsetX, OffsetY, aWindowRect.Width, aWindowRect.Height, awt::PosSize::POS );
 885             }
 886             else
 887             {
 888                 xHWindow->setPosSize( aWorkRect.Left(), aWorkRect.Top(), aWorkRect.GetWidth(), aWorkRect.GetHeight(), awt::PosSize::POSSIZE );
 889             }
 890
 891             xHWindow->setVisible( true );
 892         }
 893     }
 894     catch ( const uno::Exception& )
 895     {
 896     }
 897
 898     return m_xFrame;
 899 }
 900
 901
 902 void DocumentHolder::SetComponent( const uno::Reference< util::XCloseable >& xDoc, bool bReadOnly )
 903 {
 904     if ( m_xComponent.is() )
 905     {
 906         // May be should be improved
 907         try {
 908             CloseDocument( true, false );
 909         } catch( const uno::Exception& )
 910         {}
 911     }
 912
 913     m_xComponent = xDoc;
 914
 915     m_bReadOnly = bReadOnly;
 916     m_bAllowClosing = false;
 917
 918     if ( m_xComponent.is() )
 919         m_xComponent->addCloseListener( static_cast<util::XCloseListener*>(this) );
 920
 921     uno::Reference< document::XEventBroadcaster > xEventBroadcaster( m_xComponent, uno::UNO_QUERY );
 922     if ( xEventBroadcaster.is() )
 923         xEventBroadcaster->addEventListener( static_cast<document::XEventListener*>(this) );
 924     else
 925     {
 926         // the object does not support document::XEventBroadcaster interface
 927         // use the workaround, register for modified events
 928         uno::Reference< util::XModifyBroadcaster > xModifyBroadcaster( m_xComponent, uno::UNO_QUERY );
 929         if ( xModifyBroadcaster.is() )
 930             xModifyBroadcaster->addModifyListener( static_cast<util::XModifyListener*>(this) );
 931     }
 932
 933     if ( m_xFrame.is() )
 934         LoadDocToFrame(false);
 935 }
 936
 937
 938 bool DocumentHolder::LoadDocToFrame( bool bInPlace )
 939 {
 940     if ( !m_xFrame || !m_xComponent )
 941         return true;
 942
 943     uno::Reference < frame::XModel > xDoc( m_xComponent, uno::UNO_QUERY );
 944     if ( xDoc.is() )
 945     {
 946         // load new document into the frame
 947         uno::Reference< frame::XComponentLoader > xComponentLoader( m_xFrame, uno::UNO_QUERY_THROW );
 948
 949         ::comphelper::NamedValueCollection aArgs;
 950         aArgs.put( "Model", m_xComponent );
 951         aArgs.put( "ReadOnly", m_bReadOnly );
 952
 953         // set document title to show in the title bar
 954         css::uno::Reference< css::frame::XTitle > xModelTitle( xDoc, css::uno::UNO_QUERY );
 955         if( xModelTitle.is() && m_pEmbedObj && !m_pEmbedObj->getContainerName().isEmpty() )
 956         {
 957             std::locale aResLoc = Translate::Create("sfx");
 958             OUString sEmbedded = Translate::get(STR_EMBEDDED_TITLE, aResLoc);
 959             xModelTitle->setTitle( m_pEmbedObj->getContainerName() + sEmbedded );
 960             m_aContainerName = m_pEmbedObj->getContainerName();
 961             // TODO: get real m_aDocumentNamePart
 962             m_aDocumentNamePart = sEmbedded;
 963         }
 964
 965         if ( bInPlace )
 966             aArgs.put( "PluginMode", sal_Int16(1) );
 967         OUString sUrl;
 968         uno::Reference< lang::XServiceInfo> xServiceInfo(xDoc,uno::UNO_QUERY);
 969         if (    xServiceInfo.is()
 970             &&  xServiceInfo->supportsService("com.sun.star.report.ReportDefinition") )
 971         {
 972             sUrl = ".component:DB/ReportDesign";
 973         }
 974         else if( xServiceInfo.is()
 975             &&   xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
 976             sUrl = "private:factory/schart";
 977         else
 978             sUrl = "private:object";
 979
 980         xComponentLoader->loadComponentFromURL( sUrl,
 981                                                     "_self",
 982                                                     0,
 983                                                     aArgs.getPropertyValues() );
 984
 985         return true;
 986     }
 987     else
 988     {
 989         uno::Reference < frame::XSynchronousFrameLoader > xLoader( m_xComponent, uno::UNO_QUERY );
 990         if ( xLoader.is() )
 991             return xLoader->load( uno::Sequence < beans::PropertyValue >(), m_xFrame );
 992         else
 993             return false;
 994     }
 995
 996     return true;
 997 }
 998
 999
1000 void DocumentHolder::Show()
1001 {
1002     if( m_xFrame.is() )
1003     {
1004         m_xFrame->activate();
1005         uno::Reference<awt::XTopWindow> xTopWindow( m_xFrame->getContainerWindow(), uno::UNO_QUERY );
1006         if( xTopWindow.is() )
1007             xTopWindow->toFront();
1008     }
1009     else
1010         GetDocFrame();
1011 }
1012
1013
1014 bool DocumentHolder::SetExtent( sal_Int64 nAspect, const awt::Size& aSize )
1015 {
1016     uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1017     if ( xDocVis.is() )
1018     {
1019         try
1020         {
1021             xDocVis->setVisualAreaSize( nAspect, aSize );
1022             return true;
1023         }
1024         catch( const uno::Exception& )
1025         {
1026             // TODO: Error handling
1027         }
1028     }
1029
1030     return false;
1031 }
1032
1033
1034 bool DocumentHolder::GetExtent( sal_Int64 nAspect, awt::Size *pSize )
1035 {
1036     uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1037     if ( pSize && xDocVis.is() )
1038     {
1039         try
1040         {
1041             *pSize = xDocVis->getVisualAreaSize( nAspect );
1042             return true;
1043         }
1044         catch( const uno::Exception& )
1045         {
1046             // TODO: Error handling
1047         }
1048     }
1049
1050     return false;
1051 }
1052
1053
1054 sal_Int32 DocumentHolder::GetMapUnit( sal_Int64 nAspect )
1055 {
1056     uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1057     if ( xDocVis.is() )
1058     {
1059         try
1060         {
1061             return xDocVis->getMapUnit( nAspect );
1062         }
1063         catch( const uno::Exception& )
1064         {
1065             // TODO: Error handling
1066         }
1067     }
1068
1069     return 0;
1070 }
1071
1072
1073 awt::Rectangle DocumentHolder::CalculateBorderedArea( const awt::Rectangle& aRect )
1074 {
1075     return awt::Rectangle( aRect.X + m_aBorderWidths.Left + HATCH_BORDER_WIDTH,
1076                              aRect.Y + m_aBorderWidths.Top + HATCH_BORDER_WIDTH,
1077                              aRect.Width - m_aBorderWidths.Left - m_aBorderWidths.Right - 2*HATCH_BORDER_WIDTH,
1078                              aRect.Height - m_aBorderWidths.Top - m_aBorderWidths.Bottom - 2*HATCH_BORDER_WIDTH );
1079 }
1080
1081
1082 awt::Rectangle DocumentHolder::AddBorderToArea( const awt::Rectangle& aRect )
1083 {
1084     return awt::Rectangle( aRect.X - m_aBorderWidths.Left - HATCH_BORDER_WIDTH,
1085                              aRect.Y - m_aBorderWidths.Top - HATCH_BORDER_WIDTH,
1086                              aRect.Width + m_aBorderWidths.Left + m_aBorderWidths.Right + 2*HATCH_BORDER_WIDTH,
1087                              aRect.Height + m_aBorderWidths.Top + m_aBorderWidths.Bottom + 2*HATCH_BORDER_WIDTH );
1088 }
1089
1090
1091 void SAL_CALL DocumentHolder::disposing( const css::lang::EventObject& aSource )
1092 {
1093     if ( m_xComponent.is() && m_xComponent == aSource.Source )
1094     {
1095         m_xComponent = nullptr;
1096         if ( m_bWaitForClose )
1097         {
1098             m_bWaitForClose = false;
1099             FreeOffice();
1100         }
1101     }
1102
1103     if( m_xFrame.is() && m_xFrame == aSource.Source )
1104     {
1105         m_xHatchWindow.clear();
1106         m_xOwnWindow.clear();
1107         m_xFrame.clear();
1108     }
1109 }
1110
1111
1112 void SAL_CALL DocumentHolder::queryClosing( const lang::EventObject& aSource, sal_Bool /*bGetsOwnership*/ )
1113 {
1114     if ( m_xComponent.is() && m_xComponent == aSource.Source && !m_bAllowClosing )
1115         throw util::CloseVetoException("To close an embedded document, close the document holder (document definition), not the document itself.", static_cast< ::cppu::OWeakObject*>(this));
1116 }
1117
1118
1119 void SAL_CALL DocumentHolder::notifyClosing( const lang::EventObject& aSource )
1120 {
1121     if ( m_xComponent.is() && m_xComponent == aSource.Source )
1122     {
1123         m_xComponent = nullptr;
1124         if ( m_bWaitForClose )
1125         {
1126             m_bWaitForClose = false;
1127             FreeOffice();
1128         }
1129     }
1130
1131     if( m_xFrame.is() && m_xFrame == aSource.Source )
1132     {
1133         m_xHatchWindow.clear();
1134         m_xOwnWindow.clear();
1135         m_xFrame.clear();
1136     }
1137 }
1138
1139
1140 void SAL_CALL DocumentHolder::queryTermination( const lang::EventObject& )
1141 {
1142     if ( m_bWaitForClose )
1143         throw frame::TerminationVetoException();
1144 }
1145
1146
1147 void SAL_CALL DocumentHolder::notifyTermination( const lang::EventObject& aSource )
1148 {
1149     OSL_ENSURE( !m_xComponent.is(), "Just a disaster..." );
1150
1151     uno::Reference< frame::XDesktop > xDesktop( aSource.Source, uno::UNO_QUERY );
1152     m_bDesktopTerminated = true;
1153     if ( xDesktop.is() )
1154         xDesktop->removeTerminateListener( static_cast<frame::XTerminateListener*>(this) );
1155 }
1156
1157
1158 void SAL_CALL DocumentHolder::modified( const lang::EventObject& aEvent )
1159 {
1160     // if the component does not support document::XEventBroadcaster
1161     // the modify notifications are used as workaround, but only for running state
1162     if( aEvent.Source == m_xComponent && m_pEmbedObj && m_pEmbedObj->getCurrentState() == embed::EmbedStates::RUNNING )
1163         m_pEmbedObj->PostEvent_Impl( "OnVisAreaChanged" );
1164 }
1165
1166
1167 void SAL_CALL DocumentHolder::notifyEvent( const document::EventObject& Event )
1168 {
1169     if( m_pEmbedObj && Event.Source == m_xComponent )
1170     {
1171         // for now the ignored events are not forwarded, but sent by the object itself
1172         if ( !Event.EventName.startsWith( "OnSave" )
1173           && !Event.EventName.startsWith( "OnSaveDone" )
1174           && !Event.EventName.startsWith( "OnSaveAs" )
1175           && !Event.EventName.startsWith( "OnSaveAsDone" )
1176           && !( Event.EventName.startsWith( "OnVisAreaChanged" ) && m_nNoResizeReact ) )
1177             m_pEmbedObj->PostEvent_Impl( Event.EventName );
1178     }
1179 }
1180
1181
1182 void SAL_CALL DocumentHolder::borderWidthsChanged( const uno::Reference< uno::XInterface >& aObject,
1183                                                     const frame::BorderWidths& aNewSize )
1184 {
1185     // TODO: may require mutex introduction ???
1186     if ( m_pEmbedObj && m_xFrame.is() && aObject == m_xFrame->getController() )
1187     {
1188         if ( m_aBorderWidths.Left != aNewSize.Left
1189           || m_aBorderWidths.Right != aNewSize.Right
1190           || m_aBorderWidths.Top != aNewSize.Top
1191           || m_aBorderWidths.Bottom != aNewSize.Bottom )
1192         {
1193             m_aBorderWidths = aNewSize;
1194             if ( !m_nNoBorderResizeReact )
1195                 PlaceFrame( m_aObjRect );
1196         }
1197     }
1198 }
1199
1200
1201 void SAL_CALL DocumentHolder::requestPositioning( const awt::Rectangle& aRect )
1202 {
1203     // TODO: may require mutex introduction ???
1204     if ( m_pEmbedObj )
1205     {
1206         // borders should not be counted
1207         awt::Rectangle aObjRect = CalculateBorderedArea( aRect );
1208         IntCounterGuard aGuard( m_nNoResizeReact );
1209         m_pEmbedObj->requestPositioning( aObjRect );
1210     }
1211 }
1212
1213
1214 awt::Rectangle SAL_CALL DocumentHolder::calcAdjustedRectangle( const awt::Rectangle& aRect )
1215 {
1216     // Solar mutex should be locked already since this is a call from HatchWindow with focus
1217     awt::Rectangle aResult( aRect );
1218
1219     if ( m_xFrame.is() )
1220     {
1221         // borders should not be counted
1222         uno::Reference< frame::XControllerBorder > xControllerBorder( m_xFrame->getController(), uno::UNO_QUERY );
1223         if ( xControllerBorder.is() )
1224         {
1225             awt::Rectangle aObjRect = CalculateBorderedArea( aRect );
1226             aObjRect = xControllerBorder->queryBorderedArea( aObjRect );
1227             aResult = AddBorderToArea( aObjRect );
1228         }
1229     }
1230
1231     awt::Rectangle aMinRectangle = AddBorderToArea( awt::Rectangle() );
1232     if ( aResult.Width < aMinRectangle.Width + 2 )
1233         aResult.Width = aMinRectangle.Width + 2;
1234     if ( aResult.Height < aMinRectangle.Height + 2 )
1235         aResult.Height = aMinRectangle.Height + 2;
1236
1237     return aResult;
1238 }
1239
1240 void SAL_CALL DocumentHolder::activated(  )
1241 {
1242     if ( !(m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE) )
1243         return;
1244
1245     if ( m_pEmbedObj->getCurrentState() != embed::EmbedStates::UI_ACTIVE &&
1246     !(m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_NOUIACTIVATE) )
1247     {
1248         try
1249         {
1250             m_pEmbedObj->changeState( embed::EmbedStates::UI_ACTIVE );
1251         }
1252         catch ( const css::embed::StateChangeInProgressException& )
1253         {
1254             // must catch this exception because focus is grabbed while UI activation in doVerb()
1255         }
1256         catch ( const css::uno::Exception& )
1257         {
1258             // no outgoing exceptions specified here
1259         }
1260     }
1261     else
1262     {
1263         uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
1264         if ( xSupp.is() )
1265             xSupp->setActiveFrame( m_xFrame );
1266     }
1267 }
1268
1269 void DocumentHolder::ResizeHatchWindow()
1270 {
1271     awt::Rectangle aHatchRect = AddBorderToArea( m_aObjRect );
1272     ResizeWindows_Impl( aHatchRect );
1273     uno::Reference< embed::XHatchWindow > xHatchWindow( m_xHatchWindow, uno::UNO_QUERY );
1274     xHatchWindow->setHatchBorderSize( awt::Size( HATCH_BORDER_WIDTH, HATCH_BORDER_WIDTH ) );
1275 }
1276
1277 void SAL_CALL DocumentHolder::deactivated(  )
1278 {
1279     // deactivation is too unspecific to be useful; usually we only trigger code from activation
1280     // so UIDeactivation is actively triggered by the container
1281 }
1282
1283 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */