sd/source/ui/dlg/TemplateScanner.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: TemplateScanner.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "TemplateScanner.hxx"
  35
  36 #ifndef _COMPHELPER_SERVICEFACTORY_HXX
  37 #include <comphelper/processfactory.hxx>
  38 #endif
  39 #include <comphelper/documentconstants.hxx>
  40
  41 #include <tools/debug.hxx>
  42 #include <vos/mutex.hxx>
  43 #include <vcl/svapp.hxx>
  44 #include <com/sun/star/frame/XDocumentTemplates.hpp>
  45 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  46 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  47 #include <com/sun/star/ucb/XContentAccess.hpp>
  48 #include <com/sun/star/sdbc/XResultSet.hpp>
  49 #include <com/sun/star/sdbc/XRow.hpp>
  50
  51 #include <set>
  52
  53 using namespace ::com::sun::star;
  54 using namespace ::com::sun::star::uno;
  55
  56 namespace {
  57
  58 const ::rtl::OUString TITLE            = ::rtl::OUString::createFromAscii ("Title");
  59 const ::rtl::OUString TARGET_DIR_URL   = ::rtl::OUString::createFromAscii ("TargetDirURL");
  60 const ::rtl::OUString DESCRIPTION      = ::rtl::OUString::createFromAscii ("TypeDescription");
  61 const ::rtl::OUString TARGET_URL       = ::rtl::OUString::createFromAscii ("TargetURL");
  62
  63 const ::rtl::OUString DOCTEMPLATES     = ::rtl::OUString::createFromAscii ("com.sun.star.frame.DocumentTemplates");
  64
  65 //  These strings are used to find impress templates in the tree of
  66 //  template files.  Should probably be determined dynamically.
  67 const ::rtl::OUString IMPRESS_BIN_TEMPLATE = ::rtl::OUString::createFromAscii ("application/vnd.stardivision.impress");
  68 const ::rtl::OUString IMPRESS_XML_TEMPLATE = MIMETYPE_VND_SUN_XML_IMPRESS;
  69 // The following id comes from the bugdoc in #i2764#.
  70 const ::rtl::OUString IMPRESS_XML_TEMPLATE_B = ::rtl::OUString::createFromAscii ("Impress 2.0");
  71 const ::rtl::OUString IMPRESS_XML_TEMPLATE_OASIS = MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION;
  72
  73
  74 class FolderDescriptor
  75 {
  76 public:
  77     FolderDescriptor (
  78         int nPriority,
  79         const ::rtl::OUString& rsTitle,
  80         const ::rtl::OUString& rsTargetDir,
  81         const ::rtl::OUString& rsContentIdentifier,
  82         const Reference<com::sun::star::ucb::XCommandEnvironment>& rxFolderEnvironment)
  83         : mnPriority(nPriority),
  84           msTitle(rsTitle),
  85           msTargetDir(rsTargetDir),
  86           msContentIdentifier(rsContentIdentifier),
  87           mxFolderEnvironment(rxFolderEnvironment)
  88     { }
  89     int mnPriority;
  90     ::rtl::OUString msTitle;
  91     ::rtl::OUString msTargetDir;
  92     ::rtl::OUString msContentIdentifier;
  93     //    Reference<sdbc::XResultSet> mxFolderResultSet;
  94     Reference<com::sun::star::ucb::XCommandEnvironment> mxFolderEnvironment;
  95
  96     class Comparator { public:
  97         bool operator() (const FolderDescriptor& r1, const FolderDescriptor& r2)
  98         { return r1.mnPriority < r2.mnPriority; }
  99     };
 100 };
 101
 102 /** Use a heuristic based on the URL of a top-level template folder to
 103     assign a priority that is used to sort the folders.
 104 */
 105 int Classify (const ::rtl::OUString&, const ::rtl::OUString& rsURL)
 106 {
 107     int nPriority (0);
 108
 109     if (rsURL.getLength() == 0)
 110         nPriority = 100;
 111     else if (rsURL.indexOf(::rtl::OUString::createFromAscii("presnt"))>=0)
 112     {
 113         nPriority = 30;
 114     }
 115     else if (rsURL.indexOf(::rtl::OUString::createFromAscii("layout"))>=0)
 116     {
 117         nPriority = 20;
 118     }
 119     else if (rsURL.indexOf(::rtl::OUString::createFromAscii("educate"))>=0)
 120     {
 121         nPriority = 40;
 122     }
 123     else if (rsURL.indexOf(::rtl::OUString::createFromAscii("finance"))>=0)
 124     {
 125         nPriority = 40;
 126     }
 127     else
 128     {
 129         // All other folders are taken for user supplied and have the
 130         // highest priority.
 131         nPriority = 10;
 132     }
 133
 134     return nPriority;
 135 }
 136
 137 } // end of anonymous namespace
 138
 139
 140
 141
 142 namespace sd
 143 {
 144
 145 class TemplateScanner::FolderDescriptorList
 146     : public ::std::multiset<FolderDescriptor,FolderDescriptor::Comparator>
 147 {
 148 };
 149
 150 TemplateScanner::TemplateScanner (void)
 151     : meState(INITIALIZE_SCANNING),
 152       maFolderContent(),
 153       mpTemplateDirectory(NULL),
 154       maFolderList(),
 155       mpLastAddedEntry(NULL),
 156       mpFolderDescriptors(new FolderDescriptorList()),
 157       mxTemplateRoot(),
 158       mxFolderEnvironment(),
 159       mxEntryEnvironment(),
 160       mxFolderResultSet(),
 161       mxEntryResultSet()
 162 {
 163     //  empty;
 164 }
 165
 166
 167
 168
 169 TemplateScanner::~TemplateScanner (void)
 170 {
 171     mpFolderDescriptors.reset();
 172
 173     // Delete all entries of the template list that have not been
 174     // transferred to another object.
 175     std::vector<TemplateDir*>::iterator I;
 176     for (I=maFolderList.begin(); I!=maFolderList.end(); I++)
 177         if (*I != NULL)
 178             delete *I;
 179 }
 180
 181
 182
 183
 184 TemplateScanner::State TemplateScanner::GetTemplateRoot (void)
 185 {
 186     State eNextState (INITIALIZE_FOLDER_SCANNING);
 187
 188     Reference<lang::XMultiServiceFactory> xFactory = ::comphelper::getProcessServiceFactory ();
 189     DBG_ASSERT (xFactory.is(), "TemplateScanner::GetTemplateRoot: xFactory is NULL");
 190
 191     if (xFactory.is())
 192     {
 193         Reference<frame::XDocumentTemplates> xTemplates (
 194             xFactory->createInstance (DOCTEMPLATES), UNO_QUERY);
 195         DBG_ASSERT (xTemplates.is(), "TemplateScanner::GetTemplateRoot: xTemplates is NULL");
 196
 197         if (xTemplates.is())
 198             mxTemplateRoot = xTemplates->getContent();
 199         else
 200             eNextState = ERROR;
 201     }
 202     else
 203         eNextState = ERROR;
 204
 205     return eNextState;
 206 }
 207
 208
 209
 210
 211 TemplateScanner::State TemplateScanner::InitializeEntryScanning (void)
 212 {
 213     State eNextState (SCAN_ENTRY);
 214
 215     if (maFolderContent.isFolder())
 216     {
 217         mxEntryEnvironment = Reference<com::sun::star::ucb::XCommandEnvironment>();
 218
 219         //  We are interested only in three properties: the entry's name,
 220         //  its URL, and its content type.
 221         Sequence<rtl::OUString> aProps (3);
 222         aProps[0] = TITLE;
 223         aProps[1] = TARGET_URL;
 224         aProps[2] = DESCRIPTION;
 225
 226         //  Create a cursor to iterate over the templates in this folders.
 227         ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_DOCUMENTS_ONLY;
 228         mxEntryResultSet = Reference<com::sun::star::sdbc::XResultSet>(
 229             maFolderContent.createCursor(aProps, eInclude));
 230     }
 231     else
 232         eNextState = ERROR;
 233
 234     return eNextState;
 235 }
 236
 237
 238
 239
 240 TemplateScanner::State TemplateScanner::ScanEntry (void)
 241 {
 242     State eNextState (ERROR);
 243
 244     Reference<com::sun::star::ucb::XContentAccess> xContentAccess (mxEntryResultSet, UNO_QUERY);
 245     Reference<com::sun::star::sdbc::XRow> xRow (mxEntryResultSet, UNO_QUERY);
 246
 247     if (xContentAccess.is() && xRow.is() && mxEntryResultSet.is())
 248     {
 249         if (mxEntryResultSet->next())
 250         {
 251             ::rtl::OUString sTitle (xRow->getString (1));
 252             ::rtl::OUString sTargetURL (xRow->getString (2));
 253             ::rtl::OUString sContentType (xRow->getString (3));
 254
 255             ::rtl::OUString aId = xContentAccess->queryContentIdentifierString();
 256             ::ucbhelper::Content  aContent = ::ucbhelper::Content (aId, mxEntryEnvironment);
 257             if (aContent.isDocument ())
 258             {
 259                 //  Check wether the entry is an impress template.  If so
 260                 //  add a new entry to the resulting list (which is created
 261                 //  first if necessary).
 262                 if (    (sContentType == MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE)
 263                     ||  (sContentType == IMPRESS_XML_TEMPLATE_OASIS)
 264                     ||  (sContentType == IMPRESS_BIN_TEMPLATE)
 265                     ||  (sContentType == IMPRESS_XML_TEMPLATE)
 266                     ||  (sContentType == IMPRESS_XML_TEMPLATE_B))
 267                 {
 268                     mpLastAddedEntry = new TemplateEntry(sTitle, sTargetURL);
 269                     mpTemplateDirectory->maEntries.push_back(mpLastAddedEntry);
 270                 }
 271             }
 272
 273             // Continue scanning entries.
 274             eNextState = SCAN_ENTRY;
 275         }
 276         else
 277         {
 278             if (mpTemplateDirectory->maEntries.empty())
 279             {
 280                 delete mpTemplateDirectory;
 281                 mpTemplateDirectory = NULL;
 282             }
 283             else
 284             {
 285                 ::vos::OGuard aGuard(Application::GetSolarMutex());
 286                 maFolderList.push_back(mpTemplateDirectory);
 287             }
 288
 289             // Continue with scanning the next folder.
 290             eNextState = SCAN_FOLDER;
 291         }
 292     }
 293
 294     return eNextState;
 295 }
 296
 297
 298
 299
 300 TemplateScanner::State TemplateScanner::InitializeFolderScanning (void)
 301 {
 302     State eNextState (ERROR);
 303
 304     mxFolderResultSet = Reference<sdbc::XResultSet>();
 305
 306     try
 307     {
 308         //  Create content for template folders.
 309         mxFolderEnvironment = Reference<com::sun::star::ucb::XCommandEnvironment>();
 310         ::ucbhelper::Content aTemplateDir (mxTemplateRoot, mxFolderEnvironment);
 311
 312         //  Define the list of properties we are interested in.
 313         Sequence<rtl::OUString> aProps (2);
 314         aProps[0] = TITLE;
 315         aProps[1] = TARGET_DIR_URL;
 316
 317         //  Create an cursor to iterate over the template folders.
 318         ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_ONLY;
 319         mxFolderResultSet = Reference<sdbc::XResultSet>(
 320             aTemplateDir.createCursor(aProps, eInclude));
 321         if (mxFolderResultSet.is())
 322             eNextState = GATHER_FOLDER_LIST;
 323     }
 324     catch (::com::sun::star::uno::Exception&)
 325     {
 326        eNextState = ERROR;
 327     }
 328
 329     return eNextState;
 330 }
 331
 332
 333
 334
 335 TemplateScanner::State TemplateScanner::GatherFolderList (void)
 336 {
 337     State eNextState (ERROR);
 338
 339     Reference<com::sun::star::ucb::XContentAccess> xContentAccess (mxFolderResultSet, UNO_QUERY);
 340     if (xContentAccess.is() && mxFolderResultSet.is())
 341     {
 342         while (mxFolderResultSet->next())
 343         {
 344             Reference<sdbc::XRow> xRow (mxFolderResultSet, UNO_QUERY);
 345             if (xRow.is())
 346             {
 347                 ::rtl::OUString sTitle (xRow->getString (1));
 348                 ::rtl::OUString sTargetDir (xRow->getString (2));
 349                 ::rtl::OUString aId = xContentAccess->queryContentIdentifierString();
 350
 351                 mpFolderDescriptors->insert(
 352                     FolderDescriptor(
 353                         Classify(sTitle,sTargetDir),
 354                         sTitle,
 355                         sTargetDir,
 356                         aId,
 357                         mxFolderEnvironment));
 358             }
 359         }
 360
 361         eNextState = SCAN_FOLDER;
 362     }
 363
 364     return eNextState;
 365 }
 366
 367
 368
 369
 370 TemplateScanner::State TemplateScanner::ScanFolder (void)
 371 {
 372     State eNextState (ERROR);
 373
 374     if (mpFolderDescriptors->size() > 0)
 375     {
 376         FolderDescriptor aDescriptor (*mpFolderDescriptors->begin());
 377         mpFolderDescriptors->erase(mpFolderDescriptors->begin());
 378
 379         ::rtl::OUString sTitle (aDescriptor.msTitle);
 380         ::rtl::OUString sTargetDir (aDescriptor.msTargetDir);
 381         ::rtl::OUString aId (aDescriptor.msContentIdentifier);
 382
 383         maFolderContent = ::ucbhelper::Content (aId, aDescriptor.mxFolderEnvironment);
 384         if (maFolderContent.isFolder())
 385         {
 386             // Scan the folder and insert it into the list of template
 387             // folders.
 388             mpTemplateDirectory = new TemplateDir (sTitle, sTargetDir);
 389             if (mpTemplateDirectory != NULL)
 390             {
 391                 // Continue with scanning all entries in the folder.
 392                 eNextState = INITIALIZE_ENTRY_SCAN;
 393             }
 394         }
 395     }
 396     else
 397     {
 398         eNextState = DONE;
 399     }
 400
 401     return eNextState;
 402 }
 403
 404
 405
 406
 407 void TemplateScanner::Scan (void)
 408 {
 409     while (HasNextStep())
 410         RunNextStep();
 411 }
 412
 413
 414
 415
 416 std::vector<TemplateDir*>& TemplateScanner::GetFolderList (void)
 417 {
 418     return maFolderList;
 419 }
 420
 421
 422
 423
 424 void TemplateScanner::RunNextStep (void)
 425 {
 426     switch (meState)
 427     {
 428         case INITIALIZE_SCANNING:
 429             meState = GetTemplateRoot();
 430             break;
 431
 432         case INITIALIZE_FOLDER_SCANNING:
 433             meState = InitializeFolderScanning();
 434             break;
 435
 436         case SCAN_FOLDER:
 437             meState = ScanFolder();
 438             break;
 439
 440         case GATHER_FOLDER_LIST:
 441             meState = GatherFolderList();
 442             break;
 443
 444         case INITIALIZE_ENTRY_SCAN:
 445             meState = InitializeEntryScanning();
 446             break;
 447
 448         case SCAN_ENTRY:
 449             meState = ScanEntry();
 450             break;
 451         default:
 452             break;
 453     }
 454
 455     switch (meState)
 456     {
 457         case DONE:
 458         case ERROR:
 459             mxTemplateRoot.clear();
 460             mxTemplateRoot.clear();
 461             mxFolderEnvironment.clear();
 462             mxEntryEnvironment.clear();
 463             mxFolderResultSet.clear();
 464             mxEntryResultSet.clear();
 465             mpLastAddedEntry = NULL;
 466             break;
 467         default:
 468             break;
 469     }
 470 }
 471
 472
 473
 474
 475 bool TemplateScanner::HasNextStep (void)
 476 {
 477     switch (meState)
 478     {
 479         case DONE:
 480         case ERROR:
 481             return false;
 482
 483         default:
 484             return true;
 485     }
 486 }
 487
 488
 489
 490
 491 const TemplateEntry* TemplateScanner::GetLastAddedEntry (void) const
 492 {
 493     return mpLastAddedEntry;
 494 }
 495
 496 }