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_framework.hxx" 26 #include <uiconfiguration/moduleuiconfigurationmanager.hxx> 27 #include <threadhelp/resetableguard.hxx> 28 #include <services.h> 29 #include <uielement/constitemcontainer.hxx> 30 #include <uielement/rootitemcontainer.hxx> 31 #include <uielement/uielementtypenames.hxx> 32 #include <framework/menuconfiguration.hxx> 33 #include <framework/toolboxconfiguration.hxx> 34 35 #ifndef __FRAMEWORK_XML_STATUSBARCONFIGURATION_HXX_ 36 #include <framework/statusbarconfiguration.hxx> 37 #endif 38 39 //_________________________________________________________________________________________________________________ 40 // interface includes 41 //_________________________________________________________________________________________________________________ 42 #include <com/sun/star/ui/UIElementType.hpp> 43 #include <com/sun/star/ui/ConfigurationEvent.hpp> 44 #include <com/sun/star/lang/DisposedException.hpp> 45 #include <com/sun/star/beans/XPropertySet.hpp> 46 #include <com/sun/star/embed/ElementModes.hpp> 47 #include <com/sun/star/container/XNameAccess.hpp> 48 #include <com/sun/star/io/XStream.hpp> 49 50 //_________________________________________________________________________________________________________________ 51 // other includes 52 //_________________________________________________________________________________________________________________ 53 54 #include <vcl/svapp.hxx> 55 #include <rtl/ustrbuf.hxx> 56 #include <comphelper/sequenceashashmap.hxx> 57 58 //_________________________________________________________________________________________________________________ 59 // namespaces 60 //_________________________________________________________________________________________________________________ 61 62 using rtl::OUString; 63 using namespace com::sun::star::uno; 64 using namespace com::sun::star::io; 65 using namespace com::sun::star::embed; 66 using namespace com::sun::star::lang; 67 using namespace com::sun::star::container; 68 using namespace com::sun::star::beans; 69 using namespace ::com::sun::star::ui; 70 71 namespace framework 72 { 73 74 //***************************************************************************************************************** 75 // XInterface, XTypeProvider, XServiceInfo 76 //***************************************************************************************************************** 77 DEFINE_XINTERFACE_8 ( ModuleUIConfigurationManager , 78 OWeakObject , 79 DIRECT_INTERFACE( css::lang::XTypeProvider ), 80 DIRECT_INTERFACE( css::lang::XServiceInfo ), 81 DIRECT_INTERFACE( css::lang::XComponent ), 82 DIRECT_INTERFACE( css::lang::XInitialization ), 83 DIRECT_INTERFACE( ::com::sun::star::ui::XUIConfiguration ), 84 DIRECT_INTERFACE( ::com::sun::star::ui::XUIConfigurationManager ), 85 DIRECT_INTERFACE( ::com::sun::star::ui::XModuleUIConfigurationManager ), 86 DIRECT_INTERFACE( ::com::sun::star::ui::XUIConfigurationPersistence ) 87 ) 88 89 DEFINE_XTYPEPROVIDER_8 ( ModuleUIConfigurationManager , 90 css::lang::XTypeProvider , 91 css::lang::XServiceInfo , 92 css::lang::XComponent , 93 css::lang::XInitialization , 94 ::com::sun::star::ui::XUIConfiguration , 95 ::com::sun::star::ui::XUIConfigurationManager , 96 ::com::sun::star::ui::XModuleUIConfigurationManager , 97 ::com::sun::star::ui::XUIConfigurationPersistence 98 ) 99 100 DEFINE_XSERVICEINFO_MULTISERVICE ( ModuleUIConfigurationManager , 101 ::cppu::OWeakObject , 102 SERVICENAME_MODULEUICONFIGURATIONMANAGER , 103 IMPLEMENTATIONNAME_MODULEUICONFIGURATIONMANAGER 104 ) 105 106 DEFINE_INIT_SERVICE ( ModuleUIConfigurationManager, {} ) 107 108 109 // important: The order and position of the elements must match the constant 110 // definition of "::com::sun::star::ui::UIElementType" 111 static const char* UIELEMENTTYPENAMES[] = 112 { 113 "", // Dummy value for unknown! 114 UIELEMENTTYPE_MENUBAR_NAME, 115 UIELEMENTTYPE_POPUPMENU_NAME, 116 UIELEMENTTYPE_TOOLBAR_NAME, 117 UIELEMENTTYPE_STATUSBAR_NAME, 118 UIELEMENTTYPE_FLOATINGWINDOW_NAME, 119 UIELEMENTTYPE_PROGRESSBAR_NAME, 120 UIELEMENTTYPE_TOOLPANEL_NAME 121 }; 122 123 static const char RESOURCEURL_PREFIX[] = "private:resource/"; 124 static const sal_Int32 RESOURCEURL_PREFIX_SIZE = 17; 125 static const char RESOURCEURL_CUSTOM_ELEMENT[] = "custom_"; 126 RetrieveTypeFromResourceURL(const rtl::OUString & aResourceURL)127 static sal_Int16 RetrieveTypeFromResourceURL( const rtl::OUString& aResourceURL ) 128 { 129 130 if (( aResourceURL.indexOf( OUString( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_PREFIX ))) == 0 ) && 131 ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE )) 132 { 133 OUString aTmpStr = aResourceURL.copy( RESOURCEURL_PREFIX_SIZE ); 134 sal_Int32 nIndex = aTmpStr.indexOf( '/' ); 135 if (( nIndex > 0 ) && ( aTmpStr.getLength() > nIndex )) 136 { 137 OUString aTypeStr( aTmpStr.copy( 0, nIndex )); 138 for ( int i = 0; i < UIElementType::COUNT; i++ ) 139 { 140 if ( aTypeStr.equalsAscii( UIELEMENTTYPENAMES[i] )) 141 return sal_Int16( i ); 142 } 143 } 144 } 145 146 return UIElementType::UNKNOWN; 147 } 148 RetrieveNameFromResourceURL(const rtl::OUString & aResourceURL)149 static OUString RetrieveNameFromResourceURL( const rtl::OUString& aResourceURL ) 150 { 151 if (( aResourceURL.indexOf( OUString( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_PREFIX ))) == 0 ) && 152 ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE )) 153 { 154 sal_Int32 nIndex = aResourceURL.lastIndexOf( '/' ); 155 if (( nIndex > 0 ) && (( nIndex+1 ) < aResourceURL.getLength())) 156 return aResourceURL.copy( nIndex+1 ); 157 } 158 159 return OUString(); 160 } 161 impl_fillSequenceWithElementTypeInfo(UIElementInfoHashMap & aUIElementInfoCollection,sal_Int16 nElementType)162 void ModuleUIConfigurationManager::impl_fillSequenceWithElementTypeInfo( UIElementInfoHashMap& aUIElementInfoCollection, sal_Int16 nElementType ) 163 { 164 // preload list of element types on demand 165 impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType ); 166 impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); 167 168 UIElementDataHashMap& rUserElements = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap; 169 UIElementDataHashMap::const_iterator pUserIter = rUserElements.begin(); 170 171 OUString aCustomUrlPrefix( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_CUSTOM_ELEMENT )); 172 while ( pUserIter != rUserElements.end() ) 173 { 174 sal_Int32 nIndex = pUserIter->second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX_SIZE ); 175 if ( nIndex > RESOURCEURL_PREFIX_SIZE ) 176 { 177 // Performance: Retrieve user interface name only for custom user interface elements. 178 // It's only used by them! 179 UIElementData* pDataSettings = impl_findUIElementData( pUserIter->second.aResourceURL, nElementType ); 180 if ( pDataSettings ) 181 { 182 // Retrieve user interface name from XPropertySet interface 183 rtl::OUString aUIName; 184 Reference< XPropertySet > xPropSet( pDataSettings->xSettings, UNO_QUERY ); 185 if ( xPropSet.is() ) 186 { 187 Any a = xPropSet->getPropertyValue( m_aPropUIName ); 188 a >>= aUIName; 189 } 190 191 UIElementInfo aInfo( pUserIter->second.aResourceURL, aUIName ); 192 aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pUserIter->second.aResourceURL, aInfo )); 193 } 194 } 195 else 196 { 197 // The user interface name for standard user interface elements is stored in the WindowState.xcu file 198 UIElementInfo aInfo( pUserIter->second.aResourceURL, OUString() ); 199 aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pUserIter->second.aResourceURL, aInfo )); 200 } 201 ++pUserIter; 202 } 203 204 UIElementDataHashMap& rDefaultElements = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; 205 UIElementDataHashMap::const_iterator pDefIter = rDefaultElements.begin(); 206 207 while ( pDefIter != rDefaultElements.end() ) 208 { 209 UIElementInfoHashMap::const_iterator pIterInfo = aUIElementInfoCollection.find( pDefIter->second.aResourceURL ); 210 if ( pIterInfo == aUIElementInfoCollection.end() ) 211 { 212 sal_Int32 nIndex = pDefIter->second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX_SIZE ); 213 if ( nIndex > RESOURCEURL_PREFIX_SIZE ) 214 { 215 // Performance: Retrieve user interface name only for custom user interface elements. 216 // It's only used by them! 217 UIElementData* pDataSettings = impl_findUIElementData( pDefIter->second.aResourceURL, nElementType ); 218 if ( pDataSettings ) 219 { 220 // Retrieve user interface name from XPropertySet interface 221 rtl::OUString aUIName; 222 Reference< XPropertySet > xPropSet( pDataSettings->xSettings, UNO_QUERY ); 223 if ( xPropSet.is() ) 224 { 225 Any a = xPropSet->getPropertyValue( m_aPropUIName ); 226 a >>= aUIName; 227 } 228 229 UIElementInfo aInfo( pDefIter->second.aResourceURL, aUIName ); 230 aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pDefIter->second.aResourceURL, aInfo )); 231 } 232 } 233 else 234 { 235 // The user interface name for standard user interface elements is stored in the WindowState.xcu file 236 UIElementInfo aInfo( pDefIter->second.aResourceURL, OUString() ); 237 aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pDefIter->second.aResourceURL, aInfo )); 238 } 239 } 240 241 ++pDefIter; 242 } 243 } 244 impl_preloadUIElementTypeList(Layer eLayer,sal_Int16 nElementType)245 void ModuleUIConfigurationManager::impl_preloadUIElementTypeList( Layer eLayer, sal_Int16 nElementType ) 246 { 247 UIElementType& rElementTypeData = m_aUIElements[eLayer][nElementType]; 248 249 if ( !rElementTypeData.bLoaded ) 250 { 251 Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage; 252 if ( xElementTypeStorage.is() ) 253 { 254 rtl::OUStringBuffer aBuf( RESOURCEURL_PREFIX_SIZE ); 255 aBuf.appendAscii( RESOURCEURL_PREFIX ); 256 aBuf.appendAscii( UIELEMENTTYPENAMES[ nElementType ] ); 257 aBuf.appendAscii( "/" ); 258 OUString aResURLPrefix( aBuf.makeStringAndClear() ); 259 260 UIElementDataHashMap& rHashMap = rElementTypeData.aElementsHashMap; 261 Reference< XNameAccess > xNameAccess( xElementTypeStorage, UNO_QUERY ); 262 Sequence< OUString > aUIElementNames = xNameAccess->getElementNames(); 263 for ( sal_Int32 n = 0; n < aUIElementNames.getLength(); n++ ) 264 { 265 UIElementData aUIElementData; 266 267 // Resource name must be without ".xml" 268 sal_Int32 nIndex = aUIElementNames[n].lastIndexOf( '.' ); 269 if (( nIndex > 0 ) && ( nIndex < aUIElementNames[n].getLength() )) 270 { 271 OUString aExtension( aUIElementNames[n].copy( nIndex+1 )); 272 OUString aUIElementName( aUIElementNames[n].copy( 0, nIndex )); 273 274 if (( aUIElementName.getLength() > 0 ) && 275 ( aExtension.equalsIgnoreAsciiCaseAsciiL( "xml", 3 ))) 276 { 277 aUIElementData.aResourceURL = aResURLPrefix + aUIElementName; 278 aUIElementData.aName = aUIElementNames[n]; 279 280 if ( eLayer == LAYER_USERDEFINED ) 281 { 282 aUIElementData.bModified = false; 283 aUIElementData.bDefault = false; 284 aUIElementData.bDefaultNode = false; 285 } 286 287 // Create hash_map entries for all user interface elements inside the storage. We don't load the 288 // settings to speed up the process. 289 rHashMap.insert( UIElementDataHashMap::value_type( aUIElementData.aResourceURL, aUIElementData )); 290 } 291 } 292 rElementTypeData.bLoaded = true; 293 } 294 } 295 } 296 297 //rElementTypeData.bLoaded = true; 298 } 299 impl_requestUIElementData(sal_Int16 nElementType,Layer eLayer,UIElementData & aUIElementData)300 void ModuleUIConfigurationManager::impl_requestUIElementData( sal_Int16 nElementType, Layer eLayer, UIElementData& aUIElementData ) 301 { 302 UIElementType& rElementTypeData = m_aUIElements[eLayer][nElementType]; 303 304 Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage; 305 if ( xElementTypeStorage.is() && aUIElementData.aName.getLength() ) 306 { 307 try 308 { 309 Reference< XStream > xStream = xElementTypeStorage->openStreamElement( aUIElementData.aName, ElementModes::READ ); 310 Reference< XInputStream > xInputStream = xStream->getInputStream(); 311 312 if ( xInputStream.is() ) 313 { 314 switch ( nElementType ) 315 { 316 case ::com::sun::star::ui::UIElementType::UNKNOWN: 317 break; 318 319 case ::com::sun::star::ui::UIElementType::MENUBAR: 320 { 321 try 322 { 323 MenuConfiguration aMenuCfg( m_xServiceManager ); 324 Reference< XIndexAccess > xContainer( aMenuCfg.CreateMenuBarConfigurationFromXML( xInputStream )); 325 RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xContainer ); 326 if ( pRootItemContainer ) 327 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); 328 else 329 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( xContainer, sal_True ) ), UNO_QUERY ); 330 return; 331 } 332 catch ( ::com::sun::star::lang::WrappedTargetException& ) 333 { 334 } 335 } 336 break; 337 338 case ::com::sun::star::ui::UIElementType::POPUPMENU: 339 { 340 break; 341 } 342 343 case ::com::sun::star::ui::UIElementType::TOOLBAR: 344 { 345 try 346 { 347 Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); 348 ToolBoxConfiguration::LoadToolBox( m_xServiceManager, xInputStream, xIndexContainer ); 349 RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xIndexContainer ); 350 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); 351 return; 352 } 353 catch ( ::com::sun::star::lang::WrappedTargetException& ) 354 { 355 } 356 357 break; 358 } 359 360 case ::com::sun::star::ui::UIElementType::STATUSBAR: 361 { 362 try 363 { 364 Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); 365 StatusBarConfiguration::LoadStatusBar( m_xServiceManager, xInputStream, xIndexContainer ); 366 RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xIndexContainer ); 367 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); 368 return; 369 } 370 catch ( ::com::sun::star::lang::WrappedTargetException& ) 371 { 372 } 373 374 break; 375 } 376 377 case ::com::sun::star::ui::UIElementType::FLOATINGWINDOW: 378 { 379 break; 380 } 381 } 382 } 383 } 384 catch ( ::com::sun::star::embed::InvalidStorageException& ) 385 { 386 } 387 catch ( ::com::sun::star::lang::IllegalArgumentException& ) 388 { 389 } 390 catch ( ::com::sun::star::io::IOException& ) 391 { 392 } 393 catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) 394 { 395 } 396 } 397 398 // At least we provide an empty settings container! 399 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer() ), UNO_QUERY ); 400 } 401 impl_findUIElementData(const rtl::OUString & aResourceURL,sal_Int16 nElementType,bool bLoad)402 ModuleUIConfigurationManager::UIElementData* ModuleUIConfigurationManager::impl_findUIElementData( const rtl::OUString& aResourceURL, sal_Int16 nElementType, bool bLoad ) 403 { 404 // preload list of element types on demand 405 impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType ); 406 impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); 407 408 // first try to look into our user-defined vector/hash_map combination 409 UIElementDataHashMap& rUserHashMap = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap; 410 UIElementDataHashMap::iterator pIter = rUserHashMap.find( aResourceURL ); 411 if ( pIter != rUserHashMap.end() ) 412 { 413 // Default data settings data must be retrieved from the default layer! 414 if ( !pIter->second.bDefault ) 415 { 416 if ( !pIter->second.xSettings.is() && bLoad ) 417 impl_requestUIElementData( nElementType, LAYER_USERDEFINED, pIter->second ); 418 return &(pIter->second); 419 } 420 } 421 422 // Not successfull, we have to look into our default vector/hash_map combination 423 UIElementDataHashMap& rDefaultHashMap = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; 424 pIter = rDefaultHashMap.find( aResourceURL ); 425 if ( pIter != rDefaultHashMap.end() ) 426 { 427 if ( !pIter->second.xSettings.is() && bLoad ) 428 impl_requestUIElementData( nElementType, LAYER_DEFAULT, pIter->second ); 429 return &(pIter->second); 430 } 431 432 // Nothing has been found! 433 return NULL; 434 } 435 impl_storeElementTypeData(Reference<XStorage> xStorage,UIElementType & rElementType,bool bResetModifyState)436 void ModuleUIConfigurationManager::impl_storeElementTypeData( Reference< XStorage > xStorage, UIElementType& rElementType, bool bResetModifyState ) 437 { 438 UIElementDataHashMap& rHashMap = rElementType.aElementsHashMap; 439 UIElementDataHashMap::iterator pIter = rHashMap.begin(); 440 441 while ( pIter != rHashMap.end() ) 442 { 443 UIElementData& rElement = pIter->second; 444 if ( rElement.bModified ) 445 { 446 if ( rElement.bDefault ) 447 { 448 xStorage->removeElement( rElement.aName ); 449 rElement.bModified = sal_False; // mark as not modified 450 } 451 else 452 { 453 Reference< XStream > xStream( xStorage->openStreamElement( rElement.aName, ElementModes::WRITE|ElementModes::TRUNCATE ), UNO_QUERY ); 454 Reference< XOutputStream > xOutputStream( xStream->getOutputStream() ); 455 456 if ( xOutputStream.is() ) 457 { 458 switch( rElementType.nElementType ) 459 { 460 case ::com::sun::star::ui::UIElementType::MENUBAR: 461 { 462 try 463 { 464 MenuConfiguration aMenuCfg( m_xServiceManager ); 465 aMenuCfg.StoreMenuBarConfigurationToXML( rElement.xSettings, xOutputStream ); 466 } 467 catch ( ::com::sun::star::lang::WrappedTargetException& ) 468 { 469 } 470 } 471 break; 472 473 case ::com::sun::star::ui::UIElementType::TOOLBAR: 474 { 475 try 476 { 477 ToolBoxConfiguration::StoreToolBox( m_xServiceManager, xOutputStream, rElement.xSettings ); 478 } 479 catch ( ::com::sun::star::lang::WrappedTargetException& ) 480 { 481 } 482 } 483 break; 484 485 case ::com::sun::star::ui::UIElementType::STATUSBAR: 486 { 487 try 488 { 489 StatusBarConfiguration::StoreStatusBar( m_xServiceManager, xOutputStream, rElement.xSettings ); 490 } 491 catch ( ::com::sun::star::lang::WrappedTargetException& ) 492 { 493 } 494 } 495 break; 496 497 default: 498 break; 499 } 500 } 501 502 // mark as not modified if we store to our own storage 503 if ( bResetModifyState ) 504 rElement.bModified = sal_False; 505 } 506 } 507 508 ++pIter; 509 } 510 511 // commit element type storage 512 Reference< XTransactedObject > xTransactedObject( xStorage, UNO_QUERY ); 513 if ( xTransactedObject.is() ) 514 xTransactedObject->commit(); 515 516 // mark UIElementType as not modified if we store to our own storage 517 if ( bResetModifyState ) 518 rElementType.bModified = sal_False; 519 } 520 521 // This is only allowed to be called on the LAYER_USER_DEFINED! impl_resetElementTypeData(UIElementType & rUserElementType,UIElementType & rDefaultElementType,ConfigEventNotifyContainer & rRemoveNotifyContainer,ConfigEventNotifyContainer & rReplaceNotifyContainer)522 void ModuleUIConfigurationManager::impl_resetElementTypeData( 523 UIElementType& rUserElementType, 524 UIElementType& rDefaultElementType, 525 ConfigEventNotifyContainer& rRemoveNotifyContainer, 526 ConfigEventNotifyContainer& rReplaceNotifyContainer ) 527 { 528 UIElementDataHashMap& rHashMap = rUserElementType.aElementsHashMap; 529 UIElementDataHashMap::iterator pIter = rHashMap.begin(); 530 531 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 532 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 533 Reference< XNameAccess > xDefaultNameAccess( rDefaultElementType.xStorage, UNO_QUERY ); 534 sal_Int16 nType = rUserElementType.nElementType; 535 536 // Make copies of the event structures to be thread-safe. We have to unlock our mutex before calling 537 // our listeners! 538 while ( pIter != rHashMap.end() ) 539 { 540 UIElementData& rElement = pIter->second; 541 if ( !rElement.bDefault ) 542 { 543 if ( xDefaultNameAccess->hasByName( rElement.aName )) 544 { 545 // Replace settings with data from default layer 546 Reference< XIndexAccess > xOldSettings( rElement.xSettings ); 547 impl_requestUIElementData( nType, LAYER_DEFAULT, rElement ); 548 549 ConfigurationEvent aReplaceEvent; 550 aReplaceEvent.ResourceURL = rElement.aResourceURL; 551 aReplaceEvent.Accessor <<= xThis; 552 aReplaceEvent.Source = xIfac; 553 aReplaceEvent.ReplacedElement <<= xOldSettings; 554 aReplaceEvent.Element <<= rElement.xSettings; 555 556 rReplaceNotifyContainer.push_back( aReplaceEvent ); 557 558 // Mark element as default and not modified. That means "not active" 559 // in the user layer anymore. 560 rElement.bModified = false; 561 rElement.bDefault = true; 562 } 563 else 564 { 565 // Remove user-defined settings from user layer 566 ConfigurationEvent aEvent; 567 aEvent.ResourceURL = rElement.aResourceURL; 568 aEvent.Accessor <<= xThis; 569 aEvent.Source = xIfac; 570 aEvent.Element <<= rElement.xSettings; 571 572 rRemoveNotifyContainer.push_back( aEvent ); 573 574 // Mark element as default and not modified. That means "not active" 575 // in the user layer anymore. 576 rElement.bModified = false; 577 rElement.bDefault = true; 578 } 579 } 580 581 ++pIter; 582 } 583 584 // Remove all settings from our user interface elements 585 rHashMap.clear(); 586 } 587 impl_reloadElementTypeData(UIElementType & rUserElementType,UIElementType & rDefaultElementType,ConfigEventNotifyContainer & rRemoveNotifyContainer,ConfigEventNotifyContainer & rReplaceNotifyContainer)588 void ModuleUIConfigurationManager::impl_reloadElementTypeData( 589 UIElementType& rUserElementType, 590 UIElementType& rDefaultElementType, 591 ConfigEventNotifyContainer& rRemoveNotifyContainer, 592 ConfigEventNotifyContainer& rReplaceNotifyContainer ) 593 { 594 UIElementDataHashMap& rHashMap = rUserElementType.aElementsHashMap; 595 UIElementDataHashMap::iterator pIter = rHashMap.begin(); 596 Reference< XStorage > xUserStorage( rUserElementType.xStorage ); 597 Reference< XStorage > xDefaultStorage( rDefaultElementType.xStorage ); 598 Reference< XNameAccess > xUserNameAccess( rUserElementType.xStorage, UNO_QUERY ); 599 Reference< XNameAccess > xDefaultNameAccess( rDefaultElementType.xStorage, UNO_QUERY ); 600 601 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 602 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 603 sal_Int16 nType = rUserElementType.nElementType; 604 605 while ( pIter != rHashMap.end() ) 606 { 607 UIElementData& rElement = pIter->second; 608 if ( rElement.bModified ) 609 { 610 if ( xUserNameAccess->hasByName( rElement.aName )) 611 { 612 // Replace settings with data from user layer 613 Reference< XIndexAccess > xOldSettings( rElement.xSettings ); 614 615 impl_requestUIElementData( nType, LAYER_USERDEFINED, rElement ); 616 617 ConfigurationEvent aReplaceEvent; 618 619 aReplaceEvent.ResourceURL = rElement.aResourceURL; 620 aReplaceEvent.Accessor <<= xThis; 621 aReplaceEvent.Source = xIfac; 622 aReplaceEvent.ReplacedElement <<= xOldSettings; 623 aReplaceEvent.Element <<= rElement.xSettings; 624 rReplaceNotifyContainer.push_back( aReplaceEvent ); 625 626 rElement.bModified = false; 627 } 628 else if ( xDefaultNameAccess->hasByName( rElement.aName )) 629 { 630 // Replace settings with data from default layer 631 Reference< XIndexAccess > xOldSettings( rElement.xSettings ); 632 633 impl_requestUIElementData( nType, LAYER_DEFAULT, rElement ); 634 635 ConfigurationEvent aReplaceEvent; 636 637 aReplaceEvent.ResourceURL = rElement.aResourceURL; 638 aReplaceEvent.Accessor <<= xThis; 639 aReplaceEvent.Source = xIfac; 640 aReplaceEvent.ReplacedElement <<= xOldSettings; 641 aReplaceEvent.Element <<= rElement.xSettings; 642 rReplaceNotifyContainer.push_back( aReplaceEvent ); 643 644 // Mark element as default and not modified. That means "not active" 645 // in the user layer anymore. 646 rElement.bModified = false; 647 rElement.bDefault = true; 648 } 649 else 650 { 651 // Element settings are not in any storage => remove 652 ConfigurationEvent aRemoveEvent; 653 654 aRemoveEvent.ResourceURL = rElement.aResourceURL; 655 aRemoveEvent.Accessor <<= xThis; 656 aRemoveEvent.Source = xIfac; 657 aRemoveEvent.Element <<= rElement.xSettings; 658 659 rRemoveNotifyContainer.push_back( aRemoveEvent ); 660 661 // Mark element as default and not modified. That means "not active" 662 // in the user layer anymore. 663 rElement.bModified = false; 664 rElement.bDefault = true; 665 } 666 } 667 ++pIter; 668 } 669 670 rUserElementType.bModified = sal_False; 671 } 672 impl_Initialize()673 void ModuleUIConfigurationManager::impl_Initialize() 674 { 675 // Initialize the top-level structures with the storage data 676 if ( m_xUserConfigStorage.is() ) 677 { 678 // Try to access our module sub folder 679 for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; 680 i++ ) 681 { 682 Reference< XStorage > xElementTypeStorage; 683 try 684 { 685 if ( m_pStorageHandler[i] ) 686 xElementTypeStorage = m_pStorageHandler[i]->getWorkingStorageUser(); 687 } 688 catch ( com::sun::star::container::NoSuchElementException& ) 689 { 690 } 691 catch ( ::com::sun::star::embed::InvalidStorageException& ) 692 { 693 } 694 catch ( ::com::sun::star::lang::IllegalArgumentException& ) 695 { 696 } 697 catch ( ::com::sun::star::io::IOException& ) 698 { 699 } 700 catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) 701 { 702 } 703 704 m_aUIElements[LAYER_USERDEFINED][i].nElementType = i; 705 m_aUIElements[LAYER_USERDEFINED][i].bModified = false; 706 m_aUIElements[LAYER_USERDEFINED][i].xStorage = xElementTypeStorage; 707 m_aUIElements[LAYER_USERDEFINED][i].bDefaultLayer = false; 708 } 709 } 710 711 if ( m_xDefaultConfigStorage.is() ) 712 { 713 Reference< XNameAccess > xNameAccess( m_xDefaultConfigStorage, UNO_QUERY_THROW ); 714 715 // Try to access our module sub folder 716 for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; 717 i++ ) 718 { 719 Reference< XStorage > xElementTypeStorage; 720 try 721 { 722 const OUString sName( OUString::createFromAscii( UIELEMENTTYPENAMES[i] ) ); 723 if( xNameAccess->hasByName( sName ) ) 724 xNameAccess->getByName( sName ) >>= xElementTypeStorage; 725 } 726 catch ( com::sun::star::container::NoSuchElementException& ) 727 { 728 } 729 730 m_aUIElements[LAYER_DEFAULT][i].nElementType = i; 731 m_aUIElements[LAYER_DEFAULT][i].bModified = false; 732 m_aUIElements[LAYER_DEFAULT][i].xStorage = xElementTypeStorage; 733 m_aUIElements[LAYER_DEFAULT][i].bDefaultLayer = true; 734 } 735 } 736 } 737 ModuleUIConfigurationManager(com::sun::star::uno::Reference<com::sun::star::lang::XMultiServiceFactory> xServiceManager)738 ModuleUIConfigurationManager::ModuleUIConfigurationManager( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > xServiceManager ) : 739 ThreadHelpBase( &Application::GetSolarMutex() ) 740 , m_xDefaultConfigStorage( 0 ) 741 , m_xUserConfigStorage( 0 ) 742 , m_bReadOnly( true ) 743 , m_bInitialized( false ) 744 , m_bModified( false ) 745 , m_bConfigRead( false ) 746 , m_bDisposed( false ) 747 , m_aXMLPostfix( RTL_CONSTASCII_USTRINGPARAM( ".xml" )) 748 , m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( "UIName" )) 749 , m_aPropResourceURL( RTL_CONSTASCII_USTRINGPARAM( "ResourceURL" )) 750 , m_xServiceManager( xServiceManager ) 751 , m_aListenerContainer( m_aLock.getShareableOslMutex() ) 752 { 753 for ( int i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 754 m_pStorageHandler[i] = 0; 755 756 // Make sure we have a default initialized entry for every layer and user interface element type! 757 // The following code depends on this! 758 m_aUIElements[LAYER_DEFAULT].resize( ::com::sun::star::ui::UIElementType::COUNT ); 759 m_aUIElements[LAYER_USERDEFINED].resize( ::com::sun::star::ui::UIElementType::COUNT ); 760 } 761 ~ModuleUIConfigurationManager()762 ModuleUIConfigurationManager::~ModuleUIConfigurationManager() 763 { 764 for ( int i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 765 delete m_pStorageHandler[i]; 766 } 767 768 // XComponent dispose()769 void SAL_CALL ModuleUIConfigurationManager::dispose() throw (::com::sun::star::uno::RuntimeException) 770 { 771 Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY ); 772 773 css::lang::EventObject aEvent( xThis ); 774 m_aListenerContainer.disposeAndClear( aEvent ); 775 776 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 777 ResetableGuard aGuard( m_aLock ); 778 Reference< XComponent > xModuleImageManager( m_xModuleImageManager ); 779 m_xModuleImageManager.clear(); 780 Reference< XComponent > xCompMAM( m_xModuleAcceleratorManager, UNO_QUERY ); 781 if ( xCompMAM.is() ) 782 xCompMAM->dispose(); 783 m_xModuleAcceleratorManager.clear(); 784 m_aUIElements[LAYER_USERDEFINED].clear(); 785 m_aUIElements[LAYER_DEFAULT].clear(); 786 m_xDefaultConfigStorage.clear(); 787 m_xUserConfigStorage.clear(); 788 m_xUserRootCommit.clear(); 789 m_bConfigRead = false; 790 m_bModified = false; 791 m_bDisposed = true; 792 aGuard.unlock(); 793 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 794 795 try 796 { 797 if ( xModuleImageManager.is() ) 798 xModuleImageManager->dispose(); 799 } 800 catch ( Exception& ) 801 { 802 } 803 } 804 addEventListener(const Reference<XEventListener> & xListener)805 void SAL_CALL ModuleUIConfigurationManager::addEventListener( const Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 806 { 807 { 808 ResetableGuard aGuard( m_aLock ); 809 810 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 811 if ( m_bDisposed ) 812 throw DisposedException(); 813 } 814 815 m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); 816 } 817 removeEventListener(const Reference<XEventListener> & xListener)818 void SAL_CALL ModuleUIConfigurationManager::removeEventListener( const Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 819 { 820 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 821 m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); 822 } 823 824 // XInitialization initialize(const Sequence<Any> & aArguments)825 void SAL_CALL ModuleUIConfigurationManager::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException ) 826 { 827 ResetableGuard aLock( m_aLock ); 828 829 if ( !m_bInitialized ) 830 { 831 ::comphelper::SequenceAsHashMap lArgs(aArguments); 832 m_aModuleIdentifier = lArgs.getUnpackedValueOrDefault(::rtl::OUString::createFromAscii("ModuleIdentifier"), ::rtl::OUString()); 833 m_aModuleShortName = lArgs.getUnpackedValueOrDefault(::rtl::OUString::createFromAscii("ModuleShortName"), ::rtl::OUString()); 834 835 for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 836 { 837 rtl::OUString aResourceType; 838 if ( i == ::com::sun::star::ui::UIElementType::MENUBAR ) 839 aResourceType = PresetHandler::RESOURCETYPE_MENUBAR(); 840 else if ( i == ::com::sun::star::ui::UIElementType::TOOLBAR ) 841 aResourceType = PresetHandler::RESOURCETYPE_TOOLBAR(); 842 else if ( i == ::com::sun::star::ui::UIElementType::STATUSBAR ) 843 aResourceType = PresetHandler::RESOURCETYPE_STATUSBAR(); 844 845 if ( aResourceType.getLength() > 0 ) 846 { 847 m_pStorageHandler[i] = new PresetHandler( m_xServiceManager ); 848 m_pStorageHandler[i]->connectToResource( PresetHandler::E_MODULES, 849 aResourceType, // this path wont be used later ... seee next lines! 850 m_aModuleShortName, 851 css::uno::Reference< css::embed::XStorage >()); // no document root used here! 852 } 853 } 854 855 // initialize root storages for all resource types 856 m_xUserRootCommit = css::uno::Reference< css::embed::XTransactedObject >( 857 m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getOrCreateRootStorageUser(), css::uno::UNO_QUERY); // can be empty 858 m_xDefaultConfigStorage = m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getParentStorageShare( 859 m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getWorkingStorageShare()); 860 m_xUserConfigStorage = m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getParentStorageUser( 861 m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getWorkingStorageUser()); 862 863 if ( m_xUserConfigStorage.is() ) 864 { 865 Reference< XPropertySet > xPropSet( m_xUserConfigStorage, UNO_QUERY ); 866 if ( xPropSet.is() ) 867 { 868 long nOpenMode = 0; 869 Any a = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ))); 870 if ( a >>= nOpenMode ) 871 m_bReadOnly = !( nOpenMode & ElementModes::WRITE ); 872 } 873 } 874 875 impl_Initialize(); 876 877 m_bInitialized = true; 878 } 879 } 880 881 // XUIConfiguration addConfigurationListener(const Reference<::com::sun::star::ui::XUIConfigurationListener> & xListener)882 void SAL_CALL ModuleUIConfigurationManager::addConfigurationListener( const Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 883 { 884 { 885 ResetableGuard aGuard( m_aLock ); 886 887 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 888 if ( m_bDisposed ) 889 throw DisposedException(); 890 } 891 892 m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XUIConfigurationListener >* ) NULL ), xListener ); 893 } 894 removeConfigurationListener(const Reference<::com::sun::star::ui::XUIConfigurationListener> & xListener)895 void SAL_CALL ModuleUIConfigurationManager::removeConfigurationListener( const Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 896 { 897 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 898 m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XUIConfigurationListener >* ) NULL ), xListener ); 899 } 900 901 902 // XUIConfigurationManager reset()903 void SAL_CALL ModuleUIConfigurationManager::reset() throw (::com::sun::star::uno::RuntimeException) 904 { 905 ResetableGuard aGuard( m_aLock ); 906 907 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 908 if ( m_bDisposed ) 909 throw DisposedException(); 910 911 bool bResetStorage( false ); 912 913 if ( !isReadOnly() ) 914 { 915 // Remove all elements from our user-defined storage! 916 try 917 { 918 for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 919 { 920 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; 921 Reference< XStorage > xSubStorage( rElementType.xStorage, UNO_QUERY ); 922 923 if ( xSubStorage.is() ) 924 { 925 bool bCommitSubStorage( false ); 926 Reference< XNameAccess > xSubStorageNameAccess( xSubStorage, UNO_QUERY ); 927 Sequence< OUString > aUIElementStreamNames = xSubStorageNameAccess->getElementNames(); 928 for ( sal_Int32 j = 0; j < aUIElementStreamNames.getLength(); j++ ) 929 { 930 xSubStorage->removeElement( aUIElementStreamNames[j] ); 931 bCommitSubStorage = true; 932 } 933 934 if ( bCommitSubStorage ) 935 { 936 Reference< XTransactedObject > xTransactedObject( xSubStorage, UNO_QUERY ); 937 if ( xTransactedObject.is() ) 938 xTransactedObject->commit(); 939 m_pStorageHandler[i]->commitUserChanges(); 940 } 941 } 942 } 943 944 bResetStorage = true; 945 946 // remove settings from user defined layer and notify listener about removed settings data! 947 ConfigEventNotifyContainer aRemoveEventNotifyContainer; 948 ConfigEventNotifyContainer aReplaceEventNotifyContainer; 949 for ( sal_Int16 j = 1; j < ::com::sun::star::ui::UIElementType::COUNT; j++ ) 950 { 951 try 952 { 953 UIElementType& rUserElementType = m_aUIElements[LAYER_USERDEFINED][j]; 954 UIElementType& rDefaultElementType = m_aUIElements[LAYER_DEFAULT][j]; 955 956 impl_resetElementTypeData( rUserElementType, rDefaultElementType, aRemoveEventNotifyContainer, aReplaceEventNotifyContainer ); 957 rUserElementType.bModified = sal_False; 958 } 959 catch ( Exception& ) 960 { 961 throw IOException(); 962 } 963 } 964 965 m_bModified = sal_False; 966 967 // Unlock mutex before notify our listeners 968 aGuard.unlock(); 969 970 // Notify our listeners 971 sal_uInt32 k = 0; 972 for ( k = 0; k < aRemoveEventNotifyContainer.size(); k++ ) 973 implts_notifyContainerListener( aRemoveEventNotifyContainer[k], NotifyOp_Remove ); 974 for ( k = 0; k < aReplaceEventNotifyContainer.size(); k++ ) 975 implts_notifyContainerListener( aReplaceEventNotifyContainer[k], NotifyOp_Replace ); 976 } 977 catch ( ::com::sun::star::lang::IllegalArgumentException& ) 978 { 979 } 980 catch ( ::com::sun::star::container::NoSuchElementException& ) 981 { 982 } 983 catch ( ::com::sun::star::embed::InvalidStorageException& ) 984 { 985 } 986 catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) 987 { 988 } 989 } 990 } 991 getUIElementsInfo(sal_Int16 ElementType)992 Sequence< Sequence< PropertyValue > > SAL_CALL ModuleUIConfigurationManager::getUIElementsInfo( sal_Int16 ElementType ) 993 throw ( IllegalArgumentException, RuntimeException ) 994 { 995 if (( ElementType < 0 ) || ( ElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 996 throw IllegalArgumentException(); 997 998 ResetableGuard aGuard( m_aLock ); 999 if ( m_bDisposed ) 1000 throw DisposedException(); 1001 1002 Sequence< Sequence< PropertyValue > > aElementInfoSeq; 1003 UIElementInfoHashMap aUIElementInfoCollection; 1004 1005 if ( ElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) 1006 { 1007 for ( sal_Int16 i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 1008 impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, sal_Int16( i ) ); 1009 } 1010 else 1011 impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, ElementType ); 1012 1013 Sequence< PropertyValue > aUIElementInfo( 2 ); 1014 aUIElementInfo[0].Name = m_aPropResourceURL; 1015 aUIElementInfo[1].Name = m_aPropUIName; 1016 1017 aElementInfoSeq.realloc( aUIElementInfoCollection.size() ); 1018 UIElementInfoHashMap::const_iterator pIter = aUIElementInfoCollection.begin(); 1019 1020 sal_Int32 n = 0; 1021 while ( pIter != aUIElementInfoCollection.end() ) 1022 { 1023 aUIElementInfo[0].Value <<= pIter->second.aResourceURL; 1024 aUIElementInfo[1].Value <<= pIter->second.aUIName; 1025 aElementInfoSeq[n++] = aUIElementInfo; 1026 ++pIter; 1027 } 1028 1029 return aElementInfoSeq; 1030 } 1031 createSettings()1032 Reference< XIndexContainer > SAL_CALL ModuleUIConfigurationManager::createSettings() throw (::com::sun::star::uno::RuntimeException) 1033 { 1034 ResetableGuard aGuard( m_aLock ); 1035 1036 if ( m_bDisposed ) 1037 throw DisposedException(); 1038 1039 // Creates an empty item container which can be filled from outside 1040 return Reference< XIndexContainer >( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); 1041 } 1042 hasSettings(const::rtl::OUString & ResourceURL)1043 sal_Bool SAL_CALL ModuleUIConfigurationManager::hasSettings( const ::rtl::OUString& ResourceURL ) 1044 throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) 1045 { 1046 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1047 1048 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1049 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1050 throw IllegalArgumentException(); 1051 else 1052 { 1053 ResetableGuard aGuard( m_aLock ); 1054 1055 if ( m_bDisposed ) 1056 throw DisposedException(); 1057 1058 UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType, false ); 1059 if ( pDataSettings ) 1060 return sal_True; 1061 } 1062 1063 return sal_False; 1064 } 1065 getSettings(const::rtl::OUString & ResourceURL,sal_Bool bWriteable)1066 Reference< XIndexAccess > SAL_CALL ModuleUIConfigurationManager::getSettings( const ::rtl::OUString& ResourceURL, sal_Bool bWriteable ) 1067 throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) 1068 { 1069 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1070 1071 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1072 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1073 throw IllegalArgumentException(); 1074 else 1075 { 1076 ResetableGuard aGuard( m_aLock ); 1077 1078 if ( m_bDisposed ) 1079 throw DisposedException(); 1080 1081 UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); 1082 if ( pDataSettings ) 1083 { 1084 // Create a copy of our data if someone wants to change the data. 1085 if ( bWriteable ) 1086 return Reference< XIndexAccess >( static_cast< OWeakObject * >( new RootItemContainer( pDataSettings->xSettings ) ), UNO_QUERY ); 1087 else 1088 return pDataSettings->xSettings; 1089 } 1090 } 1091 1092 throw NoSuchElementException(); 1093 } 1094 replaceSettings(const::rtl::OUString & ResourceURL,const Reference<::com::sun::star::container::XIndexAccess> & aNewData)1095 void SAL_CALL ModuleUIConfigurationManager::replaceSettings( const ::rtl::OUString& ResourceURL, const Reference< ::com::sun::star::container::XIndexAccess >& aNewData ) 1096 throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException) 1097 { 1098 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1099 1100 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1101 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1102 throw IllegalArgumentException(); 1103 else if ( m_bReadOnly ) 1104 throw IllegalAccessException(); 1105 else 1106 { 1107 ResetableGuard aGuard( m_aLock ); 1108 1109 if ( m_bDisposed ) 1110 throw DisposedException(); 1111 1112 UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); 1113 if ( pDataSettings ) 1114 { 1115 if ( !pDataSettings->bDefaultNode ) 1116 { 1117 // we have a settings entry in our user-defined layer - replace 1118 Reference< XIndexAccess > xOldSettings = pDataSettings->xSettings; 1119 1120 // Create a copy of the data if the container is not const 1121 Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); 1122 if ( xReplace.is() ) 1123 pDataSettings->xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); 1124 else 1125 pDataSettings->xSettings = aNewData; 1126 pDataSettings->bDefault = false; 1127 pDataSettings->bModified = true; 1128 m_bModified = true; 1129 1130 // Modify type container 1131 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; 1132 rElementType.bModified = true; 1133 1134 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 1135 1136 // Create event to notify listener about replaced element settings 1137 ConfigurationEvent aEvent; 1138 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 1139 1140 aEvent.ResourceURL = ResourceURL; 1141 aEvent.Accessor <<= xThis; 1142 aEvent.Source = xIfac; 1143 aEvent.ReplacedElement <<= xOldSettings; 1144 aEvent.Element <<= pDataSettings->xSettings; 1145 1146 aGuard.unlock(); 1147 1148 implts_notifyContainerListener( aEvent, NotifyOp_Replace ); 1149 } 1150 else 1151 { 1152 // we have no settings in our user-defined layer - insert 1153 UIElementData aUIElementData; 1154 1155 aUIElementData.bDefault = false; 1156 aUIElementData.bDefaultNode = false; 1157 aUIElementData.bModified = true; 1158 1159 // Create a copy of the data if the container is not const 1160 Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); 1161 if ( xReplace.is() ) 1162 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); 1163 else 1164 aUIElementData.xSettings = aNewData; 1165 aUIElementData.aName = RetrieveNameFromResourceURL( ResourceURL ) + m_aXMLPostfix; 1166 aUIElementData.aResourceURL = ResourceURL; 1167 m_bModified = true; 1168 1169 // Modify type container 1170 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; 1171 rElementType.bModified = true; 1172 1173 UIElementDataHashMap& rElements = rElementType.aElementsHashMap; 1174 1175 // Check our user element settings hash map as it can already contain settings that have been set to default! 1176 // If no node can be found, we have to insert it. 1177 UIElementDataHashMap::iterator pIter = rElements.find( ResourceURL ); 1178 if ( pIter != rElements.end() ) 1179 pIter->second = aUIElementData; 1180 else 1181 rElements.insert( UIElementDataHashMap::value_type( ResourceURL, aUIElementData )); 1182 1183 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 1184 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 1185 1186 // Create event to notify listener about replaced element settings 1187 ConfigurationEvent aEvent; 1188 1189 aEvent.ResourceURL = ResourceURL; 1190 aEvent.Accessor <<= xThis; 1191 aEvent.Source = xIfac; 1192 aEvent.ReplacedElement <<= pDataSettings->xSettings; 1193 aEvent.Element <<= aUIElementData.xSettings; 1194 1195 aGuard.unlock(); 1196 1197 implts_notifyContainerListener( aEvent, NotifyOp_Replace ); 1198 } 1199 } 1200 else 1201 throw NoSuchElementException(); 1202 } 1203 } 1204 removeSettings(const::rtl::OUString & ResourceURL)1205 void SAL_CALL ModuleUIConfigurationManager::removeSettings( const ::rtl::OUString& ResourceURL ) 1206 throw ( NoSuchElementException, IllegalArgumentException, IllegalAccessException, RuntimeException) 1207 { 1208 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1209 1210 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1211 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1212 throw IllegalArgumentException(); 1213 else if ( m_bReadOnly ) 1214 throw IllegalAccessException(); 1215 else 1216 { 1217 ResetableGuard aGuard( m_aLock ); 1218 1219 if ( m_bDisposed ) 1220 throw DisposedException(); 1221 1222 UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); 1223 if ( pDataSettings ) 1224 { 1225 // If element settings are default, we don't need to change anything! 1226 if ( pDataSettings->bDefault ) 1227 return; 1228 else 1229 { 1230 Reference< XIndexAccess > xRemovedSettings = pDataSettings->xSettings; 1231 pDataSettings->bDefault = true; 1232 1233 // check if this is a default layer node 1234 if ( !pDataSettings->bDefaultNode ) 1235 pDataSettings->bModified = true; // we have to remove this node from the user layer! 1236 pDataSettings->xSettings.clear(); 1237 m_bModified = true; // user layer must be written 1238 1239 // Modify type container 1240 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; 1241 rElementType.bModified = true; 1242 1243 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 1244 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 1245 1246 // Check if we have settings in the default layer which replaces the user-defined one! 1247 UIElementData* pDefaultDataSettings = impl_findUIElementData( ResourceURL, nElementType ); 1248 if ( pDefaultDataSettings ) 1249 { 1250 // Create event to notify listener about replaced element settings 1251 ConfigurationEvent aEvent; 1252 1253 aEvent.ResourceURL = ResourceURL; 1254 aEvent.Accessor <<= xThis; 1255 aEvent.Source = xIfac; 1256 aEvent.Element <<= xRemovedSettings; 1257 aEvent.ReplacedElement <<= pDefaultDataSettings->xSettings; 1258 1259 aGuard.unlock(); 1260 1261 implts_notifyContainerListener( aEvent, NotifyOp_Replace ); 1262 } 1263 else 1264 { 1265 // Create event to notify listener about removed element settings 1266 ConfigurationEvent aEvent; 1267 1268 aEvent.ResourceURL = ResourceURL; 1269 aEvent.Accessor <<= xThis; 1270 aEvent.Source = xIfac; 1271 aEvent.Element <<= xRemovedSettings; 1272 1273 aGuard.unlock(); 1274 1275 implts_notifyContainerListener( aEvent, NotifyOp_Remove ); 1276 } 1277 } 1278 } 1279 else 1280 throw NoSuchElementException(); 1281 } 1282 } 1283 insertSettings(const::rtl::OUString & NewResourceURL,const Reference<XIndexAccess> & aNewData)1284 void SAL_CALL ModuleUIConfigurationManager::insertSettings( const ::rtl::OUString& NewResourceURL, const Reference< XIndexAccess >& aNewData ) 1285 throw ( ElementExistException, IllegalArgumentException, IllegalAccessException, RuntimeException ) 1286 { 1287 sal_Int16 nElementType = RetrieveTypeFromResourceURL( NewResourceURL ); 1288 1289 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1290 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1291 throw IllegalArgumentException(); 1292 else if ( m_bReadOnly ) 1293 throw IllegalAccessException(); 1294 else 1295 { 1296 ResetableGuard aGuard( m_aLock ); 1297 1298 if ( m_bDisposed ) 1299 throw DisposedException(); 1300 1301 UIElementData* pDataSettings = impl_findUIElementData( NewResourceURL, nElementType ); 1302 if ( !pDataSettings ) 1303 { 1304 UIElementData aUIElementData; 1305 1306 aUIElementData.bDefault = false; 1307 aUIElementData.bDefaultNode = false; 1308 aUIElementData.bModified = true; 1309 1310 // Create a copy of the data if the container is not const 1311 Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); 1312 if ( xReplace.is() ) 1313 aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); 1314 else 1315 aUIElementData.xSettings = aNewData; 1316 aUIElementData.aName = RetrieveNameFromResourceURL( NewResourceURL ) + m_aXMLPostfix; 1317 aUIElementData.aResourceURL = NewResourceURL; 1318 m_bModified = true; 1319 1320 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; 1321 rElementType.bModified = true; 1322 1323 UIElementDataHashMap& rElements = rElementType.aElementsHashMap; 1324 rElements.insert( UIElementDataHashMap::value_type( NewResourceURL, aUIElementData )); 1325 1326 Reference< XIndexAccess > xInsertSettings( aUIElementData.xSettings ); 1327 Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY ); 1328 Reference< XInterface > xIfac( xThis, UNO_QUERY ); 1329 1330 // Create event to notify listener about removed element settings 1331 ConfigurationEvent aEvent; 1332 1333 aEvent.ResourceURL = NewResourceURL; 1334 aEvent.Accessor <<= xThis; 1335 aEvent.Source = xIfac; 1336 aEvent.Element <<= xInsertSettings; 1337 1338 aGuard.unlock(); 1339 1340 implts_notifyContainerListener( aEvent, NotifyOp_Insert ); 1341 } 1342 else 1343 throw ElementExistException(); 1344 } 1345 } 1346 getImageManager()1347 Reference< XInterface > SAL_CALL ModuleUIConfigurationManager::getImageManager() throw (::com::sun::star::uno::RuntimeException) 1348 { 1349 ResetableGuard aGuard( m_aLock ); 1350 1351 if ( m_bDisposed ) 1352 throw DisposedException(); 1353 1354 if ( !m_xModuleImageManager.is() ) 1355 { 1356 m_xModuleImageManager = Reference< XComponent >( static_cast< cppu::OWeakObject *>( new ModuleImageManager( m_xServiceManager )), 1357 UNO_QUERY ); 1358 Reference< XInitialization > xInit( m_xModuleImageManager, UNO_QUERY ); 1359 1360 Sequence< Any > aPropSeq( 3 ); 1361 PropertyValue aPropValue; 1362 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfigStorage" )); 1363 aPropValue.Value = makeAny( m_xUserConfigStorage ); 1364 aPropSeq[0] = makeAny( aPropValue ); 1365 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ModuleIdentifier" )); 1366 aPropValue.Value = makeAny( m_aModuleIdentifier ); 1367 aPropSeq[1] = makeAny( aPropValue ); 1368 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserRootCommit" )); 1369 aPropValue.Value = makeAny( m_xUserRootCommit ); 1370 aPropSeq[2] = makeAny( aPropValue ); 1371 1372 xInit->initialize( aPropSeq ); 1373 } 1374 1375 return Reference< XInterface >( m_xModuleImageManager, UNO_QUERY ); 1376 } 1377 getShortCutManager()1378 Reference< XInterface > SAL_CALL ModuleUIConfigurationManager::getShortCutManager() throw (::com::sun::star::uno::RuntimeException) 1379 { 1380 ResetableGuard aGuard( m_aLock ); 1381 1382 if ( m_bDisposed ) 1383 throw DisposedException(); 1384 1385 Reference< XMultiServiceFactory > xSMGR = m_xServiceManager; 1386 ::rtl::OUString aModule = m_aModuleIdentifier; 1387 1388 if ( !m_xModuleAcceleratorManager.is() ) 1389 { 1390 Reference< XInterface > xManager = xSMGR->createInstance(SERVICENAME_MODULEACCELERATORCONFIGURATION); 1391 Reference< XInitialization > xInit (xManager, UNO_QUERY_THROW); 1392 1393 PropertyValue aProp; 1394 aProp.Name = ::rtl::OUString::createFromAscii("ModuleIdentifier"); 1395 aProp.Value <<= aModule; 1396 1397 Sequence< Any > lArgs(1); 1398 lArgs[0] <<= aProp; 1399 1400 xInit->initialize(lArgs); 1401 m_xModuleAcceleratorManager = Reference< XInterface >( xManager, UNO_QUERY ); 1402 } 1403 1404 return m_xModuleAcceleratorManager; 1405 } 1406 getEventsManager()1407 Reference< XInterface > SAL_CALL ModuleUIConfigurationManager::getEventsManager() throw (::com::sun::star::uno::RuntimeException) 1408 { 1409 return Reference< XInterface >(); 1410 } 1411 1412 // XModuleUIConfigurationManager isDefaultSettings(const::rtl::OUString & ResourceURL)1413 sal_Bool SAL_CALL ModuleUIConfigurationManager::isDefaultSettings( const ::rtl::OUString& ResourceURL ) 1414 throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) 1415 { 1416 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1417 1418 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1419 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1420 throw IllegalArgumentException(); 1421 else 1422 { 1423 ResetableGuard aGuard( m_aLock ); 1424 1425 if ( m_bDisposed ) 1426 throw DisposedException(); 1427 1428 UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType, false ); 1429 if ( pDataSettings && pDataSettings->bDefaultNode ) 1430 return sal_True; 1431 } 1432 1433 return sal_False; 1434 } 1435 getDefaultSettings(const::rtl::OUString & ResourceURL)1436 Reference< XIndexAccess > SAL_CALL ModuleUIConfigurationManager::getDefaultSettings( const ::rtl::OUString& ResourceURL ) 1437 throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) 1438 { 1439 sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); 1440 1441 if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || 1442 ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) 1443 throw IllegalArgumentException(); 1444 else 1445 { 1446 ResetableGuard aGuard( m_aLock ); 1447 1448 if ( m_bDisposed ) 1449 throw DisposedException(); 1450 1451 // preload list of element types on demand 1452 impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); 1453 1454 // Look into our default vector/hash_map combination 1455 UIElementDataHashMap& rDefaultHashMap = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; 1456 UIElementDataHashMap::iterator pIter = rDefaultHashMap.find( ResourceURL ); 1457 if ( pIter != rDefaultHashMap.end() ) 1458 { 1459 if ( !pIter->second.xSettings.is() ) 1460 impl_requestUIElementData( nElementType, LAYER_DEFAULT, pIter->second ); 1461 return pIter->second.xSettings; 1462 } 1463 } 1464 1465 // Nothing has been found! 1466 throw NoSuchElementException(); 1467 } 1468 1469 // XUIConfigurationPersistence reload()1470 void SAL_CALL ModuleUIConfigurationManager::reload() throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) 1471 { 1472 ResetableGuard aGuard( m_aLock ); 1473 1474 if ( m_bDisposed ) 1475 throw DisposedException(); 1476 1477 if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) 1478 { 1479 // Try to access our module sub folder 1480 ConfigEventNotifyContainer aRemoveNotifyContainer; 1481 ConfigEventNotifyContainer aReplaceNotifyContainer; 1482 for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 1483 { 1484 try 1485 { 1486 UIElementType& rUserElementType = m_aUIElements[LAYER_USERDEFINED][i]; 1487 UIElementType& rDefaultElementType = m_aUIElements[LAYER_DEFAULT][i]; 1488 1489 if ( rUserElementType.bModified ) 1490 impl_reloadElementTypeData( rUserElementType, rDefaultElementType, aRemoveNotifyContainer, aReplaceNotifyContainer ); 1491 } 1492 catch ( Exception& ) 1493 { 1494 throw IOException(); 1495 } 1496 } 1497 1498 m_bModified = sal_False; 1499 1500 // Unlock mutex before notify our listeners 1501 aGuard.unlock(); 1502 1503 // Notify our listeners 1504 for ( sal_uInt32 j = 0; j < aRemoveNotifyContainer.size(); j++ ) 1505 implts_notifyContainerListener( aRemoveNotifyContainer[j], NotifyOp_Remove ); 1506 for ( sal_uInt32 k = 0; k < aReplaceNotifyContainer.size(); k++ ) 1507 implts_notifyContainerListener( aReplaceNotifyContainer[k], NotifyOp_Replace ); 1508 } 1509 } 1510 store()1511 void SAL_CALL ModuleUIConfigurationManager::store() throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) 1512 { 1513 ResetableGuard aGuard( m_aLock ); 1514 1515 if ( m_bDisposed ) 1516 throw DisposedException(); 1517 1518 if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) 1519 { 1520 // Try to access our module sub folder 1521 for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 1522 { 1523 try 1524 { 1525 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; 1526 Reference< XStorage > xStorage( rElementType.xStorage, UNO_QUERY ); 1527 1528 if ( rElementType.bModified && xStorage.is() ) 1529 { 1530 impl_storeElementTypeData( xStorage, rElementType ); 1531 m_pStorageHandler[i]->commitUserChanges(); 1532 } 1533 } 1534 catch ( Exception& ) 1535 { 1536 throw IOException(); 1537 } 1538 } 1539 1540 m_bModified = false; 1541 } 1542 } 1543 storeToStorage(const Reference<XStorage> & Storage)1544 void SAL_CALL ModuleUIConfigurationManager::storeToStorage( const Reference< XStorage >& Storage ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) 1545 { 1546 ResetableGuard aGuard( m_aLock ); 1547 1548 if ( m_bDisposed ) 1549 throw DisposedException(); 1550 1551 if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) 1552 { 1553 // Try to access our module sub folder 1554 for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) 1555 { 1556 try 1557 { 1558 Reference< XStorage > xElementTypeStorage( Storage->openStorageElement( 1559 OUString::createFromAscii( UIELEMENTTYPENAMES[i] ), ElementModes::READWRITE )); 1560 UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; 1561 1562 if ( rElementType.bModified && xElementTypeStorage.is() ) 1563 impl_storeElementTypeData( xElementTypeStorage, rElementType, false ); // store data to storage, but don't reset modify flag! 1564 } 1565 catch ( Exception& ) 1566 { 1567 throw IOException(); 1568 } 1569 } 1570 1571 Reference< XTransactedObject > xTransactedObject( Storage, UNO_QUERY ); 1572 if ( xTransactedObject.is() ) 1573 xTransactedObject->commit(); 1574 } 1575 } 1576 isModified()1577 sal_Bool SAL_CALL ModuleUIConfigurationManager::isModified() throw (::com::sun::star::uno::RuntimeException) 1578 { 1579 ResetableGuard aGuard( m_aLock ); 1580 1581 return m_bModified; 1582 } 1583 isReadOnly()1584 sal_Bool SAL_CALL ModuleUIConfigurationManager::isReadOnly() throw (::com::sun::star::uno::RuntimeException) 1585 { 1586 ResetableGuard aGuard( m_aLock ); 1587 1588 return m_bReadOnly; 1589 } 1590 implts_notifyContainerListener(const ConfigurationEvent & aEvent,NotifyOp eOp)1591 void ModuleUIConfigurationManager::implts_notifyContainerListener( const ConfigurationEvent& aEvent, NotifyOp eOp ) 1592 { 1593 ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( ::getCppuType( ( const css::uno::Reference< ::com::sun::star::ui::XUIConfigurationListener >*) NULL ) ); 1594 if ( pContainer != NULL ) 1595 { 1596 ::cppu::OInterfaceIteratorHelper pIterator( *pContainer ); 1597 while ( pIterator.hasMoreElements() ) 1598 { 1599 try 1600 { 1601 switch ( eOp ) 1602 { 1603 case NotifyOp_Replace: 1604 ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementReplaced( aEvent ); 1605 break; 1606 case NotifyOp_Insert: 1607 ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementInserted( aEvent ); 1608 break; 1609 case NotifyOp_Remove: 1610 ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementRemoved( aEvent ); 1611 break; 1612 } 1613 } 1614 catch( css::uno::RuntimeException& ) 1615 { 1616 pIterator.remove(); 1617 } 1618 } 1619 } 1620 } 1621 1622 } // namespace framework 1623