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