?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 4.2-24
[LibreOffice.git] / sfx2 / source / doc / doctempl.cxx
blobdd8f8afe562f11f2cee4b3e09cf6c87f90829fe7
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <limits.h>
22 #include <com/sun/star/uno/Any.h>
23 #include <osl/mutex.hxx>
24 #include <osl/thread.hxx>
25
26 #include <vcl/svapp.hxx>
27 #include <vcl/settings.hxx>
28 #include <unotools/localedatawrapper.hxx>
29 #include <unotools/pathoptions.hxx>
30 #include <tools/resary.hxx>
31 #include <tools/urlobj.hxx>
32 #include <svtools/ehdl.hxx>
33 #include <svtools/sfxecode.hxx>
34 #include <comphelper/processfactory.hxx>
35 #include <ucbhelper/content.hxx>
36 #include <com/sun/star/beans/PropertyAttribute.hpp>
37 #include <com/sun/star/beans/PropertyValue.hpp>
38 #include <com/sun/star/beans/XPropertyContainer.hpp>
39 #include <com/sun/star/beans/XPropertySet.hpp>
40 #include <com/sun/star/beans/XPropertySetInfo.hpp>
41 #include <com/sun/star/document/XTypeDetection.hpp>
42 #include <com/sun/star/document/DocumentProperties.hpp>
43 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
44 #include <com/sun/star/frame/Desktop.hpp>
45 #include <com/sun/star/frame/XComponentLoader.hpp>
46 #include <com/sun/star/frame/DocumentTemplates.hpp>
47 #include <com/sun/star/frame/XDocumentTemplates.hpp>
48 #include <com/sun/star/io/XInputStream.hpp>
49 #include <com/sun/star/io/XPersist.hpp>
50 #include <com/sun/star/lang/XLocalizable.hpp>
51 #include <com/sun/star/sdbc/XResultSet.hpp>
52 #include <com/sun/star/sdbc/XRow.hpp>
53 #include <com/sun/star/ucb/ContentInfo.hpp>
54 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
55 #include <com/sun/star/ucb/NameClash.hpp>
56 #include <com/sun/star/ucb/TransferInfo.hpp>
57 #include <com/sun/star/ucb/XCommandProcessor.hpp>
58 #include <com/sun/star/ucb/XContent.hpp>
59 #include <com/sun/star/ucb/XContentAccess.hpp>
60 #include <com/sun/star/ucb/AnyCompareFactory.hpp>
61 #include <com/sun/star/ucb/XAnyCompare.hpp>
62 #include <com/sun/star/ucb/NumberedSortingInfo.hpp>
63 #include <com/sun/star/embed/ElementModes.hpp>
64 #include <com/sun/star/embed/XTransactedObject.hpp>
65
66 #include "sfxurlrelocator.hxx"
67
68 using namespace ::com::sun::star;
69 using namespace ::com::sun::star::beans;
70 using namespace ::com::sun::star::frame;
71 using namespace ::com::sun::star::io;
72 using namespace ::com::sun::star::lang;
73 using namespace ::com::sun::star::sdbc;
74 using namespace ::com::sun::star::uno;
75 using namespace ::com::sun::star::ucb;
76 using namespace ::com::sun::star::document;
77 using namespace ::rtl;
78 using namespace ::ucbhelper;
79
80
81 #include <sfx2/doctempl.hxx>
82 #include <sfx2/docfac.hxx>
83 #include <sfx2/docfile.hxx>
84 #include <sfx2/objsh.hxx>
85 #include "sfxtypes.hxx"
86 #include <sfx2/app.hxx>
87 #include <sfx2/sfxresid.hxx>
88 #include <sfx2/templatelocnames.hrc>
89 #include "doc.hrc"
90 #include <sfx2/fcontnr.hxx>
91 #include <svtools/templatefoldercache.hxx>
92
93 #include <comphelper/storagehelper.hxx>
94 #include <unotools/ucbhelper.hxx>
95
96 #include <vector>
97 using ::std::vector;
98 using ::std::advance;
99
100 //========================================================================
101
102 #define TITLE "Title"
103 #define TARGET_URL "TargetURL"
104
105 #define COMMAND_TRANSFER "transfer"
106
107 //========================================================================
108
109 class RegionData_Impl;
110
111 namespace DocTempl {
112
113 class DocTempl_EntryData_Impl
114 {
115 RegionData_Impl* mpParent;
116
117 // the following member must be SfxObjectShellLock since it controlls that SfxObjectShell lifetime by design
118 // and users of this class expect it to be so.
119 SfxObjectShellLock mxObjShell;
120
121 OUString maTitle;
122 OUString maOwnURL;
123 OUString maTargetURL;
124 sal_Bool mbIsOwner : 1;
125 sal_Bool mbDidConvert: 1;
126
127 private:
128 RegionData_Impl* GetParent() const { return mpParent; }
129
130 public:
131 DocTempl_EntryData_Impl( RegionData_Impl* pParent,
132 const OUString& rTitle );
133
134 const OUString& GetTitle() const { return maTitle; }
135 const OUString& GetTargetURL();
136 const OUString& GetHierarchyURL();
137
138 void SetTitle( const OUString& rTitle ) { maTitle = rTitle; }
139 void SetTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
140 void SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; }
141
142 int Compare( const OUString& rTitle ) const;
143 };
144
145 }
146
147 using namespace ::DocTempl;
148
149 // ------------------------------------------------------------------------
150
151 class RegionData_Impl
152 {
153 const SfxDocTemplate_Impl* mpParent;
154 vector< DocTempl_EntryData_Impl* > maEntries;
155 OUString maTitle;
156 OUString maOwnURL;
157 OUString maTargetURL;
158
159 private:
160 size_t GetEntryPos( const OUString& rTitle,
161 sal_Bool& rFound ) const;
162 const SfxDocTemplate_Impl* GetParent() const { return mpParent; }
163
164 public:
165 RegionData_Impl( const SfxDocTemplate_Impl* pParent,
166 const OUString& rTitle );
167 ~RegionData_Impl();
168
169 void SetTargetURL( const OUString& rURL ) { maTargetURL = rURL; }
170 void SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; }
171
172 DocTempl_EntryData_Impl* GetEntry( size_t nIndex ) const;
173 DocTempl_EntryData_Impl* GetEntry( const OUString& rName ) const;
174
175 const OUString& GetTitle() const { return maTitle; }
176 const OUString& GetHierarchyURL();
177
178 size_t GetCount() const;
179
180 void SetTitle( const OUString& rTitle ) { maTitle = rTitle; }
181
182 void AddEntry( const OUString& rTitle,
183 const OUString& rTargetURL,
184 size_t *pPos = NULL );
185 void DeleteEntry( size_t nIndex );
186
187 int Compare( const OUString& rTitle ) const
188 { return maTitle.compareTo( rTitle ); }
189 int Compare( RegionData_Impl* pCompareWith ) const;
190 };
191
192 typedef vector< RegionData_Impl* > RegionList_Impl;
193
194 // ------------------------------------------------------------------------
195
196 class SfxDocTemplate_Impl : public SvRefBase
197 {
198 uno::Reference< XPersist > mxInfo;
199 uno::Reference< XDocumentTemplates > mxTemplates;
200
201 ::osl::Mutex maMutex;
202 OUString maRootURL;
203 OUString maStandardGroup;
204 RegionList_Impl maRegions;
205 sal_Bool mbConstructed;
206
207 uno::Reference< XAnyCompareFactory > m_rCompareFactory;
208
209 // the following member is intended to prevent clearing of the global data when it is in use
210 // TODO/LATER: it still does not make the implementation complete thread-safe
211 sal_Int32 mnLockCounter;
212
213 private:
214 void Clear();
215
216 public:
217 SfxDocTemplate_Impl();
218 ~SfxDocTemplate_Impl();
219
220 void IncrementLock();
221 void DecrementLock();
222
223 sal_Bool Construct( );
224 void CreateFromHierarchy( Content &rTemplRoot );
225 void ReInitFromComponent();
226 void AddRegion( const OUString& rTitle,
227 Content& rContent );
228
229 void Rescan();
230
231 void DeleteRegion( size_t nIndex );
232
233 size_t GetRegionCount() const
234 { return maRegions.size(); }
235 RegionData_Impl* GetRegion( const OUString& rName ) const;
236 RegionData_Impl* GetRegion( size_t nIndex ) const;
237
238 sal_Bool GetTitleFromURL( const OUString& rURL, OUString& aTitle );
239 sal_Bool InsertRegion( RegionData_Impl *pData, size_t nPos = size_t(-1) );
240 OUString GetRootURL() const { return maRootURL; }
241
242 uno::Reference< XDocumentTemplates > getDocTemplates() { return mxTemplates; }
243 };
244
245 // ------------------------------------------------------------------------
246
247 class DocTemplLocker_Impl
248 {
249 SfxDocTemplate_Impl& m_aDocTempl;
250 public:
251 DocTemplLocker_Impl( SfxDocTemplate_Impl& aDocTempl )
252 : m_aDocTempl( aDocTempl )
253 {
254 m_aDocTempl.IncrementLock();
255 }
256
257 ~DocTemplLocker_Impl()
258 {
259 m_aDocTempl.DecrementLock();
260 }
261 };
262
263 // ------------------------------------------------------------------------
264
265 #ifndef SFX_DECL_DOCTEMPLATES_DEFINED
266 #define SFX_DECL_DOCTEMPLATES_DEFINED
267 SV_DECL_REF(SfxDocTemplate_Impl)
268 #endif
269
270 SV_IMPL_REF(SfxDocTemplate_Impl)
271
272 // ------------------------------------------------------------------------
273
274 SfxDocTemplate_Impl *gpTemplateData = 0;
275
276 // -----------------------------------------------------------------------
277
278 static sal_Bool getTextProperty_Impl( Content& rContent,
279 const OUString& rPropName,
280 OUString& rPropValue );
281
282 //========================================================================
283
284 OUString SfxDocumentTemplates::GetFullRegionName
285 (
286 sal_uInt16 nIdx // Region Index
287 ) const
288
289 /* [Description]
290
291 Returns the logical name of a region and its path
292
293 [Return value] Reference to the Region name
294
295 */
296
297 {
298 // First: find the RegionData for the index
299 OUString aName;
300
301 DocTemplLocker_Impl aLocker( *pImp );
302
303 if ( pImp->Construct() )
304 {
305 RegionData_Impl *pData1 = pImp->GetRegion( nIdx );
306
307 if ( pData1 )
308 aName = pData1->GetTitle();
309
310 // --**-- here was some code which appended the path to the
311 // group if there was more than one with the same name.
312 // this should not happen anymore
313 }
314
315 return aName;
316 }
317
318 //------------------------------------------------------------------------
319
320 const OUString& SfxDocumentTemplates::GetRegionName
321 (
322 sal_uInt16 nIdx // Region Index
323 ) const
324
325 /* [Description]
326
327 Returns the logical name of a region
328
329 [Return value]
330
331 const String& Reference to the Region name
332
333 */
334 {
335 static OUString maTmpString;
336
337 DocTemplLocker_Impl aLocker( *pImp );
338
339 if ( pImp->Construct() )
340 {
341 RegionData_Impl *pData = pImp->GetRegion( nIdx );
342
343 if ( pData )
344 maTmpString = pData->GetTitle();
345 else
346 maTmpString = "";
347 }
348 else
349 maTmpString = "";
350
351 return maTmpString;
352 }
353
354 //------------------------------------------------------------------------
355
356 sal_uInt16 SfxDocumentTemplates::GetRegionCount() const
357
358 /* [Description]
359
360 Returns the number of Regions
361
362 [Return value]
363
364 sal_uInt16 Number of Regions
365 */
366 {
367 DocTemplLocker_Impl aLocker( *pImp );
368
369 if ( !pImp->Construct() )
370 return 0;
371
372 sal_uIntPtr nCount = pImp->GetRegionCount();
373
374 return (sal_uInt16) nCount;
375 }
376
377 //------------------------------------------------------------------------
378
379 sal_uInt16 SfxDocumentTemplates::GetCount
380 (
381 sal_uInt16 nRegion /* Region index whose number is
382 to be determined */
383
384 ) const
385
386 /* [Description]
387
388 Number of entries in Region
389
390 [Return value] Number of entries
391 */
392
393 {
394 DocTemplLocker_Impl aLocker( *pImp );
395
396 if ( !pImp->Construct() )
397 return 0;
398
399 RegionData_Impl *pData = pImp->GetRegion( nRegion );
400 sal_uIntPtr nCount = 0;
401
402 if ( pData )
403 nCount = pData->GetCount();
404
405 return (sal_uInt16) nCount;
406 }
407
408 //------------------------------------------------------------------------
409
410 const OUString& SfxDocumentTemplates::GetName
411 (
412 sal_uInt16 nRegion, // Region Index, in which the entry lies
413 sal_uInt16 nIdx // Index of the entry
414 ) const
415
416 /* [Description]
417
418 Returns the logical name of an entry in Region
419
420 [Return value]
421
422 const String& Entry Name
423 */
424
425 {
426 DocTemplLocker_Impl aLocker( *pImp );
427
428 static OUString maTmpString;
429
430 if ( pImp->Construct() )
431 {
432 DocTempl_EntryData_Impl *pEntry = NULL;
433 RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
434
435 if ( pRegion )
436 pEntry = pRegion->GetEntry( nIdx );
437
438 if ( pEntry )
439 maTmpString = pEntry->GetTitle();
440 else
441 maTmpString = "";
442 }
443 else
444 maTmpString = "";
445
446 return maTmpString;
447 }
448
449 //------------------------------------------------------------------------
450
451 OUString SfxDocumentTemplates::GetPath
452 (
453 sal_uInt16 nRegion, // Region Index, in which the entry lies
454 sal_uInt16 nIdx // Index of the entry
455 ) const
456
457 /* [Description]
458
459 Returns the file name with full path to the file assigned to an entry
460
461 [Return value]
462
463 String File name with full path
464 */
465 {
466 DocTemplLocker_Impl aLocker( *pImp );
467
468 if ( !pImp->Construct() )
469 return OUString();
470
471 DocTempl_EntryData_Impl *pEntry = NULL;
472 RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
473
474 if ( pRegion )
475 pEntry = pRegion->GetEntry( nIdx );
476
477 if ( pEntry )
478 return pEntry->GetTargetURL();
479 else
480 return OUString();
481 }
482
483 //------------------------------------------------------------------------
484
485 OUString SfxDocumentTemplates::GetTemplateTargetURLFromComponent( const OUString& aGroupName,
486 const OUString& aTitle )
487 {
488 DocTemplLocker_Impl aLocker( *pImp );
489
490 INetURLObject aTemplateObj( pImp->GetRootURL() );
491
492 aTemplateObj.insertName( aGroupName, false,
493 INetURLObject::LAST_SEGMENT, true,
494 INetURLObject::ENCODE_ALL );
495
496 aTemplateObj.insertName( aTitle, false,
497 INetURLObject::LAST_SEGMENT, true,
498 INetURLObject::ENCODE_ALL );
499
500
501 OUString aResult;
502 Content aTemplate;
503 uno::Reference< XCommandEnvironment > aCmdEnv;
504 if ( Content::create( aTemplateObj.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) )
505 {
506 OUString aPropName( TARGET_URL );
507 getTextProperty_Impl( aTemplate, aPropName, aResult );
508 aResult = SvtPathOptions().SubstituteVariable( aResult );
509 }
510
511 return aResult;
512 }
513
514 //------------------------------------------------------------------------
515
516 /** Convert a resource string - a template name - to its localised pair if it exists.
517 @param nSourceResIds
518 Resource ID where the list of original en-US template names begin.
519 @param nDestResIds
520 Resource ID where the list of localised template names begin.
521 @param nCount
522 The number of names that have been localised.
523 @param rString
524 Name to be translated.
525 @return
526 The localised pair of rString or rString if the former does not exist.
527 */
528 OUString SfxDocumentTemplates::ConvertResourceString (
529 int nSourceResIds, int nDestResIds, int nCount, const OUString& rString )
530 {
531 for( int i = 0; i < nCount; ++i )
532 {
533 if( rString == SFX2_RESSTR(nSourceResIds + i))
534 return SFX2_RESSTR(nDestResIds + i);
535 }
536 return rString;
537 }
538
539 //------------------------------------------------------------------------
540
541 sal_Bool SfxDocumentTemplates::CopyOrMove
542 (
543 sal_uInt16 nTargetRegion, // Target Region Index
544 sal_uInt16 nTargetIdx, // Target position Index
545 sal_uInt16 nSourceRegion, // Source Region Index
546 sal_uInt16 nSourceIdx, /* Index to be copied / to moved template */
547 sal_Bool bMove // Copy / Move
548 )
549
550 /* [Description]
551
552 Copy or move a document template
553
554 [Return value]
555
556 sal_Bool sal_True, Action could be performed
557 sal_False, Action could not be performed
558
559 [Cross-references]
560
561 <SfxDocumentTemplates::Move(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)>
562 <SfxDocumentTemplates::Copy(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)>
563 */
564
565 {
566 /* to perform a copy or move, we need to send a transfer command to
567 the destination folder with the URL of the source as parameter.
568 ( If the destination content doesn't support the transfer command,
569 we could try a copy ( and delete ) instead. )
570 We need two transfers ( one for the real template and one for its
571 representation in the hierarchy )
572 ...
573 */
574
575 DocTemplLocker_Impl aLocker( *pImp );
576
577 if ( !pImp->Construct() )
578 return sal_False;
579
580 // Don't copy or move any folders
581 if( nSourceIdx == USHRT_MAX )
582 return sal_False ;
583
584 if ( nSourceRegion == nTargetRegion )
585 {
586 SAL_WARN( "sfx.doc", "Don't know, what to do!" );
587 return sal_False;
588 }
589
590 RegionData_Impl *pSourceRgn = pImp->GetRegion( nSourceRegion );
591 if ( !pSourceRgn )
592 return sal_False;
593
594 DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nSourceIdx );
595 if ( !pSource )
596 return sal_False;
597
598 RegionData_Impl *pTargetRgn = pImp->GetRegion( nTargetRegion );
599 if ( !pTargetRgn )
600 return sal_False;
601
602 OUString aTitle = pSource->GetTitle();
603
604 uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
605
606 if ( xTemplates->addTemplate( pTargetRgn->GetTitle(),
607 aTitle,
608 pSource->GetTargetURL() ) )
609 {
610 OUString aNewTargetURL = GetTemplateTargetURLFromComponent( pTargetRgn->GetTitle(), aTitle );
611 if ( aNewTargetURL.isEmpty() )
612 return sal_False;
613
614 if ( bMove )
615 {
616 // --**-- delete the original file
617 sal_Bool bDeleted = xTemplates->removeTemplate( pSourceRgn->GetTitle(),
618 pSource->GetTitle() );
619 if ( bDeleted )
620 pSourceRgn->DeleteEntry( nSourceIdx );
621 else
622 {
623 if ( xTemplates->removeTemplate( pTargetRgn->GetTitle(), aTitle ) )
624 return sal_False; // will trigger tetry with copy instead of move
625
626 // if it is not possible to remove just created template ( must be possible! )
627 // it is better to report success here, since at least the copy has succeeded
628 // TODO/LATER: solve it more gracefully in future
629 }
630 }
631
632 // todo: fix SfxDocumentTemplates to handle size_t instead of sal_uInt16
633 size_t temp_nTargetIdx = nTargetIdx;
634 pTargetRgn->AddEntry( aTitle, aNewTargetURL, &temp_nTargetIdx );
635
636 return sal_True;
637 }
638
639 // --**-- if the current file is opened,
640 // it must be re-opened afterwards.
641
642 return sal_False;
643 }
644
645 //------------------------------------------------------------------------
646
647 sal_Bool SfxDocumentTemplates::Move
648 (
649 sal_uInt16 nTargetRegion, // Target Region Index
650 sal_uInt16 nTargetIdx, // Target position Index
651 sal_uInt16 nSourceRegion, // Source Region Index
652 sal_uInt16 nSourceIdx /* Index to be copied / to moved template */
653 )
654
655 /* [Description]
656
657 Moving a template
658
659 [Return value]
660
661 sal_Bool sal_True, Action could be performed
662 sal_False, Action could not be performed
663
664 [Cross-references]
665
666 <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)>
667 */
668 {
669 DocTemplLocker_Impl aLocker( *pImp );
670
671 return CopyOrMove( nTargetRegion, nTargetIdx,
672 nSourceRegion, nSourceIdx, sal_True );
673 }
674
675 //------------------------------------------------------------------------
676
677 sal_Bool SfxDocumentTemplates::Copy
678 (
679 sal_uInt16 nTargetRegion, // Target Region Index
680 sal_uInt16 nTargetIdx, // Target position Index
681 sal_uInt16 nSourceRegion, // Source Region Index
682 sal_uInt16 nSourceIdx /* Index to be copied / to moved template */
683 )
684
685 /* [Description]
686
687 Copying a template
688
689 [Return value]
690
691 sal_Bool sal_True, Action could be performed
692 sal_False, Action could not be performed
693
694 [Cross-references]
695
696 <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)>
697 */
698
699 {
700 DocTemplLocker_Impl aLocker( *pImp );
701
702 return CopyOrMove( nTargetRegion, nTargetIdx,
703 nSourceRegion, nSourceIdx, sal_False );
704 }
705
706 //------------------------------------------------------------------------
707
708 sal_Bool SfxDocumentTemplates::CopyTo
709 (
710 sal_uInt16 nRegion, // Region of the template to be exported
711 sal_uInt16 nIdx, // Index of the template to be exported
712 const OUString& rName /* File name under which the template is to
713 be created */
714 ) const
715
716 /* [Description]
717
718 Exporting a template into the file system
719
720 [Return value]
721
722 sal_Bool sal_True, Action could be performed
723 sal_False, Action could not be performed
724
725 [Cross-references]
726
727 <SfxDocumentTemplates::CopyFrom(sal_uInt16,sal_uInt16,String&)>
728 */
729
730 {
731 DocTemplLocker_Impl aLocker( *pImp );
732
733 if ( ! pImp->Construct() )
734 return sal_False;
735
736 RegionData_Impl *pSourceRgn = pImp->GetRegion( nRegion );
737 if ( !pSourceRgn )
738 return sal_False;
739
740 DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nIdx );
741 if ( !pSource )
742 return sal_False;
743
744 INetURLObject aTargetURL( rName );
745
746 OUString aTitle( aTargetURL.getName( INetURLObject::LAST_SEGMENT, true,
747 INetURLObject::DECODE_WITH_CHARSET ) );
748 aTargetURL.removeSegment();
749
750 OUString aParentURL = aTargetURL.GetMainURL( INetURLObject::NO_DECODE );
751
752 uno::Reference< XCommandEnvironment > aCmdEnv;
753 Content aTarget;
754
755 try
756 {
757 aTarget = Content( aParentURL, aCmdEnv, comphelper::getProcessComponentContext() );
758
759 TransferInfo aTransferInfo;
760 aTransferInfo.MoveData = sal_False;
761 aTransferInfo.SourceURL = pSource->GetTargetURL();
762 aTransferInfo.NewTitle = aTitle;
763 aTransferInfo.NameClash = NameClash::OVERWRITE;
764
765 Any aArg = makeAny( aTransferInfo );
766 OUString aCmd( COMMAND_TRANSFER );
767
768 aTarget.executeCommand( aCmd, aArg );
769 }
770 catch ( ContentCreationException& )
771 { return sal_False; }
772 catch ( Exception& )
773 { return sal_False; }
774
775 return sal_True;
776 }
777
778 //------------------------------------------------------------------------
779
780 sal_Bool SfxDocumentTemplates::CopyFrom
781 (
782 sal_uInt16 nRegion, /* Region in which the template is to be
783 imported */
784 sal_uInt16 nIdx, // Index of the new template in this Region
785 OUString& rName /* File name of the template to be imported
786 as an out parameter of the (automatically
787 generated from the file name) logical name
788 of the template */
789 )
790
791 /* [Description]
792
793 Import a template from the file system
794
795 [Return value] Sucess (sal_True) or serfpTargetDirectory->GetContent());
796
797 sal_Bool sal_True, Action could be performed
798 sal_False, Action could not be performed
799
800 [Cross-references]
801
802 <SfxDocumentTemplates::CopyTo(sal_uInt16,sal_uInt16,const String&)>
803 */
804
805 {
806 DocTemplLocker_Impl aLocker( *pImp );
807
808 if ( ! pImp->Construct() )
809 return sal_False;
810
811 RegionData_Impl *pTargetRgn = pImp->GetRegion( nRegion );
812
813 if ( !pTargetRgn )
814 return sal_False;
815
816 uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
817 if ( !xTemplates.is() )
818 return sal_False;
819
820 OUString aTitle;
821 sal_Bool bTemplateAdded = sal_False;
822
823 if( pImp->GetTitleFromURL( rName, aTitle ) )
824 {
825 bTemplateAdded = xTemplates->addTemplate( pTargetRgn->GetTitle(), aTitle, rName );
826 }
827 else
828 {
829 uno::Reference< XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );;
830
831 Sequence< PropertyValue > aArgs( 1 );
832 aArgs[0].Name = "Hidden";
833 aArgs[0].Value <<= sal_True;
834
835 INetURLObject aTemplURL( rName );
836 uno::Reference< XDocumentPropertiesSupplier > xDocPropsSupplier;
837 uno::Reference< XStorable > xStorable;
838 try
839 {
840 xStorable = uno::Reference< XStorable >(
841 xDesktop->loadComponentFromURL( aTemplURL.GetMainURL(INetURLObject::NO_DECODE),
842 OUString("_blank"),
843 0,
844 aArgs ),
845 UNO_QUERY );
846
847 xDocPropsSupplier = uno::Reference< XDocumentPropertiesSupplier >(
848 xStorable, UNO_QUERY );
849 }
850 catch( Exception& )
851 {
852 }
853
854 if( xStorable.is() )
855 {
856 // get Title from XDocumentPropertiesSupplier
857 if( xDocPropsSupplier.is() )
858 {
859 uno::Reference< XDocumentProperties > xDocProps
860 = xDocPropsSupplier->getDocumentProperties();
861 if (xDocProps.is() ) {
862 aTitle = xDocProps->getTitle();
863 }
864 }
865
866 if( aTitle.isEmpty() )
867 {
868 INetURLObject aURL( aTemplURL );
869 aURL.CutExtension();
870 aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,
871 INetURLObject::DECODE_WITH_CHARSET );
872 }
873
874 // write a template using XStorable interface
875 bTemplateAdded = xTemplates->storeTemplate( pTargetRgn->GetTitle(), aTitle, xStorable );
876 }
877 }
878
879
880 if( bTemplateAdded )
881 {
882 INetURLObject aTemplObj( pTargetRgn->GetHierarchyURL() );
883 aTemplObj.insertName( aTitle, false,
884 INetURLObject::LAST_SEGMENT, true,
885 INetURLObject::ENCODE_ALL );
886 OUString aTemplURL = aTemplObj.GetMainURL( INetURLObject::NO_DECODE );
887
888 uno::Reference< XCommandEnvironment > aCmdEnv;
889 Content aTemplCont;
890
891 if( Content::create( aTemplURL, aCmdEnv, comphelper::getProcessComponentContext(), aTemplCont ) )
892 {
893 OUString aTemplName;
894 OUString aPropName( TARGET_URL );
895
896 if( getTextProperty_Impl( aTemplCont, aPropName, aTemplName ) )
897 {
898 if ( nIdx == USHRT_MAX )
899 nIdx = 0;
900 else
901 nIdx += 1;
902
903 // todo: fix SfxDocumentTemplates to handle size_t instead of sal_uInt16
904 size_t temp_nIdx = nIdx;
905 pTargetRgn->AddEntry( aTitle, aTemplName, &temp_nIdx );
906 rName = aTitle;
907 return sal_True;
908 }
909 else
910 {
911 DBG_ASSERT( sal_False, "CopyFrom(): The content should contain target URL!" );
912 }
913 }
914 else
915 {
916 DBG_ASSERT( sal_False, "CopyFrom(): The content just was created!" );
917 }
918 }
919
920 return sal_False;
921 }
922
923 //------------------------------------------------------------------------
924
925 sal_Bool SfxDocumentTemplates::Delete
926 (
927 sal_uInt16 nRegion, // Region Index
928 sal_uInt16 nIdx /* Index of the entry or USHRT_MAX,
929 if a directory is meant. */
930 )
931
932 /* [Description]
933
934 Deleting an entry or a directory
935
936 [Return value]
937
938 sal_Bool sal_True, Action could be performed
939 sal_False, Action could not be performed
940
941 [Cross-references]
942
943 <SfxDocumentTemplates::InsertDir(const String&,sal_uInt16)>
944 <SfxDocumentTemplates::KillDir(SfxTemplateDir&)>
945 */
946
947 {
948 DocTemplLocker_Impl aLocker( *pImp );
949
950 /* delete the template or folder in the hierarchy and in the
951 template folder by sending a delete command to the content.
952 Then remove the data from the lists
953 */
954 if ( ! pImp->Construct() )
955 return sal_False;
956
957 RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
958
959 if ( !pRegion )
960 return sal_False;
961
962 sal_Bool bRet;
963 uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
964
965 if ( nIdx == USHRT_MAX )
966 {
967 bRet = xTemplates->removeGroup( pRegion->GetTitle() );
968 if ( bRet )
969 pImp->DeleteRegion( nRegion );
970 }
971 else
972 {
973 DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx );
974
975 if ( !pEntry )
976 return sal_False;
977
978 bRet = xTemplates->removeTemplate( pRegion->GetTitle(),
979 pEntry->GetTitle() );
980 if( bRet )
981 pRegion->DeleteEntry( nIdx );
982 }
983
984 return bRet;
985 }
986
987 //------------------------------------------------------------------------
988
989 sal_Bool SfxDocumentTemplates::InsertDir
990 (
991 const OUString& rText, // the logical name of the new Region
992 sal_uInt16 nRegion // Region Index
993 )
994
995 /* [Description]
996
997 Insert an index
998
999 [Return value]
1000
1001 sal_Bool sal_True, Action could be performed
1002 sal_False, Action could not be performed
1003
1004 [Cross-references]
1005
1006 <SfxDocumentTemplates::KillDir(SfxTemplateDir&)>
1007 */
1008 {
1009 DocTemplLocker_Impl aLocker( *pImp );
1010
1011 if ( ! pImp->Construct() )
1012 return sal_False;
1013
1014 RegionData_Impl *pRegion = pImp->GetRegion( rText );
1015
1016 if ( pRegion )
1017 return sal_False;
1018
1019 uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1020
1021 if ( xTemplates->addGroup( rText ) )
1022 {
1023 RegionData_Impl* pNewRegion = new RegionData_Impl( pImp, rText );
1024
1025 if ( ! pImp->InsertRegion( pNewRegion, nRegion ) )
1026 {
1027 delete pNewRegion;
1028 return sal_False;
1029 }
1030 return sal_True;
1031 }
1032
1033 return sal_False;
1034 }
1035
1036 sal_Bool SfxDocumentTemplates::InsertTemplate(sal_uInt16 nSourceRegion, sal_uInt16 nIdx, const OUString &rName, const OUString &rPath)
1037 {
1038 DocTemplLocker_Impl aLocker( *pImp );
1039
1040 if ( ! pImp->Construct() )
1041 return sal_False;
1042
1043 RegionData_Impl *pRegion = pImp->GetRegion( nSourceRegion );
1044
1045 if ( !pRegion )
1046 return sal_False;
1047
1048 size_t pos = nIdx;
1049 pRegion->AddEntry( rName, rPath, &pos );
1050
1051 return sal_True;
1052 }
1053
1054 sal_Bool SfxDocumentTemplates::SetName( const OUString& rName, sal_uInt16 nRegion, sal_uInt16 nIdx )
1055
1056 {
1057 DocTemplLocker_Impl aLocker( *pImp );
1058
1059 if ( ! pImp->Construct() )
1060 return sal_False;
1061
1062 RegionData_Impl *pRegion = pImp->GetRegion( nRegion );
1063
1064 if ( !pRegion )
1065 return sal_False;
1066
1067 uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates();
1068 OUString aEmpty;
1069
1070 if ( nIdx == USHRT_MAX )
1071 {
1072 if ( pRegion->GetTitle() == rName )
1073 return sal_True;
1074
1075 // we have to rename a region
1076 if ( xTemplates->renameGroup( pRegion->GetTitle(), rName ) )
1077 {
1078 pRegion->SetTitle( rName );
1079 pRegion->SetTargetURL( aEmpty );
1080 pRegion->SetHierarchyURL( aEmpty );
1081 return sal_True;
1082 }
1083 }
1084 else
1085 {
1086 DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx );
1087
1088 if ( !pEntry )
1089 return sal_False;
1090
1091 if ( pEntry->GetTitle() == rName )
1092 return sal_True;
1093
1094 if ( xTemplates->renameTemplate( pRegion->GetTitle(),
1095 pEntry->GetTitle(),
1096 rName ) )
1097 {
1098 pEntry->SetTitle( rName );
1099 pEntry->SetTargetURL( aEmpty );
1100 pEntry->SetHierarchyURL( aEmpty );
1101 return sal_True;
1102 }
1103 }
1104
1105 return sal_False;
1106 }
1107
1108 //------------------------------------------------------------------------
1109
1110 sal_Bool SfxDocumentTemplates::GetFull
1111 (
1112 const OUString &rRegion, // Region Name
1113 const OUString &rName, // Template Name
1114 OUString &rPath // Out: Path + File name
1115 )
1116
1117 /* [Description]
1118
1119 Returns Path + File name of the template specified by rRegion and rName.
1120
1121 [Return value]
1122
1123 sal_Bool sal_True, Action could be performed
1124 sal_False, Action could not be performed
1125
1126 [Cross-references]
1127
1128 <SfxDocumentTemplates::GetLogicNames(const String&,String&,String&)>
1129 */
1130
1131 {
1132 DocTemplLocker_Impl aLocker( *pImp );
1133
1134 // We don't search for empty names!
1135 if ( rName.isEmpty() )
1136 return sal_False;
1137
1138 if ( ! pImp->Construct() )
1139 return sal_False;
1140
1141 DocTempl_EntryData_Impl* pEntry = NULL;
1142 const sal_uInt16 nCount = GetRegionCount();
1143
1144 for ( sal_uInt16 i = 0; i < nCount; ++i )
1145 {
1146 RegionData_Impl *pRegion = pImp->GetRegion( i );
1147
1148 if( pRegion &&
1149 ( rRegion.isEmpty() || ( rRegion == pRegion->GetTitle() ) ) )
1150 {
1151 pEntry = pRegion->GetEntry( rName );
1152
1153 if ( pEntry )
1154 {
1155 rPath = pEntry->GetTargetURL();
1156 break;
1157 }
1158 }
1159 }
1160
1161 return ( pEntry != NULL );
1162 }
1163
1164 //------------------------------------------------------------------------
1165
1166 sal_Bool SfxDocumentTemplates::GetLogicNames
1167 (
1168 const OUString &rPath, // Full Path to the template
1169 OUString &rRegion, // Out: Region name
1170 OUString &rName // Out: Template name
1171 ) const
1172
1173 /* [Description]
1174
1175 Returns and logical path name to the template specified by rPath
1176
1177 [Return value]
1178
1179 sal_Bool sal_True, Action could be performed
1180 sal_False, Action could not be performed
1181
1182 [Cross-references]
1183
1184 <SfxDocumentTemplates::GetFull(const String&,const String&,DirEntry&)>
1185 */
1186
1187 {
1188 DocTemplLocker_Impl aLocker( *pImp );
1189
1190 if ( ! pImp->Construct() )
1191 return sal_False;
1192
1193 INetURLObject aFullPath;
1194
1195 aFullPath.SetSmartProtocol( INET_PROT_FILE );
1196 aFullPath.SetURL( rPath );
1197 OUString aPath( aFullPath.GetMainURL( INetURLObject::NO_DECODE ) );
1198
1199 RegionData_Impl *pData = NULL;
1200 DocTempl_EntryData_Impl *pEntry = NULL;
1201 sal_Bool bFound = sal_False;
1202
1203 sal_uIntPtr nCount = GetRegionCount();
1204
1205 for ( sal_uIntPtr i=0; !bFound && (i<nCount); i++ )
1206 {
1207 pData = pImp->GetRegion( i );
1208 if ( pData )
1209 {
1210 sal_uIntPtr nChildCount = pData->GetCount();
1211
1212 for ( sal_uIntPtr j=0; !bFound && (j<nChildCount); j++ )
1213 {
1214 pEntry = pData->GetEntry( j );
1215 if ( pEntry->GetTargetURL() == aPath )
1216 {
1217 bFound = sal_True;
1218 }
1219 }
1220 }
1221 }
1222
1223 if ( bFound )
1224 {
1225 rRegion = pData->GetTitle();
1226 rName = pEntry->GetTitle();
1227 }
1228
1229 return bFound;
1230 }
1231
1232 //------------------------------------------------------------------------
1233
1234 SfxDocumentTemplates::SfxDocumentTemplates()
1235
1236 /* [Description]
1237
1238 Constructor
1239 */
1240 {
1241 if ( !gpTemplateData )
1242 gpTemplateData = new SfxDocTemplate_Impl;
1243
1244 pImp = gpTemplateData;
1245 }
1246
1247 //-------------------------------------------------------------------------
1248
1249 void SfxDocumentTemplates::Construct()
1250
1251 // Delayed build-up of administrative data
1252
1253 {
1254 }
1255
1256 //------------------------------------------------------------------------
1257
1258 SfxDocumentTemplates::~SfxDocumentTemplates()
1259
1260 /* [Description]
1261
1262 Destructor
1263 Release of administrative data
1264 */
1265
1266 {
1267 pImp = NULL;
1268 }
1269
1270 void SfxDocumentTemplates::Update( sal_Bool _bSmart )
1271 {
1272 if ( !_bSmart // don't be smart
1273 || ::svt::TemplateFolderCache( sal_True ).needsUpdate() // update is really necessary
1274 )
1275 {
1276 if ( pImp->Construct() )
1277 pImp->Rescan();
1278 }
1279 }
1280
1281 void SfxDocumentTemplates::ReInitFromComponent()
1282 {
1283 pImp->ReInitFromComponent();
1284 }
1285
1286 // -----------------------------------------------------------------------
1287 DocTempl_EntryData_Impl::DocTempl_EntryData_Impl( RegionData_Impl* pParent,
1288 const OUString& rTitle )
1289 {
1290 mpParent = pParent;
1291 maTitle = SfxDocumentTemplates::ConvertResourceString(
1292 STR_TEMPLATE_NAME1_DEF, STR_TEMPLATE_NAME1, NUM_TEMPLATE_NAMES, rTitle );
1293 mbIsOwner = sal_False;
1294 mbDidConvert= sal_False;
1295 }
1296
1297 // -----------------------------------------------------------------------
1298 int DocTempl_EntryData_Impl::Compare( const OUString& rTitle ) const
1299 {
1300 return maTitle.compareTo( rTitle );
1301 }
1302
1303 // -----------------------------------------------------------------------
1304 const OUString& DocTempl_EntryData_Impl::GetHierarchyURL()
1305 {
1306 if ( maOwnURL.isEmpty() )
1307 {
1308 INetURLObject aTemplateObj( GetParent()->GetHierarchyURL() );
1309
1310 aTemplateObj.insertName( GetTitle(), false,
1311 INetURLObject::LAST_SEGMENT, true,
1312 INetURLObject::ENCODE_ALL );
1313
1314 maOwnURL = aTemplateObj.GetMainURL( INetURLObject::NO_DECODE );
1315 DBG_ASSERT( !maOwnURL.isEmpty(), "GetHierarchyURL(): Could not create URL!" );
1316 }
1317
1318 return maOwnURL;
1319 }
1320
1321 // -----------------------------------------------------------------------
1322 const OUString& DocTempl_EntryData_Impl::GetTargetURL()
1323 {
1324 if ( maTargetURL.isEmpty() )
1325 {
1326 uno::Reference< XCommandEnvironment > aCmdEnv;
1327 Content aRegion;
1328
1329 if ( Content::create( GetHierarchyURL(), aCmdEnv, comphelper::getProcessComponentContext(), aRegion ) )
1330 {
1331 OUString aPropName( TARGET_URL );
1332
1333 getTextProperty_Impl( aRegion, aPropName, maTargetURL );
1334 }
1335 else
1336 {
1337 SAL_WARN( "sfx.doc", "GetTargetURL(): Could not create hierarchy content!" );
1338 }
1339 }
1340
1341 return maTargetURL;
1342 }
1343
1344 // -----------------------------------------------------------------------
1345 RegionData_Impl::RegionData_Impl( const SfxDocTemplate_Impl* pParent,
1346 const OUString& rTitle )
1347 {
1348 maTitle = rTitle;
1349 mpParent = pParent;
1350 }
1351
1352 // -----------------------------------------------------------------------
1353 RegionData_Impl::~RegionData_Impl()
1354 {
1355 for ( size_t i = 0, n = maEntries.size(); i < n; ++i )
1356 delete maEntries[ i ];
1357 maEntries.clear();
1358 }
1359
1360 // -----------------------------------------------------------------------
1361 size_t RegionData_Impl::GetEntryPos( const OUString& rTitle, sal_Bool& rFound ) const
1362 {
1363 #if 1 // Don't use binary search today
1364 size_t i;
1365 size_t nCount = maEntries.size();
1366
1367 for ( i=0; i<nCount; i++ )
1368 {
1369 DocTempl_EntryData_Impl *pData = maEntries[ i ];
1370
1371 if ( pData->Compare( rTitle ) == 0 )
1372 {
1373 rFound = sal_True;
1374 return i;
1375 }
1376 }
1377
1378 rFound = sal_False;
1379 return i;
1380
1381 #else
1382 // use binary search to find the correct position
1383 // in the maEntries list
1384
1385 int nCompVal = 1;
1386 size_t nStart = 0;
1387 size_t nEnd = maEntries.size() - 1;
1388 size_t nMid;
1389
1390 DocTempl_EntryData_Impl* pMid;
1391
1392 rFound = sal_False;
1393
1394 while ( nCompVal && ( nStart <= nEnd ) )
1395 {
1396 nMid = ( nEnd - nStart ) / 2 + nStart;
1397 pMid = maEntries[ nMid ];
1398
1399 nCompVal = pMid->Compare( rTitle );
1400
1401 if ( nCompVal < 0 ) // pMid < pData
1402 nStart = nMid + 1;
1403 else
1404 nEnd = nMid - 1;
1405 }
1406
1407 if ( nCompVal == 0 )
1408 {
1409 rFound = sal_True;
1410 }
1411 else
1412 {
1413 if ( nCompVal < 0 ) // pMid < pData
1414 nMid++;
1415 }
1416
1417 return nMid;
1418 #endif
1419 }
1420
1421 // -----------------------------------------------------------------------
1422 void RegionData_Impl::AddEntry( const OUString& rTitle,
1423 const OUString& rTargetURL,
1424 size_t *pPos )
1425 {
1426 INetURLObject aLinkObj( GetHierarchyURL() );
1427 aLinkObj.insertName( rTitle, false,
1428 INetURLObject::LAST_SEGMENT, true,
1429 INetURLObject::ENCODE_ALL );
1430 OUString aLinkURL = aLinkObj.GetMainURL( INetURLObject::NO_DECODE );
1431
1432 DocTempl_EntryData_Impl* pEntry;
1433 sal_Bool bFound = sal_False;
1434 size_t nPos = GetEntryPos( rTitle, bFound );
1435
1436 if ( bFound )
1437 {
1438 pEntry = maEntries[ nPos ];
1439 }
1440 else
1441 {
1442 if ( pPos )
1443 nPos = *pPos;
1444
1445 pEntry = new DocTempl_EntryData_Impl( this, rTitle );
1446 pEntry->SetTargetURL( rTargetURL );
1447 pEntry->SetHierarchyURL( aLinkURL );
1448 if ( nPos < maEntries.size() ) {
1449 vector< DocTempl_EntryData_Impl* >::iterator it = maEntries.begin();
1450 advance( it, nPos );
1451 maEntries.insert( it, pEntry );
1452 }
1453 else
1454 maEntries.push_back( pEntry );
1455 }
1456 }
1457
1458 // -----------------------------------------------------------------------
1459 size_t RegionData_Impl::GetCount() const
1460 {
1461 return maEntries.size();
1462 }
1463
1464 // -----------------------------------------------------------------------
1465 const OUString& RegionData_Impl::GetHierarchyURL()
1466 {
1467 if ( maOwnURL.isEmpty() )
1468 {
1469 INetURLObject aRegionObj( GetParent()->GetRootURL() );
1470
1471 aRegionObj.insertName( GetTitle(), false,
1472 INetURLObject::LAST_SEGMENT, true,
1473 INetURLObject::ENCODE_ALL );
1474
1475 maOwnURL = aRegionObj.GetMainURL( INetURLObject::NO_DECODE );
1476 DBG_ASSERT( !maOwnURL.isEmpty(), "GetHierarchyURL(): Could not create URL!" );
1477 }
1478
1479 return maOwnURL;
1480 }
1481
1482 // -----------------------------------------------------------------------
1483 DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( const OUString& rName ) const
1484 {
1485 sal_Bool bFound = sal_False;
1486 long nPos = GetEntryPos( rName, bFound );
1487
1488 if ( bFound )
1489 return maEntries[ nPos ];
1490 else
1491 return NULL;
1492 }
1493
1494 // -----------------------------------------------------------------------
1495 DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( size_t nIndex ) const
1496 {
1497 if ( nIndex < maEntries.size() )
1498 return maEntries[ nIndex ];
1499 return NULL;
1500 }
1501
1502 // -----------------------------------------------------------------------
1503 void RegionData_Impl::DeleteEntry( size_t nIndex )
1504 {
1505 if ( nIndex < maEntries.size() )
1506 {
1507 delete maEntries[ nIndex ];
1508 vector< DocTempl_EntryData_Impl*>::iterator it = maEntries.begin();
1509 advance( it, nIndex );
1510 maEntries.erase( it );
1511 }
1512 }
1513
1514 // -----------------------------------------------------------------------
1515 int RegionData_Impl::Compare( RegionData_Impl* pCompare ) const
1516 {
1517 int nCompare = maTitle.compareTo( pCompare->maTitle );
1518
1519 return nCompare;
1520 }
1521
1522 // -----------------------------------------------------------------------
1523
1524 SfxDocTemplate_Impl::SfxDocTemplate_Impl()
1525 : mbConstructed( sal_False )
1526 , mnLockCounter( 0 )
1527 {
1528 }
1529
1530 // -----------------------------------------------------------------------
1531 SfxDocTemplate_Impl::~SfxDocTemplate_Impl()
1532 {
1533 Clear();
1534
1535 gpTemplateData = NULL;
1536 }
1537
1538 // -----------------------------------------------------------------------
1539 void SfxDocTemplate_Impl::IncrementLock()
1540 {
1541 ::osl::MutexGuard aGuard( maMutex );
1542 mnLockCounter++;
1543 }
1544
1545 // -----------------------------------------------------------------------
1546 void SfxDocTemplate_Impl::DecrementLock()
1547 {
1548 ::osl::MutexGuard aGuard( maMutex );
1549 if ( mnLockCounter )
1550 mnLockCounter--;
1551 }
1552
1553 // -----------------------------------------------------------------------
1554 RegionData_Impl* SfxDocTemplate_Impl::GetRegion( size_t nIndex ) const
1555 {
1556 if ( nIndex < maRegions.size() )
1557 return maRegions[ nIndex ];
1558 return NULL;
1559 }
1560
1561 // -----------------------------------------------------------------------
1562 RegionData_Impl* SfxDocTemplate_Impl::GetRegion( const OUString& rName )
1563 const
1564 {
1565 for ( size_t i = 0, n = maRegions.size(); i < n; ++i )
1566 {
1567 RegionData_Impl* pData = maRegions[ i ];
1568 if( pData->GetTitle() == rName )
1569 return pData;
1570 }
1571 return NULL;
1572 }
1573
1574 // -----------------------------------------------------------------------
1575 void SfxDocTemplate_Impl::DeleteRegion( size_t nIndex )
1576 {
1577 if ( nIndex < maRegions.size() )
1578 {
1579 delete maRegions[ nIndex ];
1580 RegionList_Impl::iterator it = maRegions.begin();
1581 advance( it, nIndex );
1582 maRegions.erase( it );
1583 }
1584 }
1585
1586 // -----------------------------------------------------------------------
1587 /* AddRegion adds a Region to the RegionList
1588 */
1589 void SfxDocTemplate_Impl::AddRegion( const OUString& rTitle,
1590 Content& rContent )
1591 {
1592 RegionData_Impl* pRegion;
1593 pRegion = new RegionData_Impl( this, rTitle );
1594
1595 if ( ! InsertRegion( pRegion ) )
1596 {
1597 delete pRegion;
1598 return;
1599 }
1600
1601 // now get the content of the region
1602 uno::Reference< XResultSet > xResultSet;
1603 Sequence< OUString > aProps(2);
1604 aProps[0] = TITLE;
1605 aProps[1] = TARGET_URL;
1606
1607 try
1608 {
1609 ResultSetInclude eInclude = INCLUDE_DOCUMENTS_ONLY;
1610 Sequence< NumberedSortingInfo > aSortingInfo(1);
1611 aSortingInfo.getArray()->ColumnIndex = 1;
1612 aSortingInfo.getArray()->Ascending = sal_True;
1613 xResultSet = rContent.createSortedCursor( aProps, aSortingInfo, m_rCompareFactory, eInclude );
1614 }
1615 catch ( Exception& ) {}
1616
1617 if ( xResultSet.is() )
1618 {
1619 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
1620 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
1621
1622 try
1623 {
1624 while ( xResultSet->next() )
1625 {
1626 OUString aTitle( xRow->getString( 1 ) );
1627 OUString aTargetDir( xRow->getString( 2 ) );
1628
1629 pRegion->AddEntry( aTitle, aTargetDir );
1630 }
1631 }
1632 catch ( Exception& ) {}
1633 }
1634 }
1635
1636 // -----------------------------------------------------------------------
1637 void SfxDocTemplate_Impl::CreateFromHierarchy( Content &rTemplRoot )
1638 {
1639 uno::Reference< XResultSet > xResultSet;
1640 Sequence< OUString > aProps(1);
1641 aProps[0] = TITLE;
1642
1643 try
1644 {
1645 ResultSetInclude eInclude = INCLUDE_FOLDERS_ONLY;
1646 Sequence< NumberedSortingInfo > aSortingInfo(1);
1647 aSortingInfo.getArray()->ColumnIndex = 1;
1648 aSortingInfo.getArray()->Ascending = sal_True;
1649 xResultSet = rTemplRoot.createSortedCursor( aProps, aSortingInfo, m_rCompareFactory, eInclude );
1650 }
1651 catch ( Exception& ) {}
1652
1653 if ( xResultSet.is() )
1654 {
1655 uno::Reference< XCommandEnvironment > aCmdEnv;
1656 uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY );
1657 uno::Reference< XRow > xRow( xResultSet, UNO_QUERY );
1658
1659 try
1660 {
1661 while ( xResultSet->next() )
1662 {
1663 OUString aTitle( xRow->getString( 1 ) );
1664
1665 OUString aId = xContentAccess->queryContentIdentifierString();
1666 Content aContent = Content( aId, aCmdEnv, comphelper::getProcessComponentContext() );
1667
1668 AddRegion( aTitle, aContent );
1669 }
1670 }
1671 catch ( Exception& ) {}
1672 }
1673 }
1674
1675 // ------------------------------------------------------------------------
1676 sal_Bool SfxDocTemplate_Impl::Construct( )
1677 {
1678 ::osl::MutexGuard aGuard( maMutex );
1679
1680 if ( mbConstructed )
1681 return sal_True;
1682
1683 uno::Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
1684
1685 uno::Reference< XPersist > xInfo( document::DocumentProperties::create(xContext), UNO_QUERY );
1686 mxInfo = xInfo;
1687
1688 mxTemplates = frame::DocumentTemplates::create(xContext);
1689
1690 uno::Reference< XLocalizable > xLocalizable( mxTemplates, UNO_QUERY );
1691
1692 m_rCompareFactory = AnyCompareFactory::createWithLocale(xContext, xLocalizable->getLocale());
1693
1694 uno::Reference < XContent > aRootContent = mxTemplates->getContent();
1695 uno::Reference < XCommandEnvironment > aCmdEnv;
1696
1697 if ( ! aRootContent.is() )
1698 return sal_False;
1699
1700 mbConstructed = sal_True;
1701 maRootURL = aRootContent->getIdentifier()->getContentIdentifier();
1702
1703 ResStringArray aLongNames( SfxResId( TEMPLATE_LONG_NAMES_ARY ) );
1704
1705 if ( aLongNames.Count() )
1706 maStandardGroup = aLongNames.GetString( 0 );
1707
1708 Content aTemplRoot( aRootContent, aCmdEnv, xContext );
1709 CreateFromHierarchy( aTemplRoot );
1710
1711 return sal_True;
1712 }
1713
1714 // -----------------------------------------------------------------------
1715 void SfxDocTemplate_Impl::ReInitFromComponent()
1716 {
1717 uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates();
1718 if ( xTemplates.is() )
1719 {
1720 uno::Reference < XContent > aRootContent = xTemplates->getContent();
1721 uno::Reference < XCommandEnvironment > aCmdEnv;
1722 Content aTemplRoot( aRootContent, aCmdEnv, comphelper::getProcessComponentContext() );
1723 Clear();
1724 CreateFromHierarchy( aTemplRoot );
1725 }
1726 }
1727
1728 // -----------------------------------------------------------------------
1729 sal_Bool SfxDocTemplate_Impl::InsertRegion( RegionData_Impl *pNew, size_t nPos )
1730 {
1731 ::osl::MutexGuard aGuard( maMutex );
1732
1733 // return false (not inserted) if the entry already exists
1734 for ( size_t i = 0, n = maRegions.size(); i < n; ++i )
1735 if ( maRegions[ i ]->Compare( pNew ) == 0 )
1736 return sal_False;
1737
1738 size_t newPos = nPos;
1739 if ( pNew->GetTitle() == maStandardGroup )
1740 newPos = 0;
1741
1742 if ( newPos < maRegions.size() )
1743 {
1744 RegionList_Impl::iterator it = maRegions.begin();
1745 advance( it, newPos );
1746 maRegions.insert( it, pNew );
1747 }
1748 else
1749 maRegions.push_back( pNew );
1750
1751 return sal_True;
1752 }
1753
1754 // -----------------------------------------------------------------------
1755 void SfxDocTemplate_Impl::Rescan()
1756 {
1757 Clear();
1758
1759 try
1760 {
1761 uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates();
1762 DBG_ASSERT( xTemplates.is(), "SfxDocTemplate_Impl::Rescan:invalid template instance!" );
1763 if ( xTemplates.is() )
1764 {
1765 xTemplates->update();
1766
1767 uno::Reference < XContent > aRootContent = xTemplates->getContent();
1768 uno::Reference < XCommandEnvironment > aCmdEnv;
1769
1770 Content aTemplRoot( aRootContent, aCmdEnv, comphelper::getProcessComponentContext() );
1771 CreateFromHierarchy( aTemplRoot );
1772 }
1773 }
1774 catch( const Exception& )
1775 {
1776 SAL_WARN( "sfx.doc", "SfxDocTemplate_Impl::Rescan: caught an exception while doing the update!" );
1777 }
1778 }
1779
1780 // -----------------------------------------------------------------------
1781 sal_Bool SfxDocTemplate_Impl::GetTitleFromURL( const OUString& rURL,
1782 OUString& aTitle )
1783 {
1784 if ( mxInfo.is() )
1785 {
1786 try
1787 {
1788 mxInfo->read( rURL );
1789 }
1790 catch ( Exception& )
1791 {
1792 // the document is not a StarOffice document
1793 return sal_False;
1794 }
1795
1796
1797 try
1798 {
1799 uno::Reference< XPropertySet > aPropSet( mxInfo, UNO_QUERY );
1800 if ( aPropSet.is() )
1801 {
1802 OUString aPropName( TITLE );
1803 Any aValue = aPropSet->getPropertyValue( aPropName );
1804 aValue >>= aTitle;
1805 }
1806 }
1807 catch ( IOException& ) {}
1808 catch ( UnknownPropertyException& ) {}
1809 catch ( Exception& ) {}
1810 }
1811
1812 if ( aTitle.isEmpty() )
1813 {
1814 INetURLObject aURL( rURL );
1815 aURL.CutExtension();
1816 aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,
1817 INetURLObject::DECODE_WITH_CHARSET );
1818 }
1819
1820 return sal_True;
1821 }
1822
1823
1824 // -----------------------------------------------------------------------
1825 void SfxDocTemplate_Impl::Clear()
1826 {
1827 ::osl::MutexGuard aGuard( maMutex );
1828 if ( mnLockCounter )
1829 return;
1830
1831 for ( size_t i = 0, n = maRegions.size(); i < n; ++i )
1832 delete maRegions[ i ];
1833 maRegions.clear();
1834 }
1835
1836 // -----------------------------------------------------------------------
1837 sal_Bool getTextProperty_Impl( Content& rContent,
1838 const OUString& rPropName,
1839 OUString& rPropValue )
1840 {
1841 sal_Bool bGotProperty = sal_False;
1842
1843 // Get the property
1844 try
1845 {
1846 uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties();
1847
1848 // check, whether or not the property exists
1849 if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) )
1850 {
1851 return sal_False;
1852 }
1853
1854 // now get the property
1855 Any aAnyValue;
1856
1857 aAnyValue = rContent.getPropertyValue( rPropName );
1858 aAnyValue >>= rPropValue;
1859
1860 if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) )
1861 {
1862 SfxURLRelocator_Impl aRelocImpl( ::comphelper::getProcessComponentContext() );
1863 aRelocImpl.makeAbsoluteURL( rPropValue );
1864 }
1865
1866 bGotProperty = sal_True;
1867 }
1868 catch ( RuntimeException& ) {}
1869 catch ( Exception& ) {}
1870
1871 return bGotProperty;
1872 }
1873
1874 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE