| /************************************************************** |
| * |
| * 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" |
| |
| #ifndef _TOOLBOX_HXX //autogen |
| #include <vcl/toolbox.hxx> |
| #endif |
| #ifndef _RCID_H |
| #include <tools/rcid.h> |
| #endif |
| #include <unotools/viewoptions.hxx> |
| #include <com/sun/star/frame/XController.hpp> |
| #include <com/sun/star/frame/XFrame.hpp> |
| #include <com/sun/star/util/XCloseable.hpp> |
| #include <cppuhelper/implbase1.hxx> |
| |
| #ifndef GCC |
| #endif |
| |
| #include <sfx2/childwin.hxx> |
| #include <sfx2/app.hxx> |
| #include "arrdecl.hxx" |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/module.hxx> |
| #include <sfx2/dockwin.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include "workwin.hxx" |
| |
| static const sal_uInt16 nVersion = 2; |
| |
| DBG_NAME(SfxChildWindow) |
| |
| SV_IMPL_PTRARR( SfxChildWinContextArr_Impl, SfxChildWinContextFactory* ); |
| |
| struct SfxChildWindow_Impl |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > xFrame; |
| ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > xListener; |
| SfxChildWinFactory* pFact; |
| sal_Bool bHideNotDelete; |
| sal_Bool bVisible; |
| sal_Bool bHideAtToggle; |
| sal_Bool bWantsFocus; |
| SfxModule* pContextModule; |
| SfxWorkWindow* pWorkWin; |
| }; |
| |
| // ----------------------------------------------------------------------- |
| |
| class DisposeListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener > |
| { |
| public: |
| DisposeListener( SfxChildWindow* pOwner , |
| SfxChildWindow_Impl* pData ) |
| : m_pOwner( pOwner ) |
| , m_pData ( pData ) |
| {} |
| |
| virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aSource ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > xSelfHold( this ); |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComp( aSource.Source, ::com::sun::star::uno::UNO_QUERY ); |
| if( xComp.is() ) |
| xComp->removeEventListener( this ); |
| |
| if( m_pOwner && m_pData ) |
| { |
| m_pData->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >(); |
| |
| if ( m_pData->pWorkWin ) |
| { |
| // m_pOwner and m_pData will be killed |
| m_pData->xFrame = ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >(); |
| m_pData->pWorkWin->GetBindings().Execute( m_pOwner->GetType() ); |
| } |
| else |
| { |
| delete m_pOwner; |
| } |
| |
| m_pOwner = NULL; |
| m_pData = NULL; |
| } |
| } |
| |
| private: |
| SfxChildWindow* m_pOwner; |
| SfxChildWindow_Impl* m_pData ; |
| }; |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool GetPosSizeFromString( const String& rStr, Point& rPos, Size& rSize ) |
| { |
| if ( rStr.GetTokenCount('/') != 4 ) |
| return sal_False; |
| |
| xub_StrLen nIdx = 0; |
| rPos.X() = rStr.GetToken(0, '/', nIdx).ToInt32(); |
| rPos.Y() = rStr.GetToken(0, '/', nIdx).ToInt32(); |
| rSize.Width() = rStr.GetToken(0, '/', nIdx).ToInt32(); |
| rSize.Height() = rStr.GetToken(0, '/', nIdx).ToInt32(); |
| |
| // negative sizes are invalid |
| if ( rSize.Width() < 0 || rSize.Height() < 0 ) |
| return sal_False; |
| |
| return sal_True; |
| } |
| |
| sal_Bool GetSplitSizeFromString( const String& rStr, Size& rSize ) |
| { |
| xub_StrLen nIndex = rStr.Search( ',' ); |
| if ( nIndex != STRING_NOTFOUND ) |
| { |
| String aStr = rStr.Copy( nIndex+1 ); |
| |
| sal_Int32 nCount = aStr.GetTokenCount(';'); |
| if ( nCount != 2 ) |
| return sal_False; |
| |
| rSize.Width() = aStr.GetToken(0, ';' ).ToInt32(); |
| rSize.Height() = aStr.GetToken(1, ';' ).ToInt32(); |
| |
| // negative sizes are invalid |
| if ( rSize.Width() < 0 || rSize.Height() < 0 ) |
| return sal_False; |
| |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| //========================================================================= |
| SfxChildWindow::SfxChildWindow(Window *pParentWindow, sal_uInt16 nId) |
| : pParent(pParentWindow) |
| , nType(nId) |
| , eChildAlignment(SFX_ALIGN_NOALIGNMENT) |
| , pWindow(0L) |
| { |
| pImp = new SfxChildWindow_Impl; |
| pImp->pFact = 0L; |
| pImp->bHideNotDelete = sal_False; |
| pImp->bHideAtToggle = sal_False; |
| pImp->bWantsFocus = sal_True; |
| pImp->bVisible = sal_True; |
| pImp->pContextModule = NULL; |
| pImp->pWorkWin = NULL; |
| |
| pContext = 0L; |
| DBG_CTOR(SfxChildWindow,0); |
| } |
| |
| void SfxChildWindow::Destroy() |
| { |
| if ( GetFrame().is() ) |
| { |
| pImp->pWorkWin = NULL; |
| try |
| { |
| ::com::sun::star::uno::Reference < ::com::sun::star::util::XCloseable > xClose( GetFrame(), ::com::sun::star::uno::UNO_QUERY ); |
| if ( xClose.is() ) |
| xClose->close( sal_True ); |
| else |
| GetFrame()->dispose(); |
| } |
| catch ( com::sun::star::uno::Exception& ) |
| { |
| } |
| } |
| else |
| delete this; |
| } |
| |
| //------------------------------------------------------------------------- |
| SfxChildWindow::~SfxChildWindow() |
| { |
| DBG_DTOR(SfxChildWindow,0); |
| if ( pContext ) |
| delete pContext; |
| if ( pWindow ) |
| delete pWindow; |
| delete pImp; |
| } |
| |
| //------------------------------------------------------------------------- |
| SfxChildWindow* SfxChildWindow::CreateChildWindow( sal_uInt16 nId, |
| Window *pParent, SfxBindings* pBindings, SfxChildWinInfo& rInfo) |
| { |
| SfxChildWindow *pChild=0; |
| SfxChildWinFactory* pFact=0; |
| sal_uInt16 nOldMode = Application::GetSystemWindowMode(); |
| |
| // Zuerst ChildWindow im SDT suchen; "Uberlagerungen m"ussen mit einem |
| // ChildWindowContext realisiert werden |
| SfxApplication *pApp = SFX_APP(); |
| { |
| SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl(); |
| for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) |
| { |
| pFact = rFactories[nFactory]; |
| if ( pFact->nId == nId ) |
| { |
| SfxChildWinInfo& rFactInfo = pFact->aInfo; |
| if ( rInfo.bVisible ) |
| { |
| if ( pBindings ) |
| pBindings->ENTERREGISTRATIONS(); |
| SfxChildWinInfo aInfo = rFactInfo; |
| Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE ); |
| pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo ); |
| Application::SetSystemWindowMode( nOldMode ); |
| if ( pBindings ) |
| pBindings->LEAVEREGISTRATIONS(); |
| } |
| |
| break; |
| } |
| } |
| } |
| |
| SfxDispatcher *pDisp = pBindings->GetDispatcher_Impl(); |
| SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0; |
| if ( !pChild && pMod ) |
| { |
| SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl(); |
| if ( pFactories ) |
| { |
| SfxChildWinFactArr_Impl &rFactories = *pFactories; |
| for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) |
| { |
| pFact = rFactories[nFactory]; |
| if ( pFact->nId == nId ) |
| { |
| SfxChildWinInfo& rFactInfo = pFact->aInfo; |
| if ( rInfo.bVisible ) |
| { |
| if ( pBindings ) |
| pBindings->ENTERREGISTRATIONS(); |
| SfxChildWinInfo aInfo = rFactInfo; |
| Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE ); |
| pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo ); |
| Application::SetSystemWindowMode( nOldMode ); |
| if ( pBindings ) |
| pBindings->LEAVEREGISTRATIONS(); |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| |
| if ( pChild ) |
| pChild->SetFactory_Impl( pFact ); |
| |
| DBG_ASSERT(pFact && (pChild || !rInfo.bVisible), "ChildWindow-Typ nicht registriert!"); |
| |
| if ( pChild && !pChild->pWindow ) |
| { |
| DELETEZ(pChild); |
| DBG_WARNING("ChildWindow hat kein Fenster!"); |
| } |
| |
| return pChild; |
| } |
| |
| //------------------------------------------------------------------------- |
| void SfxChildWindow::SaveStatus(const SfxChildWinInfo& rInfo) |
| { |
| sal_uInt16 nID = GetType(); |
| |
| String aWinData( 'V' ); |
| aWinData += String::CreateFromInt32( nVersion ); |
| aWinData += ','; |
| aWinData += rInfo.bVisible ? 'V' : 'H'; |
| aWinData += ','; |
| aWinData += String::CreateFromInt32( rInfo.nFlags ); |
| if ( rInfo.aExtraString.Len() ) |
| { |
| aWinData += ','; |
| aWinData += rInfo.aExtraString; |
| } |
| |
| SvtViewOptions aWinOpt( E_WINDOW, String::CreateFromInt32( nID ) ); |
| // aWinOpt.SetPosition( rInfo.aPos.X(), rInfo.aPos.Y() ); |
| // aWinOpt.SetSize( rInfo.aSize.Width(), rInfo.aSize.Height() ); |
| aWinOpt.SetWindowState( String( rInfo.aWinState, RTL_TEXTENCODING_UTF8 ) ); |
| |
| ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq(1); |
| aSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Data") ); |
| aSeq[0].Value <<= ::rtl::OUString( aWinData ); |
| aWinOpt.SetUserData( aSeq ); |
| |
| // ... but save status at runtime! |
| pImp->pFact->aInfo = rInfo; |
| } |
| |
| //------------------------------------------------------------------------- |
| void SfxChildWindow::SetAlignment(SfxChildAlignment eAlign) |
| { |
| DBG_CHKTHIS(SfxChildWindow,0); |
| |
| eChildAlignment = eAlign; |
| } |
| |
| //------------------------------------------------------------------------- |
| void SfxChildWindow::SetPosSizePixel(const Point& rPoint, Size& rSize) |
| { |
| DBG_CHKTHIS(SfxChildWindow,0); |
| |
| pWindow->SetPosSizePixel(rPoint, rSize); |
| } |
| |
| //------------------------------------------------------------------------- |
| SfxChildWinInfo SfxChildWindow::GetInfo() const |
| { |
| DBG_CHKTHIS(SfxChildWindow,0); |
| |
| SfxChildWinInfo aInfo; |
| aInfo.aPos = pWindow->GetPosPixel(); |
| aInfo.aSize = pWindow->GetSizePixel(); |
| if ( pWindow->IsSystemWindow() ) |
| { |
| sal_uIntPtr nMask = WINDOWSTATE_MASK_POS | WINDOWSTATE_MASK_STATE; |
| if ( pWindow->GetStyle() & WB_SIZEABLE ) |
| nMask |= ( WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT ); |
| aInfo.aWinState = ((SystemWindow*)pWindow)->GetWindowState( nMask ); |
| } |
| else if ( pWindow->GetType() == RSC_DOCKINGWINDOW ) |
| { |
| if (((DockingWindow*)pWindow)->GetFloatingWindow() ) |
| aInfo.aWinState = ((DockingWindow*)pWindow)->GetFloatingWindow()->GetWindowState(); |
| else |
| { |
| SfxChildWinInfo aTmpInfo; |
| ((SfxDockingWindow*)pWindow)->FillInfo( aTmpInfo ); |
| aInfo.aExtraString = aTmpInfo.aExtraString; |
| } |
| } |
| |
| aInfo.bVisible = pImp->bVisible; |
| aInfo.nFlags = 0; |
| return aInfo; |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_uInt16 SfxChildWindow::GetPosition() |
| { |
| return pImp->pFact->nPos; |
| } |
| |
| #if 0 |
| static void ImplWindowStateFromStr( Point rPos, Size rSize, const ByteString& rStr ) |
| { |
| sal_uIntPtr nValidMask = 0; |
| xub_StrLen nIndex = 0; |
| ByteString aTokenStr; |
| |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rPos.X() = aTokenStr.ToInt32(); |
| nValidMask |= WINDOWSTATE_MASK_X; |
| } |
| |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rPos.Y() = aTokenStr.ToInt32(); |
| nValidMask |= WINDOWSTATE_MASK_Y; |
| } |
| |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rSize.Width() = aTokenStr.ToInt32(); |
| nValidMask |= WINDOWSTATE_MASK_WIDTH; |
| } |
| |
| aTokenStr = rStr.GetToken( 0, ';', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rSize.Height() = aTokenStr.ToInt32(); |
| nValidMask |= WINDOWSTATE_MASK_HEIGHT; |
| } |
| } |
| #endif |
| |
| //------------------------------------------------------------------------- |
| void SfxChildWindow::InitializeChildWinFactory_Impl( sal_uInt16 nId, SfxChildWinInfo& rInfo ) |
| { |
| // load configuration |
| SvtViewOptions aWinOpt( E_WINDOW, String::CreateFromInt32( nId ) ); |
| |
| if ( aWinOpt.Exists() ) |
| rInfo.bVisible = aWinOpt.IsVisible(); // set state from configuration. Can be overwritten by UserData, see below |
| |
| ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq = aWinOpt.GetUserData(); |
| |
| ::rtl::OUString aTmp; |
| if ( aSeq.getLength() ) |
| aSeq[0].Value >>= aTmp; |
| |
| String aWinData( aTmp ); |
| rInfo.aWinState = ByteString( String(aWinOpt.GetWindowState()), RTL_TEXTENCODING_UTF8 ); |
| |
| //ImplWindowStateFromStr( rInfo.aPos, rInfo.aSize, ByteString( aWinState, RTL_TEXTENCODING_UTF8 ) ); |
| |
| if ( aWinData.Len() ) |
| { |
| // Nach Versionskennung suchen |
| if ( aWinData.GetChar((sal_uInt16)0) != 0x0056 ) // 'V' = 56h |
| // Keine Versionskennung, daher nicht verwenden |
| return; |
| |
| // 'V' l"oschen |
| aWinData.Erase(0,1); |
| |
| // Version lesen |
| char cToken = ','; |
| sal_uInt16 nPos = aWinData.Search( cToken ); |
| sal_uInt16 nActVersion = (sal_uInt16)aWinData.Copy( 0, nPos + 1 ).ToInt32(); |
| if ( nActVersion != nVersion ) |
| return; |
| |
| aWinData.Erase(0,nPos+1); |
| |
| //aWinOpt.GetPosition( rInfo.aPos.X(), rInfo.aPos.Y() ); |
| //aWinOpt.GetSize( rInfo.aSize.Width(), rInfo.aSize.Height() ); |
| |
| // Sichtbarkeit laden: ist als ein char codiert |
| rInfo.bVisible = (aWinData.GetChar(0) == 0x0056); // 'V' = 56h |
| aWinData.Erase(0,1); |
| nPos = aWinData.Search( cToken ); |
| if (nPos != STRING_NOTFOUND) |
| { |
| sal_uInt16 nNextPos = aWinData.Search( cToken, 2 ); |
| if ( nNextPos != STRING_NOTFOUND ) |
| { |
| // es gibt noch Extra-Information |
| rInfo.nFlags = (sal_uInt16)aWinData.Copy( nPos+1, nNextPos - nPos - 1 ).ToInt32(); |
| aWinData.Erase( nPos, nNextPos-nPos+1 ); |
| rInfo.aExtraString = aWinData; |
| } |
| else |
| rInfo.nFlags = (sal_uInt16)aWinData.Copy( nPos+1 ).ToInt32(); |
| } |
| } |
| } |
| |
| void SfxChildWindow::CreateContext( sal_uInt16 nContextId, SfxBindings& rBindings ) |
| { |
| SfxChildWindowContext *pCon = NULL; |
| SfxChildWinFactory* pFact=0; |
| SfxApplication *pApp = SFX_APP(); |
| SfxDispatcher *pDisp = rBindings.GetDispatcher_Impl(); |
| SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0; |
| if ( pMod ) |
| { |
| SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl(); |
| if ( pFactories ) |
| { |
| SfxChildWinFactArr_Impl &rFactories = *pFactories; |
| for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) |
| { |
| pFact = rFactories[nFactory]; |
| if ( pFact->nId == GetType() ) |
| { |
| DBG_ASSERT( pFact->pArr, "Kein Kontext angemeldet!" ); |
| if ( !pFact->pArr ) |
| break; |
| |
| SfxChildWinContextFactory *pConFact=0; |
| for ( sal_uInt16 n=0; n<pFact->pArr->Count(); ++n ) |
| { |
| pConFact = (*pFact->pArr)[n]; |
| rBindings.ENTERREGISTRATIONS(); |
| if ( pConFact->nContextId == nContextId ) |
| { |
| SfxChildWinInfo aInfo = pFact->aInfo; |
| pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo ); |
| pCon->nContextId = pConFact->nContextId; |
| pImp->pContextModule = pMod; |
| } |
| rBindings.LEAVEREGISTRATIONS(); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| if ( !pCon ) |
| { |
| SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl(); |
| for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) |
| { |
| pFact = rFactories[nFactory]; |
| if ( pFact->nId == GetType() ) |
| { |
| DBG_ASSERT( pFact->pArr, "Kein Kontext angemeldet!" ); |
| if ( !pFact->pArr ) |
| break; |
| |
| SfxChildWinContextFactory *pConFact=0; |
| for ( sal_uInt16 n=0; n<pFact->pArr->Count(); ++n ) |
| { |
| pConFact = (*pFact->pArr)[n]; |
| rBindings.ENTERREGISTRATIONS(); |
| if ( pConFact->nContextId == nContextId ) |
| { |
| SfxChildWinInfo aInfo = pFact->aInfo; |
| pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo ); |
| pCon->nContextId = pConFact->nContextId; |
| pImp->pContextModule = NULL; |
| } |
| rBindings.LEAVEREGISTRATIONS(); |
| } |
| break; |
| } |
| } |
| } |
| |
| if ( !pCon ) |
| { |
| DBG_ERROR( "Kein geeigneter Context gefunden!" ); |
| return; |
| } |
| |
| if ( pContext ) |
| delete( pContext ); |
| pContext = pCon; |
| pContext->GetWindow()->SetSizePixel( pWindow->GetOutputSizePixel() ); |
| pContext->GetWindow()->Show(); |
| } |
| |
| SfxChildWindowContext::SfxChildWindowContext( sal_uInt16 nId ) |
| : pWindow( NULL ) |
| , nContextId( nId ) |
| { |
| } |
| |
| SfxChildWindowContext::~SfxChildWindowContext() |
| { |
| delete pWindow; |
| } |
| |
| FloatingWindow* SfxChildWindowContext::GetFloatingWindow() const |
| { |
| Window *pParent = pWindow->GetParent(); |
| if ( pParent->GetType() == RSC_DOCKINGWINDOW || pParent->GetType() == RSC_TOOLBOX ) |
| { |
| return ((DockingWindow*)pParent)->GetFloatingWindow(); |
| } |
| else if ( pParent->GetType() == RSC_FLOATINGWINDOW ) |
| { |
| return (FloatingWindow*) pParent; |
| } |
| else |
| { |
| DBG_ERROR("Kein FloatingWindow-Context!"); |
| return NULL; |
| } |
| } |
| |
| SfxChildAlignment SfxChildWindowContext::GetAlignment() const |
| { |
| Window *pParent = pWindow->GetParent(); |
| if ( pParent->GetType() == RSC_DOCKINGWINDOW ) |
| { |
| return ((SfxDockingWindow*)pParent)->GetAlignment(); |
| } |
| else if ( pParent->GetType() == RSC_TOOLBOX ) |
| { |
| HACK(noch nicht verwendet und noch nicht implementiert); |
| return SFX_ALIGN_NOALIGNMENT; |
| } |
| else |
| return SFX_ALIGN_NOALIGNMENT; |
| } |
| |
| void SfxChildWindowContext::Resizing( Size& ) |
| { |
| } |
| |
| sal_Bool SfxChildWindowContext::Close() |
| { |
| return sal_True; |
| } |
| |
| void SfxChildWindow::SetFactory_Impl( SfxChildWinFactory *pF ) |
| { |
| pImp->pFact = pF; |
| } |
| |
| void SfxChildWindow::SetHideNotDelete( sal_Bool bOn ) |
| { |
| pImp->bHideNotDelete = bOn; |
| } |
| |
| sal_Bool SfxChildWindow::IsHideNotDelete() const |
| { |
| return pImp->bHideNotDelete; |
| } |
| |
| void SfxChildWindow::SetHideAtToggle( sal_Bool bOn ) |
| { |
| pImp->bHideAtToggle = bOn; |
| } |
| |
| sal_Bool SfxChildWindow::IsHideAtToggle() const |
| { |
| return pImp->bHideAtToggle; |
| } |
| |
| void SfxChildWindow::SetWantsFocus( sal_Bool bSet ) |
| { |
| pImp->bWantsFocus = bSet; |
| } |
| |
| sal_Bool SfxChildWindow::WantsFocus() const |
| { |
| return pImp->bWantsFocus; |
| } |
| |
| sal_Bool SfxChildWinInfo::GetExtraData_Impl |
| ( |
| SfxChildAlignment *pAlign, |
| SfxChildAlignment *pLastAlign, |
| Size *pSize, |
| sal_uInt16 *pLine, |
| sal_uInt16 *pPos |
| ) const |
| { |
| // ung"ultig? |
| if ( !aExtraString.Len() ) |
| return sal_False; |
| String aStr; |
| sal_uInt16 nPos = aExtraString.SearchAscii("AL:"); |
| if ( nPos == STRING_NOTFOUND ) |
| return sal_False; |
| |
| // Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn |
| // er nicht vorhanden ist, liegt eine "altere Version vor |
| if ( nPos != STRING_NOTFOUND ) |
| { |
| sal_uInt16 n1 = aExtraString.Search('(', nPos); |
| if ( n1 != STRING_NOTFOUND ) |
| { |
| sal_uInt16 n2 = aExtraString.Search(')', n1); |
| if ( n2 != STRING_NOTFOUND ) |
| { |
| // Alignment-String herausschneiden |
| aStr = aExtraString.Copy(nPos, n2 - nPos + 1); |
| aStr.Erase(nPos, n1-nPos+1); |
| } |
| } |
| } |
| |
| // Zuerst das Alignment extrahieren |
| if ( !aStr.Len() ) |
| return sal_False; |
| if ( pAlign ) |
| *pAlign = (SfxChildAlignment) (sal_uInt16) aStr.ToInt32(); |
| |
| // Dann das LastAlignment |
| nPos = aStr.Search(','); |
| if ( nPos == STRING_NOTFOUND ) |
| return sal_False; |
| aStr.Erase(0, nPos+1); |
| if ( pLastAlign ) |
| *pLastAlign = (SfxChildAlignment) (sal_uInt16) aStr.ToInt32(); |
| |
| // Dann die Splitting-Informationen |
| nPos = aStr.Search(','); |
| if ( nPos == STRING_NOTFOUND ) |
| // Dockt nicht in einem Splitwindow |
| return sal_True; |
| aStr.Erase(0, nPos+1); |
| Point aChildPos; |
| Size aChildSize; |
| if ( GetPosSizeFromString( aStr, aChildPos, aChildSize ) ) |
| { |
| if ( pSize ) |
| *pSize = aChildSize; |
| if ( pLine ) |
| *pLine = (sal_uInt16) aChildPos.X(); |
| if ( pPos ) |
| *pPos = (sal_uInt16) aChildPos.Y(); |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| sal_Bool SfxChildWindow::IsVisible() const |
| { |
| return pImp->bVisible; |
| } |
| |
| void SfxChildWindow::SetVisible_Impl( sal_Bool bVis ) |
| { |
| pImp->bVisible = bVis; |
| } |
| |
| void SfxChildWindow::Hide() |
| { |
| switch ( pWindow->GetType() ) |
| { |
| case RSC_DOCKINGWINDOW : |
| ((DockingWindow*)pWindow)->Hide(); |
| break; |
| case RSC_TOOLBOX : |
| ((ToolBox*)pWindow)->Hide(); |
| break; |
| default: |
| pWindow->Hide(); |
| break; |
| } |
| } |
| |
| |
| |
| void SfxChildWindow::Show( sal_uInt16 nFlags ) |
| { |
| switch ( pWindow->GetType() ) |
| { |
| case RSC_DOCKINGWINDOW : |
| ((DockingWindow*)pWindow)->Show( sal_True, nFlags ); |
| break; |
| case RSC_TOOLBOX : |
| ((ToolBox*)pWindow)->Show( sal_True, nFlags ); |
| break; |
| default: |
| pWindow->Show( sal_True, nFlags ); |
| break; |
| } |
| } |
| |
| Window* SfxChildWindow::GetContextWindow( SfxModule *pModule ) const |
| { |
| return pModule == pImp->pContextModule && pContext ? pContext->GetWindow(): 0; |
| } |
| |
| void SfxChildWindow::SetWorkWindow_Impl( SfxWorkWindow* pWin ) |
| { |
| pImp->pWorkWin = pWin; |
| if ( pWin && pWindow->HasChildPathFocus() ) |
| pImp->pWorkWin->SetActiveChild_Impl( pWindow ); |
| } |
| |
| //SfxWorkWindow* SfxChildWindow::GetWorkWindow_Impl() const |
| //{ |
| // return pImp->pWorkWin; |
| //} |
| |
| void SfxChildWindow::Activate_Impl() |
| { |
| if(pImp->pWorkWin!=NULL) //@#60568# |
| pImp->pWorkWin->SetActiveChild_Impl( pWindow ); |
| } |
| |
| void SfxChildWindow::Deactivate_Impl() |
| { |
| // pImp->pWorkWin->SetActiveChild_Impl( NULL ); |
| } |
| |
| sal_Bool SfxChildWindow::QueryClose() |
| { |
| sal_Bool bAllow = sal_True; |
| |
| if ( pImp->xFrame.is() ) |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > xCtrl = pImp->xFrame->getController(); |
| if ( xCtrl.is() ) |
| bAllow = xCtrl->suspend( sal_True ); |
| } |
| |
| if ( bAllow ) |
| bAllow = !GetWindow()->IsInModalMode(); |
| |
| return bAllow; |
| } |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxChildWindow::GetFrame() |
| { |
| return pImp->xFrame; |
| } |
| |
| void SfxChildWindow::SetFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > & rFrame ) |
| { |
| // Do nothing if nothing will be changed ... |
| if( pImp->xFrame != rFrame ) |
| { |
| // ... but stop listening on old frame, if connection exist! |
| if( pImp->xFrame.is() ) |
| pImp->xFrame->removeEventListener( pImp->xListener ); |
| |
| // If new frame isnt NULL -> we must guarantee valid listener for disposing events. |
| // Use already existing or create new one. |
| if( rFrame.is() ) |
| if( !pImp->xListener.is() ) |
| pImp->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >( new DisposeListener( this, pImp ) ); |
| |
| // Set new frame in data container |
| // and build new listener connection, if neccessary. |
| pImp->xFrame = rFrame; |
| if( pImp->xFrame.is() ) |
| pImp->xFrame->addEventListener( pImp->xListener ); |
| } |
| } |
| |
| sal_Bool SfxChildWindow::CanGetFocus() const |
| { |
| return !(pImp->pFact->aInfo.nFlags & SFX_CHILDWIN_CANTGETFOCUS); |
| } |
| |
| void SfxChildWindowContext::RegisterChildWindowContext(SfxModule* pMod, sal_uInt16 nId, SfxChildWinContextFactory* pFact) |
| { |
| SFX_APP()->RegisterChildWindowContext_Impl( pMod, nId, pFact ); |
| } |
| |
| void SfxChildWindow::RegisterChildWindow(SfxModule* pMod, SfxChildWinFactory* pFact) |
| { |
| SFX_APP()->RegisterChildWindow_Impl( pMod, pFact ); |
| } |
| |