sfx2/source/appl/childwin.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: childwin.cxx,v $
  10  * $Revision: 1.28 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sfx2.hxx"
  33
  34 #ifndef _TOOLBOX_HXX //autogen
  35 #include <vcl/toolbox.hxx>
  36 #endif
  37 #ifndef _RCID_H
  38 #include <tools/rcid.h>
  39 #endif
  40 #include <svtools/viewoptions.hxx>
  41 #include <com/sun/star/frame/XController.hpp>
  42 #include <com/sun/star/frame/XFrame.hpp>
  43 #include <com/sun/star/util/XCloseable.hpp>
  44 #include <cppuhelper/implbase1.hxx>
  45
  46 #ifndef GCC
  47 #endif
  48
  49 #include <sfx2/childwin.hxx>
  50 #include <sfx2/app.hxx>
  51 #include "arrdecl.hxx"
  52 #include <sfx2/bindings.hxx>
  53 #include <sfx2/module.hxx>
  54 #include <sfx2/dockwin.hxx>
  55 #include <sfx2/dispatch.hxx>
  56 #include "workwin.hxx"
  57
  58 static const sal_uInt16 nVersion = 2;
  59
  60 DBG_NAME(SfxChildWindow)
  61
  62 SV_IMPL_PTRARR( SfxChildWinContextArr_Impl, SfxChildWinContextFactory* );
  63
  64 struct SfxChildWindow_Impl
  65 {
  66     ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >                         xFrame;
  67     ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >      xListener;
  68     SfxChildWinFactory* pFact;
  69     sal_Bool                            bHideNotDelete;
  70     sal_Bool                            bVisible;
  71     sal_Bool                            bHideAtToggle;
  72     sal_Bool                            bWantsFocus;
  73     SfxModule*                  pContextModule;
  74     SfxWorkWindow*              pWorkWin;
  75 };
  76
  77 // -----------------------------------------------------------------------
  78
  79 class DisposeListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener >
  80 {
  81     public:
  82         DisposeListener( SfxChildWindow*      pOwner ,
  83                          SfxChildWindow_Impl* pData  )
  84             :   m_pOwner( pOwner )
  85             ,   m_pData ( pData  )
  86         {}
  87
  88         virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aSource ) throw (::com::sun::star::uno::RuntimeException)
  89         {
  90             ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > xSelfHold( this );
  91
  92             ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComp( aSource.Source, ::com::sun::star::uno::UNO_QUERY );
  93             if( xComp.is() )
  94                 xComp->removeEventListener( this );
  95
  96             if( m_pOwner && m_pData )
  97             {
  98                 m_pData->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >();
  99
 100                 if ( m_pData->pWorkWin )
 101                 {
 102                     // m_pOwner and m_pData will be killed
 103                     m_pData->xFrame    = ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >();
 104                     m_pData->pWorkWin->GetBindings().Execute( m_pOwner->GetType() );
 105                 }
 106                 else
 107                 {
 108                     delete m_pOwner;
 109                 }
 110
 111                 m_pOwner = NULL;
 112                 m_pData  = NULL;
 113             }
 114         }
 115
 116     private:
 117         SfxChildWindow*      m_pOwner;
 118         SfxChildWindow_Impl* m_pData ;
 119 };
 120
 121 // -----------------------------------------------------------------------
 122
 123 sal_Bool GetPosSizeFromString( const String& rStr, Point& rPos, Size& rSize )
 124 {
 125     if ( rStr.GetTokenCount('/') != 4 )
 126         return sal_False;
 127
 128     xub_StrLen nIdx = 0;
 129     rPos.X() = rStr.GetToken(0, '/', nIdx).ToInt32();
 130     rPos.Y() = rStr.GetToken(0, '/', nIdx).ToInt32();
 131     rSize.Width() = rStr.GetToken(0, '/', nIdx).ToInt32();
 132     rSize.Height() = rStr.GetToken(0, '/', nIdx).ToInt32();
 133
 134     // negative sizes are invalid
 135     if ( rSize.Width() < 0 || rSize.Height() < 0 )
 136         return sal_False;
 137
 138     return sal_True;
 139 }
 140
 141 sal_Bool GetSplitSizeFromString( const String& rStr, Size& rSize )
 142 {
 143     xub_StrLen nIndex = rStr.Search( ',' );
 144     if ( nIndex != STRING_NOTFOUND )
 145     {
 146         String aStr = rStr.Copy( nIndex+1 );
 147
 148         sal_Int32 nCount = aStr.GetTokenCount(';');
 149         if ( nCount != 2 )
 150             return sal_False;
 151
 152         rSize.Width() = aStr.GetToken(0, ';' ).ToInt32();
 153         rSize.Height() = aStr.GetToken(1, ';' ).ToInt32();
 154
 155         // negative sizes are invalid
 156         if ( rSize.Width() < 0 || rSize.Height() < 0 )
 157             return sal_False;
 158
 159         return sal_True;
 160     }
 161
 162     return sal_False;
 163 }
 164
 165 //=========================================================================
 166 SfxChildWindow::SfxChildWindow(Window *pParentWindow, sal_uInt16 nId)
 167     : pParent(pParentWindow)
 168     , nType(nId)
 169     , eChildAlignment(SFX_ALIGN_NOALIGNMENT)
 170     , pWindow(0L)
 171 {
 172     pImp = new SfxChildWindow_Impl;
 173     pImp->pFact = 0L;
 174     pImp->bHideNotDelete = sal_False;
 175     pImp->bHideAtToggle = sal_False;
 176     pImp->bWantsFocus = sal_True;
 177     pImp->bVisible = sal_True;
 178     pImp->pContextModule = NULL;
 179     pImp->pWorkWin = NULL;
 180
 181     pContext = 0L;
 182     DBG_CTOR(SfxChildWindow,0);
 183 }
 184
 185 void SfxChildWindow::Destroy()
 186 {
 187     if ( GetFrame().is() )
 188     {
 189         pImp->pWorkWin = NULL;
 190         try
 191         {
 192             ::com::sun::star::uno::Reference < ::com::sun::star::util::XCloseable > xClose( GetFrame(), ::com::sun::star::uno::UNO_QUERY );
 193             if ( xClose.is() )
 194                 xClose->close( sal_True );
 195             else
 196                 GetFrame()->dispose();
 197         }
 198         catch ( com::sun::star::uno::Exception& )
 199         {
 200         }
 201     }
 202     else
 203         delete this;
 204 }
 205
 206 //-------------------------------------------------------------------------
 207 SfxChildWindow::~SfxChildWindow()
 208 {
 209     DBG_DTOR(SfxChildWindow,0);
 210     if ( pContext )
 211         delete pContext;
 212     if ( pWindow )
 213         delete pWindow;
 214     delete pImp;
 215 }
 216
 217 //-------------------------------------------------------------------------
 218 SfxChildWindow* SfxChildWindow::CreateChildWindow( sal_uInt16 nId,
 219         Window *pParent, SfxBindings* pBindings, SfxChildWinInfo& rInfo)
 220 {
 221     SfxChildWindow *pChild=0;
 222     SfxChildWinFactory* pFact=0;
 223     sal_uInt16 nOldMode = Application::GetSystemWindowMode();
 224
 225     // Zuerst ChildWindow im SDT suchen; "Uberlagerungen m"ussen mit einem
 226     // ChildWindowContext realisiert werden
 227     SfxApplication *pApp = SFX_APP();
 228     {
 229         SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
 230         for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 231         {
 232             pFact = rFactories[nFactory];
 233             if ( pFact->nId == nId )
 234             {
 235                 SfxChildWinInfo& rFactInfo = pFact->aInfo;
 236                 if ( rInfo.bVisible )
 237                 {
 238                     if ( pBindings )
 239                         pBindings->ENTERREGISTRATIONS();
 240                     SfxChildWinInfo aInfo = rFactInfo;
 241                     Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE );
 242                     pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
 243                     Application::SetSystemWindowMode( nOldMode );
 244                     if ( pBindings )
 245                         pBindings->LEAVEREGISTRATIONS();
 246                 }
 247
 248                 break;
 249             }
 250         }
 251     }
 252
 253     SfxDispatcher *pDisp = pBindings->GetDispatcher_Impl();
 254     SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0;
 255     if ( !pChild &&  pMod )
 256     {
 257         SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
 258         if ( pFactories )
 259         {
 260             SfxChildWinFactArr_Impl &rFactories = *pFactories;
 261             for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 262             {
 263                 pFact = rFactories[nFactory];
 264                 if ( pFact->nId == nId )
 265                 {
 266                     SfxChildWinInfo& rFactInfo = pFact->aInfo;
 267                     if ( rInfo.bVisible )
 268                     {
 269                         if ( pBindings )
 270                             pBindings->ENTERREGISTRATIONS();
 271                         SfxChildWinInfo aInfo = rFactInfo;
 272                         Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE );
 273                         pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
 274                         Application::SetSystemWindowMode( nOldMode );
 275                         if ( pBindings )
 276                             pBindings->LEAVEREGISTRATIONS();
 277                     }
 278
 279                     break;
 280                 }
 281             }
 282         }
 283     }
 284
 285     if ( pChild )
 286         pChild->SetFactory_Impl( pFact );
 287
 288     DBG_ASSERT(pFact && (pChild || !rInfo.bVisible), "ChildWindow-Typ nicht registriert!");
 289
 290     if ( pChild && !pChild->pWindow )
 291     {
 292         DELETEZ(pChild);
 293         DBG_WARNING("ChildWindow hat kein Fenster!");
 294     }
 295
 296     return pChild;
 297 }
 298
 299 //-------------------------------------------------------------------------
 300 void SfxChildWindow::SaveStatus(const SfxChildWinInfo& rInfo)
 301 {
 302     sal_uInt16 nID = GetType();
 303
 304     String aWinData( 'V' );
 305     aWinData += String::CreateFromInt32( nVersion );
 306     aWinData += ',';
 307     aWinData += rInfo.bVisible ? 'V' : 'H';
 308     aWinData += ',';
 309     aWinData += String::CreateFromInt32( rInfo.nFlags );
 310     if ( rInfo.aExtraString.Len() )
 311     {
 312         aWinData += ',';
 313         aWinData += rInfo.aExtraString;
 314     }
 315
 316     SvtViewOptions aWinOpt( E_WINDOW, String::CreateFromInt32( nID ) );
 317     // aWinOpt.SetPosition( rInfo.aPos.X(), rInfo.aPos.Y() );
 318     // aWinOpt.SetSize( rInfo.aSize.Width(), rInfo.aSize.Height() );
 319     aWinOpt.SetWindowState( String( rInfo.aWinState, RTL_TEXTENCODING_UTF8 ) );
 320
 321     ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq(1);
 322     aSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Data") );
 323     aSeq[0].Value <<= ::rtl::OUString( aWinData );
 324     aWinOpt.SetUserData( aSeq );
 325
 326     // ... but save status at runtime!
 327     pImp->pFact->aInfo = rInfo;
 328 }
 329
 330 //-------------------------------------------------------------------------
 331 void SfxChildWindow::SetAlignment(SfxChildAlignment eAlign)
 332 {
 333     DBG_CHKTHIS(SfxChildWindow,0);
 334
 335     eChildAlignment = eAlign;
 336 }
 337
 338 //-------------------------------------------------------------------------
 339 void SfxChildWindow::SetPosSizePixel(const Point& rPoint, Size& rSize)
 340 {
 341     DBG_CHKTHIS(SfxChildWindow,0);
 342
 343     pWindow->SetPosSizePixel(rPoint, rSize);
 344 }
 345
 346 //-------------------------------------------------------------------------
 347 SfxChildWinInfo SfxChildWindow::GetInfo() const
 348 {
 349     DBG_CHKTHIS(SfxChildWindow,0);
 350
 351     SfxChildWinInfo aInfo;
 352     aInfo.aPos  = pWindow->GetPosPixel();
 353     aInfo.aSize = pWindow->GetSizePixel();
 354     if ( pWindow->IsSystemWindow() )
 355     {
 356         ULONG nMask = WINDOWSTATE_MASK_POS | WINDOWSTATE_MASK_STATE;
 357         if ( pWindow->GetStyle() & WB_SIZEABLE )
 358             nMask |= ( WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT );
 359         aInfo.aWinState = ((SystemWindow*)pWindow)->GetWindowState( nMask );
 360     }
 361     else if ( pWindow->GetType() == RSC_DOCKINGWINDOW )
 362     {
 363         if (((DockingWindow*)pWindow)->GetFloatingWindow() )
 364             aInfo.aWinState = ((DockingWindow*)pWindow)->GetFloatingWindow()->GetWindowState();
 365         else
 366         {
 367             SfxChildWinInfo aTmpInfo;
 368             ((SfxDockingWindow*)pWindow)->FillInfo( aTmpInfo );
 369             aInfo.aExtraString = aTmpInfo.aExtraString;
 370         }
 371     }
 372
 373     aInfo.bVisible = pImp->bVisible;
 374     aInfo.nFlags = 0;
 375     return aInfo;
 376 }
 377
 378 //-------------------------------------------------------------------------
 379 sal_uInt16 SfxChildWindow::GetPosition()
 380 {
 381     return pImp->pFact->nPos;
 382 }
 383
 384 #if 0
 385 static void ImplWindowStateFromStr( Point rPos, Size rSize, const ByteString& rStr )
 386 {
 387     ULONG       nValidMask  = 0;
 388     xub_StrLen  nIndex      = 0;
 389     ByteString  aTokenStr;
 390
 391     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 392     if ( aTokenStr.Len() )
 393     {
 394         rPos.X() = aTokenStr.ToInt32();
 395         nValidMask |= WINDOWSTATE_MASK_X;
 396     }
 397
 398     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 399     if ( aTokenStr.Len() )
 400     {
 401         rPos.Y() = aTokenStr.ToInt32();
 402         nValidMask |= WINDOWSTATE_MASK_Y;
 403     }
 404
 405     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 406     if ( aTokenStr.Len() )
 407     {
 408         rSize.Width() = aTokenStr.ToInt32();
 409         nValidMask |= WINDOWSTATE_MASK_WIDTH;
 410     }
 411
 412     aTokenStr = rStr.GetToken( 0, ';', nIndex );
 413     if ( aTokenStr.Len() )
 414     {
 415         rSize.Height() = aTokenStr.ToInt32();
 416         nValidMask |= WINDOWSTATE_MASK_HEIGHT;
 417     }
 418 }
 419 #endif
 420
 421 //-------------------------------------------------------------------------
 422 void SfxChildWindow::InitializeChildWinFactory_Impl( sal_uInt16 nId, SfxChildWinInfo& rInfo )
 423 {
 424     // load configuration
 425     SvtViewOptions aWinOpt( E_WINDOW, String::CreateFromInt32( nId ) );
 426
 427     if ( aWinOpt.Exists() )
 428         rInfo.bVisible  = aWinOpt.IsVisible(); // set state from configuration. Can be overwritten by UserData, see below
 429
 430     ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq = aWinOpt.GetUserData();
 431
 432     ::rtl::OUString aTmp;
 433     if ( aSeq.getLength() )
 434         aSeq[0].Value >>= aTmp;
 435
 436     String aWinData( aTmp );
 437     rInfo.aWinState = ByteString( String(aWinOpt.GetWindowState()), RTL_TEXTENCODING_UTF8 );
 438
 439     //ImplWindowStateFromStr( rInfo.aPos, rInfo.aSize, ByteString( aWinState, RTL_TEXTENCODING_UTF8 ) );
 440
 441     if ( aWinData.Len() )
 442     {
 443         // Nach Versionskennung suchen
 444         if ( aWinData.GetChar((sal_uInt16)0) != 0x0056 ) // 'V' = 56h
 445             // Keine Versionskennung, daher nicht verwenden
 446             return;
 447
 448         // 'V' l"oschen
 449         aWinData.Erase(0,1);
 450
 451         // Version lesen
 452         char cToken = ',';
 453         sal_uInt16 nPos = aWinData.Search( cToken );
 454         sal_uInt16 nActVersion = (sal_uInt16)aWinData.Copy( 0, nPos + 1 ).ToInt32();
 455         if ( nActVersion != nVersion )
 456             return;
 457
 458         aWinData.Erase(0,nPos+1);
 459
 460         //aWinOpt.GetPosition( rInfo.aPos.X(), rInfo.aPos.Y() );
 461         //aWinOpt.GetSize( rInfo.aSize.Width(), rInfo.aSize.Height() );
 462
 463         // Sichtbarkeit laden: ist als ein char codiert
 464         rInfo.bVisible = (aWinData.GetChar(0) == 0x0056); // 'V' = 56h
 465         aWinData.Erase(0,1);
 466         nPos = aWinData.Search( cToken );
 467         if (nPos != STRING_NOTFOUND)
 468         {
 469             USHORT nNextPos = aWinData.Search( cToken, 2 );
 470             if ( nNextPos != STRING_NOTFOUND )
 471             {
 472                 // es gibt noch Extra-Information
 473                 rInfo.nFlags = (sal_uInt16)aWinData.Copy( nPos+1, nNextPos - nPos - 1 ).ToInt32();
 474                 aWinData.Erase( nPos, nNextPos-nPos+1 );
 475                 rInfo.aExtraString = aWinData;
 476             }
 477             else
 478                 rInfo.nFlags = (sal_uInt16)aWinData.Copy( nPos+1 ).ToInt32();
 479         }
 480     }
 481 }
 482
 483 void SfxChildWindow::CreateContext( sal_uInt16 nContextId, SfxBindings& rBindings )
 484 {
 485     SfxChildWindowContext *pCon = NULL;
 486     SfxChildWinFactory* pFact=0;
 487     SfxApplication *pApp = SFX_APP();
 488     SfxDispatcher *pDisp = rBindings.GetDispatcher_Impl();
 489     SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0;
 490     if ( pMod )
 491     {
 492         SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
 493         if ( pFactories )
 494         {
 495             SfxChildWinFactArr_Impl &rFactories = *pFactories;
 496             for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 497             {
 498                 pFact = rFactories[nFactory];
 499                 if ( pFact->nId == GetType() )
 500                 {
 501                     DBG_ASSERT( pFact->pArr, "Kein Kontext angemeldet!" );
 502                     if ( !pFact->pArr )
 503                         break;
 504
 505                     SfxChildWinContextFactory *pConFact=0;
 506                     for ( sal_uInt16 n=0; n<pFact->pArr->Count(); ++n )
 507                     {
 508                         pConFact = (*pFact->pArr)[n];
 509                         rBindings.ENTERREGISTRATIONS();
 510                         if ( pConFact->nContextId == nContextId )
 511                         {
 512                             SfxChildWinInfo aInfo = pFact->aInfo;
 513                             pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
 514                             pCon->nContextId = pConFact->nContextId;
 515                             pImp->pContextModule = pMod;
 516                         }
 517                         rBindings.LEAVEREGISTRATIONS();
 518                     }
 519                     break;
 520                 }
 521             }
 522         }
 523     }
 524
 525     if ( !pCon )
 526     {
 527         SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
 528         for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 529         {
 530             pFact = rFactories[nFactory];
 531             if ( pFact->nId == GetType() )
 532             {
 533                 DBG_ASSERT( pFact->pArr, "Kein Kontext angemeldet!" );
 534                 if ( !pFact->pArr )
 535                     break;
 536
 537                 SfxChildWinContextFactory *pConFact=0;
 538                 for ( sal_uInt16 n=0; n<pFact->pArr->Count(); ++n )
 539                 {
 540                     pConFact = (*pFact->pArr)[n];
 541                     rBindings.ENTERREGISTRATIONS();
 542                     if ( pConFact->nContextId == nContextId )
 543                     {
 544                         SfxChildWinInfo aInfo = pFact->aInfo;
 545                         pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
 546                         pCon->nContextId = pConFact->nContextId;
 547                         pImp->pContextModule = NULL;
 548                     }
 549                     rBindings.LEAVEREGISTRATIONS();
 550                 }
 551                 break;
 552             }
 553         }
 554     }
 555
 556     if ( !pCon )
 557     {
 558         DBG_ERROR( "Kein geeigneter Context gefunden!" );
 559         return;
 560     }
 561
 562     if ( pContext )
 563         delete( pContext );
 564     pContext = pCon;
 565     pContext->GetWindow()->SetSizePixel( pWindow->GetOutputSizePixel() );
 566     pContext->GetWindow()->Show();
 567 }
 568
 569 SfxChildWindowContext::SfxChildWindowContext( sal_uInt16 nId )
 570     : pWindow( NULL )
 571     , nContextId( nId )
 572 {
 573 }
 574
 575 SfxChildWindowContext::~SfxChildWindowContext()
 576 {
 577     delete pWindow;
 578 }
 579
 580 FloatingWindow* SfxChildWindowContext::GetFloatingWindow() const
 581 {
 582     Window *pParent = pWindow->GetParent();
 583     if ( pParent->GetType() == RSC_DOCKINGWINDOW || pParent->GetType() == RSC_TOOLBOX )
 584     {
 585         return ((DockingWindow*)pParent)->GetFloatingWindow();
 586     }
 587     else if ( pParent->GetType() == RSC_FLOATINGWINDOW )
 588     {
 589         return (FloatingWindow*) pParent;
 590     }
 591     else
 592     {
 593         DBG_ERROR("Kein FloatingWindow-Context!");
 594         return NULL;
 595     }
 596 }
 597
 598 SfxChildAlignment SfxChildWindowContext::GetAlignment() const
 599 {
 600     Window *pParent = pWindow->GetParent();
 601     if ( pParent->GetType() == RSC_DOCKINGWINDOW )
 602     {
 603         return ((SfxDockingWindow*)pParent)->GetAlignment();
 604     }
 605     else if ( pParent->GetType() == RSC_TOOLBOX )
 606     {
 607         HACK(noch nicht verwendet und noch nicht implementiert);
 608         return SFX_ALIGN_NOALIGNMENT;
 609     }
 610     else
 611         return SFX_ALIGN_NOALIGNMENT;
 612 }
 613
 614 void SfxChildWindowContext::Resizing( Size& )
 615 {
 616 }
 617
 618 sal_Bool SfxChildWindowContext::Close()
 619 {
 620     return sal_True;
 621 }
 622
 623 void SfxChildWindow::SetFactory_Impl( SfxChildWinFactory *pF )
 624 {
 625     pImp->pFact = pF;
 626 }
 627
 628 void SfxChildWindow::SetHideNotDelete( sal_Bool bOn )
 629 {
 630     pImp->bHideNotDelete = bOn;
 631 }
 632
 633 sal_Bool SfxChildWindow::IsHideNotDelete() const
 634 {
 635     return pImp->bHideNotDelete;
 636 }
 637
 638 void SfxChildWindow::SetHideAtToggle( sal_Bool bOn )
 639 {
 640     pImp->bHideAtToggle = bOn;
 641 }
 642
 643 sal_Bool SfxChildWindow::IsHideAtToggle() const
 644 {
 645     return pImp->bHideAtToggle;
 646 }
 647
 648 void SfxChildWindow::SetWantsFocus( BOOL bSet )
 649 {
 650     pImp->bWantsFocus = bSet;
 651 }
 652
 653 sal_Bool SfxChildWindow::WantsFocus() const
 654 {
 655     return pImp->bWantsFocus;
 656 }
 657
 658 sal_Bool SfxChildWinInfo::GetExtraData_Impl
 659 (
 660     SfxChildAlignment   *pAlign,
 661     SfxChildAlignment   *pLastAlign,
 662     Size                                *pSize,
 663     sal_uInt16                  *pLine,
 664     sal_uInt16                  *pPos
 665 )   const
 666 {
 667     // ung"ultig?
 668     if ( !aExtraString.Len() )
 669         return sal_False;
 670     String aStr;
 671     sal_uInt16 nPos = aExtraString.SearchAscii("AL:");
 672     if ( nPos == STRING_NOTFOUND )
 673         return sal_False;
 674
 675     // Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn
 676     // er nicht vorhanden ist, liegt eine "altere Version vor
 677     if ( nPos != STRING_NOTFOUND )
 678     {
 679         sal_uInt16 n1 = aExtraString.Search('(', nPos);
 680         if ( n1 != STRING_NOTFOUND )
 681         {
 682             sal_uInt16 n2 = aExtraString.Search(')', n1);
 683             if ( n2 != STRING_NOTFOUND )
 684             {
 685                 // Alignment-String herausschneiden
 686                 aStr = aExtraString.Copy(nPos, n2 - nPos + 1);
 687                 aStr.Erase(nPos, n1-nPos+1);
 688             }
 689         }
 690     }
 691
 692     // Zuerst das Alignment extrahieren
 693     if ( !aStr.Len() )
 694         return sal_False;
 695     if ( pAlign )
 696         *pAlign = (SfxChildAlignment) (sal_uInt16) aStr.ToInt32();
 697
 698     // Dann das LastAlignment
 699     nPos = aStr.Search(',');
 700     if ( nPos == STRING_NOTFOUND )
 701         return sal_False;
 702     aStr.Erase(0, nPos+1);
 703     if ( pLastAlign )
 704         *pLastAlign = (SfxChildAlignment) (sal_uInt16) aStr.ToInt32();
 705
 706     // Dann die Splitting-Informationen
 707     nPos = aStr.Search(',');
 708     if ( nPos == STRING_NOTFOUND )
 709         // Dockt nicht in einem Splitwindow
 710         return sal_True;
 711     aStr.Erase(0, nPos+1);
 712     Point aChildPos;
 713     Size aChildSize;
 714     if ( GetPosSizeFromString( aStr, aChildPos, aChildSize ) )
 715     {
 716         if ( pSize )
 717             *pSize = aChildSize;
 718         if ( pLine )
 719             *pLine = (sal_uInt16) aChildPos.X();
 720         if ( pPos )
 721             *pPos = (sal_uInt16) aChildPos.Y();
 722         return sal_True;
 723     }
 724     return sal_False;
 725 }
 726
 727 sal_Bool SfxChildWindow::IsVisible() const
 728 {
 729     return pImp->bVisible;
 730 }
 731
 732 void SfxChildWindow::SetVisible_Impl( sal_Bool bVis )
 733 {
 734     pImp->bVisible = bVis;
 735 }
 736
 737 void SfxChildWindow::Hide()
 738 {
 739     switch ( pWindow->GetType() )
 740     {
 741         case RSC_DOCKINGWINDOW :
 742             ((DockingWindow*)pWindow)->Hide();
 743             break;
 744         case RSC_TOOLBOX :
 745             ((ToolBox*)pWindow)->Hide();
 746             break;
 747         default:
 748             pWindow->Hide();
 749             break;
 750     }
 751 }
 752
 753
 754
 755 void SfxChildWindow::Show( USHORT nFlags )
 756 {
 757     switch ( pWindow->GetType() )
 758     {
 759         case RSC_DOCKINGWINDOW :
 760             ((DockingWindow*)pWindow)->Show( TRUE, nFlags );
 761             break;
 762         case RSC_TOOLBOX :
 763             ((ToolBox*)pWindow)->Show( TRUE, nFlags );
 764             break;
 765         default:
 766             pWindow->Show( TRUE, nFlags );
 767             break;
 768     }
 769 }
 770
 771 Window* SfxChildWindow::GetContextWindow( SfxModule *pModule ) const
 772 {
 773     return pModule == pImp->pContextModule && pContext ? pContext->GetWindow(): 0;
 774 }
 775
 776 void SfxChildWindow::SetWorkWindow_Impl( SfxWorkWindow* pWin )
 777 {
 778     pImp->pWorkWin = pWin;
 779     if ( pWin && pWindow->HasChildPathFocus() )
 780         pImp->pWorkWin->SetActiveChild_Impl( pWindow );
 781 }
 782
 783 //SfxWorkWindow* SfxChildWindow::GetWorkWindow_Impl() const
 784 //{
 785 //      return pImp->pWorkWin;
 786 //}
 787
 788 void SfxChildWindow::Activate_Impl()
 789 {
 790     if(pImp->pWorkWin!=NULL) //@#60568#
 791         pImp->pWorkWin->SetActiveChild_Impl( pWindow );
 792 }
 793
 794 void SfxChildWindow::Deactivate_Impl()
 795 {
 796 //      pImp->pWorkWin->SetActiveChild_Impl( NULL );
 797 }
 798
 799 sal_Bool SfxChildWindow::QueryClose()
 800 {
 801     sal_Bool bAllow = sal_True;
 802
 803     if ( pImp->xFrame.is() )
 804     {
 805         ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController >  xCtrl = pImp->xFrame->getController();
 806         if ( xCtrl.is() )
 807             bAllow = xCtrl->suspend( sal_True );
 808     }
 809
 810     if ( bAllow )
 811         bAllow = !GetWindow()->IsInModalMode();
 812
 813     return bAllow;
 814 }
 815
 816 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >  SfxChildWindow::GetFrame()
 817 {
 818     return pImp->xFrame;
 819 }
 820
 821 void SfxChildWindow::SetFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > & rFrame )
 822 {
 823     // Do nothing if nothing will be changed ...
 824     if( pImp->xFrame != rFrame )
 825     {
 826         // ... but stop listening on old frame, if connection exist!
 827         if( pImp->xFrame.is() )
 828             pImp->xFrame->removeEventListener( pImp->xListener );
 829
 830         // If new frame isnt NULL -> we must guarantee valid listener for disposing events.
 831         // Use already existing or create new one.
 832         if( rFrame.is() )
 833             if( !pImp->xListener.is() )
 834                 pImp->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >( new DisposeListener( this, pImp ) );
 835
 836         // Set new frame in data container
 837         // and build new listener connection, if neccessary.
 838         pImp->xFrame = rFrame;
 839         if( pImp->xFrame.is() )
 840             pImp->xFrame->addEventListener( pImp->xListener );
 841     }
 842 }
 843
 844 sal_Bool SfxChildWindow::CanGetFocus() const
 845 {
 846     return !(pImp->pFact->aInfo.nFlags & SFX_CHILDWIN_CANTGETFOCUS);
 847 }
 848
 849 void SfxChildWindowContext::RegisterChildWindowContext(SfxModule* pMod, USHORT nId, SfxChildWinContextFactory* pFact)
 850 {
 851     SFX_APP()->RegisterChildWindowContext_Impl( pMod, nId, pFact );
 852 }
 853
 854 void SfxChildWindow::RegisterChildWindow(SfxModule* pMod, SfxChildWinFactory* pFact)
 855 {
 856     SFX_APP()->RegisterChildWindow_Impl( pMod, pFact );
 857 }
 858