| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sfx2.hxx" |
| #include <com/sun/star/embed/EmbedStates.hpp> |
| #include <com/sun/star/uno/Reference.h> |
| #include <com/sun/star/awt/XWindow.hpp> |
| #include <com/sun/star/util/XURLTransformer.hpp> |
| #include <com/sun/star/util/XCloseable.hpp> |
| #include <com/sun/star/util/CloseVetoException.hpp> |
| #include <com/sun/star/lang/XComponent.hpp> |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/container/XChild.hpp> |
| |
| #ifndef _MENU_HXX //autogen |
| #include <vcl/menu.hxx> |
| #endif |
| #include <svl/intitem.hxx> |
| #ifndef _SPLITWIN_HXX //autogen |
| #include <vcl/splitwin.hxx> |
| #endif |
| #include <svl/eitem.hxx> |
| #include <svl/stritem.hxx> |
| #ifndef _TOOLKIT_UNOHLP_HXX |
| #include <toolkit/helper/vclunohelper.hxx> |
| #endif |
| #include <com/sun/star/awt/PosSize.hpp> |
| #ifndef _UNOTOOLS_PROCESSFACTORY_HXX |
| #include <comphelper/processfactory.hxx> |
| #endif |
| #include <vcl/msgbox.hxx> |
| |
| #ifndef GCC |
| #endif |
| |
| // wg. pTopFrames |
| #include "appdata.hxx" |
| #include <sfx2/app.hxx> |
| #include <sfx2/event.hxx> |
| #include <sfx2/unoctitm.hxx> |
| #include <sfx2/frame.hxx> |
| #include "arrdecl.hxx" |
| #include <sfx2/objsh.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <sfx2/docfilt.hxx> |
| #include <sfx2/frmdescr.hxx> |
| #include "openflag.hxx" |
| #include <sfx2/viewsh.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/request.hxx> |
| #include <sfx2/fcontnr.hxx> |
| #include "impframe.hxx" |
| #include <sfx2/appuno.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include "workwin.hxx" |
| #include <sfx2/sfxuno.hxx> |
| #include <sfx2/msgpool.hxx> |
| #include "objshimp.hxx" |
| #include <sfx2/ipclient.hxx> |
| |
| #ifdef DBG_UTIL |
| #include <sfx2/frmhtmlw.hxx> |
| #endif |
| |
| using namespace com::sun::star; |
| |
| static SfxFrameArr_Impl* pFramesArr_Impl=0; |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::container; |
| |
| TYPEINIT1(SfxFrame, SfxListener); |
| TYPEINIT1_AUTOFACTORY(SfxFrameItem, SfxPoolItem); |
| TYPEINIT1(SfxUsrAnyItem, SfxPoolItem); |
| TYPEINIT1_AUTOFACTORY(SfxUnoFrameItem, SfxPoolItem); |
| |
| SvCompatWeakHdl* SfxFrame::GetHdl() |
| { |
| return pImp->GetHdl(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SfxFrame::Construct_Impl() |
| { |
| pImp = new SfxFrame_Impl( this ); |
| if ( !pFramesArr_Impl ) |
| pFramesArr_Impl = new SfxFrameArr_Impl; |
| pFramesArr_Impl->Insert( this, pFramesArr_Impl->Count() ); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| SfxFrame::~SfxFrame() |
| { |
| RemoveTopFrame_Impl( this ); |
| DELETEZ( pWindow ); |
| |
| pFramesArr_Impl->Remove( pFramesArr_Impl->GetPos( this ) ); |
| |
| if ( pParentFrame ) |
| { |
| pParentFrame->RemoveChildFrame_Impl( this ); |
| pParentFrame = 0; |
| } |
| |
| delete pImp->pDescr; |
| |
| if ( pChildArr ) |
| { |
| DBG_ASSERT( !pChildArr->Count(), "Childs nicht entfernt!" ); |
| delete pChildArr; |
| } |
| |
| delete pImp; |
| } |
| |
| sal_Bool SfxFrame::DoClose() |
| { |
| // Eigentlich wird noch ein PrepareClose gebraucht !!! |
| sal_Bool bRet = sal_False; |
| if ( !pImp->bClosing ) |
| { |
| pImp->bClosing = sal_True; |
| CancelTransfers(); |
| |
| // now close frame; it will be deleted if this call is successful, so don't use any members after that! |
| bRet = sal_True; |
| try |
| { |
| Reference< XCloseable > xCloseable ( pImp->xFrame, UNO_QUERY ); |
| if ( (!GetCurrentDocument() || !GetCurrentDocument()->Get_Impl()->bDisposing ) && xCloseable.is()) |
| xCloseable->close(sal_True); |
| else if ( pImp->xFrame.is() ) |
| { |
| Reference < XFrame > xFrame = pImp->xFrame; |
| xFrame->setComponent( Reference < com::sun::star::awt::XWindow >(), Reference < XController >() ); |
| xFrame->dispose(); |
| } |
| else |
| bRet = DoClose_Impl(); |
| } |
| catch( ::com::sun::star::util::CloseVetoException& ) |
| { |
| pImp->bClosing = sal_False; |
| bRet = sal_False; |
| } |
| catch( ::com::sun::star::lang::DisposedException& ) |
| { |
| } |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool SfxFrame::DoClose_Impl() |
| { |
| sal_Bool bRet = sal_True; |
| SfxBindings* pBindings = NULL; |
| if ( pImp->pCurrentViewFrame ) |
| pBindings = &pImp->pCurrentViewFrame->GetBindings(); |
| |
| // Bei internen Tasks m"ussen Controller und Tools abger"aumt werden |
| if ( pImp->pWorkWin ) |
| pImp->pWorkWin->DeleteControllers_Impl(); |
| |
| if ( pImp->pCurrentViewFrame ) |
| bRet = pImp->pCurrentViewFrame->Close(); |
| |
| if ( pImp->bOwnsBindings ) |
| DELETEZ( pBindings ); |
| |
| bRet = Close(); |
| DBG_ASSERT( bRet, "Impossible state: frame closes, but controller refuses!"); |
| return bRet; |
| } |
| |
| sal_Bool SfxFrame::DocIsModified_Impl() |
| { |
| if ( pImp->pCurrentViewFrame && pImp->pCurrentViewFrame->GetObjectShell() && |
| pImp->pCurrentViewFrame->GetObjectShell()->IsModified() ) |
| return sal_True; |
| for( sal_uInt16 nPos = GetChildFrameCount(); nPos--; ) |
| if( pChildArr->GetObject( nPos )->DocIsModified_Impl() ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| sal_uInt16 SfxFrame::PrepareClose_Impl( sal_Bool bUI, sal_Bool bForBrowsing ) |
| { |
| sal_uInt16 nRet = RET_OK; |
| |
| // prevent recursive calls |
| if( !pImp->bPrepClosing ) |
| { |
| pImp->bPrepClosing = sal_True; |
| |
| SfxObjectShell* pCur = GetCurrentDocument() ; |
| if( pCur ) |
| { |
| // SFX components have a known behaviour |
| // First check if this frame is the only view to its current document |
| int bOther = sal_False; |
| for ( const SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pCur ); |
| !bOther && pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, pCur ) ) |
| { |
| bOther = ( &pFrame->GetFrame() != this ); |
| } |
| |
| SFX_APP()->NotifyEvent( SfxViewEventHint(SFX_EVENT_PREPARECLOSEVIEW, GlobalEventConfig::GetEventName( STR_EVENT_PREPARECLOSEVIEW ), pCur, GetController() ) ); |
| |
| if ( bOther ) |
| // if there are other views only the current view of this frame must be asked |
| nRet = GetCurrentViewFrame()->GetViewShell()->PrepareClose( bUI, bForBrowsing ); |
| else |
| // otherwise ask the document |
| nRet = pCur->PrepareClose( bUI, bForBrowsing ); |
| } |
| |
| if ( nRet == RET_OK ) |
| { |
| // if this frame has child frames, ask them too |
| for( sal_uInt16 nPos = GetChildFrameCount(); nRet == RET_OK && nPos--; ) |
| nRet = pChildArr->GetObject( nPos )->PrepareClose_Impl( bUI, bForBrowsing ); |
| } |
| |
| pImp->bPrepClosing = sal_False; |
| } |
| |
| if ( nRet == RET_OK && pImp->pWorkWin ) |
| // if closing was accepted by the component the UI subframes must be asked also |
| nRet = pImp->pWorkWin->PrepareClose_Impl(); |
| |
| return nRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| SfxFrame* SfxFrame::GetChildFrame( sal_uInt16 nPos ) const |
| { |
| if ( pChildArr && pChildArr->Count() > nPos ) |
| { |
| DBG_ASSERT( nPos < pChildArr->Count(), "Falscher Index!"); |
| return (*pChildArr)[nPos]; |
| } |
| |
| return 0L; |
| } |
| |
| void SfxFrame::RemoveChildFrame_Impl( SfxFrame* pFrame ) |
| { |
| DBG_ASSERT( pChildArr, "Unbekannter Frame!"); |
| sal_uInt16 nPos = pChildArr->GetPos(pFrame); |
| pChildArr->Remove( nPos ); |
| }; |
| |
| SfxFrame& SfxFrame::GetTopFrame() const |
| { |
| const SfxFrame* pParent = this; |
| while ( pParent->pParentFrame ) |
| pParent = pParent->pParentFrame; |
| return *const_cast< SfxFrame* >( pParent ); |
| } |
| |
| sal_Bool SfxFrame::IsClosing_Impl() const |
| { |
| return pImp->bClosing; |
| } |
| |
| void SfxFrame::SetIsClosing_Impl() |
| { |
| pImp->bClosing = sal_True; |
| } |
| |
| sal_uInt16 SfxFrame::GetChildFrameCount() const |
| { |
| return pChildArr ? pChildArr->Count() : 0; |
| } |
| |
| void SfxFrame::CancelTransfers( sal_Bool /*bCancelLoadEnv*/ ) |
| { |
| if( !pImp->bInCancelTransfers ) |
| { |
| pImp->bInCancelTransfers = sal_True; |
| SfxObjectShell* pObj = GetCurrentDocument(); |
| if( pObj ) //&& !( pObj->Get_Impl()->nLoadedFlags & SFX_LOADED_ALL )) |
| { |
| SfxViewFrame* pFrm; |
| for( pFrm = SfxViewFrame::GetFirst( pObj ); |
| pFrm && &pFrm->GetFrame() == this; |
| pFrm = SfxViewFrame::GetNext( *pFrm, pObj ) ) ; |
| // Keine anderer Frame mehr auf Doc -> Cancel |
| if( !pFrm ) |
| { |
| pObj->CancelTransfers(); |
| GetCurrentDocument()->Broadcast( SfxSimpleHint(SFX_HINT_TITLECHANGED) ); |
| } |
| } |
| |
| // zuerst Nachladende Frames stoppen |
| sal_uInt16 nCount = GetChildFrameCount(); |
| for( sal_uInt16 n = 0; n<nCount; n++ ) |
| GetChildFrame( n )->CancelTransfers(); |
| |
| // ggf. StarOne-Loader canceln |
| SfxFrameWeak wFrame( this ); |
| if (wFrame.Is()) |
| pImp->bInCancelTransfers = sal_False; |
| } |
| } |
| |
| SfxViewFrame* SfxFrame::GetCurrentViewFrame() const |
| { |
| return pImp->pCurrentViewFrame; |
| } |
| |
| SfxDispatcher* SfxFrame::GetDispatcher_Impl() const |
| { |
| if ( pImp->pCurrentViewFrame ) |
| return pImp->pCurrentViewFrame->GetDispatcher(); |
| return GetParentFrame()->GetDispatcher_Impl(); |
| } |
| |
| SfxObjectShell* SfxFrame::GetCurrentDocument() const |
| { |
| return pImp->pCurrentViewFrame ? |
| pImp->pCurrentViewFrame->GetObjectShell() : |
| NULL; |
| } |
| |
| void SfxFrame::SetCurrentViewFrame_Impl( SfxViewFrame *pFrame ) |
| { |
| pImp->pCurrentViewFrame = pFrame; |
| } |
| |
| sal_uInt32 SfxFrame::GetFrameType() const |
| { |
| return pImp->nType; |
| } |
| |
| void SfxFrame::SetFrameType_Impl( sal_uInt32 n ) |
| { |
| pImp->nType = n; |
| } |
| |
| void SfxFrame::GetViewData_Impl() |
| { |
| // Alle zwischen Laden und Entfernen "anderbaren Daten aktualisieren; die |
| // festen Daten werden nur einmal ( nach PrepareForDoc_Impl in UpdateDescriptor ) |
| // geholt, um Zeit zu sparen. |
| SfxViewFrame* pViewFrame = GetCurrentViewFrame(); |
| if( pViewFrame && pViewFrame->GetViewShell() ) |
| { |
| const SfxMedium *pMed = GetCurrentDocument()->GetMedium(); |
| sal_Bool bReadOnly = pMed->GetOpenMode() == SFX_STREAM_READONLY; |
| GetDescriptor()->SetReadOnly( bReadOnly ); |
| |
| SfxItemSet *pSet = GetDescriptor()->GetArgs(); |
| sal_Bool bGetViewData = sal_False; |
| if ( GetController().is() && pSet->GetItemState( SID_VIEW_DATA ) != SFX_ITEM_SET ) |
| { |
| ::com::sun::star::uno::Any aData = GetController()->getViewData(); |
| pSet->Put( SfxUsrAnyItem( SID_VIEW_DATA, aData ) ); |
| bGetViewData = sal_True; |
| } |
| |
| if ( pViewFrame->GetCurViewId() ) |
| pSet->Put( SfxUInt16Item( SID_VIEW_ID, pViewFrame->GetCurViewId() ) ); |
| if ( pChildArr ) |
| { |
| // Bei Framesets m"ussen auch die Daten der ChildViews geholt werden |
| sal_uInt16 nCount = pChildArr->Count(); |
| for ( sal_uInt16 n=nCount; n>0; n--) |
| { |
| SfxFrame* pFrame = (*pChildArr)[n-1]; |
| if ( bGetViewData ) |
| pFrame->GetDescriptor()->GetArgs()->ClearItem( SID_VIEW_DATA ); |
| pFrame->GetViewData_Impl(); |
| } |
| } |
| } |
| } |
| |
| void SfxFrame::UpdateDescriptor( SfxObjectShell *pDoc ) |
| { |
| // Beim PrepareForDoc_Impl wird der Descriptor des Frames aktualisiert |
| // und sein ItemSet neu initialisiert. Alle Daten, die f"ur ein sp"ateres |
| // Restaurieren der View n"otig sind, sind damit festgehalten. |
| // Soll das Dokument ersetzt werden, wird durch GetViewData_Impl (s.o.) |
| // die neueste Information hinzugef"ugt. Alles zusammen wird dann in der |
| // Browse-History gesichert. Beim Aktivieren eines solchen FramePickEntry |
| // wird das komplette ItemSet und der Descriptor im OpenDoc mitgeschickt. |
| // Hier werden nur die festen Eigenschaften gesichert; die "anderbaren werden |
| // durch GetViewData geholt ( spart Zeit ). |
| DBG_ASSERT( pDoc, "NULL-Document inserted ?!" ); |
| |
| GetParentFrame(); |
| const SfxMedium *pMed = pDoc->GetMedium(); |
| GetDescriptor()->SetActualURL( pMed->GetOrigURL() ); |
| |
| SFX_ITEMSET_ARG( pMed->GetItemSet(), pItem, SfxBoolItem, SID_EDITDOC, sal_False ); |
| sal_Bool bEditable = ( !pItem || pItem->GetValue() ); |
| |
| GetDescriptor()->SetEditable( bEditable ); |
| |
| // FileOpen-Parameter merken |
| SfxItemSet* pItemSet = pMed->GetItemSet(); |
| String aMedName( pMed->GetName() ); |
| |
| const SfxFilter* pFilter = pMed->GetOrigFilter(); |
| String aFilter; |
| if ( pFilter ) |
| aFilter = pFilter->GetFilterName(); |
| |
| SFX_ITEMSET_ARG( pItemSet, pRefererItem, SfxStringItem, SID_REFERER, sal_False); |
| SFX_ITEMSET_ARG( pItemSet, pOptionsItem, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False); |
| SFX_ITEMSET_ARG( pItemSet, pTitle1Item, SfxStringItem, SID_DOCINFO_TITLE, sal_False); |
| |
| SfxItemSet *pSet = GetDescriptor()->GetArgs(); |
| |
| // Alle alten Items l"oschen |
| pSet->ClearItem(); |
| |
| if ( pRefererItem ) |
| pSet->Put( *pRefererItem ); |
| else |
| pSet->Put( SfxStringItem( SID_REFERER, String() ) ); |
| |
| if ( pOptionsItem ) |
| pSet->Put( *pOptionsItem ); |
| |
| if ( pTitle1Item ) |
| pSet->Put( *pTitle1Item ); |
| |
| pSet->Put( SfxStringItem( SID_FILTER_NAME, aFilter )); |
| } |
| |
| //------------------------------------------------------------------------- |
| |
| void SfxFrame::SetDescriptor( SfxFrameDescriptor *pD ) |
| { |
| DBG_ASSERT( pD, "Kein Descriptor!" ); |
| DBG_ASSERT( pD != pImp->pDescr, "Descriptor ist schon gesetzt!" ); |
| |
| if ( pImp->pDescr ) |
| { |
| // Nur TopLevel-Frames verwalten ihren Descriptor selbst, bei den |
| // anderen tut es das Frameset |
| if ( !pParentFrame ) |
| delete pImp->pDescr; |
| } |
| pImp->pDescr = pD; |
| } |
| |
| //------------------------------------------------------------------------- |
| |
| SfxFrameDescriptor* SfxFrame::GetDescriptor() const |
| { |
| // On Demand einen FrameDescriptor anlegen; wenn es kein TopLevel-Frame |
| // ist, f"uhrt es zu Fehlern, da keine g"ulige Verkettung hergestellt wird |
| |
| if ( !pImp->pDescr ) |
| { |
| DBG_ASSERT( !GetParentFrame(), "Kein TopLevel-Frame, aber kein Descriptor!" ); |
| pImp->pDescr = new SfxFrameDescriptor; |
| if ( GetCurrentDocument() ) |
| pImp->pDescr->SetURL( GetCurrentDocument()->GetMedium()->GetOrigURL() ); |
| } |
| return pImp->pDescr; |
| } |
| |
| //------------------------------------------------------------------------- |
| |
| void SfxFrame::GetTargetList( TargetList& rList ) const |
| { |
| if ( !GetParentFrame() ) |
| { |
| // Einen Leerstring f"ur 'Kein Target' |
| rList.Insert( new String() ); |
| rList.Insert( new String( DEFINE_CONST_UNICODE( "_top" ) ) ); |
| rList.Insert( new String( DEFINE_CONST_UNICODE( "_parent" ) ) ); |
| rList.Insert( new String( DEFINE_CONST_UNICODE( "_blank" ) ) ); |
| rList.Insert( new String( DEFINE_CONST_UNICODE( "_self" ) ) ); |
| } |
| |
| SfxViewFrame* pView = GetCurrentViewFrame(); |
| if( pView && pView->GetViewShell() && pChildArr ) |
| { |
| sal_uInt16 nCount = pChildArr->Count(); |
| for ( sal_uInt16 n=0; n<nCount; n++) |
| { |
| SfxFrame* pFrame = (*pChildArr)[n]; |
| pFrame->GetTargetList( rList ); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| |
| SfxBroadcaster& SfxFrame::GetBroadcaster() const |
| { |
| return *pImp; |
| } |
| |
| sal_Bool SfxFrame::IsParent( SfxFrame *pFrame ) const |
| { |
| SfxFrame *pParent = pParentFrame; |
| while ( pParent ) |
| { |
| if ( pParent == pFrame ) |
| return sal_True; |
| pParent = pParent->pParentFrame; |
| } |
| |
| return sal_False; |
| } |
| |
| void SfxFrame::InsertTopFrame_Impl( SfxFrame* pFrame ) |
| { |
| SfxFrameArr_Impl& rArr = *SFX_APP()->Get_Impl()->pTopFrames; |
| rArr.Insert( pFrame, rArr.Count() ); |
| } |
| |
| void SfxFrame::RemoveTopFrame_Impl( SfxFrame* pFrame ) |
| { |
| SfxFrameArr_Impl& rArr = *SFX_APP()->Get_Impl()->pTopFrames; |
| rArr.Remove( rArr.GetPos( pFrame ) ); |
| } |
| |
| SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxViewFrame *p ) |
| : SfxPoolItem( nWhichId ), pFrame( p ? &p->GetFrame() : NULL ) |
| { |
| wFrame = pFrame; |
| } |
| |
| SfxFrameItem::SfxFrameItem( sal_uInt16 nWhichId, SfxFrame *p ): |
| SfxPoolItem( nWhichId ), |
| pFrame( p ), wFrame( p ) |
| { |
| } |
| |
| SfxFrameItem::SfxFrameItem( SfxFrame *p ): |
| SfxPoolItem( 0 ), |
| pFrame( p ), wFrame( p ) |
| { |
| } |
| |
| int SfxFrameItem::operator==( const SfxPoolItem &rItem ) const |
| { |
| return ((SfxFrameItem&)rItem).pFrame == pFrame && |
| ((SfxFrameItem&)rItem).wFrame == wFrame; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| String SfxFrameItem::GetValueText() const |
| { |
| return String(); |
| } |
| |
| SfxPoolItem* SfxFrameItem::Clone( SfxItemPool *) const |
| { |
| SfxFrameItem* pNew = new SfxFrameItem( wFrame); |
| pNew->SetFramePtr_Impl( pFrame ); |
| return pNew; |
| } |
| |
| sal_Bool SfxFrameItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 ) const |
| { |
| if ( wFrame ) |
| { |
| rVal <<= wFrame->GetFrameInterface(); |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| sal_Bool SfxFrameItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 ) |
| { |
| Reference < XFrame > xFrame; |
| if ( (rVal >>= xFrame) && xFrame.is() ) |
| { |
| SfxFrame* pFr = SfxFrame::GetFirst(); |
| while ( pFr ) |
| { |
| if ( pFr->GetFrameInterface() == xFrame ) |
| { |
| wFrame = pFrame = pFr; |
| return sal_True; |
| } |
| |
| pFr = SfxFrame::GetNext( *pFr ); |
| } |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| |
| SfxUsrAnyItem::SfxUsrAnyItem( sal_uInt16 nWhichId, const ::com::sun::star::uno::Any& rAny ) |
| : SfxPoolItem( nWhichId ) |
| { |
| aValue = rAny; |
| } |
| |
| int SfxUsrAnyItem::operator==( const SfxPoolItem& /*rItem*/ ) const |
| { |
| // return rItem.ISA( SfxUsrAnyItem ) && ((SfxUsrAnyItem&)rItem).aValue == aValue; |
| return sal_False; |
| } |
| |
| SfxPoolItem* SfxUsrAnyItem::Clone( SfxItemPool *) const |
| { |
| return new SfxUsrAnyItem( Which(), aValue ); |
| } |
| |
| sal_Bool SfxUsrAnyItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const |
| { |
| rVal = aValue; |
| return sal_True; |
| } |
| |
| sal_Bool SfxUsrAnyItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) |
| { |
| aValue = rVal; |
| return sal_True; |
| } |
| |
| SfxUnoFrameItem::SfxUnoFrameItem() |
| : SfxPoolItem() |
| , m_xFrame() |
| { |
| } |
| |
| SfxUnoFrameItem::SfxUnoFrameItem( sal_uInt16 nWhichId, const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& i_rFrame ) |
| : SfxPoolItem( nWhichId ) |
| , m_xFrame( i_rFrame ) |
| { |
| } |
| |
| int SfxUnoFrameItem::operator==( const SfxPoolItem& i_rItem ) const |
| { |
| return i_rItem.ISA( SfxUnoFrameItem ) && static_cast< const SfxUnoFrameItem& >( i_rItem ).m_xFrame == m_xFrame; |
| } |
| |
| SfxPoolItem* SfxUnoFrameItem::Clone( SfxItemPool* ) const |
| { |
| return new SfxUnoFrameItem( Which(), m_xFrame ); |
| } |
| |
| sal_Bool SfxUnoFrameItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const |
| { |
| rVal <<= m_xFrame; |
| return sal_True; |
| } |
| |
| sal_Bool SfxUnoFrameItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) |
| { |
| return ( rVal >>= m_xFrame ); |
| } |
| |
| SfxFrameIterator::SfxFrameIterator( const SfxFrame& rFrame, sal_Bool bRecur ) |
| : pFrame( &rFrame ) |
| , bRecursive( bRecur ) |
| {} |
| |
| SfxFrame* SfxFrameIterator::FirstFrame() |
| { |
| // GetFirst beginnt die Iteration beim ersten ChildFrame |
| return pFrame->GetChildFrame( 0 ); |
| } |
| |
| SfxFrame* SfxFrameIterator::NextFrame( SfxFrame& rPrev ) |
| { |
| // Zuerst auf Kinder testen, wenn Rekursion erw"unscht |
| SfxFrame *pRet = NULL; |
| if ( bRecursive ) |
| pRet = rPrev.GetChildFrame( 0 ); |
| if ( !pRet ) |
| { |
| // Anderenfalls mit den Geschwistern von rPrev weitermachen |
| pRet = NextSibling_Impl( rPrev ); |
| } |
| |
| return pRet; |
| } |
| |
| |
| SfxFrame* SfxFrameIterator::NextSibling_Impl( SfxFrame& rPrev ) |
| { |
| SfxFrame *pRet = NULL; |
| if ( &rPrev != pFrame ) |
| { |
| SfxFrameArr_Impl& rArr = *rPrev.pParentFrame->pChildArr; |
| sal_uInt16 nPos = rArr.GetPos( &rPrev ); |
| if ( nPos+1 < rArr.Count() ) |
| pRet = rArr[nPos+1]; |
| |
| if ( !pRet && rPrev.pParentFrame->pParentFrame ) |
| pRet = NextSibling_Impl( *rPrev.pParentFrame ); |
| } |
| |
| return pRet; |
| } |
| |
| sal_Bool SfxFrame::IsTop() const |
| { |
| return GetFrameInterface().is() ? GetFrameInterface()->isTop() : sal_False; |
| } |
| |
| sal_Bool SfxFrame::HasComponent() const |
| { |
| return sal_False; |
| } |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > SfxFrame::GetController() const |
| { |
| if ( pImp->pCurrentViewFrame && pImp->pCurrentViewFrame->GetViewShell() ) |
| return pImp->pCurrentViewFrame->GetViewShell()->GetController(); |
| else |
| return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > (); |
| } |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxFrame::GetFrameInterface() const |
| { |
| return pImp->xFrame; |
| } |
| |
| void SfxFrame::SetFrameInterface_Impl( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) |
| { |
| pImp->xFrame = rFrame; |
| com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder; |
| if ( !rFrame.is() && GetCurrentViewFrame() ) |
| GetCurrentViewFrame()->GetBindings().SetRecorder_Impl( xRecorder ); |
| } |
| |
| void SfxFrame::Appear() |
| { |
| if ( GetCurrentViewFrame() ) |
| { |
| GetCurrentViewFrame()->Show(); |
| GetWindow().Show(); |
| pImp->xFrame->getContainerWindow()->setVisible( sal_True ); |
| if ( pParentFrame ) |
| pParentFrame->Appear(); |
| Reference < ::com::sun::star::awt::XTopWindow > xTopWindow( pImp->xFrame->getContainerWindow(), UNO_QUERY ); |
| if ( xTopWindow.is() ) |
| xTopWindow->toFront(); |
| } |
| } |
| |
| void SfxFrame::AppearWithUpdate() |
| { |
| Appear(); |
| if ( GetCurrentViewFrame() ) |
| GetCurrentViewFrame()->GetDispatcher()->Update_Impl( sal_True ); |
| } |
| |
| void SfxFrame::SetOwnsBindings_Impl( sal_Bool bSet ) |
| { |
| pImp->bOwnsBindings = bSet; |
| } |
| |
| sal_Bool SfxFrame::OwnsBindings_Impl() const |
| { |
| return pImp->bOwnsBindings; |
| } |
| |
| void SfxFrame::SetToolSpaceBorderPixel_Impl( const SvBorder& rBorder ) |
| { |
| pImp->aBorder = rBorder; |
| SfxViewFrame *pF = GetCurrentViewFrame(); |
| if ( pF ) |
| { |
| Point aPos ( rBorder.Left(), rBorder.Top() ); |
| Size aSize( GetWindow().GetOutputSizePixel() ); |
| long nDeltaX = rBorder.Left() + rBorder.Right(); |
| if ( aSize.Width() > nDeltaX ) |
| aSize.Width() -= nDeltaX; |
| else |
| aSize.Width() = 0; |
| |
| long nDeltaY = rBorder.Top() + rBorder.Bottom(); |
| if ( aSize.Height() > nDeltaY ) |
| aSize.Height() -= nDeltaY; |
| else |
| aSize.Height() = 0; |
| |
| if ( GetParentFrame() ) |
| { |
| sal_Bool bHasTools = rBorder.Left() != rBorder.Right() || rBorder.Top() != rBorder.Bottom(); |
| pF->GetWindow().SetBorderStyle( bHasTools ? WINDOW_BORDER_NORMAL : WINDOW_BORDER_NOBORDER ); |
| } |
| |
| pF->GetWindow().SetPosSizePixel( aPos, aSize ); |
| } |
| } |
| |
| Rectangle SfxFrame::GetTopOuterRectPixel_Impl() const |
| { |
| Size aSize( GetWindow().GetOutputSizePixel() ); |
| Point aPoint; |
| return ( Rectangle ( aPoint, aSize ) ); |
| } |
| |
| SfxWorkWindow* SfxFrame::GetWorkWindow_Impl() const |
| { |
| if ( pImp->pWorkWin ) |
| return pImp->pWorkWin; |
| else if ( pParentFrame ) |
| return pParentFrame->GetWorkWindow_Impl(); |
| else |
| return NULL; |
| } |
| |
| void SfxFrame::SetWorkWindow_Impl( SfxWorkWindow* pWorkwin ) |
| { |
| pImp->pWorkWin = pWorkwin; |
| } |
| |
| void SfxFrame::CreateWorkWindow_Impl() |
| { |
| SfxFrame* pFrame = this; |
| |
| if ( IsInPlace() ) |
| { |
| // this makes sence only for inplace activated objects |
| try |
| { |
| Reference < XChild > xChild( GetCurrentDocument()->GetModel(), UNO_QUERY ); |
| if ( xChild.is() ) |
| { |
| Reference < XModel > xParent( xChild->getParent(), UNO_QUERY ); |
| if ( xParent.is() ) |
| { |
| Reference< XController > xParentCtrler = xParent->getCurrentController(); |
| if ( xParentCtrler.is() ) |
| { |
| Reference < XFrame > xFrame( xParentCtrler->getFrame() ); |
| SfxFrame* pFr = SfxFrame::GetFirst(); |
| while ( pFr ) |
| { |
| if ( pFr->GetFrameInterface() == xFrame ) |
| { |
| pFrame = pFr; |
| break; |
| } |
| |
| pFr = SfxFrame::GetNext( *pFr ); |
| } |
| } |
| } |
| } |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(0,"SfxFrame::CreateWorkWindow_Impl: Exception cachted. Please try to submit a repoducable bug !"); |
| } |
| } |
| |
| pImp->pWorkWin = new SfxFrameWorkWin_Impl( &pFrame->GetWindow(), this, pFrame ); |
| } |
| |
| void SfxFrame::GrabFocusOnComponent_Impl() |
| { |
| if ( pImp->bReleasingComponent ) |
| { |
| GetWindow().GrabFocus(); |
| return; |
| } |
| |
| Window* pFocusWindow = &GetWindow(); |
| if ( GetCurrentViewFrame() && GetCurrentViewFrame()->GetViewShell() && GetCurrentViewFrame()->GetViewShell()->GetWindow() ) |
| pFocusWindow = GetCurrentViewFrame()->GetViewShell()->GetWindow(); |
| |
| if( !pFocusWindow->HasChildPathFocus() ) |
| pFocusWindow->GrabFocus(); |
| } |
| |
| void SfxFrame::ReleasingComponent_Impl( sal_Bool bSet ) |
| { |
| pImp->bReleasingComponent = bSet; |
| } |
| |
| sal_Bool SfxFrame::IsInPlace() const |
| { |
| return pImp->bInPlace; |
| } |
| |
| void SfxFrame::SetInPlace_Impl( sal_Bool bSet ) |
| { |
| pImp->bInPlace = bSet; |
| } |
| |
| void SfxFrame::Resize() |
| { |
| if ( IsClosing_Impl() ) |
| return; |
| |
| if ( OwnsBindings_Impl() ) |
| { |
| if ( IsInPlace() ) |
| { |
| SetToolSpaceBorderPixel_Impl( SvBorder() ); |
| } |
| else |
| { |
| // check for IPClient that contains UIactive object or object that is currently UI activating |
| SfxWorkWindow *pWork = GetWorkWindow_Impl(); |
| SfxInPlaceClient* pClient = GetCurrentViewFrame()->GetViewShell() ? GetCurrentViewFrame()->GetViewShell()->GetUIActiveIPClient_Impl() : 0; |
| if ( pClient ) |
| { |
| uno::Reference < lang::XUnoTunnel > xObj( pClient->GetObject()->getComponent(), uno::UNO_QUERY ); |
| uno::Sequence < sal_Int8 > aSeq( SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence() ); |
| sal_Int64 nHandle = (xObj.is()? xObj->getSomething( aSeq ): 0); |
| if ( nHandle ) |
| { |
| SfxObjectShell* pDoc = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle )); |
| pWork = SfxViewFrame::GetFirst( pDoc )->GetFrame().GetWorkWindow_Impl(); |
| } |
| } |
| |
| if ( pWork ) |
| { |
| pWork->ArrangeChilds_Impl(); |
| pWork->ShowChilds_Impl(); |
| } |
| |
| // problem in presence of UIActive object: when the window is resized, but the toolspace border |
| // remains the same, setting the toolspace border at the ContainerEnvironment doesn't force a |
| // resize on the IPEnvironment; without that no resize is called for the SfxViewFrame. So always |
| // set the window size of the SfxViewFrame explicit. |
| SetToolSpaceBorderPixel_Impl( pImp->aBorder ); |
| } |
| } |
| else if ( pImp->pCurrentViewFrame ) |
| { |
| pImp->pCurrentViewFrame->GetWindow().SetSizePixel( GetWindow().GetOutputSizePixel() ); |
| } |
| |
| } |
| |
| SfxFrame* SfxFrame::GetFirst() |
| { |
| if ( !pFramesArr_Impl ) |
| return 0; |
| return pFramesArr_Impl->Count() ? pFramesArr_Impl->GetObject(0) : 0; |
| } |
| |
| SfxFrame* SfxFrame::GetNext( SfxFrame& rFrame ) |
| { |
| sal_uInt16 nPos = pFramesArr_Impl->GetPos( &rFrame ); |
| if ( nPos+1 < pFramesArr_Impl->Count() ) |
| return pFramesArr_Impl->GetObject(nPos+1); |
| else |
| return NULL; |
| } |
| |
| const SfxPoolItem* SfxFrame::OpenDocumentSynchron( SfxItemSet& i_rSet, const Reference< XFrame >& i_rTargetFrame ) |
| { |
| i_rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, i_rTargetFrame ) ); |
| i_rSet.ClearItem( SID_TARGETNAME ); |
| return SFX_APP()->GetDispatcher_Impl()->Execute( SID_OPENDOC, SFX_CALLMODE_SYNCHRON, i_rSet ); |
| } |
| |