sfx2/source/doc/doctempl.cxx

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