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