sd/source/ui/toolpanel/controls/MasterPageContainerProviders.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: MasterPageContainerProviders.cxx,v $
  10  * $Revision: 1.5 $
  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 "MasterPageContainerProviders.hxx"
  35
  36 #include "DrawDocShell.hxx"
  37 #include "drawdoc.hxx"
  38 #include "PreviewRenderer.hxx"
  39 #include <comphelper/processfactory.hxx>
  40 #include <sfx2/app.hxx>
  41 #include <sfx2/sfxsids.hrc>
  42 #include <unotools/ucbstreamhelper.hxx>
  43 #include <vcl/image.hxx>
  44 #include <vcl/pngread.hxx>
  45 #include <com/sun/star/embed/ElementModes.hpp>
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::uno;
  49 using namespace ::sd::toolpanel::controls;
  50
  51
  52 namespace sd { namespace toolpanel { namespace controls {
  53
  54
  55 //===== PagePreviewProvider ===================================================
  56
  57 PagePreviewProvider::PagePreviewProvider (void)
  58 {
  59 }
  60
  61
  62
  63
  64 Image PagePreviewProvider::operator () (
  65     int nWidth,
  66     SdPage* pPage,
  67     ::sd::PreviewRenderer& rRenderer)
  68 {
  69     Image aPreview;
  70
  71     if (pPage != NULL)
  72     {
  73         // Use the given renderer to create a preview of the given page
  74         // object.
  75         aPreview = rRenderer.RenderPage(
  76             pPage,
  77             nWidth,
  78             String::CreateFromAscii(""),
  79             false);
  80     }
  81
  82     return aPreview;
  83 }
  84
  85
  86
  87
  88 int PagePreviewProvider::GetCostIndex (void)
  89 {
  90     return 5;
  91 }
  92
  93
  94
  95
  96 bool PagePreviewProvider::NeedsPageObject (void)
  97 {
  98     return true;
  99 }
 100
 101
 102
 103
 104 //===== TemplatePreviewProvider ===============================================
 105
 106 TemplatePreviewProvider::TemplatePreviewProvider (const ::rtl::OUString& rsURL)
 107     : msURL(rsURL)
 108 {
 109 }
 110
 111
 112
 113
 114 Image TemplatePreviewProvider::operator() (
 115     int nWidth,
 116     SdPage* pPage,
 117     ::sd::PreviewRenderer& rRenderer)
 118 {
 119     // Unused parameters.
 120     (void)nWidth;
 121     (void)pPage;
 122     (void)rRenderer;
 123
 124     // Load the thumbnail from a template document.
 125     uno::Reference<io::XInputStream> xIStream;
 126
 127     uno::Reference< lang::XMultiServiceFactory > xServiceManager (
 128         ::comphelper::getProcessServiceFactory());
 129     if (xServiceManager.is())
 130     {
 131         try
 132         {
 133             uno::Reference<lang::XSingleServiceFactory> xStorageFactory(
 134                 xServiceManager->createInstance(
 135                     ::rtl::OUString::createFromAscii(
 136                         "com.sun.star.embed.StorageFactory")),
 137                 uno::UNO_QUERY);
 138
 139             if (xStorageFactory.is())
 140             {
 141                 uno::Sequence<uno::Any> aArgs (2);
 142                 aArgs[0] <<= msURL;
 143                 aArgs[1] <<= embed::ElementModes::READ;
 144                 uno::Reference<embed::XStorage> xDocStorage (
 145                     xStorageFactory->createInstanceWithArguments(aArgs),
 146                     uno::UNO_QUERY);
 147
 148                 try
 149                 {
 150                     if (xDocStorage.is())
 151                     {
 152                         uno::Reference<embed::XStorage> xStorage (
 153                             xDocStorage->openStorageElement(
 154                                 ::rtl::OUString::createFromAscii("Thumbnails"),
 155                                 embed::ElementModes::READ));
 156                         if (xStorage.is())
 157                         {
 158                             uno::Reference<io::XStream> xThumbnailCopy (
 159                                 xStorage->cloneStreamElement(
 160                                     ::rtl::OUString::createFromAscii(
 161                                         "thumbnail.png")));
 162                             if (xThumbnailCopy.is())
 163                                 xIStream = xThumbnailCopy->getInputStream();
 164                         }
 165                     }
 166                 }
 167                 catch (uno::Exception& rException)
 168                 {
 169                     OSL_TRACE (
 170                         "caught exception while trying to access Thumbnail/thumbnail.png of %s: %s",
 171                         ::rtl::OUStringToOString(msURL,
 172                             RTL_TEXTENCODING_UTF8).getStr(),
 173                         ::rtl::OUStringToOString(rException.Message,
 174                             RTL_TEXTENCODING_UTF8).getStr());
 175                 }
 176
 177                 try
 178                 {
 179                     // An (older) implementation had a bug - The storage
 180                     // name was "Thumbnail" instead of "Thumbnails".  The
 181                     // old name is still used as fallback but this code can
 182                     // be removed soon.
 183                     if ( ! xIStream.is())
 184                     {
 185                         uno::Reference<embed::XStorage> xStorage (
 186                             xDocStorage->openStorageElement(
 187                                 ::rtl::OUString::createFromAscii("Thumbnail"),
 188                                 embed::ElementModes::READ));
 189                         if (xStorage.is())
 190                         {
 191                             uno::Reference<io::XStream> xThumbnailCopy (
 192                                 xStorage->cloneStreamElement(
 193                                     ::rtl::OUString::createFromAscii(
 194                                         "thumbnail.png")));
 195                             if (xThumbnailCopy.is())
 196                                 xIStream = xThumbnailCopy->getInputStream();
 197                         }
 198                     }
 199                 }
 200                 catch (uno::Exception& rException)
 201                 {
 202                     OSL_TRACE (
 203                         "caught exception while trying to access Thumbnails/thumbnail.png of %s: %s",
 204                         ::rtl::OUStringToOString(msURL,
 205                             RTL_TEXTENCODING_UTF8).getStr(),
 206                         ::rtl::OUStringToOString(rException.Message,
 207                             RTL_TEXTENCODING_UTF8).getStr());
 208                 }
 209             }
 210         }
 211         catch (uno::Exception& rException)
 212         {
 213             OSL_TRACE (
 214                 "caught exception while trying to access tuhmbnail of %s: %s",
 215                 ::rtl::OUStringToOString(msURL,
 216                     RTL_TEXTENCODING_UTF8).getStr(),
 217                 ::rtl::OUStringToOString(rException.Message,
 218                     RTL_TEXTENCODING_UTF8).getStr());
 219         }
 220     }
 221
 222     // Extract the image from the stream.
 223     BitmapEx aThumbnail;
 224     if (xIStream.is())
 225     {
 226         ::std::auto_ptr<SvStream> pStream (
 227             ::utl::UcbStreamHelper::CreateStream (xIStream));
 228         ::vcl::PNGReader aReader (*pStream);
 229         aThumbnail = aReader.Read ();
 230     }
 231
 232     // Note that the preview is returned without scaling it to the desired
 233     // width.  This gives the caller the chance to take advantage of a
 234     // possibly larger resolution then was asked for.
 235     return aThumbnail;
 236 }
 237
 238
 239
 240
 241 int TemplatePreviewProvider::GetCostIndex (void)
 242 {
 243     return 10;
 244 }
 245
 246
 247
 248
 249 bool TemplatePreviewProvider::NeedsPageObject (void)
 250 {
 251     return false;
 252 }
 253
 254
 255
 256
 257 //===== TemplatePageObjectProvider =============================================
 258
 259 TemplatePageObjectProvider::TemplatePageObjectProvider (const ::rtl::OUString& rsURL)
 260     : msURL(rsURL),
 261       mxDocumentShell()
 262 {
 263 }
 264
 265
 266
 267
 268 SdPage* TemplatePageObjectProvider::operator() (SdDrawDocument* pContainerDocument)
 269 {
 270     // Unused parameters.
 271     (void)pContainerDocument;
 272
 273     SdPage* pPage = NULL;
 274
 275     mxDocumentShell = NULL;
 276     ::sd::DrawDocShell* pDocumentShell = NULL;
 277     try
 278     {
 279         // Load the template document and return its first page.
 280         pDocumentShell = LoadDocument (msURL);
 281         if (pDocumentShell != NULL)
 282         {
 283             SdDrawDocument* pDocument = pDocumentShell->GetDoc();
 284             if (pDocument != NULL)
 285             {
 286                 pPage = pDocument->GetMasterSdPage(0, PK_STANDARD);
 287                 // In order to make the newly loaded master page deletable
 288                 // when copied into documents it is marked as no "precious".
 289                 // When it is modified then it is marked as "precious".
 290                 if (pPage != NULL)
 291                     pPage->SetPrecious(false);
 292             }
 293         }
 294     }
 295     catch (uno::RuntimeException)
 296     {
 297         OSL_TRACE ("caught exception while loading page from template file");
 298         pPage = NULL;
 299     }
 300
 301     return pPage;
 302 }
 303
 304
 305
 306
 307 ::sd::DrawDocShell* TemplatePageObjectProvider::LoadDocument (const ::rtl::OUString& sFileName)
 308 {
 309     SfxApplication* pSfxApp = SFX_APP();
 310     SfxItemSet* pSet = new SfxAllItemSet (pSfxApp->GetPool());
 311     pSet->Put (SfxBoolItem (SID_TEMPLATE, TRUE));
 312     pSet->Put (SfxBoolItem (SID_PREVIEW, TRUE));
 313     if (pSfxApp->LoadTemplate (mxDocumentShell, sFileName, TRUE, pSet))
 314     {
 315         mxDocumentShell = NULL;
 316     }
 317     SfxObjectShell* pShell = mxDocumentShell;
 318     return PTR_CAST(::sd::DrawDocShell,pShell);
 319 }
 320
 321
 322
 323
 324 int TemplatePageObjectProvider::GetCostIndex (void)
 325 {
 326     return 20;
 327 }
 328
 329
 330
 331
 332 bool TemplatePageObjectProvider::operator== (const PageObjectProvider& rProvider)
 333 {
 334     const TemplatePageObjectProvider* pTemplatePageObjectProvider
 335         = dynamic_cast<const TemplatePageObjectProvider*>(&rProvider);
 336     if (pTemplatePageObjectProvider != NULL)
 337         return (msURL == pTemplatePageObjectProvider->msURL);
 338     else
 339         return false;
 340 }
 341
 342
 343
 344
 345 //===== DefaultPageObjectProvider ==============================================
 346
 347 DefaultPageObjectProvider::DefaultPageObjectProvider (void)
 348 {
 349 }
 350
 351
 352
 353
 354 SdPage* DefaultPageObjectProvider::operator () (SdDrawDocument* pContainerDocument)
 355 {
 356     SdPage* pLocalMasterPage = NULL;
 357     if (pContainerDocument != NULL)
 358     {
 359         sal_Int32 nIndex (0);
 360         SdPage* pLocalSlide = pContainerDocument->GetSdPage((USHORT)nIndex, PK_STANDARD);
 361         if (pLocalSlide!=NULL && pLocalSlide->TRG_HasMasterPage())
 362             pLocalMasterPage = dynamic_cast<SdPage*>(&pLocalSlide->TRG_GetMasterPage());
 363     }
 364
 365     if (pLocalMasterPage == NULL)
 366     {
 367         DBG_ASSERT(false, "can not create master page for slide");
 368     }
 369
 370     return pLocalMasterPage;
 371 }
 372
 373
 374
 375
 376 int DefaultPageObjectProvider::GetCostIndex (void)
 377 {
 378     return 15;
 379 }
 380
 381
 382
 383
 384 bool DefaultPageObjectProvider::operator== (const PageObjectProvider& rProvider)
 385 {
 386     return (dynamic_cast<const DefaultPageObjectProvider*>(&rProvider) != NULL);
 387 }
 388
 389
 390
 391
 392 //===== DefaultPagePreviewProvider ============================================
 393
 394 DefaultPagePreviewProvider::DefaultPagePreviewProvider (void)
 395 {
 396 }
 397
 398
 399
 400 Image DefaultPagePreviewProvider::operator() (
 401     int nWidth,
 402     SdPage* pPage,
 403     ::sd::PreviewRenderer& rRenderer)
 404 {
 405     // Unused parameters.
 406     (void)nWidth;
 407     (void)pPage;
 408     (void)rRenderer;
 409
 410     return Image();
 411 }
 412
 413
 414
 415
 416 int DefaultPagePreviewProvider::GetCostIndex (void)
 417 {
 418     return 0;
 419 }
 420
 421
 422
 423
 424 bool DefaultPagePreviewProvider::NeedsPageObject (void)
 425 {
 426     return false;
 427 }
 428
 429
 430
 431
 432 //===== ExistingPageProvider ==================================================
 433
 434 ExistingPageProvider::ExistingPageProvider (SdPage* pPage)
 435     : mpPage(pPage)
 436 {
 437 }
 438
 439
 440
 441
 442 SdPage* ExistingPageProvider::operator() (SdDrawDocument* pDocument)
 443 {
 444     (void)pDocument; // Unused parameter.
 445
 446     return mpPage;
 447 }
 448
 449
 450
 451
 452 int ExistingPageProvider::GetCostIndex (void)
 453 {
 454     return 0;
 455 }
 456
 457
 458
 459
 460 bool ExistingPageProvider::operator== (const PageObjectProvider& rProvider)
 461 {
 462     const ExistingPageProvider* pExistingPageProvider
 463         = dynamic_cast<const ExistingPageProvider*>(&rProvider);
 464     if (pExistingPageProvider != NULL)
 465         return (mpPage == pExistingPageProvider->mpPage);
 466     else
 467         return false;
 468 }
 469
 470
 471 } } } // end of namespace ::sd::toolpanel::controls