sfx2/source/view/frame.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/uno/Reference.h>
  21 #include <com/sun/star/awt/XTopWindow.hpp>
  22 #include <com/sun/star/awt/XWindow.hpp>
  23 #include <com/sun/star/util/XCloseable.hpp>
  24 #include <com/sun/star/util/CloseVetoException.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <com/sun/star/lang/XUnoTunnel.hpp>
  27 #include <com/sun/star/container/XChild.hpp>
  28 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  29
  30 #include <vcl/menu.hxx>
  31 #include <svl/intitem.hxx>
  32 #include <svl/stritem.hxx>
  33 #include <tools/svborder.hxx>
  34 #include <osl/diagnose.h>
  35
  36 #include <appdata.hxx>
  37 #include <sfx2/app.hxx>
  38 #include <sfx2/event.hxx>
  39 #include <sfx2/frame.hxx>
  40 #include <sfx2/objsh.hxx>
  41 #include <sfx2/dispatch.hxx>
  42 #include <sfx2/docfile.hxx>
  43 #include <sfx2/docfilt.hxx>
  44 #include <sfx2/frmdescr.hxx>
  45 #include <sfx2/sfxsids.hrc>
  46 #include <sfx2/viewsh.hxx>
  47 #include <sfx2/viewfrm.hxx>
  48 #include "impframe.hxx"
  49 #include <workwin.hxx>
  50 #include <sfx2/ipclient.hxx>
  51 #include <vector>
  52
  53 using namespace com::sun::star;
  54
  55 static std::vector<SfxFrame*>* pFramesArr_Impl=nullptr;
  56
  57 using namespace ::com::sun::star::uno;
  58 using namespace ::com::sun::star::util;
  59 using namespace ::com::sun::star::frame;
  60 using namespace ::com::sun::star::container;
  61
  62 SfxPoolItem* SfxUnoAnyItem::CreateDefault()
  63 {
  64     return new SfxUnoAnyItem();
  65 }
  66
  67 SfxPoolItem* SfxUnoFrameItem::CreateDefault()
  68 {
  69     return new SfxUnoFrameItem();
  70 }
  71
  72 void SfxFrame::Construct_Impl()
  73 {
  74     pImpl.reset(new SfxFrame_Impl);
  75     if ( !pFramesArr_Impl )
  76         pFramesArr_Impl = new std::vector<SfxFrame*>;
  77     pFramesArr_Impl->push_back( this );
  78 }
  79
  80
  81 SfxFrame::~SfxFrame()
  82 {
  83     RemoveTopFrame_Impl( this );
  84     pWindow.disposeAndClear();
  85
  86     auto it = std::find( pFramesArr_Impl->begin(), pFramesArr_Impl->end(), this );
  87     if ( it != pFramesArr_Impl->end() )
  88         pFramesArr_Impl->erase( it );
  89
  90     delete pImpl->pDescr;
  91 }
  92
  93 bool SfxFrame::DoClose()
  94 {
  95     // Actually, one more PrepareClose is still needed!
  96     bool bRet = false;
  97     if ( !pImpl->bClosing )
  98     {
  99         pImpl->bClosing = true;
 100         CancelTransfers();
 101
 102         // now close frame; it will be deleted if this call is successful, so don't use any members after that!
 103         bRet = true;
 104         try
 105         {
 106             Reference< XCloseable > xCloseable  ( pImpl->xFrame, UNO_QUERY );
 107             if (xCloseable.is())
 108                 xCloseable->close(true);
 109             else if ( pImpl->xFrame.is() )
 110             {
 111                 Reference < XFrame > xFrame = pImpl->xFrame;
 112                 xFrame->setComponent( Reference < css::awt::XWindow >(), Reference < XController >() );
 113                 xFrame->dispose();
 114             }
 115             else
 116                 DoClose_Impl();
 117         }
 118         catch( css::util::CloseVetoException& )
 119         {
 120             pImpl->bClosing = false;
 121             bRet = false;
 122         }
 123         catch( css::lang::DisposedException& )
 124         {
 125         }
 126     }
 127
 128     return bRet;
 129 }
 130
 131 void SfxFrame::DoClose_Impl()
 132 {
 133     SfxBindings* pBindings = nullptr;
 134     if ( pImpl->pCurrentViewFrame )
 135         pBindings = &pImpl->pCurrentViewFrame->GetBindings();
 136
 137     // For internal tasks Controllers and Tools must be cleared
 138     if ( pImpl->pWorkWin )
 139         pImpl->pWorkWin->DeleteControllers_Impl();
 140
 141     if ( pImpl->pCurrentViewFrame )
 142         pImpl->pCurrentViewFrame->Close();
 143
 144     if ( pImpl->bOwnsBindings )
 145     {
 146         delete pBindings;
 147         pBindings = nullptr;
 148     }
 149
 150     delete this;
 151 }
 152
 153 bool SfxFrame::DocIsModified_Impl()
 154 {
 155     return pImpl->pCurrentViewFrame && pImpl->pCurrentViewFrame->GetObjectShell() &&
 156             pImpl->pCurrentViewFrame->GetObjectShell()->IsModified();
 157 }
 158
 159 bool SfxFrame::PrepareClose_Impl( bool bUI )
 160 {
 161     bool bRet = true;
 162
 163     // prevent recursive calls
 164     if( !pImpl->bPrepClosing )
 165     {
 166         pImpl->bPrepClosing = true;
 167
 168         SfxObjectShell* pCur = GetCurrentDocument() ;
 169         if( pCur )
 170         {
 171             // SFX components have a known behaviour
 172             // First check if this frame is the only view to its current document
 173             bool bOther = false;
 174             for ( const SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pCur );
 175                     !bOther && pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, pCur ) )
 176             {
 177                 bOther = ( &pFrame->GetFrame() != this );
 178             }
 179
 180             SfxGetpApp()->NotifyEvent( SfxViewEventHint(SfxEventHintId::PrepareCloseView, GlobalEventConfig::GetEventName( GlobalEventId::PREPARECLOSEVIEW ), pCur, GetController() ) );
 181
 182             if ( bOther )
 183                 // if there are other views only the current view of this frame must be asked
 184                 bRet = GetCurrentViewFrame()->GetViewShell()->PrepareClose( bUI );
 185             else
 186                 // otherwise ask the document
 187                 bRet = pCur->PrepareClose( bUI );
 188         }
 189
 190         pImpl->bPrepClosing = false;
 191     }
 192
 193     if ( bRet && pImpl->pWorkWin )
 194         // if closing was accepted by the component the UI subframes must be asked also
 195         bRet = pImpl->pWorkWin->PrepareClose_Impl();
 196
 197     return bRet;
 198 }
 199
 200
 201 bool SfxFrame::IsClosing_Impl() const
 202 {
 203     return pImpl->bClosing;
 204 }
 205
 206 void SfxFrame::SetIsClosing_Impl()
 207 {
 208     pImpl->bClosing = true;
 209 }
 210
 211 void SfxFrame::CancelTransfers()
 212 {
 213     if( pImpl->bInCancelTransfers )
 214         return;
 215
 216     pImpl->bInCancelTransfers = true;
 217     SfxObjectShell* pObj = GetCurrentDocument();
 218     if( pObj ) //&& !( pObj->Get_Impl()->nLoadedFlags & SfxLoadedFlags::ALL ))
 219     {
 220         SfxViewFrame* pFrm;
 221         for( pFrm = SfxViewFrame::GetFirst( pObj );
 222              pFrm && &pFrm->GetFrame() == this;
 223              pFrm = SfxViewFrame::GetNext( *pFrm, pObj ) ) ;
 224         // No more Frame in Document -> Cancel
 225         if( !pFrm )
 226         {
 227             pObj->CancelTransfers();
 228             GetCurrentDocument()->Broadcast( SfxHint(SfxHintId::TitleChanged) );
 229         }
 230     }
 231
 232     //  Check if StarOne-Loader should be canceled
 233     SfxFrameWeakRef wFrame( this );
 234     if (wFrame.is())
 235         pImpl->bInCancelTransfers = false;
 236 }
 237
 238 SfxViewFrame* SfxFrame::GetCurrentViewFrame() const
 239 {
 240     return pImpl->pCurrentViewFrame;
 241 }
 242
 243 bool SfxFrame::IsAutoLoadLocked_Impl() const
 244 {
 245     // Its own Document is locked?
 246     const SfxObjectShell* pObjSh = GetCurrentDocument();
 247     if ( !pObjSh || !pObjSh->IsAutoLoadLocked() )
 248         return false;
 249
 250     // otherwise allow AutoLoad
 251     return true;
 252 }
 253
 254 SfxObjectShell* SfxFrame::GetCurrentDocument() const
 255 {
 256     return pImpl->pCurrentViewFrame ?
 257             pImpl->pCurrentViewFrame->GetObjectShell() :
 258             nullptr;
 259 }
 260
 261 void SfxFrame::SetCurrentViewFrame_Impl( SfxViewFrame *pFrame )
 262 {
 263     pImpl->pCurrentViewFrame = pFrame;
 264 }
 265
 266 bool SfxFrame::GetHasTitle() const
 267 {
 268     return pImpl->mbHasTitle;
 269 }
 270
 271 void SfxFrame::SetHasTitle( bool n )
 272 {
 273     pImpl->mbHasTitle = n;
 274 }
 275
 276 void SfxFrame::GetViewData_Impl()
 277 {
 278     // Update all modifiable data between load and unload, the
 279     // fixed data is only processed once (after PrepareForDoc_Impl in
 280     // updateDescriptor) to save time.
 281
 282     SfxViewFrame* pViewFrame = GetCurrentViewFrame();
 283     if( pViewFrame && pViewFrame->GetViewShell() )
 284     {
 285         SfxItemSet *pSet = GetDescriptor()->GetArgs();
 286         if ( GetController().is() && pSet->GetItemState( SID_VIEW_DATA ) != SfxItemState::SET )
 287         {
 288             css::uno::Any aData = GetController()->getViewData();
 289             pSet->Put( SfxUnoAnyItem( SID_VIEW_DATA, aData ) );
 290         }
 291
 292         if ( pViewFrame->GetCurViewId() )
 293             pSet->Put( SfxUInt16Item( SID_VIEW_ID, static_cast<sal_uInt16>(pViewFrame->GetCurViewId()) ) );
 294     }
 295 }
 296
 297 void SfxFrame::UpdateDescriptor( SfxObjectShell const *pDoc )
 298 {
 299     // For PrepareForDoc_Impl frames, the descriptor of the updated
 300     // and new itemset to be initialized. All data fir restoring the view
 301     // are thus saved. If the document be replaced, GetViewData_Impl (so)
 302     // the latest information hinzugef by "added. All together then the
 303     // browser-history saved in. When you activate such frame pick entry
 304     // is complete itemsets and the descriptor in the OpenDoc sent;.
 305     // Here only the fixed properties identified "other adjustable, the
 306     // retrieved by GetViewData (saves time).
 307
 308     assert(pDoc && "NULL-Document inserted ?!");
 309
 310     const SfxMedium *pMed = pDoc->GetMedium();
 311     GetDescriptor()->SetActualURL();
 312
 313     // Mark FileOpen parameter
 314     SfxItemSet* pItemSet = pMed->GetItemSet();
 315
 316     const std::shared_ptr<const SfxFilter>& pFilter = pMed->GetFilter();
 317     OUString aFilter;
 318     if ( pFilter )
 319         aFilter = pFilter->GetFilterName();
 320
 321     const SfxStringItem* pRefererItem = SfxItemSet::GetItem<SfxStringItem>(pItemSet, SID_REFERER, false);
 322     const SfxStringItem* pOptionsItem = SfxItemSet::GetItem<SfxStringItem>(pItemSet, SID_FILE_FILTEROPTIONS, false);
 323     const SfxStringItem* pTitle1Item = SfxItemSet::GetItem<SfxStringItem>(pItemSet, SID_DOCINFO_TITLE, false);
 324
 325     SfxItemSet *pSet = GetDescriptor()->GetArgs();
 326
 327     // Delete all old Items
 328     pSet->ClearItem();
 329
 330     if ( pRefererItem )
 331         pSet->Put( *pRefererItem );
 332     else
 333         pSet->Put( SfxStringItem( SID_REFERER, OUString() ) );
 334
 335     if ( pOptionsItem )
 336         pSet->Put( *pOptionsItem );
 337
 338     if ( pTitle1Item )
 339         pSet->Put( *pTitle1Item );
 340
 341     pSet->Put( SfxStringItem( SID_FILTER_NAME, aFilter ));
 342 }
 343
 344
 345 SfxFrameDescriptor* SfxFrame::GetDescriptor() const
 346 {
 347     // Create a FrameDescriptor On Demand; if there is no TopLevel-Frame
 348     // will result in an error, as no valid link is created.
 349
 350     if ( !pImpl->pDescr )
 351     {
 352         DBG_ASSERT( true, "No TopLevel-Frame, but no Descriptor!" );
 353         pImpl->pDescr = new SfxFrameDescriptor;
 354         if ( GetCurrentDocument() )
 355             pImpl->pDescr->SetURL( GetCurrentDocument()->GetMedium()->GetOrigURL() );
 356     }
 357     return pImpl->pDescr;
 358 }
 359
 360 void SfxFrame::GetDefaultTargetList(TargetList& rList)
 361 {
 362     // An empty string for 'No Target'
 363     rList.emplace_back( );
 364     rList.emplace_back( "_top" );
 365     rList.emplace_back( "_parent" );
 366     rList.emplace_back( "_blank" );
 367     rList.emplace_back( "_self" );
 368 }
 369
 370 void SfxFrame::InsertTopFrame_Impl( SfxFrame* pFrame )
 371 {
 372     auto& rArr = SfxGetpApp()->Get_Impl()->vTopFrames;
 373     rArr.push_back( pFrame );
 374 }
 375
 376 void SfxFrame::RemoveTopFrame_Impl( SfxFrame* pFrame )
 377 {
 378     auto& rArr = SfxGetpApp()->Get_Impl()->vTopFrames;
 379     auto it = std::find( rArr.begin(), rArr.end(), pFrame );
 380     if ( it != rArr.end() )
 381         rArr.erase( it );
 382 }
 383
 384 SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxViewFrame const *p )
 385     : SfxPoolItem( nWhichId ), pFrame( p ? &p->GetFrame() : nullptr )
 386 {
 387     wFrame = pFrame;
 388 }
 389
 390 SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxFrame *p ):
 391     SfxPoolItem( nWhichId ),
 392     pFrame( p ), wFrame( p )
 393 {
 394 }
 395
 396 SfxFrameItem::SfxFrameItem( SfxFrame *p ):
 397     SfxPoolItem( 0 ),
 398     pFrame( p ), wFrame( p )
 399 {
 400 }
 401
 402 bool SfxFrameItem::operator==( const SfxPoolItem &rItem ) const
 403 {
 404      return SfxPoolItem::operator==(rItem) &&
 405         static_cast<const SfxFrameItem&>(rItem).pFrame == pFrame &&
 406         static_cast<const SfxFrameItem&>(rItem).wFrame == wFrame;
 407 }
 408
 409 SfxFrameItem* SfxFrameItem::Clone( SfxItemPool *) const
 410 {
 411     SfxFrameItem* pNew = new SfxFrameItem( wFrame);
 412     pNew->pFrame = pFrame;
 413     return pNew;
 414 }
 415
 416 bool SfxFrameItem::QueryValue( css::uno::Any& rVal, sal_uInt8 ) const
 417 {
 418     if ( wFrame )
 419     {
 420         rVal <<= wFrame->GetFrameInterface();
 421         return true;
 422     }
 423
 424     return false;
 425 }
 426
 427 bool SfxFrameItem::PutValue( const css::uno::Any& rVal, sal_uInt8 )
 428 {
 429     Reference < XFrame > xFrame;
 430     if ( (rVal >>= xFrame) && xFrame.is() )
 431     {
 432         SfxFrame* pFr = SfxFrame::GetFirst();
 433         while ( pFr )
 434         {
 435             if ( pFr->GetFrameInterface() == xFrame )
 436             {
 437                 wFrame = pFrame = pFr;
 438                 return true;
 439             }
 440
 441             pFr = SfxFrame::GetNext( *pFr );
 442         }
 443         return true;
 444     }
 445
 446     return false;
 447 }
 448
 449 SfxUnoAnyItem::SfxUnoAnyItem()
 450     : SfxPoolItem( 0 )
 451 {
 452 }
 453
 454 SfxUnoAnyItem::SfxUnoAnyItem( sal_uInt16 nWhichId, const css::uno::Any& rAny )
 455     : SfxPoolItem( nWhichId )
 456 {
 457     aValue = rAny;
 458 }
 459
 460 bool SfxUnoAnyItem::operator==( const SfxPoolItem& rItem ) const
 461 {
 462     assert(SfxPoolItem::operator==(rItem)); (void)rItem;
 463     return false;
 464 }
 465
 466 SfxUnoAnyItem* SfxUnoAnyItem::Clone( SfxItemPool *) const
 467 {
 468     return new SfxUnoAnyItem( *this );
 469 }
 470
 471 bool SfxUnoAnyItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 472 {
 473     rVal = aValue;
 474     return true;
 475 }
 476
 477 bool SfxUnoAnyItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 478 {
 479     aValue = rVal;
 480     return true;
 481 }
 482
 483 SfxUnoFrameItem::SfxUnoFrameItem()
 484     : SfxPoolItem()
 485     , m_xFrame()
 486 {
 487 }
 488
 489 SfxUnoFrameItem::SfxUnoFrameItem( sal_uInt16 nWhichId, const css::uno::Reference< css::frame::XFrame >& i_rFrame )
 490     : SfxPoolItem( nWhichId )
 491     , m_xFrame( i_rFrame )
 492 {
 493 }
 494
 495 bool SfxUnoFrameItem::operator==( const SfxPoolItem& i_rItem ) const
 496 {
 497     return SfxPoolItem::operator==(i_rItem) &&
 498         static_cast< const SfxUnoFrameItem& >( i_rItem ).m_xFrame == m_xFrame;
 499 }
 500
 501 SfxUnoFrameItem* SfxUnoFrameItem::Clone( SfxItemPool* ) const
 502 {
 503     return new SfxUnoFrameItem( *this );
 504 }
 505
 506 bool SfxUnoFrameItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 507 {
 508     rVal <<= m_xFrame;
 509     return true;
 510 }
 511
 512 bool SfxUnoFrameItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 513 {
 514     return ( rVal >>= m_xFrame );
 515 }
 516
 517 css::uno::Reference< css::frame::XController > SfxFrame::GetController() const
 518 {
 519     if ( pImpl->pCurrentViewFrame && pImpl->pCurrentViewFrame->GetViewShell() )
 520         return pImpl->pCurrentViewFrame->GetViewShell()->GetController();
 521     else
 522         return css::uno::Reference< css::frame::XController > ();
 523 }
 524
 525 const css::uno::Reference< css::frame::XFrame >&  SfxFrame::GetFrameInterface() const
 526 {
 527     return pImpl->xFrame;
 528 }
 529
 530 void SfxFrame::SetFrameInterface_Impl( const css::uno::Reference< css::frame::XFrame >& rFrame )
 531 {
 532     pImpl->xFrame = rFrame;
 533     css::uno::Reference< css::frame::XDispatchRecorder > xRecorder;
 534     if ( !rFrame.is() && GetCurrentViewFrame() )
 535         GetCurrentViewFrame()->GetBindings().SetRecorder_Impl( xRecorder );
 536 }
 537
 538 void SfxFrame::Appear()
 539 {
 540     if ( GetCurrentViewFrame() )
 541     {
 542         GetCurrentViewFrame()->Show();
 543         GetWindow().Show();
 544         pImpl->xFrame->getContainerWindow()->setVisible( true );
 545         Reference < css::awt::XTopWindow > xTopWindow( pImpl->xFrame->getContainerWindow(), UNO_QUERY );
 546         if ( xTopWindow.is() )
 547             xTopWindow->toFront();
 548     }
 549 }
 550
 551 void SfxFrame::AppearWithUpdate()
 552 {
 553     Appear();
 554     if ( GetCurrentViewFrame() )
 555         GetCurrentViewFrame()->GetDispatcher()->Update_Impl( true );
 556 }
 557
 558 void SfxFrame::SetOwnsBindings_Impl( bool bSet )
 559 {
 560     pImpl->bOwnsBindings = bSet;
 561 }
 562
 563 bool SfxFrame::OwnsBindings_Impl() const
 564 {
 565     return pImpl->bOwnsBindings;
 566 }
 567
 568 void SfxFrame::SetToolSpaceBorderPixel_Impl( const SvBorder& rBorder )
 569 {
 570     pImpl->aBorder = rBorder;
 571     SfxViewFrame *pF = GetCurrentViewFrame();
 572     if ( !pF )
 573         return;
 574
 575     Point aPos ( rBorder.Left(), rBorder.Top() );
 576     Size aSize( GetWindow().GetOutputSizePixel() );
 577     tools::Long nDeltaX = rBorder.Left() + rBorder.Right();
 578     if ( aSize.Width() > nDeltaX )
 579         aSize.AdjustWidth( -nDeltaX );
 580     else
 581         aSize.setWidth( 0 );
 582
 583     tools::Long nDeltaY = rBorder.Top() + rBorder.Bottom();
 584     if ( aSize.Height() > nDeltaY )
 585         aSize.AdjustHeight( -nDeltaY );
 586     else
 587         aSize.setHeight( 0 );
 588
 589     pF->GetWindow().SetPosSizePixel( aPos, aSize );
 590 }
 591
 592 tools::Rectangle SfxFrame::GetTopOuterRectPixel_Impl() const
 593 {
 594     Size aSize( GetWindow().GetOutputSizePixel() );
 595     return tools::Rectangle( Point(), aSize );
 596 }
 597
 598 SfxWorkWindow* SfxFrame::GetWorkWindow_Impl() const
 599 {
 600     if ( pImpl->pWorkWin )
 601         return pImpl->pWorkWin;
 602     else
 603         return nullptr;
 604 }
 605
 606 void SfxFrame::CreateWorkWindow_Impl()
 607 {
 608     SfxFrame* pFrame = this;
 609
 610     if ( IsInPlace() )
 611     {
 612         // this makes sense only for inplace activated objects
 613         try
 614         {
 615             Reference < XChild > xChild( GetCurrentDocument()->GetModel(), UNO_QUERY );
 616             if ( xChild.is() )
 617             {
 618                 Reference < XModel > xParent( xChild->getParent(), UNO_QUERY );
 619                 if ( xParent.is() )
 620                 {
 621                     Reference< XController > xParentCtrler = xParent->getCurrentController();
 622                     if ( xParentCtrler.is() )
 623                     {
 624                         Reference < XFrame > xFrame( xParentCtrler->getFrame() );
 625                         SfxFrame* pFr = SfxFrame::GetFirst();
 626                         while ( pFr )
 627                         {
 628                             if ( pFr->GetFrameInterface() == xFrame )
 629                             {
 630                                 pFrame = pFr;
 631                                 break;
 632                             }
 633
 634                             pFr = SfxFrame::GetNext( *pFr );
 635                         }
 636                     }
 637                 }
 638             }
 639         }
 640         catch(Exception&)
 641         {
 642             OSL_FAIL("SfxFrame::CreateWorkWindow_Impl: Exception caught. Please try to submit a reproducible bug!");
 643         }
 644     }
 645
 646     pImpl->pWorkWin = new SfxWorkWindow( &pFrame->GetWindow(), this, pFrame );
 647 }
 648
 649 void SfxFrame::GrabFocusOnComponent_Impl()
 650 {
 651     if ( pImpl->bReleasingComponent )
 652     {
 653         GetWindow().GrabFocus();
 654         return;
 655     }
 656
 657     vcl::Window* pFocusWindow = &GetWindow();
 658     if ( GetCurrentViewFrame() && GetCurrentViewFrame()->GetViewShell() && GetCurrentViewFrame()->GetViewShell()->GetWindow() )
 659         pFocusWindow = GetCurrentViewFrame()->GetViewShell()->GetWindow();
 660
 661     if( !pFocusWindow->HasChildPathFocus() )
 662         pFocusWindow->GrabFocus();
 663 }
 664
 665 void SfxFrame::ReleasingComponent_Impl()
 666 {
 667     pImpl->bReleasingComponent = true;
 668 }
 669
 670 bool SfxFrame::IsInPlace() const
 671 {
 672     return pImpl->bInPlace;
 673 }
 674
 675 void SfxFrame::Resize()
 676 {
 677     if ( IsClosing_Impl() )
 678         return;
 679
 680     if ( OwnsBindings_Impl() )
 681     {
 682         if ( IsInPlace() )
 683         {
 684             SetToolSpaceBorderPixel_Impl( SvBorder() );
 685         }
 686         else
 687         {
 688             // check for IPClient that contains UIactive object or object that is currently UI activating
 689             SfxWorkWindow *pWork = GetWorkWindow_Impl();
 690             SfxInPlaceClient* pClient = GetCurrentViewFrame()->GetViewShell() ? GetCurrentViewFrame()->GetViewShell()->GetUIActiveIPClient_Impl() : nullptr;
 691             if ( pClient )
 692             {
 693                 SfxObjectShell* pDoc
 694                     = SfxObjectShell::GetShellFromComponent(pClient->GetObject()->getComponent());
 695                 SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDoc);
 696                 pWork = pFrame ? pFrame->GetFrame().GetWorkWindow_Impl() : nullptr;
 697             }
 698
 699             if ( pWork )
 700             {
 701                 pWork->ArrangeChildren_Impl();
 702                 pWork->ShowChildren_Impl();
 703             }
 704
 705             // problem in presence of UIActive object: when the window is resized, but the toolspace border
 706             // remains the same, setting the toolspace border at the ContainerEnvironment doesn't force a
 707             // resize on the IPEnvironment; without that no resize is called for the SfxViewFrame. So always
 708             // set the window size of the SfxViewFrame explicit.
 709             SetToolSpaceBorderPixel_Impl( pImpl->aBorder );
 710         }
 711     }
 712     else if ( pImpl->pCurrentViewFrame )
 713     {
 714         pImpl->pCurrentViewFrame->GetWindow().SetSizePixel( GetWindow().GetOutputSizePixel() );
 715     }
 716
 717 }
 718
 719 SfxFrame* SfxFrame::GetFirst()
 720 {
 721     if ( !pFramesArr_Impl )
 722         return nullptr;
 723     return pFramesArr_Impl->empty() ? nullptr : pFramesArr_Impl->front();
 724 }
 725
 726 SfxFrame* SfxFrame::GetNext( SfxFrame& rFrame )
 727 {
 728     auto it = std::find( pFramesArr_Impl->begin(), pFramesArr_Impl->end(), &rFrame );
 729     if ( it != pFramesArr_Impl->end() && (++it) != pFramesArr_Impl->end() )
 730         return *it;
 731     else
 732         return nullptr;
 733 }
 734
 735 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */