| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_framework.hxx" |
| #include <uiconfigurationmanagerimpl.hxx> |
| #include <threadhelp/resetableguard.hxx> |
| #include <services.h> |
| #include <uielement/constitemcontainer.hxx> |
| #include <uielement/rootitemcontainer.hxx> |
| #include <uielement/uielementtypenames.hxx> |
| #include <framework/menuconfiguration.hxx> |
| #include <framework/toolboxconfiguration.hxx> |
| #include <uiconfiguration/imagemanager.hxx> |
| |
| #ifndef __FRAMEWORK_XML_STATUSBARCONFIGURATION_HXX_ |
| #include <framework/statusbarconfiguration.hxx> |
| #endif |
| |
| //_________________________________________________________________________________________________________________ |
| // interface includes |
| //_________________________________________________________________________________________________________________ |
| #include <com/sun/star/ui/UIElementType.hpp> |
| #include <com/sun/star/ui/ConfigurationEvent.hpp> |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/container/XNameAccess.hpp> |
| #include <com/sun/star/io/XStream.hpp> |
| |
| //_________________________________________________________________________________________________________________ |
| // other includes |
| //_________________________________________________________________________________________________________________ |
| |
| #include <vcl/svapp.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <comphelper/sequenceashashmap.hxx> |
| #include <boost/bind.hpp> |
| |
| //_________________________________________________________________________________________________________________ |
| // namespaces |
| //_________________________________________________________________________________________________________________ |
| |
| using rtl::OUString; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::io; |
| using namespace com::sun::star::embed; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::container; |
| using namespace com::sun::star::beans; |
| using namespace ::com::sun::star::ui; |
| using namespace ::cppu; |
| |
| namespace framework |
| { |
| |
| |
| // important: The order and position of the elements must match the constant |
| // definition of "::com::sun::star::ui::UIElementType" |
| static const char* UIELEMENTTYPENAMES[] = |
| { |
| "", // Dummy value for unknown! |
| UIELEMENTTYPE_MENUBAR_NAME, |
| UIELEMENTTYPE_POPUPMENU_NAME, |
| UIELEMENTTYPE_TOOLBAR_NAME, |
| UIELEMENTTYPE_STATUSBAR_NAME, |
| UIELEMENTTYPE_FLOATINGWINDOW_NAME, |
| UIELEMENTTYPE_PROGRESSBAR_NAME |
| }; |
| |
| static const char RESOURCEURL_PREFIX[] = "private:resource/"; |
| static const sal_Int32 RESOURCEURL_PREFIX_SIZE = 17; |
| static const char RESOURCEURL_CUSTOM_ELEMENT[] = "custom_"; |
| |
| static sal_Int16 RetrieveTypeFromResourceURL( const rtl::OUString& aResourceURL ) |
| { |
| |
| if (( aResourceURL.indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_PREFIX ))) == 0 ) && |
| ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE )) |
| { |
| rtl::OUString aTmpStr = aResourceURL.copy( RESOURCEURL_PREFIX_SIZE ); |
| sal_Int32 nIndex = aTmpStr.indexOf( '/' ); |
| if (( nIndex > 0 ) && ( aTmpStr.getLength() > nIndex )) |
| { |
| rtl::OUString aTypeStr( aTmpStr.copy( 0, nIndex )); |
| for ( int i = 0; i < UIElementType::COUNT; i++ ) |
| { |
| if ( aTypeStr.equalsAscii( UIELEMENTTYPENAMES[i] )) |
| return sal_Int16( i ); |
| } |
| } |
| } |
| |
| return UIElementType::UNKNOWN; |
| } |
| |
| static rtl::OUString RetrieveNameFromResourceURL( const rtl::OUString& aResourceURL ) |
| { |
| if (( aResourceURL.indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_PREFIX ))) == 0 ) && |
| ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE )) |
| { |
| sal_Int32 nIndex = aResourceURL.lastIndexOf( '/' ); |
| if (( nIndex > 0 ) && (( nIndex+1 ) < aResourceURL.getLength())) |
| return aResourceURL.copy( nIndex+1 ); |
| } |
| |
| return rtl::OUString(); |
| } |
| |
| void UIConfigurationManagerImpl::impl_fillSequenceWithElementTypeInfo( UIElementInfoHashMap& aUIElementInfoCollection, sal_Int16 nElementType ) |
| { |
| // preload list of element types on demand |
| impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType ); |
| if ( m_bUseDefault ) |
| impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); |
| |
| UIElementDataHashMap& rUserElements = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap; |
| UIElementDataHashMap::const_iterator pUserIter = rUserElements.begin(); |
| |
| rtl::OUString aCustomUrlPrefix( RTL_CONSTASCII_USTRINGPARAM( RESOURCEURL_CUSTOM_ELEMENT )); |
| while ( pUserIter != rUserElements.end() ) |
| { |
| sal_Int32 nIndex = pUserIter->second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX_SIZE ); |
| if ( nIndex > RESOURCEURL_PREFIX_SIZE ) |
| { |
| // Performance: Retrieve user interface name only for custom user interface elements. |
| // It's only used by them! |
| UIElementData* pDataSettings = impl_findUIElementData( pUserIter->second.aResourceURL, nElementType ); |
| if ( pDataSettings && ( m_bUseDefault || !pDataSettings->bDefault )) |
| { |
| // Retrieve user interface name from XPropertySet interface |
| rtl::OUString aUIName; |
| Reference< XPropertySet > xPropSet( pDataSettings->xSettings, UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| xPropSet->getPropertyValue( m_aPropUIName ) >>= aUIName; |
| } |
| |
| UIElementInfo aInfo( pUserIter->second.aResourceURL, aUIName ); |
| aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pUserIter->second.aResourceURL, aInfo )); |
| } |
| } |
| else |
| { |
| // The user interface name for standard user interface elements is stored in the WindowState.xcu file |
| UIElementInfo aInfo( pUserIter->second.aResourceURL, rtl::OUString() ); |
| aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pUserIter->second.aResourceURL, aInfo )); |
| } |
| ++pUserIter; |
| } |
| |
| if ( m_bUseDefault ) |
| { |
| UIElementDataHashMap& rDefaultElements = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; |
| UIElementDataHashMap::const_iterator pDefIter = rDefaultElements.begin(); |
| |
| while ( pDefIter != rDefaultElements.end() ) |
| { |
| UIElementInfoHashMap::const_iterator pIterInfo = aUIElementInfoCollection.find( pDefIter->second.aResourceURL ); |
| if ( pIterInfo == aUIElementInfoCollection.end() ) |
| { |
| sal_Int32 nIndex = pDefIter->second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX_SIZE ); |
| if ( nIndex > RESOURCEURL_PREFIX_SIZE ) |
| { |
| // Performance: Retrieve user interface name only for custom user interface elements. |
| // It's only used by them! |
| UIElementData* pDataSettings = impl_findUIElementData( pDefIter->second.aResourceURL, nElementType ); |
| if ( pDataSettings ) |
| { |
| // Retrieve user interface name from XPropertySet interface |
| rtl::OUString aUIName; |
| Reference< XPropertySet > xPropSet( pDataSettings->xSettings, UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| xPropSet->getPropertyValue( m_aPropUIName ) >>= aUIName; |
| } |
| |
| UIElementInfo aInfo( pDefIter->second.aResourceURL, aUIName ); |
| aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pDefIter->second.aResourceURL, aInfo )); |
| } |
| } |
| else |
| { |
| // The user interface name for standard user interface elements is stored in the WindowState.xcu file |
| UIElementInfo aInfo( pDefIter->second.aResourceURL, rtl::OUString() ); |
| aUIElementInfoCollection.insert( UIElementInfoHashMap::value_type( pDefIter->second.aResourceURL, aInfo )); |
| } |
| } |
| |
| ++pDefIter; |
| } // while ( pDefIter != rDefaultElements.end() ) |
| } |
| } |
| |
| void UIConfigurationManagerImpl::impl_preloadUIElementTypeList( Layer eLayer, sal_Int16 nElementType ) |
| { |
| UIElementType& rElementTypeData = m_aUIElements[eLayer][nElementType]; |
| |
| if ( !rElementTypeData.bLoaded ) |
| { |
| Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage; |
| if ( xElementTypeStorage.is() ) |
| { |
| rtl::OUStringBuffer aBuf( RESOURCEURL_PREFIX_SIZE ); |
| aBuf.appendAscii( RESOURCEURL_PREFIX ); |
| aBuf.appendAscii( UIELEMENTTYPENAMES[ nElementType ] ); |
| aBuf.appendAscii( "/" ); |
| rtl::OUString aResURLPrefix( aBuf.makeStringAndClear() ); |
| |
| UIElementDataHashMap& rHashMap = rElementTypeData.aElementsHashMap; |
| Reference< XNameAccess > xNameAccess( xElementTypeStorage, UNO_QUERY ); |
| Sequence< rtl::OUString > aUIElementNames = xNameAccess->getElementNames(); |
| for ( sal_Int32 n = 0; n < aUIElementNames.getLength(); n++ ) |
| { |
| UIElementData aUIElementData; |
| |
| // Resource name must be without ".xml" |
| sal_Int32 nIndex = aUIElementNames[n].lastIndexOf( '.' ); |
| if (( nIndex > 0 ) && ( nIndex < aUIElementNames[n].getLength() )) |
| { |
| rtl::OUString aExtension( aUIElementNames[n].copy( nIndex+1 )); |
| rtl::OUString aUIElementName( aUIElementNames[n].copy( 0, nIndex )); |
| |
| if (( aUIElementName.getLength() > 0 ) && |
| ( aExtension.equalsIgnoreAsciiCaseAsciiL( "xml", 3 ))) |
| { |
| aUIElementData.aResourceURL = aResURLPrefix + aUIElementName; |
| aUIElementData.aName = aUIElementNames[n]; |
| |
| if ( eLayer == LAYER_USERDEFINED ) |
| { |
| aUIElementData.bModified = false; |
| aUIElementData.bDefault = false; |
| aUIElementData.bDefaultNode = false; |
| } |
| |
| // Create hash_map entries for all user interface elements inside the storage. We don't load the |
| // settings to speed up the process. |
| rHashMap.insert( UIElementDataHashMap::value_type( aUIElementData.aResourceURL, aUIElementData )); |
| } |
| } |
| } |
| } |
| } |
| |
| rElementTypeData.bLoaded = true; |
| } |
| |
| void UIConfigurationManagerImpl::impl_requestUIElementData( sal_Int16 nElementType, Layer eLayer, UIElementData& aUIElementData ) |
| { |
| UIElementType& rElementTypeData = m_aUIElements[eLayer][nElementType]; |
| |
| Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage; |
| if ( xElementTypeStorage.is() && aUIElementData.aName.getLength() ) |
| { |
| try |
| { |
| Reference< XStream > xStream = xElementTypeStorage->openStreamElement( aUIElementData.aName, ElementModes::READ ); |
| Reference< XInputStream > xInputStream = xStream->getInputStream(); |
| |
| if ( xInputStream.is() ) |
| { |
| switch ( nElementType ) |
| { |
| case ::com::sun::star::ui::UIElementType::UNKNOWN: |
| break; |
| |
| case ::com::sun::star::ui::UIElementType::MENUBAR: |
| { |
| try |
| { |
| MenuConfiguration aMenuCfg( m_xServiceManager ); |
| Reference< XIndexAccess > xContainer( aMenuCfg.CreateMenuBarConfigurationFromXML( xInputStream )); |
| RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xContainer ); |
| if ( pRootItemContainer ) |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); |
| else |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( xContainer, sal_True ) ), UNO_QUERY ); |
| return; |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| } |
| break; |
| |
| case ::com::sun::star::ui::UIElementType::POPUPMENU: |
| { |
| break; |
| } |
| |
| case ::com::sun::star::ui::UIElementType::TOOLBAR: |
| { |
| try |
| { |
| Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); |
| ToolBoxConfiguration::LoadToolBox( m_xServiceManager, xInputStream, xIndexContainer ); |
| RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xIndexContainer ); |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); |
| return; |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| |
| break; |
| } |
| |
| case ::com::sun::star::ui::UIElementType::STATUSBAR: |
| { |
| try |
| { |
| Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); |
| StatusBarConfiguration::LoadStatusBar( m_xServiceManager, xInputStream, xIndexContainer ); |
| RootItemContainer* pRootItemContainer = RootItemContainer::GetImplementation( xIndexContainer ); |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, sal_True ) ), UNO_QUERY ); |
| return; |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| |
| break; |
| } |
| |
| case ::com::sun::star::ui::UIElementType::FLOATINGWINDOW: |
| { |
| break; |
| } |
| } |
| } |
| } |
| catch ( ::com::sun::star::embed::InvalidStorageException& ) |
| { |
| } |
| catch ( ::com::sun::star::lang::IllegalArgumentException& ) |
| { |
| } |
| catch ( ::com::sun::star::io::IOException& ) |
| { |
| } |
| catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) |
| { |
| } |
| } |
| |
| // At least we provide an empty settings container! |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer() ), UNO_QUERY ); |
| } |
| |
| UIConfigurationManagerImpl::UIElementData* UIConfigurationManagerImpl::impl_findUIElementData( const rtl::OUString& aResourceURL, sal_Int16 nElementType, bool bLoad ) |
| { |
| // preload list of element types on demand |
| impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType ); |
| if ( m_bUseDefault ) |
| impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); |
| |
| // first try to look into our user-defined vector/hash_map combination |
| UIElementDataHashMap& rUserHashMap = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap; |
| UIElementDataHashMap::iterator pIter = rUserHashMap.find( aResourceURL ); |
| if ( pIter != rUserHashMap.end() ) |
| { |
| // Default data settings data must be retrieved from the default layer! |
| if ( !pIter->second.bDefault ) |
| { |
| if ( !pIter->second.xSettings.is() && bLoad ) |
| impl_requestUIElementData( nElementType, LAYER_USERDEFINED, pIter->second ); |
| return &(pIter->second); |
| } |
| } |
| |
| if ( m_bUseDefault ) |
| { |
| // Not successfull, we have to look into our default vector/hash_map combination |
| UIElementDataHashMap& rDefaultHashMap = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; |
| pIter = rDefaultHashMap.find( aResourceURL ); |
| if ( pIter != rDefaultHashMap.end() ) |
| { |
| if ( !pIter->second.xSettings.is() && bLoad ) |
| impl_requestUIElementData( nElementType, LAYER_DEFAULT, pIter->second ); |
| return &(pIter->second); |
| } // if ( pIter != rDefaultHashMap.end() ) |
| } |
| |
| // Nothing has been found! |
| return NULL; |
| } |
| |
| void UIConfigurationManagerImpl::impl_storeElementTypeData( Reference< XStorage > xStorage, UIElementType& rElementType, bool bResetModifyState ) |
| { |
| UIElementDataHashMap& rHashMap = rElementType.aElementsHashMap; |
| UIElementDataHashMap::iterator pIter = rHashMap.begin(); |
| |
| while ( pIter != rHashMap.end() ) |
| { |
| UIElementData& rElement = pIter->second; |
| if ( rElement.bModified ) |
| { |
| if ( rElement.bDefault ) |
| { |
| xStorage->removeElement( rElement.aName ); |
| rElement.bModified = sal_False; // mark as not modified |
| } |
| else |
| { |
| Reference< XStream > xStream( xStorage->openStreamElement( rElement.aName, ElementModes::WRITE|ElementModes::TRUNCATE ), UNO_QUERY ); |
| Reference< XOutputStream > xOutputStream( xStream->getOutputStream() ); |
| |
| if ( xOutputStream.is() ) |
| { |
| switch( rElementType.nElementType ) |
| { |
| case ::com::sun::star::ui::UIElementType::MENUBAR: |
| { |
| try |
| { |
| MenuConfiguration aMenuCfg( m_xServiceManager ); |
| aMenuCfg.StoreMenuBarConfigurationToXML( rElement.xSettings, xOutputStream ); |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| } |
| break; |
| |
| case ::com::sun::star::ui::UIElementType::TOOLBAR: |
| { |
| try |
| { |
| ToolBoxConfiguration::StoreToolBox( m_xServiceManager, xOutputStream, rElement.xSettings ); |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| } |
| break; |
| |
| case ::com::sun::star::ui::UIElementType::STATUSBAR: |
| { |
| try |
| { |
| StatusBarConfiguration::StoreStatusBar( m_xServiceManager, xOutputStream, rElement.xSettings ); |
| } |
| catch ( ::com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| // mark as not modified if we store to our own storage |
| if ( bResetModifyState ) |
| rElement.bModified = sal_False; |
| } |
| } |
| |
| ++pIter; |
| } |
| |
| // commit element type storage |
| Reference< XTransactedObject > xTransactedObject( xStorage, UNO_QUERY ); |
| if ( xTransactedObject.is() ) |
| xTransactedObject->commit(); |
| |
| // mark UIElementType as not modified if we store to our own storage |
| if ( bResetModifyState ) |
| rElementType.bModified = sal_False; |
| } |
| |
| // This is only allowed to be called on the LAYER_USER_DEFINED! |
| void UIConfigurationManagerImpl::impl_resetElementTypeData( |
| UIElementType& rUserElementType, |
| UIElementType& rDefaultElementType, |
| ConfigEventNotifyContainer& rRemoveNotifyContainer, |
| ConfigEventNotifyContainer& rReplaceNotifyContainer ) |
| { |
| UIElementDataHashMap& rHashMap = rUserElementType.aElementsHashMap; |
| UIElementDataHashMap::iterator pIter = rHashMap.begin(); |
| |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| Reference< XNameAccess > xDefaultNameAccess( rDefaultElementType.xStorage, UNO_QUERY ); |
| sal_Int16 nType = rUserElementType.nElementType; |
| |
| // Make copies of the event structures to be thread-safe. We have to unlock our mutex before calling |
| // our listeners! |
| while ( pIter != rHashMap.end() ) |
| { |
| UIElementData& rElement = pIter->second; |
| if ( !rElement.bDefault ) |
| { |
| if ( m_bUseDefault && xDefaultNameAccess->hasByName( rElement.aName )) |
| { |
| // Replace settings with data from default layer |
| Reference< XIndexAccess > xOldSettings( rElement.xSettings ); |
| impl_requestUIElementData( nType, LAYER_DEFAULT, rElement ); |
| |
| ConfigurationEvent aReplaceEvent; |
| aReplaceEvent.ResourceURL = rElement.aResourceURL; |
| aReplaceEvent.Accessor <<= xThis; |
| aReplaceEvent.Source = m_xOwner; |
| aReplaceEvent.ReplacedElement <<= xOldSettings; |
| aReplaceEvent.Element <<= rElement.xSettings; |
| |
| rReplaceNotifyContainer.push_back( aReplaceEvent ); |
| |
| // Mark element as default and not modified. That means "not active" |
| // in the user layer anymore. |
| rElement.bModified = false; |
| rElement.bDefault = true; |
| } |
| else |
| { |
| // Remove user-defined settings from user layer |
| ConfigurationEvent aEvent; |
| aEvent.ResourceURL = rElement.aResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.Element <<= rElement.xSettings; |
| |
| rRemoveNotifyContainer.push_back( aEvent ); |
| |
| // Mark element as default and not modified. That means "not active" |
| // in the user layer anymore. |
| rElement.bModified = false; |
| rElement.bDefault = true; |
| } |
| } // if ( !rElement.bDefault ) |
| else |
| rElement.bModified = false; |
| |
| ++pIter; |
| } |
| |
| // Remove all settings from our user interface elements |
| rHashMap.clear(); |
| } |
| |
| void UIConfigurationManagerImpl::impl_reloadElementTypeData( |
| UIElementType& rUserElementType, |
| UIElementType& rDefaultElementType, |
| ConfigEventNotifyContainer& rRemoveNotifyContainer, |
| ConfigEventNotifyContainer& rReplaceNotifyContainer ) |
| { |
| UIElementDataHashMap& rHashMap = rUserElementType.aElementsHashMap; |
| UIElementDataHashMap::iterator pIter = rHashMap.begin(); |
| Reference< XStorage > xUserStorage( rUserElementType.xStorage ); |
| Reference< XStorage > xDefaultStorage( rDefaultElementType.xStorage ); |
| Reference< XNameAccess > xUserNameAccess( rUserElementType.xStorage, UNO_QUERY ); |
| Reference< XNameAccess > xDefaultNameAccess( rDefaultElementType.xStorage, UNO_QUERY ); |
| |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| sal_Int16 nType = rUserElementType.nElementType; |
| |
| while ( pIter != rHashMap.end() ) |
| { |
| UIElementData& rElement = pIter->second; |
| if ( rElement.bModified ) |
| { |
| if ( xUserNameAccess->hasByName( rElement.aName )) |
| { |
| // Replace settings with data from user layer |
| Reference< XIndexAccess > xOldSettings( rElement.xSettings ); |
| |
| impl_requestUIElementData( nType, LAYER_USERDEFINED, rElement ); |
| |
| ConfigurationEvent aReplaceEvent; |
| |
| aReplaceEvent.ResourceURL = rElement.aResourceURL; |
| aReplaceEvent.Accessor <<= xThis; |
| aReplaceEvent.Source = m_xOwner; |
| aReplaceEvent.ReplacedElement <<= xOldSettings; |
| aReplaceEvent.Element <<= rElement.xSettings; |
| rReplaceNotifyContainer.push_back( aReplaceEvent ); |
| |
| rElement.bModified = false; |
| } |
| else if ( m_bUseDefault && xDefaultNameAccess->hasByName( rElement.aName )) |
| { |
| // Replace settings with data from default layer |
| Reference< XIndexAccess > xOldSettings( rElement.xSettings ); |
| |
| impl_requestUIElementData( nType, LAYER_DEFAULT, rElement ); |
| |
| ConfigurationEvent aReplaceEvent; |
| |
| aReplaceEvent.ResourceURL = rElement.aResourceURL; |
| aReplaceEvent.Accessor <<= xThis; |
| aReplaceEvent.Source = m_xOwner; |
| aReplaceEvent.ReplacedElement <<= xOldSettings; |
| aReplaceEvent.Element <<= rElement.xSettings; |
| rReplaceNotifyContainer.push_back( aReplaceEvent ); |
| |
| // Mark element as default and not modified. That means "not active" |
| // in the user layer anymore. |
| rElement.bModified = false; |
| rElement.bDefault = true; |
| } |
| else |
| { |
| // Element settings are not in any storage => remove |
| ConfigurationEvent aRemoveEvent; |
| |
| aRemoveEvent.ResourceURL = rElement.aResourceURL; |
| aRemoveEvent.Accessor <<= xThis; |
| aRemoveEvent.Source = m_xOwner; |
| aRemoveEvent.Element <<= rElement.xSettings; |
| |
| rRemoveNotifyContainer.push_back( aRemoveEvent ); |
| |
| // Mark element as default and not modified. That means "not active" |
| // in the user layer anymore. |
| rElement.bModified = false; |
| rElement.bDefault = true; |
| } |
| } |
| ++pIter; |
| } |
| |
| rUserElementType.bModified = sal_False; |
| } |
| |
| void UIConfigurationManagerImpl::impl_Initialize() |
| { |
| // Initialize the top-level structures with the storage data |
| if ( m_xUserConfigStorage.is() ) |
| { |
| // Try to access our module sub folder |
| for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; |
| i++ ) |
| { |
| Reference< XStorage > xElementTypeStorage; |
| try |
| { |
| if ( m_pStorageHandler[i] ) |
| xElementTypeStorage = m_pStorageHandler[i]->getWorkingStorageUser(); |
| } |
| catch ( com::sun::star::container::NoSuchElementException& ) |
| { |
| } |
| catch ( ::com::sun::star::embed::InvalidStorageException& ) |
| { |
| } |
| catch ( ::com::sun::star::lang::IllegalArgumentException& ) |
| { |
| } |
| catch ( ::com::sun::star::io::IOException& ) |
| { |
| } |
| catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) |
| { |
| } |
| |
| m_aUIElements[LAYER_USERDEFINED][i].nElementType = i; |
| m_aUIElements[LAYER_USERDEFINED][i].bModified = false; |
| m_aUIElements[LAYER_USERDEFINED][i].xStorage = xElementTypeStorage; |
| m_aUIElements[LAYER_USERDEFINED][i].bDefaultLayer = false; |
| } |
| } // if ( m_xUserConfigStorage.is() ) |
| else if ( !m_bUseDefault ) |
| { |
| // We have no storage, just initialize ui element types with empty storage! |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| m_aUIElements[LAYER_USERDEFINED][i].xStorage.clear(); |
| } |
| |
| if ( m_bUseDefault && m_xUserConfigStorage.is() ) |
| { |
| Reference< XNameAccess > xNameAccess( m_xDefaultConfigStorage, UNO_QUERY_THROW ); |
| |
| // Try to access our module sub folder |
| for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; |
| i++ ) |
| { |
| Reference< XStorage > xElementTypeStorage; |
| try |
| { |
| xNameAccess->getByName( rtl::OUString::createFromAscii( UIELEMENTTYPENAMES[i] )) >>= xElementTypeStorage; |
| } |
| catch ( com::sun::star::container::NoSuchElementException& ) |
| { |
| } |
| |
| m_aUIElements[LAYER_DEFAULT][i].nElementType = i; |
| m_aUIElements[LAYER_DEFAULT][i].bModified = false; |
| m_aUIElements[LAYER_DEFAULT][i].xStorage = xElementTypeStorage; |
| m_aUIElements[LAYER_DEFAULT][i].bDefaultLayer = true; |
| } |
| } |
| } |
| |
| UIConfigurationManagerImpl::UIConfigurationManagerImpl( const Reference< com::sun::star::lang::XMultiServiceFactory >& xServiceManager |
| ,const Reference< XInterface >& _xOwner |
| , bool _bUseDefault) : |
| ThreadHelpBase( &Application::GetSolarMutex() ) |
| , m_xOwner( _xOwner ) |
| , m_bUseDefault(_bUseDefault) |
| , m_bReadOnly( true ) |
| , m_bInitialized( false ) |
| , m_bModified( false ) |
| , m_bConfigRead( false ) |
| , m_bDisposed( false ) |
| , m_aXMLPostfix( RTL_CONSTASCII_USTRINGPARAM( ".xml" )) |
| , m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( "UIName" )) |
| , m_aPropResourceURL( RTL_CONSTASCII_USTRINGPARAM( "ResourceURL" )) |
| , m_xServiceManager( xServiceManager ) |
| , m_aListenerContainer( m_aLock.getShareableOslMutex() ) |
| { |
| for ( int i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| m_pStorageHandler[i] = 0; |
| |
| // Make sure we have a default initialized entry for every layer and user interface element type! |
| // The following code depends on this! |
| m_aUIElements[LAYER_DEFAULT].resize( ::com::sun::star::ui::UIElementType::COUNT ); |
| m_aUIElements[LAYER_USERDEFINED].resize( ::com::sun::star::ui::UIElementType::COUNT ); |
| } |
| |
| UIConfigurationManagerImpl::~UIConfigurationManagerImpl() |
| { |
| for ( int i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| delete m_pStorageHandler[i]; |
| } |
| |
| // XComponent |
| void UIConfigurationManagerImpl::dispose() throw (::com::sun::star::uno::RuntimeException) |
| { |
| css::lang::EventObject aEvent( m_xOwner ); |
| m_aListenerContainer.disposeAndClear( aEvent ); |
| |
| { |
| ResetableGuard aGuard( m_aLock ); |
| try |
| { |
| if ( m_xModuleImageManager.is() ) |
| m_xModuleImageManager->dispose(); |
| } |
| catch ( Exception& ) |
| { |
| } |
| |
| m_xModuleImageManager.clear(); |
| m_aUIElements[LAYER_USERDEFINED].clear(); |
| m_aUIElements[LAYER_DEFAULT].clear(); |
| m_xDefaultConfigStorage.clear(); |
| m_xUserConfigStorage.clear(); |
| m_xUserRootCommit.clear(); |
| m_bConfigRead = false; |
| m_bModified = false; |
| m_bDisposed = true; |
| } |
| } |
| |
| void UIConfigurationManagerImpl::addEventListener( const Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| /* SAFE AREA ----------------------------------------------------------------------------------------------- */ |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| } |
| |
| m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); |
| } |
| |
| void UIConfigurationManagerImpl::removeEventListener( const Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| /* SAFE AREA ----------------------------------------------------------------------------------------------- */ |
| m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); |
| } |
| |
| // XInitialization |
| void UIConfigurationManagerImpl::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException ) |
| { |
| ResetableGuard aLock( m_aLock ); |
| |
| if ( !m_bInitialized ) |
| { |
| ::comphelper::SequenceAsHashMap lArgs(aArguments); |
| m_aModuleIdentifier = lArgs.getUnpackedValueOrDefault(::rtl::OUString::createFromAscii("ModuleIdentifier"), ::rtl::OUString()); |
| m_aModuleShortName = lArgs.getUnpackedValueOrDefault(::rtl::OUString::createFromAscii("ModuleShortName"), ::rtl::OUString()); |
| |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| rtl::OUString aResourceType; |
| if ( i == ::com::sun::star::ui::UIElementType::MENUBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_MENUBAR(); |
| else if ( i == ::com::sun::star::ui::UIElementType::TOOLBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_TOOLBAR(); |
| else if ( i == ::com::sun::star::ui::UIElementType::STATUSBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_STATUSBAR(); |
| |
| if ( aResourceType.getLength() > 0 ) |
| { |
| m_pStorageHandler[i] = new PresetHandler( m_xServiceManager ); |
| m_pStorageHandler[i]->connectToResource( PresetHandler::E_MODULES, |
| aResourceType, // this path wont be used later ... seee next lines! |
| m_aModuleShortName, |
| css::uno::Reference< css::embed::XStorage >()); // no document root used here! |
| } |
| } |
| |
| // initialize root storages for all resource types |
| m_xUserRootCommit = css::uno::Reference< css::embed::XTransactedObject >( |
| m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getOrCreateRootStorageUser(), css::uno::UNO_QUERY); // can be empty |
| m_xDefaultConfigStorage = m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getParentStorageShare( |
| m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getWorkingStorageShare()); |
| m_xUserConfigStorage = m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getParentStorageUser( |
| m_pStorageHandler[::com::sun::star::ui::UIElementType::MENUBAR]->getWorkingStorageUser()); |
| |
| if ( m_xUserConfigStorage.is() ) |
| { |
| Reference< XPropertySet > xPropSet( m_xUserConfigStorage, UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| long nOpenMode = 0; |
| if ( xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ))) >>= nOpenMode ) |
| m_bReadOnly = !( nOpenMode & ElementModes::WRITE ); |
| } |
| } |
| |
| impl_Initialize(); |
| |
| m_bInitialized = true; |
| } |
| } |
| |
| // XUIConfiguration |
| void UIConfigurationManagerImpl::addConfigurationListener( const Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| /* SAFE AREA ----------------------------------------------------------------------------------------------- */ |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| } |
| |
| m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XUIConfigurationListener >* ) NULL ), xListener ); |
| } |
| |
| void UIConfigurationManagerImpl::removeConfigurationListener( const Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| /* SAFE AREA ----------------------------------------------------------------------------------------------- */ |
| m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XUIConfigurationListener >* ) NULL ), xListener ); |
| } |
| |
| |
| // XUIConfigurationManager |
| void UIConfigurationManagerImpl::reset() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| /* SAFE AREA ----------------------------------------------------------------------------------------------- */ |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| bool bResetStorage( false ); |
| |
| if ( !isReadOnly() ) |
| { |
| // Remove all elements from our user-defined storage! |
| try |
| { |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; |
| Reference< XStorage > xSubStorage( rElementType.xStorage, UNO_QUERY ); |
| |
| if ( xSubStorage.is() ) |
| { |
| bool bCommitSubStorage( false ); |
| Reference< XNameAccess > xSubStorageNameAccess( xSubStorage, UNO_QUERY ); |
| Sequence< rtl::OUString > aUIElementStreamNames = xSubStorageNameAccess->getElementNames(); |
| for ( sal_Int32 j = 0; j < aUIElementStreamNames.getLength(); j++ ) |
| { |
| xSubStorage->removeElement( aUIElementStreamNames[j] ); |
| bCommitSubStorage = true; |
| } |
| |
| if ( bCommitSubStorage ) |
| { |
| Reference< XTransactedObject > xTransactedObject( xSubStorage, UNO_QUERY ); |
| if ( xTransactedObject.is() ) |
| xTransactedObject->commit(); |
| m_pStorageHandler[i]->commitUserChanges(); |
| } |
| } |
| } |
| |
| bResetStorage = true; |
| |
| // remove settings from user defined layer and notify listener about removed settings data! |
| ConfigEventNotifyContainer aRemoveEventNotifyContainer; |
| ConfigEventNotifyContainer aReplaceEventNotifyContainer; |
| for ( sal_Int16 j = 1; j < ::com::sun::star::ui::UIElementType::COUNT; j++ ) |
| { |
| try |
| { |
| UIElementType& rUserElementType = m_aUIElements[LAYER_USERDEFINED][j]; |
| UIElementType& rDefaultElementType = m_aUIElements[LAYER_DEFAULT][j]; |
| |
| impl_resetElementTypeData( rUserElementType, rDefaultElementType, aRemoveEventNotifyContainer, aReplaceEventNotifyContainer ); |
| rUserElementType.bModified = sal_False; |
| } |
| catch ( Exception& ) |
| { |
| throw IOException(); |
| } |
| } |
| |
| m_bModified = sal_False; |
| |
| // Unlock mutex before notify our listeners |
| aGuard.unlock(); |
| |
| // Notify our listeners |
| ::std::for_each(aRemoveEventNotifyContainer.begin(),aRemoveEventNotifyContainer.end(),::boost::bind(&UIConfigurationManagerImpl::implts_notifyContainerListener,this,_1,NotifyOp_Remove)); |
| ::std::for_each(aReplaceEventNotifyContainer.begin(),aReplaceEventNotifyContainer.end(),::boost::bind(&UIConfigurationManagerImpl::implts_notifyContainerListener,this,_1,NotifyOp_Replace)); |
| } |
| catch ( ::com::sun::star::lang::IllegalArgumentException& ) |
| { |
| } |
| catch ( ::com::sun::star::container::NoSuchElementException& ) |
| { |
| } |
| catch ( ::com::sun::star::embed::InvalidStorageException& ) |
| { |
| } |
| catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) |
| { |
| } |
| } |
| } |
| |
| Sequence< Sequence< PropertyValue > > UIConfigurationManagerImpl::getUIElementsInfo( sal_Int16 ElementType ) |
| throw ( IllegalArgumentException, RuntimeException ) |
| { |
| if (( ElementType < 0 ) || ( ElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| |
| ResetableGuard aGuard( m_aLock ); |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| Sequence< Sequence< PropertyValue > > aElementInfoSeq; |
| UIElementInfoHashMap aUIElementInfoCollection; |
| |
| if ( ElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) |
| { |
| for ( sal_Int16 i = 0; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, sal_Int16( i ) ); |
| } |
| else |
| impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, ElementType ); |
| |
| Sequence< PropertyValue > aUIElementInfo( 2 ); |
| aUIElementInfo[0].Name = m_aPropResourceURL; |
| aUIElementInfo[1].Name = m_aPropUIName; |
| |
| aElementInfoSeq.realloc( aUIElementInfoCollection.size() ); |
| UIElementInfoHashMap::const_iterator pIter = aUIElementInfoCollection.begin(); |
| |
| sal_Int32 n = 0; |
| while ( pIter != aUIElementInfoCollection.end() ) |
| { |
| aUIElementInfo[0].Value <<= pIter->second.aResourceURL; |
| aUIElementInfo[1].Value <<= pIter->second.aUIName; |
| aElementInfoSeq[n++] = aUIElementInfo; |
| ++pIter; |
| } |
| |
| return aElementInfoSeq; |
| } |
| |
| Reference< XIndexContainer > UIConfigurationManagerImpl::createSettings() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| // Creates an empty item container which can be filled from outside |
| return Reference< XIndexContainer >( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY ); |
| } |
| |
| sal_Bool UIConfigurationManagerImpl::hasSettings( const ::rtl::OUString& ResourceURL ) |
| throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType, false ); |
| if ( pDataSettings && ( m_bUseDefault || !pDataSettings->bDefault) ) |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| Reference< XIndexAccess > UIConfigurationManagerImpl::getSettings( const ::rtl::OUString& ResourceURL, sal_Bool bWriteable ) |
| throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); |
| if ( pDataSettings && ( m_bUseDefault || !pDataSettings->bDefault) ) |
| { |
| // Create a copy of our data if someone wants to change the data. |
| if ( bWriteable ) |
| return Reference< XIndexAccess >( static_cast< OWeakObject * >( new RootItemContainer( pDataSettings->xSettings ) ), UNO_QUERY ); |
| else |
| return pDataSettings->xSettings; |
| } |
| } |
| |
| throw NoSuchElementException(); |
| } |
| |
| void UIConfigurationManagerImpl::replaceSettings( const ::rtl::OUString& ResourceURL, const Reference< ::com::sun::star::container::XIndexAccess >& aNewData ) |
| throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else if ( m_bReadOnly ) |
| throw IllegalAccessException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); |
| if ( pDataSettings && ( m_bUseDefault || !pDataSettings->bDefault) ) |
| { |
| if ( !m_bUseDefault || !pDataSettings->bDefaultNode ) |
| { |
| // we have a settings entry in our user-defined layer - replace |
| Reference< XIndexAccess > xOldSettings = pDataSettings->xSettings; |
| |
| // Create a copy of the data if the container is not const |
| Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); |
| if ( xReplace.is() ) |
| pDataSettings->xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); |
| else |
| pDataSettings->xSettings = aNewData; |
| pDataSettings->bDefault = false; |
| pDataSettings->bModified = true; |
| m_bModified = true; |
| |
| // Modify type container |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; |
| rElementType.bModified = true; |
| |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| |
| // Create event to notify listener about replaced element settings |
| ConfigurationEvent aEvent; |
| |
| aEvent.ResourceURL = ResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.ReplacedElement <<= xOldSettings; |
| aEvent.Element <<= pDataSettings->xSettings; |
| |
| aGuard.unlock(); |
| |
| implts_notifyContainerListener( aEvent, NotifyOp_Replace ); |
| } |
| else |
| { |
| // we have no settings in our user-defined layer - insert |
| UIElementData aUIElementData; |
| |
| aUIElementData.bDefault = false; |
| aUIElementData.bDefaultNode = false; |
| aUIElementData.bModified = true; |
| |
| // Create a copy of the data if the container is not const |
| Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); |
| if ( xReplace.is() ) |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); |
| else |
| aUIElementData.xSettings = aNewData; |
| aUIElementData.aName = RetrieveNameFromResourceURL( ResourceURL ) + m_aXMLPostfix; |
| aUIElementData.aResourceURL = ResourceURL; |
| m_bModified = true; |
| |
| // Modify type container |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; |
| rElementType.bModified = true; |
| |
| UIElementDataHashMap& rElements = rElementType.aElementsHashMap; |
| |
| // Check our user element settings hash map as it can already contain settings that have been set to default! |
| // If no node can be found, we have to insert it. |
| UIElementDataHashMap::iterator pIter = rElements.find( ResourceURL ); |
| if ( pIter != rElements.end() ) |
| pIter->second = aUIElementData; |
| else |
| rElements.insert( UIElementDataHashMap::value_type( ResourceURL, aUIElementData )); |
| |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| |
| // Create event to notify listener about replaced element settings |
| ConfigurationEvent aEvent; |
| |
| aEvent.ResourceURL = ResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.ReplacedElement <<= pDataSettings->xSettings; |
| aEvent.Element <<= aUIElementData.xSettings; |
| |
| aGuard.unlock(); |
| |
| implts_notifyContainerListener( aEvent, NotifyOp_Replace ); |
| } |
| } |
| else |
| throw NoSuchElementException(); |
| } |
| } |
| |
| void UIConfigurationManagerImpl::removeSettings( const ::rtl::OUString& ResourceURL ) |
| throw ( NoSuchElementException, IllegalArgumentException, IllegalAccessException, RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else if ( m_bReadOnly ) |
| throw IllegalAccessException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType ); |
| if ( pDataSettings ) |
| { |
| // If element settings are default, we don't need to change anything! |
| if ( pDataSettings->bDefault ) |
| return; |
| else |
| { |
| Reference< XIndexAccess > xRemovedSettings = pDataSettings->xSettings; |
| pDataSettings->bDefault = true; |
| |
| // check if this is a default layer node |
| if ( !m_bUseDefault || !pDataSettings->bDefaultNode ) |
| pDataSettings->bModified = true; // we have to remove this node from the user layer! |
| pDataSettings->xSettings.clear(); |
| m_bModified = true; // user layer must be written |
| |
| // Modify type container |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; |
| rElementType.bModified = true; |
| |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| // Check if we have settings in the default layer which replaces the user-defined one! |
| UIElementData* pDefaultDataSettings = m_bUseDefault ? impl_findUIElementData( ResourceURL, nElementType ) : NULL; |
| if ( pDefaultDataSettings ) |
| { |
| // Create event to notify listener about replaced element settings |
| ConfigurationEvent aEvent; |
| |
| aEvent.ResourceURL = ResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.Element <<= xRemovedSettings; |
| aEvent.ReplacedElement <<= pDefaultDataSettings->xSettings; |
| |
| aGuard.unlock(); |
| |
| implts_notifyContainerListener( aEvent, NotifyOp_Replace ); |
| } |
| else |
| { |
| // Create event to notify listener about removed element settings |
| ConfigurationEvent aEvent; |
| |
| aEvent.ResourceURL = ResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.Element <<= xRemovedSettings; |
| |
| aGuard.unlock(); |
| |
| implts_notifyContainerListener( aEvent, NotifyOp_Remove ); |
| } |
| } |
| } |
| else |
| throw NoSuchElementException(); |
| } |
| } |
| |
| void UIConfigurationManagerImpl::insertSettings( const ::rtl::OUString& NewResourceURL, const Reference< XIndexAccess >& aNewData ) |
| throw ( ElementExistException, IllegalArgumentException, IllegalAccessException, RuntimeException ) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( NewResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else if ( m_bReadOnly ) |
| throw IllegalAccessException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| bool bInsertData( false ); |
| UIElementData aUIElementData; |
| UIElementData* pDataSettings = impl_findUIElementData( NewResourceURL, nElementType ); |
| if ( !m_bUseDefault ) |
| { |
| if ( pDataSettings && !pDataSettings->bDefault ) |
| throw ElementExistException(); |
| if ( !pDataSettings ) |
| { |
| pDataSettings = &aUIElementData; |
| bInsertData = true; |
| } |
| } |
| if ( !pDataSettings || !m_bUseDefault ) |
| { |
| aUIElementData.bDefault = false; |
| if ( !m_bUseDefault ) |
| aUIElementData.bDefaultNode = false; |
| aUIElementData.bModified = true; |
| |
| // Create a copy of the data if the container is not const |
| Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY ); |
| if ( xReplace.is() ) |
| aUIElementData.xSettings = Reference< XIndexAccess >( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY ); |
| else |
| aUIElementData.xSettings = aNewData; |
| |
| m_bModified = true; |
| |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][nElementType]; |
| rElementType.bModified = true; |
| |
| if ( bInsertData ) |
| { |
| aUIElementData.aName = RetrieveNameFromResourceURL( NewResourceURL ) + m_aXMLPostfix; |
| aUIElementData.aResourceURL = NewResourceURL; |
| UIElementDataHashMap& rElements = rElementType.aElementsHashMap; |
| rElements.insert( UIElementDataHashMap::value_type( NewResourceURL, aUIElementData )); |
| } |
| |
| Reference< XIndexAccess > xInsertSettings( aUIElementData.xSettings ); |
| Reference< XUIConfigurationManager > xThis( m_xOwner, UNO_QUERY ); |
| |
| // Create event to notify listener about removed element settings |
| ConfigurationEvent aEvent; |
| |
| aEvent.ResourceURL = NewResourceURL; |
| aEvent.Accessor <<= xThis; |
| aEvent.Source = m_xOwner; |
| aEvent.Element <<= xInsertSettings; |
| |
| aGuard.unlock(); |
| |
| implts_notifyContainerListener( aEvent, NotifyOp_Insert ); |
| } |
| else |
| throw ElementExistException(); |
| } |
| } |
| |
| Reference< XInterface > UIConfigurationManagerImpl::getImageManager() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| if ( !m_xModuleImageManager.is() ) |
| { |
| if ( m_bUseDefault ) |
| m_xModuleImageManager = Reference< XComponent >( static_cast< cppu::OWeakObject *>( new ModuleImageManager( m_xServiceManager )), |
| UNO_QUERY ); |
| else |
| m_xModuleImageManager = Reference< XComponent >( static_cast< cppu::OWeakObject *>( new ImageManager( m_xServiceManager )), |
| UNO_QUERY ); |
| Reference< XInitialization > xInit( m_xModuleImageManager, UNO_QUERY ); |
| |
| Sequence< Any > aPropSeq( m_bUseDefault ? 3 : 2 ); |
| PropertyValue aPropValue; |
| aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfigStorage" )); |
| aPropValue.Value <<= m_xUserConfigStorage; |
| aPropSeq[0] <<= aPropValue; |
| aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ModuleIdentifier" )); |
| aPropValue.Value <<= m_aModuleIdentifier; |
| aPropSeq[1] <<= aPropValue; |
| if ( m_bUseDefault ) |
| { |
| aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserRootCommit" )); |
| aPropValue.Value <<= m_xUserRootCommit; |
| aPropSeq[2] <<= aPropValue; |
| } |
| |
| xInit->initialize( aPropSeq ); |
| } |
| |
| return Reference< XInterface >( m_xModuleImageManager, UNO_QUERY ); |
| |
| // return Reference< XInterface >(); |
| } |
| |
| Reference< XInterface > UIConfigurationManagerImpl::getShortCutManager() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| if ( !m_bUseDefault && m_xAccConfig.is()) |
| return m_xAccConfig; |
| |
| Reference< XMultiServiceFactory > xSMGR = m_xServiceManager; |
| ::rtl::OUString aModule = m_aModuleIdentifier; |
| Reference< XStorage > xDocumentRoot = m_xUserConfigStorage; |
| aGuard.unlock(); |
| Reference< XInterface > xManager = xSMGR->createInstance(m_bUseDefault ? SERVICENAME_MODULEACCELERATORCONFIGURATION : SERVICENAME_DOCUMENTACCELERATORCONFIGURATION ); |
| Reference< XInitialization > xInit (xManager, UNO_QUERY_THROW); |
| |
| PropertyValue aProp; |
| Sequence< Any > lArgs(1); |
| if ( m_bUseDefault ) |
| { |
| aProp.Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ModuleIdentifier")); |
| aProp.Value <<= aModule; |
| } // if ( m_bUseDefault ) |
| else |
| { |
| aProp.Name = ::rtl::OUString::createFromAscii("DocumentRoot"); |
| aProp.Value <<= xDocumentRoot; |
| } |
| lArgs[0] <<= aProp; |
| xInit->initialize(lArgs); |
| |
| if ( !m_bUseDefault ) |
| { |
| // SAFE -> |
| aGuard.lock(); |
| m_xAccConfig = xManager; |
| aGuard.unlock(); |
| // <- SAFE |
| } |
| |
| return xManager; |
| } |
| |
| Reference< XInterface > UIConfigurationManagerImpl::getEventsManager() throw (::com::sun::star::uno::RuntimeException) |
| { |
| return Reference< XInterface >(); |
| } |
| // XUIConfigurationStorage |
| void UIConfigurationManagerImpl::setStorage( const Reference< XStorage >& Storage ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| if ( m_xUserConfigStorage.is() ) |
| { |
| try |
| { |
| // Dispose old storage to be sure that it will be closed |
| Reference< XComponent > xComponent( m_xUserConfigStorage, UNO_QUERY ); |
| if ( xComponent.is() ) |
| xComponent->dispose(); |
| } |
| catch ( Exception& ) |
| { |
| } |
| } |
| |
| // We store the new storage. Be careful it could be an empty reference! |
| m_xUserConfigStorage = Storage; |
| m_bReadOnly = sal_True; |
| |
| Reference< XUIConfigurationStorage > xAccUpdate(m_xAccConfig, UNO_QUERY); |
| if ( xAccUpdate.is() ) |
| xAccUpdate->setStorage( m_xUserConfigStorage ); |
| |
| if ( m_xModuleImageManager.is() ) |
| { |
| ImageManager* pImageManager = (ImageManager*)m_xModuleImageManager.get(); |
| if ( pImageManager ) |
| pImageManager->setStorage( m_xUserConfigStorage ); |
| } |
| |
| if ( m_xUserConfigStorage.is() ) |
| { |
| ::rtl::OUString sEmpty; |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| rtl::OUString aResourceType; |
| if ( i == ::com::sun::star::ui::UIElementType::MENUBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_MENUBAR(); |
| else if ( i == ::com::sun::star::ui::UIElementType::TOOLBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_TOOLBAR(); |
| else if ( i == ::com::sun::star::ui::UIElementType::STATUSBAR ) |
| aResourceType = PresetHandler::RESOURCETYPE_STATUSBAR(); |
| |
| //if ( aResourceType.getLength() > 0 ) |
| { |
| m_pStorageHandler[i] = new PresetHandler( m_xServiceManager ); |
| m_pStorageHandler[i]->connectToResource( PresetHandler::E_DOCUMENT, |
| rtl::OUString::createFromAscii( UIELEMENTTYPENAMES[i] ), // this path wont be used later ... seee next lines! |
| sEmpty, |
| m_xUserConfigStorage); |
| } |
| } |
| Reference< XPropertySet > xPropSet( m_xUserConfigStorage, UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| try |
| { |
| long nOpenMode = 0; |
| if ( xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ))) >>= nOpenMode ) |
| m_bReadOnly = !( nOpenMode & ElementModes::WRITE ); |
| } |
| catch ( com::sun::star::beans::UnknownPropertyException& ) |
| { |
| } |
| catch ( com::sun::star::lang::WrappedTargetException& ) |
| { |
| } |
| } |
| } |
| |
| impl_Initialize(); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool UIConfigurationManagerImpl::hasStorage() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| return ( m_xUserConfigStorage.is() ); |
| } |
| |
| // XUIConfigurationManagerImpl |
| sal_Bool UIConfigurationManagerImpl::isDefaultSettings( const ::rtl::OUString& ResourceURL ) |
| throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType, false ); |
| if ( pDataSettings && pDataSettings->bDefaultNode ) |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| Reference< XIndexAccess > UIConfigurationManagerImpl::getDefaultSettings( const ::rtl::OUString& ResourceURL ) |
| throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL ); |
| |
| if (( nElementType == ::com::sun::star::ui::UIElementType::UNKNOWN ) || |
| ( nElementType >= ::com::sun::star::ui::UIElementType::COUNT )) |
| throw IllegalArgumentException(); |
| else |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| // preload list of element types on demand |
| impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType ); |
| |
| // Look into our default vector/hash_map combination |
| UIElementDataHashMap& rDefaultHashMap = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap; |
| UIElementDataHashMap::iterator pIter = rDefaultHashMap.find( ResourceURL ); |
| if ( pIter != rDefaultHashMap.end() ) |
| { |
| if ( !pIter->second.xSettings.is() ) |
| impl_requestUIElementData( nElementType, LAYER_DEFAULT, pIter->second ); |
| return pIter->second.xSettings; |
| } |
| } |
| |
| // Nothing has been found! |
| throw NoSuchElementException(); |
| } |
| |
| // XUIConfigurationPersistence |
| void UIConfigurationManagerImpl::reload() throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) |
| { |
| // Try to access our module sub folder |
| ConfigEventNotifyContainer aRemoveNotifyContainer; |
| ConfigEventNotifyContainer aReplaceNotifyContainer; |
| for ( sal_Int16 i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| try |
| { |
| UIElementType& rUserElementType = m_aUIElements[LAYER_USERDEFINED][i]; |
| UIElementType& rDefaultElementType = m_aUIElements[LAYER_DEFAULT][i]; |
| |
| if ( rUserElementType.bModified ) |
| impl_reloadElementTypeData( rUserElementType, rDefaultElementType, aRemoveNotifyContainer, aReplaceNotifyContainer ); |
| } |
| catch ( Exception& ) |
| { |
| throw IOException(); |
| } |
| } |
| |
| m_bModified = sal_False; |
| |
| // Unlock mutex before notify our listeners |
| aGuard.unlock(); |
| |
| // Notify our listeners |
| ::std::for_each(aRemoveNotifyContainer.begin(),aRemoveNotifyContainer.end(),::boost::bind(&UIConfigurationManagerImpl::implts_notifyContainerListener,this,_1,NotifyOp_Remove)); |
| ::std::for_each(aReplaceNotifyContainer.begin(),aReplaceNotifyContainer.end(),::boost::bind(&UIConfigurationManagerImpl::implts_notifyContainerListener,this,_1,NotifyOp_Replace)); |
| } |
| } |
| |
| void UIConfigurationManagerImpl::store() throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) |
| { |
| // Try to access our module sub folder |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| try |
| { |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; |
| Reference< XStorage > xStorage( rElementType.xStorage, UNO_QUERY ); |
| |
| if ( rElementType.bModified && xStorage.is() ) |
| { |
| impl_storeElementTypeData( xStorage, rElementType ); |
| m_pStorageHandler[i]->commitUserChanges(); |
| } |
| } |
| catch ( Exception& ) |
| { |
| throw IOException(); |
| } |
| } |
| |
| m_bModified = false; |
| } |
| } |
| |
| void UIConfigurationManagerImpl::storeToStorage( const Reference< XStorage >& Storage ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| if ( m_bDisposed ) |
| throw DisposedException(); |
| |
| if ( m_xUserConfigStorage.is() && m_bModified && !m_bReadOnly ) |
| { |
| // Try to access our module sub folder |
| for ( int i = 1; i < ::com::sun::star::ui::UIElementType::COUNT; i++ ) |
| { |
| try |
| { |
| Reference< XStorage > xElementTypeStorage( Storage->openStorageElement( |
| rtl::OUString::createFromAscii( UIELEMENTTYPENAMES[i] ), ElementModes::READWRITE )); |
| UIElementType& rElementType = m_aUIElements[LAYER_USERDEFINED][i]; |
| |
| if ( rElementType.bModified && xElementTypeStorage.is() ) |
| impl_storeElementTypeData( xElementTypeStorage, rElementType, false ); // store data to storage, but don't reset modify flag! |
| } |
| catch ( Exception& ) |
| { |
| throw IOException(); |
| } |
| } |
| |
| Reference< XTransactedObject > xTransactedObject( Storage, UNO_QUERY ); |
| if ( xTransactedObject.is() ) |
| xTransactedObject->commit(); |
| } |
| } |
| |
| sal_Bool UIConfigurationManagerImpl::isModified() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| return m_bModified; |
| } |
| |
| sal_Bool UIConfigurationManagerImpl::isReadOnly() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ResetableGuard aGuard( m_aLock ); |
| |
| return m_bReadOnly; |
| } |
| |
| void UIConfigurationManagerImpl::implts_notifyContainerListener( const ConfigurationEvent& aEvent, NotifyOp eOp ) |
| { |
| ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( ::getCppuType( ( const css::uno::Reference< ::com::sun::star::ui::XUIConfigurationListener >*) NULL ) ); |
| if ( pContainer != NULL ) |
| { |
| ::cppu::OInterfaceIteratorHelper pIterator( *pContainer ); |
| while ( pIterator.hasMoreElements() ) |
| { |
| try |
| { |
| switch ( eOp ) |
| { |
| case NotifyOp_Replace: |
| ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementReplaced( aEvent ); |
| break; |
| case NotifyOp_Insert: |
| ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementInserted( aEvent ); |
| break; |
| case NotifyOp_Remove: |
| ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementRemoved( aEvent ); |
| break; |
| } |
| } |
| catch( css::uno::RuntimeException& ) |
| { |
| pIterator.remove(); |
| } |
| } |
| } |
| } |
| |
| } // namespace framework |
