sd/source/ui/toolpanel/controls/MasterPageContainerProviders.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_sd.hxx"
  30
  31 #include "MasterPageContainerProviders.hxx"
  32
  33 #include "DrawDocShell.hxx"
  34 #include "drawdoc.hxx"
  35 #include "PreviewRenderer.hxx"
  36 #include <comphelper/processfactory.hxx>
  37 #include <sfx2/app.hxx>
  38 #include <sfx2/sfxsids.hrc>
  39 #include <unotools/ucbstreamhelper.hxx>
  40 #include <vcl/image.hxx>
  41 #include <vcl/pngread.hxx>
  42 #include <com/sun/star/embed/ElementModes.hpp>
  43 #include <tools/diagnose_ex.h>
  44
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::uno;
  47 using namespace ::sd::toolpanel::controls;
  48
  49
  50 namespace sd { namespace toolpanel { namespace controls {
  51
  52
  53 //===== PagePreviewProvider ===================================================
  54
  55 PagePreviewProvider::PagePreviewProvider (void)
  56 {
  57 }
  58
  59
  60
  61
  62 Image PagePreviewProvider::operator () (
  63     int nWidth,
  64     SdPage* pPage,
  65     ::sd::PreviewRenderer& rRenderer)
  66 {
  67     Image aPreview;
  68
  69     if (pPage != NULL)
  70     {
  71         // Use the given renderer to create a preview of the given page
  72         // object.
  73         aPreview = rRenderer.RenderPage(
  74             pPage,
  75             nWidth,
  76             String::CreateFromAscii(""),
  77             false);
  78     }
  79
  80     return aPreview;
  81 }
  82
  83
  84
  85
  86 int PagePreviewProvider::GetCostIndex (void)
  87 {
  88     return 5;
  89 }
  90
  91
  92
  93
  94 bool PagePreviewProvider::NeedsPageObject (void)
  95 {
  96     return true;
  97 }
  98
  99
 100
 101
 102 //===== TemplatePreviewProvider ===============================================
 103
 104 TemplatePreviewProvider::TemplatePreviewProvider (const ::rtl::OUString& rsURL)
 105     : msURL(rsURL)
 106 {
 107 }
 108
 109
 110
 111
 112 Image TemplatePreviewProvider::operator() (
 113     int nWidth,
 114     SdPage* pPage,
 115     ::sd::PreviewRenderer& rRenderer)
 116 {
 117     // Unused parameters.
 118     (void)nWidth;
 119     (void)pPage;
 120     (void)rRenderer;
 121
 122     // Load the thumbnail from a template document.
 123     uno::Reference<io::XInputStream> xIStream;
 124
 125     uno::Reference< lang::XMultiServiceFactory > xServiceManager (
 126         ::comphelper::getProcessServiceFactory());
 127     if (xServiceManager.is())
 128     {
 129         try
 130         {
 131             uno::Reference<lang::XSingleServiceFactory> xStorageFactory(
 132                 xServiceManager->createInstance(
 133                     ::rtl::OUString::createFromAscii(
 134                         "com.sun.star.embed.StorageFactory")),
 135                 uno::UNO_QUERY);
 136
 137             if (xStorageFactory.is())
 138             {
 139                 uno::Sequence<uno::Any> aArgs (2);
 140                 aArgs[0] <<= msURL;
 141                 aArgs[1] <<= embed::ElementModes::READ;
 142                 uno::Reference<embed::XStorage> xDocStorage (
 143                     xStorageFactory->createInstanceWithArguments(aArgs),
 144                     uno::UNO_QUERY);
 145
 146                 try
 147                 {
 148                     if (xDocStorage.is())
 149                     {
 150                         uno::Reference<embed::XStorage> xStorage (
 151                             xDocStorage->openStorageElement(
 152                                 ::rtl::OUString::createFromAscii("Thumbnails"),
 153                                 embed::ElementModes::READ));
 154                         if (xStorage.is())
 155                         {
 156                             uno::Reference<io::XStream> xThumbnailCopy (
 157                                 xStorage->cloneStreamElement(
 158                                     ::rtl::OUString::createFromAscii(
 159                                         "thumbnail.png")));
 160                             if (xThumbnailCopy.is())
 161                                 xIStream = xThumbnailCopy->getInputStream();
 162                         }
 163                     }
 164                 }
 165                 catch (uno::Exception& rException)
 166                 {
 167                     OSL_TRACE (
 168                         "caught exception while trying to access Thumbnail/thumbnail.png of %s: %s",
 169                         ::rtl::OUStringToOString(msURL,
 170                             RTL_TEXTENCODING_UTF8).getStr(),
 171                         ::rtl::OUStringToOString(rException.Message,
 172                             RTL_TEXTENCODING_UTF8).getStr());
 173                 }
 174
 175                 try
 176                 {
 177                     // An (older) implementation had a bug - The storage
 178                     // name was "Thumbnail" instead of "Thumbnails".  The
 179                     // old name is still used as fallback but this code can
 180                     // be removed soon.
 181                     if ( ! xIStream.is())
 182                     {
 183                         uno::Reference<embed::XStorage> xStorage (
 184                             xDocStorage->openStorageElement(
 185                                 ::rtl::OUString::createFromAscii("Thumbnail"),
 186                                 embed::ElementModes::READ));
 187                         if (xStorage.is())
 188                         {
 189                             uno::Reference<io::XStream> xThumbnailCopy (
 190                                 xStorage->cloneStreamElement(
 191                                     ::rtl::OUString::createFromAscii(
 192                                         "thumbnail.png")));
 193                             if (xThumbnailCopy.is())
 194                                 xIStream = xThumbnailCopy->getInputStream();
 195                         }
 196                     }
 197                 }
 198                 catch (uno::Exception& rException)
 199                 {
 200                     OSL_TRACE (
 201                         "caught exception while trying to access Thumbnails/thumbnail.png of %s: %s",
 202                         ::rtl::OUStringToOString(msURL,
 203                             RTL_TEXTENCODING_UTF8).getStr(),
 204                         ::rtl::OUStringToOString(rException.Message,
 205                             RTL_TEXTENCODING_UTF8).getStr());
 206                 }
 207             }
 208         }
 209         catch (uno::Exception& rException)
 210         {
 211             OSL_TRACE (
 212                 "caught exception while trying to access tuhmbnail of %s: %s",
 213                 ::rtl::OUStringToOString(msURL,
 214                     RTL_TEXTENCODING_UTF8).getStr(),
 215                 ::rtl::OUStringToOString(rException.Message,
 216                     RTL_TEXTENCODING_UTF8).getStr());
 217         }
 218     }
 219
 220     // Extract the image from the stream.
 221     BitmapEx aThumbnail;
 222     if (xIStream.is())
 223     {
 224         ::std::auto_ptr<SvStream> pStream (
 225             ::utl::UcbStreamHelper::CreateStream (xIStream));
 226         ::vcl::PNGReader aReader (*pStream);
 227         aThumbnail = aReader.Read ();
 228     }
 229
 230     // Note that the preview is returned without scaling it to the desired
 231     // width.  This gives the caller the chance to take advantage of a
 232     // possibly larger resolution then was asked for.
 233     return aThumbnail;
 234 }
 235
 236
 237
 238
 239 int TemplatePreviewProvider::GetCostIndex (void)
 240 {
 241     return 10;
 242 }
 243
 244
 245
 246
 247 bool TemplatePreviewProvider::NeedsPageObject (void)
 248 {
 249     return false;
 250 }
 251
 252
 253
 254
 255 //===== TemplatePageObjectProvider =============================================
 256
 257 TemplatePageObjectProvider::TemplatePageObjectProvider (const ::rtl::OUString& rsURL)
 258     : msURL(rsURL),
 259       mxDocumentShell()
 260 {
 261 }
 262
 263
 264
 265
 266 SdPage* TemplatePageObjectProvider::operator() (SdDrawDocument* pContainerDocument)
 267 {
 268     // Unused parameters.
 269     (void)pContainerDocument;
 270
 271     SdPage* pPage = NULL;
 272
 273     mxDocumentShell = NULL;
 274     ::sd::DrawDocShell* pDocumentShell = NULL;
 275     try
 276     {
 277         // Load the template document and return its first page.
 278         pDocumentShell = LoadDocument (msURL);
 279         if (pDocumentShell != NULL)
 280         {
 281             SdDrawDocument* pDocument = pDocumentShell->GetDoc();
 282             if (pDocument != NULL)
 283             {
 284                 pPage = pDocument->GetMasterSdPage(0, PK_STANDARD);
 285                 // In order to make the newly loaded master page deletable
 286                 // when copied into documents it is marked as no "precious".
 287                 // When it is modified then it is marked as "precious".
 288                 if (pPage != NULL)
 289                     pPage->SetPrecious(false);
 290             }
 291         }
 292     }
 293     catch (uno::RuntimeException)
 294     {
 295         DBG_UNHANDLED_EXCEPTION();
 296         pPage = NULL;
 297     }
 298
 299     return pPage;
 300 }
 301
 302
 303
 304
 305 ::sd::DrawDocShell* TemplatePageObjectProvider::LoadDocument (const ::rtl::OUString& sFileName)
 306 {
 307     SfxApplication* pSfxApp = SFX_APP();
 308     SfxItemSet* pSet = new SfxAllItemSet (pSfxApp->GetPool());
 309     pSet->Put (SfxBoolItem (SID_TEMPLATE, sal_True));
 310     pSet->Put (SfxBoolItem (SID_PREVIEW, sal_True));
 311     if (pSfxApp->LoadTemplate (mxDocumentShell, sFileName, sal_True, pSet))
 312     {
 313         mxDocumentShell = NULL;
 314     }
 315     SfxObjectShell* pShell = mxDocumentShell;
 316     return PTR_CAST(::sd::DrawDocShell,pShell);
 317 }
 318
 319
 320
 321
 322 int TemplatePageObjectProvider::GetCostIndex (void)
 323 {
 324     return 20;
 325 }
 326
 327
 328
 329
 330 bool TemplatePageObjectProvider::operator== (const PageObjectProvider& rProvider)
 331 {
 332     const TemplatePageObjectProvider* pTemplatePageObjectProvider
 333         = dynamic_cast<const TemplatePageObjectProvider*>(&rProvider);
 334     if (pTemplatePageObjectProvider != NULL)
 335         return (msURL == pTemplatePageObjectProvider->msURL);
 336     else
 337         return false;
 338 }
 339
 340
 341
 342
 343 //===== DefaultPageObjectProvider ==============================================
 344
 345 DefaultPageObjectProvider::DefaultPageObjectProvider (void)
 346 {
 347 }
 348
 349
 350
 351
 352 SdPage* DefaultPageObjectProvider::operator () (SdDrawDocument* pContainerDocument)
 353 {
 354     SdPage* pLocalMasterPage = NULL;
 355     if (pContainerDocument != NULL)
 356     {
 357         sal_Int32 nIndex (0);
 358         SdPage* pLocalSlide = pContainerDocument->GetSdPage((sal_uInt16)nIndex, PK_STANDARD);
 359         if (pLocalSlide!=NULL && pLocalSlide->TRG_HasMasterPage())
 360             pLocalMasterPage = dynamic_cast<SdPage*>(&pLocalSlide->TRG_GetMasterPage());
 361     }
 362
 363     if (pLocalMasterPage == NULL)
 364     {
 365         DBG_ASSERT(false, "can not create master page for slide");
 366     }
 367
 368     return pLocalMasterPage;
 369 }
 370
 371
 372
 373
 374 int DefaultPageObjectProvider::GetCostIndex (void)
 375 {
 376     return 15;
 377 }
 378
 379
 380
 381
 382 bool DefaultPageObjectProvider::operator== (const PageObjectProvider& rProvider)
 383 {
 384     return (dynamic_cast<const DefaultPageObjectProvider*>(&rProvider) != NULL);
 385 }
 386
 387
 388
 389
 390 //===== ExistingPageProvider ==================================================
 391
 392 ExistingPageProvider::ExistingPageProvider (SdPage* pPage)
 393     : mpPage(pPage)
 394 {
 395 }
 396
 397
 398
 399
 400 SdPage* ExistingPageProvider::operator() (SdDrawDocument* pDocument)
 401 {
 402     (void)pDocument; // Unused parameter.
 403
 404     return mpPage;
 405 }
 406
 407
 408
 409
 410 int ExistingPageProvider::GetCostIndex (void)
 411 {
 412     return 0;
 413 }
 414
 415
 416
 417
 418 bool ExistingPageProvider::operator== (const PageObjectProvider& rProvider)
 419 {
 420     const ExistingPageProvider* pExistingPageProvider
 421         = dynamic_cast<const ExistingPageProvider*>(&rProvider);
 422     if (pExistingPageProvider != NULL)
 423         return (mpPage == pExistingPageProvider->mpPage);
 424     else
 425         return false;
 426 }
 427
 428
 429 } } } // end of namespace ::sd::toolpanel::controls