xref: /aoo42x/main/sfx2/source/doc/doctempl.cxx (revision 940681c7)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sfx2.hxx"
26 
27 #include <limits.h>
28 #include <com/sun/star/uno/Any.h>
29 #include <vos/mutex.hxx>
30 #include <vos/thread.hxx>
31 
32 #ifndef _SV_RESARY_HXX
33 #include <tools/resary.hxx>
34 #endif
35 #include <vcl/svapp.hxx>
36 #include <vcl/settings.hxx>
37 #include <unotools/localedatawrapper.hxx>
38 #include <unotools/pathoptions.hxx>
39 #include <tools/string.hxx>
40 #include <tools/urlobj.hxx>
41 #include <svtools/ehdl.hxx>
42 #include <svtools/sfxecode.hxx>
43 #include <comphelper/processfactory.hxx>
44 #include <ucbhelper/content.hxx>
45 #include <com/sun/star/beans/PropertyAttribute.hpp>
46 #include <com/sun/star/beans/PropertyValue.hpp>
47 #include <com/sun/star/beans/XPropertyContainer.hpp>
48 #include <com/sun/star/beans/XPropertySet.hpp>
49 #include <com/sun/star/beans/XPropertySetInfo.hpp>
50 #include <com/sun/star/document/XTypeDetection.hpp>
51 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
52 #include <com/sun/star/frame/XComponentLoader.hpp>
53 #include <com/sun/star/frame/XDocumentTemplates.hpp>
54 #include <com/sun/star/io/XInputStream.hpp>
55 #include <com/sun/star/io/XPersist.hpp>
56 #include <com/sun/star/lang/XLocalizable.hpp>
57 #include <com/sun/star/sdbc/XResultSet.hpp>
58 #include <com/sun/star/sdbc/XRow.hpp>
59 #include <com/sun/star/ucb/ContentInfo.hpp>
60 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
61 #include <com/sun/star/ucb/NameClash.hpp>
62 #include <com/sun/star/ucb/TransferInfo.hpp>
63 #include <com/sun/star/ucb/XCommandProcessor.hpp>
64 #include <com/sun/star/ucb/XContent.hpp>
65 #include <com/sun/star/ucb/XContentAccess.hpp>
66 #include <com/sun/star/ucb/XAnyCompareFactory.hpp>
67 #include <com/sun/star/ucb/XAnyCompare.hpp>
68 #include <com/sun/star/ucb/NumberedSortingInfo.hpp>
69 #include <com/sun/star/embed/ElementModes.hpp>
70 #include <com/sun/star/embed/XTransactedObject.hpp>
71 
72 #include "sfxurlrelocator.hxx"
73 
74 using namespace ::com::sun::star;
75 using namespace ::com::sun::star::beans;
76 using namespace ::com::sun::star::frame;
77 using namespace ::com::sun::star::io;
78 using namespace ::com::sun::star::lang;
79 using namespace ::com::sun::star::sdbc;
80 using namespace ::com::sun::star::uno;
81 using namespace ::com::sun::star::ucb;
82 using namespace ::com::sun::star::document;
83 using namespace ::rtl;
84 using namespace ::ucbhelper;
85 
86 
87 #include <sfx2/doctempl.hxx>
88 #include <sfx2/docfac.hxx>
89 #include <sfx2/docfile.hxx>
90 #include <sfx2/objsh.hxx>
91 #include "sfxtypes.hxx"
92 #include <sfx2/app.hxx>
93 #include "sfx2/sfxresid.hxx"
94 #include "doc.hrc"
95 #include <sfx2/fcontnr.hxx>
96 #include <svtools/templatefoldercache.hxx>
97 
98 #include <comphelper/storagehelper.hxx>
99 #include <unotools/ucbhelper.hxx>
100 
101 //========================================================================
102 
103 // #define DONT_USE_HIERARCHY
104 
105 #define TITLE                   "Title"
106 #define IS_FOLDER               "IsFolder"
107 #define PROPERTY_TYPE           "TypeDescription"
108 #define TARGET_URL              "TargetURL"
109 #define TYPE_FOLDER             "application/vnd.sun.star.hier-folder"
110 #define TYPE_LINK               "application/vnd.sun.star.hier-link"
111 #define TYPE_FSYS_FOLDER        "application/vnd.sun.staroffice.fsys-folder"
112 
113 #define TARGET_DIR_URL          "TargetDirURL"
114 #define COMMAND_DELETE          "delete"
115 #define COMMAND_TRANSFER        "transfer"
116 
117 #define STANDARD_FOLDER         "standard"
118 
119 #define SERVICENAME_TYPEDETECTION       "com.sun.star.document.TypeDetection"
120 #define TYPEDETECTION_PARAMETER         "FileName"
121 //#define SERVICENAME_OLD_TYPEDETECTION   "com.sun.star.frame.FrameLoaderFactory"
122 //#define PARAMETER_OLD_TYPEDETECTION     "DeepDetection"
123 #define SERVICENAME_DOCINFO             "com.sun.star.document.DocumentProperties"
124 #define SERVICENAME_DOCTEMPLATES        "com.sun.star.frame.DocumentTemplates"
125 #define SERVICENAME_DESKTOP             "com.sun.star.frame.Desktop"
126 
127 //========================================================================
128 
129 class RegionData_Impl;
130 
131 namespace DocTempl {
132 
133 class DocTempl_EntryData_Impl
134 {
135     RegionData_Impl*    mpParent;
136 
137     // the following member must be SfxObjectShellLock since it controls that SfxObjectShell lifetime by design
138     // and users of this class expect it to be so.
139     SfxObjectShellLock  mxObjShell;
140 
141     OUString            maTitle;
142     OUString            maOwnURL;
143     OUString            maTargetURL;
144     sal_Bool            mbIsOwner   : 1;
145     sal_Bool            mbDidConvert: 1;
146 
147 private:
GetParent() const148     RegionData_Impl*    GetParent() const { return mpParent; }
149 
150 public:
151                         DocTempl_EntryData_Impl( RegionData_Impl* pParent,
152                                         const OUString& rTitle );
153 
GetTitle() const154     const OUString&     GetTitle() const { return maTitle; }
155     const OUString&     GetTargetURL();
156     const OUString&     GetHierarchyURL();
157 
SetTitle(const OUString & rTitle)158     void                SetTitle( const OUString& rTitle ) { maTitle = rTitle; }
SetTargetURL(const OUString & rURL)159     void                SetTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
SetHierarchyURL(const OUString & rURL)160     void                SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; }
161 
162     int                 Compare( const OUString& rTitle ) const;
163 
164     SfxObjectShellRef   CreateObjectShell();
165     sal_Bool                DeleteObjectShell();
166 };
167 
168 }
169 
170 using namespace ::DocTempl;
171 
172 // ------------------------------------------------------------------------
173 
174 class RegionData_Impl
175 {
176     DECLARE_LIST( EntryList_Impl, DocTempl_EntryData_Impl* )
177     const SfxDocTemplate_Impl*  mpParent;
178     EntryList_Impl              maEntries;
179     OUString                    maTitle;
180     OUString                    maOwnURL;
181     OUString                    maTargetURL;
182 
183 private:
184     long                        GetEntryPos( const OUString& rTitle,
185                                              sal_Bool& rFound ) const;
GetParent() const186     const SfxDocTemplate_Impl*  GetParent() const { return mpParent; }
187 
188 public:
189                         RegionData_Impl( const SfxDocTemplate_Impl* pParent,
190                                          const OUString& rTitle );
191                         ~RegionData_Impl();
192 
SetTargetURL(const OUString & rURL)193     void                SetTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
SetHierarchyURL(const OUString & rURL)194     void                SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; }
195 
196     DocTempl_EntryData_Impl*     GetEntry( sal_uIntPtr nIndex ) const;
197     DocTempl_EntryData_Impl*     GetEntry( const OUString& rName ) const;
198     DocTempl_EntryData_Impl*     GetByTargetURL( const OUString& rName ) const;
199 
GetTitle() const200     const OUString&     GetTitle() const { return maTitle; }
201     const OUString&     GetTargetURL();
202     const OUString&     GetHierarchyURL();
203 
204     sal_uIntPtr               GetCount() const;
205 
SetTitle(const OUString & rTitle)206     void                SetTitle( const OUString& rTitle ) { maTitle = rTitle; }
207 
208     void                AddEntry( const OUString& rTitle,
209                                   const OUString& rTargetURL,
210                                   sal_uInt16 *pPos = NULL );
211     void                DeleteEntry( sal_uIntPtr nIndex );
212 
Compare(const OUString & rTitle) const213     int                 Compare( const OUString& rTitle ) const
214                             { return maTitle.compareTo( rTitle ); }
215     int                 Compare( RegionData_Impl* pCompareWith ) const;
216 };
217 
218 DECLARE_LIST( RegionList_Impl, RegionData_Impl* )
219 
220 // ------------------------------------------------------------------------
221 
222 class SfxDocTemplate_Impl : public SvRefBase
223 {
224     uno::Reference< XPersist >               mxInfo;
225     uno::Reference< XDocumentTemplates >     mxTemplates;
226 
227     ::osl::Mutex        maMutex;
228     OUString            maRootURL;
229     OUString            maStandardGroup;
230     RegionList_Impl     maRegions;
231     sal_Bool            mbConstructed;
232 
233     uno::Reference< XAnyCompareFactory > m_rCompareFactory;
234 
235     // the following member is intended to prevent clearing of the global data when it is in use
236     // TODO/LATER: it still does not make the implementation complete thread-safe
237     sal_Int32           mnLockCounter;
238 
239 private:
240     void                Clear();
241 
242 public:
243                         SfxDocTemplate_Impl();
244                         ~SfxDocTemplate_Impl();
245 
246     void                IncrementLock();
247     void                DecrementLock();
248 
249     sal_Bool            Construct( );
250     void                CreateFromHierarchy( Content &rTemplRoot );
251     void                ReInitFromComponent();
252     void                AddRegion( const OUString& rTitle,
253                                    Content& rContent );
254 
255     void                Rescan();
256 
257     void                DeleteRegion( sal_uIntPtr nIndex );
258 
GetRegionCount() const259     sal_uIntPtr               GetRegionCount() const
260                             { return maRegions.Count(); }
261     RegionData_Impl*    GetRegion( const OUString& rName ) const;
262     RegionData_Impl*    GetRegion( sal_uIntPtr nIndex ) const;
263     void                GetTemplates( Content& rTargetFolder,
264                                       Content& rParentFolder,
265                                       RegionData_Impl* pRegion );
266 
267     long                GetRegionPos( const OUString& rTitle,
268                                       sal_Bool& rFound ) const;
269 
270     sal_Bool            GetTitleFromURL( const OUString& rURL, OUString& aTitle );
271     sal_Bool            InsertRegion( RegionData_Impl *pData, sal_uIntPtr nPos = LIST_APPEND );
GetRootURL() const272     OUString            GetRootURL() const { return maRootURL; }
273 
getDocTemplates()274     uno::Reference< XDocumentTemplates >     getDocTemplates() { return mxTemplates; }
275 };
276 
277 // ------------------------------------------------------------------------
278 
279 class DocTemplLocker_Impl
280 {
281     SfxDocTemplate_Impl& m_aDocTempl;
282 public:
DocTemplLocker_Impl(SfxDocTemplate_Impl & aDocTempl)283     DocTemplLocker_Impl( SfxDocTemplate_Impl& aDocTempl )
284     : m_aDocTempl( aDocTempl )
285     {
286         m_aDocTempl.IncrementLock();
287     }
288 
~DocTemplLocker_Impl()289     ~DocTemplLocker_Impl()
290     {
291         m_aDocTempl.DecrementLock();
292     }
293 };
294 
295 // ------------------------------------------------------------------------
296 
297 #ifndef SFX_DECL_DOCTEMPLATES_DEFINED
298 #define SFX_DECL_DOCTEMPLATES_DEFINED
299 SV_DECL_REF(SfxDocTemplate_Impl)
300 #endif
301 
302 SV_IMPL_REF(SfxDocTemplate_Impl)
303 
304 // ------------------------------------------------------------------------
305 
306 SfxDocTemplate_Impl *gpTemplateData = 0;
307 
308 // -----------------------------------------------------------------------
309 
310 static sal_Bool getTextProperty_Impl( Content& rContent,
311                                       const OUString& rPropName,
312                                       OUString& rPropValue );
313 
314 //========================================================================
315 //========================================================================
316 //========================================================================
317 
GetFullRegionName(sal_uInt16 nIdx) const318 String SfxDocumentTemplates::GetFullRegionName
319 (
320     sal_uInt16 nIdx                     // Index des Bereiches
321 )   const
322 
323 /*  [Beschreibung]
324 
325     Liefert den logischen Namen eines Bereiches Plus seinem  Pfad
326 
327 
328     [R"uckgabewert]                 Referenz auf diesen Namen
329 
330 */
331 
332 {
333     // First: find the RegionData for the index
334     String aName;
335 
336     DocTemplLocker_Impl aLocker( *pImp );
337 
338     if ( pImp->Construct() )
339     {
340         RegionData_Impl *pData1 = pImp->GetRegion( nIdx );
341 
342         if ( pData1 )
343             aName = pData1->GetTitle();
344 
345         // --**-- here was some code which appended the path to the
346         //      group if there was more than one with the same name.
347         //      this should not happen anymore
348     }
349 
350     return aName;
351 }
352 
353 //------------------------------------------------------------------------
354 
GetRegionName(sal_uInt16 nIdx) const355 const String& SfxDocumentTemplates::GetRegionName
356 (
357     sal_uInt16 nIdx                 // Index des Bereiches
358 )   const
359 
360 /*  [Beschreibung]
361 
362     Liefert den logischen Namen eines Bereiches
363 
364 
365     [R"uckgabewert]
366 
367     const String&                   Referenz auf diesen Namen
368 
369 */
370 {
371     static String maTmpString;
372 
373     DocTemplLocker_Impl aLocker( *pImp );
374 
375     if ( pImp->Construct() )
376     {
377         RegionData_Impl *pData = pImp->GetRegion( nIdx );
378 
379         if ( pData )
380             maTmpString = pData->GetTitle();
381         else
382             maTmpString.Erase();
383     }
384     else
385         maTmpString.Erase();
386 
387     return maTmpString;
388 }
389 
390 
391 //------------------------------------------------------------------------
392 
GetRegionNo(const String & rRegion) const393 sal_uInt16 SfxDocumentTemplates::GetRegionNo
394 (
395     const String &rRegion       // Name der Region
396 )   const
397 
398 /*  [Beschreibung]
399 
400     Liefert den Index f"ur einen logischen Namen eines Bereiches.
401 
402 
403     [R"uckgabewert]
404 
405     sal_uInt16          Index von 'rRegion' oder USHRT_MAX falls unbekannt
406 
407 */
408 {
409     DocTemplLocker_Impl aLocker( *pImp );
410 
411     if ( !pImp->Construct() )
412         return USHRT_MAX;
413 
414     sal_Bool    bFound;
415     sal_uIntPtr       nIndex = pImp->GetRegionPos( rRegion, bFound );
416 
417     if ( bFound )
418         return (sal_uInt16) nIndex;
419     else
420         return USHRT_MAX;
421 }
422 
423 
424 //------------------------------------------------------------------------
425 
GetRegionCount() const426 sal_uInt16 SfxDocumentTemplates::GetRegionCount() const
427 
428 /*  [Beschreibung]
429 
430     Liefert die Anzahl der Bereiche
431 
432 
433     [R"uckgabewert]
434 
435     sal_uInt16                  Anzahl der Bereiche
436 
437 */
438 {
439     DocTemplLocker_Impl aLocker( *pImp );
440 
441     if ( !pImp->Construct() )
442         return 0;
443 
444     sal_uIntPtr nCount = pImp->GetRegionCount();
445 
446     return (sal_uInt16) nCount;
447 }
448 
449 //------------------------------------------------------------------------
450 
IsRegionLoaded(sal_uInt16 nIdx) const451 sal_Bool SfxDocumentTemplates::IsRegionLoaded( sal_uInt16 nIdx ) const
452 {
453     DocTemplLocker_Impl aLocker( *pImp );
454 
455     if ( !pImp->Construct() )
456         return sal_False;
457 
458     RegionData_Impl *pData = pImp->GetRegion( nIdx );
459 
460     if ( pData )
461         return sal_True;
462     else
463         return sal_False;
464 }
465 
466 //------------------------------------------------------------------------
467 
GetCount(const String & rName) const468 sal_uInt16 SfxDocumentTemplates::GetCount
469 (
470     const String&   rName   /*  Name des Bereiches, dessen Eintrags-
471                                 anzahl ermittelt werden soll */
472 
473 )   const
474 
475 /*  [Beschreibung]
476 
477     Liefert die Anzahl der Eintr"age eines Bereiches
478 
479 
480     [R"uckgabewert]
481 
482     USHORT                      Anzahl der Eintr"age
483 
484 */
485 
486 {
487     DocTemplLocker_Impl aLocker( *pImp );
488 
489     if ( !pImp->Construct() )
490         return 0;
491 
492     RegionData_Impl *pData = pImp->GetRegion( rName );
493     sal_uIntPtr            nCount = 0;
494 
495     if ( pData )
496         nCount = pData->GetCount();
497 
498     return (sal_uInt16) nCount;
499 }
500 
501 //------------------------------------------------------------------------
502 
GetCount(sal_uInt16 nRegion) const503 sal_uInt16 SfxDocumentTemplates::GetCount
504 (
505     sal_uInt16 nRegion              /*  Index des Bereiches, dessen Eintrags-
506                                     anzahl ermittelt werden soll */
507 
508 )   const
509 
510 /*  [Beschreibung]
511 
512     Liefert die Anzahl der Eintr"age eines Bereiches
513 
514 
515     [R"uckgabewert]                 Anzahl der Eintr"age
516 
517 */
518 
519 {
520     DocTemplLocker_Impl aLocker( *pImp );
521 
522     if ( !pImp->Construct() )
523         return 0;
524 
525     RegionData_Impl *pData = pImp->GetRegion( nRegion );
526     sal_uIntPtr            nCount = 0;
527 
528     if ( pData )
529         nCount = pData->GetCount();
530 
531     return (sal_uInt16) nCount;
532 }
533 
534 //------------------------------------------------------------------------
535 
GetName(sal_uInt16 nRegion,sal_uInt16 nIdx) const536 const String& SfxDocumentTemplates::GetName
537 (
538     sal_uInt16 nRegion,     //  Index des Bereiches, in dem der Eintrag liegt
539     sal_uInt16 nIdx         //  Index des Eintrags
540 )   const
541 
542 /*  [Beschreibung]
543 
544     Liefert den logischen Namen eines Eintrags eines Bereiches
545 
546 
547     [R"uckgabewert]
548 
549     const String&           Name des Eintrags
550 
551 */
552 
553 {
554     DocTemplLocker_Impl aLocker( *pImp );
555 
556     static String maTmpString;
557 
558     if ( pImp->Construct() )
559     {
560         DocTempl_EntryData_Impl  *pEntry = NULL;
561         RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
562 
563         if ( pRegion )
564             pEntry = pRegion->GetEntry( nIdx );
565 
566         if ( pEntry )
567             maTmpString = pEntry->GetTitle();
568         else
569             maTmpString.Erase();
570     }
571     else
572         maTmpString.Erase();
573 
574     return maTmpString;
575 }
576 
577 //------------------------------------------------------------------------
578 
GetFileName(sal_uInt16 nRegion,sal_uInt16 nIdx) const579 String SfxDocumentTemplates::GetFileName
580 (
581     sal_uInt16 nRegion,     //  Index des Bereiches, in dem der Eintrag liegt
582     sal_uInt16 nIdx         //  Index des Eintrags
583 )   const
584 
585 /*  [Beschreibung]
586 
587     Liefert den Dateinamen eines Eintrags eines Bereiches
588 
589     [R"uckgabewert]                 Dateiname des Eintrags
590 
591 */
592 {
593     DocTemplLocker_Impl aLocker( *pImp );
594 
595     if ( !pImp->Construct() )
596         return String();
597 
598     DocTempl_EntryData_Impl  *pEntry = NULL;
599     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
600 
601     if ( pRegion )
602         pEntry = pRegion->GetEntry( nIdx );
603 
604     if ( pEntry )
605     {
606         INetURLObject aURLObj( pEntry->GetTargetURL() );
607         return aURLObj.getName( INetURLObject::LAST_SEGMENT, true,
608                                 INetURLObject::DECODE_WITH_CHARSET );
609     }
610     else
611         return String();
612 }
613 
614 //------------------------------------------------------------------------
615 
GetPath(sal_uInt16 nRegion,sal_uInt16 nIdx) const616 String SfxDocumentTemplates::GetPath
617 (
618     sal_uInt16  nRegion,    //  Index des Bereiches, in dem der Eintrag liegt
619     sal_uInt16  nIdx        //  Index des Eintrags
620 )   const
621 
622 /*  [Beschreibung]
623 
624     Liefert den Dateinamen mit vollst"andigem Pfad zu der einem
625     Eintrag zugeordneten Datei
626 
627 
628     [R"uckgabewert]
629 
630     String                  Dateiname mit vollst"andigem Pfad
631 
632 */
633 {
634     DocTemplLocker_Impl aLocker( *pImp );
635 
636     if ( !pImp->Construct() )
637         return String();
638 
639     DocTempl_EntryData_Impl  *pEntry = NULL;
640     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
641 
642     if ( pRegion )
643         pEntry = pRegion->GetEntry( nIdx );
644 
645     if ( pEntry )
646         return pEntry->GetTargetURL();
647     else
648         return String();
649 }
650 
651 //------------------------------------------------------------------------
652 
GetTemplatePath(sal_uInt16 nRegion,const String & rLongName) const653 String SfxDocumentTemplates::GetTemplatePath
654 (
655     sal_uInt16          nRegion,    //  Index des Bereiches, in dem der Eintrag liegt
656     const String&   rLongName   //  logischer Name des Eintrags
657 )   const
658 
659 /*  [Beschreibung]
660 
661     Liefert den Dateinamen mit vollst"andigem Pfad zu der einem
662     Eintrag zugeordneten Datei
663 
664 
665     [R"uckgabewert]
666 
667     String                          Dateiname mit vollst"andigem Pfad
668 
669 */
670 {
671     DocTemplLocker_Impl aLocker( *pImp );
672 
673     if ( !pImp->Construct() )
674         return String();
675 
676     DocTempl_EntryData_Impl  *pEntry = NULL;
677     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
678 
679     if ( pRegion )
680         pEntry = pRegion->GetEntry( rLongName );
681 
682     if ( pEntry )
683         return pEntry->GetTargetURL();
684     else if ( pRegion )
685     {
686         // a new template is going to be inserted, generate a new URL
687         // TODO/LATER: if the title is localized, use minimized URL in future
688 
689         // --**-- extension handling will become more complicated, because
690         //          every new document type will have it's own extension
691         //          e.g.: .stw or .stc instead of .vor
692         INetURLObject aURLObj( pRegion->GetTargetURL() );
693         aURLObj.insertName( rLongName, false,
694                      INetURLObject::LAST_SEGMENT, true,
695                      INetURLObject::ENCODE_ALL );
696 
697         OUString aExtension = aURLObj.getExtension();
698 
699         if ( ! aExtension.getLength() )
700             aURLObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM( "vor" ) ) );
701 
702         return aURLObj.GetMainURL( INetURLObject::NO_DECODE );
703     }
704     else
705         return String();
706 }
707 
708 //------------------------------------------------------------------------
709 
GetDefaultTemplatePath(const String & rLongName)710 String SfxDocumentTemplates::GetDefaultTemplatePath
711 (
712     const String& rLongName
713 )
714 
715 /*  [Beschreibung]
716 
717     Liefert den Standardpfad zu Dokumentvorlagen
718 
719 
720     [R"uckgabewert]
721 
722     String                  Standardpfad zu Dokumentvorlagen
723 
724 */
725 {
726     DocTemplLocker_Impl aLocker( *pImp );
727 
728     if ( ! pImp->Construct() )
729         return String();
730 
731     // the first region in the list should always be the standard
732     // group
733     // --**-- perhaps we have to create it ???
734     RegionData_Impl *pRegion = pImp->GetRegion( 0L );
735     DocTempl_EntryData_Impl  *pEntry = NULL;
736 
737     if ( pRegion )
738         pEntry = pRegion->GetEntry( rLongName );
739 
740     if ( pEntry )
741         return pEntry->GetTargetURL();
742     else if ( pRegion )
743     {
744         // a new template is going to be inserted, generate a new URL
745         // TODO/LATER: if the title is localized, use minimized URL in future
746 
747         INetURLObject aURLObj( pRegion->GetTargetURL() );
748         aURLObj.insertName( rLongName, false,
749                      INetURLObject::LAST_SEGMENT, true,
750                      INetURLObject::ENCODE_ALL );
751 
752         OUString aExtension = aURLObj.getExtension();
753 
754         if ( ! aExtension.getLength() )
755             aURLObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM( "vor" ) ) );
756 
757         return aURLObj.GetMainURL( INetURLObject::NO_DECODE );
758     }
759     else
760         return String();
761 
762 /* dv! missing: create the directory, if it doesn't exists
763 
764 
765     DBG_ASSERT(aDirs.GetTokenCount(cDelim), "Keine Bereiche");
766     DirEntry aPath(aDirs.GetToken(0, cDelim));
767 
768     // Verzeichnis anlegen
769     if(!aPath.MakeDir())
770         return String();
771 
772     MakeFileName_Impl(aPath, rLongName, sal_True);
773     SfxTemplateDir  *pEntry = new SfxTemplateDir;
774     SfxTemplateDirEntryPtr pDirEntry =
775         new SfxTemplateDirEntry( String( '.' ), aPath.GetPath() );
776     pDirEntry->SetContent(new SfxTemplateDir(aPath.GetPath()));
777     pEntry->Insert(pDirEntry, pEntry->Count());
778     pDirs->Insert(pEntry, pDirs->Count());
779     return aPath.GetFull();
780 */
781 }
782 
783 //------------------------------------------------------------------------
784 
GetTemplateTargetURLFromComponent(const::rtl::OUString & aGroupName,const::rtl::OUString & aTitle)785 ::rtl::OUString SfxDocumentTemplates::GetTemplateTargetURLFromComponent( const ::rtl::OUString& aGroupName,
786                                                                          const ::rtl::OUString& aTitle )
787 {
788     DocTemplLocker_Impl aLocker( *pImp );
789 
790     INetURLObject aTemplateObj( pImp->GetRootURL() );
791 
792     aTemplateObj.insertName( aGroupName, false,
793                         INetURLObject::LAST_SEGMENT, true,
794                         INetURLObject::ENCODE_ALL );
795 
796     aTemplateObj.insertName( aTitle, false,
797                         INetURLObject::LAST_SEGMENT, true,
798                         INetURLObject::ENCODE_ALL );
799 
800 
801     ::rtl::OUString aResult;
802     Content aTemplate;
803     uno::Reference< XCommandEnvironment > aCmdEnv;
804     if ( Content::create( aTemplateObj.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv, aTemplate ) )
805     {
806         OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
807         getTextProperty_Impl( aTemplate, aPropName, aResult );
808         aResult = SvtPathOptions().SubstituteVariable( aResult );
809     }
810 
811     return aResult;
812 }
813 
814 //------------------------------------------------------------------------
815 
SaveDir()816 sal_Bool SfxDocumentTemplates::SaveDir
817 (
818 //  SfxTemplateDir& rDir        //  das zu speichernde Directory
819 )
820 
821 /*  [Beschreibung]
822 
823     Speichert das Directory rDir
824 
825 
826     [R"uckgabewert]
827 
828     sal_Bool                        sal_False,
829                                 Schreibfehler
830 
831                                 sal_True
832                                 gespeichert
833 
834 */
835 
836 {
837     return sal_True;
838 }
839 
840 //------------------------------------------------------------------------
841 
NewTemplate(sal_uInt16 nRegion,const String & rLongName,const String & rFileName)842 void SfxDocumentTemplates::NewTemplate
843 (
844     sal_uInt16          nRegion,    /*  Index des Bereiches, in dem die Vorlage
845                                     angelegt werden soll */
846 
847     const String&   rLongName,  //  logischer Name der neuen Vorlage
848     const String&   rFileName   //  Dateiname der neuen Vorlage
849 )
850 
851 /*  [Beschreibung]
852 
853     Eintragen einer neuen Dokumentvorlage in die Verwaltungsstrukturen
854     Das "Uberschreiben einer Vorlage gleichen Namens wird
855     verhindert (!! Fehlermeldung)
856 
857 */
858 
859 {
860     DocTemplLocker_Impl aLocker( *pImp );
861 
862     if ( ! pImp->Construct() )
863         return;
864 
865     DocTempl_EntryData_Impl  *pEntry;
866     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
867 
868     // do nothing if there is no region with that index
869     if ( !pRegion )
870         return;
871 
872     pEntry = pRegion->GetEntry( rLongName );
873 
874     // do nothing if there is already an entry with that name
875     if ( pEntry )
876         return;
877 
878     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
879 
880     if ( xTemplates->addTemplate( pRegion->GetTitle(), rLongName, rFileName ) )
881         pRegion->AddEntry( rLongName, rFileName );
882 }
883 
884 //------------------------------------------------------------------------
885 
CopyOrMove(sal_uInt16 nTargetRegion,sal_uInt16 nTargetIdx,sal_uInt16 nSourceRegion,sal_uInt16 nSourceIdx,sal_Bool bMove)886 sal_Bool SfxDocumentTemplates::CopyOrMove
887 (
888     sal_uInt16  nTargetRegion,      //  Index des Zielbereiches
889     sal_uInt16  nTargetIdx,         //  Index Zielposition
890     sal_uInt16  nSourceRegion,      //  Index des Quellbereiches
891     sal_uInt16  nSourceIdx,         /*  Index der zu kopierenden / zu verschiebenden
892                                     Dokumentvorlage */
893     sal_Bool    bMove               //  kopieren / verschieben
894 )
895 
896 /*  [Beschreibung]
897 
898     Kopieren oder Verschieben einer Dokumentvorlage
899 
900     [R"uckgabewert]
901 
902     sal_Bool                            sal_True
903                                     Aktion konnte ausgef"uhrt werden
904 
905                                     sal_False
906                                     Aktion konnte nicht ausgef2uhrt werden
907     [Querverweise]
908 
909     <SfxDocumentTemplates::Move(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)>
910     <SfxDocumentTemplates::Copy(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)>
911 */
912 
913 {
914     /* to perform a copy or move, we need to send a transfer command to
915        the destination folder with the URL of the source as parameter.
916        ( If the destination content doesn't support the transfer command,
917        we could try a copy ( and delete ) instead. )
918        We need two transfers ( one for the real template and one for its
919        representation in the hierarchy )
920        ...
921     */
922 
923     DocTemplLocker_Impl aLocker( *pImp );
924 
925     if ( !pImp->Construct() )
926         return sal_False;
927 
928     // Don't copy or move any folders
929     if( nSourceIdx == USHRT_MAX )
930         return sal_False ;
931 
932     if ( nSourceRegion == nTargetRegion )
933     {
934         DBG_ERRORFILE( "Don't know, what to do!" );
935         return sal_False;
936 #if 0
937     // Verschieben einer Vorlage innerhalb eines Bereiches
938     // --> nur Verwaltungsdaten aktualisieren
939     if ( bMove && nTargetRegion == nSourceRegion )
940     {
941         if(nTargetIdx == USHRT_MAX)
942             nTargetIdx = 0;
943         const SfxTemplateDirEntryPtr pEntry = rTargetDir[nSourceIdx];
944         rTargetDir.Insert(pEntry, nTargetIdx);
945         if(nTargetIdx < nSourceIdx)
946             ++nSourceIdx;
947         rTargetDir.Remove(nSourceIdx);
948         return SaveDir(rTargetDir);
949     }
950 #endif
951     }
952 
953     RegionData_Impl *pSourceRgn = pImp->GetRegion( nSourceRegion );
954     if ( !pSourceRgn )
955         return sal_False;
956 
957     DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nSourceIdx );
958     if ( !pSource )
959         return sal_False;
960 
961     RegionData_Impl *pTargetRgn = pImp->GetRegion( nTargetRegion );
962     if ( !pTargetRgn )
963         return sal_False;
964 
965     OUString aTitle = pSource->GetTitle();
966 
967     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
968 
969     if ( xTemplates->addTemplate( pTargetRgn->GetTitle(),
970                                   aTitle,
971                                   pSource->GetTargetURL() ) )
972     {
973 
974         INetURLObject aSourceObj( pSource->GetTargetURL() );
975 
976         ::rtl::OUString aNewTargetURL = GetTemplateTargetURLFromComponent( pTargetRgn->GetTitle(), aTitle );
977         if ( !aNewTargetURL.getLength() )
978             return sal_False;
979 
980         if ( bMove )
981         {
982             // --**-- delete the original file
983             sal_Bool bDeleted = xTemplates->removeTemplate( pSourceRgn->GetTitle(),
984                                                             pSource->GetTitle() );
985             if ( bDeleted )
986                 pSourceRgn->DeleteEntry( nSourceIdx );
987             else
988             {
989                 if ( xTemplates->removeTemplate( pTargetRgn->GetTitle(), aTitle ) )
990                     return sal_False; // will trigger tetry with copy instead of move
991 
992                 // if it is not possible to remove just created template ( must be possible! )
993                 // it is better to report success here, since at least the copy has succeeded
994                 // TODO/LATER: solve it more gracefully in future
995             }
996         }
997 
998         pTargetRgn->AddEntry( aTitle, aNewTargetURL, &nTargetIdx );
999 
1000         return sal_True;
1001     }
1002 
1003     // --**-- wenn aktuell das File geoeffnet ist,
1004     // muss es hinterher wieder geoeffnet werden
1005 
1006     return sal_False;
1007 }
1008 
1009 //------------------------------------------------------------------------
1010 
Move(sal_uInt16 nTargetRegion,sal_uInt16 nTargetIdx,sal_uInt16 nSourceRegion,sal_uInt16 nSourceIdx)1011 sal_Bool SfxDocumentTemplates::Move
1012 (
1013     sal_uInt16 nTargetRegion,       //  Index des Zielbereiches
1014     sal_uInt16 nTargetIdx,          //  Index Zielposition
1015     sal_uInt16 nSourceRegion,       //  Index des Quellbereiches
1016     sal_uInt16 nSourceIdx           /*  Index der zu kopierenden / zu verschiebenden
1017                                     Dokumentvorlage */
1018 )
1019 
1020 /*  [Beschreibung]
1021 
1022     Verschieben einer Dokumentvorlage
1023 
1024 
1025     [R"uckgabewert]
1026 
1027     sal_Bool                            sal_True
1028                                     Aktion konnte ausgef"uhrt werden
1029 
1030                                     sal_False
1031                                     Aktion konnte nicht ausgef2uhrt werden
1032 
1033     [Querverweise]
1034 
1035     <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)>
1036 */
1037 {
1038     DocTemplLocker_Impl aLocker( *pImp );
1039 
1040     return CopyOrMove( nTargetRegion, nTargetIdx,
1041                        nSourceRegion, nSourceIdx, sal_True );
1042 }
1043 
1044 //------------------------------------------------------------------------
1045 
Copy(sal_uInt16 nTargetRegion,sal_uInt16 nTargetIdx,sal_uInt16 nSourceRegion,sal_uInt16 nSourceIdx)1046 sal_Bool SfxDocumentTemplates::Copy
1047 (
1048     sal_uInt16 nTargetRegion,       //  Index des Zielbereiches
1049     sal_uInt16 nTargetIdx,          //  Index Zielposition
1050     sal_uInt16 nSourceRegion,       //  Index des Quellbereiches
1051     sal_uInt16 nSourceIdx           /*  Index der zu kopierenden / zu verschiebenden
1052                                     Dokumentvorlage */
1053 )
1054 
1055 /*  [Beschreibung]
1056 
1057     Kopieren einer Dokumentvorlage
1058 
1059 
1060     [R"uckgabewert]
1061 
1062     sal_Bool                            sal_True
1063                                     Aktion konnte ausgef"uhrt werden
1064 
1065                                     sal_False
1066                                     Aktion konnte nicht ausgef"uhrt werden
1067 
1068     [Querverweise]
1069 
1070     <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)>
1071 */
1072 
1073 {
1074     DocTemplLocker_Impl aLocker( *pImp );
1075 
1076     return CopyOrMove( nTargetRegion, nTargetIdx,
1077                        nSourceRegion, nSourceIdx, sal_False );
1078 }
1079 
1080 //------------------------------------------------------------------------
1081 
CopyTo(sal_uInt16 nRegion,sal_uInt16 nIdx,const String & rName) const1082 sal_Bool SfxDocumentTemplates::CopyTo
1083 (
1084     sal_uInt16          nRegion,    /*  Bereich der Vorlage, die exportiert werden
1085                                     soll  */
1086     sal_uInt16          nIdx,       /*  Index der Vorlage, die exportiert werden
1087                                     soll */
1088     const String&   rName       /*  Dateiname, unter dem die Vorlage angelegt
1089                                     werden soll */
1090 )   const
1091 
1092 /*  [Beschreibung]
1093 
1094     Exportieren einer Dokumentvorlage in das Dateisystem
1095 
1096 
1097     [R"uckgabewert]
1098 
1099     sal_Bool                            sal_True
1100                                     Aktion konnte ausgef"uhrt werden
1101 
1102                                     sal_False
1103                                     Aktion konnte nicht ausgef"uhrt werden
1104 
1105 
1106     [Querverweise]
1107 
1108     <SfxDocumentTemplates::CopyFrom(sal_uInt16,sal_uInt16,String&)>
1109 */
1110 
1111 {
1112     DocTemplLocker_Impl aLocker( *pImp );
1113 
1114     if ( ! pImp->Construct() )
1115         return sal_False;
1116 
1117     RegionData_Impl *pSourceRgn = pImp->GetRegion( nRegion );
1118     if ( !pSourceRgn )
1119         return sal_False;
1120 
1121     DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nIdx );
1122     if ( !pSource )
1123         return sal_False;
1124 
1125     INetURLObject aTargetURL( rName );
1126 
1127     OUString aTitle( aTargetURL.getName( INetURLObject::LAST_SEGMENT, true,
1128                                          INetURLObject::DECODE_WITH_CHARSET ) );
1129     aTargetURL.removeSegment();
1130 
1131     OUString aParentURL = aTargetURL.GetMainURL( INetURLObject::NO_DECODE );
1132 
1133     uno::Reference< XCommandEnvironment > aCmdEnv;
1134     Content aTarget;
1135 
1136     try
1137     {
1138         aTarget = Content( aParentURL, aCmdEnv );
1139 
1140         TransferInfo aTransferInfo;
1141         aTransferInfo.MoveData = sal_False;
1142         aTransferInfo.SourceURL = pSource->GetTargetURL();
1143         aTransferInfo.NewTitle = aTitle;
1144         aTransferInfo.NameClash = NameClash::OVERWRITE;
1145 
1146         Any aArg = makeAny( aTransferInfo );
1147         OUString aCmd( RTL_CONSTASCII_USTRINGPARAM( COMMAND_TRANSFER ) );
1148 
1149         aTarget.executeCommand( aCmd, aArg );
1150     }
1151     catch ( ContentCreationException& )
1152     { return sal_False; }
1153     catch ( Exception& )
1154     { return sal_False; }
1155 
1156     return sal_True;
1157 }
1158 
1159 //------------------------------------------------------------------------
1160 
CopyFrom(sal_uInt16 nRegion,sal_uInt16 nIdx,String & rName)1161 sal_Bool SfxDocumentTemplates::CopyFrom
1162 (
1163     sal_uInt16      nRegion,        /*  Bereich, in den die Vorlage importiert
1164                                     werden soll */
1165     sal_uInt16      nIdx,           //  Index der neuen Vorlage in diesem Bereich
1166     String&     rName           /*  Dateiname der Vorlage, die importiert
1167                                     werden soll, als out-Parameter der (auto-
1168                                     matisch aus dem Dateinamen generierte)
1169                                     logische Name der Vorlage */
1170 )
1171 
1172 /*  [Beschreibung]
1173 
1174     Importieren einer Dokumentvorlage aus dem Dateisystem
1175 
1176 
1177     [R"uckgabewert]                 Erfolg (sal_True) oder Mi"serfpTargetDirectory->GetContent());
1178 
1179     sal_Bool                            sal_True
1180                                     Aktion konnte ausgef"uhrt werden
1181 
1182                                     sal_False
1183                                     Aktion konnte nicht ausgef"uhrt werden
1184 
1185     [Querverweise]
1186 
1187     <SfxDocumentTemplates::CopyTo(sal_uInt16,sal_uInt16,const String&)>
1188 */
1189 
1190 {
1191     DocTemplLocker_Impl aLocker( *pImp );
1192 
1193     if ( ! pImp->Construct() )
1194         return sal_False;
1195 
1196     RegionData_Impl *pTargetRgn = pImp->GetRegion( nRegion );
1197 
1198     if ( !pTargetRgn )
1199         return sal_False;
1200 
1201     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1202     if ( !xTemplates.is() )
1203         return sal_False;
1204 
1205     OUString aTitle;
1206     sal_Bool bTemplateAdded = sal_False;
1207 
1208     if( pImp->GetTitleFromURL( rName, aTitle ) )
1209     {
1210         bTemplateAdded = xTemplates->addTemplate( pTargetRgn->GetTitle(), aTitle, rName );
1211     }
1212     else
1213     {
1214         OUString aService( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_DESKTOP ) );
1215         uno::Reference< XComponentLoader > xDesktop( ::comphelper::getProcessServiceFactory()->createInstance( aService ),
1216                                                 UNO_QUERY );
1217 
1218         Sequence< PropertyValue > aArgs( 1 );
1219         aArgs[0].Name = ::rtl::OUString::createFromAscii("Hidden");
1220         aArgs[0].Value <<= sal_True;
1221 
1222         INetURLObject   aTemplURL( rName );
1223         uno::Reference< XDocumentPropertiesSupplier > xDocPropsSupplier;
1224         uno::Reference< XStorable > xStorable;
1225         try
1226         {
1227             xStorable = uno::Reference< XStorable >(
1228                 xDesktop->loadComponentFromURL( aTemplURL.GetMainURL(INetURLObject::NO_DECODE),
1229                                                 OUString::createFromAscii( "_blank" ),
1230                                                 0,
1231                                                 aArgs ),
1232                 UNO_QUERY );
1233 
1234             xDocPropsSupplier = uno::Reference< XDocumentPropertiesSupplier >(
1235                 xStorable, UNO_QUERY );
1236         }
1237         catch( Exception& )
1238         {
1239         }
1240 
1241         if( xStorable.is() )
1242         {
1243             // get Title from XDocumentPropertiesSupplier
1244             if( xDocPropsSupplier.is() )
1245             {
1246                 uno::Reference< XDocumentProperties > xDocProps
1247                     = xDocPropsSupplier->getDocumentProperties();
1248                 if (xDocProps.is() ) {
1249                     aTitle = xDocProps->getTitle();
1250                 }
1251             }
1252 
1253             if( ! aTitle.getLength() )
1254             {
1255                 INetURLObject aURL( aTemplURL );
1256                 aURL.CutExtension();
1257                 aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,
1258                                         INetURLObject::DECODE_WITH_CHARSET );
1259             }
1260 
1261             // write a template using XStorable interface
1262             bTemplateAdded = xTemplates->storeTemplate( pTargetRgn->GetTitle(), aTitle, xStorable );
1263         }
1264     }
1265 
1266 
1267     if( bTemplateAdded )
1268     {
1269         INetURLObject aTemplObj( pTargetRgn->GetHierarchyURL() );
1270         aTemplObj.insertName( aTitle, false,
1271                               INetURLObject::LAST_SEGMENT, true,
1272                               INetURLObject::ENCODE_ALL );
1273         OUString aTemplURL = aTemplObj.GetMainURL( INetURLObject::NO_DECODE );
1274 
1275         uno::Reference< XCommandEnvironment > aCmdEnv;
1276         Content aTemplCont;
1277 
1278         if( Content::create( aTemplURL, aCmdEnv, aTemplCont ) )
1279         {
1280             OUString aTemplName;
1281             OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
1282 
1283             if( getTextProperty_Impl( aTemplCont, aPropName, aTemplName ) )
1284             {
1285                 if ( nIdx == USHRT_MAX )
1286                     nIdx = 0;
1287                 else
1288                     nIdx += 1;
1289 
1290                 pTargetRgn->AddEntry( aTitle, aTemplName, &nIdx );
1291                 rName = aTitle;
1292                 return sal_True;
1293             }
1294             else
1295             {
1296                 DBG_ASSERT( sal_False, "CopyFrom(): The content should contain target URL!" );
1297             }
1298         }
1299         else
1300         {
1301             DBG_ASSERT( sal_False, "CopyFrom(): The content just was created!" );
1302         }
1303     }
1304 
1305     return sal_False;
1306 }
1307 
1308 //------------------------------------------------------------------------
1309 
Delete(sal_uInt16 nRegion,sal_uInt16 nIdx)1310 sal_Bool SfxDocumentTemplates::Delete
1311 (
1312     sal_uInt16 nRegion,             //  Index des Bereiches
1313     sal_uInt16 nIdx                 /*  Index des Eintrags oder USHRT_MAX,
1314                                     wenn ein Verzeichnis gemeint ist. */
1315 )
1316 
1317 /*  [Beschreibung]
1318 
1319     "oschen eines Eintrags oder eines Verzeichnisses
1320 
1321 
1322     [R"uckgabewert]
1323 
1324     sal_Bool                            sal_True
1325                                     Aktion konnte ausgef"uhrt werden
1326 
1327                                     sal_False
1328                                     Aktion konnte nicht ausgef"uhrt werden
1329 
1330 
1331     [Querverweise]
1332 
1333     <SfxDocumentTemplates::InsertDir(const String&,sal_uInt16)>
1334     <SfxDocumentTemplates::KillDir(SfxTemplateDir&)>
1335     <SfxDocumentTemplates::SaveDir(SfxTemplateDir&)>
1336 */
1337 
1338 {
1339     DocTemplLocker_Impl aLocker( *pImp );
1340 
1341     /* delete the template or folder in the hierarchy and in the
1342        template folder by sending a delete command to the content.
1343        Then remove the data from the lists
1344     */
1345     if ( ! pImp->Construct() )
1346         return sal_False;
1347 
1348     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
1349 
1350     if ( !pRegion )
1351         return sal_False;
1352 
1353     sal_Bool bRet;
1354     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1355 
1356     if ( nIdx == USHRT_MAX )
1357     {
1358         bRet = xTemplates->removeGroup( pRegion->GetTitle() );
1359         if ( bRet )
1360             pImp->DeleteRegion( nRegion );
1361     }
1362     else
1363     {
1364         DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx );
1365 
1366         if ( !pEntry )
1367             return sal_False;
1368 
1369         bRet = xTemplates->removeTemplate( pRegion->GetTitle(),
1370                                            pEntry->GetTitle() );
1371         if( bRet )
1372             pRegion->DeleteEntry( nIdx );
1373     }
1374 
1375     return bRet;
1376 }
1377 
1378 //------------------------------------------------------------------------
1379 
InsertDir(const String & rText,sal_uInt16 nRegion)1380 sal_Bool SfxDocumentTemplates::InsertDir
1381 (
1382     const String&   rText,      //  der logische Name des neuen Bereiches
1383     sal_uInt16          nRegion     //  Index des Bereiches
1384 )
1385 
1386 /*  [Beschreibung]
1387 
1388     Einf"ugen eines Verzeichnisses
1389 
1390 
1391     [R"uckgabewert]
1392 
1393     sal_Bool                            sal_True
1394                                     Aktion konnte ausgef"uhrt werden
1395 
1396                                     sal_False
1397                                     Aktion konnte nicht ausgef"uhrt werden
1398 
1399     [Querverweise]
1400 
1401     <SfxDocumentTemplates::KillDir(SfxTemplateDir&)>
1402     <SfxDocumentTemplates::SaveDir(SfxTemplateDir&)>
1403 */
1404 {
1405     DocTemplLocker_Impl aLocker( *pImp );
1406 
1407     if ( ! pImp->Construct() )
1408         return sal_False;
1409 
1410     RegionData_Impl *pRegion = pImp->GetRegion( rText );
1411 
1412     if ( pRegion )
1413         return sal_False;
1414 
1415     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1416 
1417     if ( xTemplates->addGroup( rText ) )
1418     {
1419         RegionData_Impl* pNewRegion = new RegionData_Impl( pImp, rText );
1420 
1421         if ( ! pImp->InsertRegion( pNewRegion, nRegion ) )
1422         {
1423             delete pNewRegion;
1424             return sal_False;
1425         }
1426         return sal_True;
1427     }
1428 
1429     return sal_False;
1430 }
1431 
1432 //------------------------------------------------------------------------
1433 
SetName(const String & rName,sal_uInt16 nRegion,sal_uInt16 nIdx)1434 sal_Bool SfxDocumentTemplates::SetName
1435 (
1436     const String&   rName,      //  Der zu setzende Name
1437     sal_uInt16          nRegion,    //  Index des Bereiches
1438     sal_uInt16          nIdx        /*  Index des Eintrags oder USHRT_MAX,
1439                                     wenn ein Verzeichnis gemeint ist. */
1440 )
1441 
1442 /*  [Beschreibung]
1443 
1444     "Andern des Namens eines Eintrags oder eines Verzeichnisses
1445 
1446 
1447     [R"uckgabewert]
1448 
1449     sal_Bool                            sal_True
1450                                     Aktion konnte ausgef"uhrt werden
1451 
1452                                     sal_False
1453                                     Aktion konnte nicht ausgef"uhrt werden
1454 
1455 */
1456 
1457 {
1458     DocTemplLocker_Impl aLocker( *pImp );
1459 
1460     if ( ! pImp->Construct() )
1461         return sal_False;
1462 
1463     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
1464     DocTempl_EntryData_Impl *pEntry = NULL;
1465 
1466     if ( !pRegion )
1467         return sal_False;
1468 
1469     uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1470     OUString aEmpty;
1471 
1472     if ( nIdx == USHRT_MAX )
1473     {
1474         if ( pRegion->GetTitle() == OUString( rName ) )
1475             return sal_True;
1476 
1477         // we have to rename a region
1478         if ( xTemplates->renameGroup( pRegion->GetTitle(), rName ) )
1479         {
1480             pRegion->SetTitle( rName );
1481             pRegion->SetTargetURL( aEmpty );
1482             pRegion->SetHierarchyURL( aEmpty );
1483             return sal_True;
1484         }
1485     }
1486     else
1487     {
1488         pEntry = pRegion->GetEntry( nIdx );
1489 
1490         if ( !pEntry )
1491             return sal_False;
1492 
1493         if ( pEntry->GetTitle() == OUString( rName ) )
1494             return sal_True;
1495 
1496         if ( xTemplates->renameTemplate( pRegion->GetTitle(),
1497                                          pEntry->GetTitle(),
1498                                          rName ) )
1499         {
1500             pEntry->SetTitle( rName );
1501             pEntry->SetTargetURL( aEmpty );
1502             pEntry->SetHierarchyURL( aEmpty );
1503             return sal_True;
1504         }
1505     }
1506 
1507     return sal_False;
1508 }
1509 
1510 //------------------------------------------------------------------------
1511 
Rescan()1512 sal_Bool SfxDocumentTemplates::Rescan()
1513 
1514 /*  [Beschreibung]
1515 
1516     Abgleich des Verwaltungsdaten mit dem aktuellen Zustand auf der Platte.
1517     Die logischen Namen, zu denen keine Datei mit existiert, werden aus
1518     der Verwaltungsstruktur entfernt; Dateien, zu denen kein Eintrag
1519     existiert, werden aufgenommen.
1520 
1521 
1522     [R"uckgabewert]
1523 
1524     sal_Bool                            sal_True
1525                                     Aktion konnte ausgef"uhrt werden
1526 
1527                                     sal_False
1528                                     Aktion konnte nicht ausgef"uhrt werden
1529 
1530 
1531     [Querverweise]
1532 
1533     <SfxTemplateDir::Scan(sal_Bool bDirectory, sal_Bool bSave)>
1534     <SfxTemplateDir::Freshen(const SfxTemplateDir &rNew)>
1535 */
1536 {
1537     if ( !pImp->Construct() )
1538         return sal_False;
1539 
1540     pImp->Rescan();
1541 
1542     return sal_True;
1543 }
1544 
1545 //------------------------------------------------------------------------
1546 
CreateObjectShell(sal_uInt16 nRegion,sal_uInt16 nIdx)1547 SfxObjectShellRef SfxDocumentTemplates::CreateObjectShell
1548 (
1549     sal_uInt16 nRegion,         //  Index des Bereiches
1550     sal_uInt16 nIdx             //  Index des Eintrags
1551 )
1552 
1553 /*  [Beschreibung]
1554 
1555     Zugriff auf die DokumentShell eines Eintrags
1556 
1557 
1558     [R"uckgabewert]
1559 
1560     SfxObjectShellRef         Referenz auf die ObjectShell
1561 
1562 
1563     [Querverweise]
1564 
1565     <SfxTemplateDirEntry::CreateObjectShell()>
1566     <SfxDocumentTemplates::DeleteObjectShell(sal_uInt16, sal_uInt16)>
1567 */
1568 
1569 {
1570     DocTemplLocker_Impl aLocker( *pImp );
1571 
1572     if ( !pImp->Construct() )
1573         return NULL;
1574 
1575     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
1576     DocTempl_EntryData_Impl *pEntry = NULL;
1577 
1578     if ( pRegion )
1579         pEntry = pRegion->GetEntry( nIdx );
1580 
1581     if ( pEntry )
1582         return pEntry->CreateObjectShell();
1583     else
1584         return NULL;
1585 }
1586 
1587 //------------------------------------------------------------------------
1588 
DeleteObjectShell(sal_uInt16 nRegion,sal_uInt16 nIdx)1589 sal_Bool SfxDocumentTemplates::DeleteObjectShell
1590 (
1591     sal_uInt16 nRegion,         //  Index des Bereiches
1592     sal_uInt16 nIdx             //  Index des Eintrags
1593 )
1594 
1595 /*  [Beschreibung]
1596 
1597     Freigeben der ObjectShell eines Eintrags
1598 
1599 
1600     [R"uckgabewert]
1601 
1602     sal_Bool                            sal_True
1603                                     Aktion konnte ausgef"uhrt werden
1604 
1605                                     sal_False
1606                                     Aktion konnte nicht ausgef"uhrt werden
1607 
1608     [Querverweise]
1609 
1610     <SfxTemplateDirEntry::DeleteObjectShell()>
1611     <SfxDocumentTemplates::CreateObjectShell(sal_uInt16, sal_uInt16)>
1612 */
1613 
1614 {
1615     DocTemplLocker_Impl aLocker( *pImp );
1616 
1617     if ( ! pImp->Construct() )
1618         return sal_True;
1619 
1620     RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
1621     DocTempl_EntryData_Impl *pEntry = NULL;
1622 
1623     if ( pRegion )
1624         pEntry = pRegion->GetEntry( nIdx );
1625 
1626     if ( pEntry )
1627         return pEntry->DeleteObjectShell();
1628     else
1629         return sal_True;
1630 }
1631 
1632 //------------------------------------------------------------------------
1633 
GetFull(const String & rRegion,const String & rName,String & rPath)1634 sal_Bool SfxDocumentTemplates::GetFull
1635 (
1636     const String &rRegion,      // Der Name des Bereiches
1637     const String &rName,        // Der Name der Vorlage
1638     String &rPath               // Out: Pfad + Dateiname
1639 )
1640 
1641 /*  [Beschreibung]
1642 
1643     Liefert Pfad + Dateiname zu der durch rRegion und rName bezeichneten
1644     Vorlage
1645 
1646 
1647     [R"uckgabewert]
1648 
1649     sal_Bool                            sal_True
1650                                     Aktion konnte ausgef"uhrt werden
1651 
1652                                     sal_False
1653                                     Aktion konnte nicht ausgef"uhrt werden
1654 
1655 
1656     [Querverweise]
1657 
1658     <SfxDocumentTemplates::GetLogicNames(const String&,String&,String&)>
1659 */
1660 
1661 {
1662     DocTemplLocker_Impl aLocker( *pImp );
1663 
1664     // We don't search for empty names!
1665     if ( ! rName.Len() )
1666         return sal_False;
1667 
1668     if ( ! pImp->Construct() )
1669         return sal_False;
1670 
1671     DocTempl_EntryData_Impl* pEntry = NULL;
1672     const sal_uInt16 nCount = GetRegionCount();
1673 
1674     for ( sal_uInt16 i = 0; i < nCount; ++i )
1675     {
1676         RegionData_Impl *pRegion = pImp->GetRegion( i );
1677 
1678         if( pRegion &&
1679             ( !rRegion.Len() || ( rRegion == String( pRegion->GetTitle() ) ) ) )
1680         {
1681             pEntry = pRegion->GetEntry( rName );
1682 
1683             if ( pEntry )
1684             {
1685                 rPath = pEntry->GetTargetURL();
1686                 break;
1687             }
1688         }
1689     }
1690 
1691     return ( pEntry != NULL );
1692 }
1693 
1694 //------------------------------------------------------------------------
1695 
GetLogicNames(const String & rPath,String & rRegion,String & rName) const1696 sal_Bool SfxDocumentTemplates::GetLogicNames
1697 (
1698     const String &rPath,            // vollst"andiger Pfad zu der Vorlage
1699     String &rRegion,                // Out: der Bereichsname
1700     String &rName                   // Out: der Vorlagenname
1701 ) const
1702 
1703 /*  [Beschreibung]
1704 
1705     Liefert Pfad und logischen Namen zu der durch rPath bezeichneten
1706     Vorlage
1707 
1708     [R"uckgabewert]
1709 
1710     sal_Bool                            sal_True
1711                                     Aktion konnte ausgef"uhrt werden
1712 
1713                                     sal_False
1714                                     Aktion konnte nicht ausgef"uhrt werden
1715 
1716 
1717     [Querverweise]
1718 
1719     <SfxDocumentTemplates::GetFull(const String&,const String&,DirEntry&)>
1720 */
1721 
1722 {
1723     DocTemplLocker_Impl aLocker( *pImp );
1724 
1725     if ( ! pImp->Construct() )
1726         return sal_False;
1727 
1728     INetURLObject aFullPath;
1729 
1730     aFullPath.SetSmartProtocol( INET_PROT_FILE );
1731     aFullPath.SetURL( rPath );
1732     OUString aPath( aFullPath.GetMainURL( INetURLObject::NO_DECODE ) );
1733 
1734     RegionData_Impl *pData = NULL;
1735     DocTempl_EntryData_Impl  *pEntry = NULL;
1736     sal_Bool         bFound = sal_False;
1737 
1738     sal_uIntPtr nCount = GetRegionCount();
1739 
1740     for ( sal_uIntPtr i=0; !bFound && (i<nCount); i++ )
1741     {
1742         pData = pImp->GetRegion( i );
1743         if ( pData )
1744         {
1745             sal_uIntPtr nChildCount = pData->GetCount();
1746 
1747             for ( sal_uIntPtr j=0; !bFound && (j<nChildCount); j++ )
1748             {
1749                 pEntry = pData->GetEntry( j );
1750                 if ( pEntry->GetTargetURL() == aPath )
1751                 {
1752                     bFound = sal_True;
1753                 }
1754             }
1755         }
1756     }
1757 
1758     if ( bFound )
1759     {
1760         rRegion = pData->GetTitle();
1761         rName = pEntry->GetTitle();
1762     }
1763 
1764     return bFound;
1765 }
1766 
1767 //------------------------------------------------------------------------
1768 
SfxDocumentTemplates()1769 SfxDocumentTemplates::SfxDocumentTemplates()
1770 
1771 /*  [Beschreibung]
1772 
1773     Konstruktor
1774 */
1775 {
1776     if ( !gpTemplateData )
1777         gpTemplateData = new SfxDocTemplate_Impl;
1778 
1779     pImp = gpTemplateData;
1780 }
1781 
1782 //-------------------------------------------------------------------------
1783 
Construct()1784 void SfxDocumentTemplates::Construct()
1785 
1786 //  verz"ogerter Aufbau der Verwaltungsdaten
1787 
1788 {
1789 //  pImp->Construct();
1790 }
1791 
1792 //------------------------------------------------------------------------
1793 
~SfxDocumentTemplates()1794 SfxDocumentTemplates::~SfxDocumentTemplates()
1795 
1796 /*  [Beschreibung]
1797 
1798     Destruktor
1799     Freigeben der Verwaltungsdaten
1800 */
1801 
1802 {
1803     pImp = NULL;
1804 }
1805 
Update(sal_Bool _bSmart)1806 void SfxDocumentTemplates::Update( sal_Bool _bSmart )
1807 {
1808     if  (   !_bSmart                                                // don't be smart
1809         ||  ::svt::TemplateFolderCache( sal_True ).needsUpdate()    // update is really necessary
1810         )
1811     {
1812         if ( pImp->Construct() )
1813             pImp->Rescan();
1814     }
1815 }
1816 
ReInitFromComponent()1817 void SfxDocumentTemplates::ReInitFromComponent()
1818 {
1819     pImp->ReInitFromComponent();
1820 }
1821 
1822 
HasUserContents(sal_uInt16 nRegion,sal_uInt16 nIdx) const1823 sal_Bool SfxDocumentTemplates::HasUserContents( sal_uInt16 nRegion, sal_uInt16 nIdx ) const
1824 {
1825     DocTemplLocker_Impl aLocker( *pImp );
1826 
1827     sal_Bool bResult = sal_False;
1828 
1829     RegionData_Impl* pRegion = pImp->GetRegion( nRegion );
1830 
1831     if ( pRegion )
1832     {
1833         ::rtl::OUString aRegionTargetURL = pRegion->GetTargetURL();
1834         if ( aRegionTargetURL.getLength() )
1835         {
1836             sal_uInt16 nLen = 0;
1837             sal_uInt16 nStartInd = 0;
1838 
1839             if( nIdx == USHRT_MAX )
1840             {
1841                 // this is a folder
1842                 // check whether there is at least one editable template
1843                 nLen = ( sal_uInt16 )pRegion->GetCount();
1844                 nStartInd = 0;
1845                 if ( nLen == 0 )
1846                     bResult = sal_True; // the writing part of empty folder with writing URL can be removed
1847             }
1848             else
1849             {
1850                 // this is a template
1851                 // check whether the template is inserted by user
1852                 nLen = 1;
1853                 nStartInd = nIdx;
1854             }
1855 
1856             for ( sal_uInt16 nInd = nStartInd; nInd < nStartInd + nLen; nInd++ )
1857             {
1858                 DocTempl_EntryData_Impl* pEntryData = pRegion->GetEntry( nInd );
1859                 if ( pEntryData )
1860                 {
1861                     ::rtl::OUString aEntryTargetURL = pEntryData->GetTargetURL();
1862                     if ( aEntryTargetURL.getLength()
1863                       && ::utl::UCBContentHelper::IsSubPath( aRegionTargetURL, aEntryTargetURL ) )
1864                     {
1865                         bResult = sal_True;
1866                         break;
1867                     }
1868                 }
1869             }
1870         }
1871     }
1872 
1873     return bResult;
1874 }
1875 
1876 // -----------------------------------------------------------------------
1877 // -----------------------------------------------------------------------
1878 // -----------------------------------------------------------------------
DocTempl_EntryData_Impl(RegionData_Impl * pParent,const OUString & rTitle)1879 DocTempl_EntryData_Impl::DocTempl_EntryData_Impl( RegionData_Impl* pParent,
1880                                 const OUString& rTitle )
1881 {
1882     mpParent    = pParent;
1883     maTitle     = rTitle;
1884     mbIsOwner   = sal_False;
1885     mbDidConvert= sal_False;
1886 }
1887 
1888 // -----------------------------------------------------------------------
Compare(const OUString & rTitle) const1889 int DocTempl_EntryData_Impl::Compare( const OUString& rTitle ) const
1890 {
1891     return maTitle.compareTo( rTitle );
1892 }
1893 
1894 //------------------------------------------------------------------------
CreateObjectShell()1895 SfxObjectShellRef DocTempl_EntryData_Impl::CreateObjectShell()
1896 {
1897     if( ! mxObjShell.Is() )
1898     {
1899         mbIsOwner = sal_False;
1900         sal_Bool bDum = sal_False;
1901         SfxApplication *pSfxApp = SFX_APP();
1902         String          aTargetURL = GetTargetURL();
1903 
1904         mxObjShell = pSfxApp->DocAlreadyLoaded( aTargetURL, sal_True, bDum );
1905 
1906         if( ! mxObjShell.Is() )
1907         {
1908             mbIsOwner = sal_True;
1909             SfxMedium *pMed=new SfxMedium(
1910                 aTargetURL,(STREAM_STD_READWRITE | STREAM_SHARE_DENYALL),  sal_False, 0 );
1911             const SfxFilter* pFilter = NULL;
1912             pMed->UseInteractionHandler(sal_True);
1913             if( pSfxApp->GetFilterMatcher().GuessFilter(
1914                 *pMed, &pFilter, SFX_FILTER_TEMPLATE, 0 ) ||
1915                 (pFilter && !pFilter->IsOwnFormat()) ||
1916                 (pFilter && !pFilter->UsesStorage()) )
1917             {
1918                 SfxErrorContext aEc( ERRCTX_SFX_LOADTEMPLATE,
1919                                      aTargetURL );
1920                 delete pMed;
1921                 mbDidConvert=sal_True;
1922                 sal_uIntPtr lErr;
1923                 if ( mxObjShell.Is() ) {
1924                     lErr = pSfxApp->LoadTemplate( mxObjShell,aTargetURL);
1925                     if( lErr != ERRCODE_NONE )
1926                         ErrorHandler::HandleError(lErr);
1927                 }
1928 
1929             }
1930             else if (pFilter)
1931             {
1932                 mbDidConvert=sal_False;
1933                 mxObjShell = SfxObjectShell::CreateObject( pFilter->GetServiceName(), SFX_CREATE_MODE_ORGANIZER );
1934                 if ( mxObjShell.Is() )
1935                 {
1936                     mxObjShell->DoInitNew(0);
1937                     // TODO/LATER: make sure that we don't use binary templates!
1938                     if( mxObjShell->LoadFrom( *pMed ) )
1939                     {
1940                         mxObjShell->DoSaveCompleted( pMed );
1941                     }
1942                     else
1943                         mxObjShell.Clear();
1944                 }
1945             }
1946         }
1947     }
1948 
1949     return (SfxObjectShellRef)(SfxObjectShell*) mxObjShell;
1950 }
1951 
1952 //------------------------------------------------------------------------
DeleteObjectShell()1953 sal_Bool DocTempl_EntryData_Impl::DeleteObjectShell()
1954 {
1955     sal_Bool bRet = sal_True;
1956 
1957     if ( mxObjShell.Is() )
1958     {
1959         if( mxObjShell->IsModified() )
1960         {
1961             //Hier speichern wir auch, falls die Vorlage in Bearbeitung ist...
1962             bRet = sal_False;
1963 
1964             if ( mbIsOwner )
1965             {
1966                 if( mbDidConvert )
1967                 {
1968                     bRet=mxObjShell->PreDoSaveAs_Impl(
1969                         GetTargetURL(),
1970                         mxObjShell->GetFactory().GetFilterContainer()->GetAnyFilter( SFX_FILTER_EXPORT | SFX_FILTER_IMPORT, SFX_FILTER_INTERNAL )->GetFilterName(), 0 );
1971                 }
1972                 else
1973                 {
1974                     if( mxObjShell->Save() )
1975                     {
1976                         uno::Reference< embed::XTransactedObject > xTransacted( mxObjShell->GetStorage(), uno::UNO_QUERY );
1977                         DBG_ASSERT( xTransacted.is(), "Storage must implement XTransactedObject!\n" );
1978                         if ( xTransacted.is() )
1979                         {
1980                             try
1981                             {
1982                                 xTransacted->commit();
1983                                 bRet = sal_True;
1984                             }
1985                             catch( uno::Exception& )
1986                             {
1987                             }
1988                         }
1989                     }
1990                 }
1991             }
1992         }
1993 
1994         if( bRet )
1995         {
1996             mxObjShell.Clear();
1997         }
1998     }
1999     return bRet;
2000 }
2001 
2002 // -----------------------------------------------------------------------
GetHierarchyURL()2003 const OUString& DocTempl_EntryData_Impl::GetHierarchyURL()
2004 {
2005     if ( !maOwnURL.getLength() )
2006     {
2007         INetURLObject aTemplateObj( GetParent()->GetHierarchyURL() );
2008 
2009         aTemplateObj.insertName( GetTitle(), false,
2010                      INetURLObject::LAST_SEGMENT, true,
2011                      INetURLObject::ENCODE_ALL );
2012 
2013         maOwnURL = aTemplateObj.GetMainURL( INetURLObject::NO_DECODE );
2014         DBG_ASSERT( maOwnURL.getLength(), "GetHierarchyURL(): Could not create URL!" );
2015     }
2016 
2017     return maOwnURL;
2018 }
2019 
2020 // -----------------------------------------------------------------------
GetTargetURL()2021 const OUString& DocTempl_EntryData_Impl::GetTargetURL()
2022 {
2023     if ( !maTargetURL.getLength() )
2024     {
2025         uno::Reference< XCommandEnvironment > aCmdEnv;
2026         Content aRegion;
2027 
2028         if ( Content::create( GetHierarchyURL(), aCmdEnv, aRegion ) )
2029         {
2030             OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_URL ) );
2031 
2032             getTextProperty_Impl( aRegion, aPropName, maTargetURL );
2033         }
2034         else
2035         {
2036             DBG_ERRORFILE( "GetTargetURL(): Could not create hierarchy content!" );
2037         }
2038     }
2039 
2040     return maTargetURL;
2041 }
2042 
2043 // -----------------------------------------------------------------------
2044 // -----------------------------------------------------------------------
2045 // -----------------------------------------------------------------------
2046 // -----------------------------------------------------------------------
RegionData_Impl(const SfxDocTemplate_Impl * pParent,const OUString & rTitle)2047 RegionData_Impl::RegionData_Impl( const SfxDocTemplate_Impl* pParent,
2048                                   const OUString& rTitle )
2049 {
2050     maTitle     = rTitle;
2051     mpParent    = pParent;
2052 }
2053 
2054 // -----------------------------------------------------------------------
~RegionData_Impl()2055 RegionData_Impl::~RegionData_Impl()
2056 {
2057     DocTempl_EntryData_Impl *pData = maEntries.First();
2058 
2059     while ( pData )
2060     {
2061         delete pData;
2062         pData = maEntries.Next();
2063     }
2064 }
2065 
2066 // -----------------------------------------------------------------------
GetEntryPos(const OUString & rTitle,sal_Bool & rFound) const2067 long RegionData_Impl::GetEntryPos( const OUString& rTitle,
2068                                    sal_Bool& rFound ) const
2069 {
2070 #if 1   // Don't use binary search today
2071     sal_uIntPtr i;
2072     sal_uIntPtr nCount = maEntries.Count();
2073 
2074     for ( i=0; i<nCount; i++ )
2075     {
2076         DocTempl_EntryData_Impl *pData = maEntries.GetObject( i );
2077 
2078         if ( pData->Compare( rTitle ) == 0 )
2079         {
2080             rFound = sal_True;
2081             return i;
2082         }
2083     }
2084 
2085     rFound = sal_False;
2086     return i;
2087 
2088 #else
2089     // use binary search to find the correct position
2090     // in the maEntries list
2091 
2092     int     nCompVal = 1;
2093     long    nStart = 0;
2094     long    nEnd = maEntries.Count() - 1;
2095     long    nMid;
2096 
2097     DocTempl_EntryData_Impl* pMid;
2098 
2099     rFound = sal_False;
2100 
2101     while ( nCompVal && ( nStart <= nEnd ) )
2102     {
2103         nMid = ( nEnd - nStart ) / 2 + nStart;
2104         pMid = maEntries.GetObject( nMid );
2105 
2106         nCompVal = pMid->Compare( rTitle );
2107 
2108         if ( nCompVal < 0 )     // pMid < pData
2109             nStart = nMid + 1;
2110         else
2111             nEnd = nMid - 1;
2112     }
2113 
2114     if ( nCompVal == 0 )
2115     {
2116         rFound = sal_True;
2117     }
2118     else
2119     {
2120         if ( nCompVal < 0 )     // pMid < pData
2121             nMid++;
2122     }
2123 
2124     return nMid;
2125 #endif
2126 }
2127 
2128 // -----------------------------------------------------------------------
AddEntry(const OUString & rTitle,const OUString & rTargetURL,sal_uInt16 * pPos)2129 void RegionData_Impl::AddEntry( const OUString& rTitle,
2130                                 const OUString& rTargetURL,
2131                                 sal_uInt16 *pPos )
2132 {
2133     INetURLObject aLinkObj( GetHierarchyURL() );
2134     aLinkObj.insertName( rTitle, false,
2135                       INetURLObject::LAST_SEGMENT, true,
2136                       INetURLObject::ENCODE_ALL );
2137     OUString aLinkURL = aLinkObj.GetMainURL( INetURLObject::NO_DECODE );
2138 
2139     DocTempl_EntryData_Impl *pEntry;
2140     sal_Bool        bFound = sal_False;
2141     long            nPos = GetEntryPos( rTitle, bFound );
2142 
2143     if ( bFound )
2144     {
2145         pEntry = maEntries.GetObject( nPos );
2146     }
2147     else
2148     {
2149         if ( pPos )
2150             nPos = *pPos;
2151 
2152         pEntry = new DocTempl_EntryData_Impl( this, rTitle );
2153         pEntry->SetTargetURL( rTargetURL );
2154         pEntry->SetHierarchyURL( aLinkURL );
2155         maEntries.Insert( pEntry, nPos );
2156     }
2157 }
2158 
2159 // -----------------------------------------------------------------------
GetCount() const2160 sal_uIntPtr RegionData_Impl::GetCount() const
2161 {
2162     return maEntries.Count();
2163 }
2164 
2165 // -----------------------------------------------------------------------
GetHierarchyURL()2166 const OUString& RegionData_Impl::GetHierarchyURL()
2167 {
2168     if ( !maOwnURL.getLength() )
2169     {
2170         INetURLObject aRegionObj( GetParent()->GetRootURL() );
2171 
2172         aRegionObj.insertName( GetTitle(), false,
2173                      INetURLObject::LAST_SEGMENT, true,
2174                      INetURLObject::ENCODE_ALL );
2175 
2176         maOwnURL = aRegionObj.GetMainURL( INetURLObject::NO_DECODE );
2177         DBG_ASSERT( maOwnURL.getLength(), "GetHierarchyURL(): Could not create URL!" );
2178     }
2179 
2180     return maOwnURL;
2181 }
2182 
2183 // -----------------------------------------------------------------------
GetTargetURL()2184 const OUString& RegionData_Impl::GetTargetURL()
2185 {
2186     if ( !maTargetURL.getLength() )
2187     {
2188         uno::Reference< XCommandEnvironment > aCmdEnv;
2189         Content aRegion;
2190 
2191         if ( Content::create( GetHierarchyURL(), aCmdEnv, aRegion ) )
2192         {
2193             OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TARGET_DIR_URL ) );
2194 
2195             getTextProperty_Impl( aRegion, aPropName, maTargetURL );
2196             // --> PB 2004-10-27 #i32656# - the targeturl must be substituted: $(baseinsturl)
2197             maTargetURL = SvtPathOptions().SubstituteVariable( maTargetURL );
2198             // <--
2199         }
2200         else
2201         {
2202             DBG_ERRORFILE( "GetTargetURL(): Could not create hierarchy content!" );
2203         }
2204     }
2205 
2206     return maTargetURL;
2207 }
2208 
2209 // -----------------------------------------------------------------------
GetEntry(const OUString & rName) const2210 DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( const OUString& rName ) const
2211 {
2212     sal_Bool    bFound = sal_False;
2213     long        nPos = GetEntryPos( rName, bFound );
2214 
2215     if ( bFound )
2216         return maEntries.GetObject( nPos );
2217     else
2218         return NULL;
2219 }
2220 
2221 // -----------------------------------------------------------------------
GetByTargetURL(const OUString & rName) const2222 DocTempl_EntryData_Impl* RegionData_Impl::GetByTargetURL( const OUString& rName ) const
2223 {
2224     DocTempl_EntryData_Impl *pEntry;
2225 
2226     sal_uIntPtr nCount = maEntries.Count();
2227 
2228     for ( sal_uIntPtr i=0; i<nCount; i++ )
2229     {
2230         pEntry = maEntries.GetObject( i );
2231         if ( pEntry && ( pEntry->GetTargetURL() == rName ) )
2232             return pEntry;
2233     }
2234 
2235     return NULL;
2236 }
2237 
2238 // -----------------------------------------------------------------------
GetEntry(sal_uIntPtr nIndex) const2239 DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( sal_uIntPtr nIndex ) const
2240 {
2241     return maEntries.GetObject( nIndex );
2242 }
2243 
2244 // -----------------------------------------------------------------------
DeleteEntry(sal_uIntPtr nIndex)2245 void RegionData_Impl::DeleteEntry( sal_uIntPtr nIndex )
2246 {
2247     DocTempl_EntryData_Impl *pEntry = maEntries.GetObject( nIndex );
2248 
2249     if ( pEntry )
2250     {
2251         delete pEntry;
2252         maEntries.Remove( (sal_uIntPtr) nIndex );
2253     }
2254 }
2255 
2256 // -----------------------------------------------------------------------
Compare(RegionData_Impl * pCompare) const2257 int RegionData_Impl::Compare( RegionData_Impl* pCompare ) const
2258 {
2259     int nCompare = maTitle.compareTo( pCompare->maTitle );
2260 
2261     return nCompare;
2262 }
2263 
2264 // -----------------------------------------------------------------------
2265 // -----------------------------------------------------------------------
2266 // -----------------------------------------------------------------------
2267 
SfxDocTemplate_Impl()2268 SfxDocTemplate_Impl::SfxDocTemplate_Impl()
2269 : mbConstructed( sal_False )
2270 , mnLockCounter( 0 )
2271 {
2272 }
2273 
2274 // -----------------------------------------------------------------------
~SfxDocTemplate_Impl()2275 SfxDocTemplate_Impl::~SfxDocTemplate_Impl()
2276 {
2277     Clear();
2278 
2279     gpTemplateData = NULL;
2280 }
2281 
2282 // -----------------------------------------------------------------------
IncrementLock()2283 void SfxDocTemplate_Impl::IncrementLock()
2284 {
2285     ::osl::MutexGuard aGuard( maMutex );
2286     mnLockCounter++;
2287 }
2288 
2289 // -----------------------------------------------------------------------
DecrementLock()2290 void SfxDocTemplate_Impl::DecrementLock()
2291 {
2292     ::osl::MutexGuard aGuard( maMutex );
2293     if ( mnLockCounter )
2294         mnLockCounter--;
2295 }
2296 
2297 // -----------------------------------------------------------------------
GetRegion(sal_uIntPtr nIndex) const2298 RegionData_Impl* SfxDocTemplate_Impl::GetRegion( sal_uIntPtr nIndex ) const
2299 {
2300     return maRegions.GetObject( nIndex );
2301 }
2302 
2303 // -----------------------------------------------------------------------
GetRegion(const OUString & rName) const2304 RegionData_Impl* SfxDocTemplate_Impl::GetRegion( const OUString& rName )
2305     const
2306 {
2307     sal_uIntPtr nCount = maRegions.Count();
2308     RegionData_Impl *pData;
2309 
2310     for ( sal_uIntPtr i=0; i<nCount; i++ )
2311     {
2312         pData = maRegions.GetObject( i );
2313 
2314         if ( pData->GetTitle() == rName )
2315             return pData;
2316     }
2317 
2318     return NULL;
2319 }
2320 
2321 // -----------------------------------------------------------------------
DeleteRegion(sal_uIntPtr nIndex)2322 void SfxDocTemplate_Impl::DeleteRegion( sal_uIntPtr nIndex )
2323 {
2324     RegionData_Impl* pRegion = maRegions.GetObject( nIndex );
2325 
2326     if ( pRegion )
2327     {
2328         delete pRegion;
2329         maRegions.Remove( (sal_uIntPtr) nIndex );
2330     }
2331 }
2332 
2333 // -----------------------------------------------------------------------
2334 /*  AddRegion adds a Region to the RegionList
2335 */
AddRegion(const OUString & rTitle,Content & rContent)2336 void SfxDocTemplate_Impl::AddRegion( const OUString& rTitle,
2337                                      Content& rContent )
2338 {
2339     RegionData_Impl* pRegion;
2340     pRegion = new RegionData_Impl( this, rTitle );
2341 
2342     if ( ! InsertRegion( pRegion ) )
2343     {
2344         delete pRegion;
2345         return;
2346     }
2347 
2348     // now get the content of the region
2349     uno::Reference< XResultSet > xResultSet;
2350     Sequence< OUString > aProps(2);
2351     aProps[0] = OUString::createFromAscii( TITLE );
2352     aProps[1] = OUString::createFromAscii( TARGET_URL );
2353 
2354     try
2355     {
2356         ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
2357         Sequence< NumberedSortingInfo >     aSortingInfo(1);
2358         aSortingInfo.getArray()->ColumnIndex = 1;
2359         aSortingInfo.getArray()->Ascending = sal_True;
2360         xResultSet = rContent.createSortedCursor( aProps, aSortingInfo, m_rCompareFactory, eInclude );
2361     }
2362     catch ( Exception& ) {}
2363 
2364     if ( xResultSet.is() )
2365     {
2366         uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2367         uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2368 
2369         try
2370         {
2371             while ( xResultSet->next() )
2372             {
2373                 OUString aTitle( xRow->getString( 1 ) );
2374                 OUString aTargetDir( xRow->getString( 2 ) );
2375 
2376                 pRegion->AddEntry( aTitle, aTargetDir );
2377             }
2378         }
2379         catch ( Exception& ) {}
2380     }
2381 }
2382 
2383 // -----------------------------------------------------------------------
CreateFromHierarchy(Content & rTemplRoot)2384 void SfxDocTemplate_Impl::CreateFromHierarchy( Content &rTemplRoot )
2385 {
2386     uno::Reference< XResultSet > xResultSet;
2387     Sequence< OUString > aProps(1);
2388     aProps[0] = OUString::createFromAscii( TITLE );
2389 
2390     try
2391     {
2392         ResultSetInclude eInclude = INCLUDE_FOLDERS_ONLY;
2393         Sequence< NumberedSortingInfo >     aSortingInfo(1);
2394         aSortingInfo.getArray()->ColumnIndex = 1;
2395         aSortingInfo.getArray()->Ascending = sal_True;
2396         xResultSet = rTemplRoot.createSortedCursor( aProps, aSortingInfo, m_rCompareFactory, eInclude );
2397     }
2398     catch ( Exception& ) {}
2399 
2400     if ( xResultSet.is() )
2401     {
2402         uno::Reference< XCommandEnvironment > aCmdEnv;
2403         uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2404         uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2405 
2406         try
2407         {
2408             while ( xResultSet->next() )
2409             {
2410                 OUString aTitle( xRow->getString( 1 ) );
2411 
2412                 OUString aId = xContentAccess->queryContentIdentifierString();
2413                 Content  aContent = Content( aId, aCmdEnv );
2414 
2415                 AddRegion( aTitle, aContent );
2416             }
2417         }
2418         catch ( Exception& ) {}
2419     }
2420 }
2421 
2422 // ------------------------------------------------------------------------
Construct()2423 sal_Bool SfxDocTemplate_Impl::Construct( )
2424 {
2425     ::osl::MutexGuard aGuard( maMutex );
2426 
2427     if ( mbConstructed )
2428         return sal_True;
2429 
2430     uno::Reference< XMultiServiceFactory >   xFactory;
2431     xFactory = ::comphelper::getProcessServiceFactory();
2432 
2433     OUString aService( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_DOCINFO ) );
2434     uno::Reference< XPersist > xInfo( xFactory->createInstance( aService ), UNO_QUERY );
2435     mxInfo = xInfo;
2436 
2437     aService = OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_DOCTEMPLATES ) );
2438     uno::Reference< XDocumentTemplates > xTemplates( xFactory->createInstance( aService ), UNO_QUERY );
2439 
2440     if ( xTemplates.is() )
2441         mxTemplates = xTemplates;
2442     else
2443         return sal_False;
2444 
2445     uno::Reference< XLocalizable > xLocalizable( xTemplates, UNO_QUERY );
2446 
2447     Sequence< Any > aCompareArg(1);
2448     *(aCompareArg.getArray()) <<= xLocalizable->getLocale();;
2449     m_rCompareFactory = uno::Reference< XAnyCompareFactory >(
2450                     xFactory->createInstanceWithArguments( OUString::createFromAscii( "com.sun.star.ucb.AnyCompareFactory" ),
2451                                                            aCompareArg ),
2452                     UNO_QUERY );
2453 
2454     uno::Reference < XContent > aRootContent = xTemplates->getContent();
2455     uno::Reference < XCommandEnvironment > aCmdEnv;
2456 
2457     if ( ! aRootContent.is() )
2458         return sal_False;
2459 
2460     mbConstructed = sal_True;
2461     maRootURL = aRootContent->getIdentifier()->getContentIdentifier();
2462 
2463     ResStringArray  aLongNames( SfxResId( TEMPLATE_LONG_NAMES_ARY ) );
2464 
2465     if ( aLongNames.Count() )
2466         maStandardGroup = aLongNames.GetString( 0 );
2467 
2468     Content aTemplRoot( aRootContent, aCmdEnv );
2469     CreateFromHierarchy( aTemplRoot );
2470 
2471     return sal_True;
2472 }
2473 
2474 // -----------------------------------------------------------------------
ReInitFromComponent()2475 void SfxDocTemplate_Impl::ReInitFromComponent()
2476 {
2477     uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates();
2478     if ( xTemplates.is() )
2479     {
2480         uno::Reference < XContent > aRootContent = xTemplates->getContent();
2481         uno::Reference < XCommandEnvironment > aCmdEnv;
2482         Content aTemplRoot( aRootContent, aCmdEnv );
2483         Clear();
2484         CreateFromHierarchy( aTemplRoot );
2485     }
2486 }
2487 
2488 // -----------------------------------------------------------------------
GetTemplates(Content & rTargetFolder,Content &,RegionData_Impl * pRegion)2489 void SfxDocTemplate_Impl::GetTemplates( Content& rTargetFolder,
2490                                         Content& /*rParentFolder*/,
2491                                         RegionData_Impl* pRegion )
2492 {
2493     uno::Reference< XResultSet > xResultSet;
2494     Sequence< OUString >    aProps(1);
2495 
2496     aProps[0] = OUString::createFromAscii( TITLE );
2497 
2498     try
2499     {
2500         ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
2501         Sequence< NumberedSortingInfo >     aSortingInfo(1);
2502         aSortingInfo.getArray()->ColumnIndex = 1;
2503         aSortingInfo.getArray()->Ascending = sal_True;
2504         xResultSet = rTargetFolder.createSortedCursor( aProps, aSortingInfo, m_rCompareFactory, eInclude );
2505     }
2506     catch ( Exception& ) {}
2507 
2508     if ( xResultSet.is() )
2509     {
2510         uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
2511         uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
2512 
2513         try
2514         {
2515             while ( xResultSet->next() )
2516             {
2517                 OUString aTitle( xRow->getString(1) );
2518 
2519                 if ( aTitle.compareToAscii( "sfx.tlx" ) == 0 )
2520                     continue;
2521 
2522                 OUString aId = xContentAccess->queryContentIdentifierString();
2523 
2524                 DocTempl_EntryData_Impl* pEntry = pRegion->GetByTargetURL( aId );
2525 
2526                 if ( ! pEntry )
2527                 {
2528                     OUString aFullTitle;
2529                     if( !GetTitleFromURL( aId, aFullTitle ) )
2530                     {
2531                         DBG_ERRORFILE( "GetTemplates(): template of alien format" );
2532                         continue;
2533                     }
2534 
2535                     if ( aFullTitle.getLength() )
2536                         aTitle = aFullTitle;
2537 
2538                     pRegion->AddEntry( aTitle, aId );
2539                 }
2540             }
2541         }
2542         catch ( Exception& ) {}
2543     }
2544 }
2545 
2546 
2547 // -----------------------------------------------------------------------
GetRegionPos(const OUString & rTitle,sal_Bool & rFound) const2548 long SfxDocTemplate_Impl::GetRegionPos( const OUString& rTitle,
2549                                         sal_Bool& rFound ) const
2550 {
2551     int     nCompVal = 1;
2552     long    nStart = 0;
2553     long    nEnd = maRegions.Count() - 1;
2554     long    nMid = 0;
2555 
2556     RegionData_Impl* pMid;
2557 
2558     while ( nCompVal && ( nStart <= nEnd ) )
2559     {
2560         nMid = ( nEnd - nStart ) / 2 + nStart;
2561         pMid = maRegions.GetObject( nMid );
2562 
2563         nCompVal = pMid->Compare( rTitle );
2564 
2565         if ( nCompVal < 0 )     // pMid < pData
2566             nStart = nMid + 1;
2567         else
2568             nEnd = nMid - 1;
2569     }
2570 
2571     if ( nCompVal == 0 )
2572         rFound = sal_True;
2573     else
2574     {
2575         if ( nCompVal < 0 )     // pMid < pData
2576             nMid++;
2577 
2578         rFound = sal_False;
2579     }
2580 
2581     return nMid;
2582 }
2583 
2584 // -----------------------------------------------------------------------
InsertRegion(RegionData_Impl * pNew,sal_uIntPtr nPos)2585 sal_Bool SfxDocTemplate_Impl::InsertRegion( RegionData_Impl *pNew,
2586                                             sal_uIntPtr nPos )
2587 {
2588     ::osl::MutexGuard   aGuard( maMutex );
2589     RegionData_Impl    *pData = maRegions.First();
2590 
2591     while ( pData && ( pData->Compare( pNew ) != 0 ) )
2592         pData = maRegions.Next();
2593 
2594     if ( ! pData )
2595     {
2596         // compare with the name of the standard group here to insert it
2597         // first
2598 
2599         if ( pNew->GetTitle() == maStandardGroup )
2600             maRegions.Insert( pNew, (sal_uIntPtr) 0 );
2601         else
2602             maRegions.Insert( pNew, nPos );
2603     }
2604 
2605     return ( pData == NULL );
2606 }
2607 
2608 // -----------------------------------------------------------------------
Rescan()2609 void SfxDocTemplate_Impl::Rescan()
2610 {
2611     Clear();
2612 
2613     try
2614     {
2615         uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates();
2616         DBG_ASSERT( xTemplates.is(), "SfxDocTemplate_Impl::Rescan:invalid template instance!" );
2617         if ( xTemplates.is() )
2618         {
2619             xTemplates->update();
2620 
2621             uno::Reference < XContent > aRootContent = xTemplates->getContent();
2622             uno::Reference < XCommandEnvironment > aCmdEnv;
2623 
2624             Content aTemplRoot( aRootContent, aCmdEnv );
2625             CreateFromHierarchy( aTemplRoot );
2626         }
2627     }
2628     catch( const Exception& )
2629     {
2630         DBG_ERRORFILE( "SfxDocTemplate_Impl::Rescan: caught an exception while doing the update!" );
2631     }
2632 }
2633 
2634 // -----------------------------------------------------------------------
GetTitleFromURL(const OUString & rURL,OUString & aTitle)2635 sal_Bool SfxDocTemplate_Impl::GetTitleFromURL( const OUString& rURL,
2636                                            OUString& aTitle )
2637 {
2638     if ( mxInfo.is() )
2639     {
2640         try
2641         {
2642             mxInfo->read( rURL );
2643         }
2644         catch ( Exception& )
2645         {
2646             // the document is not a StarOffice document
2647             return sal_False;
2648         }
2649 
2650 
2651         try
2652         {
2653             uno::Reference< XPropertySet > aPropSet( mxInfo, UNO_QUERY );
2654             if ( aPropSet.is() )
2655             {
2656                 OUString aPropName( RTL_CONSTASCII_USTRINGPARAM( TITLE ) );
2657                 Any aValue = aPropSet->getPropertyValue( aPropName );
2658                 aValue >>= aTitle;
2659             }
2660         }
2661         catch ( IOException& ) {}
2662         catch ( UnknownPropertyException& ) {}
2663         catch ( Exception& ) {}
2664     }
2665 
2666     if ( ! aTitle.getLength() )
2667     {
2668         INetURLObject aURL( rURL );
2669         aURL.CutExtension();
2670         aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,
2671                                INetURLObject::DECODE_WITH_CHARSET );
2672     }
2673 
2674     return sal_True;
2675 }
2676 
2677 
2678 // -----------------------------------------------------------------------
Clear()2679 void SfxDocTemplate_Impl::Clear()
2680 {
2681     ::osl::MutexGuard   aGuard( maMutex );
2682     if ( mnLockCounter )
2683         return;
2684 
2685     RegionData_Impl *pRegData = maRegions.First();
2686 
2687     while ( pRegData )
2688     {
2689         delete pRegData;
2690         pRegData = maRegions.Next();
2691     }
2692 
2693     maRegions.Clear();
2694 }
2695 
2696 // -----------------------------------------------------------------------
2697 // -----------------------------------------------------------------------
2698 // -----------------------------------------------------------------------
getTextProperty_Impl(Content & rContent,const OUString & rPropName,OUString & rPropValue)2699 sal_Bool getTextProperty_Impl( Content& rContent,
2700                                const OUString& rPropName,
2701                                OUString& rPropValue )
2702 {
2703     sal_Bool bGotProperty = sal_False;
2704 
2705     // Get the property
2706     try
2707     {
2708         uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties();
2709 
2710         // check, whether or not the property exists
2711         if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) )
2712         {
2713             return sal_False;
2714         }
2715 
2716         // now get the property
2717         Any aAnyValue;
2718 
2719         aAnyValue = rContent.getPropertyValue( rPropName );
2720         aAnyValue >>= rPropValue;
2721 
2722         if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) )
2723         {
2724             SfxURLRelocator_Impl aRelocImpl( ::comphelper::getProcessServiceFactory() );
2725             aRelocImpl.makeAbsoluteURL( rPropValue );
2726         }
2727 
2728         bGotProperty = sal_True;
2729     }
2730     catch ( RuntimeException& ) {}
2731     catch ( Exception& ) {}
2732 
2733     return bGotProperty;
2734 }
2735 
2736