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