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/embed/EmbedStates.hpp>
  21 #include <com/sun/star/uno/Reference.h>
  22 #include <com/sun/star/awt/XWindow.hpp>
  23 #include <com/sun/star/util/XURLTransformer.hpp>
  24 #include <com/sun/star/util/XCloseable.hpp>
  25 #include <com/sun/star/util/CloseVetoException.hpp>
  26 #include <com/sun/star/lang/XComponent.hpp>
  27 #include <com/sun/star/lang/DisposedException.hpp>
  28 #include <com/sun/star/container/XChild.hpp>
  29
  30 #include <vcl/menu.hxx>
  31 #include <svl/intitem.hxx>
  32 #include <vcl/splitwin.hxx>
  33 #include <svl/eitem.hxx>
  34 #include <svl/stritem.hxx>
  35 #include <toolkit/helper/vclunohelper.hxx>
  36 #include <com/sun/star/awt/PosSize.hpp>
  37 #include <comphelper/processfactory.hxx>
  38 #include <vcl/msgbox.hxx>
  39
  40 // due to pTopFrames
  41 #include "appdata.hxx"
  42 #include <sfx2/app.hxx>
  43 #include <sfx2/event.hxx>
  44 #include <sfx2/unoctitm.hxx>
  45 #include <sfx2/frame.hxx>
  46 #include "arrdecl.hxx"
  47 #include <sfx2/objsh.hxx>
  48 #include <sfx2/dispatch.hxx>
  49 #include <sfx2/docfile.hxx>
  50 #include <sfx2/docfilt.hxx>
  51 #include <sfx2/frmdescr.hxx>
  52 #include "openflag.hxx"
  53 #include <sfx2/viewsh.hxx>
  54 #include <sfx2/viewfrm.hxx>
  55 #include <sfx2/request.hxx>
  56 #include <sfx2/fcontnr.hxx>
  57 #include "impframe.hxx"
  58 #include "workwin.hxx"
  59 #include <sfx2/sfxuno.hxx>
  60 #include <sfx2/msgpool.hxx>
  61 #include "objshimp.hxx"
  62 #include <sfx2/ipclient.hxx>
  63 #include <childwinimpl.hxx>
  64
  65 #ifdef DBG_UTIL
  66 #include <sfx2/frmhtmlw.hxx>
  67 #endif
  68
  69 using namespace com::sun::star;
  70
  71 static SfxFrameArr_Impl* pFramesArr_Impl=0;
  72
  73 using namespace ::com::sun::star::uno;
  74 using namespace ::com::sun::star::util;
  75 using namespace ::com::sun::star::frame;
  76 using namespace ::com::sun::star::container;
  77
  78 TYPEINIT1(SfxFrame, SfxListener);
  79 TYPEINIT1_AUTOFACTORY(SfxFrameItem, SfxPoolItem);
  80 TYPEINIT1(SfxUsrAnyItem, SfxPoolItem);
  81 TYPEINIT1_AUTOFACTORY(SfxUnoFrameItem, SfxPoolItem);
  82
  83 void SfxFrame::Construct_Impl()
  84 {
  85     pImp = new SfxFrame_Impl( this );
  86     if ( !pFramesArr_Impl )
  87         pFramesArr_Impl = new SfxFrameArr_Impl;
  88     pFramesArr_Impl->push_back( this );
  89 }
  90
  91
  92
  93 SfxFrame::~SfxFrame()
  94 {
  95     RemoveTopFrame_Impl( this );
  96     pWindow.disposeAndClear();
  97
  98     SfxFrameArr_Impl::iterator it = std::find( pFramesArr_Impl->begin(), pFramesArr_Impl->end(), this );
  99     if ( it != pFramesArr_Impl->end() )
 100         pFramesArr_Impl->erase( it );
 101
 102     if ( pParentFrame )
 103     {
 104         pParentFrame->RemoveChildFrame_Impl( this );
 105         pParentFrame = 0;
 106     }
 107
 108     delete pImp->pDescr;
 109
 110     if ( pChildArr )
 111     {
 112         DBG_ASSERT( pChildArr->empty(), "Children are not removed!" );
 113         delete pChildArr;
 114     }
 115
 116     delete pImp;
 117 }
 118
 119 bool SfxFrame::DoClose()
 120 {
 121     // Actually, one more PrepareClose is still needed!
 122     bool bRet = false;
 123     if ( !pImp->bClosing )
 124     {
 125         pImp->bClosing = true;
 126         CancelTransfers();
 127
 128         // now close frame; it will be deleted if this call is successful, so don't use any members after that!
 129         bRet = true;
 130         try
 131         {
 132             Reference< XCloseable > xCloseable  ( pImp->xFrame, UNO_QUERY );
 133             if ( (!GetCurrentDocument() || !GetCurrentDocument()->Get_Impl()->bDisposing ) && xCloseable.is())
 134                 xCloseable->close(sal_True);
 135             else if ( pImp->xFrame.is() )
 136             {
 137                 Reference < XFrame > xFrame = pImp->xFrame;
 138                 xFrame->setComponent( Reference < com::sun::star::awt::XWindow >(), Reference < XController >() );
 139                 xFrame->dispose();
 140             }
 141             else
 142                 bRet = DoClose_Impl();
 143         }
 144         catch( ::com::sun::star::util::CloseVetoException& )
 145         {
 146             pImp->bClosing = false;
 147             bRet = false;
 148         }
 149         catch( ::com::sun::star::lang::DisposedException& )
 150         {
 151         }
 152     }
 153
 154     return bRet;
 155 }
 156
 157 bool SfxFrame::DoClose_Impl()
 158 {
 159     SfxBindings* pBindings = NULL;
 160     if ( pImp->pCurrentViewFrame )
 161         pBindings = &pImp->pCurrentViewFrame->GetBindings();
 162
 163     // For internal tasks Controllers and Tools must be cleared
 164     if ( pImp->pWorkWin )
 165         pImp->pWorkWin->DeleteControllers_Impl();
 166
 167     if ( pImp->pCurrentViewFrame )
 168         pImp->pCurrentViewFrame->Close();
 169
 170     if ( pImp->bOwnsBindings )
 171         DELETEZ( pBindings );
 172
 173     bool bRet = Close();
 174     DBG_ASSERT( bRet, "Impossible state: frame closes, but controller refuses!");
 175     return bRet;
 176 }
 177
 178 bool SfxFrame::DocIsModified_Impl()
 179 {
 180     if ( pImp->pCurrentViewFrame && pImp->pCurrentViewFrame->GetObjectShell() &&
 181             pImp->pCurrentViewFrame->GetObjectShell()->IsModified() )
 182         return true;
 183     for( sal_uInt16 nPos = GetChildFrameCount(); nPos--; )
 184         if( (*pChildArr)[ nPos ]->DocIsModified_Impl() )
 185             return true;
 186     return false;
 187 }
 188
 189 bool SfxFrame::PrepareClose_Impl( bool bUI )
 190 {
 191     bool nRet = true;
 192
 193     // prevent recursive calls
 194     if( !pImp->bPrepClosing )
 195     {
 196         pImp->bPrepClosing = true;
 197
 198         SfxObjectShell* pCur = GetCurrentDocument() ;
 199         if( pCur )
 200         {
 201             // SFX components have a known behaviour
 202             // First check if this frame is the only view to its current document
 203             bool bOther = false;
 204             for ( const SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pCur );
 205                     !bOther && pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, pCur ) )
 206             {
 207                 bOther = ( &pFrame->GetFrame() != this );
 208             }
 209
 210             SfxGetpApp()->NotifyEvent( SfxViewEventHint(SFX_EVENT_PREPARECLOSEVIEW, GlobalEventConfig::GetEventName( GlobalEventId::PREPARECLOSEVIEW ), pCur, GetController() ) );
 211
 212             if ( bOther )
 213                 // if there are other views only the current view of this frame must be asked
 214                 nRet = GetCurrentViewFrame()->GetViewShell()->PrepareClose( bUI );
 215             else
 216                 // otherwise ask the document
 217                 nRet = pCur->PrepareClose( bUI );
 218         }
 219
 220         if ( nRet )
 221         {
 222             // if this frame has child frames, ask them too
 223             for( sal_uInt16 nPos = GetChildFrameCount(); nRet && nPos--; )
 224                 nRet = (*pChildArr)[ nPos ]->PrepareClose_Impl( bUI );
 225         }
 226
 227         pImp->bPrepClosing = false;
 228     }
 229
 230     if ( nRet && pImp->pWorkWin )
 231         // if closing was accepted by the component the UI subframes must be asked also
 232         nRet = pImp->pWorkWin->PrepareClose_Impl();
 233
 234     return nRet;
 235 }
 236
 237
 238
 239 SfxFrame* SfxFrame::GetChildFrame( sal_uInt16 nPos ) const
 240 {
 241     if ( pChildArr && pChildArr->size() > nPos )
 242     {
 243         DBG_ASSERT( nPos < pChildArr->size(), "Wrong Index!");
 244         return (*pChildArr)[nPos];
 245     }
 246
 247     return 0L;
 248 }
 249
 250 void SfxFrame::RemoveChildFrame_Impl( SfxFrame* pFrame )
 251 {
 252     DBG_ASSERT( pChildArr, "Unknown Frame!");
 253     SfxFrameArr_Impl::iterator it = std::find( pChildArr->begin(), pChildArr->end(), pFrame );
 254     if ( it != pChildArr->end() )
 255         pChildArr->erase( it );
 256 };
 257
 258 SfxFrame& SfxFrame::GetTopFrame() const
 259 {
 260     const SfxFrame* pParent = this;
 261     while ( pParent->pParentFrame )
 262         pParent = pParent->pParentFrame;
 263     return *const_cast< SfxFrame* >( pParent );
 264 }
 265
 266 bool SfxFrame::IsClosing_Impl() const
 267 {
 268     return pImp->bClosing;
 269 }
 270
 271 void SfxFrame::SetIsClosing_Impl()
 272 {
 273     pImp->bClosing = true;
 274 }
 275
 276 sal_uInt16 SfxFrame::GetChildFrameCount() const
 277 {
 278     return pChildArr ? pChildArr->size() : 0;
 279 }
 280
 281 void SfxFrame::CancelTransfers( bool /*bCancelLoadEnv*/ )
 282 {
 283     if( !pImp->bInCancelTransfers )
 284     {
 285         pImp->bInCancelTransfers = true;
 286         SfxObjectShell* pObj = GetCurrentDocument();
 287         if( pObj ) //&& !( pObj->Get_Impl()->nLoadedFlags & SfxLoadedFlags::ALL ))
 288         {
 289             SfxViewFrame* pFrm;
 290             for( pFrm = SfxViewFrame::GetFirst( pObj );
 291                  pFrm && &pFrm->GetFrame() == this;
 292                  pFrm = SfxViewFrame::GetNext( *pFrm, pObj ) ) ;
 293             // No more Frame in Document -> Cancel
 294             if( !pFrm )
 295             {
 296                 pObj->CancelTransfers();
 297                 GetCurrentDocument()->Broadcast( SfxSimpleHint(SFX_HINT_TITLECHANGED) );
 298             }
 299         }
 300
 301         // First stop multiload Frames
 302         sal_uInt16 nCount = GetChildFrameCount();
 303         for( sal_uInt16 n = 0; n<nCount; n++ )
 304             GetChildFrame( n )->CancelTransfers();
 305
 306         //  Check if StarOne-Loader should be canceled
 307         SfxFrameWeakRef wFrame( this );
 308         if (wFrame.Is())
 309             pImp->bInCancelTransfers = false;
 310     }
 311 }
 312
 313 SfxViewFrame* SfxFrame::GetCurrentViewFrame() const
 314 {
 315     return pImp->pCurrentViewFrame;
 316 }
 317
 318 SfxDispatcher* SfxFrame::GetDispatcher_Impl() const
 319 {
 320     if ( pImp->pCurrentViewFrame )
 321         return pImp->pCurrentViewFrame->GetDispatcher();
 322     return GetParentFrame()->GetDispatcher_Impl();
 323 }
 324
 325 bool SfxFrame::IsAutoLoadLocked_Impl() const
 326 {
 327     // Its own Docucument is locked?
 328     const SfxObjectShell* pObjSh = GetCurrentDocument();
 329     if ( !pObjSh || !pObjSh->IsAutoLoadLocked() )
 330         return false;
 331
 332     // Its children are locked?
 333     for ( sal_uInt16 n = GetChildFrameCount(); n--; )
 334         if ( !GetChildFrame(n)->IsAutoLoadLocked_Impl() )
 335             return false;
 336
 337     // otherwise allow AutoLoad
 338     return true;
 339 }
 340
 341 SfxObjectShell* SfxFrame::GetCurrentDocument() const
 342 {
 343     return pImp->pCurrentViewFrame ?
 344             pImp->pCurrentViewFrame->GetObjectShell() :
 345             NULL;
 346 }
 347
 348 void SfxFrame::SetCurrentViewFrame_Impl( SfxViewFrame *pFrame )
 349 {
 350     pImp->pCurrentViewFrame = pFrame;
 351 }
 352
 353 sal_uInt32 SfxFrame::GetFrameType() const
 354 {
 355     return pImp->nType;
 356 }
 357
 358 void SfxFrame::SetFrameType_Impl( sal_uInt32 n )
 359 {
 360     pImp->nType = n;
 361 }
 362
 363 void SfxFrame::GetViewData_Impl()
 364 {
 365     // Update all modifiable data between load and unload, the
 366     // fixed data is only processed once (after PrepareForDoc_Impl in
 367     // updateDescriptor) to save time.
 368
 369     SfxViewFrame* pViewFrame = GetCurrentViewFrame();
 370     if( pViewFrame && pViewFrame->GetViewShell() )
 371     {
 372         const SfxMedium *pMed = GetCurrentDocument()->GetMedium();
 373         bool bReadOnly = pMed->GetOpenMode() == SFX_STREAM_READONLY;
 374         GetDescriptor()->SetReadOnly( bReadOnly );
 375
 376         SfxItemSet *pSet = GetDescriptor()->GetArgs();
 377         bool bGetViewData = false;
 378         if ( GetController().is() && pSet->GetItemState( SID_VIEW_DATA ) != SfxItemState::SET )
 379         {
 380             ::com::sun::star::uno::Any aData = GetController()->getViewData();
 381             pSet->Put( SfxUsrAnyItem( SID_VIEW_DATA, aData ) );
 382             bGetViewData = true;
 383         }
 384
 385         if ( pViewFrame->GetCurViewId() )
 386             pSet->Put( SfxUInt16Item( SID_VIEW_ID, pViewFrame->GetCurViewId() ) );
 387         if ( pChildArr )
 388         {
 389             // For Framesets also the data from the ChildViews hace to be processed
 390             sal_uInt16 nCount = pChildArr->size();
 391             for ( sal_uInt16 n=nCount; n>0; n--)
 392             {
 393                 SfxFrame* pFrame = (*pChildArr)[n-1];
 394                 if ( bGetViewData )
 395                     pFrame->GetDescriptor()->GetArgs()->ClearItem( SID_VIEW_DATA );
 396                 pFrame->GetViewData_Impl();
 397             }
 398         }
 399     }
 400 }
 401
 402 void SfxFrame::UpdateDescriptor( SfxObjectShell *pDoc )
 403 {
 404     // For PrepareForDoc_Impl frames, the descriptor of the updated
 405     // and new itemset to be initialized. All data fir restoring the view
 406     // are thus saved. If the document be replaced, GetViewData_Impl (so)
 407     // the latest information hinzugef by "added. All together then the
 408     // browser-history saved in. When you activate such frame pick entry
 409     // is complete itemsets and the descriptor in the OpenDoc sent;.
 410     // Here only the fixed properties identified "other adjustable, the
 411     // retrieved by GetViewData (saves time).
 412
 413     assert(pDoc && "NULL-Document inserted ?!");
 414
 415     GetParentFrame();
 416     const SfxMedium *pMed = pDoc->GetMedium();
 417     GetDescriptor()->SetActualURL( pMed->GetOrigURL() );
 418
 419     SFX_ITEMSET_ARG( pMed->GetItemSet(), pItem, SfxBoolItem, SID_EDITDOC, false );
 420     bool bEditable = ( !pItem || pItem->GetValue() );
 421
 422     GetDescriptor()->SetEditable( bEditable );
 423
 424     // Mark FileOpen parameter
 425     SfxItemSet* pItemSet = pMed->GetItemSet();
 426
 427     const SfxFilter* pFilter = pMed->GetOrigFilter();
 428     OUString aFilter;
 429     if ( pFilter )
 430         aFilter = pFilter->GetFilterName();
 431
 432     SFX_ITEMSET_ARG( pItemSet, pRefererItem, SfxStringItem, SID_REFERER, false);
 433     SFX_ITEMSET_ARG( pItemSet, pOptionsItem, SfxStringItem, SID_FILE_FILTEROPTIONS, false);
 434     SFX_ITEMSET_ARG( pItemSet, pTitle1Item, SfxStringItem, SID_DOCINFO_TITLE, false);
 435
 436     SfxItemSet *pSet = GetDescriptor()->GetArgs();
 437
 438     // Delete all old Items
 439     pSet->ClearItem();
 440
 441     if ( pRefererItem )
 442         pSet->Put( *pRefererItem );
 443     else
 444         pSet->Put( SfxStringItem( SID_REFERER, OUString() ) );
 445
 446     if ( pOptionsItem )
 447         pSet->Put( *pOptionsItem );
 448
 449     if ( pTitle1Item )
 450         pSet->Put( *pTitle1Item );
 451
 452     pSet->Put( SfxStringItem( SID_FILTER_NAME, aFilter ));
 453 }
 454
 455
 456
 457 SfxFrameDescriptor* SfxFrame::GetDescriptor() const
 458 {
 459     // Create a FrameDescriptor On Demand; if there is no TopLevel-Frame
 460     // will result in an error, as no valid link is created.
 461
 462     if ( !pImp->pDescr )
 463     {
 464         DBG_ASSERT( !GetParentFrame(), "No TopLevel-Frame, but no Descriptor!" );
 465         pImp->pDescr = new SfxFrameDescriptor;
 466         if ( GetCurrentDocument() )
 467             pImp->pDescr->SetURL( GetCurrentDocument()->GetMedium()->GetOrigURL() );
 468     }
 469     return pImp->pDescr;
 470 }
 471
 472 void SfxFrame::GetDefaultTargetList(TargetList& rList)
 473 {
 474     // An empty string for 'No Target'
 475     rList.push_back( OUString() );
 476     rList.push_back( OUString( "_top" ) );
 477     rList.push_back( OUString( "_parent" ) );
 478     rList.push_back( OUString( "_blank" ) );
 479     rList.push_back( OUString( "_self" ) );
 480 }
 481
 482 void SfxFrame::GetTargetList( TargetList& rList ) const
 483 {
 484     if ( !GetParentFrame() )
 485     {
 486         SfxFrame::GetDefaultTargetList(rList);
 487     }
 488
 489     SfxViewFrame* pView = GetCurrentViewFrame();
 490     if( pView && pView->GetViewShell() && pChildArr )
 491     {
 492         sal_uInt16 nCount = pChildArr->size();
 493         for ( sal_uInt16 n=0; n<nCount; n++)
 494         {
 495             SfxFrame* pFrame = (*pChildArr)[n];
 496             pFrame->GetTargetList( rList );
 497         }
 498     }
 499 }
 500
 501 bool SfxFrame::IsParent( SfxFrame *pFrame ) const
 502 {
 503     SfxFrame *pParent = pParentFrame;
 504     while ( pParent )
 505     {
 506         if ( pParent == pFrame )
 507             return true;
 508         pParent = pParent->pParentFrame;
 509     }
 510
 511     return false;
 512 }
 513
 514 void SfxFrame::InsertTopFrame_Impl( SfxFrame* pFrame )
 515 {
 516     SfxFrameArr_Impl& rArr = *SfxGetpApp()->Get_Impl()->pTopFrames;
 517     rArr.push_back( pFrame );
 518 }
 519
 520 void SfxFrame::RemoveTopFrame_Impl( SfxFrame* pFrame )
 521 {
 522     SfxFrameArr_Impl& rArr = *SfxGetpApp()->Get_Impl()->pTopFrames;
 523     SfxFrameArr_Impl::iterator it = std::find( rArr.begin(), rArr.end(), pFrame );
 524     if ( it != rArr.end() )
 525         rArr.erase( it );
 526 }
 527
 528 SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxViewFrame *p )
 529     : SfxPoolItem( nWhichId ), pFrame( p ? &p->GetFrame() : NULL )
 530 {
 531     wFrame = pFrame;
 532 }
 533
 534 SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxFrame *p ):
 535     SfxPoolItem( nWhichId ),
 536     pFrame( p ), wFrame( p )
 537 {
 538 }
 539
 540 SfxFrameItem::SfxFrameItem( SfxFrame *p ):
 541     SfxPoolItem( 0 ),
 542     pFrame( p ), wFrame( p )
 543 {
 544 }
 545
 546 bool SfxFrameItem::operator==( const SfxPoolItem &rItem ) const
 547 {
 548      return static_cast<const SfxFrameItem&>(rItem).pFrame == pFrame &&
 549          static_cast<const SfxFrameItem&>(rItem).wFrame == wFrame;
 550 }
 551
 552 SfxPoolItem* SfxFrameItem::Clone( SfxItemPool *) const
 553 {
 554     SfxFrameItem* pNew = new SfxFrameItem( wFrame);
 555     pNew->SetFramePtr_Impl( pFrame );
 556     return pNew;
 557 }
 558
 559 bool SfxFrameItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 ) const
 560 {
 561     if ( wFrame )
 562     {
 563         rVal <<= wFrame->GetFrameInterface();
 564         return true;
 565     }
 566
 567     return false;
 568 }
 569
 570 bool SfxFrameItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 )
 571 {
 572     Reference < XFrame > xFrame;
 573     if ( (rVal >>= xFrame) && xFrame.is() )
 574     {
 575         SfxFrame* pFr = SfxFrame::GetFirst();
 576         while ( pFr )
 577         {
 578             if ( pFr->GetFrameInterface() == xFrame )
 579             {
 580                 wFrame = pFrame = pFr;
 581                 return true;
 582             }
 583
 584             pFr = SfxFrame::GetNext( *pFr );
 585         }
 586         return true;
 587     }
 588
 589     return false;
 590 }
 591
 592
 593 SfxUsrAnyItem::SfxUsrAnyItem( sal_uInt16 nWhichId, const ::com::sun::star::uno::Any& rAny )
 594     : SfxPoolItem( nWhichId )
 595 {
 596     aValue = rAny;
 597 }
 598
 599 bool SfxUsrAnyItem::operator==( const SfxPoolItem& /*rItem*/ ) const
 600 {
 601     return false;
 602 }
 603
 604 SfxPoolItem* SfxUsrAnyItem::Clone( SfxItemPool *) const
 605 {
 606     return new SfxUsrAnyItem( Which(), aValue );
 607 }
 608
 609 bool SfxUsrAnyItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 610 {
 611     rVal = aValue;
 612     return true;
 613 }
 614
 615 bool SfxUsrAnyItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 616 {
 617     aValue = rVal;
 618     return true;
 619 }
 620
 621 SfxUnoFrameItem::SfxUnoFrameItem()
 622     : SfxPoolItem()
 623     , m_xFrame()
 624 {
 625 }
 626
 627 SfxUnoFrameItem::SfxUnoFrameItem( sal_uInt16 nWhichId, const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& i_rFrame )
 628     : SfxPoolItem( nWhichId )
 629     , m_xFrame( i_rFrame )
 630 {
 631 }
 632
 633 bool SfxUnoFrameItem::operator==( const SfxPoolItem& i_rItem ) const
 634 {
 635     return i_rItem.ISA( SfxUnoFrameItem ) && static_cast< const SfxUnoFrameItem& >( i_rItem ).m_xFrame == m_xFrame;
 636 }
 637
 638 SfxPoolItem* SfxUnoFrameItem::Clone( SfxItemPool* ) const
 639 {
 640     return new SfxUnoFrameItem( Which(), m_xFrame );
 641 }
 642
 643 bool SfxUnoFrameItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
 644 {
 645     rVal <<= m_xFrame;
 646     return true;
 647 }
 648
 649 bool SfxUnoFrameItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 650 {
 651     return ( rVal >>= m_xFrame );
 652 }
 653
 654 SfxFrameIterator::SfxFrameIterator( const SfxFrame& rFrame, bool bRecur )
 655     : pFrame( &rFrame )
 656     , bRecursive( bRecur )
 657 {}
 658
 659 SfxFrame* SfxFrameIterator::FirstFrame()
 660 {
 661     // GetFirst starts the iteration at the first child frame
 662     return pFrame->GetChildFrame( 0 );
 663 }
 664
 665 SfxFrame* SfxFrameIterator::NextFrame( SfxFrame& rPrev )
 666 {
 667     // If recursion is requested testing is done first on Children.
 668     SfxFrame *pRet = NULL;
 669     if ( bRecursive )
 670         pRet = rPrev.GetChildFrame( 0 );
 671     if ( !pRet )
 672     {
 673         // In other case continue with the siblings of rPrev
 674         pRet = NextSibling_Impl( rPrev );
 675     }
 676
 677     return pRet;
 678 }
 679
 680
 681 SfxFrame* SfxFrameIterator::NextSibling_Impl( SfxFrame& rPrev )
 682 {
 683     SfxFrame *pRet = NULL;
 684     if ( &rPrev != pFrame )
 685     {
 686         SfxFrameArr_Impl& rArr = *rPrev.pParentFrame->pChildArr;
 687         SfxFrameArr_Impl::iterator it = std::find( rArr.begin(), rArr.end(), &rPrev );
 688         if ( it != rArr.end() && (++it) != rArr.end() )
 689             pRet = *it;
 690
 691         if ( !pRet && rPrev.pParentFrame->pParentFrame )
 692             pRet = NextSibling_Impl( *rPrev.pParentFrame );
 693     }
 694
 695     return pRet;
 696 }
 697
 698 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > SfxFrame::GetController() const
 699 {
 700     if ( pImp->pCurrentViewFrame && pImp->pCurrentViewFrame->GetViewShell() )
 701         return pImp->pCurrentViewFrame->GetViewShell()->GetController();
 702     else
 703         return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > ();
 704 }
 705
 706 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >  SfxFrame::GetFrameInterface() const
 707 {
 708     return pImp->xFrame;
 709 }
 710
 711 void SfxFrame::SetFrameInterface_Impl( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame )
 712 {
 713     pImp->xFrame = rFrame;
 714     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
 715     if ( !rFrame.is() && GetCurrentViewFrame() )
 716         GetCurrentViewFrame()->GetBindings().SetRecorder_Impl( xRecorder );
 717 }
 718
 719 void SfxFrame::Appear()
 720 {
 721     if ( GetCurrentViewFrame() )
 722     {
 723         GetCurrentViewFrame()->Show();
 724         GetWindow().Show();
 725         pImp->xFrame->getContainerWindow()->setVisible( sal_True );
 726         if ( pParentFrame )
 727             pParentFrame->Appear();
 728         Reference < ::com::sun::star::awt::XTopWindow > xTopWindow( pImp->xFrame->getContainerWindow(), UNO_QUERY );
 729         if ( xTopWindow.is() )
 730             xTopWindow->toFront();
 731     }
 732 }
 733
 734 void SfxFrame::AppearWithUpdate()
 735 {
 736     Appear();
 737     if ( GetCurrentViewFrame() )
 738         GetCurrentViewFrame()->GetDispatcher()->Update_Impl( true );
 739 }
 740
 741 void SfxFrame::SetOwnsBindings_Impl( bool bSet )
 742 {
 743     pImp->bOwnsBindings = bSet;
 744 }
 745
 746 bool SfxFrame::OwnsBindings_Impl() const
 747 {
 748     return pImp->bOwnsBindings;
 749 }
 750
 751 void SfxFrame::SetToolSpaceBorderPixel_Impl( const SvBorder& rBorder )
 752 {
 753     pImp->aBorder = rBorder;
 754     SfxViewFrame *pF = GetCurrentViewFrame();
 755     if ( pF )
 756     {
 757         Point aPos ( rBorder.Left(), rBorder.Top() );
 758         Size aSize( GetWindow().GetOutputSizePixel() );
 759         long nDeltaX = rBorder.Left() + rBorder.Right();
 760         if ( aSize.Width() > nDeltaX )
 761             aSize.Width() -= nDeltaX;
 762         else
 763             aSize.Width() = 0;
 764
 765         long nDeltaY = rBorder.Top() + rBorder.Bottom();
 766         if ( aSize.Height() > nDeltaY )
 767             aSize.Height() -= nDeltaY;
 768         else
 769             aSize.Height() = 0;
 770
 771         if ( GetParentFrame() )
 772         {
 773             bool bHasTools = rBorder.Left() != rBorder.Right() || rBorder.Top() != rBorder.Bottom();
 774             pF->GetWindow().SetBorderStyle( bHasTools ? WindowBorderStyle::NORMAL : WindowBorderStyle::NOBORDER );
 775         }
 776
 777         pF->GetWindow().SetPosSizePixel( aPos, aSize );
 778     }
 779 }
 780
 781 Rectangle SfxFrame::GetTopOuterRectPixel_Impl() const
 782 {
 783     Size aSize( GetWindow().GetOutputSizePixel() );
 784     Point aPoint;
 785     return ( Rectangle ( aPoint, aSize ) );
 786 }
 787
 788 SfxWorkWindow* SfxFrame::GetWorkWindow_Impl() const
 789 {
 790     if ( pImp->pWorkWin )
 791         return pImp->pWorkWin;
 792     else if ( pParentFrame )
 793         return pParentFrame->GetWorkWindow_Impl();
 794     else
 795         return NULL;
 796 }
 797
 798 void SfxFrame::CreateWorkWindow_Impl()
 799 {
 800     SfxFrame* pFrame = this;
 801
 802     if ( IsInPlace() )
 803     {
 804         // this makes sense only for inplace activated objects
 805         try
 806         {
 807             Reference < XChild > xChild( GetCurrentDocument()->GetModel(), UNO_QUERY );
 808             if ( xChild.is() )
 809             {
 810                 Reference < XModel > xParent( xChild->getParent(), UNO_QUERY );
 811                 if ( xParent.is() )
 812                 {
 813                     Reference< XController > xParentCtrler = xParent->getCurrentController();
 814                     if ( xParentCtrler.is() )
 815                     {
 816                         Reference < XFrame > xFrame( xParentCtrler->getFrame() );
 817                         SfxFrame* pFr = SfxFrame::GetFirst();
 818                         while ( pFr )
 819                         {
 820                             if ( pFr->GetFrameInterface() == xFrame )
 821                             {
 822                                 pFrame = pFr;
 823                                 break;
 824                             }
 825
 826                             pFr = SfxFrame::GetNext( *pFr );
 827                         }
 828                     }
 829                 }
 830             }
 831         }
 832         catch(Exception&)
 833         {
 834             OSL_FAIL("SfxFrame::CreateWorkWindow_Impl: Exception caught. Please try to submit a reproducable bug!");
 835         }
 836     }
 837
 838     pImp->pWorkWin = new SfxFrameWorkWin_Impl( &pFrame->GetWindow(), this, pFrame );
 839 }
 840
 841 void SfxFrame::GrabFocusOnComponent_Impl()
 842 {
 843     if ( pImp->bReleasingComponent )
 844     {
 845         GetWindow().GrabFocus();
 846         return;
 847     }
 848
 849     vcl::Window* pFocusWindow = &GetWindow();
 850     if ( GetCurrentViewFrame() && GetCurrentViewFrame()->GetViewShell() && GetCurrentViewFrame()->GetViewShell()->GetWindow() )
 851         pFocusWindow = GetCurrentViewFrame()->GetViewShell()->GetWindow();
 852
 853     if( !pFocusWindow->HasChildPathFocus() )
 854         pFocusWindow->GrabFocus();
 855 }
 856
 857 void SfxFrame::ReleasingComponent_Impl( bool bSet )
 858 {
 859     pImp->bReleasingComponent = bSet;
 860 }
 861
 862 bool SfxFrame::IsInPlace() const
 863 {
 864     return pImp->bInPlace;
 865 }
 866
 867 void SfxFrame::SetInPlace_Impl( bool bSet )
 868 {
 869     pImp->bInPlace = bSet;
 870 }
 871
 872 void SfxFrame::Resize()
 873 {
 874     if ( IsClosing_Impl() )
 875         return;
 876
 877     if ( OwnsBindings_Impl() )
 878     {
 879         if ( IsInPlace() )
 880         {
 881             SetToolSpaceBorderPixel_Impl( SvBorder() );
 882         }
 883         else
 884         {
 885             // check for IPClient that contains UIactive object or object that is currently UI activating
 886             SfxWorkWindow *pWork = GetWorkWindow_Impl();
 887             SfxInPlaceClient* pClient = GetCurrentViewFrame()->GetViewShell() ? GetCurrentViewFrame()->GetViewShell()->GetUIActiveIPClient_Impl() : 0;
 888             if ( pClient )
 889             {
 890                 uno::Reference < lang::XUnoTunnel > xObj( pClient->GetObject()->getComponent(), uno::UNO_QUERY );
 891                 uno::Sequence < sal_Int8 > aSeq( SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence() );
 892                 sal_Int64 nHandle = (xObj.is()? xObj->getSomething( aSeq ): 0);
 893                 if ( nHandle )
 894                 {
 895                     SfxObjectShell* pDoc = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
 896                     SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pDoc );
 897                     pWork = pFrame ? pFrame->GetFrame().GetWorkWindow_Impl() : NULL;
 898                 }
 899             }
 900
 901             if ( pWork )
 902             {
 903                 pWork->ArrangeChildren_Impl();
 904                 pWork->ShowChildren_Impl();
 905             }
 906
 907             // problem in presence of UIActive object: when the window is resized, but the toolspace border
 908             // remains the same, setting the toolspace border at the ContainerEnvironment doesn't force a
 909             // resize on the IPEnvironment; without that no resize is called for the SfxViewFrame. So always
 910             // set the window size of the SfxViewFrame explicit.
 911             SetToolSpaceBorderPixel_Impl( pImp->aBorder );
 912         }
 913     }
 914     else if ( pImp->pCurrentViewFrame )
 915     {
 916         pImp->pCurrentViewFrame->GetWindow().SetSizePixel( GetWindow().GetOutputSizePixel() );
 917     }
 918
 919 }
 920
 921 SfxFrame* SfxFrame::GetFirst()
 922 {
 923     if ( !pFramesArr_Impl )
 924         return 0;
 925     return pFramesArr_Impl->empty() ? 0 : pFramesArr_Impl->front();
 926 }
 927
 928 SfxFrame* SfxFrame::GetNext( SfxFrame& rFrame )
 929 {
 930     SfxFrameArr_Impl::iterator it = std::find( pFramesArr_Impl->begin(), pFramesArr_Impl->end(), &rFrame );
 931     if ( it != pFramesArr_Impl->end() && (++it) != pFramesArr_Impl->end() )
 932         return *it;
 933     else
 934         return NULL;
 935 }
 936
 937 const SfxPoolItem* SfxFrame::OpenDocumentSynchron( SfxItemSet& i_rSet, const Reference< XFrame >& i_rTargetFrame )
 938 {
 939     i_rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, i_rTargetFrame ) );
 940     i_rSet.ClearItem( SID_TARGETNAME );
 941     return SfxGetpApp()->GetDispatcher_Impl()->Execute( SID_OPENDOC, SfxCallMode::SYNCHRON, i_rSet );
 942 }
 943
 944 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */