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