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