sd/source/ui/dlg/TemplateScanner.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <TemplateScanner.hxx>
  21
  22 #include <comphelper/processfactory.hxx>
  23 #include <comphelper/documentconstants.hxx>
  24
  25 #include <sfx2/doctempl.hxx>
  26 #include <com/sun/star/frame/DocumentTemplates.hpp>
  27 #include <com/sun/star/frame/XDocumentTemplates.hpp>
  28 #include <com/sun/star/ucb/XContentAccess.hpp>
  29 #include <com/sun/star/sdbc/XResultSet.hpp>
  30 #include <com/sun/star/sdbc/XRow.hpp>
  31
  32 #include <set>
  33
  34 using namespace ::com::sun::star;
  35 using namespace ::com::sun::star::uno;
  36
  37 namespace {
  38
  39 const char TITLE[] = "Title";
  40
  41 class FolderDescriptor
  42 {
  43 public:
  44     FolderDescriptor (
  45         int nPriority,
  46         const OUString& rsContentIdentifier,
  47         const Reference<css::ucb::XCommandEnvironment>& rxFolderEnvironment)
  48         : mnPriority(nPriority),
  49           msContentIdentifier(rsContentIdentifier),
  50           mxFolderEnvironment(rxFolderEnvironment)
  51     { }
  52     int const mnPriority;
  53     OUString const msContentIdentifier;
  54     //    Reference<sdbc::XResultSet> mxFolderResultSet;
  55     Reference<css::ucb::XCommandEnvironment> mxFolderEnvironment;
  56
  57     class Comparator
  58     {
  59     public:
  60         bool operator() (const FolderDescriptor& r1, const FolderDescriptor& r2) const
  61             { return r1.mnPriority < r2.mnPriority; }
  62     };
  63 };
  64
  65 /** Use a heuristic based on the URL of a top-level template folder to
  66     assign a priority that is used to sort the folders.
  67 */
  68 int Classify (const OUString&, const OUString& rsURL)
  69 {
  70     int nPriority (0);
  71
  72     if (rsURL.isEmpty())
  73         nPriority = 100;
  74     else if (rsURL.indexOf("presnt")>=0)
  75     {
  76         nPriority = 30;
  77     }
  78     else if (rsURL.indexOf("layout")>=0)
  79     {
  80         nPriority = 20;
  81     }
  82     else if (rsURL.indexOf("educate")>=0)
  83     {
  84         nPriority = 40;
  85     }
  86     else if (rsURL.indexOf("finance")>=0)
  87     {
  88         nPriority = 40;
  89     }
  90     else
  91     {
  92         // All other folders are taken for user supplied and have the
  93         // highest priority.
  94         nPriority = 10;
  95     }
  96
  97     return nPriority;
  98 }
  99
 100 } // end of anonymous namespace
 101
 102 namespace sd
 103 {
 104
 105 class TemplateScanner::FolderDescriptorList
 106     : public ::std::multiset<FolderDescriptor,FolderDescriptor::Comparator>
 107 {
 108 };
 109
 110 TemplateScanner::TemplateScanner()
 111     : meState(INITIALIZE_SCANNING),
 112       maFolderContent(),
 113       mpFolderDescriptors(new FolderDescriptorList),
 114       mxTemplateRoot(),
 115       mxFolderEnvironment(),
 116       mxEntryEnvironment(),
 117       mxFolderResultSet(),
 118       mxEntryResultSet()
 119 {
 120     //  empty;
 121 }
 122
 123 TemplateScanner::~TemplateScanner()
 124 {
 125 }
 126
 127 TemplateScanner::State TemplateScanner::GetTemplateRoot()
 128 {
 129     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 130     Reference<frame::XDocumentTemplates> xTemplates = frame::DocumentTemplates::create(xContext);
 131     mxTemplateRoot = xTemplates->getContent();
 132
 133     return INITIALIZE_FOLDER_SCANNING;
 134 }
 135
 136 TemplateScanner::State TemplateScanner::InitializeEntryScanning()
 137 {
 138     State eNextState (SCAN_ENTRY);
 139
 140     if (maFolderContent.isFolder())
 141     {
 142         mxEntryEnvironment.clear();
 143
 144         //  We are interested only in three properties: the entry's name,
 145         //  its URL, and its content type.
 146         Sequence<OUString> aProps (3);
 147         aProps[0] = TITLE;
 148         aProps[1] = "TargetURL";
 149         aProps[2] = "TypeDescription";
 150
 151         //  Create a cursor to iterate over the templates in this folders.
 152         mxEntryResultSet.set( maFolderContent.createCursor(aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY));
 153     }
 154     else
 155         eNextState = ERROR;
 156
 157     return eNextState;
 158 }
 159
 160 TemplateScanner::State TemplateScanner::ScanEntry()
 161 {
 162     State eNextState (ERROR);
 163
 164     Reference<css::ucb::XContentAccess> xContentAccess (mxEntryResultSet, UNO_QUERY);
 165     Reference<css::sdbc::XRow> xRow (mxEntryResultSet, UNO_QUERY);
 166
 167     if (xContentAccess.is() && xRow.is() && mxEntryResultSet.is())
 168     {
 169         if (mxEntryResultSet->next())
 170         {
 171             OUString sTitle (xRow->getString (1));
 172             OUString sTargetURL (xRow->getString (2));
 173             OUString sContentType (xRow->getString (3));
 174
 175             OUString aId = xContentAccess->queryContentIdentifierString();
 176             ::ucbhelper::Content  aContent = ::ucbhelper::Content (aId, mxEntryEnvironment, comphelper::getProcessComponentContext());
 177             if (aContent.isDocument ())
 178             {
 179                 //  Check whether the entry is an impress template.  If so
 180                 //  add a new entry to the resulting list (which is created
 181                 //  first if necessary).
 182                 //  These strings are used to find impress templates in the tree of
 183                 //  template files.  Should probably be determined dynamically.
 184                 if (    (sContentType == MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE_ASCII)
 185                     ||  (sContentType == MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_ASCII)
 186                     ||  (sContentType == "application/vnd.stardivision.impress")
 187                     ||  (sContentType == MIMETYPE_VND_SUN_XML_IMPRESS_ASCII)
 188                         // The following id comes from the bugdoc in #i2764#.
 189                     ||  (sContentType == "Impress 2.0"))
 190                 {
 191                     OUString sLocalisedTitle = SfxDocumentTemplates::ConvertResourceString(sTitle);
 192                     mpTemplateEntries.push_back(std::make_unique<TemplateEntry>(sLocalisedTitle, sTargetURL));
 193                 }
 194             }
 195
 196             // Continue scanning entries.
 197             eNextState = SCAN_ENTRY;
 198         }
 199         else
 200         {
 201             // Continue with scanning the next folder.
 202             eNextState = SCAN_FOLDER;
 203         }
 204     }
 205
 206     return eNextState;
 207 }
 208
 209 TemplateScanner::State TemplateScanner::InitializeFolderScanning()
 210 {
 211     State eNextState (ERROR);
 212
 213     mxFolderResultSet.clear();
 214
 215     try
 216     {
 217         //  Create content for template folders.
 218         mxFolderEnvironment.clear();
 219         ::ucbhelper::Content aTemplateDir (mxTemplateRoot, mxFolderEnvironment, comphelper::getProcessComponentContext());
 220
 221         //  Define the list of properties we are interested in.
 222         Sequence<OUString> aProps (2);
 223         aProps[0] = TITLE;
 224         aProps[1] = "TargetDirURL";
 225
 226         //  Create an cursor to iterate over the template folders.
 227         mxFolderResultSet.set( aTemplateDir.createCursor(aProps, ::ucbhelper::INCLUDE_FOLDERS_ONLY));
 228         if (mxFolderResultSet.is())
 229             eNextState = GATHER_FOLDER_LIST;
 230     }
 231     catch (css::uno::Exception&)
 232     {
 233        eNextState = ERROR;
 234     }
 235
 236     return eNextState;
 237 }
 238
 239 TemplateScanner::State TemplateScanner::GatherFolderList()
 240 {
 241     State eNextState (ERROR);
 242
 243     Reference<css::ucb::XContentAccess> xContentAccess (mxFolderResultSet, UNO_QUERY);
 244     if (xContentAccess.is() && mxFolderResultSet.is())
 245     {
 246         while (mxFolderResultSet->next())
 247         {
 248             Reference<sdbc::XRow> xRow (mxFolderResultSet, UNO_QUERY);
 249             if (xRow.is())
 250             {
 251                 OUString sTitle (xRow->getString (1));
 252                 OUString sTargetDir (xRow->getString (2));
 253                 OUString aId = xContentAccess->queryContentIdentifierString();
 254
 255                 mpFolderDescriptors->insert(
 256                     FolderDescriptor(
 257                         Classify(sTitle,sTargetDir),
 258                         aId,
 259                         mxFolderEnvironment));
 260             }
 261         }
 262
 263         eNextState = SCAN_FOLDER;
 264     }
 265
 266     return eNextState;
 267 }
 268
 269 TemplateScanner::State TemplateScanner::ScanFolder()
 270 {
 271     State eNextState (ERROR);
 272
 273     if (!mpFolderDescriptors->empty())
 274     {
 275         FolderDescriptor aDescriptor (*mpFolderDescriptors->begin());
 276         mpFolderDescriptors->erase(mpFolderDescriptors->begin());
 277
 278         OUString aId (aDescriptor.msContentIdentifier);
 279
 280         maFolderContent = ::ucbhelper::Content (aId, aDescriptor.mxFolderEnvironment, comphelper::getProcessComponentContext());
 281         if (maFolderContent.isFolder())
 282         {
 283             // Scan the folder and insert it into the list of template
 284             // folders.
 285             // Continue with scanning all entries in the folder.
 286             mpTemplateEntries.clear();
 287             eNextState = INITIALIZE_ENTRY_SCAN;
 288         }
 289     }
 290     else
 291     {
 292         eNextState = DONE;
 293     }
 294
 295     return eNextState;
 296 }
 297
 298 void TemplateScanner::RunNextStep()
 299 {
 300     switch (meState)
 301     {
 302         case INITIALIZE_SCANNING:
 303             meState = GetTemplateRoot();
 304             break;
 305
 306         case INITIALIZE_FOLDER_SCANNING:
 307             meState = InitializeFolderScanning();
 308             break;
 309
 310         case SCAN_FOLDER:
 311             meState = ScanFolder();
 312             break;
 313
 314         case GATHER_FOLDER_LIST:
 315             meState = GatherFolderList();
 316             break;
 317
 318         case INITIALIZE_ENTRY_SCAN:
 319             meState = InitializeEntryScanning();
 320             break;
 321
 322         case SCAN_ENTRY:
 323             meState = ScanEntry();
 324             break;
 325         default:
 326             break;
 327     }
 328
 329     switch (meState)
 330     {
 331         case DONE:
 332         case ERROR:
 333             mxTemplateRoot.clear();
 334             mxFolderEnvironment.clear();
 335             mxEntryEnvironment.clear();
 336             mxFolderResultSet.clear();
 337             mxEntryResultSet.clear();
 338             break;
 339         default:
 340             break;
 341     }
 342 }
 343
 344 bool TemplateScanner::HasNextStep()
 345 {
 346     switch (meState)
 347     {
 348         case DONE:
 349         case ERROR:
 350             return false;
 351
 352         default:
 353             return true;
 354     }
 355 }
 356
 357 }
 358
 359 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */