?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 7.6.3.2-android, tag libreoffice-7.6.3.2-android
[LibreOffice.git] / unotools / source / config / pathoptions.cxx
blobe7d2bbfd098778addeeda09b453c3114f2a501b3
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21
22 #include <sal/log.hxx>
23 #include <unotools/pathoptions.hxx>
24 #include <comphelper/diagnose_ex.hxx>
25 #include <tools/urlobj.hxx>
26 #include <com/sun/star/uno/Any.hxx>
27 #include <com/sun/star/uno/Sequence.hxx>
28 #include <osl/mutex.hxx>
29 #include <osl/file.hxx>
30
31 #include <unotools/ucbhelper.hxx>
32 #include <comphelper/getexpandeduri.hxx>
33 #include <comphelper/processfactory.hxx>
34 #include <com/sun/star/beans/XFastPropertySet.hpp>
35 #include <com/sun/star/beans/XPropertySetInfo.hpp>
36 #include <com/sun/star/util/thePathSettings.hpp>
37 #include <com/sun/star/util/PathSubstitution.hpp>
38 #include <com/sun/star/util/XStringSubstitution.hpp>
39 #include <com/sun/star/util/theMacroExpander.hpp>
40 #include <o3tl/enumarray.hxx>
41 #include <o3tl/string_view.hxx>
42
43 #include "itemholder1.hxx"
44
45 #include <set>
46 #include <unordered_map>
47
48 using namespace osl;
49 using namespace utl;
50 using namespace com::sun::star::uno;
51 using namespace com::sun::star::beans;
52 using namespace com::sun::star::util;
53 using namespace com::sun::star::lang;
54
55 #define SEARCHPATH_DELIMITER ';'
56 #define SIGN_STARTVARIABLE "$("
57 #define SIGN_ENDVARIABLE ")"
58
59 // Supported variables by the old SvtPathOptions implementation
60 #define SUBSTITUTE_INSTPATH "$(instpath)"
61 #define SUBSTITUTE_PROGPATH "$(progpath)"
62 #define SUBSTITUTE_USERPATH "$(userpath)"
63 #define SUBSTITUTE_PATH "$(path)"
64
65 #define STRPOS_NOTFOUND -1
66
67 typedef std::unordered_map<OUString, sal_Int32> NameToHandleMap;
68
69 typedef std::set<OUString> VarNameSet;
70
71 // class SvtPathOptions_Impl ---------------------------------------------
72 class SvtPathOptions_Impl
73 {
74 private:
75 // Local variables to return const references
76 o3tl::enumarray< SvtPathOptions::Paths, OUString > m_aPathArray;
77 Reference< XFastPropertySet > m_xPathSettings;
78 Reference< XStringSubstitution > m_xSubstVariables;
79 Reference< XMacroExpander > m_xMacroExpander;
80 mutable std::unordered_map<SvtPathOptions::Paths, sal_Int32>
81 m_aMapEnumToPropHandle;
82 VarNameSet m_aSystemPathVarNames;
83
84 OUString m_aEmptyString;
85 mutable std::mutex m_aMutex;
86
87 public:
88 SvtPathOptions_Impl();
89
90 // get the paths, not const because of using a mutex
91 const OUString& GetPath( SvtPathOptions::Paths );
92 const OUString& GetAddinPath() { return GetPath( SvtPathOptions::Paths::AddIn ); }
93 const OUString& GetAutoCorrectPath() { return GetPath( SvtPathOptions::Paths::AutoCorrect ); }
94 const OUString& GetAutoTextPath() { return GetPath( SvtPathOptions::Paths::AutoText ); }
95 const OUString& GetBackupPath() { return GetPath( SvtPathOptions::Paths::Backup ); }
96 const OUString& GetBasicPath() { return GetPath( SvtPathOptions::Paths::Basic ); }
97 const OUString& GetBitmapPath() { return GetPath( SvtPathOptions::Paths::Bitmap ); }
98 const OUString& GetConfigPath() { return GetPath( SvtPathOptions::Paths::Config ); }
99 const OUString& GetDictionaryPath() { return GetPath( SvtPathOptions::Paths::Dictionary ); }
100 const OUString& GetFavoritesPath() { return GetPath( SvtPathOptions::Paths::Favorites ); }
101 const OUString& GetFilterPath() { return GetPath( SvtPathOptions::Paths::Filter ); }
102 const OUString& GetGalleryPath() { return GetPath( SvtPathOptions::Paths::Gallery ); }
103 const OUString& GetGraphicPath() { return GetPath( SvtPathOptions::Paths::Graphic ); }
104 const OUString& GetHelpPath() { return GetPath( SvtPathOptions::Paths::Help ); }
105 const OUString& GetLinguisticPath() { return GetPath( SvtPathOptions::Paths::Linguistic ); }
106 const OUString& GetModulePath() { return GetPath( SvtPathOptions::Paths::Module ); }
107 const OUString& GetPalettePath() { return GetPath( SvtPathOptions::Paths::Palette ); }
108 const OUString& GetIconsetPath() { return GetPath( SvtPathOptions::Paths::IconSet); }
109 const OUString& GetPluginPath() { return GetPath( SvtPathOptions::Paths::Plugin ); }
110 const OUString& GetStoragePath() { return GetPath( SvtPathOptions::Paths::Storage ); }
111 const OUString& GetTempPath() { return GetPath( SvtPathOptions::Paths::Temp ); }
112 const OUString& GetTemplatePath() { return GetPath( SvtPathOptions::Paths::Template ); }
113 const OUString& GetUserConfigPath() { return GetPath( SvtPathOptions::Paths::UserConfig ); }
114 const OUString& GetWorkPath() { return GetPath( SvtPathOptions::Paths::Work ); }
115 const OUString& GetUIConfigPath() { return GetPath( SvtPathOptions::Paths::UIConfig ); }
116 const OUString& GetFingerprintPath() { return GetPath( SvtPathOptions::Paths::Fingerprint ); }
117 const OUString& GetNumbertextPath() { return GetPath( SvtPathOptions::Paths::NumberText ); }
118 const OUString& GetClassificationPath() { return GetPath( SvtPathOptions::Paths::Classification ); }
119
120 // set the paths
121 void SetPath( SvtPathOptions::Paths, const OUString& rNewPath );
122 void SetAddinPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AddIn, rPath ); }
123 void SetAutoCorrectPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AutoCorrect, rPath ); }
124 void SetAutoTextPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AutoText, rPath ); }
125 void SetBackupPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Backup, rPath ); }
126 void SetBasicPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Basic, rPath ); }
127 void SetBitmapPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Bitmap, rPath ); }
128 void SetConfigPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Config, rPath ); }
129 void SetDictionaryPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Dictionary, rPath ); }
130 void SetFavoritesPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Favorites, rPath ); }
131 void SetFilterPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Filter, rPath ); }
132 void SetGalleryPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Gallery, rPath ); }
133 void SetGraphicPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Graphic, rPath ); }
134 void SetHelpPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Help, rPath ); }
135 void SetLinguisticPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Linguistic, rPath ); }
136 void SetModulePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Module, rPath ); }
137 void SetPalettePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Palette, rPath ); }
138 void SetPluginPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Plugin, rPath ); }
139 void SetStoragePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Storage, rPath ); }
140 void SetTempPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Temp, rPath ); }
141 void SetTemplatePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Template, rPath ); }
142 void SetUserConfigPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::UserConfig, rPath ); }
143 void SetWorkPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Work, rPath ); }
144
145 OUString SubstVar( const OUString& rVar ) const;
146 OUString ExpandMacros( const OUString& rPath ) const;
147 OUString UsePathVariables( const OUString& rPath ) const;
148 };
149
150 // global ----------------------------------------------------------------
151
152 static std::weak_ptr<SvtPathOptions_Impl> g_pOptions;
153
154 namespace {
155
156 // functions -------------------------------------------------------------
157 struct PropertyStruct
158 {
159 const char* pPropName; // The ascii name of the Office path
160 SvtPathOptions::Paths ePath; // The enum value used by SvtPathOptions
161 };
162
163 struct VarNameAttribute
164 {
165 const char* pVarName; // The name of the path variable
166 };
167
168 }
169
170 const PropertyStruct aPropNames[] =
171 {
172 { "Addin", SvtPathOptions::Paths::AddIn },
173 { "AutoCorrect", SvtPathOptions::Paths::AutoCorrect },
174 { "AutoText", SvtPathOptions::Paths::AutoText },
175 { "Backup", SvtPathOptions::Paths::Backup },
176 { "Basic", SvtPathOptions::Paths::Basic },
177 { "Bitmap", SvtPathOptions::Paths::Bitmap },
178 { "Config", SvtPathOptions::Paths::Config },
179 { "Dictionary", SvtPathOptions::Paths::Dictionary },
180 { "Favorite", SvtPathOptions::Paths::Favorites },
181 { "Filter", SvtPathOptions::Paths::Filter },
182 { "Gallery", SvtPathOptions::Paths::Gallery },
183 { "Graphic", SvtPathOptions::Paths::Graphic },
184 { "Help", SvtPathOptions::Paths::Help },
185 { "Iconset", SvtPathOptions::Paths::IconSet },
186 { "Linguistic", SvtPathOptions::Paths::Linguistic },
187 { "Module", SvtPathOptions::Paths::Module },
188 { "Palette", SvtPathOptions::Paths::Palette },
189 { "Plugin", SvtPathOptions::Paths::Plugin },
190 { "Storage", SvtPathOptions::Paths::Storage },
191 { "Temp", SvtPathOptions::Paths::Temp },
192 { "Template", SvtPathOptions::Paths::Template },
193 { "UserConfig", SvtPathOptions::Paths::UserConfig },
194 { "Work", SvtPathOptions::Paths::Work },
195 { "UIConfig", SvtPathOptions::Paths::UIConfig },
196 { "Fingerprint", SvtPathOptions::Paths::Fingerprint },
197 { "Numbertext", SvtPathOptions::Paths::NumberText },
198 { "Classification", SvtPathOptions::Paths::Classification }
199 };
200
201 const VarNameAttribute aVarNameAttribute[] =
202 {
203 { SUBSTITUTE_INSTPATH }, // $(instpath)
204 { SUBSTITUTE_PROGPATH }, // $(progpath)
205 { SUBSTITUTE_USERPATH }, // $(userpath)
206 { SUBSTITUTE_PATH }, // $(path)
207 };
208
209 // class SvtPathOptions_Impl ---------------------------------------------
210
211 const OUString& SvtPathOptions_Impl::GetPath( SvtPathOptions::Paths ePath )
212 {
213 std::unique_lock aGuard( m_aMutex );
214
215 try
216 {
217 OUString aPathValue;
218 sal_Int32 nHandle = m_aMapEnumToPropHandle[ePath];
219
220 // Substitution is done by the service itself using the substitution service
221 Any a = m_xPathSettings->getFastPropertyValue( nHandle );
222 a >>= aPathValue;
223 if( ePath == SvtPathOptions::Paths::AddIn ||
224 ePath == SvtPathOptions::Paths::Filter ||
225 ePath == SvtPathOptions::Paths::Help ||
226 ePath == SvtPathOptions::Paths::Module ||
227 ePath == SvtPathOptions::Paths::Plugin ||
228 ePath == SvtPathOptions::Paths::Storage
229 )
230 {
231 // These office paths have to be converted to system pates
232 OUString aResult;
233 osl::FileBase::getSystemPathFromFileURL( aPathValue, aResult );
234 aPathValue = aResult;
235 }
236 else if (ePath == SvtPathOptions::Paths::Palette ||
237 ePath == SvtPathOptions::Paths::IconSet)
238 {
239 auto ctx = comphelper::getProcessComponentContext();
240 OUStringBuffer buf(aPathValue.getLength()*2);
241 for (sal_Int32 i = 0;;)
242 {
243 buf.append(
244 comphelper::getExpandedUri(
245 ctx, aPathValue.getToken(0, ';', i)));
246 if (i == -1) {
247 break;
248 }
249 buf.append(';');
250 }
251 aPathValue = buf.makeStringAndClear();
252 }
253
254 m_aPathArray[ ePath ] = aPathValue;
255 return m_aPathArray[ ePath ];
256 }
257 catch (UnknownPropertyException &)
258 {
259 }
260
261 return m_aEmptyString;
262 }
263
264 void SvtPathOptions_Impl::SetPath( SvtPathOptions::Paths ePath, const OUString& rNewPath )
265 {
266 std::unique_lock aGuard( m_aMutex );
267
268 OUString aResult;
269 OUString aNewValue;
270 Any a;
271
272 switch ( ePath )
273 {
274 case SvtPathOptions::Paths::AddIn:
275 case SvtPathOptions::Paths::Filter:
276 case SvtPathOptions::Paths::Help:
277 case SvtPathOptions::Paths::Module:
278 case SvtPathOptions::Paths::Plugin:
279 case SvtPathOptions::Paths::Storage:
280 {
281 // These office paths have to be convert back to UCB-URL's
282 osl::FileBase::getFileURLFromSystemPath( rNewPath, aResult );
283 aNewValue = aResult;
284 }
285 break;
286
287 default:
288 aNewValue = rNewPath;
289 }
290
291 // Resubstitution is done by the service itself using the substitution service
292 a <<= aNewValue;
293 try
294 {
295 m_xPathSettings->setFastPropertyValue( m_aMapEnumToPropHandle[ePath], a );
296 }
297 catch (const Exception&)
298 {
299 TOOLS_WARN_EXCEPTION("unotools.config", "SetPath");
300 }
301 }
302
303 OUString SvtPathOptions_Impl::ExpandMacros( const OUString& rPath ) const
304 {
305 OUString sExpanded( rPath );
306
307 const INetURLObject aParser( rPath );
308 if ( aParser.GetProtocol() == INetProtocol::VndSunStarExpand )
309 sExpanded = m_xMacroExpander->expandMacros( aParser.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ) );
310
311 return sExpanded;
312 }
313
314 OUString SvtPathOptions_Impl::UsePathVariables( const OUString& rPath ) const
315 {
316 return m_xSubstVariables->reSubstituteVariables( rPath );
317 }
318
319 OUString SvtPathOptions_Impl::SubstVar( const OUString& rVar ) const
320 {
321 // Don't work at parameter-string directly. Copy it.
322 OUString aWorkText = rVar;
323
324 // Convert the returned path to system path!
325 bool bConvertLocal = false;
326
327 // Search for first occurrence of "$(...".
328 sal_Int32 nPosition = aWorkText.indexOf( SIGN_STARTVARIABLE ); // = first position of "$(" in string
329 sal_Int32 nLength = 0; // = count of letters from "$(" to ")" in string
330
331 // Have we found any variable like "$(...)"?
332 if ( nPosition != STRPOS_NOTFOUND )
333 {
334 // Yes; Get length of found variable.
335 // If no ")" was found - nLength is set to 0 by default! see before.
336 sal_Int32 nEndPosition = aWorkText.indexOf( SIGN_ENDVARIABLE, nPosition );
337 if ( nEndPosition != STRPOS_NOTFOUND )
338 nLength = nEndPosition - nPosition + 1;
339 }
340
341 // Is there another path variable?
342 while ( ( nPosition != STRPOS_NOTFOUND ) && ( nLength > 0 ) )
343 {
344 // YES; Get the next variable for replace.
345 OUString aSubString = aWorkText.copy( nPosition, nLength );
346 aSubString = aSubString.toAsciiLowerCase();
347
348 // Look for special variable that needs a system path.
349 VarNameSet::const_iterator pIter = m_aSystemPathVarNames.find( aSubString );
350 if ( pIter != m_aSystemPathVarNames.end() )
351 bConvertLocal = true;
352
353 nPosition += nLength;
354
355 // We must control index in string before call something at OUString!
356 // The OUString-implementation don't do it for us :-( but the result is not defined otherwise.
357 if ( nPosition + 1 > aWorkText.getLength() )
358 {
359 // Position is out of range. Break loop!
360 nPosition = STRPOS_NOTFOUND;
361 nLength = 0;
362 }
363 else
364 {
365 // Else; Position is valid. Search for next variable.
366 nPosition = aWorkText.indexOf( SIGN_STARTVARIABLE, nPosition );
367 // Have we found any variable like "$(...)"?
368 if ( nPosition != STRPOS_NOTFOUND )
369 {
370 // Yes; Get length of found variable. If no ")" was found - nLength must set to 0!
371 nLength = 0;
372 sal_Int32 nEndPosition = aWorkText.indexOf( SIGN_ENDVARIABLE, nPosition );
373 if ( nEndPosition != STRPOS_NOTFOUND )
374 nLength = nEndPosition - nPosition + 1;
375 }
376 }
377 }
378
379 aWorkText = m_xSubstVariables->substituteVariables( rVar, false );
380
381 if ( bConvertLocal )
382 {
383 // Convert the URL to a system path for special path variables
384 OUString aReturn;
385 osl::FileBase::getSystemPathFromFileURL( aWorkText, aReturn );
386 return aReturn;
387 }
388
389 return aWorkText;
390 }
391
392 SvtPathOptions_Impl::SvtPathOptions_Impl()
393 {
394 Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
395
396 // Create necessary services
397 Reference< XPathSettings > xPathSettings = thePathSettings::get(xContext);
398 m_xPathSettings.set( xPathSettings, UNO_QUERY_THROW );
399 m_xSubstVariables.set( PathSubstitution::create(xContext) );
400 m_xMacroExpander = theMacroExpander::get(xContext);
401
402 // Create temporary hash map to have a mapping between property names and property handles
403 Reference< XPropertySetInfo > xPropSetInfo = xPathSettings->getPropertySetInfo();
404 const Sequence< Property > aPathPropSeq = xPropSetInfo->getProperties();
405
406 NameToHandleMap aTempHashMap;
407 for ( const css::beans::Property& aProperty : aPathPropSeq )
408 {
409 aTempHashMap.emplace(aProperty.Name, aProperty.Handle);
410 }
411
412 // Create mapping between internal enum (SvtPathOptions::Paths) and property handle
413 for ( auto const & p : aPropNames )
414 {
415 NameToHandleMap::const_iterator pIter =
416 aTempHashMap.find( OUString::createFromAscii( p.pPropName ));
417
418 if ( pIter != aTempHashMap.end() )
419 {
420 sal_Int32 nHandle = pIter->second;
421 SvtPathOptions::Paths nEnum = p.ePath;
422 m_aMapEnumToPropHandle.emplace( nEnum, nHandle );
423 }
424 }
425
426 // Create hash map for path variables that need a system path as a return value!
427 for ( auto const & i : aVarNameAttribute )
428 {
429 m_aSystemPathVarNames.insert( OUString::createFromAscii( i.pVarName ) );
430 }
431 }
432
433 // class SvtPathOptions --------------------------------------------------
434
435 namespace
436 {
437 std::mutex& lclMutex()
438 {
439 static std::mutex SINGLETON;
440 return SINGLETON;
441 }
442 }
443
444 SvtPathOptions::SvtPathOptions()
445 {
446 // Global access, must be guarded (multithreading)
447 std::unique_lock aGuard( lclMutex() );
448 pImpl = g_pOptions.lock();
449 if ( !pImpl )
450 {
451 pImpl = std::make_shared<SvtPathOptions_Impl>();
452 g_pOptions = pImpl;
453 aGuard.unlock(); // because holdConfigItem will call this constructor
454 ItemHolder1::holdConfigItem(EItem::PathOptions);
455 }
456 }
457
458 SvtPathOptions::~SvtPathOptions()
459 {
460 // Global access, must be guarded (multithreading)
461 std::unique_lock aGuard( lclMutex() );
462
463 pImpl.reset();
464 }
465
466 const OUString& SvtPathOptions::GetAddinPath() const
467 {
468 return pImpl->GetAddinPath();
469 }
470
471 const OUString& SvtPathOptions::GetAutoCorrectPath() const
472 {
473 return pImpl->GetAutoCorrectPath();
474 }
475
476 const OUString& SvtPathOptions::GetAutoTextPath() const
477 {
478 return pImpl->GetAutoTextPath();
479 }
480
481 const OUString& SvtPathOptions::GetBackupPath() const
482 {
483 return pImpl->GetBackupPath();
484 }
485
486 const OUString& SvtPathOptions::GetBasicPath() const
487 {
488 return pImpl->GetBasicPath();
489 }
490
491 const OUString& SvtPathOptions::GetBitmapPath() const
492 {
493 return pImpl->GetBitmapPath();
494 }
495
496 const OUString& SvtPathOptions::GetConfigPath() const
497 {
498 return pImpl->GetConfigPath();
499 }
500
501 const OUString& SvtPathOptions::GetDictionaryPath() const
502 {
503 return pImpl->GetDictionaryPath();
504 }
505
506 const OUString& SvtPathOptions::GetFavoritesPath() const
507 {
508 return pImpl->GetFavoritesPath();
509 }
510
511 const OUString& SvtPathOptions::GetFilterPath() const
512 {
513 return pImpl->GetFilterPath();
514 }
515
516 const OUString& SvtPathOptions::GetGalleryPath() const
517 {
518 return pImpl->GetGalleryPath();
519 }
520
521 const OUString& SvtPathOptions::GetGraphicPath() const
522 {
523 return pImpl->GetGraphicPath();
524 }
525
526 const OUString& SvtPathOptions::GetHelpPath() const
527 {
528 return pImpl->GetHelpPath();
529 }
530
531 const OUString& SvtPathOptions::GetLinguisticPath() const
532 {
533 return pImpl->GetLinguisticPath();
534 }
535
536 const OUString& SvtPathOptions::GetFingerprintPath() const
537 {
538 return pImpl->GetFingerprintPath();
539 }
540
541 const OUString& SvtPathOptions::GetNumbertextPath() const
542 {
543 return pImpl->GetNumbertextPath();
544 }
545
546 const OUString& SvtPathOptions::GetModulePath() const
547 {
548 return pImpl->GetModulePath();
549 }
550
551 const OUString& SvtPathOptions::GetPalettePath() const
552 {
553 return pImpl->GetPalettePath();
554 }
555
556 const OUString& SvtPathOptions::GetIconsetPath() const
557 {
558 return pImpl->GetIconsetPath();
559 }
560
561 const OUString& SvtPathOptions::GetPluginPath() const
562 {
563 return pImpl->GetPluginPath();
564 }
565
566 const OUString& SvtPathOptions::GetStoragePath() const
567 {
568 return pImpl->GetStoragePath();
569 }
570
571 const OUString& SvtPathOptions::GetTempPath() const
572 {
573 return pImpl->GetTempPath();
574 }
575
576 const OUString& SvtPathOptions::GetTemplatePath() const
577 {
578 return pImpl->GetTemplatePath();
579 }
580
581 const OUString& SvtPathOptions::GetUserConfigPath() const
582 {
583 return pImpl->GetUserConfigPath();
584 }
585
586 const OUString& SvtPathOptions::GetWorkPath() const
587 {
588 return pImpl->GetWorkPath();
589 }
590
591 const OUString& SvtPathOptions::GetClassificationPath() const
592 {
593 return pImpl->GetClassificationPath();
594 }
595
596 void SvtPathOptions::SetAddinPath( const OUString& rPath )
597 {
598 pImpl->SetAddinPath( rPath );
599 }
600
601 void SvtPathOptions::SetAutoCorrectPath( const OUString& rPath )
602 {
603 pImpl->SetAutoCorrectPath( rPath );
604 }
605
606 void SvtPathOptions::SetAutoTextPath( const OUString& rPath )
607 {
608 pImpl->SetAutoTextPath( rPath );
609 }
610
611 void SvtPathOptions::SetBackupPath( const OUString& rPath )
612 {
613 pImpl->SetBackupPath( rPath );
614 }
615
616 void SvtPathOptions::SetBasicPath( const OUString& rPath )
617 {
618 pImpl->SetBasicPath( rPath );
619 }
620
621 void SvtPathOptions::SetBitmapPath( const OUString& rPath )
622 {
623 pImpl->SetBitmapPath( rPath );
624 }
625
626 void SvtPathOptions::SetConfigPath( const OUString& rPath )
627 {
628 pImpl->SetConfigPath( rPath );
629 }
630
631 void SvtPathOptions::SetDictionaryPath( const OUString& rPath )
632 {
633 pImpl->SetDictionaryPath( rPath );
634 }
635
636 void SvtPathOptions::SetFavoritesPath( const OUString& rPath )
637 {
638 pImpl->SetFavoritesPath( rPath );
639 }
640
641 void SvtPathOptions::SetFilterPath( const OUString& rPath )
642 {
643 pImpl->SetFilterPath( rPath );
644 }
645
646 void SvtPathOptions::SetGalleryPath( const OUString& rPath )
647 {
648 pImpl->SetGalleryPath( rPath );
649 }
650
651 void SvtPathOptions::SetGraphicPath( const OUString& rPath )
652 {
653 pImpl->SetGraphicPath( rPath );
654 }
655
656 void SvtPathOptions::SetHelpPath( const OUString& rPath )
657 {
658 pImpl->SetHelpPath( rPath );
659 }
660
661 void SvtPathOptions::SetLinguisticPath( const OUString& rPath )
662 {
663 pImpl->SetLinguisticPath( rPath );
664 }
665
666 void SvtPathOptions::SetModulePath( const OUString& rPath )
667 {
668 pImpl->SetModulePath( rPath );
669 }
670
671 void SvtPathOptions::SetPalettePath( const OUString& rPath )
672 {
673 pImpl->SetPalettePath( rPath );
674 }
675
676 void SvtPathOptions::SetPluginPath( const OUString& rPath )
677 {
678 pImpl->SetPluginPath( rPath );
679 }
680
681 void SvtPathOptions::SetStoragePath( const OUString& rPath )
682 {
683 pImpl->SetStoragePath( rPath );
684 }
685
686 void SvtPathOptions::SetTempPath( const OUString& rPath )
687 {
688 pImpl->SetTempPath( rPath );
689 }
690
691 void SvtPathOptions::SetTemplatePath( const OUString& rPath )
692 {
693 pImpl->SetTemplatePath( rPath );
694 }
695
696 void SvtPathOptions::SetUserConfigPath( const OUString& rPath )
697 {
698 pImpl->SetUserConfigPath( rPath );
699 }
700
701 void SvtPathOptions::SetWorkPath( const OUString& rPath )
702 {
703 pImpl->SetWorkPath( rPath );
704 }
705
706 OUString SvtPathOptions::SubstituteVariable( const OUString& rVar ) const
707 {
708 return pImpl->SubstVar( rVar );
709 }
710
711 OUString SvtPathOptions::ExpandMacros( const OUString& rPath ) const
712 {
713 return pImpl->ExpandMacros( rPath );
714 }
715
716 OUString SvtPathOptions::UseVariable( const OUString& rPath ) const
717 {
718 return pImpl->UsePathVariables( rPath );
719 }
720
721 bool SvtPathOptions::SearchFile( OUString& rIniFile, SvtPathOptions::Paths ePath )
722 {
723 // check parameter: empty inifile name?
724 if ( rIniFile.isEmpty() )
725 {
726 SAL_WARN( "unotools.config", "SvtPathOptions::SearchFile(): invalid parameter" );
727 return false;
728 }
729
730 OUString aIniFile = pImpl->SubstVar( rIniFile );
731 bool bRet = false;
732
733 switch ( ePath )
734 {
735 case SvtPathOptions::Paths::UserConfig:
736 {
737 // path is a URL
738 bRet = true;
739 INetURLObject aObj( GetUserConfigPath() );
740
741 sal_Int32 nIniIndex = 0;
742 do
743 {
744 std::u16string_view aToken = o3tl::getToken(aIniFile, 0, '/', nIniIndex );
745 aObj.insertName(aToken);
746 }
747 while ( nIniIndex >= 0 );
748
749 if ( !::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )
750 {
751 aObj.SetSmartURL( GetConfigPath() );
752 aObj.insertName( aIniFile );
753 bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
754 }
755
756 if ( bRet )
757 rIniFile = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
758
759 break;
760 }
761
762 default:
763 {
764 OUString aPath;
765 switch ( ePath )
766 {
767 case SvtPathOptions::Paths::AddIn: aPath = GetAddinPath(); break;
768 case SvtPathOptions::Paths::AutoCorrect: aPath = GetAutoCorrectPath(); break;
769 case SvtPathOptions::Paths::AutoText: aPath = GetAutoTextPath(); break;
770 case SvtPathOptions::Paths::Backup: aPath = GetBackupPath(); break;
771 case SvtPathOptions::Paths::Basic: aPath = GetBasicPath(); break;
772 case SvtPathOptions::Paths::Bitmap: aPath = GetBitmapPath(); break;
773 case SvtPathOptions::Paths::Config: aPath = GetConfigPath(); break;
774 case SvtPathOptions::Paths::Dictionary: aPath = GetDictionaryPath(); break;
775 case SvtPathOptions::Paths::Favorites: aPath = GetFavoritesPath(); break;
776 case SvtPathOptions::Paths::Filter: aPath = GetFilterPath(); break;
777 case SvtPathOptions::Paths::Gallery: aPath = GetGalleryPath(); break;
778 case SvtPathOptions::Paths::Graphic: aPath = GetGraphicPath(); break;
779 case SvtPathOptions::Paths::Help: aPath = GetHelpPath(); break;
780 case SvtPathOptions::Paths::Linguistic: aPath = GetLinguisticPath(); break;
781 case SvtPathOptions::Paths::Module: aPath = GetModulePath(); break;
782 case SvtPathOptions::Paths::Palette: aPath = GetPalettePath(); break;
783 case SvtPathOptions::Paths::IconSet: aPath = GetIconsetPath(); break;
784 case SvtPathOptions::Paths::Plugin: aPath = GetPluginPath(); break;
785 case SvtPathOptions::Paths::Storage: aPath = GetStoragePath(); break;
786 case SvtPathOptions::Paths::Temp: aPath = GetTempPath(); break;
787 case SvtPathOptions::Paths::Template: aPath = GetTemplatePath(); break;
788 case SvtPathOptions::Paths::Work: aPath = GetWorkPath(); break;
789 case SvtPathOptions::Paths::UIConfig: aPath = pImpl->GetUIConfigPath(); break;
790 case SvtPathOptions::Paths::Fingerprint: aPath = GetFingerprintPath(); break;
791 case SvtPathOptions::Paths::NumberText: aPath = GetNumbertextPath(); break;
792 case SvtPathOptions::Paths::Classification: aPath = GetClassificationPath(); break;
793 // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
794 case SvtPathOptions::Paths::UserConfig:
795 case SvtPathOptions::Paths::LAST:
796 break;
797 }
798
799 sal_Int32 nPathIndex = 0;
800 do
801 {
802 bool bIsURL = true;
803 OUString aPathToken( aPath.getToken( 0, SEARCHPATH_DELIMITER, nPathIndex ) );
804 INetURLObject aObj( aPathToken );
805 if ( aObj.HasError() )
806 {
807 bIsURL = false;
808 OUString aURL;
809 if ( osl::FileBase::getFileURLFromSystemPath( aPathToken, aURL )
810 == osl::FileBase::E_None )
811 aObj.SetURL( aURL );
812 }
813 if ( aObj.GetProtocol() == INetProtocol::VndSunStarExpand )
814 {
815 Reference< XMacroExpander > xMacroExpander = theMacroExpander::get( ::comphelper::getProcessComponentContext() );
816 const OUString sExpandedPath = xMacroExpander->expandMacros( aObj.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ) );
817 aObj.SetURL( sExpandedPath );
818 }
819
820 sal_Int32 nIniIndex = 0;
821 do
822 {
823 std::u16string_view aToken = o3tl::getToken(aIniFile, 0, '/', nIniIndex );
824 aObj.insertName(aToken);
825 }
826 while ( nIniIndex >= 0 );
827
828 bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
829
830 if ( bRet )
831 {
832 if ( !bIsURL )
833 {
834 OUString sTmp;
835 osl::FileBase::getSystemPathFromFileURL(
836 aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), sTmp );
837 rIniFile = sTmp;
838 }
839 else
840 rIniFile = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
841 break;
842 }
843 }
844 while ( nPathIndex >= 0 );
845 }
846 }
847
848 return bRet;
849 }
850
851 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE