svx/source/gallery2/galleryfilestorage.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 <svx/unomodel.hxx>
  21 #include <svx/fmmodel.hxx>
  22 #include <svx/galtheme.hxx>
  23 #include <galobj.hxx>
  24 #include <galleryfilestorage.hxx>
  25 #include <svx/galleryobjectcollection.hxx>
  26 #include <svx/gallery1.hxx>
  27 #include "codec.hxx"
  28 #include "gallerydrawmodel.hxx"
  29 #include <vcl/cvtgrf.hxx>
  30 #include <vcl/filter/SvmWriter.hxx>
  31
  32 #include <sal/log.hxx>
  33
  34 #include <com/sun/star/ucb/ContentCreationException.hpp>
  35 #include <com/sun/star/sdbc/XResultSet.hpp>
  36 #include <com/sun/star/ucb/XContentAccess.hpp>
  37 #include <comphelper/fileformat.h>
  38 #include <comphelper/graphicmimetype.hxx>
  39 #include <comphelper/processfactory.hxx>
  40 #include <tools/urlobj.hxx>
  41 #include <comphelper/diagnose_ex.hxx>
  42 #include <tools/datetime.hxx>
  43 #include <unotools/datetime.hxx>
  44 #include <unotools/ucbstreamhelper.hxx>
  45 #include <unotools/streamwrap.hxx>
  46 #include <unotools/tempfile.hxx>
  47 #include <ucbhelper/content.hxx>
  48 #include <tools/vcompat.hxx>
  49
  50 using namespace ::com::sun::star;
  51
  52 GalleryFileStorage::GalleryFileStorage(
  53     const GalleryStorageLocations& rGalleryBinaryStorageLocations,
  54     GalleryObjectCollection& rGalleryObjectCollection, bool bReadOnly)
  55     : maGalleryStorageLocations(rGalleryBinaryStorageLocations)
  56     , mrGalleryObjectCollection(rGalleryObjectCollection)
  57     , mbReadOnly(bReadOnly)
  58     , m_bDestDirRelative(false)
  59 {
  60     ImplCreateSvDrawStorage();
  61 }
  62
  63 GalleryFileStorage::~GalleryFileStorage() { clearSotStorage(); }
  64
  65 void GalleryFileStorage::setDestDir(const OUString& rDestDir, bool bRelative)
  66 {
  67     m_aDestDir = rDestDir;
  68     m_bDestDirRelative = bRelative;
  69 }
  70
  71 void GalleryFileStorage::clearSotStorage() { m_aSvDrawStorageRef.clear(); }
  72
  73 void GalleryFileStorage::ImplCreateSvDrawStorage()
  74 {
  75     try
  76     {
  77         m_aSvDrawStorageRef
  78             = new SotStorage(false, GetSdvURL().GetMainURL(INetURLObject::DecodeMechanism::NONE),
  79                              mbReadOnly ? StreamMode::READ : StreamMode::STD_READWRITE);
  80         // #i50423# ReadOnly may not been set though the file can't be written (because of security reasons)
  81         if ((m_aSvDrawStorageRef->GetError() != ERRCODE_NONE) && !mbReadOnly)
  82             m_aSvDrawStorageRef = new SotStorage(
  83                 false, GetSdvURL().GetMainURL(INetURLObject::DecodeMechanism::NONE),
  84                 StreamMode::READ);
  85     }
  86     catch (const css::ucb::ContentCreationException&)
  87     {
  88         TOOLS_WARN_EXCEPTION("svx", "failed to open: " << GetSdvURL().GetMainURL(
  89                                                               INetURLObject::DecodeMechanism::NONE)
  90                                                        << "due to");
  91     }
  92 }
  93
  94 const rtl::Reference<SotStorage>& GalleryFileStorage::GetSvDrawStorage() const
  95 {
  96     return m_aSvDrawStorageRef;
  97 }
  98
  99 bool GalleryFileStorage::implWrite(const GalleryTheme& rTheme, const GalleryThemeEntry* pThm)
 100 {
 101     INetURLObject aPathURL(GetThmURL());
 102
 103     aPathURL.removeSegment();
 104     aPathURL.removeFinalSlash();
 105
 106     DBG_ASSERT(aPathURL.GetProtocol() != INetProtocol::NotValid, "invalid URL");
 107
 108     if (FileExists(aPathURL) || CreateDir(aPathURL))
 109     {
 110 #ifdef UNX
 111         std::unique_ptr<SvStream> pOStm(::utl::UcbStreamHelper::CreateStream(
 112             GetThmURL().GetMainURL(INetURLObject::DecodeMechanism::NONE),
 113             StreamMode::WRITE | StreamMode::COPY_ON_SYMLINK | StreamMode::TRUNC));
 114 #else
 115         std::unique_ptr<SvStream> pOStm(::utl::UcbStreamHelper::CreateStream(
 116             GetThmURL().GetMainURL(INetURLObject::DecodeMechanism::NONE),
 117             StreamMode::WRITE | StreamMode::TRUNC));
 118 #endif
 119
 120         if (pOStm)
 121         {
 122             writeGalleryTheme(*pOStm, rTheme, pThm);
 123             pOStm.reset();
 124             return true;
 125         }
 126
 127         return false;
 128     }
 129     return true;
 130 }
 131
 132 void GalleryFileStorage::insertObject(const SgaObject& rObj, GalleryObject* pFoundEntry,
 133                                       sal_uInt32 nInsertPos)
 134 {
 135     if (pFoundEntry)
 136     {
 137         GalleryObject aNewEntry;
 138
 139         // update title of new object if necessary
 140         if (rObj.GetTitle().isEmpty())
 141         {
 142             std::unique_ptr<SgaObject> pOldObj(implReadSgaObject(pFoundEntry));
 143
 144             if (pOldObj)
 145             {
 146                 const_cast<SgaObject&>(rObj).SetTitle(pOldObj->GetTitle());
 147             }
 148         }
 149         else if (rObj.GetTitle() == "__<empty>__")
 150             const_cast<SgaObject&>(rObj).SetTitle("");
 151
 152         implWriteSgaObject(rObj, nInsertPos, &aNewEntry);
 153         pFoundEntry->nOffset = aNewEntry.nOffset;
 154     }
 155     else
 156         implWriteSgaObject(rObj, nInsertPos, nullptr);
 157 }
 158
 159 void GalleryFileStorage::removeObject(const std::unique_ptr<GalleryObject>& pEntry)
 160 {
 161     if (mrGalleryObjectCollection.getObjectList().empty())
 162         KillFile(GetSdgURL());
 163
 164     if (SgaObjKind::SvDraw == pEntry->eObjKind)
 165         GetSvDrawStorage()->Remove(
 166             pEntry->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE));
 167 }
 168
 169 std::unique_ptr<SgaObject> GalleryFileStorage::implReadSgaObject(GalleryObject const* pEntry)
 170 {
 171     std::unique_ptr<SgaObject> pSgaObj;
 172
 173     if (pEntry)
 174     {
 175         std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream(
 176             GetSdgURL().GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ));
 177
 178         if (pIStm)
 179         {
 180             sal_uInt32 nInventor;
 181
 182             // Check to ensure that the file is a valid SGA file
 183             pIStm->Seek(pEntry->nOffset);
 184             pIStm->ReadUInt32(nInventor);
 185
 186             if (nInventor == COMPAT_FORMAT('S', 'G', 'A', '3'))
 187             {
 188                 pIStm->Seek(pEntry->nOffset);
 189
 190                 switch (pEntry->eObjKind)
 191                 {
 192                     case SgaObjKind::Bitmap:
 193                         pSgaObj.reset(new SgaObjectBmp());
 194                         break;
 195                     case SgaObjKind::Animation:
 196                         pSgaObj.reset(new SgaObjectAnim());
 197                         break;
 198                     case SgaObjKind::Inet:
 199                         pSgaObj.reset(new SgaObjectINet());
 200                         break;
 201                     case SgaObjKind::SvDraw:
 202                         pSgaObj.reset(new SgaObjectSvDraw());
 203                         break;
 204                     case SgaObjKind::Sound:
 205                         pSgaObj.reset(new SgaObjectSound());
 206                         break;
 207
 208                     default:
 209                         break;
 210                 }
 211
 212                 if (pSgaObj)
 213                 {
 214                     ReadSgaObject(*pIStm, *pSgaObj);
 215                     pSgaObj->ImplUpdateURL(*pEntry->m_oStorageUrl);
 216                 }
 217             }
 218         }
 219     }
 220
 221     return pSgaObj;
 222 }
 223
 224 bool GalleryFileStorage::implWriteSgaObject(const SgaObject& rObj, sal_uInt32 nPos,
 225                                             GalleryObject* pExistentEntry)
 226 {
 227     std::unique_ptr<SvStream> pOStm(::utl::UcbStreamHelper::CreateStream(
 228         GetSdgURL().GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::WRITE));
 229     bool bRet = false;
 230
 231     if (pOStm)
 232     {
 233         const sal_uInt32 nOffset = pOStm->Seek(STREAM_SEEK_TO_END);
 234
 235         rObj.WriteData(*pOStm, m_aDestDir);
 236
 237         if (!pOStm->GetError())
 238         {
 239             GalleryObject* pEntry;
 240
 241             if (!pExistentEntry)
 242             {
 243                 pEntry = new GalleryObject;
 244                 if (nPos < mrGalleryObjectCollection.size())
 245                 {
 246                     mrGalleryObjectCollection.getObjectList().emplace(
 247                         mrGalleryObjectCollection.getObjectList().begin() + nPos, pEntry);
 248                 }
 249                 else
 250                     mrGalleryObjectCollection.getObjectList().emplace_back(pEntry);
 251             }
 252             else
 253                 pEntry = pExistentEntry;
 254
 255             pEntry->m_oStorageUrl = rObj.GetURL();
 256
 257             pEntry->nOffset = nOffset;
 258             pEntry->eObjKind = rObj.GetObjKind();
 259             bRet = true;
 260         }
 261     }
 262
 263     return bRet;
 264 }
 265
 266 bool GalleryFileStorage::readModel(const GalleryObject* pObject, SdrModel& rModel)
 267 {
 268     rtl::Reference<SotStorage> xSotStorage(GetSvDrawStorage());
 269     bool bRet = false;
 270     const INetURLObject aURL(ImplGetURL(pObject));
 271
 272     if (xSotStorage.is())
 273     {
 274         const OUString aStreamName(GetSvDrawStreamNameFromURL(aURL));
 275         rtl::Reference<SotStorageStream> xInputStream(
 276             xSotStorage->OpenSotStream(aStreamName, StreamMode::READ));
 277
 278         if (xInputStream.is() && !xInputStream->GetError())
 279         {
 280             xInputStream->SetBufferSize(STREAMBUF_SIZE);
 281             bRet = GallerySvDrawImport(*xInputStream, rModel);
 282             xInputStream->SetBufferSize(0);
 283         }
 284     }
 285     return bRet;
 286 }
 287
 288 SgaObjectSvDraw GalleryFileStorage::insertModel(const FmFormModel& rModel,
 289                                                 const INetURLObject& rUserURL)
 290 {
 291     INetURLObject aURL(implCreateUniqueURL(SgaObjKind::SvDraw, rUserURL));
 292     rtl::Reference<SotStorage> xSotStorage(GetSvDrawStorage());
 293     bool bRet = false;
 294
 295     if (xSotStorage.is())
 296     {
 297         const OUString aStreamName(GetSvDrawStreamNameFromURL(aURL));
 298         rtl::Reference<SotStorageStream> xOutputStream(
 299             xSotStorage->OpenSotStream(aStreamName, StreamMode::WRITE | StreamMode::TRUNC));
 300
 301         if (xOutputStream.is() && !xOutputStream->GetError())
 302         {
 303             SvMemoryStream aMemoryStream(65535, 65535);
 304             FmFormModel* pFormModel = const_cast<FmFormModel*>(&rModel);
 305
 306             pFormModel->BurnInStyleSheetAttributes();
 307
 308             {
 309                 uno::Reference<io::XOutputStream> xDocOut(
 310                     new utl::OOutputStreamWrapper(aMemoryStream));
 311
 312                 if (xDocOut.is())
 313                     (void)SvxDrawingLayerExport(pFormModel, xDocOut);
 314             }
 315
 316             aMemoryStream.Seek(0);
 317
 318             xOutputStream->SetBufferSize(16348);
 319             GalleryCodec aCodec(*xOutputStream);
 320             aCodec.Write(aMemoryStream);
 321
 322             xOutputStream->SetBufferSize(0);
 323             xOutputStream->Commit();
 324             bRet = !xOutputStream->GetError();
 325         }
 326     }
 327     if (bRet)
 328     {
 329         SgaObjectSvDraw aObjSvDraw(rModel, aURL);
 330         return aObjSvDraw;
 331     }
 332     return SgaObjectSvDraw();
 333 }
 334
 335 bool GalleryFileStorage::readModelStream(const GalleryObject* pObject,
 336                                          tools::SvRef<SotTempStream> const& rxModelStream)
 337 {
 338     const INetURLObject aURL(ImplGetURL(pObject));
 339     rtl::Reference<SotStorage> xSotStorage(GetSvDrawStorage());
 340     bool bRet = false;
 341
 342     if (xSotStorage.is())
 343     {
 344         const OUString aStreamName(GetSvDrawStreamNameFromURL(aURL));
 345         rtl::Reference<SotStorageStream> xInputStream(
 346             xSotStorage->OpenSotStream(aStreamName, StreamMode::READ));
 347
 348         if (xInputStream.is() && !xInputStream->GetError())
 349         {
 350             sal_uInt32 nVersion = 0;
 351
 352             xInputStream->SetBufferSize(16348);
 353
 354             if (GalleryCodec::IsCoded(*xInputStream, nVersion))
 355             {
 356                 SvxGalleryDrawModel aModel;
 357
 358                 if (aModel.GetModel())
 359                 {
 360                     if (GallerySvDrawImport(*xInputStream, *aModel.GetModel()))
 361                     {
 362                         aModel.GetModel()->BurnInStyleSheetAttributes();
 363
 364                         {
 365                             uno::Reference<io::XOutputStream> xDocOut(
 366                                 new utl::OOutputStreamWrapper(*rxModelStream));
 367
 368                             SvxDrawingLayerExport(aModel.GetModel(), xDocOut);
 369                         }
 370                     }
 371
 372                     bRet = (rxModelStream->GetError() == ERRCODE_NONE);
 373                 }
 374             }
 375
 376             xInputStream->SetBufferSize(0);
 377         }
 378     }
 379     return bRet;
 380 }
 381
 382 SgaObjectSvDraw
 383 GalleryFileStorage::insertModelStream(const tools::SvRef<SotTempStream>& rxModelStream,
 384                                       const INetURLObject& rUserURL)
 385 {
 386     INetURLObject aURL(implCreateUniqueURL(SgaObjKind::SvDraw, rUserURL));
 387     rtl::Reference<SotStorage> xSotStorage(GetSvDrawStorage());
 388
 389     if (xSotStorage.is())
 390     {
 391         const OUString aStreamName(GetSvDrawStreamNameFromURL(aURL));
 392         rtl::Reference<SotStorageStream> xOutputStream(
 393             xSotStorage->OpenSotStream(aStreamName, StreamMode::WRITE | StreamMode::TRUNC));
 394
 395         if (xOutputStream.is() && !xOutputStream->GetError())
 396         {
 397             GalleryCodec aCodec(*xOutputStream);
 398
 399             xOutputStream->SetBufferSize(16348);
 400             aCodec.Write(*rxModelStream);
 401
 402             if (!xOutputStream->GetError())
 403             {
 404                 xOutputStream->Seek(0);
 405                 SgaObjectSvDraw aObjSvDraw(*xOutputStream, aURL);
 406                 return aObjSvDraw;
 407             }
 408         }
 409     }
 410     return SgaObjectSvDraw();
 411 }
 412
 413 INetURLObject GalleryFileStorage::implCreateUniqueURL(SgaObjKind eObjKind,
 414                                                       const INetURLObject& rUserURL,
 415                                                       ConvertDataFormat nFormat)
 416 {
 417     INetURLObject aDir(rUserURL);
 418     INetURLObject aInfoFileURL(rUserURL);
 419     INetURLObject aNewURL;
 420     sal_uInt32 nNextNumber = 1999;
 421     char const* pExt = nullptr;
 422     bool bExists;
 423
 424     aDir.Append(u"dragdrop");
 425     CreateDir(aDir);
 426
 427     aInfoFileURL.Append(u"sdddndx1");
 428
 429     // read next possible number
 430     if (FileExists(aInfoFileURL))
 431     {
 432         std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream(
 433             aInfoFileURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ));
 434
 435         if (pIStm)
 436         {
 437             pIStm->ReadUInt32(nNextNumber);
 438         }
 439     }
 440
 441     pExt = comphelper::GraphicMimeTypeHelper::GetExtensionForConvertDataFormat(nFormat);
 442
 443     do
 444     {
 445         // get URL
 446         if (SgaObjKind::SvDraw == eObjKind)
 447         {
 448             OUString aFileName = "gallery/svdraw/dd" + OUString::number(++nNextNumber % 99999999);
 449             aNewURL = INetURLObject(aFileName, INetProtocol::PrivSoffice);
 450
 451             bExists = false;
 452
 453             for (auto const& pObject : mrGalleryObjectCollection.getObjectList())
 454             {
 455                 if (*pObject->m_oStorageUrl == aNewURL)
 456                 {
 457                     bExists = true;
 458                     break;
 459                 }
 460             }
 461         }
 462         else
 463         {
 464             OUString aFileName = "dd" + OUString::number(++nNextNumber % 999999);
 465
 466             if (pExt)
 467                 aFileName += OUString(pExt, strlen(pExt), RTL_TEXTENCODING_ASCII_US);
 468
 469             aNewURL = aDir;
 470             aNewURL.Append(aFileName);
 471
 472             bExists = FileExists(aNewURL);
 473         }
 474     } while (bExists);
 475
 476     // write updated number
 477     std::unique_ptr<SvStream> pOStm(::utl::UcbStreamHelper::CreateStream(
 478         aInfoFileURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::WRITE));
 479
 480     if (pOStm)
 481     {
 482         pOStm->WriteUInt32(nNextNumber);
 483     }
 484
 485     return aNewURL;
 486 }
 487
 488 SgaObjectBmp GalleryFileStorage::insertGraphic(const Graphic& rGraphic, const GfxLink& aGfxLink,
 489                                                const ConvertDataFormat& nExportFormat,
 490                                                const INetURLObject& rUserURL)
 491 {
 492     const INetURLObject aURL(implCreateUniqueURL(SgaObjKind::Bitmap, rUserURL, nExportFormat));
 493     std::unique_ptr<SvStream> pOStm(
 494         ::utl::UcbStreamHelper::CreateStream(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),
 495                                              StreamMode::WRITE | StreamMode::TRUNC));
 496     bool bRet = false;
 497
 498     if (pOStm)
 499     {
 500         pOStm->SetVersion(SOFFICE_FILEFORMAT_50);
 501
 502         if (ConvertDataFormat::SVM == nExportFormat)
 503         {
 504             GDIMetaFile aMtf(rGraphic.GetGDIMetaFile());
 505
 506             SvmWriter aWriter(*pOStm);
 507             aWriter.Write(aMtf);
 508             bRet = (pOStm->GetError() == ERRCODE_NONE);
 509         }
 510         else
 511         {
 512             if (aGfxLink.GetDataSize() && aGfxLink.GetData())
 513             {
 514                 pOStm->WriteBytes(aGfxLink.GetData(), aGfxLink.GetDataSize());
 515                 bRet = (pOStm->GetError() == ERRCODE_NONE);
 516             }
 517             else
 518                 bRet = (GraphicConverter::Export(*pOStm, rGraphic, nExportFormat) == ERRCODE_NONE);
 519         }
 520
 521         pOStm.reset();
 522     }
 523     if (bRet)
 524     {
 525         const SgaObjectBmp aObjBmp(aURL);
 526         return aObjBmp;
 527     }
 528     return SgaObjectBmp();
 529 }
 530
 531 SgaObjectSvDraw GalleryFileStorage::updateSvDrawObject(const GalleryObject* pEntry)
 532 {
 533     if (GetSvDrawStorage().is())
 534     {
 535         const OUString aStmName(GetSvDrawStreamNameFromURL(*pEntry->m_oStorageUrl));
 536         rtl::Reference<SotStorageStream> pIStm
 537             = GetSvDrawStorage()->OpenSotStream(aStmName, StreamMode::READ);
 538
 539         if (pIStm.is() && !pIStm->GetError())
 540         {
 541             pIStm->SetBufferSize(16384);
 542
 543             SgaObjectSvDraw aNewObj(*pIStm, *pEntry->m_oStorageUrl);
 544
 545             pIStm->SetBufferSize(0);
 546
 547             return aNewObj;
 548         }
 549     }
 550     return SgaObjectSvDraw();
 551 }
 552
 553 void GalleryFileStorage::updateTheme()
 554 {
 555     ::utl::TempFileNamed aTmp;
 556     INetURLObject aInURL(GetSdgURL());
 557     INetURLObject aTmpURL(aTmp.GetURL());
 558
 559     DBG_ASSERT(aInURL.GetProtocol() != INetProtocol::NotValid, "invalid URL");
 560     DBG_ASSERT(aTmpURL.GetProtocol() != INetProtocol::NotValid, "invalid URL");
 561
 562     std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream(
 563         aInURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ));
 564     std::unique_ptr<SvStream> pTmpStm(::utl::UcbStreamHelper::CreateStream(
 565         aTmpURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),
 566         StreamMode::WRITE | StreamMode::TRUNC));
 567
 568     if (pIStm && pTmpStm)
 569     {
 570         for (const auto& i : mrGalleryObjectCollection.getObjectList())
 571         {
 572             GalleryObject* pEntry = i.get();
 573             std::unique_ptr<SgaObject> pObj;
 574
 575             switch (pEntry->eObjKind)
 576             {
 577                 case SgaObjKind::Bitmap:
 578                     pObj.reset(new SgaObjectBmp());
 579                     break;
 580                 case SgaObjKind::Animation:
 581                     pObj.reset(new SgaObjectAnim());
 582                     break;
 583                 case SgaObjKind::Inet:
 584                     pObj.reset(new SgaObjectINet());
 585                     break;
 586                 case SgaObjKind::SvDraw:
 587                     pObj.reset(new SgaObjectSvDraw());
 588                     break;
 589                 case SgaObjKind::Sound:
 590                     pObj.reset(new SgaObjectSound());
 591                     break;
 592
 593                 default:
 594                     break;
 595             }
 596
 597             if (pObj)
 598             {
 599                 pIStm->Seek(pEntry->nOffset);
 600                 ReadSgaObject(*pIStm, *pObj);
 601                 pEntry->nOffset = pTmpStm->Tell();
 602                 WriteSgaObject(*pTmpStm, *pObj);
 603             }
 604         }
 605     }
 606     else
 607     {
 608         OSL_FAIL("File(s) could not be opened");
 609     }
 610
 611     pIStm.reset();
 612     pTmpStm.reset();
 613
 614     CopyFile(aTmpURL, aInURL);
 615     KillFile(aTmpURL);
 616
 617     ErrCode nStorErr = ERRCODE_NONE;
 618
 619     try
 620     {
 621         rtl::Reference<SotStorage> aTempStorageRef(
 622             new SotStorage(false, aTmpURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),
 623                            StreamMode::STD_READWRITE));
 624         GetSvDrawStorage()->CopyTo(aTempStorageRef.get());
 625         nStorErr = GetSvDrawStorage()->GetError();
 626     }
 627     catch (const css::ucb::ContentCreationException&)
 628     {
 629         TOOLS_WARN_EXCEPTION("svx", "failed to open: "
 630                                         << aTmpURL.GetMainURL(INetURLObject::DecodeMechanism::NONE)
 631                                         << "due to");
 632         nStorErr = ERRCODE_IO_GENERAL;
 633     }
 634
 635     if (nStorErr == ERRCODE_NONE)
 636     {
 637         clearSotStorage();
 638         CopyFile(aTmpURL, GetSdvURL());
 639         ImplCreateSvDrawStorage();
 640     }
 641
 642     KillFile(aTmpURL);
 643 }
 644
 645 void GalleryFileStorage::insertFileOrDirURL(const INetURLObject& rFileOrDirURL,
 646                                             std::vector<INetURLObject>& rURLVector)
 647 {
 648     INetURLObject aURL;
 649     try
 650     {
 651         ::ucbhelper::Content aCnt(rFileOrDirURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),
 652                                   uno::Reference<ucb::XCommandEnvironment>(),
 653                                   comphelper::getProcessComponentContext());
 654         bool bFolder = false;
 655
 656         aCnt.getPropertyValue("IsFolder") >>= bFolder;
 657
 658         if (bFolder)
 659         {
 660             uno::Sequence<OUString> aProps{ "Url" };
 661             uno::Reference<sdbc::XResultSet> xResultSet(
 662                 aCnt.createCursor(aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY));
 663             uno::Reference<ucb::XContentAccess> xContentAccess(xResultSet, uno::UNO_QUERY);
 664             if (xContentAccess.is())
 665             {
 666                 while (xResultSet->next())
 667                 {
 668                     aURL.SetSmartURL(xContentAccess->queryContentIdentifierString());
 669                     rURLVector.push_back(aURL);
 670                 }
 671             }
 672         }
 673         else
 674             rURLVector.push_back(rFileOrDirURL);
 675     }
 676     catch (const ucb::ContentCreationException&)
 677     {
 678     }
 679     catch (const uno::RuntimeException&)
 680     {
 681     }
 682     catch (const uno::Exception&)
 683     {
 684     }
 685 }
 686
 687 SvStream& GalleryFileStorage::writeGalleryTheme(SvStream& rOStm, const GalleryTheme& rTheme,
 688                                                 const GalleryThemeEntry* pThm)
 689 {
 690     const INetURLObject rRelURL1 = rTheme.GetParent()->GetRelativeURL();
 691     const INetURLObject rRelURL2 = rTheme.GetParent()->GetUserURL();
 692     const sal_uInt32 rId = rTheme.GetId();
 693     sal_uInt32 nCount = mrGalleryObjectCollection.size();
 694     bool bRel;
 695
 696     rOStm.WriteUInt16(0x0004);
 697     write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, pThm->GetThemeName(),
 698                                                  RTL_TEXTENCODING_UTF8);
 699     rOStm.WriteUInt32(nCount);
 700     rOStm.WriteUInt16(RTL_TEXTENCODING_UTF8); // unused on reading
 701
 702     for (sal_uInt32 i = 0; i < nCount; i++)
 703     {
 704         const GalleryObject* pObj = mrGalleryObjectCollection.getForPosition(i);
 705         OUString aPath;
 706
 707         if (SgaObjKind::SvDraw == pObj->eObjKind)
 708         {
 709             aPath = GetSvDrawStreamNameFromURL(*pObj->m_oStorageUrl);
 710             bRel = false;
 711         }
 712         else
 713         {
 714             aPath = pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE);
 715             aPath = aPath.copy(
 716                 0, std::min(rRelURL1.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength(),
 717                             aPath.getLength()));
 718             bRel = aPath == rRelURL1.GetMainURL(INetURLObject::DecodeMechanism::NONE);
 719
 720             if (bRel
 721                 && (pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE)
 722                         .getLength()
 723                     > (rRelURL1.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength() + 1)))
 724             {
 725                 aPath = pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE);
 726                 aPath = aPath.copy(
 727                     std::min(rRelURL1.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength(),
 728                              aPath.getLength()));
 729             }
 730             else
 731             {
 732                 aPath = pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE);
 733                 aPath = aPath.copy(
 734                     0,
 735                     std::min(rRelURL2.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength(),
 736                              aPath.getLength()));
 737                 bRel = aPath == rRelURL2.GetMainURL(INetURLObject::DecodeMechanism::NONE);
 738
 739                 if (bRel
 740                     && (pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE)
 741                             .getLength()
 742                         > (rRelURL2.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength()
 743                            + 1)))
 744                 {
 745                     aPath = pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE);
 746                     aPath = aPath.copy(std::min(
 747                         rRelURL2.GetMainURL(INetURLObject::DecodeMechanism::NONE).getLength(),
 748                         aPath.getLength()));
 749                 }
 750                 else
 751                     aPath = pObj->m_oStorageUrl->GetMainURL(INetURLObject::DecodeMechanism::NONE);
 752             }
 753         }
 754
 755         if (!m_aDestDir.isEmpty())
 756         {
 757             bool aFound = aPath.indexOf(m_aDestDir) != -1;
 758             aPath = aPath.replaceFirst(m_aDestDir, "");
 759             if (aFound)
 760                 bRel = m_bDestDirRelative;
 761             else
 762                 SAL_WARN("svx", "failed to replace destdir of '" << m_aDestDir << "' in '" << aPath
 763                                                                  << "'");
 764         }
 765
 766         rOStm.WriteBool(bRel);
 767         write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aPath, RTL_TEXTENCODING_UTF8);
 768         rOStm.WriteUInt32(pObj->nOffset).WriteUInt16(static_cast<sal_uInt16>(pObj->eObjKind));
 769     }
 770
 771     // more recently, a 512-byte reserve buffer is written,
 772     // to recognize them two sal_uInt32-Ids will be written.
 773     rOStm.WriteUInt32(COMPAT_FORMAT('G', 'A', 'L', 'R'))
 774         .WriteUInt32(COMPAT_FORMAT('E', 'S', 'R', 'V'));
 775
 776     const sal_uInt64 nReservePos = rOStm.Tell();
 777     std::unique_ptr<VersionCompatWrite> pCompat(new VersionCompatWrite(rOStm, 2));
 778
 779     rOStm.WriteUInt32(rId).WriteBool(pThm->IsNameFromResource()); // From version 2 and up
 780
 781     pCompat.reset();
 782
 783     // Fill the rest of the buffer.
 784     const tools::Long nRest
 785         = std::max(tools::Long(512 - (rOStm.Tell() - nReservePos)), tools::Long(0));
 786
 787     if (nRest)
 788     {
 789         std::unique_ptr<char[]> pReserve(new char[nRest]);
 790         memset(pReserve.get(), 0, nRest);
 791         rOStm.WriteBytes(pReserve.get(), nRest);
 792     }
 793
 794     return rOStm;
 795 }
 796
 797 DateTime GalleryFileStorage::getModificationDate() const
 798 {
 799     ::ucbhelper::Content aCnt(GetThmURL().GetMainURL(INetURLObject::DecodeMechanism::NONE),
 800                               uno::Reference<ucb::XCommandEnvironment>(),
 801                               comphelper::getProcessComponentContext());
 802     util::DateTime aDateTimeModified;
 803     DateTime aDateTime(DateTime::EMPTY);
 804
 805     aCnt.getPropertyValue("DateModified") >>= aDateTimeModified;
 806     ::utl::typeConvert(aDateTimeModified, aDateTime);
 807
 808     return aDateTime;
 809 }
 810
 811 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */