1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sfx2.hxx" 26 27 #ifndef GCC 28 #endif 29 30 #include <stdio.h> 31 #include <hash_map> 32 33 #include <sfx2/docfile.hxx> 34 #include <sfx2/objsh.hxx> 35 #include <sfx2/app.hxx> 36 #include "workwin.hxx" 37 #include <sfx2/viewfrm.hxx> 38 #include "arrdecl.hxx" 39 #include <sfx2/viewfrm.hxx> 40 #include <sfx2/module.hxx> 41 #include <sfx2/dispatch.hxx> 42 #include <sfx2/dockwin.hxx> 43 #include <sfx2/viewsh.hxx> 44 #include "splitwin.hxx" 45 #include <sfx2/msgpool.hxx> 46 #include "sfx2/sfxresid.hxx" 47 #include <sfx2/objsh.hxx> 48 #include <sfx2/request.hxx> // SFX_ITEMSET_SET 49 #include <vcl/taskpanelist.hxx> 50 #include <vcl/toolbox.hxx> 51 #include <tools/rcid.h> 52 #include <tools/diagnose_ex.h> 53 #include <toolkit/helper/vclunohelper.hxx> 54 #include <svl/itempool.hxx> 55 #include <svl/itemiter.hxx> 56 #include <svl/whiter.hxx> 57 #include <svl/intitem.hxx> 58 #ifndef _SFXEITEM_HXX //autogen 59 #include <svl/eitem.hxx> 60 #endif 61 #include <com/sun/star/ui/XUIElement.hpp> 62 #include <com/sun/star/frame/XLayoutManager.hpp> 63 #include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp> 64 #include <com/sun/star/frame/LayoutManagerEvents.hpp> 65 #include <com/sun/star/beans/XPropertySet.hpp> 66 #include <com/sun/star/awt/XWindow.hpp> 67 #include <com/sun/star/lang/DisposedException.hpp> 68 69 using namespace ::com::sun::star; 70 using namespace ::com::sun::star::uno; 71 namespace css = ::com::sun::star; 72 73 struct ResIdToResName 74 { 75 sal_uInt16 nId; 76 const char* pName; 77 }; 78 79 static const ResIdToResName pToolBarResToName[] = 80 { 81 { 558, "fullscreenbar" }, 82 { 560, "standardbar", }, 83 { 18001, "formsnavigationbar" }, 84 { 18002, "formsfilterbar" }, 85 { 18003, "formtextobjectbar" }, 86 { 18004, "formcontrols" }, 87 { 18005, "moreformcontrols" }, 88 { 18006, "formdesign" }, 89 { 20050, "toolbar" }, //math 90 { 30001, "objectbar" }, //chart 91 { 30513, "toolbar" }, //chart 92 { 25005, "textobjectbar" }, //calc 93 { 25053, "drawobjectbar" }, 94 { 25054, "graphicobjectbar" }, 95 { 25001, "formatobjectbar" }, 96 { 25006, "previewbar" }, 97 { 25035, "toolbar" }, //calc 98 { 23015, "bezierobjectbar" }, //draw/impress 99 { 23019, "gluepointsobjectbar" }, 100 { 23030, "graphicobjectbar" }, 101 { 23013, "drawingobjectbar" }, //impress 102 { 23016, "textobjectbar" }, //impress 103 { 23028, "textobjectbar" }, //draw 104 { 23011, "toolbar" }, //impress 105 { 23020, "optionsbar" }, 106 { 23021, "commontaskbar" }, 107 { 23025, "toolbar" }, //draw 108 { 23026, "optionsbar" }, 109 { 23027, "drawingobjectbar" }, //draw 110 { 23017, "outlinetoolbar" }, //impress 111 { 23012, "slideviewtoolbar" }, 112 { 23014, "slideviewobjectbar" }, 113 { 23283, "bezierobjectbar" }, //writer 114 { 23269, "drawingobjectbar" }, 115 { 23270, "drawtextobjectbar" }, 116 { 23267, "frameobjectbar" }, 117 { 23268, "graphicobjectbar" }, 118 { 23271, "numobjectbar" }, 119 { 23272, "oleobjectbar" }, 120 { 23266, "tableobjectbar" }, 121 { 23265, "textobjectbar" }, 122 { 20631, "previewobjectbar" }, //writer 123 { 20402, "toolbar" }, //web 124 { 20403, "textobjectbar" }, 125 { 23273, "toolbar" }, //writer 126 { 20408, "frameobjectbar" }, //web 127 { 20410, "graphicobjectbar" }, 128 { 20411, "oleobjectbar" }, 129 { 14850, "macrobar" }, 130 { 10987, "fontworkobjectbar" }, //global 131 { 10986, "extrusionobjectbar" }, 132 { 23022, "formsobjectbar" }, 133 { 23310, "viewerbar" }, //writer (plugin) 134 { 25000, "viewerbar" }, //calc (plugin) 135 { 23023, "viewerbar" }, //impress(plugin) 136 { 23024, "viewerbar" }, //draw (plugin) 137 { 23031, "mediaobjectbar" }, //draw/impress 138 { 25060, "mediaobjectbar" }, //calc 139 { 23311, "mediaobjectbar" }, //writer 140 { 0, "" } 141 }; 142 143 DBG_NAME(SfxWorkWindow) 144 145 //SV_IMPL_OBJARR( SfxObjectBarArr_Impl, SfxObjectBar_Impl ); 146 147 //==================================================================== 148 // Sortiert die Children nach ihrem Alignment 149 // Reihenfolge entspricht der im enum SfxChildAlignment (->CHILDWIN.HXX). 150 // 151 152 // Hilfe, um die "Anderungen am Alignment kompatibal zu machen! 153 154 155 SFX_IMPL_XINTERFACE_3( LayoutManagerListener, OWeakObject, ::com::sun::star::frame::XLayoutManagerListener, ::com::sun::star::lang::XEventListener, ::com::sun::star::lang::XComponent ) 156 SFX_IMPL_XTYPEPROVIDER_3( LayoutManagerListener, ::com::sun::star::frame::XLayoutManagerListener, ::com::sun::star::lang::XEventListener, ::com::sun::star::lang::XComponent ) 157 158 LayoutManagerListener::LayoutManagerListener( 159 SfxWorkWindow* pWrkWin ) : 160 m_bHasFrame( sal_False ), 161 m_pWrkWin( pWrkWin ), 162 m_aLayoutManagerPropName( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )) 163 { 164 } 165 166 LayoutManagerListener::~LayoutManagerListener() 167 { 168 } 169 170 void LayoutManagerListener::setFrame( const css::uno::Reference< css::frame::XFrame >& xFrame ) 171 { 172 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 173 if ( m_pWrkWin && !m_bHasFrame ) 174 { 175 m_xFrame = xFrame; 176 m_bHasFrame = sal_True; 177 178 if ( xFrame.is() ) 179 { 180 css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY ); 181 css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager; 182 if ( xPropSet.is() ) 183 { 184 try 185 { 186 Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 187 aValue >>= xLayoutManager; 188 189 if ( xLayoutManager.is() ) 190 xLayoutManager->addLayoutManagerEventListener( 191 css::uno::Reference< css::frame::XLayoutManagerListener >( 192 static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY )); 193 194 xPropSet = css::uno::Reference< css::beans::XPropertySet >( xLayoutManager, UNO_QUERY ); 195 if ( xPropSet.is() ) 196 { 197 aValue = xPropSet->getPropertyValue( 198 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LockCount" )) ); 199 aValue >>= m_pWrkWin->m_nLock; 200 } 201 } 202 catch ( css::lang::DisposedException& ) 203 { 204 } 205 catch ( css::uno::RuntimeException& e ) 206 { 207 throw e; 208 } 209 catch ( css::uno::Exception& ) 210 { 211 } 212 } 213 } 214 } 215 } 216 217 //--------------------------------------------------------------------------------------------------------- 218 // XComponent 219 //--------------------------------------------------------------------------------------------------------- 220 void SAL_CALL LayoutManagerListener::addEventListener( 221 const css::uno::Reference< css::lang::XEventListener >& ) 222 { 223 // do nothing, only internal class 224 } 225 226 void SAL_CALL LayoutManagerListener::removeEventListener( 227 const css::uno::Reference< css::lang::XEventListener >& ) 228 { 229 // do nothing, only internal class 230 } 231 232 void SAL_CALL LayoutManagerListener::dispose() 233 { 234 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 235 236 // reset member 237 m_pWrkWin = 0; 238 239 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame.get(), css::uno::UNO_QUERY ); 240 if ( xFrame.is() ) 241 { 242 m_xFrame = css::uno::Reference< css::frame::XFrame >(); 243 m_bHasFrame = sal_False; 244 245 css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, css::uno::UNO_QUERY ); 246 css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager; 247 if ( xPropSet.is() ) 248 { 249 try 250 { 251 css::uno::Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 252 aValue >>= xLayoutManager; 253 254 // remove as listener from layout manager 255 if ( xLayoutManager.is() ) 256 xLayoutManager->removeLayoutManagerEventListener( 257 css::uno::Reference< css::frame::XLayoutManagerListener >( 258 static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY )); 259 } 260 catch ( css::lang::DisposedException& ) 261 { 262 } 263 catch ( css::uno::RuntimeException& e ) 264 { 265 throw e; 266 } 267 catch ( css::uno::Exception& ) 268 { 269 } 270 } 271 } 272 } 273 274 //--------------------------------------------------------------------------------------------------------- 275 // XEventListener 276 //--------------------------------------------------------------------------------------------------------- 277 void SAL_CALL LayoutManagerListener::disposing( 278 const css::lang::EventObject& ) 279 { 280 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 281 m_pWrkWin = 0; 282 m_bHasFrame = sal_False; 283 m_xFrame = css::uno::Reference< css::frame::XFrame >(); 284 } 285 286 //--------------------------------------------------------------------------------------------------------- 287 // XLayoutManagerEventListener 288 //--------------------------------------------------------------------------------------------------------- 289 void SAL_CALL LayoutManagerListener::layoutEvent( 290 const css::lang::EventObject&, 291 ::sal_Int16 eLayoutEvent, 292 const css::uno::Any& ) 293 { 294 ::vos::OGuard aGuard( Application::GetSolarMutex() ); 295 if ( m_pWrkWin ) 296 { 297 if ( eLayoutEvent == css::frame::LayoutManagerEvents::VISIBLE ) 298 { 299 m_pWrkWin->MakeVisible_Impl( sal_True ); 300 m_pWrkWin->ShowChilds_Impl(); 301 m_pWrkWin->ArrangeChilds_Impl( sal_True ); 302 } 303 else if ( eLayoutEvent == css::frame::LayoutManagerEvents::INVISIBLE ) 304 { 305 m_pWrkWin->MakeVisible_Impl( sal_False ); 306 m_pWrkWin->HideChilds_Impl(); 307 m_pWrkWin->ArrangeChilds_Impl( sal_True ); 308 } 309 else if ( eLayoutEvent == css::frame::LayoutManagerEvents::LOCK ) 310 { 311 m_pWrkWin->Lock_Impl( sal_True ); 312 } 313 else if ( eLayoutEvent == css::frame::LayoutManagerEvents::UNLOCK ) 314 { 315 m_pWrkWin->Lock_Impl( sal_False ); 316 } 317 } 318 } 319 320 //==================================================================== 321 322 typedef std::hash_map< sal_Int32, rtl::OUString > ToolBarResIdToResourceURLMap; 323 324 static sal_Bool bMapInitialized = sal_False; 325 static ToolBarResIdToResourceURLMap aResIdToResourceURLMap; 326 327 static rtl::OUString GetResourceURLFromResId( sal_uInt16 nResId ) 328 { 329 if ( !bMapInitialized ) 330 { 331 osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; 332 if ( !bMapInitialized ) 333 { 334 sal_Int32 nIndex( 0 ); 335 while ( pToolBarResToName[nIndex].nId != 0 ) 336 { 337 rtl::OUString aResourceURL( rtl::OUString::createFromAscii( pToolBarResToName[nIndex].pName )); 338 aResIdToResourceURLMap.insert( ToolBarResIdToResourceURLMap::value_type( 339 sal_Int32( pToolBarResToName[nIndex].nId ), aResourceURL )); 340 ++nIndex; 341 } 342 bMapInitialized = sal_True; 343 } 344 } 345 346 ToolBarResIdToResourceURLMap::const_iterator pIter = aResIdToResourceURLMap.find( nResId ); 347 if ( pIter != aResIdToResourceURLMap.end() ) 348 return pIter->second; 349 else 350 return rtl::OUString(); 351 } 352 353 sal_Bool IsAppWorkWinToolbox_Impl( sal_uInt16 nPos ) 354 { 355 switch ( nPos ) 356 { 357 case SFX_OBJECTBAR_APPLICATION : 358 case SFX_OBJECTBAR_MACRO: 359 case SFX_OBJECTBAR_FULLSCREEN: 360 return sal_True; 361 default: 362 return sal_False; 363 } 364 } 365 366 sal_uInt16 TbxMatch( sal_uInt16 nPos ) 367 { 368 switch ( nPos ) 369 { 370 case SFX_OBJECTBAR_APPLICATION : 371 return 0; 372 case SFX_OBJECTBAR_OPTIONS: 373 return 1; 374 case SFX_OBJECTBAR_MACRO: 375 return 2; 376 case SFX_OBJECTBAR_OBJECT: 377 return 3; 378 case SFX_OBJECTBAR_TOOLS: 379 return 4; 380 case SFX_OBJECTBAR_FULLSCREEN: 381 case SFX_OBJECTBAR_COMMONTASK: 382 case SFX_OBJECTBAR_RECORDING: 383 return nPos+1; 384 default: 385 return nPos; 386 } 387 } 388 389 sal_uInt16 ChildAlignValue(SfxChildAlignment eAlign) 390 { 391 sal_uInt16 ret = 17; 392 393 switch (eAlign) 394 { 395 case SFX_ALIGN_HIGHESTTOP: 396 ret = 1; 397 break; 398 case SFX_ALIGN_LOWESTBOTTOM: 399 ret = 2; 400 break; 401 case SFX_ALIGN_FIRSTLEFT: 402 ret = 3; 403 break; 404 case SFX_ALIGN_LASTRIGHT: 405 ret = 4; 406 break; 407 case SFX_ALIGN_LEFT: 408 ret = 5; 409 break; 410 case SFX_ALIGN_RIGHT: 411 ret = 6; 412 break; 413 case SFX_ALIGN_FIRSTRIGHT: 414 ret = 7; 415 break; 416 case SFX_ALIGN_LASTLEFT: 417 ret = 8; 418 break; 419 case SFX_ALIGN_TOP: 420 ret = 9; 421 break; 422 case SFX_ALIGN_BOTTOM: 423 ret = 10; 424 break; 425 case SFX_ALIGN_TOOLBOXTOP: 426 ret = 11; 427 break; 428 case SFX_ALIGN_TOOLBOXBOTTOM: 429 ret = 12; 430 break; 431 case SFX_ALIGN_LOWESTTOP: 432 ret = 13; 433 break; 434 case SFX_ALIGN_HIGHESTBOTTOM: 435 ret = 14; 436 break; 437 case SFX_ALIGN_TOOLBOXLEFT: 438 ret = 15; 439 break; 440 case SFX_ALIGN_TOOLBOXRIGHT: 441 ret = 16; 442 break; 443 case SFX_ALIGN_NOALIGNMENT: 444 break; // -Wall not handled... 445 } 446 447 return ret; 448 } 449 450 sal_uInt16 ChildTravelValue( SfxChildAlignment eAlign ) 451 { 452 sal_uInt16 ret = 17; 453 454 switch (eAlign) 455 { 456 case SFX_ALIGN_FIRSTLEFT: 457 ret = 1; 458 break; 459 case SFX_ALIGN_LEFT: 460 ret = 2; 461 break; 462 case SFX_ALIGN_LASTLEFT: 463 ret = 3; 464 break; 465 case SFX_ALIGN_TOOLBOXLEFT: 466 ret = 4; 467 break; 468 case SFX_ALIGN_HIGHESTTOP: 469 ret = 5; 470 break; 471 case SFX_ALIGN_TOP: 472 ret = 6; 473 break; 474 case SFX_ALIGN_TOOLBOXTOP: 475 ret = 7; 476 break; 477 case SFX_ALIGN_LOWESTTOP: 478 ret = 8; 479 break; 480 case SFX_ALIGN_HIGHESTBOTTOM: 481 ret = 9; 482 break; 483 case SFX_ALIGN_TOOLBOXBOTTOM: 484 ret = 10; 485 break; 486 case SFX_ALIGN_BOTTOM: 487 ret = 11; 488 break; 489 case SFX_ALIGN_LOWESTBOTTOM: 490 ret = 12; 491 break; 492 case SFX_ALIGN_TOOLBOXRIGHT: 493 ret = 13; 494 break; 495 case SFX_ALIGN_FIRSTRIGHT: 496 ret = 14; 497 break; 498 case SFX_ALIGN_RIGHT: 499 ret = 15; 500 break; 501 case SFX_ALIGN_LASTRIGHT: 502 ret = 16; 503 break; 504 case SFX_ALIGN_NOALIGNMENT: 505 break; // -Wall not handled. 506 } 507 508 return ret; 509 } 510 511 void SfxWorkWindow::Sort_Impl() 512 { 513 aSortedList.Remove(0, aSortedList.Count()); 514 for (sal_uInt16 i=0; i<pChilds->Count(); i++) 515 { 516 SfxChild_Impl *pCli = (*pChilds)[i]; 517 if (pCli) 518 { 519 sal_uInt16 k; 520 for (k=0; k<aSortedList.Count(); k++) 521 // if ( (*pChilds)[aSortedList[k]]->eAlign > pCli->eAlign ) 522 if (ChildAlignValue((*pChilds)[aSortedList[k]]->eAlign) > 523 ChildAlignValue(pCli->eAlign)) 524 break; 525 aSortedList.Insert (i,k); 526 } 527 } 528 529 bSorted = sal_True; 530 } 531 532 533 //==================================================================== 534 // ctor f"ur workwin eines Frames 535 536 SfxFrameWorkWin_Impl::SfxFrameWorkWin_Impl( Window *pWin, SfxFrame *pFrm, SfxFrame* pMaster ) 537 : SfxWorkWindow( 538 pWin, 539 pFrm->GetCurrentViewFrame()->GetBindings(), 540 pFrm->GetParentFrame() ? pFrm->GetParentFrame()->GetWorkWindow_Impl() : NULL ) 541 , pMasterFrame( pMaster ) 542 , pFrame( pFrm ) 543 { 544 pConfigShell = pFrm->GetCurrentViewFrame(); 545 if ( pConfigShell && pConfigShell->GetObjectShell() ) 546 { 547 bShowStatusBar = ( !pConfigShell->GetObjectShell()->IsInPlaceActive() ); 548 bDockingAllowed = sal_True; 549 bInternalDockingAllowed = sal_True; 550 } 551 552 // Die ben"otigten SplitWindows (je eins f"ur jede Seite) werden erzeugt 553 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 554 { 555 // Die SplitWindows sind direkte ChildWindows des WorkWindows und enthalten 556 // die angedockten Fenster. 557 558 SfxChildAlignment eAlign = 559 ( n == SFX_SPLITWINDOWS_LEFT ? SFX_ALIGN_LEFT : 560 n == SFX_SPLITWINDOWS_RIGHT ? SFX_ALIGN_RIGHT : 561 n == SFX_SPLITWINDOWS_TOP ? SFX_ALIGN_TOP : 562 SFX_ALIGN_BOTTOM ); 563 SfxSplitWindow *pSplitWin = new SfxSplitWindow(pWorkWin, eAlign, this, pParent==0 ); 564 pSplit[n] = pSplitWin; 565 } 566 567 //nOrigMode = SFX_VISIBILITY_CLIENT; 568 nOrigMode = SFX_VISIBILITY_STANDARD; 569 nUpdateMode = SFX_VISIBILITY_STANDARD; 570 } 571 572 //==================================================================== 573 // ctor der Basisklasse 574 575 SfxWorkWindow::SfxWorkWindow( Window *pWin, SfxBindings& rB, SfxWorkWindow* pParentWorkwin ) : 576 pParent( pParentWorkwin ), 577 pBindings(&rB), 578 pWorkWin (pWin), 579 pConfigShell( 0 ), 580 pActiveChild( 0 ), 581 nChilds( 0 ), 582 nOrigMode( 0 ), 583 bSorted( sal_True ), 584 bDockingAllowed(sal_True), 585 bInternalDockingAllowed(sal_True), 586 bAllChildsVisible(sal_True), 587 bIsFullScreen( sal_False ), 588 bShowStatusBar( sal_True ), 589 m_nLock( 0 ), 590 m_aStatusBarResName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" )), 591 m_aLayoutManagerPropName( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )), 592 m_aTbxTypeName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/" )), 593 m_aProgressBarResName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/progressbar/progressbar" )) 594 { 595 DBG_CTOR(SfxWorkWindow, 0); 596 DBG_ASSERT (pBindings, "Keine Bindings!"); 597 598 pBindings->SetWorkWindow_Impl( this ); 599 600 pChildWins = new SfxChildWindows_Impl; 601 pChilds = new SfxChildList_Impl; 602 603 // F"ur die ObjectBars wird ein fester Platz in der ChildList reserviert, 604 // damit sie immer in einer definierten Reihenfolge kommen. 605 SfxChild_Impl* pChild=0; 606 for (sal_uInt16 n=0; n < SFX_OBJECTBAR_MAX; ++n) 607 pChilds->Insert(0,pChild); 608 609 // create and initialize layout manager listener 610 Reference< com::sun::star::frame::XFrame > xFrame = GetFrameInterface(); 611 LayoutManagerListener* pLayoutManagerListener = new LayoutManagerListener( this ); 612 m_xLayoutManagerListener = css::uno::Reference< css::lang::XComponent >( 613 static_cast< cppu::OWeakObject* >( pLayoutManagerListener ), 614 css::uno::UNO_QUERY ); 615 pLayoutManagerListener->setFrame( xFrame ); 616 } 617 618 //==================================================================== 619 // dtor 620 621 SfxWorkWindow::~SfxWorkWindow() 622 { 623 DBG_DTOR(SfxWorkWindow, 0); 624 625 // SplitWindows l"oschen 626 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 627 { 628 SfxSplitWindow *p = pSplit[n]; 629 if (p->GetWindowCount()) 630 ReleaseChild_Impl(*p); 631 delete p; 632 } 633 634 // Hilfsstruktur f"ur Child-Windows l"oschen 635 DBG_ASSERT( pChilds->Count() == 0, "dangling childs" ); 636 delete pChilds; 637 delete pChildWins; 638 639 if ( m_xLayoutManagerListener.is() ) 640 m_xLayoutManagerListener->dispose(); 641 } 642 643 SystemWindow* SfxWorkWindow::GetTopWindow() const 644 { 645 Window* pRet = pWorkWin; 646 while ( pRet && !pRet->IsSystemWindow() ) 647 pRet = pRet->GetParent(); 648 return (SystemWindow*) pRet; 649 } 650 651 void SfxWorkWindow::Lock_Impl( sal_Bool bLock ) 652 { 653 if ( bLock ) 654 m_nLock++; 655 else 656 --m_nLock; 657 if ( m_nLock<0 ) 658 { 659 DBG_ERROR("Lock count underflow!"); 660 m_nLock = 0; 661 } 662 663 if ( !m_nLock ) 664 ArrangeChilds_Impl(); 665 } 666 667 void SfxWorkWindow::ChangeWindow_Impl( Window *pNew ) 668 { 669 Window *pOld = pWorkWin; 670 pWorkWin = pNew; 671 for ( sal_uInt16 nPos = 0; nPos < pChilds->Count(); ++nPos ) 672 { 673 SfxChild_Impl *pCli = (*pChilds)[nPos]; 674 if ( pCli && pCli->pWin && pCli->pWin->GetParent() == pOld ) 675 { 676 pCli->pWin->SetParent( pNew ); 677 } 678 } 679 } 680 681 void SfxWorkWindow::SaveStatus_Impl() 682 { 683 sal_uInt16 nCount = pChildWins->Count(); 684 for ( sal_uInt16 n=0; n<nCount; n++ ) 685 { 686 SfxChildWin_Impl* pCW = (*pChildWins)[n]; 687 SfxChildWindow *pChild = pCW->pWin; 688 if (pChild) 689 { 690 sal_uInt16 nFlags = pCW->aInfo.nFlags; 691 pCW->aInfo = pChild->GetInfo(); 692 pCW->aInfo.nFlags |= nFlags; 693 SaveStatus_Impl(pChild, pCW->aInfo); 694 } 695 } 696 } 697 698 //-------------------------------------------------------------------- 699 // Hilfsmethode zum Freigeben der Childlisten. Wenn danach nicht der dtor 700 // aufgerufen wird, sondern weiter gearbeitet wird, mu\s wie im ctor von 701 // SfxWorkWindow noch Platz f"ur die Objectbars und SplitWindows reserviert 702 // werden. 703 704 void SfxWorkWindow::DeleteControllers_Impl() 705 { 706 DBG_CHKTHIS(SfxWorkWindow, 0); 707 708 // SplitWindows locken (d.h. Resize-Reaktion an den 709 // DockingWindows unterdr"ucken) 710 sal_uInt16 n; 711 for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 712 { 713 SfxSplitWindow *p = pSplit[n]; 714 if (p->GetWindowCount()) 715 p->Lock(); 716 } 717 718 // Child-Windows l"oschen 719 for ( n=0; n<pChildWins->Count(); ) 720 { 721 SfxChildWin_Impl* pCW = (*pChildWins)[n]; 722 pChildWins->Remove(n); 723 SfxChildWindow *pChild = pCW->pWin; 724 if (pChild) 725 { 726 /* 727 sal_uInt16 nFlags = pCW->aInfo.nFlags; 728 pCW->aInfo = pChild->GetInfo(); 729 pCW->aInfo.nFlags |= nFlags; 730 SaveStatus_Impl(pChild, pCW->aInfo); 731 */ 732 pChild->Hide(); 733 734 // Wenn das ChildWindow ein direktes Childfenster ist und nicht 735 // in einem SplitWindow liegt, am WorkWindow abmelden. 736 // Nach TH ist eine Abmeldung am Splitwindow nicht erforderlich, 737 // wenn dieses auch gleich mit zerst"ort wird (s.u.). 738 if (pCW->pCli) 739 ReleaseChild_Impl(*pChild->GetWindow()); 740 pCW->pWin = 0; 741 pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChild->GetWindow() ); 742 pChild->Destroy(); 743 } 744 745 delete pCW; 746 747 // ATTENTION: The array itself is cleared after this loop!! 748 // Therefore we have to set every array entry to zero as it could be 749 // accessed by calling pChild->Destroy(). 750 // See task 128307 (Windows) 751 // Window::NotifyAllChilds() calls SfxWorkWindow::DataChanged_Impl for 752 // 8-bit displays (WM_QUERYPALETTECHANGED message due to focus change)!! 753 //(*pChildWins)[n] = 0; 754 } 755 756 //pChildWins->Remove((sal_uInt16)0, nCount); 757 758 Reference< com::sun::star::frame::XFrame > xFrame = GetFrameInterface(); 759 Reference< com::sun::star::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY ); 760 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; 761 if ( xPropSet.is() ) 762 { 763 try 764 { 765 Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 766 aValue >>= xLayoutManager; 767 } 768 catch ( Exception& ) 769 { 770 } 771 } 772 773 if ( xLayoutManager.is() ) 774 { 775 xLayoutManager->reset(); 776 777 // StatusBar l"oschen 778 ResetStatusBar_Impl(); 779 780 // ObjectBars l"oschen( zuletzt, damit pChilds nicht tote Pointer enh"alt ) 781 for ( sal_uInt16 i = 0; i < aObjBarList.size(); i++ ) 782 { 783 // Nicht jede Position mu\s belegt sein 784 sal_uInt16 nId = aObjBarList[i].nId; 785 if ( nId ) 786 aObjBarList[i].nId = 0; 787 } 788 } 789 790 // ObjectBars werden alle auf einmal released, da sie einen 791 // festen zusammenh"angenden Bereich im Array pChilds belegen 792 pChilds->Remove(0, SFX_OBJECTBAR_MAX); 793 bSorted = sal_False; 794 795 nChilds = 0; 796 } 797 798 //==================================================================== 799 // Virtuelle Methode zum Anordnen der Childfenster. 800 801 void SfxWorkWindow::ArrangeChilds_Impl( sal_Bool /*bForce*/) 802 { 803 Arrange_Impl(); 804 } 805 806 void SfxFrameWorkWin_Impl::ArrangeChilds_Impl( sal_Bool bForce ) 807 { 808 if ( pFrame->IsClosing_Impl() || ( m_nLock && !bForce )) 809 return; 810 811 SfxInPlaceClient *pClient = 0; 812 SfxViewFrame *pF = pFrame->GetCurrentViewFrame(); 813 if ( pF && pF->GetViewShell() ) 814 pClient = pF->GetViewShell()->GetIPClient(); 815 816 if ( pClient ) 817 return; 818 819 aClientArea = GetTopRect_Impl(); 820 if ( aClientArea.IsEmpty() ) 821 return; 822 823 SvBorder aBorder; 824 if ( nChilds ) 825 { 826 if ( IsVisible_Impl() ) 827 aBorder = Arrange_Impl(); 828 } 829 830 // Wenn das aktuelle Dokument der Applikation einen IPClient enth"alt, mu\s 831 // dem dazugeh"origen Objekt durch SetTopToolFramePixel der zur Verf"ugung 832 // stehende Platz zugeteilt werden. Das Objekt zeigt dann seine UITools an 833 // und setzt den App-Border(->SfxInPlaceEnv_Impl::ArrangeChilds_Impl()). 834 // Anderenfalls wird hier direkt der AppBorder gesetzt, um evtl. den Border 835 // zu "uberschreiben, den bisher ein Objekt aus einem anderen Dokument 836 // gesetzt hatte. 837 // Das Objekt setzt, wenn es seine UI-Tools wegnimmt, den SetAppBorder nicht, 838 // damit kein ObjectBar-Zappeln entsteht. 839 // (->SfxInPlaceEnv_Impl::ArrangeChilds_Impl()) 840 841 pMasterFrame->SetToolSpaceBorderPixel_Impl( aBorder ); 842 843 ArrangeAutoHideWindows( NULL ); 844 } 845 846 //-------------------------------------------------------------------- 847 848 SvBorder SfxWorkWindow::Arrange_Impl() 849 850 /* [Beschreibung] 851 852 Diese Methode ordnet alle sichtbaren ChildFenster so an, da\s die angedockten 853 Fenster nach der Sorierreihenfolge von au\sen nach innen aneinander 854 gesetzt werden. Wenn ein an sich sichtbares Fenster nicht mehr in die 855 noch freie ClientArea pa\st, wird es auf "nicht sichtbar" gesetzt. 856 857 */ 858 { 859 DBG_CHKTHIS(SfxWorkWindow, 0); 860 861 aClientArea = GetTopRect_Impl(); 862 aUpperClientArea = aClientArea; 863 864 SvBorder aBorder; 865 if ( !nChilds ) 866 return aBorder; 867 868 if (!bSorted) 869 Sort_Impl(); 870 871 Point aPos; 872 Size aSize; 873 Rectangle aTmp( aClientArea ); 874 875 for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n ) 876 { 877 SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]]; 878 if ( !pCli->pWin ) 879 continue; 880 881 // Zun"achst nehmen wir an, da\s das Fenster Platz hat 882 pCli->nVisible |= CHILD_FITS_IN; 883 884 // Nicht sichtbare Fenster "uberspringen 885 if (pCli->nVisible != CHILD_VISIBLE) 886 continue; 887 888 if ( pCli->bResize ) 889 aSize = pCli->aSize; 890 else 891 aSize = pCli->pWin->GetSizePixel(); 892 893 SvBorder aTemp = aBorder; 894 sal_Bool bAllowHiding = sal_True; 895 switch ( pCli->eAlign ) 896 { 897 case SFX_ALIGN_HIGHESTTOP: 898 case SFX_ALIGN_TOP: 899 case SFX_ALIGN_TOOLBOXTOP: 900 case SFX_ALIGN_LOWESTTOP: 901 aSize.Width() = aTmp.GetWidth(); 902 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW ) 903 aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize ); 904 bAllowHiding = sal_False; 905 aBorder.Top() += aSize.Height(); 906 aPos = aTmp.TopLeft(); 907 aTmp.Top() += aSize.Height(); 908 if ( pCli->eAlign == SFX_ALIGN_HIGHESTTOP ) 909 aUpperClientArea.Top() += aSize.Height(); 910 break; 911 912 case SFX_ALIGN_LOWESTBOTTOM: 913 case SFX_ALIGN_BOTTOM: 914 case SFX_ALIGN_TOOLBOXBOTTOM: 915 case SFX_ALIGN_HIGHESTBOTTOM: 916 aSize.Width() = aTmp.GetWidth(); 917 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW ) 918 aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize ); 919 aBorder.Bottom() += aSize.Height(); 920 aPos = aTmp.BottomLeft(); 921 aPos.Y() -= (aSize.Height()-1); 922 aTmp.Bottom() -= aSize.Height(); 923 if ( pCli->eAlign == SFX_ALIGN_LOWESTBOTTOM ) 924 aUpperClientArea.Bottom() -= aSize.Height(); 925 break; 926 927 case SFX_ALIGN_FIRSTLEFT: 928 case SFX_ALIGN_LEFT: 929 case SFX_ALIGN_LASTLEFT: 930 case SFX_ALIGN_TOOLBOXLEFT: 931 aSize.Height() = aTmp.GetHeight(); 932 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW ) 933 aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize ); 934 bAllowHiding = sal_False; 935 aBorder.Left() += aSize.Width(); 936 aPos = aTmp.TopLeft(); 937 aTmp.Left() += aSize.Width(); 938 if ( pCli->eAlign != SFX_ALIGN_TOOLBOXLEFT ) 939 aUpperClientArea.Left() += aSize.Width(); 940 break; 941 942 case SFX_ALIGN_FIRSTRIGHT: 943 case SFX_ALIGN_RIGHT: 944 case SFX_ALIGN_LASTRIGHT: 945 case SFX_ALIGN_TOOLBOXRIGHT: 946 aSize.Height() = aTmp.GetHeight(); 947 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW ) 948 aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize ); 949 aBorder.Right() += aSize.Width(); 950 aPos = aTmp.TopRight(); 951 aPos.X() -= (aSize.Width()-1); 952 aTmp.Right() -= aSize.Width(); 953 if ( pCli->eAlign != SFX_ALIGN_TOOLBOXRIGHT ) 954 aUpperClientArea.Right() -= aSize.Width(); 955 break; 956 957 default: 958 pCli->aSize = pCli->pWin->GetSizePixel(); 959 pCli->bResize = sal_False; 960 continue; 961 } 962 963 pCli->pWin->SetPosSizePixel( aPos, aSize ); 964 pCli->bResize = sal_False; 965 pCli->aSize = aSize; 966 if( bAllowHiding && !RequestTopToolSpacePixel_Impl( aBorder ) ) 967 { 968 pCli->nVisible ^= CHILD_FITS_IN; 969 aBorder = aTemp; 970 } 971 } 972 973 if ( aClientArea.GetWidth() >= aBorder.Left() + aBorder.Right() ) 974 { 975 aClientArea.Left() += aBorder.Left(); 976 aClientArea.Right() -= aBorder.Right(); 977 } 978 else 979 { 980 aBorder.Left() = aClientArea.Left(); 981 aBorder.Right() = aClientArea.Right(); 982 aClientArea.Right() = aClientArea.Left() = aTmp.Left(); 983 } 984 985 if ( aClientArea.GetHeight() >= aBorder.Top() + aBorder.Bottom() ) 986 { 987 aClientArea.Top() += aBorder.Top(); 988 aClientArea.Bottom() -= aBorder.Bottom(); 989 } 990 else 991 { 992 aBorder.Top() = aClientArea.Top(); 993 aBorder.Bottom() = aClientArea.Bottom(); 994 aClientArea.Top() = aClientArea.Bottom() = aTmp.Top(); 995 } 996 997 return IsDockingAllowed() ? aBorder : SvBorder(); 998 } 999 1000 //-------------------------------------------------------------------- 1001 // Close-Handler: die Konfiguration der ChildWindows wird gespeichert. 1002 // 1003 1004 void SfxWorkWindow::Close_Impl() 1005 { 1006 for (sal_uInt16 n=0; n<pChildWins->Count(); n++) 1007 { 1008 SfxChildWin_Impl *pCW = (*pChildWins)[n]; 1009 SfxChildWindow *pChild = pCW->pWin; 1010 if (pChild) 1011 { 1012 sal_uInt16 nFlags = pCW->aInfo.nFlags; 1013 pCW->aInfo = pChild->GetInfo(); 1014 pCW->aInfo.nFlags |= nFlags; 1015 SaveStatus_Impl(pChild, pCW->aInfo); 1016 } 1017 } 1018 } 1019 1020 sal_Bool SfxWorkWindow::PrepareClose_Impl() 1021 { 1022 for (sal_uInt16 n=0; n<pChildWins->Count(); n++) 1023 { 1024 SfxChildWin_Impl *pCW = (*pChildWins)[n]; 1025 SfxChildWindow *pChild = pCW->pWin; 1026 if ( pChild && !pChild->QueryClose() ) 1027 return sal_False; 1028 } 1029 1030 return sal_True; 1031 } 1032 1033 //-------------------------------------------------------------------- 1034 1035 SfxChild_Impl* SfxWorkWindow::RegisterChild_Impl( Window& rWindow, 1036 SfxChildAlignment eAlign, sal_Bool bCanGetFocus ) 1037 { 1038 DBG_CHKTHIS(SfxWorkWindow, 0); 1039 DBG_ASSERT( pChilds->Count() < 255, "too many childs" ); 1040 DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" ); 1041 DBG_ASSERT( !FindChild_Impl(rWindow), "child registered more than once" ); 1042 1043 1044 if ( rWindow.GetParent() != pWorkWin ) 1045 rWindow.SetParent( pWorkWin ); 1046 1047 SfxChild_Impl *pChild = new SfxChild_Impl(rWindow, rWindow.GetSizePixel(), 1048 eAlign, rWindow.IsVisible()); 1049 pChild->bCanGetFocus = bCanGetFocus; 1050 1051 pChilds->Insert(pChilds->Count(), pChild); 1052 bSorted = sal_False; 1053 nChilds++; 1054 return (*pChilds)[pChilds->Count()-1]; 1055 } 1056 1057 //-------------------------------------------------------------------- 1058 1059 void SfxWorkWindow::AlignChild_Impl( Window& rWindow, 1060 const Size& rNewSize, 1061 SfxChildAlignment eAlign ) 1062 { 1063 DBG_CHKTHIS(SfxWorkWindow, 0); 1064 // DBG_ASSERT( pChilds, "aligning unregistered child" ); 1065 DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" ); 1066 1067 SfxChild_Impl *pChild = FindChild_Impl(rWindow); 1068 if ( pChild ) 1069 { 1070 if (pChild->eAlign != eAlign) 1071 bSorted = sal_False; 1072 1073 pChild->eAlign = eAlign; 1074 pChild->aSize = rNewSize; 1075 pChild->bResize = sal_True; 1076 } 1077 else { 1078 DBG_ERROR( "aligning unregistered child" ); 1079 } 1080 } 1081 1082 //-------------------------------------------------------------------- 1083 1084 void SfxWorkWindow::ReleaseChild_Impl( Window& rWindow ) 1085 { 1086 DBG_CHKTHIS(SfxWorkWindow, 0); 1087 // DBG_ASSERT( pChilds, "releasing unregistered child" ); 1088 1089 SfxChild_Impl *pChild = 0; 1090 sal_uInt16 nPos; 1091 for ( nPos = 0; nPos < pChilds->Count(); ++nPos ) 1092 { 1093 pChild = (*pChilds)[nPos]; 1094 if ( pChild ) 1095 if ( pChild->pWin == &rWindow ) 1096 break; 1097 } 1098 1099 if ( nPos < pChilds->Count() ) 1100 { 1101 bSorted = sal_False; 1102 nChilds--; 1103 pChilds->Remove(nPos); 1104 delete pChild; 1105 } 1106 else { 1107 DBG_ERROR( "releasing unregistered child" ); 1108 } 1109 } 1110 1111 //-------------------------------------------------------------------- 1112 1113 SfxChild_Impl* SfxWorkWindow::FindChild_Impl( const Window& rWindow ) const 1114 { 1115 DBG_CHKTHIS(SfxWorkWindow, 0); 1116 1117 SfxChild_Impl *pChild = 0; 1118 sal_uInt16 nCount = pChilds->Count(); 1119 for ( sal_uInt16 nPos = 0; nPos < nCount; ++nPos ) 1120 { 1121 pChild = (*pChilds)[nPos]; 1122 if ( pChild ) 1123 if ( pChild->pWin == &rWindow ) 1124 return pChild; 1125 } 1126 1127 return 0; 1128 } 1129 1130 //-------------------------------------------------------------------- 1131 1132 void SfxWorkWindow::ShowChilds_Impl() 1133 { 1134 DBG_CHKTHIS(SfxWorkWindow, 0); 1135 1136 bool bInvisible = ( !IsVisible_Impl() || ( !pWorkWin->IsReallyVisible() && !pWorkWin->IsReallyShown() )); 1137 1138 SfxChild_Impl *pCli = 0; 1139 for ( sal_uInt16 nPos = 0; nPos < pChilds->Count(); ++nPos ) 1140 { 1141 SfxChildWin_Impl* pCW = 0; 1142 pCli = (*pChilds)[nPos]; 1143 1144 if ( pCli && pCli->pWin ) 1145 { 1146 // We have to find the SfxChildWin_Impl to retrieve the 1147 // SFX_CHILDWIN flags that can influence visibility. 1148 for (sal_uInt16 n=0; n<pChildWins->Count(); n++) 1149 { 1150 SfxChildWin_Impl* pCWin = (*pChildWins)[n]; 1151 SfxChild_Impl* pChild = pCWin->pCli; 1152 if ( pChild == pCli ) 1153 { 1154 pCW = pCWin; 1155 break; 1156 } 1157 } 1158 1159 bool bVisible( !bInvisible ); 1160 if ( pCW ) 1161 { 1162 // Check flag SFX_CHILDWIN_NEVERHIDE that forces us to show 1163 // the child window even in situations where no child window is 1164 // visible. 1165 sal_uInt16 nFlags = pCW->aInfo.nFlags; 1166 bVisible = !bInvisible || ( bInvisible & (( nFlags & SFX_CHILDWIN_NEVERHIDE ) != 0 )); 1167 } 1168 1169 if ( CHILD_VISIBLE == (pCli->nVisible & CHILD_VISIBLE) && bVisible ) 1170 { 1171 sal_uInt16 nFlags = pCli->bSetFocus ? 0 : SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE; 1172 switch ( pCli->pWin->GetType() ) 1173 { 1174 case RSC_DOCKINGWINDOW : 1175 ((DockingWindow*)pCli->pWin)->Show( sal_True, nFlags ); 1176 break; 1177 case RSC_SPLITWINDOW : 1178 ((SplitWindow*)pCli->pWin)->Show( sal_True, nFlags ); 1179 break; 1180 default: 1181 pCli->pWin->Show( sal_True, nFlags ); 1182 break; 1183 } 1184 1185 pCli->bSetFocus = sal_False; 1186 } 1187 else 1188 { 1189 switch ( pCli->pWin->GetType() ) 1190 { 1191 case RSC_DOCKINGWINDOW : 1192 ((DockingWindow*)pCli->pWin)->Hide(); 1193 break; 1194 default: 1195 pCli->pWin->Hide(); 1196 break; 1197 } 1198 } 1199 } 1200 } 1201 } 1202 1203 //-------------------------------------------------------------------- 1204 1205 void SfxWorkWindow::HideChilds_Impl() 1206 { 1207 SfxChild_Impl *pChild = 0; 1208 for ( sal_uInt16 nPos = pChilds->Count(); nPos > 0; --nPos ) 1209 { 1210 pChild = (*pChilds)[nPos-1]; 1211 if (pChild && pChild->pWin) 1212 { 1213 switch ( pChild->pWin->GetType() ) 1214 { 1215 case RSC_DOCKINGWINDOW : 1216 ((DockingWindow*)pChild->pWin)->Hide(); 1217 break; 1218 default: 1219 pChild->pWin->Hide(); 1220 break; 1221 } 1222 } 1223 } 1224 } 1225 1226 //------------------------------------------------------------------------ 1227 1228 void SfxWorkWindow::ResetObjectBars_Impl() 1229 { 1230 sal_uInt16 n; 1231 for ( n = 0; n < aObjBarList.size(); n++ ) 1232 aObjBarList[n].bDestroy = sal_True; 1233 1234 for ( n = 0; n < pChildWins->Count(); ++n ) 1235 (*pChildWins)[n]->nId = 0; 1236 } 1237 1238 void SfxWorkWindow::NextObjectBar_Impl( sal_uInt16 ) 1239 { 1240 } 1241 1242 sal_uInt16 SfxWorkWindow::HasNextObjectBar_Impl( sal_uInt16, String* ) 1243 { 1244 return 0; 1245 } 1246 1247 //------------------------------------------------------------------------ 1248 1249 void SfxWorkWindow::SetObjectBar_Impl( sal_uInt16 nPos, sal_uInt32 nResId, 1250 SfxInterface* pIFace, const String *pName) 1251 { 1252 DBG_ASSERT( (nPos & SFX_POSITION_MASK) < SFX_OBJECTBAR_MAX, 1253 "object bar position overflow" ); 1254 1255 sal_uInt16 nRealPos = nPos & SFX_POSITION_MASK; 1256 if ( pParent && IsAppWorkWinToolbox_Impl( nRealPos ) ) 1257 { 1258 pParent->SetObjectBar_Impl( nPos, nResId, pIFace, pName ); 1259 return; 1260 } 1261 1262 SfxObjectBar_Impl aObjBar; 1263 aObjBar.pIFace = pIFace; 1264 aObjBar.nId = sal::static_int_cast<sal_uInt16>(nResId); 1265 aObjBar.nPos = nRealPos; 1266 aObjBar.nMode = (nPos & SFX_VISIBILITY_MASK); 1267 if (pName) 1268 aObjBar.aName = *pName; 1269 else 1270 aObjBar.aName.Erase(); 1271 1272 for ( sal_uInt16 n=0; n<aObjBarList.size(); n++ ) 1273 { 1274 if ( aObjBarList[n].nId == aObjBar.nId ) 1275 { 1276 aObjBarList[n] = aObjBar; 1277 return; 1278 } 1279 } 1280 1281 aObjBarList.push_back( aObjBar ); 1282 } 1283 1284 //------------------------------------------------------------------------ 1285 1286 bool SfxWorkWindow::KnowsObjectBar_Impl( sal_uInt16 nPos ) const 1287 1288 /* [Beschreibung] 1289 1290 Stellt fest, ob an der betreffenden Position "uberhaupt eine 1291 Objektleiste zur Verf"ugung stehen w"urde. Ist unabh"agig davon, 1292 ob diese tats"achlich ein- oder ausgeschaltet ist. 1293 */ 1294 1295 { 1296 sal_uInt16 nRealPos = nPos & SFX_POSITION_MASK; 1297 if ( pParent && IsAppWorkWinToolbox_Impl( nRealPos ) ) 1298 return pParent->KnowsObjectBar_Impl( nPos ); 1299 1300 for ( sal_uInt16 n=0; n<aObjBarList.size(); n++ ) 1301 { 1302 if ( aObjBarList[n].nPos == nRealPos ) 1303 return true; 1304 } 1305 1306 return false; 1307 } 1308 1309 //------------------------------------------------------------------------ 1310 1311 sal_Bool SfxWorkWindow::IsVisible_Impl( sal_uInt16 nMode ) const 1312 { 1313 switch( nUpdateMode ) 1314 { 1315 case SFX_VISIBILITY_STANDARD: 1316 return sal_True; 1317 case SFX_VISIBILITY_UNVISIBLE: 1318 return sal_False; 1319 case SFX_VISIBILITY_PLUGSERVER: 1320 case SFX_VISIBILITY_PLUGCLIENT: 1321 case SFX_VISIBILITY_CLIENT: 1322 case SFX_VISIBILITY_SERVER: 1323 return !!(nMode & nUpdateMode); 1324 default: 1325 return !!(nMode & nOrigMode ) || 1326 nOrigMode == SFX_VISIBILITY_STANDARD; 1327 } 1328 } 1329 1330 Window* SfxWorkWindow::GetObjectBar_Impl( sal_uInt16, sal_uInt32 ) 1331 { 1332 return NULL; 1333 } 1334 1335 //------------------------------------------------------------------------ 1336 void SfxFrameWorkWin_Impl::UpdateObjectBars_Impl() 1337 { 1338 if ( pFrame->IsClosing_Impl() ) 1339 return; 1340 1341 SfxWorkWindow *pWork = pParent; 1342 while ( pWork ) 1343 { 1344 pWork->SfxWorkWindow::UpdateObjectBars_Impl(); 1345 pWork = pWork->GetParent_Impl(); 1346 } 1347 1348 SfxWorkWindow::UpdateObjectBars_Impl(); 1349 1350 // if ( pTask->IsActive() ) 1351 { 1352 pWork = pParent; 1353 while ( pWork ) 1354 { 1355 pWork->ArrangeChilds_Impl(); 1356 pWork = pWork->GetParent_Impl(); 1357 } 1358 1359 ArrangeChilds_Impl( sal_False ); 1360 1361 pWork = pParent; 1362 while ( pWork ) 1363 { 1364 pWork->ShowChilds_Impl(); 1365 pWork = pWork->GetParent_Impl(); 1366 } 1367 1368 ShowChilds_Impl(); 1369 } 1370 1371 ShowChilds_Impl(); 1372 } 1373 1374 Reference< ::com::sun::star::task::XStatusIndicator > SfxWorkWindow::GetStatusIndicator() 1375 { 1376 Reference< com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY ); 1377 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; 1378 Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator; 1379 1380 if ( xPropSet.is() ) 1381 { 1382 Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 1383 aValue >>= xLayoutManager; 1384 if ( xLayoutManager.is() ) 1385 { 1386 xLayoutManager->createElement( m_aProgressBarResName ); 1387 xLayoutManager->showElement( m_aProgressBarResName ); 1388 1389 Reference< ::com::sun::star::ui::XUIElement > xProgressBar = 1390 xLayoutManager->getElement( m_aProgressBarResName ); 1391 if ( xProgressBar.is() ) 1392 { 1393 xStatusIndicator = Reference< ::com::sun::star::task::XStatusIndicator >( 1394 xProgressBar->getRealInterface(), UNO_QUERY ); 1395 } 1396 } 1397 } 1398 1399 return xStatusIndicator; 1400 } 1401 1402 //------------------------------------------------------------------------ 1403 1404 sal_Bool SfxWorkWindow::IsPluginMode( SfxObjectShell* pObjShell ) 1405 { 1406 if ( pObjShell && pObjShell->GetMedium() ) 1407 { 1408 SFX_ITEMSET_ARG( pObjShell->GetMedium()->GetItemSet(), pViewOnlyItem, SfxBoolItem, SID_VIEWONLY, sal_False ); 1409 if ( pViewOnlyItem && pViewOnlyItem->GetValue() ) 1410 return sal_True; 1411 } 1412 1413 return sal_False; 1414 } 1415 1416 //------------------------------------------------------------------------ 1417 1418 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxWorkWindow::GetFrameInterface() 1419 { 1420 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > xFrame; 1421 1422 SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() ); 1423 if ( pDispatcher ) 1424 { 1425 SfxViewFrame* pFrame = pDispatcher->GetFrame(); 1426 if ( pFrame ) 1427 xFrame = pFrame->GetFrame().GetFrameInterface(); 1428 } 1429 1430 return xFrame; 1431 } 1432 1433 //------------------------------------------------------------------------ 1434 1435 void SfxWorkWindow::UpdateObjectBars_Impl() 1436 { 1437 // SplitWindows locken (d.h. Resize-Reaktion an den 1438 // DockingWindows unterdr"ucken) 1439 sal_uInt16 n; 1440 for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 1441 { 1442 SfxSplitWindow *p = pSplit[n]; 1443 if (p->GetWindowCount()) 1444 p->Lock(); 1445 } 1446 1447 // was man so "ofters braucht, merkt man sich (spart Code und Laufzeit) 1448 SFX_APP(); 1449 1450 Reference< com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY ); 1451 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; 1452 1453 if ( xPropSet.is() ) 1454 { 1455 Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 1456 aValue >>= xLayoutManager; 1457 } 1458 1459 if ( !xLayoutManager.is() ) 1460 return; 1461 1462 sal_Bool bPluginMode( sal_False ); 1463 SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() ); 1464 1465 if ( pDispatcher ) 1466 { 1467 SfxViewFrame* pFrame = pDispatcher->GetFrame(); 1468 if ( pFrame ) 1469 bPluginMode = IsPluginMode( pFrame->GetObjectShell() ); 1470 } 1471 1472 // "uber alle Toolboxen iterieren 1473 xLayoutManager->lock(); 1474 for ( n = 0; n < aObjBarList.size(); ++n ) 1475 { 1476 sal_uInt16 nId = aObjBarList[n].nId; 1477 sal_Bool bDestroy = aObjBarList[n].bDestroy; 1478 1479 // die Modi bestimmen, f"ur die die ToolBox gilt 1480 sal_uInt16 nTbxMode = aObjBarList[n].nMode; 1481 bool bFullScreenTbx = SFX_VISIBILITY_FULLSCREEN == 1482 ( nTbxMode & SFX_VISIBILITY_FULLSCREEN ); 1483 nTbxMode &= ~SFX_VISIBILITY_FULLSCREEN; 1484 nTbxMode &= ~SFX_VISIBILITY_VIEWER; 1485 1486 // wird in diesem Kontext eine ToolBox gefordert? 1487 bool bModesMatching = ( nUpdateMode && ( nTbxMode & nUpdateMode) == nUpdateMode ); 1488 if ( bDestroy ) 1489 { 1490 rtl::OUString aTbxId( m_aTbxTypeName ); 1491 aTbxId += GetResourceURLFromResId( aObjBarList[n].nId ); 1492 xLayoutManager->destroyElement( aTbxId ); 1493 } 1494 else if ( nId != 0 && ( ( bModesMatching && !bIsFullScreen ) || 1495 ( bIsFullScreen && bFullScreenTbx ) ) ) 1496 { 1497 rtl::OUString aTbxId( m_aTbxTypeName ); 1498 aTbxId += GetResourceURLFromResId( aObjBarList[n].nId ); 1499 if ( !IsDockingAllowed() && !xLayoutManager->isElementFloating( aTbxId )) 1500 xLayoutManager->destroyElement( aTbxId ); 1501 else 1502 { 1503 xLayoutManager->requestElement( aTbxId ); 1504 if ( bPluginMode ) 1505 xLayoutManager->lockWindow( aTbxId ); 1506 } 1507 } 1508 else if ( nId != 0 ) 1509 { 1510 // ggf. Toolbox an dieser Position l"oschen 1511 rtl::OUString aTbxId( m_aTbxTypeName ); 1512 aTbxId += GetResourceURLFromResId( aObjBarList[n].nId ); 1513 xLayoutManager->destroyElement( aTbxId ); 1514 } 1515 } 1516 1517 UpdateStatusBar_Impl(); 1518 1519 // unlocking automatically forces Layout 1520 xLayoutManager->unlock(); 1521 1522 UpdateChildWindows_Impl(); 1523 1524 // SplitWindows wieder ent-locken 1525 for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 1526 { 1527 SfxSplitWindow *p = pSplit[n]; 1528 if (p->GetWindowCount()) 1529 p->Lock(sal_False); 1530 } 1531 } 1532 1533 bool SfxWorkWindow::AllowChildWindowCreation_Impl( const SfxChildWin_Impl& i_rCW ) const 1534 { 1535 // or checking the availability of child windows, we need access to the module 1536 const SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame(); 1537 const SfxObjectShell* pShell = pViewFrame ? pViewFrame->GetObjectShell() : NULL; 1538 const SfxModule* pModule = pShell ? pShell->GetModule() : NULL; 1539 ENSURE_OR_RETURN( pModule, "SfxWorkWindow::UpdateChildWindows_Impl: did not find an SfxModule to ask for the child win availability!", true ); 1540 return pModule->IsChildWindowAvailable( i_rCW.nId, pViewFrame ); 1541 } 1542 1543 void SfxWorkWindow::UpdateChildWindows_Impl() 1544 { 1545 // alle vorhandenen oder in den Kontext gekommenen ChildWindows 1546 for ( sal_uInt16 n=0; n<pChildWins->Count(); n++ ) 1547 { 1548 SfxChildWin_Impl *pCW = (*pChildWins)[n]; 1549 SfxChildWindow *pChildWin = pCW->pWin; 1550 sal_Bool bCreate = sal_False; 1551 if ( pCW->nId && !pCW->bDisabled && (pCW->aInfo.nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE || IsVisible_Impl( pCW->nVisibility ) ) ) 1552 { 1553 // Im Kontext ist ein geeignetes ChildWindow erlaubt; 1554 // ist es auch eingeschaltet ? 1555 if ( pChildWin == NULL && pCW->bCreate ) 1556 { 1557 // Internal docking is only used for embedding into another 1558 // container. We force the floating state of all floatable 1559 // child windows. 1560 if ( !bInternalDockingAllowed ) 1561 { 1562 // Special case for all non-floatable child windows. We have 1563 // to prevent the creation here! 1564 bCreate = !( pCW->aInfo.nFlags & SFX_CHILDWIN_FORCEDOCK ); 1565 } 1566 else if ( !IsDockingAllowed() || bIsFullScreen ) // || !bInternalDocking ) 1567 { 1568 // im PresentationMode oder FullScreen nur FloatingWindows 1569 SfxChildAlignment eAlign; 1570 if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) ) 1571 bCreate = ( eAlign == SFX_ALIGN_NOALIGNMENT ); 1572 } 1573 else 1574 bCreate = sal_True; 1575 1576 if ( bCreate ) 1577 bCreate = AllowChildWindowCreation_Impl( *pCW ); 1578 1579 // Momentan kein Fenster da, aber es ist eingeschaltet; Fenster 1580 // und ggf. Context erzeugen 1581 if ( bCreate ) 1582 CreateChildWin_Impl( pCW, sal_False ); 1583 1584 if ( !bAllChildsVisible ) 1585 { 1586 if ( pCW->pCli ) 1587 pCW->pCli->nVisible &= ~CHILD_ACTIVE; 1588 } 1589 } 1590 else if ( pChildWin ) 1591 { 1592 // Fenster existiert schon; soll es auch sichtbar sein ? 1593 if ( ( !bIsFullScreen || pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT ) && bAllChildsVisible ) 1594 { 1595 // Updatemode ist kompatibel; auf jeden Fall wieder einschalten 1596 bCreate = AllowChildWindowCreation_Impl( *pCW ); 1597 if ( bCreate ) 1598 { 1599 if ( pCW->pCli ) 1600 { 1601 // Fenster ist direktes Child 1602 if ( bAllChildsVisible && ( (IsDockingAllowed() && bInternalDockingAllowed) || pCW->pCli->eAlign == SFX_ALIGN_NOALIGNMENT ) ) 1603 pCW->pCli->nVisible |= CHILD_NOT_HIDDEN; 1604 } 1605 else 1606 { 1607 if ( pCW->bCreate && IsDockingAllowed() && bInternalDockingAllowed ) 1608 // Fenster liegt in einem SplitWindow 1609 ((SfxDockingWindow*)pChildWin->GetWindow())->Reappear_Impl(); 1610 } 1611 1612 if ( pCW->nInterfaceId != pChildWin->GetContextId() ) 1613 pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() ); 1614 } 1615 } 1616 } 1617 } 1618 1619 if ( pChildWin && !bCreate ) 1620 { 1621 if ( !pChildWin->QueryClose() || pChildWin->IsHideNotDelete() || Application::IsUICaptured() ) 1622 { 1623 if ( pCW->pCli ) 1624 { 1625 if ( pCW->pCli->nVisible & CHILD_NOT_HIDDEN ) 1626 pCW->pCli->nVisible ^= CHILD_NOT_HIDDEN; 1627 } 1628 else 1629 ((SfxDockingWindow*)pChildWin->GetWindow())->Disappear_Impl(); 1630 } 1631 else 1632 RemoveChildWin_Impl( pCW ); 1633 } 1634 } 1635 } 1636 1637 void SfxWorkWindow::CreateChildWin_Impl( SfxChildWin_Impl *pCW, sal_Bool bSetFocus ) 1638 { 1639 if ( pCW->aInfo.bVisible != 42 ) 1640 pCW->aInfo.bVisible = sal_True; 1641 1642 SfxChildWindow *pChildWin = SfxChildWindow::CreateChildWindow( pCW->nId, pWorkWin, &GetBindings(), pCW->aInfo); 1643 if (pChildWin) 1644 { 1645 if ( bSetFocus ) 1646 bSetFocus = pChildWin->WantsFocus(); 1647 pChildWin->SetWorkWindow_Impl( this ); 1648 #if 0 1649 // Enable-Status richtig setzen 1650 pChildWin->GetWindow()->EnableInput( pCW->bEnable && 1651 ( pWorkWin->IsInputEnabled() /* || pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT */ ) ); 1652 #endif 1653 // Zumindest der ExtraString wird beim Auswerten ver"andert, also neu holen 1654 SfxChildWinInfo aInfo = pChildWin->GetInfo(); 1655 pCW->aInfo.aExtraString = aInfo.aExtraString; 1656 pCW->aInfo.bVisible = aInfo.bVisible; 1657 pCW->aInfo.nFlags |= aInfo.nFlags; 1658 1659 // Nein !! Sonst kann man keine Fenster defaultmaessig ausschalten ( Partwindow! ) 1660 // pCW->aInfo.bVisible = sal_True; 1661 1662 // Erzeugung war erfolgreich 1663 GetBindings().Invalidate(pCW->nId); 1664 1665 sal_uInt16 nPos = pChildWin->GetPosition(); 1666 if (nPos != CHILDWIN_NOPOS) 1667 { 1668 DBG_ASSERT(nPos < SFX_OBJECTBAR_MAX, "Illegal objectbar position!"); 1669 if ((*pChilds)[TbxMatch(nPos)])// && 1670 // pChildWin->GetAlignment() == (*pChilds)[nPos]->eAlign ) 1671 { 1672 // ChildWindow ersetzt ObjectBar 1673 (*pChilds)[TbxMatch(nPos)]->nVisible ^= CHILD_NOT_HIDDEN; 1674 } 1675 } 1676 1677 // make childwin keyboard accessible 1678 pWorkWin->GetSystemWindow()->GetTaskPaneList()->AddWindow( pChildWin->GetWindow() ); 1679 1680 pCW->pWin = pChildWin; 1681 1682 if ( pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT || pChildWin->GetWindow()->GetParent() == pWorkWin) 1683 { 1684 // Das Fenster ist entweder nicht angedockt oder au\serhalb 1685 // eines SplitWindows angedockt und mu\s daher explizit als 1686 // Child registriert werden 1687 pCW->pCli = RegisterChild_Impl(*(pChildWin->GetWindow()), pChildWin->GetAlignment(), pChildWin->CanGetFocus()); 1688 pCW->pCli->nVisible = CHILD_VISIBLE; 1689 if ( pChildWin->GetAlignment() != SFX_ALIGN_NOALIGNMENT && bIsFullScreen ) 1690 pCW->pCli->nVisible ^= CHILD_ACTIVE; 1691 pCW->pCli->bSetFocus = bSetFocus; 1692 } 1693 else 1694 { 1695 // Ein angedocktes Fenster, dessen Parent nicht das WorkWindow ist, 1696 // mu\s in einem SplitWindow liegen und daher nicht explizit 1697 // registriert werden. 1698 // Das passiert aber schon bei der Initialisierung des 1699 // SfxDockingWindows! 1700 } 1701 1702 if ( pCW->nInterfaceId != pChildWin->GetContextId() ) 1703 pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() ); 1704 1705 // Information in der INI-Datei sichern 1706 SaveStatus_Impl(pChildWin, pCW->aInfo); 1707 } 1708 } 1709 1710 void SfxWorkWindow::RemoveChildWin_Impl( SfxChildWin_Impl *pCW ) 1711 { 1712 sal_uInt16 nId = pCW->nSaveId; 1713 SfxChildWindow *pChildWin = pCW->pWin; 1714 1715 // vorhandenes Fenster geht aus dem Kontext und wird daher entfernt 1716 sal_uInt16 nPos = pChildWin->GetPosition(); 1717 if (nPos != CHILDWIN_NOPOS) 1718 { 1719 /* 1720 // ChildWindow "uberlagert einen ObjectBar 1721 DBG_ASSERT(nPos < SFX_OBJECTBAR_MAX, "Illegal objectbar position!"); 1722 if ((*pChilds)[TbxMatch(nPos)] && 1723 (aObjBars[nPos].nMode & nUpdateMode) ) //&& 1724 // pChildWin->GetAlignment() == (*pChilds)[nPos]->eAlign ) 1725 { 1726 // ObjectBar war "uberlagert; jetzt wieder anzeigen 1727 (*pChilds)[TbxMatch(nPos)]->nVisible ^= CHILD_NOT_HIDDEN; 1728 } 1729 */ 1730 } 1731 1732 // Information in der INI-Datei sichern 1733 sal_uInt16 nFlags = pCW->aInfo.nFlags; 1734 pCW->aInfo = pChildWin->GetInfo(); 1735 pCW->aInfo.nFlags |= nFlags; 1736 SaveStatus_Impl(pChildWin, pCW->aInfo); 1737 1738 pChildWin->Hide(); 1739 1740 if ( pCW->pCli ) 1741 { 1742 // ChildWindow ist ein direktes ChildWindow und mu\s sich daher 1743 // beim WorkWindow abmelden 1744 pCW->pCli = 0; 1745 ReleaseChild_Impl(*pChildWin->GetWindow()); 1746 } 1747 else 1748 { 1749 // ChildWindow liegt in einem SplitWindow und meldet sich 1750 // selbst im dtor dort ab 1751 } 1752 1753 pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChildWin->GetWindow() ); 1754 pCW->pWin = 0; 1755 pChildWin->Destroy(); 1756 1757 GetBindings().Invalidate( nId ); 1758 } 1759 1760 void SfxWorkWindow::ResetStatusBar_Impl() 1761 { 1762 aStatBar.nId = 0; 1763 } 1764 1765 //-------------------------------------------------------------------- 1766 void SfxWorkWindow::SetStatusBar_Impl( sal_uInt32 nResId, SfxShell*, SfxBindings& ) 1767 { 1768 if ( nResId && bShowStatusBar && IsVisible_Impl() ) 1769 aStatBar.nId = sal::static_int_cast<sal_uInt16>(nResId); 1770 } 1771 1772 #define SFX_ITEMTYPE_STATBAR 4 1773 1774 void SfxWorkWindow::SetTempStatusBar_Impl( sal_Bool bSet ) 1775 { 1776 if ( aStatBar.bTemp != bSet && bShowStatusBar && IsVisible_Impl() ) 1777 { 1778 sal_Bool bOn = sal_False; 1779 sal_Bool bReset = sal_False; 1780 if ( bSet && !aStatBar.nId ) 1781 { 1782 bReset = sal_True; 1783 SetStatusBar_Impl( SFX_ITEMTYPE_STATBAR, SFX_APP(), GetBindings() ); 1784 } 1785 1786 if ( aStatBar.nId && aStatBar.bOn && !bIsFullScreen ) 1787 bOn = sal_True; 1788 1789 aStatBar.bTemp = bSet; 1790 if ( !bOn || bReset || (!bSet && aStatBar.nId ) ) 1791 { 1792 // Nur was tun, wenn die Temp-Einstellung wirklich was bewirkt 1793 UpdateStatusBar_Impl(); 1794 ArrangeChilds_Impl(); 1795 ShowChilds_Impl(); 1796 } 1797 1798 if ( bReset ) 1799 ResetStatusBar_Impl(); 1800 } 1801 } 1802 1803 void SfxWorkWindow::UpdateStatusBar_Impl() 1804 { 1805 Reference< ::com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY ); 1806 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; 1807 1808 Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName ); 1809 aValue >>= xLayoutManager; 1810 1811 // keine Statusleiste, wenn keine Id gew"unscht oder bei FullScreenView 1812 // oder wenn ausgeschaltet 1813 if ( aStatBar.nId && IsDockingAllowed() && bInternalDockingAllowed && bShowStatusBar && 1814 ( (aStatBar.bOn && !bIsFullScreen) || aStatBar.bTemp ) ) 1815 { 1816 // Id hat sich ge"andert, also passenden Statusbarmanager erzeugen, 1817 // dieser "ubernimmt die aktuelle Statusleiste; 1818 if ( xLayoutManager.is() ) 1819 xLayoutManager->requestElement( m_aStatusBarResName ); 1820 } 1821 else 1822 { 1823 // Aktuelle StatusBar vernichten 1824 // Der Manager erzeugt die Statusleiste nur, er zerst"ort sie 1825 // nicht ! 1826 if ( xLayoutManager.is() ) 1827 xLayoutManager->destroyElement( m_aStatusBarResName ); 1828 } 1829 } 1830 1831 //------------------------------------------------------------------------ 1832 /* 1833 void SfxWorkWindow::SetObjectBarVisibility_Impl( sal_uInt16 nMask ) 1834 { 1835 switch( nMask ) 1836 { 1837 case SFX_VISIBILITY_UNVISIBLE: 1838 case SFX_VISIBILITY_STANDARD: 1839 case SFX_VISIBILITY_CLIENT: 1840 case SFX_VISIBILITY_SERVER: 1841 nOrigMode = nMask; 1842 } 1843 if (nMask != nUpdateMode) 1844 nUpdateMode = nMask; 1845 }*/ 1846 1847 void SfxWorkWindow::MakeVisible_Impl( sal_Bool bVis ) 1848 { 1849 if ( bVis ) 1850 nOrigMode = SFX_VISIBILITY_STANDARD; 1851 else 1852 nOrigMode = SFX_VISIBILITY_UNVISIBLE; 1853 1854 if ( nOrigMode != nUpdateMode) 1855 nUpdateMode = nOrigMode; 1856 } 1857 1858 sal_Bool SfxWorkWindow::IsVisible_Impl() 1859 { 1860 return nOrigMode != SFX_VISIBILITY_UNVISIBLE; 1861 } 1862 1863 //------------------------------------------------------------------------ 1864 void SfxWorkWindow::HidePopups_Impl(sal_Bool bHide, sal_Bool bParent, sal_uInt16 nId ) 1865 { 1866 for ( sal_uInt16 n = 0; n < pChildWins->Count(); ++n ) 1867 { 1868 SfxChildWindow *pCW = (*pChildWins)[n]->pWin; 1869 if (pCW && pCW->GetAlignment() == SFX_ALIGN_NOALIGNMENT && pCW->GetType() != nId) 1870 { 1871 Window *pWin = pCW->GetWindow(); 1872 SfxChild_Impl *pChild = FindChild_Impl(*pWin); 1873 if (bHide) 1874 { 1875 pChild->nVisible &= ~CHILD_ACTIVE; 1876 pCW->Hide(); 1877 } 1878 else 1879 { 1880 pChild->nVisible |= CHILD_ACTIVE; 1881 if ( CHILD_VISIBLE == (pChild->nVisible & CHILD_VISIBLE) ) 1882 pCW->Show( SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); 1883 } 1884 } 1885 } 1886 1887 if ( bParent && pParent ) 1888 pParent->HidePopups_Impl( bHide, bParent, nId ); 1889 } 1890 1891 //------------------------------------------------------------------------ 1892 1893 void SfxWorkWindow::ConfigChild_Impl(SfxChildIdentifier eChild, 1894 SfxDockingConfig eConfig, sal_uInt16 nId) 1895 { 1896 SfxDockingWindow* pDockWin=0; 1897 sal_uInt16 nPos = USHRT_MAX; 1898 Window *pWin=0; 1899 SfxChildWin_Impl *pCW = 0; 1900 1901 if ( eChild == SFX_CHILDWIN_OBJECTBAR ) 1902 { 1903 return; 1904 } 1905 else 1906 { 1907 // configure direct childwindow 1908 for (sal_uInt16 n=0; n<pChildWins->Count(); n++) 1909 { 1910 pCW = (*pChildWins)[n]; 1911 SfxChildWindow *pChild = pCW->pWin; 1912 if ( pChild ) 1913 { 1914 if ( pChild->GetType() == nId ) 1915 { 1916 if ( pChild->GetWindow()->GetType() == RSC_DOCKINGWINDOW ) 1917 // it's a DockingWindow 1918 pDockWin = (SfxDockingWindow*) pChild->GetWindow(); 1919 else 1920 // FloatingWindow or ModelessDialog 1921 pWin = pChild->GetWindow(); 1922 break; 1923 } 1924 } 1925 } 1926 1927 if ( pDockWin ) 1928 { 1929 if ( eChild == SFX_CHILDWIN_DOCKINGWINDOW || pDockWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT ) 1930 { 1931 if ( eChild == SFX_CHILDWIN_SPLITWINDOW && eConfig == SFX_TOGGLEFLOATMODE) 1932 { 1933 // DockingWindow was dragged out of a SplitWindow 1934 pCW->pCli = RegisterChild_Impl(*pDockWin, pDockWin->GetAlignment(), pCW->pWin->CanGetFocus()); 1935 pCW->pCli->nVisible = CHILD_VISIBLE; 1936 } 1937 1938 pWin = pDockWin; 1939 } 1940 else 1941 { 1942 SfxSplitWindow *pSplitWin = GetSplitWindow_Impl(pDockWin->GetAlignment()); 1943 1944 // configure DockingWindow inside a SplitWindow 1945 if ( eConfig == SFX_TOGGLEFLOATMODE) 1946 { 1947 // DockingWindow was dragged into a SplitWindow 1948 pCW->pCli = 0; 1949 ReleaseChild_Impl(*pDockWin); 1950 } 1951 1952 pWin = pSplitWin->GetSplitWindow(); 1953 if ( pSplitWin->GetWindowCount() == 1 ) 1954 ((SplitWindow*)pWin)->Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); 1955 } 1956 } 1957 1958 DBG_ASSERT( pCW, "Unknown window!" ); 1959 if ( !pCW && pParent ) 1960 { 1961 pParent->ConfigChild_Impl( eChild, eConfig, nId ); 1962 return; 1963 } 1964 } 1965 1966 if ( !bSorted ) 1967 // windows may have been registered and released without an update until now 1968 Sort_Impl(); 1969 1970 SfxChild_Impl *pChild = 0; 1971 sal_uInt16 n; 1972 for ( n=0; n<aSortedList.Count(); ++n ) 1973 { 1974 pChild = (*pChilds)[aSortedList[n]]; 1975 if ( pChild ) 1976 if ( pChild->pWin == pWin ) 1977 break; 1978 } 1979 1980 if ( n < aSortedList.Count() ) 1981 // sometimes called while toggeling float mode 1982 nPos = aSortedList[n]; 1983 1984 switch ( eConfig ) 1985 { 1986 case SFX_SETDOCKINGRECTS : 1987 { 1988 if ( nPos == USHRT_MAX ) 1989 return; 1990 1991 // SfxChild_Impl *pChild = (*pChilds)[nPos]; 1992 Rectangle aOuterRect( GetTopRect_Impl() ); 1993 aOuterRect.SetPos( pWorkWin->OutputToScreenPixel( aOuterRect.TopLeft() )); 1994 Rectangle aInnerRect( aOuterRect ); 1995 sal_Bool bTbx = (eChild == SFX_CHILDWIN_OBJECTBAR); 1996 1997 // Das gerade betroffene Fenster wird bei der Berechnung des 1998 // inneren Rechtecks mit eingeschlossen! 1999 for ( sal_uInt16 m=0; m<aSortedList.Count(); ++m ) 2000 { 2001 sal_uInt16 i=aSortedList[m]; 2002 SfxChild_Impl* pCli = (*pChilds)[i]; 2003 2004 if ( pCli && pCli->nVisible == CHILD_VISIBLE && pCli->pWin ) 2005 { 2006 switch ( pCli->eAlign ) 2007 { 2008 case SFX_ALIGN_TOP: 2009 // Objekt-Toolboxen kommen immer zuletzt 2010 //if ( bTbx || i <= nPos) 2011 aInnerRect.Top() += pCli->aSize.Height(); 2012 break; 2013 2014 case SFX_ALIGN_TOOLBOXTOP: 2015 // Toolbox geht nur vor, wenn nicht h"ohere Position 2016 if ( bTbx && i <= nPos) 2017 aInnerRect.Top() += pCli->aSize.Height(); 2018 break; 2019 2020 case SFX_ALIGN_HIGHESTTOP: 2021 // Geht immer vor 2022 aInnerRect.Top() += pCli->aSize.Height(); 2023 break; 2024 2025 case SFX_ALIGN_LOWESTTOP: 2026 // Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist 2027 if ( i == nPos ) 2028 aInnerRect.Top() += pCli->aSize.Height(); 2029 break; 2030 2031 case SFX_ALIGN_BOTTOM: 2032 // Objekt-Toolboxen kommen immer zuletzt 2033 //if ( bTbx || i <= nPos) 2034 aInnerRect.Bottom() -= pCli->aSize.Height(); 2035 break; 2036 2037 case SFX_ALIGN_TOOLBOXBOTTOM: 2038 // Toolbox geht nur vor, wenn nicht h"ohere Position 2039 if ( bTbx && i <= nPos) 2040 aInnerRect.Bottom() -= pCli->aSize.Height(); 2041 break; 2042 2043 case SFX_ALIGN_LOWESTBOTTOM: 2044 // Geht immer vor 2045 aInnerRect.Bottom() -= pCli->aSize.Height(); 2046 break; 2047 2048 case SFX_ALIGN_HIGHESTBOTTOM: 2049 // Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist 2050 if ( i == nPos ) 2051 aInnerRect.Bottom() -= pCli->aSize.Height(); 2052 break; 2053 2054 case SFX_ALIGN_LEFT: 2055 // Toolboxen kommen immer zuletzt 2056 //if (bTbx || i <= nPos) 2057 aInnerRect.Left() += pCli->aSize.Width(); 2058 break; 2059 2060 case SFX_ALIGN_TOOLBOXLEFT: 2061 // Toolboxen kommen immer zuletzt 2062 if (bTbx && i <= nPos) 2063 aInnerRect.Left() += pCli->aSize.Width(); 2064 break; 2065 2066 case SFX_ALIGN_FIRSTLEFT: 2067 // Geht immer vor 2068 aInnerRect.Left() += pCli->aSize.Width(); 2069 break; 2070 2071 case SFX_ALIGN_LASTLEFT: 2072 // Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist 2073 if (i == nPos) 2074 aInnerRect.Left() += pCli->aSize.Width(); 2075 2076 case SFX_ALIGN_RIGHT: 2077 // Toolboxen kommen immer zuletzt 2078 //if (bTbx || i <= nPos) 2079 aInnerRect.Right() -= pCli->aSize.Width(); 2080 break; 2081 2082 case SFX_ALIGN_TOOLBOXRIGHT: 2083 // Toolboxen kommen immer zuletzt 2084 if (bTbx && i <= nPos) 2085 aInnerRect.Right() -= pCli->aSize.Width(); 2086 break; 2087 2088 case SFX_ALIGN_FIRSTRIGHT: 2089 // Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist 2090 if (i == nPos) 2091 aInnerRect.Right() -= pCli->aSize.Width(); 2092 break; 2093 2094 case SFX_ALIGN_LASTRIGHT: 2095 // Geht immer vor 2096 aInnerRect.Right() -= pCli->aSize.Width(); 2097 break; 2098 2099 default: 2100 break; 2101 } 2102 } 2103 } 2104 2105 pDockWin->SetDockingRects(aOuterRect, aInnerRect); 2106 break; 2107 } 2108 2109 case SFX_MOVEDOCKINGWINDOW : 2110 case SFX_ALIGNDOCKINGWINDOW : 2111 case SFX_TOGGLEFLOATMODE: 2112 { 2113 if ( nPos == USHRT_MAX && !pCW ) 2114 return; 2115 2116 SfxChildAlignment eAlign = SFX_ALIGN_NOALIGNMENT; 2117 SfxChild_Impl *pCli = ( nPos != USHRT_MAX ) ? (*pChilds)[nPos] : 0; 2118 if ( pCli && pDockWin ) 2119 { 2120 eAlign = pDockWin->GetAlignment(); 2121 if ( eChild == SFX_CHILDWIN_DOCKINGWINDOW || eAlign == SFX_ALIGN_NOALIGNMENT) 2122 { 2123 // configuration inside the SplitWindow, no change for the SplitWindows' configuration 2124 pCli->bResize = sal_True; 2125 pCli->aSize = pDockWin->GetSizePixel(); 2126 } 2127 } 2128 2129 if ( pCli ) 2130 { 2131 if( pCli->eAlign != eAlign ) 2132 { 2133 bSorted = sal_False; 2134 pCli->eAlign = eAlign; 2135 } 2136 2137 ArrangeChilds_Impl(); 2138 ShowChilds_Impl(); 2139 } 2140 2141 if ( pCW && pCW->pWin ) 2142 { 2143 // store changed configuration 2144 sal_uInt16 nFlags = pCW->aInfo.nFlags; 2145 pCW->aInfo = pCW->pWin->GetInfo(); 2146 pCW->aInfo.nFlags |= nFlags; 2147 if ( eConfig != SFX_MOVEDOCKINGWINDOW ) 2148 SaveStatus_Impl( pCW->pWin, pCW->aInfo); 2149 } 2150 2151 break; 2152 } 2153 } 2154 } 2155 2156 2157 //-------------------------------------------------------------------- 2158 2159 void SfxWorkWindow::SetChildWindowVisible_Impl( sal_uInt32 lId, sal_Bool bEnabled, sal_uInt16 nMode ) 2160 { 2161 sal_uInt16 nInter = (sal_uInt16) ( lId >> 16 ); 2162 sal_uInt16 nId = (sal_uInt16) ( lId & 0xFFFF ); 2163 2164 SfxChildWin_Impl *pCW=NULL; 2165 SfxWorkWindow *pWork = pParent; 2166 2167 // Den obersten parent nehmen; ChildWindows werden immer am WorkWindow 2168 // der Task bzw. des Frames oder am AppWorkWindow angemeldet 2169 while ( pWork && pWork->pParent ) 2170 pWork = pWork->pParent; 2171 2172 if ( pWork ) 2173 { 2174 // Dem Parent schon bekannt ? 2175 sal_uInt16 nCount = pWork->pChildWins->Count(); 2176 for (sal_uInt16 n=0; n<nCount; n++) 2177 if ((*pWork->pChildWins)[n]->nSaveId == nId) 2178 { 2179 pCW = (*pWork->pChildWins)[n]; 2180 break; 2181 } 2182 } 2183 2184 if ( !pCW ) 2185 { 2186 // Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen 2187 sal_uInt16 nCount = pChildWins->Count(); 2188 for (sal_uInt16 n=0; n<nCount; n++) 2189 if ((*pChildWins)[n]->nSaveId == nId) 2190 { 2191 pCW = (*pChildWins)[n]; 2192 break; 2193 } 2194 } 2195 2196 if ( !pCW ) 2197 { 2198 // Ist neu, also initialisieren; je nach Flag beim Parent oder bei 2199 // mir eintragen 2200 pCW = new SfxChildWin_Impl( lId ); 2201 pCW->nId = nId; 2202 InitializeChild_Impl( pCW ); 2203 if ( pWork && !( pCW->aInfo.nFlags & SFX_CHILDWIN_TASK ) ) 2204 pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW ); 2205 else 2206 pChildWins->Insert( pChildWins->Count(), pCW ); 2207 } 2208 2209 pCW->nId = nId; 2210 if ( nInter ) 2211 pCW->nInterfaceId = nInter; 2212 pCW->nVisibility = nMode; 2213 pCW->bEnable = bEnabled; 2214 #if 0 2215 if ( pCW->pWin ) 2216 pCW->pWin->GetWindow()->EnableInput( bEnabled && 2217 ( pWorkWin->IsInputEnabled() /* || pCW->pWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT */ ) ); 2218 #endif 2219 pCW->nVisibility = nMode; 2220 } 2221 2222 //-------------------------------------------------------------------- 2223 // Der An/Aus-Status eines ChildWindows wird umgeschaltet. 2224 2225 void SfxWorkWindow::ToggleChildWindow_Impl(sal_uInt16 nId, sal_Bool bSetFocus) 2226 { 2227 sal_uInt16 nCount = pChildWins->Count(); 2228 sal_uInt16 n; 2229 for (n=0; n<nCount; n++) 2230 if ((*pChildWins)[n]->nId == nId) 2231 break; 2232 2233 if ( n<nCount ) 2234 { 2235 // Das Fenster ist schon bekannt 2236 SfxChildWin_Impl *pCW = (*pChildWins)[n]; 2237 SfxChildWindow *pChild = pCW->pWin; 2238 2239 bool bCreationAllowed( true ); 2240 if ( !bInternalDockingAllowed ) 2241 { 2242 // Special case for all non-floatable child windows. We have 2243 // to prevent the creation here! 2244 bCreationAllowed = !( pCW->aInfo.nFlags & SFX_CHILDWIN_FORCEDOCK ); 2245 } 2246 2247 if ( bCreationAllowed ) 2248 { 2249 if ( pCW->bCreate ) 2250 { 2251 if ( pChild ) 2252 { 2253 if ( pChild->QueryClose() ) 2254 { 2255 pCW->bCreate = sal_False; 2256 if ( pChild->IsHideAtToggle() ) 2257 { 2258 ShowChildWindow_Impl( nId, sal_False, bSetFocus ); 2259 } 2260 else 2261 { 2262 // Fenster soll ausgeschaltet werdem 2263 pChild->SetVisible_Impl( sal_False ); 2264 RemoveChildWin_Impl( pCW ); 2265 } 2266 } 2267 } 2268 else 2269 { 2270 // no actual Window exists, yet => just remember the "switched off" state 2271 pCW->bCreate = sal_False; 2272 } 2273 } 2274 else 2275 { 2276 pCW->bCreate = AllowChildWindowCreation_Impl( *pCW ); 2277 if ( pCW->bCreate ) 2278 { 2279 if ( pChild ) 2280 { 2281 ShowChildWindow_Impl( nId, sal_True, bSetFocus ); 2282 } 2283 else 2284 { 2285 // create actual Window 2286 CreateChildWin_Impl( pCW, bSetFocus ); 2287 if ( !pCW->pWin ) 2288 // no success 2289 pCW->bCreate = sal_False; 2290 } 2291 } 2292 } 2293 } 2294 2295 ArrangeChilds_Impl(); 2296 ShowChilds_Impl(); 2297 2298 if ( pCW->bCreate && bCreationAllowed ) 2299 { 2300 if ( !pCW->pCli ) 2301 { 2302 SfxDockingWindow *pDock = 2303 (SfxDockingWindow*) pCW->pWin->GetWindow(); 2304 if ( pDock->IsAutoHide_Impl() ) 2305 pDock->AutoShow_Impl(); 2306 } 2307 } 2308 2309 return; 2310 } 2311 else if ( pParent ) 2312 { 2313 pParent->ToggleChildWindow_Impl( nId, bSetFocus ); 2314 return; 2315 } 2316 2317 #ifdef DBG_UTIL 2318 nCount = pChildWins->Count(); 2319 for (n=0; n<nCount; n++) 2320 if ((*pChildWins)[n]->nSaveId == nId) 2321 break; 2322 2323 if ( n < nCount ) 2324 { 2325 DBG_ERROR("ChildWindow ist nicht im Kontext!"); 2326 } 2327 else 2328 { 2329 DBG_ERROR("ChildWindow ist nicht registriert!"); 2330 } 2331 #endif 2332 } 2333 2334 //-------------------------------------------------------------------- 2335 2336 sal_Bool SfxWorkWindow::HasChildWindow_Impl(sal_uInt16 nId) 2337 { 2338 sal_uInt16 nCount = pChildWins->Count(); 2339 sal_uInt16 n; 2340 for (n=0; n<nCount; n++) 2341 if ((*pChildWins)[n]->nSaveId == nId) 2342 break; 2343 2344 if (n<nCount) 2345 { 2346 SfxChildWin_Impl *pCW = (*pChildWins)[n]; 2347 SfxChildWindow *pChild = pCW->pWin; 2348 return ( pChild && pCW->bCreate ); 2349 } 2350 2351 if ( pParent ) 2352 return pParent->HasChildWindow_Impl( nId ); 2353 2354 return sal_False; 2355 } 2356 2357 sal_Bool SfxWorkWindow::IsFloating( sal_uInt16 nId ) 2358 { 2359 SfxChildWin_Impl *pCW=NULL; 2360 SfxWorkWindow *pWork = pParent; 2361 2362 // Den obersten parent nehmen; ChildWindows werden immer am WorkWindow 2363 // der Task bzw. des Frames oder am AppWorkWindow angemeldet 2364 while ( pWork && pWork->pParent ) 2365 pWork = pWork->pParent; 2366 2367 if ( pWork ) 2368 { 2369 // Dem Parent schon bekannt ? 2370 sal_uInt16 nCount = pWork->pChildWins->Count(); 2371 for (sal_uInt16 n=0; n<nCount; n++) 2372 if ((*pWork->pChildWins)[n]->nSaveId == nId) 2373 { 2374 pCW = (*pWork->pChildWins)[n]; 2375 break; 2376 } 2377 } 2378 2379 if ( !pCW ) 2380 { 2381 // Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen 2382 sal_uInt16 nCount = pChildWins->Count(); 2383 for (sal_uInt16 n=0; n<nCount; n++) 2384 if ((*pChildWins)[n]->nSaveId == nId) 2385 { 2386 pCW = (*pChildWins)[n]; 2387 break; 2388 } 2389 } 2390 2391 if ( !pCW ) 2392 { 2393 // Ist neu, also initialisieren; je nach Flag beim Parent oder bei 2394 // mir eintragen 2395 pCW = new SfxChildWin_Impl( nId ); 2396 pCW->bEnable = sal_False; 2397 pCW->nId = 0; 2398 pCW->nVisibility = 0; 2399 InitializeChild_Impl( pCW ); 2400 if ( pWork && !( pCW->aInfo.nFlags & SFX_CHILDWIN_TASK ) ) 2401 pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW ); 2402 else 2403 pChildWins->Insert( pChildWins->Count(), pCW ); 2404 } 2405 2406 SfxChildAlignment eAlign; 2407 if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) ) 2408 return( eAlign == SFX_ALIGN_NOALIGNMENT ); 2409 else 2410 return sal_True; 2411 } 2412 2413 //-------------------------------------------------------------------- 2414 2415 sal_Bool SfxWorkWindow::KnowsChildWindow_Impl(sal_uInt16 nId) 2416 { 2417 SfxChildWin_Impl *pCW=0; 2418 sal_uInt16 nCount = pChildWins->Count(); 2419 sal_uInt16 n; 2420 for (n=0; n<nCount; n++) 2421 { 2422 pCW = (*pChildWins)[n]; 2423 if ( pCW->nSaveId == nId) 2424 break; 2425 } 2426 2427 if (n<nCount) 2428 { 2429 if ( !(pCW->aInfo.nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE) && !IsVisible_Impl( pCW->nVisibility ) ) 2430 return sal_False; 2431 return pCW->bEnable; 2432 } 2433 else if ( pParent ) 2434 return pParent->KnowsChildWindow_Impl( nId ); 2435 else 2436 return sal_False; 2437 } 2438 2439 //-------------------------------------------------------------------- 2440 2441 void SfxWorkWindow::SetChildWindow_Impl(sal_uInt16 nId, sal_Bool bOn, sal_Bool bSetFocus) 2442 { 2443 SfxChildWin_Impl *pCW=NULL; 2444 SfxWorkWindow *pWork = pParent; 2445 2446 // Den obersten parent nehmen; ChildWindows werden immer am WorkWindow 2447 // der Task bzw. des Frames oder am AppWorkWindow angemeldet 2448 while ( pWork && pWork->pParent ) 2449 pWork = pWork->pParent; 2450 2451 if ( pWork ) 2452 { 2453 // Dem Parent schon bekannt ? 2454 sal_uInt16 nCount = pWork->pChildWins->Count(); 2455 for (sal_uInt16 n=0; n<nCount; n++) 2456 if ((*pWork->pChildWins)[n]->nSaveId == nId) 2457 { 2458 pCW = (*pWork->pChildWins)[n]; 2459 break; 2460 } 2461 } 2462 2463 if ( !pCW ) 2464 { 2465 // Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen 2466 sal_uInt16 nCount = pChildWins->Count(); 2467 for (sal_uInt16 n=0; n<nCount; n++) 2468 if ((*pChildWins)[n]->nSaveId == nId) 2469 { 2470 pCW = (*pChildWins)[n]; 2471 pWork = this; 2472 break; 2473 } 2474 } 2475 2476 if ( !pCW ) 2477 { 2478 // Ist neu, also initialisieren; je nach Flag beim Parent oder bei 2479 // mir eintragen 2480 pCW = new SfxChildWin_Impl( nId ); 2481 InitializeChild_Impl( pCW ); 2482 if ( !pWork || pCW->aInfo.nFlags & SFX_CHILDWIN_TASK ) 2483 pWork = this; 2484 pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW ); 2485 } 2486 2487 if ( pCW->bCreate != bOn ) 2488 pWork->ToggleChildWindow_Impl(nId,bSetFocus); 2489 } 2490 2491 //-------------------------------------------------------------------- 2492 2493 void SfxWorkWindow::ShowChildWindow_Impl(sal_uInt16 nId, sal_Bool bVisible, sal_Bool bSetFocus) 2494 { 2495 sal_uInt16 nCount = pChildWins->Count(); 2496 SfxChildWin_Impl* pCW=0; 2497 sal_uInt16 n; 2498 for (n=0; n<nCount; n++) 2499 { 2500 pCW = (*pChildWins)[n]; 2501 if (pCW->nId == nId) 2502 break; 2503 } 2504 2505 if ( n<nCount ) 2506 { 2507 SfxChildWindow *pChildWin = pCW->pWin; 2508 if ( pChildWin ) 2509 { 2510 if ( bVisible ) 2511 { 2512 if ( pCW->pCli ) 2513 { 2514 pCW->pCli->bSetFocus = bSetFocus; 2515 pCW->pCli->nVisible = CHILD_VISIBLE; 2516 pChildWin->Show( bSetFocus && pChildWin->WantsFocus() ? 0 : SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); 2517 } 2518 else 2519 ((SfxDockingWindow*)pChildWin->GetWindow())->Reappear_Impl(); 2520 2521 } 2522 else 2523 { 2524 if ( pCW->pCli ) 2525 { 2526 pCW->pCli->nVisible = CHILD_VISIBLE ^ CHILD_NOT_HIDDEN; 2527 pCW->pWin->Hide(); 2528 } 2529 else 2530 ((SfxDockingWindow*)pChildWin->GetWindow())->Disappear_Impl(); 2531 2532 } 2533 2534 ArrangeChilds_Impl(); 2535 ShowChilds_Impl(); 2536 } 2537 else if ( bVisible ) 2538 { 2539 SetChildWindow_Impl( nId, sal_True, bSetFocus ); 2540 pChildWin = pCW->pWin; 2541 } 2542 2543 if ( pChildWin ) 2544 { 2545 pChildWin->SetVisible_Impl( bVisible ); 2546 sal_uInt16 nFlags = pCW->aInfo.nFlags; 2547 pCW->aInfo = pChildWin->GetInfo(); 2548 pCW->aInfo.nFlags |= nFlags; 2549 if ( !pCW->bCreate ) 2550 SaveStatus_Impl( pChildWin, pCW->aInfo ); 2551 } 2552 2553 return; 2554 } 2555 2556 if ( pParent ) 2557 { 2558 pParent->ShowChildWindow_Impl( nId, bVisible, bSetFocus ); 2559 return; 2560 } 2561 2562 #ifdef DBG_UTIL 2563 nCount = pChildWins->Count(); 2564 for (n=0; n<nCount; n++) 2565 if ((*pChildWins)[n]->nSaveId == nId) 2566 break; 2567 2568 if ( n<nCount ) 2569 { 2570 DBG_ERROR("ChildWindow ist nicht im Kontext!"); 2571 } 2572 else 2573 { 2574 DBG_ERROR("ChildWindow ist nicht registriert!"); 2575 } 2576 #endif 2577 } 2578 2579 //-------------------------------------------------------------------- 2580 2581 SfxChildWindow* SfxWorkWindow::GetChildWindow_Impl(sal_uInt16 nId) 2582 { 2583 sal_uInt16 nCount = pChildWins->Count(); 2584 sal_uInt16 n; 2585 for (n=0; n<nCount; n++) 2586 if ((*pChildWins)[n]->nSaveId == nId) 2587 break; 2588 2589 if (n<nCount) 2590 return (*pChildWins)[n]->pWin; 2591 else if ( pParent ) 2592 return pParent->GetChildWindow_Impl( nId ); 2593 return 0; 2594 } 2595 2596 //------------------------------------------------------------------------ 2597 2598 void SfxWorkWindow::ResetChildWindows_Impl() 2599 { 2600 // if ( pParent ) 2601 // pParent->ResetChildWindows_Impl(); 2602 2603 for ( sal_uInt16 n = 0; n < pChildWins->Count(); ++n ) 2604 { 2605 (*pChildWins)[n]->nId = 0; 2606 (*pChildWins)[n]->bEnable = sal_False; 2607 } 2608 } 2609 2610 //------------------------------------------------------------------------ 2611 // Virtuelle Methode, die die Gr"o\se der Fl"ache (client area) des parent 2612 // windows liefert, in der Child-Fenster angeordnet werden k"onnen. 2613 // in der ClientArea des parent findet. 2614 2615 Rectangle SfxWorkWindow::GetTopRect_Impl() 2616 { 2617 return Rectangle (Point(), pWorkWin->GetOutputSizePixel() ); 2618 } 2619 2620 //------------------------------------------------------------------------ 2621 // Virtuelle Methode, die die Gr"o\se der Fl"ache (client area) des parent 2622 // windows liefert, in der Child-Fenster angeordnet werden k"onnen. 2623 // in der ClientArea des parent findet. 2624 2625 Rectangle SfxFrameWorkWin_Impl::GetTopRect_Impl() 2626 { 2627 return pMasterFrame->GetTopOuterRectPixel_Impl(); 2628 } 2629 2630 //------------------------------------------------------------------------ 2631 // Virtuelle Methode, um herauszufinden, ob ein Child-Fenster noch Platz 2632 // in der ClientArea des parent findet. 2633 2634 sal_Bool SfxWorkWindow::RequestTopToolSpacePixel_Impl( SvBorder aBorder ) 2635 { 2636 if ( !IsDockingAllowed() || 2637 aClientArea.GetWidth() < aBorder.Left() + aBorder.Right() || 2638 aClientArea.GetHeight() < aBorder.Top() + aBorder.Bottom() ) 2639 return sal_False; 2640 else 2641 return sal_True;; 2642 } 2643 2644 void SfxWorkWindow::SaveStatus_Impl(SfxChildWindow *pChild, const SfxChildWinInfo &rInfo) 2645 { 2646 // Den Status vom Presentation mode wollen wir nicht sichern 2647 if ( IsDockingAllowed() && bInternalDockingAllowed ) 2648 pChild->SaveStatus(rInfo); 2649 } 2650 2651 void SfxWorkWindow::InitializeChild_Impl(SfxChildWin_Impl *pCW) 2652 { 2653 SfxChildWinFactory* pFact=0; 2654 SfxApplication *pApp = SFX_APP(); 2655 { 2656 SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl(); 2657 for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) 2658 { 2659 pFact = rFactories[nFactory]; 2660 if ( pFact->nId == pCW->nSaveId ) 2661 { 2662 pCW->aInfo = pFact->aInfo; 2663 SfxChildWindow::InitializeChildWinFactory_Impl( 2664 pCW->nSaveId, pCW->aInfo); 2665 pCW->bCreate = pCW->aInfo.bVisible; 2666 sal_uInt16 nFlags = pFact->aInfo.nFlags; 2667 if ( nFlags & SFX_CHILDWIN_TASK ) 2668 pCW->aInfo.nFlags |= SFX_CHILDWIN_TASK; 2669 if ( nFlags & SFX_CHILDWIN_CANTGETFOCUS ) 2670 pCW->aInfo.nFlags |= SFX_CHILDWIN_CANTGETFOCUS; 2671 if ( nFlags & SFX_CHILDWIN_FORCEDOCK ) 2672 pCW->aInfo.nFlags |= SFX_CHILDWIN_FORCEDOCK; 2673 pFact->aInfo = pCW->aInfo; 2674 return; 2675 } 2676 } 2677 } 2678 2679 SfxDispatcher *pDisp = pBindings->GetDispatcher_Impl(); 2680 SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0; 2681 if ( pMod ) 2682 { 2683 SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl(); 2684 if ( pFactories ) 2685 { 2686 SfxChildWinFactArr_Impl &rFactories = *pFactories; 2687 for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory ) 2688 { 2689 pFact = rFactories[nFactory]; 2690 if ( pFact->nId == pCW->nSaveId ) 2691 { 2692 pCW->aInfo = pFact->aInfo; 2693 SfxChildWindow::InitializeChildWinFactory_Impl( 2694 pCW->nSaveId, pCW->aInfo); 2695 pCW->bCreate = pCW->aInfo.bVisible; 2696 sal_uInt16 nFlags = pFact->aInfo.nFlags; 2697 if ( nFlags & SFX_CHILDWIN_TASK ) 2698 pCW->aInfo.nFlags |= SFX_CHILDWIN_TASK; 2699 if ( nFlags & SFX_CHILDWIN_CANTGETFOCUS ) 2700 pCW->aInfo.nFlags |= SFX_CHILDWIN_CANTGETFOCUS; 2701 if ( nFlags & SFX_CHILDWIN_FORCEDOCK ) 2702 pCW->aInfo.nFlags |= SFX_CHILDWIN_FORCEDOCK; 2703 if ( nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE ) 2704 pCW->aInfo.nFlags |= SFX_CHILDWIN_ALWAYSAVAILABLE; 2705 pFact->aInfo = pCW->aInfo; 2706 return; 2707 } 2708 } 2709 } 2710 } 2711 } 2712 /* 2713 SfxStatBar_Impl* SfxWorkWindow::GetStatusBar_Impl() 2714 { 2715 return &aStatBar; 2716 } */ 2717 2718 SfxSplitWindow* SfxWorkWindow::GetSplitWindow_Impl( SfxChildAlignment eAlign ) 2719 { 2720 switch ( eAlign ) 2721 { 2722 case SFX_ALIGN_TOP: 2723 return pSplit[2]; 2724 2725 case SFX_ALIGN_BOTTOM: 2726 return pSplit[3]; 2727 2728 case SFX_ALIGN_LEFT: 2729 return pSplit[0]; 2730 2731 case SFX_ALIGN_RIGHT: 2732 return pSplit[1]; 2733 2734 default: 2735 return 0; 2736 } 2737 } 2738 2739 void SfxWorkWindow::MakeChildsVisible_Impl( sal_Bool bVis ) 2740 { 2741 if ( pParent ) 2742 pParent->MakeChildsVisible_Impl( bVis ); 2743 2744 bAllChildsVisible = bVis; 2745 if ( bVis ) 2746 { 2747 if ( !bSorted ) 2748 Sort_Impl(); 2749 for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n ) 2750 { 2751 SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]]; 2752 if ( (pCli->eAlign == SFX_ALIGN_NOALIGNMENT) || (IsDockingAllowed() && bInternalDockingAllowed) ) 2753 pCli->nVisible |= CHILD_ACTIVE; 2754 } 2755 } 2756 else 2757 { 2758 if ( !bSorted ) 2759 Sort_Impl(); 2760 for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n ) 2761 { 2762 SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]]; 2763 pCli->nVisible &= ~CHILD_ACTIVE; 2764 } 2765 } 2766 } 2767 2768 sal_Bool SfxWorkWindow::IsAutoHideMode( const SfxSplitWindow *pSplitWin ) 2769 { 2770 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 2771 { 2772 if ( pSplit[n] != pSplitWin && pSplit[n]->IsAutoHide( sal_True ) ) 2773 return sal_True; 2774 } 2775 return sal_False; 2776 } 2777 2778 2779 void SfxWorkWindow::EndAutoShow_Impl( Point aPos ) 2780 { 2781 if ( pParent ) 2782 pParent->EndAutoShow_Impl( aPos ); 2783 2784 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 2785 { 2786 SfxSplitWindow *p = pSplit[n]; 2787 if ( p && p->IsAutoHide() ) 2788 { 2789 Point aLocalPos = p->ScreenToOutputPixel( aPos ); 2790 Point aEmptyPoint = Point(); 2791 Rectangle aRect( aEmptyPoint, p->GetSizePixel() ); 2792 if ( !aRect.IsInside( aLocalPos ) ) 2793 p->FadeOut(); 2794 } 2795 } 2796 } 2797 2798 void SfxWorkWindow::ArrangeAutoHideWindows( SfxSplitWindow *pActSplitWin ) 2799 { 2800 if ( m_nLock ) 2801 return; 2802 2803 if ( pParent ) 2804 pParent->ArrangeAutoHideWindows( pActSplitWin ); 2805 2806 Rectangle aArea( aUpperClientArea ); 2807 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 2808 { 2809 // Es werden entweder Dummyfenster oder Fenster im AutoShow-Modus 2810 // ( nicht gepinned, FadeIn ) behandelt. 2811 // Nur das "ubergebene Fenster darf unsichtbar sein, denn vielleicht 2812 // soll daf"ur gerade die Gr"o\se berechnet werden, bevor es angezeigt 2813 // wird. 2814 SfxSplitWindow* pSplitWin = pSplit[n]; 2815 sal_Bool bDummyWindow = !pSplitWin->IsFadeIn(); 2816 Window *pDummy = pSplitWin->GetSplitWindow(); 2817 Window *pWin = bDummyWindow ? pDummy : pSplitWin; 2818 if ( (pSplitWin->IsPinned() && !bDummyWindow) || (!pWin->IsVisible() && pActSplitWin != pSplitWin) ) 2819 continue; 2820 2821 // Breite und Position des Dummy-Fensters als Ausgangspunkt 2822 Size aSize = pDummy->GetSizePixel(); 2823 Point aPos = pDummy->GetPosPixel(); 2824 2825 switch ( n ) 2826 { 2827 case ( 0 ) : 2828 { 2829 // Linkes SplitWindow 2830 // Breite vom Fenster selbst holen, wenn nicht das DummyWindow 2831 if ( !bDummyWindow ) 2832 aSize.Width() = pSplitWin->GetSizePixel().Width(); 2833 2834 // Wenn links ein Window sichtbar ist, beginnt der freie 2835 // Bereich rechts davon bzw. bei der Client area 2836 long nLeft = aPos.X() + aSize.Width(); 2837 if ( nLeft > aArea.Left() ) 2838 aArea.Left() = nLeft; 2839 break; 2840 } 2841 case ( 1 ) : 2842 { 2843 // Rechtes SplitWindow 2844 // Position um Differenz der Breiten korrigieren 2845 aPos.X() += aSize.Width(); 2846 2847 // Breite vom Fenster selbst holen, wenn nicht das DummyWindow 2848 if ( !bDummyWindow ) 2849 aSize.Width() = pSplitWin->GetSizePixel().Width(); 2850 2851 aPos.X() -= aSize.Width(); 2852 2853 // Wenn links schon ein Fenster aufgeklappt ist, darf 2854 // das rechte nicht dar"uber gehen 2855 if ( aPos.X() < aArea.Left() ) 2856 { 2857 aPos.X() = aArea.Left(); 2858 aSize.Width() = aArea.GetWidth(); 2859 } 2860 2861 // Wenn rechts ein Window sichtbar ist, endet der freie 2862 // Bereich links davon bzw. bei der Client area 2863 long nRight = aPos.X(); 2864 if ( nRight < aArea.Right() ) 2865 aArea.Right() = nRight; 2866 break; 2867 } 2868 case ( 2 ) : 2869 { 2870 // Oberes SplitWindow 2871 // H"ohe vom Fenster selbst holen, wenn nicht das DummyWindow 2872 if ( !bDummyWindow ) 2873 aSize.Height() = pSplitWin->GetSizePixel().Height(); 2874 2875 // Breite anpassen, je nachdem ob links oder rechts 2876 // schon ein Fenster aufgeklappt ist 2877 aPos.X() = aArea.Left(); 2878 aSize.Width() = aArea.GetWidth(); 2879 2880 // Wenn oben ein Window sichtbar ist, beginnt der freie 2881 // Bereich darunter bzw. bei der Client Area 2882 long nTop = aPos.Y() + aSize.Height(); 2883 if ( nTop > aArea.Top() ) 2884 aArea.Top() = nTop; 2885 break; 2886 } 2887 case ( 3 ) : 2888 { 2889 // Das untere SplitWindow 2890 // Position um Differenz der H"ohen korrigieren 2891 aPos.Y() += aSize.Height(); 2892 2893 // H"ohe vom Fenster selbst holen, wenn nicht das DummmyWindow 2894 if ( !bDummyWindow ) 2895 aSize.Height() = pSplitWin->GetSizePixel().Height(); 2896 2897 aPos.Y() -= aSize.Height(); 2898 2899 // Breite anpassen, je nachdem ob links oder rechts 2900 // schon ein Fenster aufgeklappt ist 2901 aPos.X() = aArea.Left(); 2902 aSize.Width() = aArea.GetWidth(); 2903 2904 // Wenn oben schon ein Fenster aufgeklappt ist, darf 2905 // das untere nicht dar"uber gehen 2906 if ( aPos.Y() < aArea.Top() ) 2907 { 2908 aPos.Y() = aArea.Top(); 2909 aSize.Height() = aArea.GetHeight(); 2910 } 2911 2912 break; 2913 } 2914 } 2915 2916 if ( !bDummyWindow ) 2917 // Das FadeIn-Window ist ein Float, dessen Koordinaten in 2918 // Screenkoordinaten gesetzt werden 2919 pSplitWin->SetPosSizePixel( pWorkWin->OutputToScreenPixel(aPos), aSize ); 2920 else 2921 // Das angedockte DummyWindow 2922 pDummy->SetPosSizePixel( aPos, aSize ); 2923 } 2924 } 2925 2926 Rectangle SfxWorkWindow::GetFreeArea( sal_Bool bAutoHide ) const 2927 { 2928 if ( bAutoHide ) 2929 { 2930 Rectangle aArea( aClientArea ); 2931 for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 2932 { 2933 if ( pSplit[n]->IsPinned() || !pSplit[n]->IsVisible() ) 2934 continue; 2935 2936 Size aSize = pSplit[n]->GetSizePixel(); 2937 switch ( n ) 2938 { 2939 case ( 0 ) : 2940 aArea.Left() += aSize.Width(); 2941 break; 2942 case ( 1 ) : 2943 aArea.Right() -= aSize.Width(); 2944 break; 2945 case ( 2 ) : 2946 aArea.Top() += aSize.Height(); 2947 break; 2948 case ( 3 ) : 2949 aArea.Bottom() -= aSize.Height(); 2950 break; 2951 } 2952 } 2953 2954 return aArea; 2955 } 2956 else 2957 return aClientArea; 2958 } 2959 2960 SfxChildWinController_Impl::SfxChildWinController_Impl( sal_uInt16 nID, SfxWorkWindow *pWork ) 2961 : SfxControllerItem( nID, pWork->GetBindings() ) 2962 , pWorkwin( pWork ) 2963 {} 2964 2965 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > SfxWorkWindow::CreateDispatch( const String& ) 2966 { 2967 return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch >(); 2968 } 2969 2970 void SfxChildWinController_Impl::StateChanged( 2971 sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* ) 2972 { 2973 pWorkwin->DisableChildWindow_Impl( nSID, eState == SFX_ITEM_DISABLED ); 2974 } 2975 2976 void SfxWorkWindow::DisableChildWindow_Impl( sal_uInt16 nId, sal_Bool bDisable ) 2977 { 2978 sal_uInt16 nCount = pChildWins->Count(); 2979 sal_uInt16 n; 2980 for (n=0; n<nCount; n++) 2981 if ((*pChildWins)[n]->nSaveId == nId) 2982 break; 2983 if ( n<nCount && (*pChildWins)[n]->bDisabled != bDisable ) 2984 { 2985 (*pChildWins)[n]->bDisabled = bDisable; 2986 UpdateChildWindows_Impl(); 2987 ArrangeChilds_Impl(); 2988 ShowChilds_Impl(); 2989 } 2990 } 2991 2992 void SfxWorkWindow::SetActiveChild_Impl( Window *pChild ) 2993 { 2994 pActiveChild = pChild; 2995 } 2996 2997 Window* SfxWorkWindow::GetActiveChild_Impl() 2998 { 2999 return pActiveChild; 3000 } 3001 3002 sal_Bool SfxWorkWindow::ActivateNextChild_Impl( sal_Bool bForward ) 3003 { 3004 // Alle Kinder gem"a\s Liste sortieren 3005 SvUShorts aList; 3006 for ( sal_uInt16 i=SFX_OBJECTBAR_MAX; i<pChilds->Count(); i++) 3007 { 3008 SfxChild_Impl *pCli = (*pChilds)[i]; 3009 if ( pCli && pCli->bCanGetFocus && pCli->pWin ) 3010 { 3011 sal_uInt16 k; 3012 for (k=0; k<aList.Count(); k++) 3013 if ( ChildTravelValue((*pChilds)[aList[k]]->eAlign) > ChildTravelValue(pCli->eAlign) ) 3014 break; 3015 aList.Insert(i,k); 3016 } 3017 } 3018 3019 if ( aList.Count() == 0 ) 3020 return sal_False; 3021 3022 sal_uInt16 nTopValue = ChildTravelValue( SFX_ALIGN_LOWESTTOP ); 3023 for ( sal_uInt16 i=0; i<aList.Count(); i++ ) 3024 { 3025 SfxChild_Impl* pCli = (*pChilds)[aList[i]]; 3026 if ( pCli->pWin && ChildTravelValue( pCli->eAlign ) > nTopValue ) 3027 break; 3028 } 3029 3030 sal_uInt16 n = bForward ? 0 : aList.Count()-1; 3031 SfxChild_Impl *pAct=NULL; 3032 if ( pActiveChild ) 3033 { 3034 // Das aktive Fenster suchen 3035 for ( n=0; n<aList.Count(); n++ ) 3036 { 3037 SfxChild_Impl* pCli = (*pChilds)[aList[n]]; 3038 if ( pCli && pCli->pWin && ( pCli->pWin == pActiveChild || !pActiveChild ) ) 3039 { 3040 pAct = pCli; 3041 break; 3042 } 3043 } 3044 } 3045 3046 // dummy entries for the container window 3047 aList.Insert( 0xFFFF, 0 ); 3048 aList.Insert( 0xFFFF, aList.Count() ); 3049 n = n + 1; 3050 if ( pAct ) 3051 { 3052 for ( sal_uInt16 i=0; i<SFX_SPLITWINDOWS_MAX; i++ ) 3053 { 3054 // Eventuell ist pAct ein Splitwindow 3055 SfxSplitWindow *p = pSplit[i]; 3056 if ( pAct->pWin == p ) 3057 { 3058 if( p->ActivateNextChild_Impl( bForward ) ) 3059 return sal_True; 3060 break; 3061 } 3062 } 3063 3064 // pAct ist ein direktes ChildWindow 3065 // mit dem Nachfolger bzw. Vorg"anger des aktiven Fensters weitermachen 3066 if ( bForward ) 3067 n = n+1; 3068 else 3069 n = n-1; 3070 3071 if ( n == 0 || n == aList.Count()-1 ) 3072 return sal_False; 3073 } 3074 3075 for( ;; ) 3076 { 3077 SfxChild_Impl* pCli = (*pChilds)[aList[n]]; 3078 if ( pCli->pWin ) 3079 { 3080 SfxChild_Impl* pNext = pCli; 3081 for ( sal_uInt16 i=0; n<SFX_SPLITWINDOWS_MAX; n++ ) 3082 { 3083 // Eventuell ist pNext ein Splitwindow 3084 SfxSplitWindow *p = pSplit[i]; 3085 if ( pNext->pWin == p ) 3086 { 3087 // Das erste/letzte Fenster dort aktivieren 3088 p->SetActiveWindow_Impl( NULL ); 3089 pNext = NULL; 3090 if( p->ActivateNextChild_Impl( bForward ) ) 3091 return sal_True; 3092 break; 3093 } 3094 } 3095 3096 if ( pNext ) 3097 { 3098 pNext->pWin->GrabFocus(); 3099 pActiveChild = pNext->pWin; 3100 return sal_True; 3101 } 3102 } 3103 3104 if ( bForward ) 3105 n = n+1; 3106 else 3107 n = n-1; 3108 3109 if ( n == 0 || n == aList.Count()-1 ) 3110 break; 3111 } 3112 3113 return sal_False; 3114 } 3115 3116 void SfxWorkWindow::SetObjectBarCustomizeMode_Impl( sal_Bool ) 3117 { 3118 } 3119 3120 void SfxWorkWindow::DataChanged_Impl( const DataChangedEvent& ) 3121 { 3122 sal_uInt16 n; 3123 sal_uInt16 nCount = pChildWins->Count(); 3124 for (n=0; n<nCount; n++) 3125 { 3126 SfxChildWin_Impl*pCW = (*pChildWins)[n]; 3127 if ( pCW && pCW->pWin ) 3128 pCW->pWin->GetWindow()->UpdateSettings( Application::GetSettings() ); 3129 } 3130 3131 ArrangeChilds_Impl(); 3132 } 3133