?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sfx2 / source / doc / doctemplates.cxx
blobf3d1bc55fa890608474940b2504e10ff5462b498
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: doctemplates.cxx,v $
10 * $Revision: 1.42.84.2 $
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_sfx2.hxx"
33
34 #include "doctemplates.hxx"
35 #include <vos/mutex.hxx>
36 #include <tools/debug.hxx>
37 #include <tools/urlobj.hxx>
38 #include <rtl/ustring.hxx>
39 #include <rtl/ustrbuf.hxx>
40 #include <osl/file.hxx>
41 #ifndef _SV_RESARY_HXX
42 #include <tools/resary.hxx>
43 #endif
44 #include <vcl/svapp.hxx>
45 #include <vcl/wrkwin.hxx>
46 #include <comphelper/sequenceashashmap.hxx>
47 #include <svtools/pathoptions.hxx>
48 #include <comphelper/processfactory.hxx>
49 #include <com/sun/star/beans/PropertyAttribute.hpp>
50 #include <com/sun/star/beans/XPropertySet.hpp>
51 #include <com/sun/star/beans/XPropertySetInfo.hpp>
52 #include <com/sun/star/beans/XPropertyContainer.hpp>
53 #include <com/sun/star/beans/StringPair.hpp>
54 #include <com/sun/star/util/XMacroExpander.hpp>
55 #include <com/sun/star/container/XContainerQuery.hpp>
56 #include <com/sun/star/document/XTypeDetection.hpp>
57 #include <com/sun/star/document/XStandaloneDocumentInfo.hpp>
58 #include <com/sun/star/sdbc/XResultSet.hpp>
59 #include <com/sun/star/sdbc/XRow.hpp>
60 #include <com/sun/star/ucb/NameClash.hpp>
61 #include <com/sun/star/ucb/NameClashException.hpp>
62 #include <com/sun/star/ucb/TransferInfo.hpp>
63 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
64 #include <com/sun/star/ucb/XContentAccess.hpp>
65 #include <com/sun/star/frame/XModuleManager.hpp>
66 #include <com/sun/star/uno/Exception.hpp>
67 #include <com/sun/star/util/XOfficeInstallationDirectories.hpp>
68
69 #include <svtools/templatefoldercache.hxx>
70 #include <unotools/configmgr.hxx>
71 #include <unotools/ucbhelper.hxx>
72
73 #include "sfxresid.hxx"
74 #include "sfxurlrelocator.hxx"
75 #include "doctemplateslocal.hxx"
76 #include <sfx2/docfac.hxx>
77 #include <sfx2/docfile.hxx>
78 #include "doc.hrc"
79
80 //-----------------------------------------------------------------------------
81
82 //=============================================================================
83
84 #define TEMPLATE_SERVICE_NAME "com.sun.star.frame.DocumentTemplates"
85 #define TEMPLATE_IMPLEMENTATION_NAME "com.sun.star.comp.sfx2.DocumentTemplates"
86
87 #define SERVICENAME_TYPEDETECTION "com.sun.star.document.TypeDetection"
88 #define SERVICENAME_DOCINFO "com.sun.star.document.StandaloneDocumentInfo"
89
90 #define TEMPLATE_ROOT_URL "vnd.sun.star.hier:/templates"
91 #define TITLE "Title"
92 #define IS_FOLDER "IsFolder"
93 #define IS_DOCUMENT "IsDocument"
94 #define TARGET_URL "TargetURL"
95 #define TEMPLATE_VERSION "TemplateComponentVersion"
96 #define TEMPLATE_VERSION_VALUE "2"
97 #define TYPE_FOLDER "application/vnd.sun.star.hier-folder"
98 #define TYPE_LINK "application/vnd.sun.star.hier-link"
99 #define TYPE_FSYS_FOLDER "application/vnd.sun.staroffice.fsys-folder"
100 #define TYPE_FSYS_FILE "application/vnd.sun.staroffice.fsys-file"
101
102 #define PROPERTY_DIRLIST "DirectoryList"
103 #define PROPERTY_NEEDSUPDATE "NeedsUpdate"
104 #define PROPERTY_TYPE "TypeDescription"
105
106 #define TARGET_DIR_URL "TargetDirURL"
107 #define COMMAND_DELETE "delete"
108 #define COMMAND_TRANSFER "transfer"
109
110 #define STANDARD_FOLDER "standard"
111
112 #define C_DELIM ';'
113
114 //=============================================================================
115
116 using namespace ::com::sun::star;
117 using namespace ::com::sun::star::beans;
118 using namespace ::com::sun::star::document;
119 using namespace ::com::sun::star::io;
120 using namespace ::com::sun::star::lang;
121 using namespace ::com::sun::star::sdbc;
122 using namespace ::com::sun::star::ucb;
123 using namespace ::com::sun::star::uno;
124 using namespace ::com::sun::star::container;
125 using namespace ::com::sun::star::util;
126
127 using namespace ::rtl;
128 using namespace ::ucbhelper;
129 using namespace ::comphelper;
130
131 //=============================================================================
132
133 class WaitWindow_Impl : public WorkWindow
134 {
135 Rectangle _aRect;
136 USHORT _nTextStyle;
137 String _aText;
138
139 public:
140 WaitWindow_Impl();
141 ~WaitWindow_Impl();
142 virtual void Paint( const Rectangle& rRect );
143 };
144
145 #define X_OFFSET 15
146 #define Y_OFFSET 15
147
148 //=============================================================================
149
150 struct NamePair_Impl
151 {
152 OUString maShortName;
153 OUString maLongName;
154 };
155
156 DECLARE_LIST( NameList_Impl, NamePair_Impl* )
157
158 class Updater_Impl;
159 class GroupList_Impl;
160 class DocTemplates_EntryData_Impl;
161 class GroupData_Impl;
162
163 //=============================================================================
164 #include <com/sun/star/task/XInteractionHandler.hpp>
165 #include <com/sun/star/ucb/XProgressHandler.hpp>
166 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
167
168 class TplTaskEnvironment : public ::cppu::WeakImplHelper1< ucb::XCommandEnvironment >
169 {
170 uno::Reference< task::XInteractionHandler > m_xInteractionHandler;
171 uno::Reference< ucb::XProgressHandler > m_xProgressHandler;
172
173 public:
174 TplTaskEnvironment( const uno::Reference< task::XInteractionHandler>& rxInteractionHandler )
175 : m_xInteractionHandler( rxInteractionHandler )
176 {}
177
178 virtual uno::Reference<task::XInteractionHandler> SAL_CALL getInteractionHandler() throw (uno::RuntimeException)
179 { return m_xInteractionHandler; }
180
181 virtual uno::Reference<ucb::XProgressHandler> SAL_CALL getProgressHandler() throw (uno::RuntimeException)
182 { return m_xProgressHandler; }
183 };
184
185 class SfxDocTplService_Impl
186 {
187 uno::Reference< XMultiServiceFactory > mxFactory;
188 uno::Reference< XCommandEnvironment > maCmdEnv;
189 uno::Reference< XStandaloneDocumentInfo > mxInfo;
190 uno::Reference< XTypeDetection > mxType;
191
192 ::osl::Mutex maMutex;
193 Sequence< OUString > maTemplateDirs;
194 OUString maRootURL;
195 NameList_Impl maNames;
196 Locale maLocale;
197 Content maRootContent;
198 Updater_Impl* mpUpdater;
199 sal_Bool mbIsInitialized : 1;
200 sal_Bool mbLocaleSet : 1;
201
202 SfxURLRelocator_Impl maRelocator;
203
204 void init_Impl();
205 void getDefaultLocale();
206 void getDirList();
207 void readFolderList();
208 sal_Bool needsUpdate();
209 OUString getLongName( const OUString& rShortName );
210 sal_Bool setTitleForURL( const OUString& rURL, const OUString& aTitle );
211 sal_Bool getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, sal_Bool& bDocHasTitle );
212
213 sal_Bool addEntry( Content& rParentFolder,
214 const OUString& rTitle,
215 const OUString& rTargetURL,
216 const OUString& rType );
217
218 sal_Bool createFolder( const OUString& rNewFolderURL,
219 sal_Bool bCreateParent,
220 sal_Bool bFsysFolder,
221 Content &rNewFolder );
222
223 sal_Bool CreateNewUniqueFolderWithPrefix( const ::rtl::OUString& aPath,
224 const ::rtl::OUString& aPrefix,
225 ::rtl::OUString& aNewFolderName,
226 ::rtl::OUString& aNewFolderURL,
227 Content& aNewFolder );
228 ::rtl::OUString CreateNewUniqueFileWithPrefix( const ::rtl::OUString& aPath,
229 const ::rtl::OUString& aPrefix,
230 const ::rtl::OUString& aExt );
231
232 uno::Sequence< beans::StringPair > ReadUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath );
233 sal_Bool UpdateUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
234 const ::rtl::OUString& aGroupName,
235 const ::rtl::OUString& aNewFolderName );
236 sal_Bool ReplaceUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
237 const ::rtl::OUString& aFsysGroupName,
238 const ::rtl::OUString& aOldGroupName,
239 const ::rtl::OUString& aNewGroupName );
240 sal_Bool RemoveUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
241 const ::rtl::OUString& aGroupName );
242 sal_Bool WriteUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
243 const uno::Sequence< beans::StringPair >& aUINames );
244
245 ::rtl::OUString CreateNewGroupFsys( const ::rtl::OUString& rGroupName, Content& aGroup );
246
247 sal_Bool removeContent( Content& rContent );
248 sal_Bool removeContent( const OUString& rContentURL );
249
250 sal_Bool setProperty( Content& rContent,
251 const OUString& rPropName,
252 const Any& rPropValue );
253 sal_Bool getProperty( Content& rContent,
254 const OUString& rPropName,
255 Any& rPropValue );
256
257 void createFromContent( GroupList_Impl& rList,
258 Content &rContent,
259 sal_Bool bHierarchy,
260 sal_Bool bWriteableContent = sal_False );
261 void addHierGroup( GroupList_Impl& rList,
262 const OUString& rTitle,
263 const OUString& rOwnURL );
264 void addFsysGroup( GroupList_Impl& rList,
265 const OUString& rTitle,
266 const OUString& rUITitle,
267 const OUString& rOwnURL,
268 sal_Bool bWriteableGroup = sal_False );
269 void removeFromHierarchy( DocTemplates_EntryData_Impl *pData );
270 void addToHierarchy( GroupData_Impl *pGroup,
271 DocTemplates_EntryData_Impl *pData );
272
273 void removeFromHierarchy( GroupData_Impl *pGroup );
274 void addGroupToHierarchy( GroupData_Impl *pGroup );
275
276 void updateData( DocTemplates_EntryData_Impl *pData );
277
278 public:
279 SfxDocTplService_Impl( uno::Reference< XMultiServiceFactory > xFactory );
280 ~SfxDocTplService_Impl();
281
282 sal_Bool init() { if ( !mbIsInitialized ) init_Impl(); return mbIsInitialized; }
283 Content getContent() { return maRootContent; }
284
285 void setLocale( const Locale & rLocale );
286 Locale getLocale();
287
288 sal_Bool storeTemplate( const OUString& rGroupName,
289 const OUString& rTemplateName,
290 const uno::Reference< XSTORABLE >& rStorable );
291
292 sal_Bool addTemplate( const OUString& rGroupName,
293 const OUString& rTemplateName,
294 const OUString& rSourceURL );
295 sal_Bool removeTemplate( const OUString& rGroupName,
296 const OUString& rTemplateName );
297 sal_Bool renameTemplate( const OUString& rGroupName,
298 const OUString& rOldName,
299 const OUString& rNewName );
300
301 sal_Bool addGroup( const OUString& rGroupName );
302 sal_Bool removeGroup( const OUString& rGroupName );
303 sal_Bool renameGroup( const OUString& rOldName,
304 const OUString& rNewName );
305
306 void update( sal_Bool bUpdateNow );
307 void doUpdate();
308 void finished() { mpUpdater = NULL; }
309 };
310
311 //=============================================================================
312
313 class Updater_Impl : public ::vos::OThread
314 {
315 private:
316 SfxDocTplService_Impl *mpDocTemplates;
317
318 public:
319 Updater_Impl( SfxDocTplService_Impl* pTemplates );
320 ~Updater_Impl();
321
322 virtual void SAL_CALL run();
323 virtual void SAL_CALL onTerminated();
324 };
325
326 //=============================================================================
327
328 class DocTemplates_EntryData_Impl
329 {
330 OUString maTitle;
331 OUString maType;
332 OUString maTargetURL;
333 OUString maHierarchyURL;
334
335 sal_Bool mbInHierarchy : 1;
336 sal_Bool mbInUse : 1;
337 sal_Bool mbUpdateType : 1;
338 sal_Bool mbUpdateLink : 1;
339
340 public:
341 DocTemplates_EntryData_Impl( const OUString& rTitle );
342
343 void setInUse() { mbInUse = sal_True; }
344 void setHierarchy( sal_Bool bInHierarchy ) { mbInHierarchy = bInHierarchy; }
345 void setUpdateLink( sal_Bool bUpdateLink ) { mbUpdateLink = bUpdateLink; }
346 void setUpdateType( sal_Bool bUpdateType ) { mbUpdateType = bUpdateType; }
347
348 sal_Bool getInUse() const { return mbInUse; }
349 sal_Bool getInHierarchy() const { return mbInHierarchy; }
350 sal_Bool getUpdateLink() const { return mbUpdateLink; }
351 sal_Bool getUpdateType() const { return mbUpdateType; }
352
353 const OUString& getHierarchyURL() const { return maHierarchyURL; }
354 const OUString& getTargetURL() const { return maTargetURL; }
355 const OUString& getTitle() const { return maTitle; }
356 const OUString& getType() const { return maType; }
357
358 void setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; }
359 void setTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
360 void setType( const OUString& rType ) { maType = rType; }
361 };
362
363 //=============================================================================
364
365 class GroupData_Impl
366 {
367 DECLARE_LIST( EntryList_Impl, DocTemplates_EntryData_Impl* )
368 EntryList_Impl maEntries;
369 OUString maTitle;
370 OUString maHierarchyURL;
371 OUString maTargetURL;
372 sal_Bool mbInUse : 1;
373 sal_Bool mbInHierarchy : 1;
374
375 public:
376 GroupData_Impl( const OUString& rTitle );
377 ~GroupData_Impl();
378
379 void setInUse() { mbInUse = sal_True; }
380 void setHierarchy( sal_Bool bInHierarchy ) { mbInHierarchy = bInHierarchy; }
381 void setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; }
382 void setTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
383
384 sal_Bool getInUse() { return mbInUse; }
385 sal_Bool getInHierarchy() { return mbInHierarchy; }
386 const OUString& getHierarchyURL() const { return maHierarchyURL; }
387 const OUString& getTargetURL() const { return maTargetURL; }
388 const OUString& getTitle() const { return maTitle; }
389
390 DocTemplates_EntryData_Impl* addEntry( const OUString& rTitle,
391 const OUString& rTargetURL,
392 const OUString& rType,
393 const OUString& rHierURL );
394 ULONG count() { return maEntries.Count(); }
395 DocTemplates_EntryData_Impl* getEntry( ULONG nPos ) { return maEntries.GetObject( nPos ); }
396 };
397
398 DECLARE_LIST( GroupList_Impl, GroupData_Impl* )
399
400 //=============================================================================
401 //=============================================================================
402 //=============================================================================
403
404 //-----------------------------------------------------------------------------
405 // private SfxDocTplService_Impl
406 //-----------------------------------------------------------------------------
407 void SfxDocTplService_Impl::init_Impl()
408 {
409 uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();
410 if ( xFactory.is() )
411 {
412 uno::Reference < task::XInteractionHandler > xInteractionHandler( xFactory->createInstance( DEFINE_CONST_UNICODE("com.sun.star.task.InteractionHandler") ), uno::UNO_QUERY );
413 maCmdEnv = new TplTaskEnvironment( xInteractionHandler );
414 }
415
416 ::osl::ClearableMutexGuard aGuard( maMutex );
417 sal_Bool bIsInitialized = sal_False;
418 sal_Bool bNeedsUpdate = sal_False;
419
420 if ( !mbLocaleSet )
421 getDefaultLocale();
422
423 // convert locale to string
424 OUString aLang = maLocale.Language;
425 aLang += String( '-' );
426 aLang += maLocale.Country;
427
428 // set maRootContent to the root of the templates hierarchy. Create the
429 // entry if necessary
430
431 maRootURL = OUString( RTL_CONSTASCII_USTRINGPARAM( TEMPLATE_ROOT_URL ) );
432 maRootURL += String( '/' );
433 maRootURL += aLang;
434
435 ::rtl::OUString aTemplVersPropName( RTL_CONSTASCII_USTRINGPARAM( TEMPLATE_VERSION ) );
436 ::rtl::OUString aTemplVers( RTL_CONSTASCII_USTRINGPARAM( TEMPLATE_VERSION_VALUE ) );
437 if ( Content::create( maRootURL, maCmdEnv, maRootContent ) )
438 {
439 uno::Any aValue;
440 ::rtl::OUString aPropValue;
441 if ( getProperty( maRootContent, aTemplVersPropName, aValue )
442 && ( aValue >>= aPropValue )
443 && aPropValue.equals( aTemplVers ) )
444 {
445 bIsInitialized = sal_True;
446 }
447 else
448 removeContent( maRootContent );
449 }
450
451 if ( !bIsInitialized )
452 {
453 if ( createFolder( maRootURL, sal_True, sal_False, maRootContent )
454 && setProperty( maRootContent, aTemplVersPropName, uno::makeAny( aTemplVers ) ) )
455 bIsInitialized = sal_True;
456
457 bNeedsUpdate = sal_True;
458 }
459
460 if ( bIsInitialized )
461 {
462 OUString aService( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_DOCINFO ) );
463 try {
464 mxInfo = uno::Reference< XStandaloneDocumentInfo > (
465 mxFactory->createInstance( aService ), UNO_QUERY );
466 } catch (uno::RuntimeException &) {
467 OSL_ENSURE(false, "SfxDocTplService_Impl::init_Impl: "
468 "cannot create DocumentProperties service");
469 }
470
471 aService = OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_TYPEDETECTION ) );
472 mxType = uno::Reference< XTypeDetection > ( mxFactory->createInstance( aService ), UNO_QUERY );
473
474 getDirList();
475 readFolderList();
476
477 if ( bNeedsUpdate )
478 {
479 aGuard.clear();
480 ::vos::OClearableGuard aSolarGuard( Application::GetSolarMutex() );
481
482 WaitWindow_Impl* pWin = new WaitWindow_Impl();
483
484 aSolarGuard.clear();
485 ::osl::ClearableMutexGuard anotherGuard( maMutex );
486
487 update( sal_True );
488
489 anotherGuard.clear();
490 ::vos::OGuard aSecondSolarGuard( Application::GetSolarMutex() );
491
492 delete pWin;
493 }
494 else if ( needsUpdate() )
495 // the UI should be shown only on the first update
496 update( sal_True );
497 }
498 else
499 {
500 DBG_ERRORFILE( "init_Impl(): Could not create root" );
501 }
502
503 mbIsInitialized = bIsInitialized;
504 }
505
506 //-----------------------------------------------------------------------------
507 void SfxDocTplService_Impl::getDefaultLocale()
508 {
509 if ( !mbLocaleSet )
510 {
511 ::osl::MutexGuard aGuard( maMutex );
512 if ( !mbLocaleSet )
513 {
514 rtl::OUString aLocale;
515 utl::ConfigManager::GetDirectConfigProperty( utl::ConfigManager::LOCALE )
516 >>= aLocale;
517
518 if ( aLocale.getLength() > 0 )
519 {
520 sal_Int32 nPos = aLocale.indexOf( sal_Unicode( '-' ) );
521 if ( nPos != -1 )
522 {
523 maLocale.Language = aLocale.copy( 0, nPos );
524 nPos = aLocale.indexOf( sal_Unicode( '_' ), nPos + 1 );
525 if ( nPos != -1 )
526 {
527 maLocale.Country
528 = aLocale.copy( maLocale.Language.getLength() + 1,
529 nPos - maLocale.Language.getLength() - 1 );
530 maLocale.Variant
531 = aLocale.copy( nPos + 1 );
532 }
533 else
534 {
535 maLocale.Country
536 = aLocale.copy( maLocale.Language.getLength() + 1 );
537 }
538 }
539
540 }
541
542 mbLocaleSet = sal_True;
543 }
544 }
545 }
546
547 // -----------------------------------------------------------------------
548 void SfxDocTplService_Impl::readFolderList()
549 {
550 ::vos::OGuard aGuard( Application::GetSolarMutex() );
551
552 ResStringArray aShortNames( SfxResId( TEMPLATE_SHORT_NAMES_ARY ) );
553 ResStringArray aLongNames( SfxResId( TEMPLATE_LONG_NAMES_ARY ) );
554
555 NamePair_Impl* pPair;
556
557 USHORT nCount = (USHORT)( Min( aShortNames.Count(), aLongNames.Count() ) );
558
559 for ( USHORT i=0; i<nCount; i++ )
560 {
561 pPair = new NamePair_Impl;
562 pPair->maShortName = aShortNames.GetString( i );
563 pPair->maLongName = aLongNames.GetString( i );
564
565 maNames.Insert( pPair, LIST_APPEND );
566 }
567 }
568
569 // -----------------------------------------------------------------------
570 OUString SfxDocTplService_Impl::getLongName( const OUString& rShortName )
571 {
572 OUString aRet;
573 NamePair_Impl *pPair = maNames.First();
574
575 while ( pPair )
576 {
577 if ( pPair->maShortName == rShortName )
578 {
579 aRet = pPair->maLongName;
580 break;
581 }
582 else
583 pPair = maNames.Next();
584 }
585
586 if ( !aRet.getLength() )
587 aRet = rShortName;
588
589 return aRet;
590 }
591
592 //-----------------------------------------------------------------------------
593 void SfxDocTplService_Impl::getDirList()
594 {
595 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( PROPERTY_DIRLIST ) );
596 Any aValue;
597
598 // Get the template dir list
599 // TODO/LATER: let use service, register listener
600 INetURLObject aURL;
601 String aDirs = SvtPathOptions().GetTemplatePath();
602 USHORT nCount = aDirs.GetTokenCount( C_DELIM );
603
604 maTemplateDirs = Sequence< OUString >( nCount );
605
606 uno::Reference< XComponentContext > xCtx;
607 uno::Reference< util::XMacroExpander > xExpander;
608 uno::Reference< XPropertySet > xPropSet( mxFactory, UNO_QUERY );
609 const rtl::OUString aPrefix(
610 RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.expand:" ) );
611
612 if ( xPropSet.is() )
613 {
614 xPropSet->getPropertyValue(
615 rtl::OUString(
616 RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ) ) )
617 >>= xCtx;
618 }
619
620 if ( xCtx.is() )
621 {
622 xCtx->getValueByName(
623 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
624 "/singletons/com.sun.star.util.theMacroExpander" ) ) )
625 >>= xExpander;
626
627 OSL_ENSURE( xExpander.is(),
628 "Unable to obtain macro expander singleton!" );
629 }
630
631 for ( USHORT i=0; i<nCount; i++ )
632 {
633 aURL.SetSmartProtocol( INET_PROT_FILE );
634 aURL.SetURL( aDirs.GetToken( i, C_DELIM ) );
635 maTemplateDirs[i] = aURL.GetMainURL( INetURLObject::NO_DECODE );
636
637 sal_Int32 nIndex = maTemplateDirs[i].indexOf( aPrefix );
638 if ( nIndex != -1 && xExpander.is() )
639 {
640 maTemplateDirs[i] = maTemplateDirs[i].replaceAt(nIndex,
641 aPrefix.getLength(),
642 rtl::OUString());
643 maTemplateDirs[i] = xExpander->expandMacros( maTemplateDirs[i] );
644 }
645 }
646
647 aValue <<= maTemplateDirs;
648
649 // Store the template dir list
650 setProperty( maRootContent, aPropName, aValue );
651 }
652
653 //-----------------------------------------------------------------------------
654 sal_Bool SfxDocTplService_Impl::needsUpdate()
655 {
656 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( PROPERTY_NEEDSUPDATE ) );
657 sal_Bool bHasProperty = sal_False;
658 sal_Bool bNeedsUpdate = sal_True;
659 Any aValue;
660
661 // Get the template dir list
662 bHasProperty = getProperty( maRootContent, aPropName, aValue );
663
664 if ( bHasProperty )
665 aValue >>= bNeedsUpdate;
666
667 // the old template component also checks this state, but it is initialized from this component
668 // so if this componend was already updated the old component does not need such an update
669 ::svt::TemplateFolderCache aTempCache;
670 if ( !bNeedsUpdate )
671 bNeedsUpdate = aTempCache.needsUpdate();
672
673 if ( bNeedsUpdate )
674 aTempCache.storeState();
675
676 return bNeedsUpdate;
677 }
678
679 // -----------------------------------------------------------------------
680 sal_Bool SfxDocTplService_Impl::setTitleForURL( const OUString& rURL, const OUString& aTitle )
681 {
682 sal_Bool bResult = sal_False;
683 if ( mxInfo.is() )
684 {
685 try
686 {
687 mxInfo->loadFromURL( rURL );
688 uno::Reference< XPropertySet > xPropSet( mxInfo, UNO_QUERY_THROW );
689 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
690 xPropSet->setPropertyValue( aPropName, uno::makeAny( aTitle ) );
691 mxInfo->storeIntoURL( rURL );
692 bResult = sal_True;
693 }
694 catch ( Exception& )
695 {
696 }
697 }
698
699 return bResult;
700 }
701
702 // -----------------------------------------------------------------------
703 sal_Bool SfxDocTplService_Impl::getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, sal_Bool& bDocHasTitle )
704 {
705 bDocHasTitle = sal_False;
706
707 if ( mxInfo.is() )
708 {
709 try
710 {
711 mxInfo->loadFromURL( rURL );
712 }
713 catch ( Exception& )
714 {
715 // the document is not a StarOffice document
716 return sal_False;
717 }
718
719 try
720 {
721 uno::Reference< XPropertySet > aPropSet( mxInfo, UNO_QUERY );
722 if ( aPropSet.is() )
723 {
724 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
725 Any aValue = aPropSet->getPropertyValue( aPropName );
726 aValue >>= aTitle;
727
728 aPropName = OUString( RTL_CONSTASCII_USTRINGPARAM( "MIMEType" ) );
729 aValue = aPropSet->getPropertyValue( aPropName );
730 aValue >>= aType;
731 }
732 }
733 catch ( UnknownPropertyException& ) {}
734 catch ( Exception& ) {}
735 }
736
737 if ( ! aType.getLength() && mxType.is() )
738 {
739 ::rtl::OUString aDocType = mxType->queryTypeByURL( rURL );
740 if ( aDocType.getLength() )
741 try
742 {
743 uno::Reference< container::XNameAccess > xTypeDetection( mxType, uno::UNO_QUERY_THROW );
744 SequenceAsHashMap aTypeProps( xTypeDetection->getByName( aDocType ) );
745 aType = aTypeProps.getUnpackedValueOrDefault(
746 ::rtl::OUString::createFromAscii( "MediaType" ),
747 ::rtl::OUString() );
748 }
749 catch( uno::Exception& )
750 {}
751 }
752
753 if ( ! aTitle.getLength() )
754 {
755 INetURLObject aURL( rURL );
756 aURL.CutExtension();
757 aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,
758 INetURLObject::DECODE_WITH_CHARSET );
759 }
760 else
761 bDocHasTitle = sal_True;
762
763 return sal_True;
764 }
765
766 // -----------------------------------------------------------------------
767 sal_Bool SfxDocTplService_Impl::addEntry( Content& rParentFolder,
768 const OUString& rTitle,
769 const OUString& rTargetURL,
770 const OUString& rType )
771 {
772 sal_Bool bAddedEntry = sal_False;
773
774 INetURLObject aLinkObj( rParentFolder.getURL() );
775 aLinkObj.insertName( rTitle, false,
776 INetURLObject::LAST_SEGMENT, true,
777 INetURLObject::ENCODE_ALL );
778 OUString aLinkURL = aLinkObj.GetMainURL( INetURLObject::NO_DECODE );
779
780 Content aLink;
781
782 if ( ! Content::create( aLinkURL, maCmdEnv, aLink ) )
783 {
784 Sequence< OUString > aNames(3);
785 aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
786 aNames[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( IS_FOLDER ) );
787 aNames[2] = OUString( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
788
789 Sequence< Any > aValues(3);
790 aValues[0] = makeAny( rTitle );
791 aValues[1] = makeAny( sal_Bool( sal_False ) );
792 aValues[2] = makeAny( rTargetURL );
793
794 OUString aType( RTL_CONSTASCII_USTRINGPARAM( TYPE_LINK ) );
795 OUString aAdditionalProp( RTL_CONSTASCII_USTRINGPARAM( PROPERTY_TYPE ) );
796
797 try
798 {
799 rParentFolder.insertNewContent( aType, aNames, aValues, aLink );
800 setProperty( aLink, aAdditionalProp, makeAny( rType ) );
801 bAddedEntry = sal_True;
802 }
803 catch( Exception& )
804 {}
805 }
806 return bAddedEntry;
807 }
808
809 // -----------------------------------------------------------------------
810 sal_Bool SfxDocTplService_Impl::createFolder( const OUString& rNewFolderURL,
811 sal_Bool bCreateParent,
812 sal_Bool bFsysFolder,
813 Content &rNewFolder )
814 {
815 Content aParent;
816 sal_Bool bCreatedFolder = sal_False;
817 INetURLObject aParentURL( rNewFolderURL );
818 OUString aFolderName = aParentURL.getName( INetURLObject::LAST_SEGMENT, true,
819 INetURLObject::DECODE_WITH_CHARSET );
820
821 // compute the parent folder url from the new folder url
822 // and remove the final slash, because Content::create doesn't
823 // like it
824 aParentURL.removeSegment();
825 if ( aParentURL.getSegmentCount() >= 1 )
826 aParentURL.removeFinalSlash();
827
828 // if the parent exists, we can continue with the creation of the
829 // new folder, we have to create the parent otherwise ( as long as
830 // bCreateParent is set to true )
831 if ( Content::create( aParentURL.GetMainURL( INetURLObject::NO_DECODE ), maCmdEnv, aParent ) )
832 {
833 try
834 {
835 Sequence< OUString > aNames(2);
836 aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
837 aNames[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( IS_FOLDER ) );
838
839 Sequence< Any > aValues(2);
840 aValues[0] = makeAny( aFolderName );
841 aValues[1] = makeAny( sal_Bool( sal_True ) );
842
843 OUString aType;
844
845 if ( bFsysFolder )
846 aType = OUString( RTL_CONSTASCII_USTRINGPARAM( TYPE_FSYS_FOLDER ) );
847 else
848 aType = OUString( RTL_CONSTASCII_USTRINGPARAM( TYPE_FOLDER ) );
849
850 aParent.insertNewContent( aType, aNames, aValues, rNewFolder );
851 bCreatedFolder = sal_True;
852 }
853 catch( RuntimeException& )
854 {
855 DBG_ERRORFILE( "createFolder(): got runtime exception" );
856 }
857 catch( Exception& )
858 {
859 DBG_ERRORFILE( "createFolder(): Could not create new folder" );
860 }
861 }
862 else if ( bCreateParent )
863 {
864 // if the parent doesn't exists and bCreateParent is set to true,
865 // we try to create the parent and if this was successful, we
866 // try to create the new folder again ( but this time, we set
867 // bCreateParent to false to avoid endless recusions )
868 if ( ( aParentURL.getSegmentCount() >= 1 ) &&
869 createFolder( aParentURL.GetMainURL( INetURLObject::NO_DECODE ), bCreateParent, bFsysFolder, aParent ) )
870 {
871 bCreatedFolder = createFolder( rNewFolderURL, sal_False, bFsysFolder, rNewFolder );
872 }
873 }
874
875 return bCreatedFolder;
876 }
877
878 // -----------------------------------------------------------------------
879 sal_Bool SfxDocTplService_Impl::CreateNewUniqueFolderWithPrefix( const ::rtl::OUString& aPath,
880 const ::rtl::OUString& aPrefix,
881 ::rtl::OUString& aNewFolderName,
882 ::rtl::OUString& aNewFolderURL,
883 Content& aNewFolder )
884 {
885 sal_Bool bCreated = sal_False;
886 INetURLObject aDirPath( aPath );
887
888 Content aParent;
889 if ( Content::create( aDirPath.GetMainURL( INetURLObject::NO_DECODE ), maCmdEnv, aParent ) )
890 {
891 for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ )
892 {
893 ::rtl::OUString aTryName = aPrefix;
894 if ( nInd )
895 aTryName += ::rtl::OUString::valueOf( nInd );
896
897 try
898 {
899 Sequence< OUString > aNames(2);
900 aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
901 aNames[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( IS_FOLDER ) );
902
903 Sequence< Any > aValues(2);
904 aValues[0] = makeAny( aTryName );
905 aValues[1] = makeAny( sal_Bool( sal_True ) );
906
907 OUString aType( RTL_CONSTASCII_USTRINGPARAM( TYPE_FSYS_FOLDER ) );
908
909 bCreated = aParent.insertNewContent( aType, aNames, aValues, aNewFolder );
910 }
911 catch( ucb::NameClashException& )
912 {
913 // if there is already an element, retry
914 }
915 catch( Exception& )
916 {
917 INetURLObject aObjPath( aDirPath );
918 aObjPath.insertName( aTryName, false,
919 INetURLObject::LAST_SEGMENT, true,
920 INetURLObject::ENCODE_ALL );
921 // if there is already an element, retry
922 // if there was another error, do not try any more
923 if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::NO_DECODE ) ) )
924 break;
925 }
926
927 if ( bCreated )
928 {
929 aNewFolderName = aTryName;
930 aNewFolderURL = aNewFolder.get()->getIdentifier()->getContentIdentifier();
931 break;
932 }
933 }
934 }
935
936 return bCreated;
937 }
938
939 // -----------------------------------------------------------------------
940 ::rtl::OUString SfxDocTplService_Impl::CreateNewUniqueFileWithPrefix( const ::rtl::OUString& aPath,
941 const ::rtl::OUString& aPrefix,
942 const ::rtl::OUString& aExt )
943 {
944 ::rtl::OUString aNewFileURL;
945 INetURLObject aDirPath( aPath );
946
947 Content aParent;
948
949 uno::Reference< XCommandEnvironment > aQuietEnv;
950 if ( Content::create( aDirPath.GetMainURL( INetURLObject::NO_DECODE ), aQuietEnv, aParent ) )
951 {
952 for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ )
953 {
954 Content aNewFile;
955 sal_Bool bCreated = sal_False;
956 ::rtl::OUString aTryName = aPrefix;
957 if ( nInd )
958 aTryName += ::rtl::OUString::valueOf( nInd );
959 if ( aExt.toChar() != '.' )
960 aTryName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "." ) );
961 aTryName += aExt;
962
963 try
964 {
965 Sequence< OUString > aNames(2);
966 aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
967 aNames[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( IS_DOCUMENT ) );
968
969 Sequence< Any > aValues(2);
970 aValues[0] = makeAny( aTryName );
971 aValues[1] = makeAny( sal_Bool( sal_True ) );
972
973 OUString aType( RTL_CONSTASCII_USTRINGPARAM( TYPE_FSYS_FILE ) );
974
975 bCreated = aParent.insertNewContent( aType, aNames, aValues, aNewFile );
976 }
977 catch( ucb::NameClashException& )
978 {
979 // if there is already an element, retry
980 }
981 catch( Exception& )
982 {
983 INetURLObject aObjPath( aPath );
984 aObjPath.insertName( aTryName, false,
985 INetURLObject::LAST_SEGMENT, true,
986 INetURLObject::ENCODE_ALL );
987 // if there is already an element, retry
988 // if there was another error, do not try any more
989 if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::NO_DECODE ) ) )
990 break;
991 }
992
993 if ( bCreated )
994 {
995 aNewFileURL = aNewFile.get()->getIdentifier()->getContentIdentifier();
996 break;
997 }
998 }
999 }
1000
1001 return aNewFileURL;
1002 }
1003
1004 // -----------------------------------------------------------------------
1005 sal_Bool SfxDocTplService_Impl::removeContent( Content& rContent )
1006 {
1007 sal_Bool bRemoved = sal_False;
1008 try
1009 {
1010 OUString aCmd( RTL_CONSTASCII_USTRINGPARAM( COMMAND_DELETE ) );
1011 Any aArg = makeAny( sal_Bool( sal_True ) );
1012
1013 rContent.executeCommand( aCmd, aArg );
1014 bRemoved = sal_True;
1015 }
1016 catch ( RuntimeException& ) {}
1017 catch ( Exception& ) {}
1018
1019 return bRemoved;
1020 }
1021
1022 // -----------------------------------------------------------------------
1023 sal_Bool SfxDocTplService_Impl::removeContent( const OUString& rContentURL )
1024 {
1025 Content aContent;
1026
1027 if ( Content::create( rContentURL, maCmdEnv, aContent ) )
1028 return removeContent( aContent );
1029 else
1030 return sal_False;
1031 }
1032
1033 // -----------------------------------------------------------------------
1034 sal_Bool SfxDocTplService_Impl::setProperty( Content& rContent,
1035 const OUString& rPropName,
1036 const Any& rPropValue )
1037 {
1038 sal_Bool bPropertySet = sal_False;
1039
1040 // Store the property
1041 try
1042 {
1043 Any aPropValue( rPropValue );
1044 uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties();
1045
1046 // check, wether or not the property exists, create it, when not
1047 if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) )
1048 {
1049 uno::Reference< XPropertyContainer > xProperties( rContent.get(), UNO_QUERY );
1050 if ( xProperties.is() )
1051 {
1052 try
1053 {
1054 xProperties->addProperty( rPropName, PropertyAttribute::MAYBEVOID, rPropValue );
1055 }
1056 catch( PropertyExistException& ) {}
1057 catch( IllegalTypeException& ) { DBG_ERRORFILE( "IllegalTypeException" ); }
1058 catch( IllegalArgumentException& ) { DBG_ERRORFILE( "IllegalArgumentException" ); }
1059 }
1060 }
1061
1062 // To ensure a reloctable office installation, the path to the
1063 // office installtion directory must never be stored directly.
1064 if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) )
1065 {
1066 OUString aValue;
1067 if ( rPropValue >>= aValue )
1068 {
1069 maRelocator.makeRelocatableURL( aValue );
1070 aPropValue = makeAny( aValue );
1071 }
1072 else
1073 {
1074 Sequence< OUString > aValues;
1075 if ( rPropValue >>= aValues )
1076 {
1077 for ( sal_Int32 n = 0; n < aValues.getLength(); n++ )
1078 {
1079 maRelocator.makeRelocatableURL( aValues[ n ] );
1080 }
1081 aPropValue = makeAny( aValues );
1082 }
1083 else
1084 {
1085 OSL_ENSURE( false, "Unsupported property value type" );
1086 }
1087 }
1088 }
1089
1090 // now set the property
1091
1092 rContent.setPropertyValue( rPropName, aPropValue );
1093 bPropertySet = sal_True;
1094 }
1095 catch ( RuntimeException& ) {}
1096 catch ( Exception& ) {}
1097
1098 return bPropertySet;
1099 }
1100
1101 // -----------------------------------------------------------------------
1102 sal_Bool SfxDocTplService_Impl::getProperty( Content& rContent,
1103 const OUString& rPropName,
1104 Any& rPropValue )
1105 {
1106 sal_Bool bGotProperty = sal_False;
1107
1108 // Get the property
1109 try
1110 {
1111 uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties();
1112
1113 // check, wether or not the property exists
1114 if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) )
1115 {
1116 return sal_False;
1117 }
1118
1119 // now get the property
1120
1121 rPropValue = rContent.getPropertyValue( rPropName );
1122
1123 // To ensure a reloctable office installation, the path to the
1124 // office installtion directory must never be stored directly.
1125 if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) )
1126 {
1127 OUString aValue;
1128 if ( rPropValue >>= aValue )
1129 {
1130 maRelocator.makeAbsoluteURL( aValue );
1131 rPropValue = makeAny( aValue );
1132 }
1133 else
1134 {
1135 Sequence< OUString > aValues;
1136 if ( rPropValue >>= aValues )
1137 {
1138 for ( sal_Int32 n = 0; n < aValues.getLength(); n++ )
1139 {
1140 maRelocator.makeAbsoluteURL( aValues[ n ] );
1141 }
1142 rPropValue = makeAny( aValues );
1143 }
1144 else
1145 {
1146 OSL_ENSURE( false, "Unsupported property value type" );
1147 }
1148 }
1149 }
1150
1151 bGotProperty = sal_True;
1152 }
1153 catch ( RuntimeException& ) {}
1154 catch ( Exception& ) {}
1155
1156 return bGotProperty;
1157 }
1158
1159 // -----------------------------------------------------------------------
1160 // static
1161 bool SfxURLRelocator_Impl::propertyCanContainOfficeDir(
1162 const rtl::OUString & rPropName )
1163 {
1164 // Note: TargetURL is handled by UCB itself (because it is a property
1165 // with a predefined semantic). Additional Core properties introduced
1166 // be a client app must be handled by the client app itself, because
1167 // the UCB does not know the semantics of those properties.
1168 return ( rPropName.equalsAsciiL(
1169 RTL_CONSTASCII_STRINGPARAM( TARGET_DIR_URL ) ) ||
1170 rPropName.equalsAsciiL(
1171 RTL_CONSTASCII_STRINGPARAM( PROPERTY_DIRLIST ) ) );
1172 }
1173
1174 //-----------------------------------------------------------------------------
1175 // public SfxDocTplService_Impl
1176 //-----------------------------------------------------------------------------
1177
1178 SfxDocTplService_Impl::SfxDocTplService_Impl( uno::Reference< XMultiServiceFactory > xFactory )
1179 : maRelocator( xFactory )
1180 {
1181 mxFactory = xFactory;
1182 mpUpdater = NULL;
1183 mbIsInitialized = sal_False;
1184 mbLocaleSet = sal_False;
1185 }
1186
1187 //-----------------------------------------------------------------------------
1188 SfxDocTplService_Impl::~SfxDocTplService_Impl()
1189 {
1190 ::osl::MutexGuard aGuard( maMutex );
1191
1192 if ( mpUpdater )
1193 {
1194 mpUpdater->kill();
1195 delete mpUpdater;
1196 }
1197 }
1198
1199 //-----------------------------------------------------------------------------
1200 Locale SfxDocTplService_Impl::getLocale()
1201 {
1202 ::osl::MutexGuard aGuard( maMutex );
1203
1204 if ( !mbLocaleSet )
1205 getDefaultLocale();
1206
1207 return maLocale;
1208 }
1209
1210 //-----------------------------------------------------------------------------
1211 void SfxDocTplService_Impl::setLocale( const Locale &rLocale )
1212 {
1213 ::osl::MutexGuard aGuard( maMutex );
1214
1215 if ( mbLocaleSet &&
1216 ( maLocale.Language != rLocale.Language ) &&
1217 ( maLocale.Country != rLocale.Country ) )
1218 mbIsInitialized = sal_False;
1219
1220 maLocale = rLocale;
1221 mbLocaleSet = sal_True;
1222 }
1223
1224 //-----------------------------------------------------------------------------
1225 void SfxDocTplService_Impl::update( sal_Bool bUpdateNow )
1226 {
1227 ::osl::MutexGuard aGuard( maMutex );
1228
1229 if ( bUpdateNow )
1230 doUpdate();
1231 else
1232 {
1233 mpUpdater = new Updater_Impl( this );
1234 mpUpdater->create();
1235 }
1236 }
1237
1238 //-----------------------------------------------------------------------------
1239 void SfxDocTplService_Impl::doUpdate()
1240 {
1241 ::osl::MutexGuard aGuard( maMutex );
1242
1243 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( PROPERTY_NEEDSUPDATE ) );
1244 Any aValue;
1245
1246 aValue <<= sal_True;
1247 setProperty( maRootContent, aPropName, aValue );
1248
1249 GroupList_Impl aGroupList;
1250
1251 // get the entries from the hierarchy
1252 createFromContent( aGroupList, maRootContent, sal_True );
1253
1254 // get the entries from the template directories
1255 sal_Int32 nCountDir = maTemplateDirs.getLength();
1256 OUString* pDirs = maTemplateDirs.getArray();
1257 Content aDirContent;
1258
1259 // the last directory in the list must be writable
1260 sal_Bool bWriteableDirectory = sal_True;
1261
1262 // the target folder might not exist, for this reason no interaction handler should be used
1263 uno::Reference< XCommandEnvironment > aQuietEnv;
1264
1265 while ( nCountDir )
1266 {
1267 nCountDir--;
1268 osl::Directory aDirectory (pDirs[ nCountDir ]);
1269 osl::FileBase::RC nError = aDirectory.open();
1270 if (nError == osl::FileBase::E_None || bWriteableDirectory)
1271 {
1272 if ( Content::create( pDirs[ nCountDir ], aQuietEnv, aDirContent ) )
1273 {
1274 createFromContent( aGroupList, aDirContent, sal_False, bWriteableDirectory );
1275 }
1276 aDirectory.close();
1277 }
1278 bWriteableDirectory = sal_False;
1279 }
1280
1281 // now check the list
1282 GroupData_Impl *pGroup = aGroupList.First();
1283 while ( pGroup )
1284 {
1285 if ( pGroup->getInUse() )
1286 {
1287 if ( pGroup->getInHierarchy() )
1288 {
1289 Content aGroup;
1290 if ( Content::create( pGroup->getHierarchyURL(), maCmdEnv, aGroup ) )
1291 setProperty( aGroup,
1292 OUString( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) ),
1293 makeAny( pGroup->getTargetURL() ) );
1294
1295 ULONG nCount = pGroup->count();
1296 for ( ULONG i=0; i<nCount; i++ )
1297 {
1298 DocTemplates_EntryData_Impl *pData = pGroup->getEntry( i );
1299 if ( ! pData->getInUse() )
1300 {
1301 if ( pData->getInHierarchy() )
1302 removeFromHierarchy( pData ); // delete entry in hierarchy
1303 else
1304 addToHierarchy( pGroup, pData ); // add entry to hierarchy
1305 }
1306 else if ( pData->getUpdateType() ||
1307 pData->getUpdateLink() )
1308 {
1309 updateData( pData );
1310 }
1311 }
1312 }
1313 else
1314 {
1315 addGroupToHierarchy( pGroup ); // add group to hierarchy
1316 }
1317 }
1318 else
1319 removeFromHierarchy( pGroup ); // delete group from hierarchy
1320
1321 delete pGroup;
1322 pGroup = aGroupList.Next();
1323 }
1324
1325 aValue <<= sal_False;
1326 setProperty( maRootContent, aPropName, aValue );
1327 }
1328
1329 //-----------------------------------------------------------------------------
1330 uno::Sequence< beans::StringPair > SfxDocTplService_Impl::ReadUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath )
1331 {
1332 INetURLObject aLocObj( aUserPath );
1333 aLocObj.insertName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "groupuinames.xml" ) ), false,
1334 INetURLObject::LAST_SEGMENT, true,
1335 INetURLObject::ENCODE_ALL );
1336 Content aLocContent;
1337
1338 // TODO/LATER: Use hashmap in future
1339 uno::Sequence< beans::StringPair > aUINames;
1340 if ( Content::create( aLocObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference < ucb::XCommandEnvironment >(), aLocContent ) )
1341 {
1342 try
1343 {
1344 uno::Reference< io::XInputStream > xLocStream = aLocContent.openStream();
1345 if ( xLocStream.is() )
1346 aUINames = DocTemplLocaleHelper::ReadGroupLocalizationSequence( xLocStream, mxFactory );
1347 }
1348 catch( uno::Exception& )
1349 {}
1350 }
1351
1352 return aUINames;
1353 }
1354
1355 //-----------------------------------------------------------------------------
1356 sal_Bool SfxDocTplService_Impl::UpdateUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
1357 const ::rtl::OUString& aGroupName,
1358 const ::rtl::OUString& aNewFolderName )
1359 {
1360 uno::Sequence< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath );
1361 sal_Int32 nLen = aUINames.getLength();
1362
1363 // it is possible that the name is used already, but it should be checked before
1364 for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ )
1365 if ( aUINames[nInd].First.equals( aNewFolderName ) )
1366 return sal_False;
1367
1368 aUINames.realloc( ++nLen );
1369 aUINames[nLen-1].First = aNewFolderName;
1370 aUINames[nLen-1].Second = aGroupName;
1371
1372 return WriteUINamesForTemplateDir_Impl( aUserPath, aUINames );
1373 }
1374
1375 //-----------------------------------------------------------------------------
1376 sal_Bool SfxDocTplService_Impl::ReplaceUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
1377 const ::rtl::OUString& aDefaultFsysGroupName,
1378 const ::rtl::OUString& aOldGroupName,
1379 const ::rtl::OUString& aNewGroupName )
1380 {
1381 uno::Sequence< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath );
1382 sal_Int32 nLen = aUINames.getLength();
1383
1384 sal_Bool bChanged = sal_False;
1385 for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ )
1386 if ( aUINames[nInd].Second.equals( aOldGroupName ) )
1387 {
1388 aUINames[nInd].Second = aNewGroupName;
1389 bChanged = sal_True;
1390 }
1391
1392 if ( !bChanged )
1393 {
1394 aUINames.realloc( ++nLen );
1395 aUINames[nLen-1].First = aDefaultFsysGroupName;
1396 aUINames[nLen-1].Second = aNewGroupName;
1397 }
1398 return WriteUINamesForTemplateDir_Impl( aUserPath, aUINames );
1399 }
1400
1401 //-----------------------------------------------------------------------------
1402 sal_Bool SfxDocTplService_Impl::RemoveUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
1403 const ::rtl::OUString& aGroupName )
1404 {
1405 uno::Sequence< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath );
1406 sal_Int32 nLen = aUINames.getLength();
1407 uno::Sequence< beans::StringPair > aNewUINames( nLen );
1408 sal_Int32 nNewLen = 0;
1409
1410 sal_Bool bChanged = sal_False;
1411 for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ )
1412 if ( aUINames[nInd].Second.equals( aGroupName ) )
1413 bChanged = sal_True;
1414 else
1415 {
1416 nNewLen++;
1417 aNewUINames[nNewLen-1].First = aUINames[nInd].First;
1418 aNewUINames[nNewLen-1].Second = aUINames[nInd].Second;
1419 }
1420
1421 aNewUINames.realloc( nNewLen );
1422
1423 return bChanged ? WriteUINamesForTemplateDir_Impl( aUserPath, aNewUINames ) : sal_True;
1424 }
1425
1426
1427 //-----------------------------------------------------------------------------
1428 sal_Bool SfxDocTplService_Impl::WriteUINamesForTemplateDir_Impl( const ::rtl::OUString& aUserPath,
1429 const uno::Sequence< beans::StringPair >& aUINames )
1430 {
1431 sal_Bool bResult = sal_False;
1432 try {
1433 uno::Reference< beans::XPropertySet > xTempFile(
1434 mxFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ),
1435 uno::UNO_QUERY_THROW );
1436
1437 ::rtl::OUString aTempURL;
1438 uno::Any aUrl = xTempFile->getPropertyValue( ::rtl::OUString::createFromAscii( "Uri" ) );
1439 aUrl >>= aTempURL;
1440
1441 uno::Reference< io::XStream > xStream( xTempFile, uno::UNO_QUERY_THROW );
1442 uno::Reference< io::XOutputStream > xOutStream = xStream->getOutputStream();
1443 if ( !xOutStream.is() )
1444 throw uno::RuntimeException();
1445
1446 DocTemplLocaleHelper::WriteGroupLocalizationSequence( xOutStream, aUINames, mxFactory );
1447 try {
1448 // the SAX writer might close the stream
1449 xOutStream->closeOutput();
1450 } catch( uno::Exception& )
1451 {}
1452
1453 Content aTargetContent( aUserPath, maCmdEnv );
1454 Content aSourceContent( aTempURL, maCmdEnv );
1455 aTargetContent.transferContent( aSourceContent,
1456 InsertOperation_COPY,
1457 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "groupuinames.xml" ) ),
1458 ucb::NameClash::OVERWRITE );
1459 bResult = sal_True;
1460 }
1461 catch ( uno::Exception& )
1462 {
1463 }
1464
1465 return bResult;
1466 }
1467
1468 //-----------------------------------------------------------------------------
1469 ::rtl::OUString SfxDocTplService_Impl::CreateNewGroupFsys( const ::rtl::OUString& rGroupName, Content& aGroup )
1470 {
1471 ::rtl::OUString aResultURL;
1472
1473 if ( maTemplateDirs.getLength() )
1474 {
1475 ::rtl::OUString aTargetPath = maTemplateDirs[ maTemplateDirs.getLength() - 1 ];
1476
1477 // create a new folder with the given name
1478 Content aNewFolder;
1479 ::rtl::OUString aNewFolderName;
1480
1481 // the Fsys name instead of GroupName should be used, the groupuinames must be added also
1482 if ( !CreateNewUniqueFolderWithPrefix( aTargetPath,
1483 rGroupName,
1484 aNewFolderName,
1485 aResultURL,
1486 aNewFolder )
1487 && !CreateNewUniqueFolderWithPrefix( aTargetPath,
1488 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserGroup" ) ),
1489 aNewFolderName,
1490 aResultURL,
1491 aNewFolder ) )
1492
1493 return ::rtl::OUString();
1494
1495 if ( !UpdateUINamesForTemplateDir_Impl( aTargetPath, rGroupName, aNewFolderName ) )
1496 {
1497 // we could not create the groupuinames for the folder, so we delete the group in the
1498 // the folder and return
1499 removeContent( aNewFolder );
1500 return ::rtl::OUString();
1501 }
1502
1503 // Now set the target url for this group and we are done
1504 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
1505 Any aValue = makeAny( aResultURL );
1506
1507 if ( ! setProperty( aGroup, aPropName, aValue ) )
1508 {
1509 removeContent( aNewFolder );
1510 return ::rtl::OUString();
1511 }
1512 }
1513
1514 return aResultURL;
1515 }
1516
1517 //-----------------------------------------------------------------------------
1518 sal_Bool SfxDocTplService_Impl::addGroup( const OUString& rGroupName )
1519 {
1520 ::osl::MutexGuard aGuard( maMutex );
1521
1522 // Check, wether or not there is a group with this name
1523 Content aNewGroup;
1524 OUString aNewGroupURL;
1525 INetURLObject aNewGroupObj( maRootURL );
1526
1527 aNewGroupObj.insertName( rGroupName, false,
1528 INetURLObject::LAST_SEGMENT, true,
1529 INetURLObject::ENCODE_ALL );
1530
1531 aNewGroupURL = aNewGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1532
1533 if ( Content::create( aNewGroupURL, maCmdEnv, aNewGroup ) ||
1534 ! createFolder( aNewGroupURL, sal_False, sal_False, aNewGroup ) )
1535 {
1536 // if there already was a group with this name or the new group
1537 // could not be created, we return here
1538 return sal_False;
1539 }
1540
1541 // Get the user template path entry ( new group will always
1542 // be added in the user template path )
1543 sal_Int32 nIndex;
1544 OUString aUserPath;
1545
1546 nIndex = maTemplateDirs.getLength();
1547 if ( nIndex )
1548 nIndex--;
1549 else
1550 return sal_False; // We don't know where to add the group
1551
1552 aUserPath = maTemplateDirs[ nIndex ];
1553
1554 // create a new folder with the given name
1555 Content aNewFolder;
1556 OUString aNewFolderName;
1557 OUString aNewFolderURL;
1558
1559 // the Fsys name instead of GroupName should be used, the groupuinames must be added also
1560 if ( !CreateNewUniqueFolderWithPrefix( aUserPath,
1561 rGroupName,
1562 aNewFolderName,
1563 aNewFolderURL,
1564 aNewFolder )
1565 && !CreateNewUniqueFolderWithPrefix( aUserPath,
1566 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserGroup" ) ),
1567 aNewFolderName,
1568 aNewFolderURL,
1569 aNewFolder ) )
1570 {
1571 // we could not create the folder, so we delete the group in the
1572 // hierarchy and return
1573 removeContent( aNewGroup );
1574 return sal_False;
1575 }
1576
1577 if ( !UpdateUINamesForTemplateDir_Impl( aUserPath, rGroupName, aNewFolderName ) )
1578 {
1579 // we could not create the groupuinames for the folder, so we delete the group in the
1580 // hierarchy, the folder and return
1581 removeContent( aNewGroup );
1582 removeContent( aNewFolder );
1583 return sal_False;
1584 }
1585
1586 // Now set the target url for this group and we are done
1587 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
1588 Any aValue = makeAny( aNewFolderURL );
1589
1590 if ( ! setProperty( aNewGroup, aPropName, aValue ) )
1591 {
1592 removeContent( aNewGroup );
1593 removeContent( aNewFolder );
1594 return sal_False;
1595 }
1596
1597 return sal_True;
1598 }
1599
1600 //-----------------------------------------------------------------------------
1601 sal_Bool SfxDocTplService_Impl::removeGroup( const OUString& rGroupName )
1602 {
1603 // remove all the elements that have the prefix aTargetURL
1604 // if the group does not have other elements remove it
1605
1606 ::osl::MutexGuard aGuard( maMutex );
1607
1608 sal_Bool bResult = sal_False;
1609
1610 // create the group url
1611 INetURLObject aGroupObj( maRootURL );
1612 aGroupObj.insertName( rGroupName, false,
1613 INetURLObject::LAST_SEGMENT, true,
1614 INetURLObject::ENCODE_ALL );
1615
1616 // Get the target url
1617 Content aGroup;
1618 OUString aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1619
1620 if ( Content::create( aGroupURL, maCmdEnv, aGroup ) )
1621 {
1622 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
1623 Any aValue;
1624
1625 OUString aGroupTargetURL;
1626 if ( getProperty( aGroup, aPropName, aValue ) )
1627 aValue >>= aGroupTargetURL;
1628
1629 if ( !aGroupTargetURL.getLength() )
1630 return sal_False; // nothing is allowed to be removed
1631
1632 if ( !maTemplateDirs.getLength() )
1633 return sal_False;
1634 ::rtl::OUString aGeneralTempPath = maTemplateDirs[ maTemplateDirs.getLength() - 1 ];
1635
1636 // check that the fs location is in writeble folder and this is not a "My templates" folder
1637 INetURLObject aGroupParentFolder( aGroupTargetURL );
1638 if ( !aGroupParentFolder.removeSegment()
1639 || !::utl::UCBContentHelper::IsSubPath( aGeneralTempPath,
1640 aGroupParentFolder.GetMainURL( INetURLObject::NO_DECODE ) ) )
1641 return sal_False;
1642
1643 // now get the content of the Group
1644 uno::Reference< XResultSet > xResultSet;
1645 Sequence< OUString > aProps( 1 );
1646
1647 aProps[0] = OUString::createFromAscii( TARGET_URL );
1648
1649 try
1650 {
1651 sal_Bool bHasNonRemovable = sal_False;
1652 sal_Bool bHasShared = sal_False;
1653
1654 ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
1655 xResultSet = aGroup.createCursor( aProps, eInclude );
1656
1657 if ( xResultSet.is() )
1658 {
1659 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW );
1660 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW );
1661
1662 while ( xResultSet->next() )
1663 {
1664 OUString aTemplTargetURL( xRow->getString( 1 ) );
1665 OUString aHierURL = xContentAccess->queryContentIdentifierString();
1666
1667 if ( ::utl::UCBContentHelper::IsSubPath( aGroupTargetURL, aTemplTargetURL ) )
1668 {
1669 // this is a user template, and it can be removed
1670 if ( removeContent( aTemplTargetURL ) )
1671 removeContent( aHierURL );
1672 else
1673 bHasNonRemovable = sal_True;
1674 }
1675 else
1676 bHasShared = sal_True;
1677 }
1678
1679 if ( !bHasNonRemovable && !bHasShared )
1680 {
1681 if ( removeContent( aGroupTargetURL )
1682 || !::utl::UCBContentHelper::Exists( aGroupTargetURL ) )
1683 {
1684 removeContent( aGroupURL );
1685 RemoveUINamesForTemplateDir_Impl( aGeneralTempPath, rGroupName );
1686 bResult = sal_True; // the operation is successful only if the whole group is removed
1687 }
1688 }
1689 else if ( !bHasNonRemovable )
1690 {
1691 if ( removeContent( aGroupTargetURL )
1692 || !::utl::UCBContentHelper::Exists( aGroupTargetURL ) )
1693 {
1694 RemoveUINamesForTemplateDir_Impl( aGeneralTempPath, rGroupName );
1695 setProperty( aGroup, aPropName, uno::makeAny( ::rtl::OUString() ) );
1696 }
1697 }
1698 }
1699 }
1700 catch ( Exception& ) {}
1701 }
1702
1703 return bResult;
1704 }
1705
1706 //-----------------------------------------------------------------------------
1707 sal_Bool SfxDocTplService_Impl::renameGroup( const OUString& rOldName,
1708 const OUString& rNewName )
1709 {
1710 ::osl::MutexGuard aGuard( maMutex );
1711
1712 // create the group url
1713 Content aGroup;
1714 INetURLObject aGroupObj( maRootURL );
1715 aGroupObj.insertName( rNewName, false,
1716 INetURLObject::LAST_SEGMENT, true,
1717 INetURLObject::ENCODE_ALL );
1718 OUString aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1719
1720 // Check, if there is a group with the new name, return false
1721 // if there is one.
1722 if ( Content::create( aGroupURL, maCmdEnv, aGroup ) )
1723 return sal_False;
1724
1725 aGroupObj.removeSegment();
1726 aGroupObj.insertName( rOldName, false,
1727 INetURLObject::LAST_SEGMENT, true,
1728 INetURLObject::ENCODE_ALL );
1729 aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1730
1731 // When there is no group with the old name, we can't rename it
1732 if ( ! Content::create( aGroupURL, maCmdEnv, aGroup ) )
1733 return sal_False;
1734
1735 OUString aGroupTargetURL;
1736 // there is no need to check whether target dir url is in target path, since if the target path is changed
1737 // the target dir url should be already generated new
1738 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
1739 Any aValue;
1740 if ( getProperty( aGroup, aPropName, aValue ) )
1741 aValue >>= aGroupTargetURL;
1742
1743 if ( !aGroupTargetURL.getLength() )
1744 return sal_False;
1745
1746 if ( !maTemplateDirs.getLength() )
1747 return sal_False;
1748 ::rtl::OUString aGeneralTempPath = maTemplateDirs[ maTemplateDirs.getLength() - 1 ];
1749
1750 // check that the fs location is in writeble folder and this is not a "My templates" folder
1751 INetURLObject aGroupParentFolder( aGroupTargetURL );
1752 if ( !aGroupParentFolder.removeSegment()
1753 || !::utl::UCBContentHelper::IsSubPath( aGeneralTempPath,
1754 aGroupParentFolder.GetMainURL( INetURLObject::NO_DECODE ) ) )
1755 return sal_False;
1756
1757 // check that the group can be renamed ( all the contents must be in target location )
1758 sal_Bool bCanBeRenamed = sal_False;
1759 try
1760 {
1761 uno::Reference< XResultSet > xResultSet;
1762 Sequence< OUString > aProps( 1 );
1763
1764 aProps[0] = OUString::createFromAscii( TARGET_URL );
1765 ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
1766 xResultSet = aGroup.createCursor( aProps, eInclude );
1767
1768 if ( xResultSet.is() )
1769 {
1770 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW );
1771 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW );
1772
1773 while ( xResultSet->next() )
1774 {
1775 OUString aTemplTargetURL( xRow->getString( 1 ) );
1776
1777 if ( !::utl::UCBContentHelper::IsSubPath( aGroupTargetURL, aTemplTargetURL ) )
1778 throw uno::Exception();
1779 }
1780
1781 bCanBeRenamed = sal_True;
1782 }
1783 }
1784 catch ( Exception& ) {}
1785
1786 if ( bCanBeRenamed )
1787 {
1788 INetURLObject aGroupTargetObj( aGroupTargetURL );
1789 ::rtl::OUString aFsysName = aGroupTargetObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
1790
1791 if ( aGroupTargetObj.removeSegment()
1792 && ReplaceUINamesForTemplateDir_Impl( aGroupTargetObj.GetMainURL( INetURLObject::NO_DECODE ),
1793 aFsysName,
1794 rOldName,
1795 rNewName ) )
1796 {
1797 // rename the group in the hierarchy
1798 OUString aTitleProp( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
1799 Any aTitleValue;
1800 aTitleValue <<= rNewName;
1801
1802 return setProperty( aGroup, aTitleProp, aTitleValue );
1803 }
1804 }
1805
1806 return sal_False;
1807 }
1808
1809 //-----------------------------------------------------------------------------
1810 sal_Bool SfxDocTplService_Impl::storeTemplate( const OUString& rGroupName,
1811 const OUString& rTemplateName,
1812 const uno::Reference< XSTORABLE >& rStorable )
1813 {
1814 ::osl::MutexGuard aGuard( maMutex );
1815
1816 // Check, wether or not there is a group with this name
1817 // Return false, if there is no group with the given name
1818 Content aGroup, aTemplate, aTargetGroup, aTemplateToRemove;
1819 OUString aGroupURL, aTemplateURL, aTemplateToRemoveTargetURL;
1820 INetURLObject aGroupObj( maRootURL );
1821 sal_Bool bRemoveOldTemplateContent = sal_False;
1822 ::rtl::OUString sDocServiceName;
1823
1824 aGroupObj.insertName( rGroupName, false,
1825 INetURLObject::LAST_SEGMENT, true,
1826 INetURLObject::ENCODE_ALL );
1827 aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1828
1829 if ( ! Content::create( aGroupURL, maCmdEnv, aGroup ) )
1830 return sal_False;
1831
1832 ::rtl::OUString aGroupTargetURL;
1833 ::rtl::OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
1834 Any aValue;
1835 if ( getProperty( aGroup, aPropName, aValue ) )
1836 aValue >>= aGroupTargetURL;
1837
1838
1839 // Check, if there's a template with the given name in this group
1840 // the target template should be overwritten if it is imported by user
1841 // in case the template is installed by office installation of by an add-in
1842 // it can not be replaced
1843 aGroupObj.insertName( rTemplateName, false,
1844 INetURLObject::LAST_SEGMENT, true,
1845 INetURLObject::ENCODE_ALL );
1846 aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
1847
1848 if ( Content::create( aTemplateURL, maCmdEnv, aTemplateToRemove ) )
1849 {
1850 OUString aTargetTemplPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
1851
1852 bRemoveOldTemplateContent = sal_True;
1853 if ( getProperty( aTemplateToRemove, aTargetTemplPropName, aValue ) )
1854 aValue >>= aTemplateToRemoveTargetURL;
1855
1856 if ( !aGroupTargetURL.getLength() || !maTemplateDirs.getLength()
1857 || (aTemplateToRemoveTargetURL.getLength() && !::utl::UCBContentHelper::IsSubPath( maTemplateDirs[ maTemplateDirs.getLength() - 1 ], aTemplateToRemoveTargetURL )) )
1858 return sal_False; // it is not allowed to remove the template
1859 }
1860
1861 try
1862 {
1863 uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();
1864 if ( !xFactory.is() )
1865 throw uno::RuntimeException();
1866
1867 // get document service name
1868 uno::Reference< frame::XModuleManager > xModuleManager(
1869 xFactory->createInstance(
1870 ::rtl::OUString::createFromAscii( "com.sun.star.frame.ModuleManager" ) ),
1871 uno::UNO_QUERY_THROW );
1872 sDocServiceName = xModuleManager->identify( uno::Reference< uno::XInterface >( rStorable, uno::UNO_QUERY ) );
1873 if ( !sDocServiceName.getLength() )
1874 throw uno::RuntimeException();
1875
1876 // get the actual filter name
1877 ::rtl::OUString aFilterName;
1878
1879 uno::Reference< lang::XMultiServiceFactory > xConfigProvider(
1880 xFactory->createInstance(
1881 ::rtl::OUString::createFromAscii( "com.sun.star.configuration.ConfigurationProvider" ) ),
1882 uno::UNO_QUERY_THROW );
1883
1884 uno::Sequence< uno::Any > aArgs( 1 );
1885 beans::PropertyValue aPathProp;
1886 aPathProp.Name = ::rtl::OUString::createFromAscii( "nodepath" );
1887 aPathProp.Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Setup/Office/Factories/" ) );
1888 aArgs[0] <<= aPathProp;
1889
1890 uno::Reference< container::XNameAccess > xSOFConfig(
1891 xConfigProvider->createInstanceWithArguments(
1892 ::rtl::OUString::createFromAscii( "com.sun.star.configuration.ConfigurationAccess" ),
1893 aArgs ),
1894 uno::UNO_QUERY_THROW );
1895
1896 uno::Reference< container::XNameAccess > xApplConfig;
1897 xSOFConfig->getByName( sDocServiceName ) >>= xApplConfig;
1898 if ( !xApplConfig.is() )
1899 throw uno::RuntimeException();
1900
1901 xApplConfig->getByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ooSetupFactoryActualTemplateFilter" ) ) ) >>= aFilterName;
1902 if ( !aFilterName.getLength() )
1903 throw uno::RuntimeException();
1904
1905 // find the related type name
1906 ::rtl::OUString aTypeName;
1907 uno::Reference< container::XNameAccess > xFilterFactory(
1908 xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ),
1909 uno::UNO_QUERY_THROW );
1910
1911 uno::Sequence< beans::PropertyValue > aFilterData;
1912 xFilterFactory->getByName( aFilterName ) >>= aFilterData;
1913 for ( sal_Int32 nInd = 0; nInd < aFilterData.getLength(); nInd++ )
1914 if ( aFilterData[nInd].Name.equalsAscii( "Type" ) )
1915 aFilterData[nInd].Value >>= aTypeName;
1916
1917 if ( !aTypeName.getLength() )
1918 throw uno::RuntimeException();
1919
1920 // find the mediatype and extension
1921 uno::Reference< container::XNameAccess > xTypeDetection =
1922 mxType.is() ?
1923 uno::Reference< container::XNameAccess >( mxType, uno::UNO_QUERY_THROW ) :
1924 uno::Reference< container::XNameAccess >(
1925 xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.TypeDetection" ) ),
1926 uno::UNO_QUERY_THROW );
1927
1928 SequenceAsHashMap aTypeProps( xTypeDetection->getByName( aTypeName ) );
1929 uno::Sequence< ::rtl::OUString > aAllExt =
1930 aTypeProps.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Extensions" ), Sequence< ::rtl::OUString >() );
1931 if ( !aAllExt.getLength() )
1932 throw uno::RuntimeException();
1933
1934 ::rtl::OUString aMediaType = aTypeProps.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "MediaType" ), ::rtl::OUString() );
1935 ::rtl::OUString aExt = aAllExt[0];
1936
1937 if ( !aMediaType.getLength() || !aExt.getLength() )
1938 throw uno::RuntimeException();
1939
1940 // construct destination url
1941 if ( !aGroupTargetURL.getLength() )
1942 {
1943 aGroupTargetURL = CreateNewGroupFsys( rGroupName, aGroup );
1944
1945 if ( !aGroupTargetURL.getLength() )
1946 throw uno::RuntimeException();
1947 }
1948
1949 ::rtl::OUString aNewTemplateTargetURL = CreateNewUniqueFileWithPrefix( aGroupTargetURL, rTemplateName, aExt );
1950 if ( !aNewTemplateTargetURL.getLength() )
1951 {
1952 aNewTemplateTargetURL = CreateNewUniqueFileWithPrefix( aGroupTargetURL, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserTemplate" ) ), aExt );
1953
1954 if ( !aNewTemplateTargetURL.getLength() )
1955 throw uno::RuntimeException();
1956 }
1957
1958 // store template
1959 uno::Sequence< PropertyValue > aStoreArgs( 2 );
1960 aStoreArgs[0].Name = ::rtl::OUString::createFromAscii( "FilterName" );
1961 aStoreArgs[0].Value <<= aFilterName;
1962 aStoreArgs[1].Name = ::rtl::OUString::createFromAscii( "DocumentTitle" );
1963 aStoreArgs[1].Value <<= rTemplateName;
1964
1965 ::rtl::OUString aCurrentDocumentURL = rStorable->getLocation();
1966 if( !SfxMedium::EqualURLs( aNewTemplateTargetURL, rStorable->getLocation() ))
1967 rStorable->storeToURL( aNewTemplateTargetURL, aStoreArgs );
1968 else
1969 rStorable->store();
1970
1971 // the storing was successful, now the old template with the same name can be removed if it existed
1972 if ( aTemplateToRemoveTargetURL.getLength() )
1973 {
1974 removeContent( aTemplateToRemoveTargetURL );
1975
1976 /*
1977 * pb: #i79496#
1978 * if the old template was the standard template
1979 * it is necessary to change the standard template with the new file name
1980 */
1981 String sStdTmplFile = SfxObjectFactory::GetStandardTemplate( sDocServiceName );
1982 if ( INetURLObject( sStdTmplFile ) == INetURLObject( aTemplateToRemoveTargetURL ) )
1983 {
1984 SfxObjectFactory::SetStandardTemplate( sDocServiceName, aNewTemplateTargetURL );
1985 }
1986 }
1987
1988 if ( bRemoveOldTemplateContent )
1989 removeContent( aTemplateToRemove );
1990
1991 // add the template to hierarchy
1992 return addEntry( aGroup, rTemplateName, aNewTemplateTargetURL, aMediaType );
1993 }
1994 catch( Exception& )
1995 {
1996 // the template was not stored
1997 return sal_False;
1998 }
1999 }
2000
2001 //-----------------------------------------------------------------------------
2002 sal_Bool SfxDocTplService_Impl::addTemplate( const OUString& rGroupName,
2003 const OUString& rTemplateName,
2004 const OUString& rSourceURL )
2005 {
2006 ::osl::MutexGuard aGuard( maMutex );
2007
2008 // Check, wether or not there is a group with this name
2009 // Return false, if there is no group with the given name
2010 Content aGroup, aTemplate, aTargetGroup;
2011 OUString aGroupURL, aTemplateURL;
2012 INetURLObject aGroupObj( maRootURL );
2013
2014 aGroupObj.insertName( rGroupName, false,
2015 INetURLObject::LAST_SEGMENT, true,
2016 INetURLObject::ENCODE_ALL );
2017 aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2018
2019 if ( ! Content::create( aGroupURL, maCmdEnv, aGroup ) )
2020 return sal_False;
2021
2022 // Check, if there's a template with the given name in this group
2023 // Return false, if there already is a template
2024 aGroupObj.insertName( rTemplateName, false,
2025 INetURLObject::LAST_SEGMENT, true,
2026 INetURLObject::ENCODE_ALL );
2027 aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2028
2029 if ( Content::create( aTemplateURL, maCmdEnv, aTemplate ) )
2030 return sal_False;
2031
2032 // get the target url of the group
2033 OUString aTargetURL;
2034 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
2035 Any aValue;
2036
2037 if ( getProperty( aGroup, aPropName, aValue ) )
2038 aValue >>= aTargetURL;
2039
2040 if ( !aTargetURL.getLength() )
2041 {
2042 aTargetURL = CreateNewGroupFsys( rGroupName, aGroup );
2043
2044 if ( !aTargetURL.getLength() )
2045 return sal_False;
2046 }
2047
2048 // Get the content type
2049 OUString aTitle, aType, aTargetURL2, aFullName;
2050
2051 // only StarOffice documents are acceptable
2052 sal_Bool bDocHasTitle = sal_False;
2053 if( !getTitleFromURL( rSourceURL, aTitle, aType, bDocHasTitle ) )
2054 return sal_False;
2055
2056 INetURLObject aSourceObj( rSourceURL );
2057 if ( rTemplateName.equals( aTitle ) )
2058 {
2059 /////////////////////////////////////////////////////
2060 // addTemplate will sometimes be called just to add an entry in the
2061 // hierarchy; the target URL and the source URL will be the same in
2062 // this scenario
2063 // TODO/LATER: get rid of this old hack
2064
2065 INetURLObject aTargetObj( aTargetURL );
2066
2067 aTargetObj.insertName( rTemplateName, false,
2068 INetURLObject::LAST_SEGMENT, true,
2069 INetURLObject::ENCODE_ALL );
2070 aTargetObj.setExtension( aSourceObj.getExtension() );
2071
2072 aTargetURL2 = aTargetObj.GetMainURL( INetURLObject::NO_DECODE );
2073
2074 if ( aTargetURL2 == rSourceURL )
2075 return addEntry( aGroup, rTemplateName, aTargetURL2, aType );
2076 }
2077
2078 /////////////////////////////////////////////////////
2079 // copy the template into the new group (targeturl)
2080
2081 INetURLObject aTmpURL( aSourceObj );
2082 aTmpURL.CutExtension();
2083 ::rtl::OUString aPattern = aTmpURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
2084
2085 ::rtl::OUString aNewTemplateTargetURL = CreateNewUniqueFileWithPrefix( aTargetURL, aPattern, aSourceObj.getExtension() );
2086 INetURLObject aNewTemplateTargetObj( aNewTemplateTargetURL );
2087 ::rtl::OUString aNewTemplateTargetName = aNewTemplateTargetObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
2088 if ( !aNewTemplateTargetURL.getLength() || !aNewTemplateTargetName.getLength() )
2089 return sal_False;
2090
2091 // get access to source file
2092 Content aSourceContent;
2093 uno::Reference < ucb::XCommandEnvironment > xEnv;
2094 INetURLObject aSourceURL( rSourceURL );
2095 if( ! Content::create( aSourceURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, aSourceContent ) )
2096 return sal_False;
2097
2098 if( ! Content::create( aTargetURL, xEnv, aTargetGroup ) )
2099 return sal_False;
2100
2101 // transfer source file
2102 try
2103 {
2104 if( ! aTargetGroup.transferContent( aSourceContent,
2105 InsertOperation_COPY,
2106 aNewTemplateTargetName,
2107 NameClash::OVERWRITE ) )
2108 return sal_False;
2109
2110 // allow to edit the added template
2111 Content aResultContent;
2112 if ( Content::create( aNewTemplateTargetURL, xEnv, aResultContent ) )
2113 {
2114 ::rtl::OUString aPropertyName( RTL_CONSTASCII_USTRINGPARAM( "IsReadOnly" ) );
2115 uno::Any aProperty;
2116 sal_Bool bReadOnly = sal_False;
2117 if ( getProperty( aResultContent, aPropertyName, aProperty ) && ( aProperty >>= bReadOnly ) && bReadOnly )
2118 setProperty( aResultContent, aPropertyName, uno::makeAny( (sal_Bool)sal_False ) );
2119 }
2120 }
2121 catch ( ContentCreationException& )
2122 { return sal_False; }
2123 catch ( Exception& )
2124 { return sal_False; }
2125
2126
2127 // either the document has title and it is the same as requested, or we have to set it
2128 sal_Bool bCorrectTitle = ( bDocHasTitle && aTitle.equals( rTemplateName ) );
2129 if ( !bCorrectTitle )
2130 {
2131 if ( !bDocHasTitle )
2132 {
2133 INetURLObject aNewTmpObj( aNewTemplateTargetObj );
2134 aNewTmpObj.CutExtension();
2135 bCorrectTitle = ( aNewTmpObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ).equals( rTemplateName ) );
2136 }
2137
2138 if ( !bCorrectTitle )
2139 bCorrectTitle = setTitleForURL( aNewTemplateTargetURL, rTemplateName );
2140 }
2141
2142 if ( bCorrectTitle )
2143 {
2144 // create a new entry in the hierarchy
2145 return addEntry( aGroup, rTemplateName, aNewTemplateTargetURL, aType );
2146 }
2147
2148 // TODO/LATER: The user could be notified here that the renaming has failed
2149 // create a new entry in the hierarchy
2150 addEntry( aGroup, aTitle, aNewTemplateTargetURL, aType );
2151 return sal_False;
2152 }
2153
2154 //-----------------------------------------------------------------------------
2155 sal_Bool SfxDocTplService_Impl::removeTemplate( const OUString& rGroupName,
2156 const OUString& rTemplateName )
2157 {
2158 ::osl::MutexGuard aGuard( maMutex );
2159
2160 // Check, wether or not there is a group with this name
2161 // Return false, if there is no group with the given name
2162 Content aGroup, aTemplate;
2163 OUString aGroupURL, aTemplateURL;
2164 INetURLObject aGroupObj( maRootURL );
2165
2166 aGroupObj.insertName( rGroupName, false,
2167 INetURLObject::LAST_SEGMENT, true,
2168 INetURLObject::ENCODE_ALL );
2169 aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2170
2171 if ( ! Content::create( aGroupURL, maCmdEnv, aGroup ) )
2172 return sal_False;
2173
2174 // Check, if there's a template with the given name in this group
2175 // Return false, if there is no template
2176 aGroupObj.insertName( rTemplateName, false,
2177 INetURLObject::LAST_SEGMENT, true,
2178 INetURLObject::ENCODE_ALL );
2179 aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2180
2181 if ( !Content::create( aTemplateURL, maCmdEnv, aTemplate ) )
2182 return sal_False;
2183
2184 // get the target URL from the template
2185 OUString aTargetURL;
2186 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
2187 Any aValue;
2188
2189 if ( getProperty( aTemplate, aPropName, aValue ) )
2190 aValue >>= aTargetURL;
2191
2192 // delete the target template
2193 if ( aTargetURL.getLength() )
2194 {
2195 if ( !maTemplateDirs.getLength()
2196 || !::utl::UCBContentHelper::IsSubPath( maTemplateDirs[ maTemplateDirs.getLength() - 1 ], aTargetURL ) )
2197 return sal_False;
2198
2199 removeContent( aTargetURL );
2200 }
2201
2202 // delete the template entry
2203 return removeContent( aTemplate );
2204 }
2205
2206 //-----------------------------------------------------------------------------
2207 sal_Bool SfxDocTplService_Impl::renameTemplate( const OUString& rGroupName,
2208 const OUString& rOldName,
2209 const OUString& rNewName )
2210 {
2211 ::osl::MutexGuard aGuard( maMutex );
2212
2213 // Check, wether or not there is a group with this name
2214 // Return false, if there is no group with the given name
2215 Content aGroup, aTemplate;
2216 OUString aGroupURL, aTemplateURL;
2217 INetURLObject aGroupObj( maRootURL );
2218
2219 aGroupObj.insertName( rGroupName, false,
2220 INetURLObject::LAST_SEGMENT, true,
2221 INetURLObject::ENCODE_ALL );
2222 aGroupURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2223
2224 if ( ! Content::create( aGroupURL, maCmdEnv, aGroup ) )
2225 return sal_False;
2226
2227 // Check, if there's a template with the new name in this group
2228 // Return false, if there is one
2229 aGroupObj.insertName( rNewName, false,
2230 INetURLObject::LAST_SEGMENT, true,
2231 INetURLObject::ENCODE_ALL );
2232 aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2233
2234 if ( Content::create( aTemplateURL, maCmdEnv, aTemplate ) )
2235 return sal_False;
2236
2237 // Check, if there's a template with the old name in this group
2238 // Return false, if there is no template
2239 aGroupObj.removeSegment();
2240 aGroupObj.insertName( rOldName, false,
2241 INetURLObject::LAST_SEGMENT, true,
2242 INetURLObject::ENCODE_ALL );
2243 aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2244
2245 if ( !Content::create( aTemplateURL, maCmdEnv, aTemplate ) )
2246 return sal_False;
2247
2248 OUString aTemplateTargetURL;
2249 OUString aTargetProp( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
2250 Any aTargetValue;
2251
2252 if ( getProperty( aTemplate, aTargetProp, aTargetValue ) )
2253 aTargetValue >>= aTemplateTargetURL;
2254
2255 if ( !setTitleForURL( aTemplateTargetURL, rNewName ) )
2256 return sal_False;
2257
2258 // rename the template entry in the cache
2259 OUString aTitleProp( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
2260 Any aTitleValue;
2261 aTitleValue <<= rNewName;
2262
2263 return setProperty( aTemplate, aTitleProp, aTitleValue );
2264 }
2265
2266 //-----------------------------------------------------------------------------
2267 //-----------------------------------------------------------------------------
2268 //-----------------------------------------------------------------------------
2269
2270 SFX_IMPL_XSERVICEINFO( SfxDocTplService, TEMPLATE_SERVICE_NAME, TEMPLATE_IMPLEMENTATION_NAME )
2271 SFX_IMPL_SINGLEFACTORY( SfxDocTplService )
2272
2273 //-----------------------------------------------------------------------------
2274 SfxDocTplService::SfxDocTplService( const uno::Reference< XMultiServiceFactory >& xFactory )
2275 {
2276 pImp = new SfxDocTplService_Impl( xFactory );
2277 }
2278
2279 //-----------------------------------------------------------------------------
2280
2281 SfxDocTplService::~SfxDocTplService()
2282 {
2283 delete pImp;
2284 }
2285
2286 //-----------------------------------------------------------------------------
2287 //--- XLocalizable ---
2288 //-----------------------------------------------------------------------------
2289
2290 Locale SAL_CALL SfxDocTplService::getLocale()
2291 throw( RUNTIMEEXCEPTION )
2292 {
2293 return pImp->getLocale();
2294 }
2295
2296 //-----------------------------------------------------------------------------
2297
2298 void SAL_CALL SfxDocTplService::setLocale( const Locale & rLocale )
2299 throw( RUNTIMEEXCEPTION )
2300 {
2301 pImp->setLocale( rLocale );
2302 }
2303
2304 //-----------------------------------------------------------------------------
2305 //--- XDocumentTemplates ---
2306 //-----------------------------------------------------------------------------
2307 uno::Reference< XCONTENT > SAL_CALL SfxDocTplService::getContent()
2308 throw( RUNTIMEEXCEPTION )
2309 {
2310 if ( pImp->init() )
2311 return pImp->getContent().get();
2312 else
2313 return NULL;
2314 }
2315
2316 //-----------------------------------------------------------------------------
2317 sal_Bool SAL_CALL SfxDocTplService::storeTemplate( const OUString& GroupName,
2318 const OUString& TemplateName,
2319 const uno::Reference< XSTORABLE >& Storable )
2320 throw( RUNTIMEEXCEPTION )
2321 {
2322 if ( pImp->init() )
2323 return pImp->storeTemplate( GroupName, TemplateName, Storable );
2324 else
2325 return sal_False;
2326 }
2327
2328 //-----------------------------------------------------------------------------
2329 sal_Bool SAL_CALL SfxDocTplService::addTemplate( const OUString& rGroupName,
2330 const OUString& rTemplateName,
2331 const OUString& rSourceURL )
2332 throw( RUNTIMEEXCEPTION )
2333 {
2334 if ( pImp->init() )
2335 return pImp->addTemplate( rGroupName, rTemplateName, rSourceURL );
2336 else
2337 return sal_False;
2338 }
2339
2340 //-----------------------------------------------------------------------------
2341 sal_Bool SAL_CALL SfxDocTplService::removeTemplate( const OUString& rGroupName,
2342 const OUString& rTemplateName )
2343 throw( RUNTIMEEXCEPTION )
2344 {
2345 if ( pImp->init() )
2346 return pImp->removeTemplate( rGroupName, rTemplateName );
2347 else
2348 return sal_False;
2349 }
2350
2351 //-----------------------------------------------------------------------------
2352 sal_Bool SAL_CALL SfxDocTplService::renameTemplate( const OUString& rGroupName,
2353 const OUString& rOldName,
2354 const OUString& rNewName )
2355 throw( RUNTIMEEXCEPTION )
2356 {
2357 if ( rOldName == rNewName )
2358 return sal_True;
2359
2360 if ( pImp->init() )
2361 return pImp->renameTemplate( rGroupName, rOldName, rNewName );
2362 else
2363 return sal_False;
2364 }
2365
2366 //-----------------------------------------------------------------------------
2367 sal_Bool SAL_CALL SfxDocTplService::addGroup( const OUString& rGroupName )
2368 throw( RUNTIMEEXCEPTION )
2369 {
2370 if ( pImp->init() )
2371 return pImp->addGroup( rGroupName );
2372 else
2373 return sal_False;
2374 }
2375
2376 //-----------------------------------------------------------------------------
2377 sal_Bool SAL_CALL SfxDocTplService::removeGroup( const OUString& rGroupName )
2378 throw( RUNTIMEEXCEPTION )
2379 {
2380 if ( pImp->init() )
2381 return pImp->removeGroup( rGroupName );
2382 else
2383 return sal_False;
2384 }
2385
2386 //-----------------------------------------------------------------------------
2387 sal_Bool SAL_CALL SfxDocTplService::renameGroup( const OUString& rOldName,
2388 const OUString& rNewName )
2389 throw( RUNTIMEEXCEPTION )
2390 {
2391 if ( rOldName == rNewName )
2392 return sal_True;
2393
2394 if ( pImp->init() )
2395 return pImp->renameGroup( rOldName, rNewName );
2396 else
2397 return sal_False;
2398 }
2399
2400 //-----------------------------------------------------------------------------
2401 void SAL_CALL SfxDocTplService::update()
2402 throw( RUNTIMEEXCEPTION )
2403 {
2404 if ( pImp->init() )
2405 pImp->update( sal_True );
2406 }
2407
2408 //-----------------------------------------------------------------------------
2409 //-----------------------------------------------------------------------------
2410 //------------------------------------------------------------------------
2411
2412 Updater_Impl::Updater_Impl( SfxDocTplService_Impl* pTemplates )
2413 {
2414 mpDocTemplates = pTemplates;
2415 }
2416
2417 //------------------------------------------------------------------------
2418 Updater_Impl::~Updater_Impl()
2419 {
2420 }
2421
2422 //------------------------------------------------------------------------
2423 void SAL_CALL Updater_Impl::run()
2424 {
2425 mpDocTemplates->doUpdate();
2426 }
2427
2428 //------------------------------------------------------------------------
2429 void SAL_CALL Updater_Impl::onTerminated()
2430 {
2431 mpDocTemplates->finished();
2432 delete this;
2433 }
2434
2435 //-----------------------------------------------------------------------------
2436 //-----------------------------------------------------------------------------
2437 //-----------------------------------------------------------------------------
2438 WaitWindow_Impl::WaitWindow_Impl()
2439 : WorkWindow( NULL, WB_BORDER | WB_3DLOOK )
2440 {
2441 Rectangle aRect = Rectangle( 0, 0, 300, 30000 );
2442 _nTextStyle = TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER | TEXT_DRAW_WORDBREAK | TEXT_DRAW_MULTILINE;
2443 _aText = String( SfxResId( RID_CNT_STR_WAITING ) );
2444 _aRect = GetTextRect( aRect, _aText, _nTextStyle );
2445 aRect = _aRect;
2446 aRect.Right() += 2*X_OFFSET;
2447 aRect.Bottom() += 2*Y_OFFSET;
2448 _aRect.SetPos( Point( X_OFFSET, Y_OFFSET ) );
2449 SetOutputSizePixel( aRect.GetSize() );
2450 Show();
2451 Update();
2452 Flush();
2453 }
2454
2455 //-----------------------------------------------------------------------------
2456 WaitWindow_Impl::~WaitWindow_Impl()
2457 {
2458 Hide();
2459 }
2460
2461 //-----------------------------------------------------------------------------
2462 void WaitWindow_Impl::Paint( const Rectangle& /*rRect*/ )
2463 {
2464 DrawText( _aRect, _aText, _nTextStyle );
2465 }
2466
2467 //-----------------------------------------------------------------------------
2468 //-----------------------------------------------------------------------------
2469 //-----------------------------------------------------------------------------
2470 void SfxDocTplService_Impl::addHierGroup( GroupList_Impl& rList,
2471 const OUString& rTitle,
2472 const OUString& rOwnURL )
2473 {
2474 // now get the content of the Group
2475 Content aContent;
2476 uno::Reference< XResultSet > xResultSet;
2477 Sequence< OUString > aProps(3);
2478
2479 aProps[0] = OUString::createFromAscii( TITLE );
2480 aProps[1] = OUString::createFromAscii( TARGET_URL );
2481 aProps[2] = OUString::createFromAscii( PROPERTY_TYPE );
2482
2483 try
2484 {
2485 aContent = Content( rOwnURL, maCmdEnv );
2486 ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
2487 xResultSet = aContent.createCursor( aProps, eInclude );
2488 }
2489 catch ( ContentCreationException& )
2490 {
2491 DBG_ERRORFILE( "addHierGroup: ContentCreationException" );
2492 }
2493 catch ( Exception& ) {}
2494
2495 if ( xResultSet.is() )
2496 {
2497 GroupData_Impl *pGroup = new GroupData_Impl( rTitle );
2498 pGroup->setHierarchy( sal_True );
2499 pGroup->setHierarchyURL( rOwnURL );
2500 rList.Insert( pGroup );
2501
2502 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2503 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2504
2505 try
2506 {
2507 while ( xResultSet->next() )
2508 {
2509 BOOL bUpdateType = sal_False;
2510 DocTemplates_EntryData_Impl *pData;
2511
2512 OUString aTitle( xRow->getString( 1 ) );
2513 OUString aTargetDir( xRow->getString( 2 ) );
2514 OUString aType( xRow->getString( 3 ) );
2515 OUString aHierURL = xContentAccess->queryContentIdentifierString();
2516
2517 if ( !aType.getLength() )
2518 {
2519 OUString aTmpTitle;
2520
2521 sal_Bool bDocHasTitle = sal_False;
2522 if( !getTitleFromURL( aTargetDir, aTmpTitle, aType, bDocHasTitle ) )
2523 {
2524 DBG_ERRORFILE( "addHierGroup(): template of alien format" );
2525 continue;
2526 }
2527
2528 if ( aType.getLength() )
2529 bUpdateType = sal_True;
2530 }
2531
2532 pData = pGroup->addEntry( aTitle, aTargetDir, aType, aHierURL );
2533 pData->setUpdateType( bUpdateType );
2534 }
2535 }
2536 catch ( Exception& ) {}
2537 }
2538 }
2539
2540 //-----------------------------------------------------------------------------
2541 void SfxDocTplService_Impl::addFsysGroup( GroupList_Impl& rList,
2542 const OUString& rTitle,
2543 const OUString& rUITitle,
2544 const OUString& rOwnURL,
2545 sal_Bool bWriteableGroup )
2546 {
2547 ::rtl::OUString aTitle;
2548
2549 if ( !rUITitle.getLength() )
2550 {
2551 // reserved FS names that should not be used
2552 if ( rTitle.compareToAscii( "wizard" ) == 0 )
2553 return;
2554 else if ( rTitle.compareToAscii( "internal" ) == 0 )
2555 return;
2556
2557 aTitle = getLongName( rTitle );
2558 }
2559 else
2560 aTitle = rUITitle;
2561
2562 if ( !aTitle.getLength() )
2563 return;
2564
2565 GroupData_Impl *pGroup = rList.First();
2566
2567 while ( pGroup && pGroup->getTitle() != aTitle )
2568 pGroup = rList.Next();
2569
2570 if ( !pGroup )
2571 {
2572 pGroup = new GroupData_Impl( aTitle );
2573 rList.Insert( pGroup );
2574 }
2575
2576 if ( bWriteableGroup )
2577 pGroup->setTargetURL( rOwnURL );
2578
2579 pGroup->setInUse();
2580
2581 // now get the content of the Group
2582 Content aContent;
2583 uno::Reference< XResultSet > xResultSet;
2584 Sequence< OUString > aProps(1);
2585 aProps[0] = OUString::createFromAscii( TITLE );
2586
2587 try
2588 {
2589 // this method is only used during checking of the available template-folders
2590 // that should happen quietly
2591 uno::Reference< XCommandEnvironment > aQuietEnv;
2592 aContent = Content( rOwnURL, aQuietEnv );
2593 ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
2594 xResultSet = aContent.createCursor( aProps, eInclude );
2595 }
2596 catch ( Exception& ) {}
2597
2598 if ( xResultSet.is() )
2599 {
2600 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2601 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2602
2603 try
2604 {
2605 while ( xResultSet->next() )
2606 {
2607 OUString aChildTitle( xRow->getString( 1 ) );
2608 OUString aTargetURL = xContentAccess->queryContentIdentifierString();
2609 OUString aType;
2610 OUString aHierURL;
2611
2612 if ( aChildTitle.compareToAscii( "sfx.tlx" ) == 0
2613 || aChildTitle.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "groupuinames.xml" ) ) )
2614 continue;
2615
2616 // only StarOffice templates are accepted
2617 sal_Bool bDocHasTitle = sal_False;
2618 if( !getTitleFromURL( aTargetURL, aChildTitle, aType, bDocHasTitle ) )
2619 continue;
2620
2621 pGroup->addEntry( aChildTitle, aTargetURL, aType, aHierURL );
2622 }
2623 }
2624 catch ( Exception& ) {}
2625 }
2626 }
2627
2628 // -----------------------------------------------------------------------
2629 void SfxDocTplService_Impl::createFromContent( GroupList_Impl& rList,
2630 Content &rContent,
2631 sal_Bool bHierarchy,
2632 sal_Bool bWriteableContent )
2633 {
2634 OUString aTargetURL = rContent.get()->getIdentifier()->getContentIdentifier();
2635
2636 // when scanning the file system, we have to add the 'standard' group, too
2637 if ( ! bHierarchy )
2638 {
2639 OUString aUIStdTitle = getLongName( OUString( RTL_CONSTASCII_USTRINGPARAM( STANDARD_FOLDER ) ) );
2640 addFsysGroup( rList, ::rtl::OUString(), aUIStdTitle, aTargetURL, bWriteableContent );
2641 }
2642
2643 // search for predefined UI names
2644 INetURLObject aLayerObj( aTargetURL );
2645
2646 // TODO/LATER: Use hashmap in future
2647 uno::Sequence< beans::StringPair > aUINames;
2648 if ( !bHierarchy )
2649 aUINames = ReadUINamesForTemplateDir_Impl( aLayerObj.GetMainURL( INetURLObject::NO_DECODE ) );
2650
2651 uno::Reference< XResultSet > xResultSet;
2652 Sequence< OUString > aProps(1);
2653 aProps[0] = OUString::createFromAscii( TITLE );
2654
2655 try
2656 {
2657 ResultSetInclude eInclude = INCLUDE_FOLDERS_ONLY;
2658 xResultSet = rContent.createCursor( aProps, eInclude );
2659 }
2660 catch ( Exception& ) {}
2661
2662 if ( xResultSet.is() )
2663 {
2664 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2665 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2666
2667 try
2668 {
2669 while ( xResultSet->next() )
2670 {
2671 // TODO/LATER: clarify the encoding of the Title
2672 OUString aTitle( xRow->getString( 1 ) );
2673 OUString aTargetSubfolderURL( xContentAccess->queryContentIdentifierString() );
2674
2675 if ( bHierarchy )
2676 addHierGroup( rList, aTitle, aTargetSubfolderURL );
2677 else
2678 {
2679 ::rtl::OUString aUITitle;
2680 for ( sal_Int32 nInd = 0; nInd < aUINames.getLength(); nInd++ )
2681 if ( aUINames[nInd].First.equals( aTitle ) )
2682 {
2683 aUITitle = aUINames[nInd].Second;
2684 break;
2685 }
2686
2687 addFsysGroup( rList, aTitle, aUITitle, aTargetSubfolderURL, bWriteableContent );
2688 }
2689 }
2690 }
2691 catch ( Exception& ) {}
2692 }
2693 }
2694
2695 //-----------------------------------------------------------------------------
2696 void SfxDocTplService_Impl::removeFromHierarchy( DocTemplates_EntryData_Impl *pData )
2697 {
2698 Content aTemplate;
2699
2700 if ( Content::create( pData->getHierarchyURL(), maCmdEnv, aTemplate ) )
2701 {
2702 removeContent( aTemplate );
2703 }
2704 }
2705
2706 //-----------------------------------------------------------------------------
2707 void SfxDocTplService_Impl::addToHierarchy( GroupData_Impl *pGroup,
2708 DocTemplates_EntryData_Impl *pData )
2709 {
2710 Content aGroup, aTemplate;
2711
2712 if ( ! Content::create( pGroup->getHierarchyURL(), maCmdEnv, aGroup ) )
2713 return;
2714
2715 // Check, if there's a template with the given name in this group
2716 // Return if there is already a template
2717 INetURLObject aGroupObj( pGroup->getHierarchyURL() );
2718
2719 aGroupObj.insertName( pData->getTitle(), false,
2720 INetURLObject::LAST_SEGMENT, true,
2721 INetURLObject::ENCODE_ALL );
2722
2723 OUString aTemplateURL = aGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2724
2725 if ( Content::create( aTemplateURL, maCmdEnv, aTemplate ) )
2726 return;
2727
2728 addEntry( aGroup, pData->getTitle(),
2729 pData->getTargetURL(),
2730 pData->getType() );
2731 }
2732
2733 //-----------------------------------------------------------------------------
2734 void SfxDocTplService_Impl::updateData( DocTemplates_EntryData_Impl *pData )
2735 {
2736 Content aTemplate;
2737
2738 if ( ! Content::create( pData->getHierarchyURL(), maCmdEnv, aTemplate ) )
2739 return;
2740
2741 OUString aPropName;
2742
2743 if ( pData->getUpdateType() )
2744 {
2745 aPropName = OUString( RTL_CONSTASCII_USTRINGPARAM( PROPERTY_TYPE ) );
2746 setProperty( aTemplate, aPropName, makeAny( pData->getType() ) );
2747 }
2748
2749 if ( pData->getUpdateLink() )
2750 {
2751 aPropName = OUString( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
2752 setProperty( aTemplate, aPropName, makeAny( pData->getTargetURL() ) );
2753 }
2754 }
2755
2756 //-----------------------------------------------------------------------------
2757 void SfxDocTplService_Impl::addGroupToHierarchy( GroupData_Impl *pGroup )
2758 {
2759 OUString aAdditionalProp( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
2760 Content aGroup;
2761
2762 INetURLObject aNewGroupObj( maRootURL );
2763 aNewGroupObj.insertName( pGroup->getTitle(), false,
2764 INetURLObject::LAST_SEGMENT, true,
2765 INetURLObject::ENCODE_ALL );
2766
2767 OUString aNewGroupURL = aNewGroupObj.GetMainURL( INetURLObject::NO_DECODE );
2768
2769 if ( createFolder( aNewGroupURL, sal_False, sal_False, aGroup ) )
2770 {
2771 setProperty( aGroup, aAdditionalProp, makeAny( pGroup->getTargetURL() ) );
2772 pGroup->setHierarchyURL( aNewGroupURL );
2773
2774 ULONG nCount = pGroup->count();
2775 for ( ULONG i=0; i<nCount; i++ )
2776 {
2777 DocTemplates_EntryData_Impl *pData = pGroup->getEntry( i );
2778 addToHierarchy( pGroup, pData ); // add entry to hierarchy
2779 }
2780 }
2781 }
2782
2783 //-----------------------------------------------------------------------------
2784 void SfxDocTplService_Impl::removeFromHierarchy( GroupData_Impl *pGroup )
2785 {
2786 Content aGroup;
2787
2788 if ( Content::create( pGroup->getHierarchyURL(), maCmdEnv, aGroup ) )
2789 {
2790 removeContent( aGroup );
2791 }
2792 }
2793
2794 // -----------------------------------------------------------------------
2795 // -----------------------------------------------------------------------
2796 // -----------------------------------------------------------------------
2797 GroupData_Impl::GroupData_Impl( const OUString& rTitle )
2798 {
2799 maTitle = rTitle;
2800 mbInUse = sal_False;
2801 mbInHierarchy = sal_False;
2802 }
2803
2804 // -----------------------------------------------------------------------
2805 GroupData_Impl::~GroupData_Impl()
2806 {
2807 DocTemplates_EntryData_Impl *pData = maEntries.First();
2808 while ( pData )
2809 {
2810 delete pData;
2811 pData = maEntries.Next();
2812 }
2813 }
2814
2815 // -----------------------------------------------------------------------
2816 DocTemplates_EntryData_Impl* GroupData_Impl::addEntry( const OUString& rTitle,
2817 const OUString& rTargetURL,
2818 const OUString& rType,
2819 const OUString& rHierURL )
2820 {
2821 DocTemplates_EntryData_Impl *pData = maEntries.First();
2822
2823 while ( pData && pData->getTitle() != rTitle )
2824 pData = maEntries.Next();
2825
2826 if ( !pData )
2827 {
2828 pData = new DocTemplates_EntryData_Impl( rTitle );
2829 pData->setTargetURL( rTargetURL );
2830 pData->setType( rType );
2831 if ( rHierURL.getLength() )
2832 {
2833 pData->setHierarchyURL( rHierURL );
2834 pData->setHierarchy( sal_True );
2835 }
2836 maEntries.Insert( pData );
2837 }
2838 else
2839 {
2840 if ( rHierURL.getLength() )
2841 {
2842 pData->setHierarchyURL( rHierURL );
2843 pData->setHierarchy( sal_True );
2844 }
2845
2846 if ( pData->getInHierarchy() )
2847 pData->setInUse();
2848
2849 if ( rTargetURL != pData->getTargetURL() )
2850 {
2851 pData->setTargetURL( rTargetURL );
2852 pData->setUpdateLink( sal_True );
2853 }
2854 }
2855
2856 return pData;
2857 }
2858
2859 // -----------------------------------------------------------------------
2860 // -----------------------------------------------------------------------
2861 // -----------------------------------------------------------------------
2862 DocTemplates_EntryData_Impl::DocTemplates_EntryData_Impl( const OUString& rTitle )
2863 {
2864 maTitle = rTitle;
2865 mbInUse = sal_False;
2866 mbInHierarchy = sal_False;
2867 mbUpdateType = sal_False;
2868 mbUpdateLink = sal_False;
2869 }
2870
2871 // -----------------------------------------------------------------------
2872 SfxURLRelocator_Impl::SfxURLRelocator_Impl( uno::Reference< XMultiServiceFactory > xFactory )
2873 : mxFactory( xFactory )
2874 {
2875 }
2876
2877 // -----------------------------------------------------------------------
2878 SfxURLRelocator_Impl::~SfxURLRelocator_Impl()
2879 {
2880 }
2881
2882 // -----------------------------------------------------------------------
2883 void SfxURLRelocator_Impl::initOfficeInstDirs()
2884 {
2885 if ( !mxOfficeInstDirs.is() )
2886 {
2887 osl::MutexGuard aGuard( maMutex );
2888 if ( !mxOfficeInstDirs.is() )
2889 {
2890 OSL_ENSURE( mxFactory.is(), "No service manager!" );
2891
2892 uno::Reference< XComponentContext > xCtx;
2893 uno::Reference< XPropertySet > xPropSet( mxFactory, UNO_QUERY );
2894 if ( xPropSet.is() )
2895 {
2896 xPropSet->getPropertyValue(
2897 rtl::OUString(
2898 RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ) ) )
2899 >>= xCtx;
2900 }
2901
2902 OSL_ENSURE( xCtx.is(),
2903 "Unable to obtain component context from "
2904 "service manager!" );
2905
2906 if ( xCtx.is() )
2907 {
2908 xCtx->getValueByName(
2909 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
2910 "/singletons/"
2911 "com.sun.star.util.theOfficeInstallationDirectories" ) ) )
2912 >>= mxOfficeInstDirs;
2913 }
2914
2915 OSL_ENSURE( mxOfficeInstDirs.is(),
2916 "Unable to obtain office installation directory "
2917 "singleton!" );
2918 }
2919 }
2920 }
2921
2922 // -----------------------------------------------------------------------
2923 void SfxURLRelocator_Impl::makeRelocatableURL( rtl::OUString & rURL )
2924 {
2925 if ( rURL.getLength() > 0 )
2926 {
2927 initOfficeInstDirs();
2928 rURL = mxOfficeInstDirs->makeRelocatableURL( rURL );
2929 }
2930 }
2931
2932 // -----------------------------------------------------------------------
2933 void SfxURLRelocator_Impl::makeAbsoluteURL( rtl::OUString & rURL )
2934 {
2935 if ( rURL.getLength() > 0 )
2936 {
2937 initOfficeInstDirs();
2938 rURL = mxOfficeInstDirs->makeAbsoluteURL( rURL );
2939 }
2940 }
2941
2942
vba interoperability for OOo