?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / framework / source / services / pathsettings.cxx
blob8871fea73456488b77a69a45dfb524d0231de6ad
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: pathsettings.cxx,v $
10 * $Revision: 1.12 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_framework.hxx"
33 // ______________________________________________
34 // my own includes
35
36 /** Attention: stl headers must(!) be included at first. Otherwhise it can make trouble
37 with solaris headers ...
38 */
39 #include <vector>
40 #include <services/pathsettings.hxx>
41 #include <threadhelp/readguard.hxx>
42 #include <threadhelp/writeguard.hxx>
43 #include <services.h>
44
45 // ______________________________________________
46 // interface includes
47 #include <com/sun/star/beans/Property.hpp>
48 #include <com/sun/star/beans/XProperty.hpp>
49 #include <com/sun/star/beans/PropertyAttribute.hpp>
50 #include <com/sun/star/container/XContainer.hpp>
51 #include <com/sun/star/beans/XPropertySet.hpp>
52 #include <com/sun/star/util/XChangesNotifier.hpp>
53
54 // ______________________________________________
55 // includes of other projects
56 #include <tools/urlobj.hxx>
57 #include <rtl/ustrbuf.hxx>
58 #include <rtl/logfile.hxx>
59
60 #include <comphelper/configurationhelper.hxx>
61 #include <unotools/configpathes.hxx>
62
63 // ______________________________________________
64 // non exported const
65
66 #define CFG_READONLY_DEFAULT sal_False
67
68 const ::rtl::OUString CFGPROP_INTERNALPATHES = ::rtl::OUString::createFromAscii("InternalPaths");
69 const ::rtl::OUString CFGPROP_USERPATHES = ::rtl::OUString::createFromAscii("UserPaths" );
70 const ::rtl::OUString CFGPROP_WRITEPATH = ::rtl::OUString::createFromAscii("WritePath" );
71 const ::rtl::OUString CFGPROP_ISSINGLEPATH = ::rtl::OUString::createFromAscii("IsSinglePath" );
72
73 /*
74 0 : old style "Template" string using ";" as seperator
75 1 : internal paths "Template_internal" string list
76 2 : user paths "Template_user" string list
77 3 : write path "Template_write" string
78 */
79
80 const ::rtl::OUString POSTFIX_INTERNAL_PATHES = ::rtl::OUString::createFromAscii("_internal");
81 const ::rtl::OUString POSTFIX_USER_PATHES = ::rtl::OUString::createFromAscii("_user" );
82 const ::rtl::OUString POSTFIX_WRITE_PATH = ::rtl::OUString::createFromAscii("_writable");
83
84 const sal_Int32 IDGROUP_OLDSTYLE = 0;
85 const sal_Int32 IDGROUP_INTERNAL_PATHES = 1;
86 const sal_Int32 IDGROUP_USER_PATHES = 2;
87 const sal_Int32 IDGROUP_WRITE_PATH = 3;
88
89 const sal_Int32 IDGROUP_COUNT = 4;
90
91 sal_Int32 impl_getPropGroup(sal_Int32 nID)
92 {
93 return (nID % IDGROUP_COUNT);
94 }
95
96 // ______________________________________________
97 // namespace
98
99 namespace framework
100 {
101
102 //-----------------------------------------------------------------------------
103 // XInterface, XTypeProvider, XServiceInfo
104
105 DEFINE_XINTERFACE_7 ( PathSettings ,
106 OWeakObject ,
107 DIRECT_INTERFACE ( css::lang::XTypeProvider ),
108 DIRECT_INTERFACE ( css::lang::XServiceInfo ),
109 DERIVED_INTERFACE( css::lang::XEventListener, css::util::XChangesListener),
110 DIRECT_INTERFACE ( css::util::XChangesListener ),
111 DIRECT_INTERFACE ( css::beans::XPropertySet ),
112 DIRECT_INTERFACE ( css::beans::XFastPropertySet ),
113 DIRECT_INTERFACE ( css::beans::XMultiPropertySet )
114 )
115
116 DEFINE_XTYPEPROVIDER_7 ( PathSettings ,
117 css::lang::XTypeProvider ,
118 css::lang::XServiceInfo ,
119 css::lang::XEventListener ,
120 css::util::XChangesListener ,
121 css::beans::XPropertySet ,
122 css::beans::XFastPropertySet ,
123 css::beans::XMultiPropertySet
124 )
125
126 DEFINE_XSERVICEINFO_ONEINSTANCESERVICE ( PathSettings ,
127 ::cppu::OWeakObject ,
128 SERVICENAME_PATHSETTINGS ,
129 IMPLEMENTATIONNAME_PATHSETTINGS
130 )
131
132 DEFINE_INIT_SERVICE ( PathSettings,
133 {
134 /*Attention
135 I think we don't need any mutex or lock here ... because we are called by our own static method impl_createInstance()
136 to create a new instance of this class by our own supported service factory.
137 see macro DEFINE_XSERVICEINFO_MULTISERVICE and "impl_initService()" for further informations!
138 */
139
140 // fill cache
141 impl_readAll();
142 }
143 )
144
145 //-----------------------------------------------------------------------------
146 PathSettings::PathSettings( const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR )
147 // Init baseclasses first
148 // Attention: Don't change order of initialization!
149 // ThreadHelpBase is a struct with a lock as member. We can't use a lock as direct member!
150 // We must garant right initialization and a valid value of this to initialize other baseclasses!
151 : ThreadHelpBase()
152 , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >(m_aLock.getShareableOslMutex())
153 , ::cppu::OPropertySetHelper(*(static_cast< ::cppu::OBroadcastHelper* >(this)))
154 , ::cppu::OWeakObject()
155 // Init member
156 , m_xSMGR (xSMGR)
157 , m_pPropHelp(0 )
158 , m_bIgnoreEvents(sal_False)
159 {
160 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::PathSettings" );
161 }
162
163 //-----------------------------------------------------------------------------
164 PathSettings::~PathSettings()
165 {
166 if (m_pPropHelp)
167 delete m_pPropHelp;
168 }
169
170 //-----------------------------------------------------------------------------
171 void SAL_CALL PathSettings::changesOccurred(const css::util::ChangesEvent& aEvent)
172 throw (css::uno::RuntimeException)
173 {
174 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::changesOccurred" );
175 /*
176 if (m_bIgnoreEvents)
177 return;
178 */
179
180 sal_Int32 c = aEvent.Changes.getLength();
181 sal_Int32 i = 0;
182 sal_Bool bUpdateDescriptor = sal_False;
183
184 for (i=0; i<c; ++i)
185 {
186 const css::util::ElementChange& aChange = aEvent.Changes[i];
187
188 ::rtl::OUString sChanged;
189 aChange.Accessor >>= sChanged;
190
191 ::rtl::OUString sPath = ::utl::extractFirstFromConfigurationPath(sChanged);
192 if (sPath.getLength())
193 {
194 PathSettings::EChangeOp eOp = impl_updatePath(sPath, sal_True);
195 if (
196 (eOp == PathSettings::E_ADDED ) ||
197 (eOp == PathSettings::E_REMOVED)
198 )
199 bUpdateDescriptor = sal_True;
200 }
201 }
202
203 if (bUpdateDescriptor)
204 impl_rebuildPropertyDescriptor();
205 }
206
207 //-----------------------------------------------------------------------------
208 void SAL_CALL PathSettings::disposing(const css::lang::EventObject& aSource)
209 throw(css::uno::RuntimeException)
210 {
211 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::disposing" );
212 // SAFE ->
213 WriteGuard aWriteLock(m_aLock);
214
215 if (aSource.Source == m_xCfgNew)
216 m_xCfgNew.clear();
217
218 aWriteLock.unlock();
219 // <- SAFE
220 }
221
222 //-----------------------------------------------------------------------------
223 void PathSettings::impl_readAll()
224 {
225 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::impl_readAll" );
226 RTL_LOGFILE_CONTEXT(aLog, "framework (as96863) ::PathSettings::load config (all)");
227
228 // TODO think about me
229 css::uno::Reference< css::container::XNameAccess > xCfg = fa_getCfgNew();
230 css::uno::Sequence< ::rtl::OUString > lPaths = xCfg->getElementNames();
231
232 sal_Int32 c = lPaths.getLength();
233 sal_Int32 i = 0;
234
235 for (i=0; i<c; ++i)
236 {
237 const ::rtl::OUString& sPath = lPaths[i];
238 impl_updatePath(sPath, sal_False);
239 }
240
241 impl_rebuildPropertyDescriptor();
242 }
243
244 //-----------------------------------------------------------------------------
245 // NO substitution here ! It's done outside ...
246 OUStringList PathSettings::impl_readOldFormat(const ::rtl::OUString& sPath)
247 {
248 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::impl_readOldFormat" );
249 css::uno::Reference< css::container::XNameAccess > xCfg = fa_getCfgOld();
250 css::uno::Any aVal = xCfg->getByName(sPath);
251
252 ::rtl::OUString sStringVal;
253 css::uno::Sequence< ::rtl::OUString > lStringListVal;
254 OUStringList aPathVal;
255
256 if (aVal >>= sStringVal)
257 {
258 aPathVal.push_back(sStringVal);
259 }
260 else
261 if (aVal >>= lStringListVal)
262 {
263 aPathVal << lStringListVal;
264 }
265
266 return aPathVal;
267 }
268
269 //-----------------------------------------------------------------------------
270 // NO substitution here ! It's done outside ...
271 PathSettings::PathInfo PathSettings::impl_readNewFormat(const ::rtl::OUString& sPath)
272 {
273 css::uno::Reference< css::container::XNameAccess > xCfg = fa_getCfgNew();
274
275 // get access to the "queried" path
276 css::uno::Reference< css::container::XNameAccess > xPath;
277 xCfg->getByName(sPath) >>= xPath;
278
279 PathSettings::PathInfo aPathVal;
280
281 // read internal path list
282 css::uno::Reference< css::container::XNameAccess > xIPath;
283 xPath->getByName(CFGPROP_INTERNALPATHES) >>= xIPath;
284 aPathVal.lInternalPaths << xIPath->getElementNames();
285
286 // read user defined path list
287 aPathVal.lUserPaths << xPath->getByName(CFGPROP_USERPATHES);
288
289 // read the writeable path
290 xPath->getByName(CFGPROP_WRITEPATH) >>= aPathVal.sWritePath;
291
292 // read state props
293 xPath->getByName(CFGPROP_ISSINGLEPATH) >>= aPathVal.bIsSinglePath;
294
295 // analyze finalized/mandatory states
296 aPathVal.bIsReadonly = sal_False;
297 css::uno::Reference< css::beans::XProperty > xInfo(xPath, css::uno::UNO_QUERY);
298 if (xInfo.is())
299 {
300 css::beans::Property aInfo = xInfo->getAsProperty();
301 sal_Bool bFinalized = ((aInfo.Attributes & css::beans::PropertyAttribute::READONLY ) == css::beans::PropertyAttribute::READONLY );
302 //sal_Bool bMandatory = ((aInfo.Attributes & css::beans::PropertyAttribute::REMOVEABLE) != css::beans::PropertyAttribute::REMOVEABLE);
303
304 // Note: Till we support finalized / mandatory on our API more in detail we handle
305 // all states simple as READONLY ! But because all realy needed pathes are "mandatory" by default
306 // we have to handle "finalized" as the real "readonly" indicator .
307 aPathVal.bIsReadonly = bFinalized;
308 }
309
310 return aPathVal;
311 }
312
313 //-----------------------------------------------------------------------------
314 void PathSettings::impl_storePath(const PathSettings::PathInfo& aPath)
315 {
316 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::impl_storePath" );
317 m_bIgnoreEvents = sal_True;
318
319 css::uno::Reference< css::container::XNameAccess > xCfgNew = fa_getCfgNew();
320 css::uno::Reference< css::container::XNameAccess > xCfgOld = fa_getCfgOld();
321
322 // try to replace path-parts with well known and uspported variables.
323 // So an office can be moved easialy to another location without loosing
324 // it's related pathes.
325 PathInfo aResubstPath(aPath);
326 impl_subst(aResubstPath, sal_True);
327
328 // update new configuration
329 if (! aResubstPath.bIsSinglePath)
330 {
331 ::comphelper::ConfigurationHelper::writeRelativeKey(xCfgNew,
332 aResubstPath.sPathName,
333 CFGPROP_USERPATHES,
334 css::uno::makeAny(aResubstPath.lUserPaths.getAsConstList()));
335 }
336
337 ::comphelper::ConfigurationHelper::writeRelativeKey(xCfgNew,
338 aResubstPath.sPathName,
339 CFGPROP_WRITEPATH,
340 css::uno::makeAny(aResubstPath.sWritePath));
341
342 ::comphelper::ConfigurationHelper::flush(xCfgNew);
343
344 // remove the whole path from the old configuration !
345 // Otherwise we cant make sure that the diff between new and old configuration
346 // on loading time realy represent an user setting !!!
347
348 // Check if the given path exists inside the old configuration.
349 // Because our new configuration knows more then the list of old pathes ... !
350 if (xCfgOld->hasByName(aResubstPath.sPathName))
351 {
352 css::uno::Reference< css::beans::XPropertySet > xProps(xCfgOld, css::uno::UNO_QUERY_THROW);
353 xProps->setPropertyValue(aResubstPath.sPathName, css::uno::Any());
354 ::comphelper::ConfigurationHelper::flush(xCfgOld);
355 }
356
357 m_bIgnoreEvents = sal_False;
358 }
359
360 //-----------------------------------------------------------------------------
361 #ifdef MIGRATE_OLD_USER_PATHES
362 void PathSettings::impl_mergeOldUserPaths( PathSettings::PathInfo& rPath,
363 const OUStringList& lOld )
364 {
365 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "PathSettings::impl_mergeOldUserPaths" );
366 OUStringList::const_iterator pIt;
367 for ( pIt = lOld.begin();
368 pIt != lOld.end() ;
369 ++pIt )
370 {
371 const ::rtl::OUString& sOld = *pIt;
372
373 if (rPath.bIsSinglePath)
374 {
375 LOG_ASSERT2(lOld.size()>1, "PathSettings::impl_mergeOldUserPaths()", "Single path has more then one path value inside old configuration (Common.xcu)!")
376 if (! rPath.sWritePath.equals(sOld))
377 rPath.sWritePath = sOld;
378 }
379 else
380 {
381 if (
382 ( rPath.lInternalPaths.findConst(sOld) == rPath.lInternalPaths.end()) &&
383 ( rPath.lUserPaths.findConst(sOld) == rPath.lUserPaths.end() ) &&
384 (! rPath.sWritePath.equals(sOld) )
385 )
386 rPath.lUserPaths.push_back(sOld);
387 }
388 }
389 }
390 #endif // MIGRATE_OLD_USER_PATHES
391
392 //-----------------------------------------------------------------------------
393 PathSettings::EChangeOp PathSettings::impl_updatePath(const ::rtl::OUString& sPath ,
394 sal_Bool bNotifyListener)
395 {
396 // SAFE ->
397 WriteGuard aWriteLock(m_aLock);
398
399 PathSettings::PathInfo* pPathOld = 0;
400 PathSettings::PathInfo* pPathNew = 0;
401 PathSettings::EChangeOp eOp = PathSettings::E_UNDEFINED;
402 PathSettings::PathInfo aPath;
403
404 try
405 {
406 aPath = impl_readNewFormat(sPath);
407 aPath.sPathName = sPath;
408 // replace all might existing variables with real values
409 // Do it before these old pathes will be compared against the
410 // new path configuration. Otherwise some striungs uses different variables ... but substitution
411 // will produce strings with same content (because some variables are redundant!)
412 impl_subst(aPath, sal_False);
413 }
414 catch(const css::uno::RuntimeException& exRun)
415 { throw exRun; }
416 catch(const css::container::NoSuchElementException&)
417 { eOp = PathSettings::E_REMOVED; }
418 catch(const css::uno::Exception& exAny)
419 { throw exAny; }
420
421 #ifdef MIGRATE_OLD_USER_PATHES
422 try
423 {
424 // migration of old user defined values on demand
425 // can be disabled for a new major
426 OUStringList lOldVals = impl_readOldFormat(sPath);
427 // replace all might existing variables with real values
428 // Do it before these old pathes will be compared against the
429 // new path configuration. Otherwise some striungs uses different variables ... but substitution
430 // will produce strings with same content (because some variables are redundant!)
431 impl_subst(lOldVals, fa_getSubstitution(), sal_False);
432 impl_mergeOldUserPaths(aPath, lOldVals);
433 }
434 catch(const css::uno::RuntimeException& exRun)
435 { throw exRun; }
436 // Normal(!) exceptions can be ignored!
437 // E.g. in case an addon installs a new path, which was not well known for an OOo 1.x installation
438 // we cant find a value for it inside the "old" configuration. So a NoSuchElementException
439 // will be normal .-)
440 catch(const css::uno::Exception&)
441 {}
442 #endif // MIGRATE_OLD_USER_PATHES
443
444 PathSettings::PathHash::iterator pPath = m_lPaths.find(sPath);
445 if (eOp == PathSettings::E_UNDEFINED)
446 {
447 if (pPath != m_lPaths.end())
448 eOp = PathSettings::E_CHANGED;
449 else
450 eOp = PathSettings::E_ADDED;
451 }
452
453 switch(eOp)
454 {
455 case PathSettings::E_ADDED :
456 {
457 if (bNotifyListener)
458 {
459 pPathOld = 0;
460 pPathNew = &aPath;
461 impl_notifyPropListener(eOp, sPath, pPathOld, pPathNew);
462 }
463 m_lPaths[sPath] = aPath;
464 }
465 break;
466
467 case PathSettings::E_CHANGED :
468 {
469 if (bNotifyListener)
470 {
471 pPathOld = &(pPath->second);
472 pPathNew = &aPath;
473 impl_notifyPropListener(eOp, sPath, pPathOld, pPathNew);
474 }
475 m_lPaths[sPath] = aPath;
476 }
477 break;
478
479 case PathSettings::E_REMOVED :
480 {
481 if (pPath != m_lPaths.end())
482 {
483 if (bNotifyListener)
484 {
485 pPathOld = &(pPath->second);
486 pPathNew = 0;
487 impl_notifyPropListener(eOp, sPath, pPathOld, pPathNew);
488 }
489 m_lPaths.erase(pPath);
490 }
491 }
492 break;
493
494 default: // to let compiler be happy
495 break;
496 }
497
498 return eOp;
499 }
500
501 //-----------------------------------------------------------------------------
502 css::uno::Sequence< sal_Int32 > PathSettings::impl_mapPathName2IDList(const ::rtl::OUString& sPath)
503 {
504 ::rtl::OUString sOldStyleProp = sPath;
505 ::rtl::OUString sInternalProp = sPath+POSTFIX_INTERNAL_PATHES;
506 ::rtl::OUString sUserProp = sPath+POSTFIX_USER_PATHES;
507 ::rtl::OUString sWriteProp = sPath+POSTFIX_WRITE_PATH;
508
509 // Attention: The default set of IDs is fix and must follow these schema.
510 // Otherwhise the outside code ant work for new added properties.
511 // Why ?
512 // The outside code must fire N events for every changed property.
513 // And the knowing about packaging of variables of the structure PathInfo
514 // follow these group IDs ! But if such ID isnt in the range of [0..IDGROUP_COUNT]
515 // the outside cant determine the right group ... and cant fire the right events .-)
516
517 css::uno::Sequence< sal_Int32 > lIDs(IDGROUP_COUNT);
518 lIDs[0] = IDGROUP_OLDSTYLE ;
519 lIDs[1] = IDGROUP_INTERNAL_PATHES;
520 lIDs[2] = IDGROUP_USER_PATHES ;
521 lIDs[3] = IDGROUP_WRITE_PATH ;
522
523 sal_Int32 c = m_lPropDesc.getLength();
524 sal_Int32 i = 0;
525 for (i=0; i<c; ++i)
526 {
527 const css::beans::Property& rProp = m_lPropDesc[i];
528
529 if (rProp.Name.equals(sOldStyleProp))
530 lIDs[IDGROUP_OLDSTYLE] = rProp.Handle;
531 else
532 if (rProp.Name.equals(sInternalProp))
533 lIDs[IDGROUP_INTERNAL_PATHES] = rProp.Handle;
534 else
535 if (rProp.Name.equals(sUserProp))
536 lIDs[IDGROUP_USER_PATHES] = rProp.Handle;
537 else
538 if (rProp.Name.equals(sWriteProp))
539 lIDs[IDGROUP_WRITE_PATH] = rProp.Handle;
540 }
541
542 return lIDs;
543 }
544
545 //-----------------------------------------------------------------------------
546 void PathSettings::impl_notifyPropListener( PathSettings::EChangeOp /*eOp*/ ,
547 const ::rtl::OUString& sPath ,
548 const PathSettings::PathInfo* pPathOld,
549 const PathSettings::PathInfo* pPathNew)
550 {
551 css::uno::Sequence< sal_Int32 > lHandles(1);
552 css::uno::Sequence< css::uno::Any > lOldVals(1);
553 css::uno::Sequence< css::uno::Any > lNewVals(1);
554
555 css::uno::Sequence< sal_Int32 > lIDs = impl_mapPathName2IDList(sPath);
556 sal_Int32 c = lIDs.getLength();
557 sal_Int32 i = 0;
558 sal_Int32 nMaxID = m_lPropDesc.getLength()-1;
559 for (i=0; i<c; ++i)
560 {
561 sal_Int32 nID = lIDs[i];
562
563 if (
564 (nID < 0 ) ||
565 (nID > nMaxID)
566 )
567 continue;
568
569 lHandles[0] = nID;
570 switch(impl_getPropGroup(nID))
571 {
572 case IDGROUP_OLDSTYLE :
573 {
574 if (pPathOld)
575 {
576 ::rtl::OUString sVal = impl_convertPath2OldStyle(*pPathOld);
577 lOldVals[0] <<= sVal;
578 }
579 if (pPathNew)
580 {
581 ::rtl::OUString sVal = impl_convertPath2OldStyle(*pPathNew);
582 lNewVals[0] <<= sVal;
583 }
584 }
585 break;
586
587 case IDGROUP_INTERNAL_PATHES :
588 {
589 if (pPathOld)
590 lOldVals[0] <<= pPathOld->lInternalPaths.getAsConstList();
591 if (pPathNew)
592 lNewVals[0] <<= pPathNew->lInternalPaths.getAsConstList();
593 }
594 break;
595
596 case IDGROUP_USER_PATHES :
597 {
598 if (pPathOld)
599 lOldVals[0] <<= pPathOld->lUserPaths.getAsConstList();
600 if (pPathNew)
601 lNewVals[0] <<= pPathNew->lUserPaths.getAsConstList();
602 }
603 break;
604
605 case IDGROUP_WRITE_PATH :
606 {
607 if (pPathOld)
608 lOldVals[0] <<= pPathOld->sWritePath;
609 if (pPathNew)
610 lNewVals[0] <<= pPathNew->sWritePath;
611 }
612 break;
613 }
614
615 fire(lHandles.getArray(),
616 lNewVals.getArray(),
617 lOldVals.getArray(),
618 1,
619 sal_False);
620 }
621 }
622
623 //-----------------------------------------------------------------------------
624 void PathSettings::impl_subst( OUStringList& lVals ,
625 const css::uno::Reference< css::util::XStringSubstitution >& xSubst ,
626 sal_Bool bReSubst)
627 {
628 OUStringList::iterator pIt;
629
630 for ( pIt = lVals.begin();
631 pIt != lVals.end() ;
632 ++pIt )
633 {
634 const ::rtl::OUString& sOld = *pIt;
635 ::rtl::OUString sNew ;
636 if (bReSubst)
637 sNew = xSubst->reSubstituteVariables(sOld);
638 else
639 sNew = xSubst->substituteVariables(sOld, sal_False);
640
641 *pIt = sNew;
642 }
643 }
644
645 //-----------------------------------------------------------------------------
646 void PathSettings::impl_subst(PathSettings::PathInfo& aPath ,
647 sal_Bool bReSubst)
648 {
649 css::uno::Reference< css::util::XStringSubstitution > xSubst = fa_getSubstitution();
650
651 impl_subst(aPath.lInternalPaths, xSubst, bReSubst);
652 impl_subst(aPath.lUserPaths , xSubst, bReSubst);
653 if (bReSubst)
654 aPath.sWritePath = xSubst->reSubstituteVariables(aPath.sWritePath);
655 else
656 aPath.sWritePath = xSubst->substituteVariables(aPath.sWritePath, sal_False);
657 }
658
659 //-----------------------------------------------------------------------------
660 ::rtl::OUString PathSettings::impl_convertPath2OldStyle(const PathSettings::PathInfo& rPath) const
661 {
662 OUStringList::const_iterator pIt;
663 OUStringList lTemp;
664 lTemp.reserve(rPath.lInternalPaths.size() + rPath.lUserPaths.size() + 1);
665
666 for ( pIt = rPath.lInternalPaths.begin();
667 pIt != rPath.lInternalPaths.end() ;
668 ++pIt )
669 {
670 lTemp.push_back(*pIt);
671 }
672 for ( pIt = rPath.lUserPaths.begin();
673 pIt != rPath.lUserPaths.end() ;
674 ++pIt )
675 {
676 lTemp.push_back(*pIt);
677 }
678
679 if (rPath.sWritePath.getLength() > 0)
680 lTemp.push_back(rPath.sWritePath);
681
682 ::rtl::OUStringBuffer sPathVal(256);
683 for ( pIt = lTemp.begin();
684 pIt != lTemp.end() ;
685 )
686 {
687 sPathVal.append(*pIt);
688 ++pIt;
689 if (pIt != lTemp.end())
690 sPathVal.appendAscii(";");
691 }
692
693 return sPathVal.makeStringAndClear();
694 }
695
696 //-----------------------------------------------------------------------------
697 OUStringList PathSettings::impl_convertOldStyle2Path(const ::rtl::OUString& sOldStylePath) const
698 {
699 OUStringList lList;
700 sal_Int32 nToken = 0;
701 do
702 {
703 ::rtl::OUString sToken = sOldStylePath.getToken(0, ';', nToken);
704 if (sToken.getLength())
705 lList.push_back(sToken);
706 }
707 while(nToken >= 0);
708
709 return lList;
710 }
711
712 //-----------------------------------------------------------------------------
713 void PathSettings::impl_purgeKnownPaths(const PathSettings::PathInfo& rPath,
714 OUStringList& lList)
715 {
716 OUStringList::const_iterator pIt;
717 for ( pIt = rPath.lInternalPaths.begin();
718 pIt != rPath.lInternalPaths.end() ;
719 ++pIt )
720 {
721 const ::rtl::OUString& rItem = *pIt;
722 OUStringList::iterator pItem = lList.find(rItem);
723 if (pItem != lList.end())
724 lList.erase(pItem);
725 }
726 for ( pIt = rPath.lUserPaths.begin();
727 pIt != rPath.lUserPaths.end() ;
728 ++pIt )
729 {
730 const ::rtl::OUString& rItem = *pIt;
731 OUStringList::iterator pItem = lList.find(rItem);
732 if (pItem != lList.end())
733 lList.erase(pItem);
734 }
735
736 OUStringList::iterator pItem = lList.find(rPath.sWritePath);
737 if (pItem != lList.end())
738 lList.erase(pItem);
739 }
740
741 //-----------------------------------------------------------------------------
742 void PathSettings::impl_rebuildPropertyDescriptor()
743 {
744 // SAFE ->
745 WriteGuard aWriteLock(m_aLock);
746
747 sal_Int32 c = (sal_Int32)m_lPaths.size();
748 sal_Int32 i = 0;
749 m_lPropDesc.realloc(c*IDGROUP_COUNT);
750
751 PathHash::const_iterator pIt;
752 for ( pIt = m_lPaths.begin();
753 pIt != m_lPaths.end() ;
754 ++pIt )
755 {
756 const PathSettings::PathInfo& rPath = pIt->second;
757 css::beans::Property* pProp = 0;
758
759 pProp = &(m_lPropDesc[i]);
760 pProp->Name = rPath.sPathName;
761 pProp->Handle = i;
762 pProp->Type = ::getCppuType((::rtl::OUString*)0);
763 pProp->Attributes = css::beans::PropertyAttribute::BOUND;
764 if (rPath.bIsReadonly)
765 pProp->Attributes |= css::beans::PropertyAttribute::READONLY;
766 ++i;
767
768 pProp = &(m_lPropDesc[i]);
769 pProp->Name = rPath.sPathName+POSTFIX_INTERNAL_PATHES;
770 pProp->Handle = i;
771 pProp->Type = ::getCppuType((css::uno::Sequence< ::rtl::OUString >*)0);
772 pProp->Attributes = css::beans::PropertyAttribute::BOUND |
773 css::beans::PropertyAttribute::READONLY;
774 ++i;
775
776 pProp = &(m_lPropDesc[i]);
777 pProp->Name = rPath.sPathName+POSTFIX_USER_PATHES;
778 pProp->Handle = i;
779 pProp->Type = ::getCppuType((css::uno::Sequence< ::rtl::OUString >*)0);
780 pProp->Attributes = css::beans::PropertyAttribute::BOUND;
781 if (rPath.bIsReadonly)
782 pProp->Attributes |= css::beans::PropertyAttribute::READONLY;
783 ++i;
784
785 pProp = &(m_lPropDesc[i]);
786 pProp->Name = rPath.sPathName+POSTFIX_WRITE_PATH;
787 pProp->Handle = i;
788 pProp->Type = ::getCppuType((::rtl::OUString*)0);
789 pProp->Attributes = css::beans::PropertyAttribute::BOUND;
790 if (rPath.bIsReadonly)
791 pProp->Attributes |= css::beans::PropertyAttribute::READONLY;
792 ++i;
793 }
794
795 if (m_pPropHelp)
796 delete m_pPropHelp;
797 m_pPropHelp = new ::cppu::OPropertyArrayHelper(m_lPropDesc, sal_False); // false => not sorted ... must be done inside helper
798
799 aWriteLock.unlock();
800 // <- SAFE
801 }
802
803 //-----------------------------------------------------------------------------
804 css::uno::Any PathSettings::impl_getPathValue(sal_Int32 nID) const
805 {
806 const PathSettings::PathInfo* pPath = impl_getPathAccessConst(nID);
807 if (! pPath)
808 throw css::container::NoSuchElementException();
809
810 css::uno::Any aVal;
811 switch(impl_getPropGroup(nID))
812 {
813 case IDGROUP_OLDSTYLE :
814 {
815 ::rtl::OUString sVal = impl_convertPath2OldStyle(*pPath);
816 aVal <<= sVal;
817 }
818 break;
819
820 case IDGROUP_INTERNAL_PATHES :
821 {
822 aVal <<= pPath->lInternalPaths.getAsConstList();
823 }
824 break;
825
826 case IDGROUP_USER_PATHES :
827 {
828 aVal <<= pPath->lUserPaths.getAsConstList();
829 }
830 break;
831
832 case IDGROUP_WRITE_PATH :
833 {
834 aVal <<= pPath->sWritePath;
835 }
836 break;
837 }
838
839 return aVal;
840 }
841
842 //-----------------------------------------------------------------------------
843 void PathSettings::impl_setPathValue( sal_Int32 nID ,
844 const css::uno::Any& aVal)
845 {
846 PathSettings::PathInfo* pOrgPath = impl_getPathAccess(nID);
847 if (! pOrgPath)
848 throw css::container::NoSuchElementException();
849
850 // We work on a copied path ... so we can be sure that errors during this operation
851 // does not make our internal cache invalid .-)
852 PathSettings::PathInfo aChangePath(*pOrgPath);
853
854 switch(impl_getPropGroup(nID))
855 {
856 case IDGROUP_OLDSTYLE :
857 {
858 ::rtl::OUString sVal;
859 aVal >>= sVal;
860 OUStringList lList = impl_convertOldStyle2Path(sVal);
861 impl_purgeKnownPaths(aChangePath, lList);
862 if (! impl_isValidPath(lList))
863 throw css::lang::IllegalArgumentException();
864
865 if (aChangePath.bIsSinglePath)
866 {
867 LOG_ASSERT2(lList.size()>1, "PathSettings::impl_setPathValue()", "You try to set more then path value for a defined SINGLE_PATH!")
868 if ( !lList.empty() )
869 aChangePath.sWritePath = *(lList.begin());
870 else
871 aChangePath.sWritePath = ::rtl::OUString();
872 }
873 else
874 {
875 OUStringList::const_iterator pIt;
876 for ( pIt = lList.begin();
877 pIt != lList.end() ;
878 ++pIt )
879 {
880 aChangePath.lUserPaths.push_back(*pIt);
881 }
882 }
883 }
884 break;
885
886 case IDGROUP_INTERNAL_PATHES :
887 {
888 if (aChangePath.bIsSinglePath)
889 {
890 ::rtl::OUStringBuffer sMsg(256);
891 sMsg.appendAscii("The path '" );
892 sMsg.append (aChangePath.sPathName);
893 sMsg.appendAscii("' is defined as SINGLE_PATH. It's sub set of internal pathes cant be set.");
894 throw css::uno::Exception(sMsg.makeStringAndClear(),
895 static_cast< ::cppu::OWeakObject* >(this));
896 }
897
898 OUStringList lList;
899 lList << aVal;
900 if (! impl_isValidPath(lList))
901 throw css::lang::IllegalArgumentException();
902 aChangePath.lInternalPaths = lList;
903 }
904 break;
905
906 case IDGROUP_USER_PATHES :
907 {
908 if (aChangePath.bIsSinglePath)
909 {
910 ::rtl::OUStringBuffer sMsg(256);
911 sMsg.appendAscii("The path '" );
912 sMsg.append (aChangePath.sPathName);
913 sMsg.appendAscii("' is defined as SINGLE_PATH. It's sub set of internal pathes cant be set.");
914 throw css::uno::Exception(sMsg.makeStringAndClear(),
915 static_cast< ::cppu::OWeakObject* >(this));
916 }
917
918 OUStringList lList;
919 lList << aVal;
920 if (! impl_isValidPath(lList))
921 throw css::lang::IllegalArgumentException();
922 aChangePath.lUserPaths = lList;
923 }
924 break;
925
926 case IDGROUP_WRITE_PATH :
927 {
928 ::rtl::OUString sVal;
929 aVal >>= sVal;
930 if (! impl_isValidPath(sVal))
931 throw css::lang::IllegalArgumentException();
932 aChangePath.sWritePath = sVal;
933 }
934 break;
935 }
936
937 // TODO check if path has at least one path value set
938 // At least it depends from the feature using this path, if an empty path list is allowed.
939 /*
940 if (impl_isPathEmpty(aChangePath))
941 {
942 ::rtl::OUStringBuffer sMsg(256);
943 sMsg.appendAscii("The path '" );
944 sMsg.append (aChangePath.sPathName);
945 sMsg.appendAscii("' is empty now ... Not a real good idea.");
946 throw css::uno::Exception(sMsg.makeStringAndClear(),
947 static_cast< ::cppu::OWeakObject* >(this));
948 }
949 */
950
951 // first we should try to store the changed (copied!) path ...
952 // In case an error occure on saving time an exception is thrown ...
953 // If no exception occures we can update our internal cache (means
954 // we can overwrite pOrgPath !
955 impl_storePath(aChangePath);
956 pOrgPath->takeOver(aChangePath);
957 }
958
959 //-----------------------------------------------------------------------------
960 sal_Bool PathSettings::impl_isValidPath(const OUStringList& lPath) const
961 {
962 OUStringList::const_iterator pIt;
963 for ( pIt = lPath.begin();
964 pIt != lPath.end() ;
965 ++pIt )
966 {
967 const ::rtl::OUString& rVal = *pIt;
968 if (! impl_isValidPath(rVal))
969 return sal_False;
970 }
971
972 return sal_True;
973 }
974
975 //-----------------------------------------------------------------------------
976 sal_Bool PathSettings::impl_isValidPath(const ::rtl::OUString& sPath) const
977 {
978 return (! INetURLObject(sPath).HasError());
979 }
980
981 //-----------------------------------------------------------------------------
982 ::rtl::OUString impl_extractBaseFromPropName(const ::rtl::OUString& sPropName)
983 {
984 sal_Int32 i = -1;
985
986 i = sPropName.indexOf(POSTFIX_INTERNAL_PATHES);
987 if (i > -1)
988 return sPropName.copy(0, i);
989 i = sPropName.indexOf(POSTFIX_USER_PATHES);
990 if (i > -1)
991 return sPropName.copy(0, i);
992 i = sPropName.indexOf(POSTFIX_WRITE_PATH);
993 if (i > -1)
994 return sPropName.copy(0, i);
995
996 return sPropName;
997 }
998
999 //-----------------------------------------------------------------------------
1000 PathSettings::PathInfo* PathSettings::impl_getPathAccess(sal_Int32 nHandle)
1001 {
1002 // SAFE ->
1003 ReadGuard aReadLock(m_aLock);
1004
1005 if (nHandle > (m_lPropDesc.getLength()-1))
1006 return 0;
1007
1008 const css::beans::Property& rProp = m_lPropDesc[nHandle];
1009 ::rtl::OUString sProp = impl_extractBaseFromPropName(rProp.Name);
1010 PathSettings::PathHash::iterator rPath = m_lPaths.find(sProp);
1011
1012 if (rPath != m_lPaths.end())
1013 return &(rPath->second);
1014
1015 return 0;
1016 // <- SAFE
1017 }
1018
1019 //-----------------------------------------------------------------------------
1020 const PathSettings::PathInfo* PathSettings::impl_getPathAccessConst(sal_Int32 nHandle) const
1021 {
1022 // SAFE ->
1023 ReadGuard aReadLock(m_aLock);
1024
1025 if (nHandle > (m_lPropDesc.getLength()-1))
1026 return 0;
1027
1028 const css::beans::Property& rProp = m_lPropDesc[nHandle];
1029 ::rtl::OUString sProp = impl_extractBaseFromPropName(rProp.Name);
1030 PathSettings::PathHash::const_iterator rPath = m_lPaths.find(sProp);
1031
1032 if (rPath != m_lPaths.end())
1033 return &(rPath->second);
1034
1035 return 0;
1036 // <- SAFE
1037 }
1038
1039 //-----------------------------------------------------------------------------
1040 sal_Bool SAL_CALL PathSettings::convertFastPropertyValue( css::uno::Any& aConvertedValue,
1041 css::uno::Any& aOldValue ,
1042 sal_Int32 nHandle ,
1043 const css::uno::Any& aValue )
1044 throw(css::lang::IllegalArgumentException)
1045 {
1046 // throws NoSuchElementException !
1047 css::uno::Any aCurrentVal = impl_getPathValue(nHandle);
1048
1049 return PropHelper::willPropertyBeChanged(
1050 aCurrentVal,
1051 aValue,
1052 aOldValue,
1053 aConvertedValue);
1054 }
1055
1056 //-----------------------------------------------------------------------------
1057 void SAL_CALL PathSettings::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle,
1058 const css::uno::Any& aValue )
1059 throw(css::uno::Exception)
1060 {
1061 // throws NoSuchElement- and IllegalArgumentException !
1062 impl_setPathValue(nHandle, aValue);
1063 }
1064
1065 //-----------------------------------------------------------------------------
1066 void SAL_CALL PathSettings::getFastPropertyValue(css::uno::Any& aValue ,
1067 sal_Int32 nHandle) const
1068 {
1069 aValue = impl_getPathValue(nHandle);
1070 }
1071
1072 //-----------------------------------------------------------------------------
1073 ::cppu::IPropertyArrayHelper& SAL_CALL PathSettings::getInfoHelper()
1074 {
1075 return *m_pPropHelp;
1076 }
1077
1078 //-----------------------------------------------------------------------------
1079 css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL PathSettings::getPropertySetInfo()
1080 throw(css::uno::RuntimeException)
1081 {
1082 return css::uno::Reference< css::beans::XPropertySetInfo >(createPropertySetInfo(getInfoHelper()));
1083 }
1084
1085 //-----------------------------------------------------------------------------
1086 css::uno::Reference< css::util::XStringSubstitution > PathSettings::fa_getSubstitution()
1087 {
1088 // SAFE ->
1089 ReadGuard aReadLock(m_aLock);
1090 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = m_xSMGR;
1091 css::uno::Reference< css::util::XStringSubstitution > xSubst = m_xSubstitution;
1092 aReadLock.unlock();
1093 // <- SAFE
1094
1095 if (! xSubst.is())
1096 {
1097 // create the needed substitution service.
1098 // We must replace all used variables inside readed path values.
1099 // In case we can't do so ... the whole office can't work realy.
1100 // That's why it seams to be OK to throw a RuntimeException then.
1101 xSubst = css::uno::Reference< css::util::XStringSubstitution >(
1102 xSMGR->createInstance(SERVICENAME_SUBSTITUTEPATHVARIABLES),
1103 css::uno::UNO_QUERY_THROW);
1104
1105 // SAFE ->
1106 WriteGuard aWriteLock(m_aLock);
1107 m_xSubstitution = xSubst;
1108 aWriteLock.unlock();
1109 }
1110
1111 return xSubst;
1112 }
1113
1114 //-----------------------------------------------------------------------------
1115 css::uno::Reference< css::container::XNameAccess > PathSettings::fa_getCfgOld()
1116 {
1117 const static ::rtl::OUString CFG_NODE_OLD = ::rtl::OUString::createFromAscii("org.openoffice.Office.Common/Path/Current");
1118
1119 // SAFE ->
1120 ReadGuard aReadLock(m_aLock);
1121 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = m_xSMGR;
1122 css::uno::Reference< css::container::XNameAccess > xCfg = m_xCfgOld;
1123 aReadLock.unlock();
1124 // <- SAFE
1125
1126 if (! xCfg.is())
1127 {
1128 xCfg = css::uno::Reference< css::container::XNameAccess >(
1129 ::comphelper::ConfigurationHelper::openConfig(
1130 xSMGR,
1131 CFG_NODE_OLD,
1132 ::comphelper::ConfigurationHelper::E_STANDARD), // not readonly! Somtimes we need write access there !!!
1133 css::uno::UNO_QUERY_THROW);
1134
1135 // SAFE ->
1136 WriteGuard aWriteLock(m_aLock);
1137 m_xCfgOld = xCfg;
1138 aWriteLock.unlock();
1139 }
1140
1141 return xCfg;
1142 }
1143
1144 //-----------------------------------------------------------------------------
1145 css::uno::Reference< css::container::XNameAccess > PathSettings::fa_getCfgNew()
1146 {
1147 const static ::rtl::OUString CFG_NODE_NEW = ::rtl::OUString::createFromAscii("org.openoffice.Office.Paths/Paths");
1148
1149 // SAFE ->
1150 ReadGuard aReadLock(m_aLock);
1151 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = m_xSMGR;
1152 css::uno::Reference< css::container::XNameAccess > xCfg = m_xCfgNew;
1153 aReadLock.unlock();
1154 // <- SAFE
1155
1156 if (! xCfg.is())
1157 {
1158 xCfg = css::uno::Reference< css::container::XNameAccess >(
1159 ::comphelper::ConfigurationHelper::openConfig(
1160 xSMGR,
1161 CFG_NODE_NEW,
1162 ::comphelper::ConfigurationHelper::E_STANDARD),
1163 css::uno::UNO_QUERY_THROW);
1164
1165 // SAFE ->
1166 WriteGuard aWriteLock(m_aLock);
1167 m_xCfgNew = xCfg;
1168 aWriteLock.unlock();
1169
1170 css::uno::Reference< css::util::XChangesNotifier > xBroadcaster(xCfg, css::uno::UNO_QUERY_THROW);
1171 xBroadcaster->addChangesListener(static_cast< css::util::XChangesListener* >(this));
1172 }
1173
1174 return xCfg;
1175 }
1176
1177 } // namespace framework
vba interoperability for OOo