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 #include <hash_map> 28 #include <svl/itempool.hxx> 29 #include <svl/itemiter.hxx> 30 #include <svl/eitem.hxx> 31 #include <svl/aeitem.hxx> 32 #include <svl/intitem.hxx> 33 #include <svl/stritem.hxx> 34 #include <svl/visitem.hxx> 35 #include <com/sun/star/util/XURLTransformer.hpp> 36 #include <com/sun/star/frame/XDispatchProviderInterceptor.hpp> 37 #include <com/sun/star/frame/XDispatch.hpp> 38 #include <com/sun/star/frame/XDispatchProvider.hpp> 39 #include <com/sun/star/frame/XStatusListener.hpp> 40 #include <com/sun/star/frame/FrameSearchFlag.hpp> 41 #include <com/sun/star/frame/XDispatchProviderInterception.hpp> 42 #include <com/sun/star/frame/FeatureStateEvent.hpp> 43 #include <com/sun/star/frame/DispatchDescriptor.hpp> 44 #include <com/sun/star/frame/XController.hpp> 45 #include <comphelper/processfactory.hxx> 46 #include <svtools/itemdel.hxx> 47 48 #ifndef GCC 49 #endif 50 51 // wg. nInReschedule 52 #include "appdata.hxx" 53 #include <sfx2/bindings.hxx> 54 #include <sfx2/msg.hxx> 55 #include "statcach.hxx" 56 #include <sfx2/ctrlitem.hxx> 57 #include <sfx2/app.hxx> 58 #include <sfx2/dispatch.hxx> 59 #include <sfx2/request.hxx> 60 #include <sfx2/objface.hxx> 61 #include "sfxtypes.hxx" 62 #include "workwin.hxx" 63 #include <sfx2/unoctitm.hxx> 64 #include <sfx2/sfx.hrc> 65 #include <sfx2/sfxuno.hxx> 66 #include <sfx2/viewfrm.hxx> 67 #include <sfx2/objsh.hxx> 68 #include <sfx2/msgpool.hxx> 69 70 #include <comphelper/uieventslogger.hxx> 71 #include <com/sun/star/frame/XModuleManager.hpp> 72 73 74 using namespace ::com::sun::star; 75 using namespace ::com::sun::star::uno; 76 using namespace ::com::sun::star::util; 77 78 DBG_NAME(SfxBindingsMsgPos) 79 DBG_NAME(SfxBindingsUpdateServers) 80 DBG_NAME(SfxBindingsCreateSet) 81 DBG_NAME(SfxBindingsUpdateCtrl1) 82 DBG_NAME(SfxBindingsUpdateCtrl2) 83 DBG_NAME(SfxBindingsNextJob_Impl0) 84 DBG_NAME(SfxBindingsNextJob_Impl) 85 DBG_NAME(SfxBindingsUpdate_Impl) 86 DBG_NAME(SfxBindingsInvalidateAll) 87 88 //==================================================================== 89 90 static sal_uInt16 nTimeOut = 300; 91 92 #define TIMEOUT_FIRST nTimeOut 93 #define TIMEOUT_UPDATING 20 94 #define TIMEOUT_IDLE 2500 95 96 static sal_uInt32 nCache1 = 0; 97 static sal_uInt32 nCache2 = 0; 98 99 typedef std::hash_map< sal_uInt16, bool > InvalidateSlotMap; 100 101 //==================================================================== 102 103 DECL_PTRARRAY(SfxStateCacheArr_Impl, SfxStateCache*, 32, 16) 104 105 //==================================================================== 106 107 class SfxAsyncExec_Impl 108 { 109 ::com::sun::star::util::URL aCommand; 110 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDisp; 111 Timer aTimer; 112 113 public: 114 115 SfxAsyncExec_Impl( const ::com::sun::star::util::URL& rCmd, const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch >& rDisp ) 116 : aCommand( rCmd ) 117 , xDisp( rDisp ) 118 { 119 aTimer.SetTimeoutHdl( LINK(this, SfxAsyncExec_Impl, TimerHdl) ); 120 aTimer.SetTimeout( 0 ); 121 aTimer.Start(); 122 } 123 124 DECL_LINK( TimerHdl, Timer*); 125 }; 126 127 IMPL_LINK(SfxAsyncExec_Impl, TimerHdl, Timer*, pTimer) 128 { 129 (void)pTimer; // unused 130 aTimer.Stop(); 131 132 Sequence<beans::PropertyValue> aSeq; 133 xDisp->dispatch( aCommand, aSeq ); 134 135 delete this; 136 return 0L; 137 } 138 139 class SfxBindings_Impl 140 { 141 public: 142 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchRecorder > xRecorder; 143 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > xProv; 144 SfxUnoControllerArr_Impl* 145 pUnoCtrlArr; 146 SfxWorkWindow* pWorkWin; 147 SfxBindings* pSubBindings; 148 SfxBindings* pSuperBindings; 149 SfxStateCacheArr_Impl* pCaches; // je ein cache fuer jede gebundene 150 sal_uInt16 nCachedFunc1; // index der zuletzt gerufenen 151 sal_uInt16 nCachedFunc2; // index der vorletzt gerufenen 152 sal_uInt16 nMsgPos; // Message-Position, ab der zu aktualisieren ist 153 SfxPopupAction ePopupAction; // in DeleteFloatinWindow() abgefragt 154 sal_Bool bContextChanged; 155 sal_Bool bMsgDirty; // wurde ein MessageServer invalidiert? 156 sal_Bool bAllMsgDirty; // wurden die MessageServer invalidiert? 157 sal_Bool bAllDirty; // nach InvalidateAll 158 sal_Bool bCtrlReleased; // waehrend EnterRegistrations 159 AutoTimer aTimer; // fuer volatile Slots 160 sal_Bool bInUpdate; // fuer Assertions 161 sal_Bool bInNextJob; // fuer Assertions 162 sal_Bool bFirstRound; // Erste Runde im Update 163 sal_uInt16 nFirstShell; // Shell, die in erster Runde bevorzugt wird 164 sal_uInt16 nOwnRegLevel; // z"ahlt die echten Locks, ohne die der SuperBindings 165 InvalidateSlotMap m_aInvalidateSlots; // store slots which are invalidated while in update 166 }; 167 168 //-------------------------------------------------------------------- 169 170 struct SfxFoundCache_Impl 171 { 172 sal_uInt16 nSlotId; // die Slot-Id 173 sal_uInt16 nWhichId; // falls verf"ugbar die Which-Id, sonst nSlotId 174 const SfxSlot* pSlot; // Pointer auf den <Master-Slot> 175 SfxStateCache* pCache; // Pointer auf den StatusCache, ggf. 0 176 177 SfxFoundCache_Impl(): 178 nSlotId(0), 179 nWhichId(0), 180 pSlot(0), 181 pCache(0) 182 {} 183 184 SfxFoundCache_Impl(SfxFoundCache_Impl&r): 185 nSlotId(r.nSlotId), 186 nWhichId(r.nWhichId), 187 pSlot(r.pSlot), 188 pCache(r.pCache) 189 {} 190 191 SfxFoundCache_Impl(sal_uInt16 nS, sal_uInt16 nW, const SfxSlot *pS, SfxStateCache *pC ): 192 nSlotId(nS), 193 nWhichId(nW), 194 pSlot(pS), 195 pCache(pC) 196 {} 197 198 int operator<( const SfxFoundCache_Impl &r ) const 199 { return nWhichId < r.nWhichId; } 200 201 int operator==( const SfxFoundCache_Impl &r ) const 202 { return nWhichId== r.nWhichId; } 203 }; 204 205 //-------------------------------------------------------------------------- 206 207 SV_DECL_PTRARR_SORT_DEL(SfxFoundCacheArr_Impl, SfxFoundCache_Impl*, 16, 16 ) 208 SV_IMPL_OP_PTRARR_SORT(SfxFoundCacheArr_Impl, SfxFoundCache_Impl*); 209 210 //========================================================================== 211 212 SfxBindings::SfxBindings() 213 : pImp(new SfxBindings_Impl), 214 pDispatcher(0), 215 nRegLevel(1) // geht erst auf 0, wenn Dispatcher gesetzt 216 { 217 pImp->nMsgPos = 0; 218 pImp->bAllMsgDirty = sal_True; 219 pImp->bContextChanged = sal_False; 220 pImp->bMsgDirty = sal_True; 221 pImp->bAllDirty = sal_True; 222 pImp->ePopupAction = SFX_POPUP_DELETE; 223 pImp->nCachedFunc1 = 0; 224 pImp->nCachedFunc2 = 0; 225 pImp->bCtrlReleased = sal_False; 226 pImp->bFirstRound = sal_False; 227 pImp->bInNextJob = sal_False; 228 pImp->bInUpdate = sal_False; 229 pImp->pSubBindings = NULL; 230 pImp->pSuperBindings = NULL; 231 pImp->pWorkWin = NULL; 232 pImp->pUnoCtrlArr = NULL; 233 pImp->nOwnRegLevel = nRegLevel; 234 235 // all caches are valid (no pending invalidate-job) 236 // create the list of caches 237 pImp->pCaches = new SfxStateCacheArr_Impl; 238 pImp->aTimer.SetTimeoutHdl( LINK(this, SfxBindings, NextJob_Impl) ); 239 } 240 241 //==================================================================== 242 243 SfxBindings::~SfxBindings() 244 245 /* [Beschreibung] 246 247 Destruktor der Klasse SfxBindings. Die eine, f"ur jede <SfxApplication> 248 existierende Instanz wird von der <SfxApplication> nach Ausf"urhung 249 von <SfxApplication::Exit()> automatisch zerst"ort. 250 251 Noch existierende <SfxControllerItem> Instanzen, die bei dieser 252 SfxBindings Instanz angemeldet sind, werden im Destruktor 253 automatisch zerst"ort. Dies sind i.d.R. Floating-Toolboxen, Value-Sets 254 etc. Arrays von SfxControllerItems d"urfen zu diesem Zeitpunkt nicht 255 mehr exisitieren. 256 */ 257 258 { 259 // Die SubBindings sollen ja nicht gelocked werden ! 260 pImp->pSubBindings = NULL; 261 262 ENTERREGISTRATIONS(); 263 264 pImp->aTimer.Stop(); 265 DeleteControllers_Impl(); 266 267 // Caches selbst l"oschen 268 sal_uInt16 nCount = pImp->pCaches->Count(); 269 for ( sal_uInt16 nCache = 0; nCache < nCount; ++nCache ) 270 delete pImp->pCaches->GetObject(nCache); 271 272 DELETEZ( pImp->pWorkWin ); 273 274 delete pImp->pCaches; 275 delete pImp; 276 } 277 278 //-------------------------------------------------------------------- 279 280 void SfxBindings::DeleteControllers_Impl() 281 { 282 // in der ersten Runde den SfxPopupWindows l"oschen 283 sal_uInt16 nCount = pImp->pCaches->Count(); 284 sal_uInt16 nCache; 285 for ( nCache = 0; nCache < nCount; ++nCache ) 286 { 287 // merken wo man ist 288 SfxStateCache *pCache = pImp->pCaches->GetObject(nCache); 289 sal_uInt16 nSlotId = pCache->GetId(); 290 291 // SfxPopupWindow l"oschen lassen 292 pCache->DeleteFloatingWindows(); 293 294 // da der Cache verkleinert worden sein kann, wiederaufsetzen 295 sal_uInt16 nNewCount = pImp->pCaches->Count(); 296 if ( nNewCount < nCount ) 297 { 298 nCache = GetSlotPos(nSlotId); 299 if ( nCache >= nNewCount || 300 nSlotId != pImp->pCaches->GetObject(nCache)->GetId() ) 301 --nCache; 302 nCount = nNewCount; 303 } 304 } 305 306 // alle Caches l"oschen 307 for ( nCache = pImp->pCaches->Count(); nCache > 0; --nCache ) 308 { 309 // Cache via ::com::sun::star::sdbcx::Index besorgen 310 SfxStateCache *pCache = pImp->pCaches->GetObject(nCache-1); 311 312 // alle Controller in dem Cache unbinden 313 SfxControllerItem *pNext; 314 for ( SfxControllerItem *pCtrl = pCache->GetItemLink(); 315 pCtrl; pCtrl = pNext ) 316 { 317 pNext = pCtrl->GetItemLink(); 318 pCtrl->UnBind(); 319 } 320 321 if ( pCache->GetInternalController() ) 322 pCache->GetInternalController()->UnBind(); 323 324 // Cache l"oschen 325 if( nCache-1 < pImp->pCaches->Count() ) 326 delete (*pImp->pCaches)[nCache-1]; 327 pImp->pCaches->Remove(nCache-1, 1); 328 } 329 330 if( pImp->pUnoCtrlArr ) 331 { 332 sal_uInt16 nCtrlCount = pImp->pUnoCtrlArr->Count(); 333 for ( sal_uInt16 n=nCtrlCount; n>0; n-- ) 334 { 335 SfxUnoControllerItem *pCtrl = (*pImp->pUnoCtrlArr)[n-1]; 336 pCtrl->ReleaseBindings(); 337 } 338 339 DBG_ASSERT( !pImp->pUnoCtrlArr->Count(), "UnoControllerItems nicht entfernt!" ); 340 DELETEZ( pImp->pUnoCtrlArr ); 341 } 342 } 343 344 //-------------------------------------------------------------------- 345 346 SfxPopupAction SfxBindings::GetPopupAction_Impl() const 347 { 348 return pImp->ePopupAction; 349 } 350 351 352 //-------------------------------------------------------------------- 353 354 void SfxBindings::HidePopups( bool bHide ) 355 { 356 // SfxPopupWindows hiden 357 HidePopupCtrls_Impl( bHide ); 358 SfxBindings *pSub = pImp->pSubBindings; 359 while ( pSub ) 360 { 361 pImp->pSubBindings->HidePopupCtrls_Impl( bHide ); 362 pSub = pSub->pImp->pSubBindings; 363 } 364 365 // SfxChildWindows hiden 366 DBG_ASSERT( pDispatcher, "HidePopups not allowed without dispatcher" ); 367 if ( pImp->pWorkWin ) 368 pImp->pWorkWin->HidePopups_Impl( bHide, sal_True ); 369 } 370 371 void SfxBindings::HidePopupCtrls_Impl( FASTBOOL bHide ) 372 { 373 if ( bHide ) 374 { 375 // SfxPopupWindows hiden 376 pImp->ePopupAction = SFX_POPUP_HIDE; 377 } 378 else 379 { 380 // SfxPopupWindows showen 381 pImp->ePopupAction = SFX_POPUP_SHOW; 382 } 383 384 for ( sal_uInt16 nCache = 0; nCache < pImp->pCaches->Count(); ++nCache ) 385 pImp->pCaches->GetObject(nCache)->DeleteFloatingWindows(); 386 pImp->ePopupAction = SFX_POPUP_DELETE; 387 } 388 389 //-------------------------------------------------------------------- 390 391 void SfxBindings::Update_Impl 392 ( 393 SfxStateCache* pCache // der upzudatende SfxStatusCache 394 ) 395 { 396 if( pCache->GetDispatch().is() && pCache->GetItemLink() ) 397 { 398 pCache->SetCachedState(sal_True); 399 if ( !pCache->GetInternalController() ) 400 return; 401 } 402 403 if ( !pDispatcher ) 404 return; 405 DBG_PROFSTART(SfxBindingsUpdate_Impl); 406 407 // alle mit derselben Statusmethode zusammensammeln, die dirty sind 408 SfxDispatcher &rDispat = *pDispatcher; 409 const SfxSlot *pRealSlot = 0; 410 const SfxSlotServer* pMsgServer = 0; 411 SfxFoundCacheArr_Impl aFound; 412 SfxItemSet *pSet = CreateSet_Impl( pCache, pRealSlot, &pMsgServer, aFound ); 413 sal_Bool bUpdated = sal_False; 414 if ( pSet ) 415 { 416 // Status erfragen 417 if ( rDispat._FillState( *pMsgServer, *pSet, pRealSlot ) ) 418 { 419 // Status posten 420 const SfxInterface *pInterface = 421 rDispat.GetShell(pMsgServer->GetShellLevel())->GetInterface(); 422 for ( sal_uInt16 nPos = 0; nPos < aFound.Count(); ++nPos ) 423 { 424 const SfxFoundCache_Impl *pFound = aFound[nPos]; 425 sal_uInt16 nWhich = pFound->nWhichId; 426 const SfxPoolItem *pItem = 0; 427 SfxItemState eState = pSet->GetItemState(nWhich, sal_True, &pItem); 428 if ( eState == SFX_ITEM_DEFAULT && SfxItemPool::IsWhich(nWhich) ) 429 pItem = &pSet->Get(nWhich); 430 UpdateControllers_Impl( pInterface, aFound[nPos], pItem, eState ); 431 } 432 bUpdated = sal_True; 433 } 434 435 delete pSet; 436 } 437 438 if ( !bUpdated && pCache ) 439 { 440 // Wenn pCache == NULL und kein SlotServer ( z.B. weil Dispatcher gelockt! ), 441 // darf nat"urlich kein Update versucht werden 442 SfxFoundCache_Impl aFoundCache( 443 pCache->GetId(), 0, 444 pRealSlot, pCache ); 445 UpdateControllers_Impl( 0, &aFoundCache, 0, SFX_ITEM_DISABLED); 446 } 447 448 DBG_PROFSTOP(SfxBindingsUpdate_Impl); 449 } 450 451 //-------------------------------------------------------------------- 452 453 void SfxBindings::InvalidateSlotsInMap_Impl() 454 { 455 InvalidateSlotMap::const_iterator pIter = pImp->m_aInvalidateSlots.begin(); 456 while ( pIter != pImp->m_aInvalidateSlots.end() ) 457 { 458 Invalidate( pIter->first ); 459 ++pIter; 460 } 461 pImp->m_aInvalidateSlots.clear(); 462 } 463 464 //-------------------------------------------------------------------- 465 466 void SfxBindings::AddSlotToInvalidateSlotsMap_Impl( sal_uInt16 nId ) 467 { 468 pImp->m_aInvalidateSlots[nId] = sal_True; 469 } 470 471 //-------------------------------------------------------------------- 472 473 void SfxBindings::Update 474 ( 475 sal_uInt16 nId // die gebundene und upzudatende Slot-Id 476 ) 477 { 478 DBG_MEMTEST(); 479 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 480 481 //!!TLX: Fuehrte zu Vorlagenkatalogstillstand 482 // if ( nRegLevel ) 483 // return; 484 485 if ( pDispatcher ) 486 pDispatcher->Flush(); 487 488 if ( pImp->pSubBindings ) 489 pImp->pSubBindings->Update( nId ); 490 491 SfxStateCache* pCache = GetStateCache( nId ); 492 if ( pCache ) 493 { 494 pImp->bInUpdate = sal_True; 495 if ( pImp->bMsgDirty ) 496 { 497 UpdateSlotServer_Impl(); 498 pCache = GetStateCache( nId ); 499 } 500 501 if (pCache) 502 { 503 sal_Bool bInternalUpdate = sal_True; 504 if( pCache->GetDispatch().is() && pCache->GetItemLink() ) 505 { 506 pCache->SetCachedState(sal_True); 507 bInternalUpdate = ( pCache->GetInternalController() != 0 ); 508 } 509 510 if ( bInternalUpdate ) 511 { 512 // Status erfragen 513 const SfxSlotServer* pMsgServer = pCache->GetSlotServer(*pDispatcher, pImp->xProv); 514 if ( !pCache->IsControllerDirty() && 515 ( !pMsgServer || 516 !pMsgServer->GetSlot()->IsMode(SFX_SLOT_VOLATILE) ) ) 517 { 518 pImp->bInUpdate = sal_False; 519 InvalidateSlotsInMap_Impl(); 520 return; 521 } 522 if (!pMsgServer) 523 { 524 pCache->SetState(SFX_ITEM_DISABLED, 0); 525 pImp->bInUpdate = sal_False; 526 InvalidateSlotsInMap_Impl(); 527 return; 528 } 529 530 Update_Impl(pCache); 531 } 532 533 pImp->bAllDirty = sal_False; 534 } 535 536 pImp->bInUpdate = sal_False; 537 InvalidateSlotsInMap_Impl(); 538 } 539 } 540 541 //-------------------------------------------------------------------- 542 543 void SfxBindings::Update() 544 { 545 DBG_MEMTEST(); 546 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 547 548 if ( pImp->pSubBindings ) 549 pImp->pSubBindings->Update(); 550 551 if ( pDispatcher ) 552 { 553 if ( nRegLevel ) 554 return; 555 556 pImp->bInUpdate = sal_True; 557 pDispatcher->Flush(); 558 pDispatcher->Update_Impl(); 559 while ( !NextJob_Impl(0) ) 560 ; // loop 561 pImp->bInUpdate = sal_False; 562 InvalidateSlotsInMap_Impl(); 563 } 564 } 565 566 //-------------------------------------------------------------------- 567 568 void SfxBindings::SetState 569 ( 570 const SfxItemSet& rSet // zu setzende Status-Werte 571 ) 572 { 573 // wenn gelockt, dann nur invalidieren 574 if ( nRegLevel ) 575 { 576 SfxItemIter aIter(rSet); 577 for ( const SfxPoolItem *pItem = aIter.FirstItem(); 578 pItem; 579 pItem = aIter.NextItem() ) 580 Invalidate( pItem->Which() ); 581 } 582 else 583 { 584 // Status d"urfen nur angenommen werden, wenn alle Slot-Pointer gesetzt sind 585 if ( pImp->bMsgDirty ) 586 UpdateSlotServer_Impl(); 587 588 // "uber das ItemSet iterieren, falls Slot gebunden, updaten 589 //! Bug: WhichIter verwenden und ggf. VoidItems hochschicken 590 SfxItemIter aIter(rSet); 591 for ( const SfxPoolItem *pItem = aIter.FirstItem(); 592 pItem; 593 pItem = aIter.NextItem() ) 594 { 595 SfxStateCache* pCache = 596 GetStateCache( rSet.GetPool()->GetSlotId(pItem->Which()) ); 597 if ( pCache ) 598 { 599 // Status updaten 600 if ( !pCache->IsControllerDirty() ) 601 pCache->Invalidate(sal_False); 602 pCache->SetState( SFX_ITEM_AVAILABLE, pItem ); 603 604 //! nicht implementiert: Updates von EnumSlots via MasterSlots 605 } 606 } 607 } 608 } 609 610 //-------------------------------------------------------------------- 611 612 void SfxBindings::SetState 613 ( 614 const SfxPoolItem& rItem // zu setzender Status-Wert 615 ) 616 { 617 if ( nRegLevel ) 618 { 619 Invalidate( rItem.Which() ); 620 } 621 else 622 { 623 // Status d"urfen nur angenommen werden, wenn alle Slot-Pointer gesetzt sind 624 if ( pImp->bMsgDirty ) 625 UpdateSlotServer_Impl(); 626 627 // falls der Slot gebunden ist, updaten 628 DBG_ASSERT( SfxItemPool::IsSlot( rItem.Which() ), 629 "cannot set items with which-id" ); 630 SfxStateCache* pCache = GetStateCache( rItem.Which() ); 631 if ( pCache ) 632 { 633 // Status updaten 634 if ( !pCache->IsControllerDirty() ) 635 pCache->Invalidate(sal_False); 636 pCache->SetState( SFX_ITEM_AVAILABLE, &rItem ); 637 638 //! nicht implementiert: Updates von EnumSlots via MasterSlots 639 } 640 } 641 } 642 643 644 //-------------------------------------------------------------------- 645 646 SfxStateCache* SfxBindings::GetAnyStateCache_Impl( sal_uInt16 nId ) 647 { 648 SfxStateCache* pCache = GetStateCache( nId ); 649 if ( !pCache && pImp->pSubBindings ) 650 return pImp->pSubBindings->GetAnyStateCache_Impl( nId ); 651 return pCache; 652 } 653 654 SfxStateCache* SfxBindings::GetStateCache 655 ( 656 sal_uInt16 nId /* Slot-Id, deren SfxStatusCache gefunden 657 werden soll */, 658 sal_uInt16* pPos /* 0 bzw. Position, ab der die Bindings 659 bin"ar durchsucht werden sollen. Liefert 660 die Position zur"uck, an der nId gefunden 661 wurde, bzw. an der es einfef"ugt werden 662 w"urde. */ 663 ) 664 { 665 DBG_MEMTEST(); 666 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 667 // is the specified function bound? 668 const sal_uInt16 nStart = ( pPos ? *pPos : 0 ); 669 const sal_uInt16 nPos = GetSlotPos( nId, nStart ); 670 671 if ( nPos < pImp->pCaches->Count() && 672 (*pImp->pCaches)[nPos]->GetId() == nId ) 673 { 674 if ( pPos ) 675 *pPos = nPos; 676 return (*pImp->pCaches)[nPos]; 677 } 678 return 0; 679 } 680 681 //-------------------------------------------------------------------- 682 683 void SfxBindings::InvalidateAll 684 ( 685 sal_Bool bWithMsg /* sal_True 686 Slot-Server als ung"ultig markieren 687 688 sal_False 689 Slot-Server bleiben g"ultig */ 690 ) 691 { 692 DBG_PROFSTART(SfxBindingsInvalidateAll); 693 DBG_ASSERT( !pImp->bInUpdate, "SfxBindings::Invalidate while in update" ); 694 695 DBG_MEMTEST(); 696 697 if ( pImp->pSubBindings ) 698 pImp->pSubBindings->InvalidateAll( bWithMsg ); 699 700 // ist schon alles dirty gesetzt oder downing => nicht zu tun 701 if ( !pDispatcher || 702 ( pImp->bAllDirty && ( !bWithMsg || pImp->bAllMsgDirty ) ) || 703 SFX_APP()->IsDowning() ) 704 { 705 DBG_PROFSTOP(SfxBindingsInvalidateAll); 706 return; 707 } 708 709 pImp->bAllMsgDirty = pImp->bAllMsgDirty || bWithMsg; 710 pImp->bMsgDirty = pImp->bMsgDirty || pImp->bAllMsgDirty || bWithMsg; 711 pImp->bAllDirty = sal_True; 712 713 for ( sal_uInt16 n = 0; n < pImp->pCaches->Count(); ++n ) 714 pImp->pCaches->GetObject(n)->Invalidate(bWithMsg); 715 /* 716 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame > xFrame 717 ( pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY ); 718 719 if ( bWithMsg && xFrame.is() ) 720 xFrame->contextChanged(); 721 */ 722 pImp->nMsgPos = 0; 723 if ( !nRegLevel ) 724 { 725 pImp->aTimer.Stop(); 726 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 727 pImp->aTimer.Start(); 728 // pImp->bFirstRound = sal_True; 729 // pImp->nFirstShell = 0; 730 } 731 732 DBG_PROFSTOP(SfxBindingsInvalidateAll); 733 } 734 735 //-------------------------------------------------------------------- 736 737 void SfxBindings::Invalidate 738 ( 739 const sal_uInt16* pIds /* numerisch sortiertes 0-terminiertes Array 740 von Slot-Ids (einzel, nicht als Paare!) */ 741 ) 742 { 743 DBG_PROFSTART(SfxBindingsInvalidateAll); 744 // DBG_ASSERT( !pImp->bInUpdate, "SfxBindings::Invalidate while in update" ); 745 746 DBG_MEMTEST(); 747 748 if ( pImp->bInUpdate ) 749 { 750 sal_Int32 i = 0; 751 while ( pIds[i] != 0 ) 752 AddSlotToInvalidateSlotsMap_Impl( pIds[i++] ); 753 754 if ( pImp->pSubBindings ) 755 pImp->pSubBindings->Invalidate( pIds ); 756 return; 757 } 758 759 if ( pImp->pSubBindings ) 760 pImp->pSubBindings->Invalidate( pIds ); 761 762 // ist schon alles dirty gesetzt oder downing => nicht zu tun 763 if ( !pDispatcher || pImp->bAllDirty || SFX_APP()->IsDowning() ) 764 return; 765 766 // in immer kleiner werdenden Berichen bin"ar suchen 767 for ( sal_uInt16 n = GetSlotPos(*pIds); 768 *pIds && n < pImp->pCaches->Count(); 769 n = GetSlotPos(*pIds, n) ) 770 { 771 // falls SID "uberhaupt gebunden ist, den Cache invalidieren 772 SfxStateCache *pCache = pImp->pCaches->GetObject(n); 773 if ( pCache->GetId() == *pIds ) 774 pCache->Invalidate(sal_False); 775 776 // n"achste SID 777 if ( !*++pIds ) 778 break; 779 DBG_ASSERT( *pIds > *(pIds-1), "pIds unsorted" ); 780 } 781 782 // falls nicht gelockt, Update-Timer starten 783 pImp->nMsgPos = 0; 784 if ( !nRegLevel ) 785 { 786 pImp->aTimer.Stop(); 787 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 788 pImp->aTimer.Start(); 789 // pImp->bFirstRound = sal_True; 790 // pImp->nFirstShell = 0; 791 } 792 793 DBG_PROFSTOP(SfxBindingsInvalidateAll); 794 } 795 796 //-------------------------------------------------------------------- 797 798 void SfxBindings::InvalidateShell 799 ( 800 const SfxShell& rSh /* Die <SfxShell>, deren Slot-Ids 801 invalidiert werden sollen. */, 802 803 sal_Bool bDeep /* sal_True 804 auch die, von der SfxShell 805 ererbten Slot-Ids werden invalidert 806 807 sal_False 808 die ererbten und nicht "uberladenen 809 Slot-Ids werden invalidiert */ 810 //! MI: z. Zt. immer bDeep 811 ) 812 { 813 DBG_ASSERT( !pImp->bInUpdate, "SfxBindings::Invalidate while in update" ); 814 815 if ( pImp->pSubBindings ) 816 pImp->pSubBindings->InvalidateShell( rSh, bDeep ); 817 818 if ( !pDispatcher || pImp->bAllDirty || SFX_APP()->IsDowning() ) 819 return; 820 821 DBG_PROFSTART(SfxBindingsInvalidateAll); 822 DBG_MEMTEST(); 823 824 // Jetzt schon flushen, wird in GetShellLevel(rSh) sowieso gemacht; wichtig, 825 // damit pImp->bAll(Msg)Dirty korrekt gesetzt ist 826 pDispatcher->Flush(); 827 828 if ( !pDispatcher || 829 ( pImp->bAllDirty && pImp->bAllMsgDirty ) || 830 SFX_APP()->IsDowning() ) 831 { 832 // Wenn sowieso demn"achst alle Server geholt werden 833 return; 834 } 835 836 // Level finden 837 sal_uInt16 nLevel = pDispatcher->GetShellLevel(rSh); 838 if ( nLevel != USHRT_MAX ) 839 { 840 for ( sal_uInt16 n = 0; n < pImp->pCaches->Count(); ++n ) 841 { 842 SfxStateCache *pCache = pImp->pCaches->GetObject(n); 843 const SfxSlotServer *pMsgServer = 844 pCache->GetSlotServer(*pDispatcher, pImp->xProv); 845 if ( pMsgServer && pMsgServer->GetShellLevel() == nLevel ) 846 pCache->Invalidate(sal_False); 847 } 848 pImp->nMsgPos = 0; 849 if ( !nRegLevel ) 850 { 851 pImp->aTimer.Stop(); 852 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 853 pImp->aTimer.Start(); 854 pImp->bFirstRound = sal_True; 855 pImp->nFirstShell = nLevel; 856 } 857 } 858 859 DBG_PROFSTOP(SfxBindingsInvalidateAll); 860 } 861 862 //-------------------------------------------------------------------- 863 864 void SfxBindings::Invalidate 865 ( 866 sal_uInt16 nId // zu invalidierende Slot-Id 867 ) 868 { 869 DBG_MEMTEST(); 870 // DBG_ASSERT( !pImp->bInUpdate, "SfxBindings::Invalidate while in update" ); 871 872 if ( pImp->bInUpdate ) 873 { 874 AddSlotToInvalidateSlotsMap_Impl( nId ); 875 if ( pImp->pSubBindings ) 876 pImp->pSubBindings->Invalidate( nId ); 877 return; 878 } 879 880 if ( pImp->pSubBindings ) 881 pImp->pSubBindings->Invalidate( nId ); 882 883 if ( !pDispatcher || pImp->bAllDirty || SFX_APP()->IsDowning() ) 884 return; 885 886 SfxStateCache* pCache = GetStateCache(nId); 887 if ( pCache ) 888 { 889 pCache->Invalidate(sal_False); 890 pImp->nMsgPos = Min(GetSlotPos(nId), pImp->nMsgPos); 891 if ( !nRegLevel ) 892 { 893 pImp->aTimer.Stop(); 894 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 895 pImp->aTimer.Start(); 896 } 897 } 898 } 899 900 //-------------------------------------------------------------------- 901 902 void SfxBindings::Invalidate 903 ( 904 sal_uInt16 nId, // zu invalidierende Slot-Id 905 sal_Bool bWithItem, // StateCache clearen ? 906 sal_Bool bWithMsg // SlotServer neu holen ? 907 ) 908 { 909 DBG_MEMTEST(); 910 DBG_ASSERT( !pImp->bInUpdate, "SfxBindings::Invalidate while in update" ); 911 912 if ( pImp->pSubBindings ) 913 pImp->pSubBindings->Invalidate( nId, bWithItem, bWithMsg ); 914 915 if ( SFX_APP()->IsDowning() ) 916 return; 917 918 SfxStateCache* pCache = GetStateCache(nId); 919 if ( pCache ) 920 { 921 if ( bWithItem ) 922 pCache->ClearCache(); 923 pCache->Invalidate(bWithMsg); 924 925 if ( !pDispatcher || pImp->bAllDirty ) 926 return; 927 928 pImp->nMsgPos = Min(GetSlotPos(nId), pImp->nMsgPos); 929 if ( !nRegLevel ) 930 { 931 pImp->aTimer.Stop(); 932 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 933 pImp->aTimer.Start(); 934 } 935 } 936 } 937 938 //-------------------------------------------------------------------- 939 940 sal_Bool SfxBindings::IsBound( sal_uInt16 nSlotId, sal_uInt16 nStartSearchAt ) 941 { 942 DBG_MEMTEST(); 943 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 944 return GetStateCache(nSlotId, &nStartSearchAt ) != 0; 945 } 946 947 //-------------------------------------------------------------------- 948 949 sal_uInt16 SfxBindings::GetSlotPos( sal_uInt16 nId, sal_uInt16 nStartSearchAt ) 950 { 951 DBG_MEMTEST(); 952 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 953 DBG_PROFSTART(SfxBindingsMsgPos); 954 955 // answer immediately if a function-seek comes repeated 956 if ( pImp->nCachedFunc1 < pImp->pCaches->Count() && 957 (*pImp->pCaches)[pImp->nCachedFunc1]->GetId() == nId ) 958 { 959 ++nCache1; 960 DBG_PROFSTOP(SfxBindingsMsgPos); 961 return pImp->nCachedFunc1; 962 } 963 if ( pImp->nCachedFunc2 < pImp->pCaches->Count() && 964 (*pImp->pCaches)[pImp->nCachedFunc2]->GetId() == nId ) 965 { 966 ++nCache2; 967 968 // swap the caches 969 sal_uInt16 nTemp = pImp->nCachedFunc1; 970 pImp->nCachedFunc1 = pImp->nCachedFunc2; 971 pImp->nCachedFunc2 = nTemp; 972 DBG_PROFSTOP(SfxBindingsMsgPos); 973 return pImp->nCachedFunc1; 974 } 975 976 // binary search, if not found, seek to target-position 977 if ( pImp->pCaches->Count() <= nStartSearchAt ) 978 { 979 DBG_PROFSTOP(SfxBindingsMsgPos); 980 return 0; 981 } 982 if ( pImp->pCaches->Count() == (nStartSearchAt+1) ) 983 { 984 DBG_PROFSTOP(SfxBindingsMsgPos); 985 return (*pImp->pCaches)[nStartSearchAt]->GetId() >= nId ? 0 : 1; 986 } 987 sal_uInt16 nLow = nStartSearchAt; 988 sal_uInt16 nMid = 0; 989 sal_uInt16 nHigh = 0; 990 sal_Bool bFound = sal_False; 991 nHigh = pImp->pCaches->Count() - 1; 992 while ( !bFound && nLow <= nHigh ) 993 { 994 nMid = (nLow + nHigh) >> 1; 995 DBG_ASSERT( nMid < pImp->pCaches->Count(), "bsearch ist buggy" ); 996 int nDiff = (int) nId - (int) ( ((*pImp->pCaches)[nMid])->GetId() ); 997 if ( nDiff < 0) 998 { if ( nMid == 0 ) 999 break; 1000 nHigh = nMid - 1; 1001 } 1002 else if ( nDiff > 0 ) 1003 { nLow = nMid + 1; 1004 if ( nLow == 0 ) 1005 break; 1006 } 1007 else 1008 bFound = sal_True; 1009 } 1010 sal_uInt16 nPos = bFound ? nMid : nLow; 1011 DBG_ASSERT( nPos <= pImp->pCaches->Count(), "" ); 1012 DBG_ASSERT( nPos == pImp->pCaches->Count() || 1013 nId <= (*pImp->pCaches)[nPos]->GetId(), "" ); 1014 DBG_ASSERT( nPos == nStartSearchAt || 1015 nId > (*pImp->pCaches)[nPos-1]->GetId(), "" ); 1016 DBG_ASSERT( ( (nPos+1) >= pImp->pCaches->Count() ) || 1017 nId < (*pImp->pCaches)[nPos+1]->GetId(), "" ); 1018 pImp->nCachedFunc2 = pImp->nCachedFunc1; 1019 pImp->nCachedFunc1 = nPos; 1020 DBG_PROFSTOP(SfxBindingsMsgPos); 1021 return nPos; 1022 } 1023 //-------------------------------------------------------------------- 1024 void SfxBindings::RegisterInternal_Impl( SfxControllerItem& rItem ) 1025 { 1026 Register_Impl( rItem, sal_True ); 1027 1028 } 1029 1030 void SfxBindings::Register( SfxControllerItem& rItem ) 1031 { 1032 Register_Impl( rItem, sal_False ); 1033 } 1034 1035 void SfxBindings::Register_Impl( SfxControllerItem& rItem, sal_Bool bInternal ) 1036 { 1037 DBG_MEMTEST(); 1038 DBG_ASSERT( nRegLevel > 0, "registration without EnterRegistrations" ); 1039 DBG_ASSERT( !pImp->bInNextJob, "SfxBindings::Register while status-updating" ); 1040 1041 // insert new cache if it does not already exist 1042 sal_uInt16 nId = rItem.GetId(); 1043 sal_uInt16 nPos = GetSlotPos(nId); 1044 if ( nPos >= pImp->pCaches->Count() || 1045 (*pImp->pCaches)[nPos]->GetId() != nId ) 1046 { 1047 SfxStateCache* pCache = new SfxStateCache(nId); 1048 pImp->pCaches->Insert( nPos, pCache ); 1049 DBG_ASSERT( nPos == 0 || 1050 (*pImp->pCaches)[nPos]->GetId() > 1051 (*pImp->pCaches)[nPos-1]->GetId(), "" ); 1052 DBG_ASSERT( (nPos == pImp->pCaches->Count()-1) || 1053 (*pImp->pCaches)[nPos]->GetId() < 1054 (*pImp->pCaches)[nPos+1]->GetId(), "" ); 1055 pImp->bMsgDirty = sal_True; 1056 } 1057 1058 // enqueue the new binding 1059 if ( bInternal ) 1060 { 1061 (*pImp->pCaches)[nPos]->SetInternalController( &rItem ); 1062 } 1063 else 1064 { 1065 SfxControllerItem *pOldItem = (*pImp->pCaches)[nPos]->ChangeItemLink(&rItem); 1066 rItem.ChangeItemLink(pOldItem); 1067 } 1068 } 1069 1070 //-------------------------------------------------------------------- 1071 1072 void SfxBindings::Release( SfxControllerItem& rItem ) 1073 { 1074 DBG_MEMTEST(); 1075 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1076 //! DBG_ASSERT( nRegLevel > 0, "release without EnterRegistrations" ); 1077 DBG_ASSERT( !pImp->bInNextJob, "SfxBindings::Release while status-updating" ); 1078 ENTERREGISTRATIONS(); 1079 1080 // find the bound function 1081 sal_uInt16 nId = rItem.GetId(); 1082 sal_uInt16 nPos = GetSlotPos(nId); 1083 SfxStateCache* pCache = (*pImp->pCaches)[nPos]; 1084 if ( pCache->GetId() == nId ) 1085 { 1086 if ( pCache->GetInternalController() == &rItem ) 1087 { 1088 pCache->ReleaseInternalController(); 1089 } 1090 else 1091 { 1092 // is this the first binding in the list? 1093 SfxControllerItem* pItem = pCache->GetItemLink(); 1094 if ( pItem == &rItem ) 1095 pCache->ChangeItemLink( rItem.GetItemLink() ); 1096 else 1097 { 1098 // search the binding in the list 1099 while ( pItem && pItem->GetItemLink() != &rItem ) 1100 pItem = pItem->GetItemLink(); 1101 1102 // unlink it if it was found 1103 if ( pItem ) 1104 pItem->ChangeItemLink( rItem.GetItemLink() ); 1105 } 1106 } 1107 1108 // was this the last controller? 1109 if ( pCache->GetItemLink() == 0 && !pCache->GetInternalController() ) 1110 { 1111 #ifdef slow 1112 // remove the BoundFunc 1113 delete (*pImp->pCaches)[nPos]; 1114 pImp->pCaches->Remove(nPos, 1); 1115 #endif 1116 pImp->bCtrlReleased = sal_True; 1117 } 1118 } 1119 1120 LEAVEREGISTRATIONS(); 1121 } 1122 1123 //-------------------------------------------------------------------- 1124 const SfxPoolItem* SfxBindings::ExecuteSynchron( sal_uInt16 nId, const SfxPoolItem** ppItems, sal_uInt16 nModi, 1125 const SfxPoolItem **ppInternalArgs ) 1126 { 1127 DBG_MEMTEST(); 1128 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1129 1130 if( !nId || !pDispatcher ) 1131 return NULL; 1132 1133 return Execute_Impl( nId, ppItems, nModi, SFX_CALLMODE_SYNCHRON, ppInternalArgs ); 1134 } 1135 1136 sal_Bool SfxBindings::Execute( sal_uInt16 nId, const SfxPoolItem** ppItems, sal_uInt16 nModi, SfxCallMode nCallMode, 1137 const SfxPoolItem **ppInternalArgs ) 1138 { 1139 DBG_MEMTEST(); 1140 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1141 1142 if( !nId || !pDispatcher ) 1143 return sal_False; 1144 1145 const SfxPoolItem* pRet = Execute_Impl( nId, ppItems, nModi, nCallMode, ppInternalArgs ); 1146 return ( pRet != 0 ); 1147 } 1148 1149 void SfxBindings::ExecuteGlobal_Impl( sal_uInt16 nId ) 1150 { 1151 if( nId && pDispatcher ) 1152 Execute_Impl( nId, NULL, 0, SFX_CALLMODE_ASYNCHRON, NULL, sal_True ); 1153 } 1154 1155 const SfxPoolItem* SfxBindings::Execute_Impl( sal_uInt16 nId, const SfxPoolItem** ppItems, sal_uInt16 nModi, SfxCallMode nCallMode, 1156 const SfxPoolItem **ppInternalArgs, sal_Bool bGlobalOnly ) 1157 { 1158 SfxStateCache *pCache = GetStateCache( nId ); 1159 if ( !pCache ) 1160 { 1161 SfxBindings *pBind = pImp->pSubBindings; 1162 while ( pBind ) 1163 { 1164 if ( pBind->GetStateCache( nId ) ) 1165 return pBind->Execute_Impl( nId, ppItems, nModi, nCallMode, ppInternalArgs, bGlobalOnly ); 1166 pBind = pBind->pImp->pSubBindings; 1167 }; 1168 } 1169 1170 SfxDispatcher &rDispatcher = *pDispatcher; 1171 rDispatcher.Flush(); 1172 rDispatcher.GetFrame(); // -Wall is this required??? 1173 1174 // get SlotServer (Slot+ShellLevel) and Shell from cache 1175 sal_Bool bDeleteCache = sal_False; 1176 if ( !pCache ) 1177 { 1178 // Execution of non cached slots (Accelerators don't use Controllers) 1179 // slot is uncached, use SlotCache to handle external dispatch providers 1180 pCache = new SfxStateCache( nId ); 1181 pCache->GetSlotServer( rDispatcher, pImp->xProv ); 1182 bDeleteCache = sal_True; 1183 } 1184 1185 if ( pCache && pCache->GetDispatch().is() ) 1186 { 1187 DBG_ASSERT( !ppInternalArgs, "Internal args get lost when dispatched!" ); 1188 1189 SfxItemPool &rPool = GetDispatcher()->GetFrame()->GetObjectShell()->GetPool(); 1190 SfxRequest aReq( nId, nCallMode, rPool ); 1191 aReq.SetModifier( nModi ); 1192 if( ppItems ) 1193 while( *ppItems ) 1194 aReq.AppendItem( **ppItems++ ); 1195 1196 // cache binds to an external dispatch provider 1197 pCache->Dispatch( aReq.GetArgs(), nCallMode == SFX_CALLMODE_SYNCHRON ); 1198 if ( bDeleteCache ) 1199 DELETEZ( pCache ); 1200 SfxPoolItem *pVoid = new SfxVoidItem( nId ); 1201 DeleteItemOnIdle( pVoid ); 1202 return pVoid; 1203 } 1204 1205 // slot is handled internally by SfxDispatcher 1206 if ( pImp->bMsgDirty ) 1207 UpdateSlotServer_Impl(); 1208 1209 SfxShell *pShell=0; 1210 const SfxSlot *pSlot=0; 1211 1212 // if slot was uncached, we should have created a cache in this method! 1213 DBG_ASSERT( pCache, "This code needs a cache!"); 1214 const SfxSlotServer* pServer = pCache ? pCache->GetSlotServer( rDispatcher, pImp->xProv ) : 0; 1215 if ( !pServer ) 1216 { 1217 return NULL; 1218 } 1219 else 1220 { 1221 pShell = rDispatcher.GetShell( pServer->GetShellLevel() ); 1222 pSlot = pServer->GetSlot(); 1223 } 1224 1225 if ( bGlobalOnly ) 1226 if ( !pShell->ISA(SfxModule) && !pShell->ISA(SfxApplication) && !pShell->ISA(SfxViewFrame) ) 1227 return NULL; 1228 1229 SfxItemPool &rPool = pShell->GetPool(); 1230 SfxRequest aReq( nId, nCallMode, rPool ); 1231 aReq.SetModifier( nModi ); 1232 if( ppItems ) 1233 while( *ppItems ) 1234 aReq.AppendItem( **ppItems++ ); 1235 if ( ppInternalArgs ) 1236 { 1237 SfxAllItemSet aSet( rPool ); 1238 for ( const SfxPoolItem **pArg = ppInternalArgs; *pArg; ++pArg ) 1239 aSet.Put( **pArg ); 1240 aReq.SetInternalArgs_Impl( aSet ); 1241 } 1242 1243 Execute_Impl( aReq, pSlot, pShell ); 1244 1245 const SfxPoolItem* pRet = aReq.GetReturnValue(); 1246 if ( !pRet ) 1247 { 1248 SfxPoolItem *pVoid = new SfxVoidItem( nId ); 1249 DeleteItemOnIdle( pVoid ); 1250 pRet = pVoid; 1251 } 1252 1253 if ( bDeleteCache ) 1254 delete pCache; 1255 1256 return pRet; 1257 } 1258 1259 void SfxBindings::Execute_Impl( SfxRequest& aReq, const SfxSlot* pSlot, SfxShell* pShell ) 1260 { 1261 SfxItemPool &rPool = pShell->GetPool(); 1262 1263 if ( SFX_KIND_ENUM == pSlot->GetKind() ) 1264 { 1265 // bei Enum-Slots muss der Master mit dem Wert des Enums executet werden 1266 const SfxSlot *pRealSlot = pShell->GetInterface()->GetRealSlot(pSlot); 1267 const sal_uInt16 nSlotId = pRealSlot->GetSlotId(); 1268 aReq.SetSlot( nSlotId ); 1269 aReq.AppendItem( SfxAllEnumItem( rPool.GetWhich(nSlotId), pSlot->GetValue() ) ); 1270 pDispatcher->_Execute( *pShell, *pRealSlot, aReq, aReq.GetCallMode() | SFX_CALLMODE_RECORD ); 1271 } 1272 else if ( SFX_KIND_ATTR == pSlot->GetKind() ) 1273 { 1274 // bei Attr-Slots muss der Which-Wert gemapped werden 1275 const sal_uInt16 nSlotId = pSlot->GetSlotId(); 1276 aReq.SetSlot( nSlotId ); 1277 if ( pSlot->IsMode(SFX_SLOT_TOGGLE) ) 1278 { 1279 // an togglebare-Attribs (Bools) wird der Wert angeheangt 1280 sal_uInt16 nWhich = pSlot->GetWhich(rPool); 1281 SfxItemSet aSet(rPool, nWhich, nWhich, 0); 1282 SfxStateFunc aFunc = pSlot->GetStateFnc(); 1283 pShell->CallState( aFunc, aSet ); 1284 const SfxPoolItem *pOldItem; 1285 SfxItemState eState = aSet.GetItemState(nWhich, sal_True, &pOldItem); 1286 if ( eState == SFX_ITEM_DISABLED ) 1287 return; 1288 1289 if ( SFX_ITEM_AVAILABLE == eState && SfxItemPool::IsWhich(nWhich) ) 1290 pOldItem = &aSet.Get(nWhich); 1291 1292 if ( SFX_ITEM_SET == eState || 1293 ( SFX_ITEM_AVAILABLE == eState && 1294 SfxItemPool::IsWhich(nWhich) && 1295 pOldItem ) ) 1296 { 1297 if ( pOldItem->ISA(SfxBoolItem) ) 1298 { 1299 // wir koennen Bools toggeln 1300 sal_Bool bOldValue = ((const SfxBoolItem *)pOldItem)->GetValue(); 1301 SfxBoolItem *pNewItem = (SfxBoolItem*) (pOldItem->Clone()); 1302 pNewItem->SetValue( !bOldValue ); 1303 aReq.AppendItem( *pNewItem ); 1304 delete pNewItem; 1305 } 1306 else if ( pOldItem->ISA(SfxEnumItemInterface) && 1307 ((SfxEnumItemInterface *)pOldItem)->HasBoolValue()) 1308 { 1309 // und Enums mit Bool-Interface 1310 SfxEnumItemInterface *pNewItem = 1311 (SfxEnumItemInterface*) (pOldItem->Clone()); 1312 pNewItem->SetBoolValue(!((SfxEnumItemInterface *)pOldItem)->GetBoolValue()); 1313 aReq.AppendItem( *pNewItem ); 1314 delete pNewItem; 1315 } 1316 else { 1317 DBG_ERROR( "Toggle only for Enums and Bools allowed" ); 1318 } 1319 } 1320 else if ( SFX_ITEM_DONTCARE == eState ) 1321 { 1322 // ein Status-Item per Factory erzeugen 1323 SfxPoolItem *pNewItem = pSlot->GetType()->CreateItem(); 1324 DBG_ASSERT( pNewItem, "Toggle an Slot ohne ItemFactory" ); 1325 pNewItem->SetWhich( nWhich ); 1326 1327 if ( pNewItem->ISA(SfxBoolItem) ) 1328 { 1329 // wir koennen Bools toggeln 1330 ((SfxBoolItem*)pNewItem)->SetValue( sal_True ); 1331 aReq.AppendItem( *pNewItem ); 1332 } 1333 else if ( pNewItem->ISA(SfxEnumItemInterface) && 1334 ((SfxEnumItemInterface *)pNewItem)->HasBoolValue()) 1335 { 1336 // und Enums mit Bool-Interface 1337 ((SfxEnumItemInterface*)pNewItem)->SetBoolValue(sal_True); 1338 aReq.AppendItem( *pNewItem ); 1339 } 1340 else { 1341 DBG_ERROR( "Toggle only for Enums and Bools allowed" ); 1342 } 1343 delete pNewItem; 1344 } 1345 else { 1346 DBG_ERROR( "suspicious Toggle-Slot" ); 1347 } 1348 } 1349 1350 pDispatcher->_Execute( *pShell, *pSlot, aReq, aReq.GetCallMode() | SFX_CALLMODE_RECORD ); 1351 } 1352 else 1353 pDispatcher->_Execute( *pShell, *pSlot, aReq, aReq.GetCallMode() | SFX_CALLMODE_RECORD ); 1354 } 1355 1356 //-------------------------------------------------------------------- 1357 1358 void SfxBindings::UpdateSlotServer_Impl() 1359 { 1360 DBG_PROFSTART(SfxBindingsUpdateServers); 1361 DBG_MEMTEST(); 1362 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1363 1364 // synchronisieren 1365 pDispatcher->Flush(); 1366 // pDispatcher->Update_Impl(); 1367 1368 if ( pImp->bAllMsgDirty ) 1369 { 1370 if ( !nRegLevel ) 1371 { 1372 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame > xFrame 1373 ( pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY ); 1374 //if ( xFrame.is() ) 1375 // xFrame->contextChanged(); 1376 pImp->bContextChanged = sal_False; 1377 } 1378 else 1379 pImp->bContextChanged = sal_True; 1380 } 1381 1382 const sal_uInt16 nCount = pImp->pCaches->Count(); 1383 for(sal_uInt16 i = 0; i < nCount; ++i) 1384 { 1385 SfxStateCache *pCache = pImp->pCaches->GetObject(i); 1386 pCache->GetSlotServer(*pDispatcher, pImp->xProv); 1387 } 1388 pImp->bMsgDirty = pImp->bAllMsgDirty = sal_False; 1389 1390 Broadcast( SfxSimpleHint(SFX_HINT_DOCCHANGED) ); 1391 1392 DBG_PROFSTOP(SfxBindingsUpdateServers); 1393 } 1394 1395 //-------------------------------------------------------------------- 1396 1397 #ifdef WNT 1398 int __cdecl CmpUS_Impl(const void *p1, const void *p2) 1399 #else 1400 int CmpUS_Impl(const void *p1, const void *p2) 1401 #endif 1402 1403 /* [Beschreibung] 1404 1405 Interne Vergleichsfunktion fuer qsort. 1406 */ 1407 1408 { 1409 return *(sal_uInt16 *)p1 - *(sal_uInt16 *)p2; 1410 } 1411 1412 //-------------------------------------------------------------------- 1413 1414 SfxItemSet* SfxBindings::CreateSet_Impl 1415 ( 1416 SfxStateCache*& pCache, // in: Status-Cache von nId 1417 const SfxSlot*& pRealSlot, // out: RealSlot zu nId 1418 const SfxSlotServer** pMsgServer, // out: Slot-Server zu nId 1419 SfxFoundCacheArr_Impl& rFound // out: Liste der Caches der Siblings 1420 ) 1421 { 1422 DBG_MEMTEST(); 1423 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1424 1425 DBG_ASSERT( !pImp->bMsgDirty, "CreateSet_Impl mit dirty MessageServer" ); 1426 1427 const SfxSlotServer* pMsgSvr = pCache->GetSlotServer(*pDispatcher, pImp->xProv); 1428 if(!pMsgSvr || !pDispatcher) 1429 return 0; 1430 1431 DBG_PROFSTART(SfxBindingsCreateSet); 1432 pRealSlot = 0; 1433 *pMsgServer = pMsgSvr; 1434 1435 sal_uInt16 nShellLevel = pMsgSvr->GetShellLevel(); 1436 SfxShell *pShell = pDispatcher->GetShell( nShellLevel ); 1437 if ( !pShell ) // seltener GPF beim Browsen durch Update aus Inet-Notify 1438 return 0; 1439 1440 SfxItemPool &rPool = pShell->GetPool(); 1441 1442 // hole die Status-Methode, von der pCache bedient wird 1443 SfxStateFunc pFnc = 0; 1444 const SfxInterface *pInterface = pShell->GetInterface(); 1445 if ( SFX_KIND_ENUM == pMsgSvr->GetSlot()->GetKind() ) 1446 { 1447 pRealSlot = pInterface->GetRealSlot(pMsgSvr->GetSlot()); 1448 pCache = GetStateCache( pRealSlot->GetSlotId() ); 1449 // DBG_ASSERT( pCache, "Kein Slotcache fuer den Masterslot gefunden!" ); 1450 } 1451 else 1452 pRealSlot = pMsgSvr->GetSlot(); 1453 1454 // 1455 // Achtung: pCache darf auch NULL sein !!! 1456 // 1457 1458 pFnc = pRealSlot->GetStateFnc(); 1459 1460 // der RealSlot ist immer drin 1461 const SfxFoundCache_Impl *pFound = new SfxFoundCache_Impl( 1462 pRealSlot->GetSlotId(), pRealSlot->GetWhich(rPool), pRealSlot, pCache ); 1463 rFound.Insert( pFound ); 1464 1465 sal_uInt16 nSlot = pRealSlot->GetSlotId(); 1466 if ( !(nSlot >= SID_VERB_START && nSlot <= SID_VERB_END) ) 1467 { 1468 pInterface = pInterface->GetRealInterfaceForSlot( pRealSlot ); 1469 DBG_ASSERT (pInterface,"Slot in angegebener Shell nicht gefunden!"); 1470 } 1471 1472 // Durchsuche die Bindings nach den von derselben Funktion bedienten Slots. 1473 // Daf"ur kommen nur Slots in Frage, die es im gefundenen Interface gibt. 1474 1475 // Die Position des Statecaches im StateCache-Array 1476 sal_uInt16 nCachePos = pImp->nMsgPos; 1477 const SfxSlot *pSibling = pRealSlot->GetNextSlot(); 1478 1479 // Die Slots eines Interfaces sind im Kreis verkettet 1480 while ( pSibling > pRealSlot ) 1481 { 1482 SfxStateFunc pSiblingFnc=0; 1483 SfxStateCache *pSiblingCache = 1484 GetStateCache( pSibling->GetSlotId(), &nCachePos ); 1485 1486 // Ist der Slot "uberhaupt gecached ? 1487 if ( pSiblingCache ) 1488 { 1489 const SfxSlotServer *pServ = pSiblingCache->GetSlotServer(*pDispatcher, pImp->xProv); 1490 if ( pServ && pServ->GetShellLevel() == nShellLevel ) 1491 pSiblingFnc = pServ->GetSlot()->GetStateFnc(); 1492 } 1493 1494 // Mu\s der Slot "uberhaupt upgedatet werden ? 1495 bool bInsert = pSiblingCache && pSiblingCache->IsControllerDirty(); 1496 1497 // Bugfix #26161#: Es reicht nicht, nach der selben Shell zu fragen !! 1498 bool bSameMethod = pSiblingCache && pFnc == pSiblingFnc; 1499 1500 // Wenn der Slot ein nicht-dirty MasterSlot ist, dann ist vielleicht 1501 // einer seiner Slaves dirty ? Dann wird der Masterslot doch eingef"ugt. 1502 if ( !bInsert && bSameMethod && pSibling->GetLinkedSlot() ) 1503 { 1504 // auch Slave-Slots auf Binding pru"fen 1505 const SfxSlot* pFirstSlave = pSibling->GetLinkedSlot(); 1506 for ( const SfxSlot *pSlaveSlot = pFirstSlave; 1507 !bInsert; 1508 pSlaveSlot = pSlaveSlot->GetNextSlot()) 1509 { 1510 // Die Slaves zeigen auf ihren Master 1511 DBG_ASSERT(pSlaveSlot->GetLinkedSlot() == pSibling, 1512 "Falsche Master/Slave-Beziehung!"); 1513 1514 sal_uInt16 nCurMsgPos = pImp->nMsgPos; 1515 const SfxStateCache *pSlaveCache = 1516 GetStateCache( pSlaveSlot->GetSlotId(), &nCurMsgPos ); 1517 1518 // Ist der Slave-Slot gecached und dirty ? 1519 bInsert = pSlaveCache && pSlaveCache->IsControllerDirty(); 1520 1521 // Slaves sind untereinander im Kreis verkettet 1522 if (pSlaveSlot->GetNextSlot() == pFirstSlave) 1523 break; 1524 } 1525 } 1526 1527 if ( bInsert && bSameMethod ) 1528 { 1529 const SfxFoundCache_Impl *pFoundCache = new SfxFoundCache_Impl( 1530 pSibling->GetSlotId(), pSibling->GetWhich(rPool), 1531 pSibling, pSiblingCache ); 1532 1533 rFound.Insert( pFoundCache ); 1534 } 1535 1536 pSibling = pSibling->GetNextSlot(); 1537 } 1538 1539 // aus den Ranges ein Set erzeugen 1540 sal_uInt16 *pRanges = new sal_uInt16[rFound.Count() * 2 + 1]; 1541 int j = 0; 1542 sal_uInt16 i = 0; 1543 while ( i < rFound.Count() ) 1544 { 1545 pRanges[j++] = rFound[i]->nWhichId; 1546 // aufeinanderfolgende Zahlen 1547 for ( ; i < rFound.Count()-1; ++i ) 1548 if ( rFound[i]->nWhichId+1 != rFound[i+1]->nWhichId ) 1549 break; 1550 pRanges[j++] = rFound[i++]->nWhichId; 1551 } 1552 pRanges[j] = 0; // terminierende NULL 1553 SfxItemSet *pSet = new SfxItemSet(rPool, pRanges); 1554 delete [] pRanges; 1555 DBG_PROFSTOP(SfxBindingsCreateSet); 1556 return pSet; 1557 } 1558 1559 //-------------------------------------------------------------------- 1560 1561 void SfxBindings::UpdateControllers_Impl 1562 ( 1563 const SfxInterface* pIF, // das diese Id momentan bedienende Interface 1564 const SfxFoundCache_Impl* pFound, // Cache, Slot, Which etc. 1565 const SfxPoolItem* pItem, // item to send to controller 1566 SfxItemState eState // state of item 1567 ) 1568 { 1569 DBG_ASSERT( !pFound->pSlot || SFX_KIND_ENUM != pFound->pSlot->GetKind(), 1570 "direct update of enum slot isn't allowed" ); 1571 DBG_PROFSTART(SfxBindingsUpdateCtrl1); 1572 1573 SfxStateCache* pCache = pFound->pCache; 1574 const SfxSlot* pSlot = pFound->pSlot; 1575 DBG_ASSERT( !pCache || !pSlot || pCache->GetId() == pSlot->GetSlotId(), "SID mismatch" ); 1576 1577 // insofern gebunden, die Controller f"uer den Slot selbst updaten 1578 if ( pCache && pCache->IsControllerDirty() ) 1579 { 1580 if ( SFX_ITEM_DONTCARE == eState ) 1581 { 1582 // uneindeuting 1583 pCache->SetState( SFX_ITEM_DONTCARE, (SfxPoolItem *)-1 ); 1584 } 1585 else if ( SFX_ITEM_DEFAULT == eState && 1586 pFound->nWhichId > SFX_WHICH_MAX ) 1587 { 1588 // kein Status oder Default aber ohne Pool 1589 SfxVoidItem aVoid(0); 1590 pCache->SetState( SFX_ITEM_UNKNOWN, &aVoid ); 1591 } 1592 else if ( SFX_ITEM_DISABLED == eState ) 1593 pCache->SetState(SFX_ITEM_DISABLED, 0); 1594 else 1595 pCache->SetState(SFX_ITEM_AVAILABLE, pItem); 1596 } 1597 1598 DBG_PROFSTOP(SfxBindingsUpdateCtrl1); 1599 1600 // insofern vorhanden und gebunden, die Controller f"uer Slave-Slots 1601 // (Enum-Werte) des Slots updaten 1602 DBG_PROFSTART(SfxBindingsUpdateCtrl2); 1603 DBG_ASSERT( !pSlot || 0 == pSlot->GetLinkedSlot() || !pItem || 1604 pItem->ISA(SfxEnumItemInterface), 1605 "master slot with non-enum-type found" ); 1606 const SfxSlot *pFirstSlave = pSlot ? pSlot->GetLinkedSlot() : 0; 1607 if ( pIF && pFirstSlave) 1608 { 1609 // Items auf EnumItem casten 1610 const SfxEnumItemInterface *pEnumItem = 1611 PTR_CAST(SfxEnumItemInterface,pItem); 1612 if ( eState == SFX_ITEM_AVAILABLE && !pEnumItem ) 1613 eState = SFX_ITEM_DONTCARE; 1614 else 1615 eState = SfxControllerItem::GetItemState( pEnumItem ); 1616 1617 // "uber alle Slaves-Slots iterieren 1618 for ( const SfxSlot *pSlave = pFirstSlave; pSlave; pSlave = pSlave->GetNextSlot() ) 1619 { 1620 DBG_ASSERT(pSlave, "Falsche SlaveSlot-Verkettung!"); 1621 DBG_ASSERT(SFX_KIND_ENUM == pSlave->GetKind(),"non enum slaves aren't allowed"); 1622 DBG_ASSERT(pSlave->GetMasterSlotId() == pSlot->GetSlotId(),"falscher MasterSlot!"); 1623 1624 // ist die Funktion gebunden? 1625 SfxStateCache *pEnumCache = GetStateCache( pSlave->GetSlotId() ); 1626 if ( pEnumCache ) 1627 { 1628 pEnumCache->Invalidate(sal_False); 1629 1630 HACK(CONTROL/SELECT Kram) 1631 if ( eState == SFX_ITEM_DONTCARE && pFound->nWhichId == 10144 ) 1632 { 1633 SfxVoidItem aVoid(0); 1634 pEnumCache->SetState( SFX_ITEM_UNKNOWN, &aVoid ); 1635 1636 if (pSlave->GetNextSlot() == pFirstSlave) 1637 break; 1638 1639 continue; 1640 } 1641 1642 if ( SFX_ITEM_DISABLED == eState || !pEnumItem->IsEnabled( pSlave->GetSlotId()) ) 1643 { 1644 // disabled 1645 pEnumCache->SetState(SFX_ITEM_DISABLED, 0); 1646 } 1647 else if ( SFX_ITEM_AVAILABLE == eState ) 1648 { 1649 // enum-Wert ermitteln 1650 sal_uInt16 nValue = pEnumItem->GetEnumValue(); 1651 SfxBoolItem aBool( pFound->nWhichId, pSlave->GetValue() == nValue ); 1652 pEnumCache->SetState(SFX_ITEM_AVAILABLE, &aBool); 1653 } 1654 else 1655 { 1656 // uneindeuting 1657 pEnumCache->SetState( SFX_ITEM_DONTCARE, (SfxPoolItem *)-1 ); 1658 } 1659 } 1660 1661 if (pSlave->GetNextSlot() == pFirstSlave) 1662 break; 1663 } 1664 } 1665 1666 DBG_PROFSTOP(SfxBindingsUpdateCtrl2); 1667 } 1668 1669 1670 //-------------------------------------------------------------------- 1671 1672 IMPL_LINK( SfxBindings, NextJob_Impl, Timer *, pTimer ) 1673 { 1674 #ifdef DBG_UTIL 1675 // on Windows very often C++ Exceptions (GPF etc.) are caught by MSVCRT or another MS library 1676 // try to get them here 1677 try 1678 { 1679 #endif 1680 const unsigned MAX_INPUT_DELAY = 200; 1681 1682 DBG_MEMTEST(); 1683 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1684 1685 DBG_PROFSTART(SfxBindingsNextJob_Impl0); 1686 1687 if ( Application::GetLastInputInterval() < MAX_INPUT_DELAY && pTimer ) 1688 { 1689 pImp->aTimer.SetTimeout(TIMEOUT_UPDATING); 1690 return sal_True; 1691 } 1692 1693 SfxApplication *pSfxApp = SFX_APP(); 1694 1695 if( pDispatcher ) 1696 pDispatcher->Update_Impl(); 1697 1698 // modifying the SfxObjectInterface-stack without SfxBindings => nothing to do 1699 SfxViewFrame* pFrame = pDispatcher->GetFrame(); 1700 //<!--Modified by PengYunQuan for Validity Cell Range Picker 1701 //if ( (pFrame && pFrame->GetObjectShell()->IsInModalMode()) || pSfxApp->IsDowning() || !pImp->pCaches->Count() ) 1702 if ( (pFrame && !pFrame->GetObjectShell()->AcceptStateUpdate()) || pSfxApp->IsDowning() || !pImp->pCaches->Count() ) 1703 //-->Modified by PengYunQuan for Validity Cell Range Picker 1704 { 1705 DBG_PROFSTOP(SfxBindingsNextJob_Impl0); 1706 return sal_True; 1707 } 1708 if ( !pDispatcher || !pDispatcher->IsFlushed() ) 1709 { 1710 DBG_PROFSTOP(SfxBindingsNextJob_Impl0); 1711 return sal_True; 1712 } 1713 1714 // gfs. alle Server aktualisieren / geschieht in eigener Zeitscheibe 1715 if ( pImp->bMsgDirty ) 1716 { 1717 UpdateSlotServer_Impl(); 1718 DBG_PROFSTOP(SfxBindingsNextJob_Impl0); 1719 return sal_False; 1720 } 1721 1722 DBG_PROFSTOP(SfxBindingsNextJob_Impl0); 1723 DBG_PROFSTART(SfxBindingsNextJob_Impl); 1724 pImp->bAllDirty = sal_False; 1725 pImp->aTimer.SetTimeout(TIMEOUT_UPDATING); 1726 1727 // at least 10 loops and further if more jobs are available but no input 1728 bool bPreEmptive = pTimer && !pSfxApp->Get_Impl()->nInReschedule; 1729 sal_uInt16 nLoops = 10; 1730 pImp->bInNextJob = sal_True; 1731 const sal_uInt16 nCount = pImp->pCaches->Count(); 1732 while ( pImp->nMsgPos < nCount ) 1733 { 1734 // iterate through the bound functions 1735 sal_Bool bJobDone = sal_False; 1736 while ( !bJobDone ) 1737 { 1738 SfxStateCache* pCache = (*pImp->pCaches)[pImp->nMsgPos]; 1739 DBG_ASSERT( pCache, "invalid SfxStateCache-position in job queue" ); 1740 sal_Bool bWasDirty = pCache->IsControllerDirty(); 1741 if ( bWasDirty ) 1742 { 1743 /* 1744 sal_Bool bSkip = sal_False; 1745 if ( pImp->bFirstRound ) 1746 { 1747 // Falls beim Update eine Shell vorgezogen werden soll, 1748 // kommt in einer ersten Update-Runde nur diese dran 1749 const SfxSlotServer *pMsgServer = 1750 pCache->GetSlotServer(*pDispatcher, pImp->xProv); 1751 if ( pMsgServer && 1752 pMsgServer->GetShellLevel() != pImp->nFirstShell ) 1753 bSkip = sal_True; 1754 } 1755 1756 if ( !bSkip ) 1757 { 1758 */ 1759 Update_Impl( pCache ); 1760 DBG_ASSERT( nCount == pImp->pCaches->Count(), 1761 "Reschedule in StateChanged => buff" ); 1762 // } 1763 } 1764 1765 // skip to next function binding 1766 ++pImp->nMsgPos; 1767 1768 // keep job if it is not completed, but any input is available 1769 bJobDone = pImp->nMsgPos >= nCount; 1770 if ( bJobDone && pImp->bFirstRound ) 1771 { 1772 // Update der bevorzugten Shell ist gelaufen, nun d"urfen 1773 // auch die anderen 1774 bJobDone = sal_False; 1775 pImp->bFirstRound = sal_False; 1776 pImp->nMsgPos = 0; 1777 } 1778 1779 if ( bWasDirty && !bJobDone && bPreEmptive && (--nLoops == 0) ) 1780 { 1781 DBG_PROFSTOP(SfxBindingsNextJob_Impl); 1782 pImp->bInNextJob = sal_False; 1783 return sal_False; 1784 } 1785 } 1786 } 1787 1788 pImp->nMsgPos = 0; 1789 1790 // check for volatile slots 1791 bool bVolatileSlotsPresent = false; 1792 for ( sal_uInt16 n = 0; n < nCount; ++n ) 1793 { 1794 SfxStateCache* pCache = (*pImp->pCaches)[n]; 1795 const SfxSlotServer *pSlotServer = pCache->GetSlotServer(*pDispatcher, pImp->xProv); 1796 if ( pSlotServer && pSlotServer->GetSlot()->IsMode(SFX_SLOT_VOLATILE) ) 1797 { 1798 pCache->Invalidate(sal_False); 1799 bVolatileSlotsPresent = true; 1800 } 1801 } 1802 1803 if (bVolatileSlotsPresent) 1804 pImp->aTimer.SetTimeout(TIMEOUT_IDLE); 1805 else 1806 pImp->aTimer.Stop(); 1807 1808 // Update-Runde ist beendet 1809 pImp->bInNextJob = sal_False; 1810 Broadcast(SfxSimpleHint(SFX_HINT_UPDATEDONE)); 1811 DBG_PROFSTOP(SfxBindingsNextJob_Impl); 1812 return sal_True; 1813 #ifdef DBG_UTIL 1814 } 1815 catch (...) 1816 { 1817 DBG_ERROR("C++ exception caught!"); 1818 pImp->bInNextJob = sal_False; 1819 } 1820 1821 return sal_False; 1822 #endif 1823 } 1824 1825 //-------------------------------------------------------------------- 1826 1827 sal_uInt16 SfxBindings::EnterRegistrations(const char *pFile, int nLine) 1828 { 1829 (void)pFile; 1830 (void)nLine; 1831 DBG_MEMTEST(); 1832 #ifdef DBG_UTIL 1833 ByteString aMsg; 1834 aMsg.Fill( Min(nRegLevel, sal_uInt16(8) ) ); 1835 aMsg += "this = "; 1836 aMsg += ByteString::CreateFromInt32((long)this); 1837 aMsg += " Level = "; 1838 aMsg += ByteString::CreateFromInt32(nRegLevel); 1839 aMsg += " SfxBindings::EnterRegistrations "; 1840 if(pFile) { 1841 aMsg += "File: "; 1842 aMsg += pFile; 1843 aMsg += " Line: "; 1844 aMsg += ByteString::CreateFromInt32(nLine); 1845 } 1846 // FILE* pLog = fopen( "c:\\bindings.log", "a+w" ); 1847 // fwrite( aMsg.GetBuffer(), 1, aMsg.Len(), pLog ); 1848 // fclose( pLog ); 1849 DbgTrace( aMsg.GetBuffer() ); 1850 #endif 1851 1852 // Wenn Bindings gelockt werden, auch SubBindings locken 1853 if ( pImp->pSubBindings ) 1854 { 1855 pImp->pSubBindings->ENTERREGISTRATIONS(); 1856 1857 // Dieses EnterRegistrations ist f"ur die SubBindings kein "echtes" 1858 pImp->pSubBindings->pImp->nOwnRegLevel--; 1859 1860 // Bindings synchronisieren 1861 pImp->pSubBindings->nRegLevel = nRegLevel + pImp->pSubBindings->pImp->nOwnRegLevel + 1; 1862 } 1863 1864 pImp->nOwnRegLevel++; 1865 1866 // check if this is the outer most level 1867 if ( ++nRegLevel == 1 ) 1868 { 1869 // stop background-processing 1870 pImp->aTimer.Stop(); 1871 1872 // flush the cache 1873 pImp->nCachedFunc1 = 0; 1874 pImp->nCachedFunc2 = 0; 1875 1876 // merken, ob ganze Caches verschwunden sind 1877 pImp->bCtrlReleased = sal_False; 1878 } 1879 1880 return nRegLevel; 1881 } 1882 //-------------------------------------------------------------------- 1883 1884 void SfxBindings::LeaveRegistrations( sal_uInt16 nLevel, const char *pFile, int nLine ) 1885 { 1886 (void)nLevel; // unused variable 1887 (void)pFile; 1888 (void)nLine; 1889 DBG_MEMTEST(); 1890 DBG_ASSERT( nRegLevel, "Leave without Enter" ); 1891 DBG_ASSERT( nLevel == USHRT_MAX || nLevel == nRegLevel, "wrong Leave" ); 1892 1893 // Nur wenn die SubBindings noch von den SuperBindings gelockt sind, diesen Lock entfernen 1894 // ( d.h. wenn es mehr Locks als "echte" Locks dort gibt ) 1895 if ( pImp->pSubBindings && pImp->pSubBindings->nRegLevel > pImp->pSubBindings->pImp->nOwnRegLevel ) 1896 { 1897 // Bindings synchronisieren 1898 pImp->pSubBindings->nRegLevel = nRegLevel + pImp->pSubBindings->pImp->nOwnRegLevel; 1899 1900 // Dieses LeaveRegistrations ist f"ur die SubBindings kein "echtes" 1901 pImp->pSubBindings->pImp->nOwnRegLevel++; 1902 pImp->pSubBindings->LEAVEREGISTRATIONS(); 1903 } 1904 1905 pImp->nOwnRegLevel--; 1906 1907 // check if this is the outer most level 1908 if ( --nRegLevel == 0 && !SFX_APP()->IsDowning() ) 1909 { 1910 if ( pImp->bContextChanged ) 1911 { 1912 pImp->bContextChanged = sal_False; 1913 /* 1914 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame > xFrame 1915 ( pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY ); 1916 if ( xFrame.is() ) 1917 xFrame->contextChanged();*/ 1918 } 1919 1920 #ifndef slow 1921 SfxViewFrame* pFrame = pDispatcher->GetFrame(); 1922 1923 // ggf unbenutzte Caches entfernen bzw. PlugInInfo aufbereiten 1924 if ( pImp->bCtrlReleased ) 1925 { 1926 for ( sal_uInt16 nCache = pImp->pCaches->Count(); nCache > 0; --nCache ) 1927 { 1928 // Cache via ::com::sun::star::sdbcx::Index besorgen 1929 SfxStateCache *pCache = pImp->pCaches->GetObject(nCache-1); 1930 1931 // kein Controller mehr interessiert 1932 if ( pCache->GetItemLink() == 0 && !pCache->GetInternalController() ) 1933 { 1934 // Cache entfernen. Safety: first remove and then delete 1935 SfxStateCache* pSfxStateCache = (*pImp->pCaches)[nCache-1]; 1936 pImp->pCaches->Remove(nCache-1, 1); 1937 delete pSfxStateCache; 1938 } 1939 else 1940 { 1941 // neue Controller mit den alten Items benachrichtigen 1942 //!pCache->SetCachedState(); 1943 } 1944 } 1945 } 1946 #endif 1947 // restart background-processing 1948 pImp->nMsgPos = 0; 1949 if ( !pFrame || !pFrame->GetObjectShell() ) 1950 return; 1951 if ( pImp->pCaches && pImp->pCaches->Count() ) 1952 { 1953 pImp->aTimer.Stop(); 1954 pImp->aTimer.SetTimeout(TIMEOUT_FIRST); 1955 pImp->aTimer.Start(); 1956 // pImp->bFirstRound = sal_True; 1957 } 1958 } 1959 1960 #ifdef DBG_UTIL 1961 ByteString aMsg; 1962 aMsg.Fill( Min(nRegLevel, sal_uInt16(8)) ); 1963 aMsg += "this = "; 1964 aMsg += ByteString::CreateFromInt32((long)this); 1965 aMsg += " Level = "; 1966 aMsg += ByteString::CreateFromInt32(nRegLevel); 1967 aMsg += " SfxBindings::LeaveRegistrations "; 1968 if(pFile) { 1969 aMsg += "File: "; 1970 aMsg += pFile; 1971 aMsg += " Line: "; 1972 aMsg += ByteString::CreateFromInt32(nLine); 1973 } 1974 // FILE* pLog = fopen( "c:\\bindings.log", "a+w" ); 1975 // fwrite( aMsg.GetBuffer(), 1, aMsg.Len(), pLog ); 1976 // fclose( pLog ); 1977 DbgTrace( aMsg.GetBuffer() ); 1978 #endif 1979 } 1980 1981 //-------------------------------------------------------------------- 1982 1983 const SfxSlot* SfxBindings::GetSlot(sal_uInt16 nSlotId) 1984 { 1985 DBG_MEMTEST(); 1986 DBG_ASSERT( pImp->pCaches != 0, "SfxBindings not initialized" ); 1987 1988 // syncronisieren 1989 pDispatcher->Flush(); 1990 if ( pImp->bMsgDirty ) 1991 UpdateSlotServer_Impl(); 1992 1993 // get the cache for the specified function; return if not bound 1994 SfxStateCache* pCache = GetStateCache(nSlotId); 1995 return pCache && pCache->GetSlotServer(*pDispatcher, pImp->xProv)? 1996 pCache->GetSlotServer(*pDispatcher, pImp->xProv)->GetSlot(): 0; 1997 } 1998 1999 //-------------------------------------------------------------------- 2000 2001 void SfxBindings::SetDispatcher( SfxDispatcher *pDisp ) 2002 { 2003 SfxDispatcher *pOldDispat = pDispatcher; 2004 if ( pDisp != pDispatcher ) 2005 { 2006 if ( pOldDispat ) 2007 { 2008 SfxBindings* pBind = pOldDispat->GetBindings(); 2009 while ( pBind ) 2010 { 2011 if ( pBind->pImp->pSubBindings == this && pBind->pDispatcher != pDisp ) 2012 pBind->SetSubBindings_Impl( NULL ); 2013 pBind = pBind->pImp->pSubBindings; 2014 } 2015 } 2016 2017 pDispatcher = pDisp; 2018 2019 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XDispatchProvider > xProv; 2020 if ( pDisp ) 2021 xProv = ::com::sun::star::uno::Reference < ::com::sun::star::frame::XDispatchProvider > 2022 ( pDisp->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY ); 2023 2024 SetDispatchProvider_Impl( xProv ); 2025 InvalidateAll( sal_True ); 2026 InvalidateUnoControllers_Impl(); 2027 2028 if ( pDispatcher && !pOldDispat ) 2029 { 2030 if ( pImp->pSubBindings && pImp->pSubBindings->pDispatcher != pOldDispat ) 2031 { 2032 DBG_ERROR( "SubBindings vor Aktivieren schon gesetzt!" ); 2033 pImp->pSubBindings->ENTERREGISTRATIONS(); 2034 } 2035 LEAVEREGISTRATIONS(); 2036 } 2037 else if( !pDispatcher ) 2038 { 2039 ENTERREGISTRATIONS(); 2040 if ( pImp->pSubBindings && pImp->pSubBindings->pDispatcher != pOldDispat ) 2041 { 2042 DBG_ERROR( "SubBindings im Deaktivieren immer noch gesetzt!" ); 2043 pImp->pSubBindings->LEAVEREGISTRATIONS(); 2044 } 2045 } 2046 2047 Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) ); 2048 2049 if ( pDisp ) 2050 { 2051 SfxBindings* pBind = pDisp->GetBindings(); 2052 while ( pBind && pBind != this ) 2053 { 2054 if ( !pBind->pImp->pSubBindings ) 2055 { 2056 pBind->SetSubBindings_Impl( this ); 2057 break; 2058 } 2059 2060 pBind = pBind->pImp->pSubBindings; 2061 } 2062 } 2063 } 2064 } 2065 2066 //-------------------------------------------------------------------- 2067 2068 void SfxBindings::ClearCache_Impl( sal_uInt16 nSlotId ) 2069 { 2070 GetStateCache(nSlotId)->ClearCache(); 2071 } 2072 2073 //-------------------------------------------------------------------- 2074 void SfxBindings::StartUpdate_Impl( sal_Bool bComplete ) 2075 { 2076 if ( pImp->pSubBindings ) 2077 pImp->pSubBindings->StartUpdate_Impl( bComplete ); 2078 2079 if ( !bComplete ) 2080 // Update darf unterbrochen werden 2081 NextJob_Impl(&pImp->aTimer); 2082 else 2083 // alle Slots am St"uck updaten 2084 NextJob_Impl(0); 2085 } 2086 2087 //------------------------------------------------------------------------- 2088 2089 SfxItemState SfxBindings::QueryState( sal_uInt16 nSlot, SfxPoolItem* &rpState ) 2090 { 2091 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDisp; 2092 SfxStateCache *pCache = GetStateCache( nSlot ); 2093 if ( pCache ) 2094 xDisp = pCache->GetDispatch(); 2095 if ( xDisp.is() || !pCache ) 2096 { 2097 const SfxSlot* pSlot = SfxSlotPool::GetSlotPool( pDispatcher->GetFrame() ).GetSlot( nSlot ); 2098 if ( !pSlot || !pSlot->pUnoName ) 2099 return SFX_ITEM_DISABLED; 2100 2101 ::com::sun::star::util::URL aURL; 2102 ::rtl::OUString aCmd( DEFINE_CONST_UNICODE(".uno:")); 2103 aURL.Protocol = aCmd; 2104 aURL.Path = ::rtl::OUString::createFromAscii(pSlot->GetUnoName()); 2105 aCmd += aURL.Path; 2106 aURL.Complete = aCmd; 2107 aURL.Main = aCmd; 2108 2109 if ( !xDisp.is() ) 2110 xDisp = pImp->xProv->queryDispatch( aURL, ::rtl::OUString(), 0 ); 2111 2112 if ( xDisp.is() ) 2113 { 2114 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xTunnel( xDisp, ::com::sun::star::uno::UNO_QUERY ); 2115 SfxOfficeDispatch* pDisp = NULL; 2116 if ( xTunnel.is() ) 2117 { 2118 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier()); 2119 pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation )); 2120 } 2121 2122 if ( !pDisp ) 2123 { 2124 sal_Bool bDeleteCache = sal_False; 2125 if ( !pCache ) 2126 { 2127 pCache = new SfxStateCache( nSlot ); 2128 pCache->GetSlotServer( *GetDispatcher_Impl(), pImp->xProv ); 2129 bDeleteCache = sal_True; 2130 } 2131 2132 SfxItemState eState = SFX_ITEM_SET; 2133 SfxPoolItem *pItem=NULL; 2134 BindDispatch_Impl *pBind = new BindDispatch_Impl( xDisp, aURL, pCache, pSlot ); 2135 pBind->acquire(); 2136 xDisp->addStatusListener( pBind, aURL ); 2137 if ( !pBind->GetStatus().IsEnabled ) 2138 { 2139 eState = SFX_ITEM_DISABLED; 2140 } 2141 else 2142 { 2143 ::com::sun::star::uno::Any aAny = pBind->GetStatus().State; 2144 ::com::sun::star::uno::Type pType = aAny.getValueType(); 2145 2146 if ( pType == ::getBooleanCppuType() ) 2147 { 2148 sal_Bool bTemp = false; 2149 aAny >>= bTemp ; 2150 pItem = new SfxBoolItem( nSlot, bTemp ); 2151 } 2152 else if ( pType == ::getCppuType((const sal_uInt16*)0) ) 2153 { 2154 sal_uInt16 nTemp = 0; 2155 aAny >>= nTemp ; 2156 pItem = new SfxUInt16Item( nSlot, nTemp ); 2157 } 2158 else if ( pType == ::getCppuType((const sal_uInt32*)0) ) 2159 { 2160 sal_uInt32 nTemp = 0; 2161 aAny >>= nTemp ; 2162 pItem = new SfxUInt32Item( nSlot, nTemp ); 2163 } 2164 else if ( pType == ::getCppuType((const ::rtl::OUString*)0) ) 2165 { 2166 ::rtl::OUString sTemp ; 2167 aAny >>= sTemp ; 2168 pItem = new SfxStringItem( nSlot, sTemp ); 2169 } 2170 else 2171 pItem = new SfxVoidItem( nSlot ); 2172 } 2173 2174 xDisp->removeStatusListener( pBind, aURL ); 2175 pBind->Release(); 2176 rpState = pItem; 2177 if ( bDeleteCache ) 2178 DELETEZ( pCache ); 2179 return eState; 2180 } 2181 } 2182 } 2183 2184 // Dann am Dispatcher testen; da die von dort zur"uckgegebenen Items immer 2185 // DELETE_ON_IDLE sind, mu\s eine Kopie davon gezogen werden, um einen 2186 // Eigent"umer"ubergang zu erm"oglichen 2187 const SfxPoolItem *pItem = NULL; 2188 SfxItemState eState = pDispatcher->QueryState( nSlot, pItem ); 2189 if ( eState == SFX_ITEM_SET ) 2190 { 2191 DBG_ASSERT( pItem, "SFX_ITEM_SET aber kein Item!" ); 2192 if ( pItem ) 2193 rpState = pItem->Clone(); 2194 } 2195 else if ( eState == SFX_ITEM_AVAILABLE && pItem ) 2196 { 2197 rpState = pItem->Clone(); 2198 } 2199 2200 return eState; 2201 } 2202 2203 void SfxBindings::SetSubBindings_Impl( SfxBindings *pSub ) 2204 { 2205 if ( pImp->pSubBindings ) 2206 { 2207 pImp->pSubBindings->SetDispatchProvider_Impl( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > () ); 2208 pImp->pSubBindings->pImp->pSuperBindings = NULL; 2209 } 2210 2211 pImp->pSubBindings = pSub; 2212 2213 if ( pSub ) 2214 { 2215 pImp->pSubBindings->SetDispatchProvider_Impl( pImp->xProv ); 2216 pSub->pImp->pSuperBindings = this; 2217 } 2218 } 2219 2220 SfxBindings* SfxBindings::GetSubBindings_Impl( sal_Bool bTop ) const 2221 { 2222 SfxBindings *pRet = pImp->pSubBindings; 2223 if ( bTop ) 2224 { 2225 while ( pRet->pImp->pSubBindings ) 2226 pRet = pRet->pImp->pSubBindings; 2227 } 2228 2229 return pRet; 2230 } 2231 2232 void SfxBindings::SetWorkWindow_Impl( SfxWorkWindow* pWork ) 2233 { 2234 pImp->pWorkWin = pWork; 2235 } 2236 2237 SfxWorkWindow* SfxBindings::GetWorkWindow_Impl() const 2238 { 2239 return pImp->pWorkWin; 2240 } 2241 2242 void SfxBindings::RegisterUnoController_Impl( SfxUnoControllerItem* pControl ) 2243 { 2244 if ( !pImp->pUnoCtrlArr ) 2245 pImp->pUnoCtrlArr = new SfxUnoControllerArr_Impl; 2246 pImp->pUnoCtrlArr->Insert( pControl, pImp->pUnoCtrlArr->Count() ); 2247 } 2248 2249 void SfxBindings::ReleaseUnoController_Impl( SfxUnoControllerItem* pControl ) 2250 { 2251 if ( pImp->pUnoCtrlArr ) 2252 { 2253 sal_uInt16 nPos = pImp->pUnoCtrlArr->GetPos( pControl ); 2254 if ( nPos != 0xFFFF ) 2255 { 2256 pImp->pUnoCtrlArr->Remove( nPos ); 2257 return; 2258 } 2259 } 2260 2261 if ( pImp->pSubBindings ) 2262 pImp->pSubBindings->ReleaseUnoController_Impl( pControl ); 2263 } 2264 2265 void SfxBindings::InvalidateUnoControllers_Impl() 2266 { 2267 if ( pImp->pUnoCtrlArr ) 2268 { 2269 sal_uInt16 nCount = pImp->pUnoCtrlArr->Count(); 2270 for ( sal_uInt16 n=nCount; n>0; n-- ) 2271 { 2272 SfxUnoControllerItem *pCtrl = (*pImp->pUnoCtrlArr)[n-1]; 2273 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > xRef( (::cppu::OWeakObject*)pCtrl, ::com::sun::star::uno::UNO_QUERY ); 2274 pCtrl->ReleaseDispatch(); 2275 pCtrl->GetNewDispatch(); 2276 } 2277 } 2278 2279 if ( pImp->pSubBindings ) 2280 pImp->pSubBindings->InvalidateUnoControllers_Impl(); 2281 } 2282 2283 sal_Bool SfxBindings::IsInUpdate() const 2284 { 2285 sal_Bool bInUpdate = pImp->bInUpdate; 2286 if ( !bInUpdate && pImp->pSubBindings ) 2287 bInUpdate = pImp->pSubBindings->IsInUpdate(); 2288 return bInUpdate; 2289 } 2290 2291 void SfxBindings::SetVisibleState( sal_uInt16 nId, sal_Bool bShow ) 2292 { 2293 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDisp; 2294 SfxStateCache *pCache = GetStateCache( nId ); 2295 if ( pCache ) 2296 pCache->SetVisibleState( bShow ); 2297 } 2298 2299 void SfxBindings::SetActiveFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > & rFrame ) 2300 { 2301 if ( rFrame.is() || !pDispatcher ) 2302 SetDispatchProvider_Impl( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > ( rFrame, ::com::sun::star::uno::UNO_QUERY ) ); 2303 else 2304 SetDispatchProvider_Impl( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > ( 2305 pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), ::com::sun::star::uno::UNO_QUERY ) ); 2306 } 2307 2308 const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxBindings::GetActiveFrame() const 2309 { 2310 const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > xFrame( pImp->xProv, ::com::sun::star::uno::UNO_QUERY ); 2311 if ( xFrame.is() || !pDispatcher ) 2312 return xFrame; 2313 else 2314 return pDispatcher->GetFrame()->GetFrame().GetFrameInterface(); 2315 } 2316 2317 void SfxBindings::SetDispatchProvider_Impl( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > & rProv ) 2318 { 2319 sal_Bool bInvalidate = ( rProv != pImp->xProv ); 2320 if ( bInvalidate ) 2321 { 2322 pImp->xProv = rProv; 2323 InvalidateAll( sal_True ); 2324 InvalidateUnoControllers_Impl(); 2325 } 2326 2327 if ( pImp->pSubBindings ) 2328 pImp->pSubBindings->SetDispatchProvider_Impl( pImp->xProv ); 2329 } 2330 2331 const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > & SfxBindings::GetDispatchProvider_Impl() const 2332 { 2333 return pImp->xProv; 2334 } 2335 2336 SystemWindow* SfxBindings::GetSystemWindow() const 2337 { 2338 SfxViewFrame *pFrame = pDispatcher->GetFrame(); 2339 while ( pFrame->GetParentViewFrame_Impl() ) 2340 pFrame = pFrame->GetParentViewFrame_Impl(); 2341 SfxViewFrame* pTop = pFrame->GetTopViewFrame(); 2342 return pTop->GetFrame().GetTopWindow_Impl(); 2343 } 2344 2345 sal_Bool SfxBindings::ExecuteCommand_Impl( const String& rCommand ) 2346 { 2347 ::com::sun::star::util::URL aURL; 2348 aURL.Complete = rCommand; 2349 Reference < XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer" )), UNO_QUERY ); 2350 xTrans->parseStrict( aURL ); 2351 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDisp = pImp->xProv->queryDispatch( aURL, ::rtl::OUString(), 0 ); 2352 if ( xDisp.is() ) 2353 { 2354 if(::comphelper::UiEventsLogger::isEnabled()) //#i88653# 2355 { 2356 ::rtl::OUString sAppName; 2357 try 2358 { 2359 static ::rtl::OUString our_aModuleManagerName = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager"); 2360 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceManager = 2361 ::comphelper::getProcessServiceFactory(); 2362 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModuleManager > xModuleManager( 2363 xServiceManager->createInstance(our_aModuleManagerName) 2364 , ::com::sun::star::uno::UNO_QUERY_THROW); 2365 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame > xFrame( 2366 pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY_THROW); 2367 sAppName = xModuleManager->identify(xFrame); 2368 } catch(::com::sun::star::uno::Exception&) {} 2369 Sequence<beans::PropertyValue> source; 2370 ::comphelper::UiEventsLogger::appendDispatchOrigin(source, sAppName, ::rtl::OUString::createFromAscii("SfxAsyncExec")); 2371 ::comphelper::UiEventsLogger::logDispatch(aURL, source); 2372 } 2373 new SfxAsyncExec_Impl( aURL, xDisp ); 2374 return sal_True; 2375 } 2376 2377 return sal_False; 2378 } 2379 2380 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > SfxBindings::GetRecorder() const 2381 { 2382 return pImp->xRecorder; 2383 } 2384 2385 void SfxBindings::SetRecorder_Impl( com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder >& rRecorder ) 2386 { 2387 pImp->xRecorder = rRecorder; 2388 } 2389 2390 void SfxBindings::ContextChanged_Impl() 2391 { 2392 if ( !pImp->bInUpdate && ( !pImp->bContextChanged || !pImp->bAllMsgDirty ) ) 2393 { 2394 InvalidateAll( sal_True ); 2395 } 2396 } 2397 2398 uno::Reference < frame::XDispatch > SfxBindings::GetDispatch( const SfxSlot* pSlot, const util::URL& aURL, sal_Bool bMasterCommand ) 2399 { 2400 uno::Reference < frame::XDispatch > xRet; 2401 SfxStateCache* pCache = GetStateCache( pSlot->nSlotId ); 2402 if ( pCache && !bMasterCommand ) 2403 xRet = pCache->GetInternalDispatch(); 2404 if ( !xRet.is() ) 2405 { 2406 // dispatches for slaves are unbound, they don't have a state 2407 SfxOfficeDispatch* pDispatch = bMasterCommand ? 2408 new SfxOfficeDispatch( pDispatcher, pSlot, aURL ) : 2409 new SfxOfficeDispatch( *this, pDispatcher, pSlot, aURL ); 2410 2411 pDispatch->SetMasterUnoCommand( bMasterCommand ); 2412 xRet = uno::Reference < frame::XDispatch >( pDispatch ); 2413 if ( !pCache ) 2414 pCache = GetStateCache( pSlot->nSlotId ); 2415 2416 DBG_ASSERT( pCache, "No cache for OfficeDispatch!" ); 2417 if ( pCache && !bMasterCommand ) 2418 pCache->SetInternalDispatch( xRet ); 2419 } 2420 2421 return xRet; 2422 } 2423