sw/source/core/doc/docglbl.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 <osl/diagnose.h>
  21 #include <unotools/tempfile.hxx>
  22 #include <svl/stritem.hxx>
  23 #include <svl/eitem.hxx>
  24 #include <sfx2/docfile.hxx>
  25 #include <sfx2/docfilt.hxx>
  26 #include <sfx2/fcontnr.hxx>
  27 #include <sfx2/bindings.hxx>
  28 #include <sfx2/request.hxx>
  29 #include <sfx2/sfxsids.hrc>
  30 #include <sfx2/viewfrm.hxx>
  31 #include <tools/datetime.hxx>
  32 #include <fmtinfmt.hxx>
  33 #include <fmtanchr.hxx>
  34 #include <doc.hxx>
  35 #include <IDocumentUndoRedo.hxx>
  36 #include <IDocumentRedlineAccess.hxx>
  37 #include <DocumentSettingManager.hxx>
  38 #include <DocumentContentOperationsManager.hxx>
  39 #include <IDocumentLayoutAccess.hxx>
  40 #include <docary.hxx>
  41 #include <pam.hxx>
  42 #include <ndtxt.hxx>
  43 #include <docsh.hxx>
  44 #include <section.hxx>
  45 #include <calbck.hxx>
  46 #include <iodetect.hxx>
  47 #include <frameformats.hxx>
  48 #include <memory>
  49 #include <com/sun/star/uno/Reference.h>
  50 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  51 #include <com/sun/star/document/XDocumentProperties.hpp>
  52 #include <com/sun/star/frame/XModel.hpp>
  53
  54 using namespace ::com::sun::star;
  55
  56 namespace {
  57
  58 enum SwSplitDocType
  59 {
  60     SPLITDOC_TO_GLOBALDOC,
  61     SPLITDOC_TO_HTML
  62 };
  63
  64 }
  65
  66 bool SwDoc::GenerateGlobalDoc( const OUString& rPath,
  67                                    const SwTextFormatColl* pSplitColl )
  68 {
  69     return SplitDoc( SPLITDOC_TO_GLOBALDOC, rPath, false, pSplitColl );
  70 }
  71
  72 bool SwDoc::GenerateGlobalDoc( const OUString& rPath, int nOutlineLevel )
  73 {
  74     return SplitDoc( SPLITDOC_TO_GLOBALDOC, rPath, true, nullptr, nOutlineLevel );
  75 }
  76
  77 bool SwDoc::GenerateHTMLDoc( const OUString& rPath, int nOutlineLevel )
  78 {
  79     return SplitDoc( SPLITDOC_TO_HTML, rPath, true, nullptr, nOutlineLevel );
  80 }
  81
  82 bool SwDoc::GenerateHTMLDoc( const OUString& rPath,
  83                                  const SwTextFormatColl* pSplitColl )
  84 {
  85     return SplitDoc( SPLITDOC_TO_HTML, rPath, false, pSplitColl );
  86 }
  87
  88 // two helpers for outline mode
  89 static SwNode* GetStartNode( SwOutlineNodes const * pOutlNds, int nOutlineLevel, SwOutlineNodes::size_type* nOutl )
  90 {
  91     for( ; *nOutl < pOutlNds->size(); ++(*nOutl) )
  92     {
  93         SwNode* pNd = (*pOutlNds)[ *nOutl ];
  94         if( pNd->GetTextNode()->GetAttrOutlineLevel() == nOutlineLevel && !pNd->FindTableNode() )
  95         {
  96             return pNd;
  97         }
  98     }
  99
 100     return nullptr;
 101 }
 102
 103 static SwNode* GetEndNode( SwOutlineNodes const * pOutlNds, int nOutlineLevel, SwOutlineNodes::size_type* nOutl )
 104 {
 105     SwNode* pNd;
 106
 107     for( ++(*nOutl); (*nOutl) < pOutlNds->size(); ++(*nOutl) )
 108     {
 109         pNd = (*pOutlNds)[ *nOutl ];
 110
 111         const int nLevel = pNd->GetTextNode()->GetAttrOutlineLevel();
 112
 113         if( ( 0 < nLevel && nLevel <= nOutlineLevel ) &&
 114             !pNd->FindTableNode() )
 115         {
 116             return pNd;
 117         }
 118     }
 119     return nullptr;
 120 }
 121
 122 // two helpers for collection mode
 123 static SwNode* GetStartNode( const SwOutlineNodes* pOutlNds, const SwTextFormatColl* pSplitColl, SwOutlineNodes::size_type* nOutl )
 124 {
 125     for( ; *nOutl < pOutlNds->size(); ++(*nOutl) )
 126     {
 127         SwNode* pNd = (*pOutlNds)[ *nOutl ];
 128         if( pNd->GetTextNode()->GetTextColl() == pSplitColl &&
 129             !pNd->FindTableNode() )
 130         {
 131             return pNd;
 132         }
 133     }
 134     return nullptr;
 135 }
 136
 137 static SwNode* GetEndNode( const SwOutlineNodes* pOutlNds, const SwTextFormatColl* pSplitColl, SwOutlineNodes::size_type* nOutl )
 138 {
 139     SwNode* pNd;
 140
 141     for( ++(*nOutl); *nOutl < pOutlNds->size(); ++(*nOutl) )
 142     {
 143         pNd = (*pOutlNds)[ *nOutl ];
 144         SwTextFormatColl* pTColl = pNd->GetTextNode()->GetTextColl();
 145
 146         if( ( pTColl == pSplitColl ||
 147               (   pSplitColl->GetAttrOutlineLevel() > 0 &&
 148                   pTColl->GetAttrOutlineLevel() > 0   &&
 149                   pTColl->GetAttrOutlineLevel() <
 150                   pSplitColl->GetAttrOutlineLevel() )) &&
 151             !pNd->FindTableNode() )
 152         {
 153             return pNd;
 154         }
 155     }
 156     return nullptr;
 157 }
 158
 159 bool SwDoc::SplitDoc( sal_uInt16 eDocType, const OUString& rPath, bool bOutline, const SwTextFormatColl* pSplitColl, int nOutlineLevel )
 160 {
 161     // Iterate over all the template's Nodes, creating an own
 162     // document for every single one and replace linked sections (GlobalDoc) for links (HTML).
 163     // Finally, we save this document as a GlobalDoc/HTMLDoc.
 164     if( !mpDocShell || !mpDocShell->GetMedium() ||
 165         ( SPLITDOC_TO_GLOBALDOC == eDocType && GetDocumentSettingManager().get(DocumentSettingId::GLOBAL_DOCUMENT) ) )
 166         return false;
 167
 168     SwOutlineNodes::size_type nOutl = 0;
 169     SwOutlineNodes* pOutlNds = const_cast<SwOutlineNodes*>(&GetNodes().GetOutLineNds());
 170     std::unique_ptr<SwOutlineNodes> xTmpOutlNds;
 171     SwNode* pStartNd;
 172
 173     if ( !bOutline) {
 174         if( pSplitColl )
 175         {
 176             // If it isn't an OutlineNumbering, then use an own array and collect the Nodes.
 177             if( pSplitColl->GetAttrOutlineLevel() == 0 )
 178             {
 179                 xTmpOutlNds.reset(new SwOutlineNodes);
 180                 pOutlNds = xTmpOutlNds.get();
 181                 SwIterator<SwTextNode,SwFormatColl> aIter( *pSplitColl );
 182                 for( SwTextNode* pTNd = aIter.First(); pTNd; pTNd = aIter.Next() )
 183                     if( pTNd->GetNodes().IsDocNodes() )
 184                         pOutlNds->insert( pTNd );
 185
 186                 if( pOutlNds->empty() )
 187                     return false;
 188             }
 189         }
 190         else
 191         {
 192             // Look for the 1st level OutlineTemplate
 193             const SwTextFormatColls& rFormatColls =*GetTextFormatColls();
 194             for( SwTextFormatColls::size_type n = rFormatColls.size(); n; )
 195                 if ( rFormatColls[ --n ]->GetAttrOutlineLevel() == 1 )
 196                 {
 197                     pSplitColl = rFormatColls[ n ];
 198                     break;
 199                 }
 200
 201             if( !pSplitColl )
 202                 return false;
 203         }
 204     }
 205
 206     std::shared_ptr<const SfxFilter> pFilter;
 207     switch( eDocType )
 208     {
 209     case SPLITDOC_TO_HTML:
 210         pFilter = SwIoSystem::GetFilterOfFormat(u"HTML");
 211         break;
 212
 213     default:
 214         pFilter = SwIoSystem::GetFilterOfFormat(FILTER_XML);
 215         eDocType = SPLITDOC_TO_GLOBALDOC;
 216         break;
 217     }
 218
 219     if( !pFilter )
 220         return false;
 221
 222     // Deactivate Undo/Redline in any case
 223     GetIDocumentUndoRedo().DoUndo(false);
 224     getIDocumentRedlineAccess().SetRedlineFlags_intern( getIDocumentRedlineAccess().GetRedlineFlags() & ~RedlineFlags::On );
 225
 226     OUString sExt = pFilter->GetSuffixes().getToken(0, ',');
 227     if( sExt.isEmpty() )
 228     {
 229         sExt = ".sxw";
 230     }
 231     else
 232     {
 233         if( '.' != sExt[ 0 ] )
 234         {
 235             sExt = "." + sExt;
 236         }
 237     }
 238
 239     INetURLObject aEntry(rPath);
 240     OUString sLeading(aEntry.GetBase());
 241     aEntry.removeSegment();
 242     OUString sPath = aEntry.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 243     utl::TempFileNamed aTemp(sLeading, true, sExt, &sPath);
 244     aTemp.EnableKillingFile();
 245
 246     DateTime aTmplDate( DateTime::SYSTEM );
 247     {
 248         tools::Time a2Min( 0 ); a2Min.SetMin( 2 );
 249         aTmplDate += a2Min;
 250     }
 251
 252     // Skip all invalid ones
 253     while( nOutl < pOutlNds->size() &&
 254         (*pOutlNds)[ nOutl ]->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() )
 255         ++nOutl;
 256
 257     do {
 258         if( bOutline )
 259             pStartNd = GetStartNode( pOutlNds, nOutlineLevel, &nOutl );
 260         else
 261             pStartNd = GetStartNode( pOutlNds, pSplitColl, &nOutl );
 262
 263         if( pStartNd )
 264         {
 265             SwNode* pEndNd;
 266             if( bOutline )
 267                 pEndNd = GetEndNode( pOutlNds, nOutlineLevel, &nOutl );
 268             else
 269                 pEndNd = GetEndNode( pOutlNds, pSplitColl, &nOutl );
 270             SwNodeIndex aEndIdx( pEndNd ? *pEndNd
 271                                         : GetNodes().GetEndOfContent() );
 272
 273             // Write out the Nodes completely
 274             OUString sFileName;
 275             if( pStartNd->GetIndex() + 1 < aEndIdx.GetIndex() )
 276             {
 277                 SfxObjectShellLock xDocSh( new SwDocShell( SfxObjectCreateMode::INTERNAL ));
 278                 if( xDocSh->DoInitNew() )
 279                 {
 280                     SwDoc* pDoc = static_cast<SwDocShell*>(&xDocSh)->GetDoc();
 281
 282                     uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
 283                         static_cast<SwDocShell*>(&xDocSh)->GetModel(),
 284                         uno::UNO_QUERY_THROW);
 285                     uno::Reference<document::XDocumentProperties> xDocProps(
 286                         xDPS->getDocumentProperties());
 287                     OSL_ENSURE(xDocProps.is(), "Doc has no DocumentProperties");
 288                     // the GlobalDoc is the template
 289                     xDocProps->setTemplateName(OUString());
 290                     ::util::DateTime uDT = aTmplDate.GetUNODateTime();
 291                     xDocProps->setTemplateDate(uDT);
 292                     xDocProps->setTemplateURL(rPath);
 293                     // Set the new doc's title to the text of the "split para".
 294                     // If the current doc has a title, insert it at the begin.
 295                     OUString sTitle( xDocProps->getTitle() );
 296                     if (!sTitle.isEmpty())
 297                         sTitle += ": ";
 298                     sTitle += pStartNd->GetTextNode()->GetExpandText(nullptr);
 299                     xDocProps->setTitle( sTitle );
 300
 301                     // Replace template
 302                     pDoc->ReplaceStyles( *this );
 303
 304                     // Take over chapter numbering
 305                     if( mpOutlineRule )
 306                         pDoc->SetOutlineNumRule( *mpOutlineRule );
 307
 308                     SwNodeRange aRg( *pStartNd, SwNodeOffset(0), aEndIdx.GetNode() );
 309                     GetDocumentContentOperationsManager().CopyWithFlyInFly(
 310                             aRg, pDoc->GetNodes().GetEndOfContent(), nullptr, false, false);
 311
 312                     // Delete the initial TextNode
 313                     SwNodeIndex aIdx( pDoc->GetNodes().GetEndOfExtras(), 2 );
 314                     if( aIdx.GetIndex() + 1 !=
 315                         pDoc->GetNodes().GetEndOfContent().GetIndex() )
 316                         pDoc->GetNodes().Delete( aIdx );
 317
 318                     sFileName = utl::CreateTempURL(sLeading, true, sExt, &sPath);
 319                     SfxMedium* pTmpMed = new SfxMedium( sFileName,
 320                                                 StreamMode::STD_READWRITE );
 321                     pTmpMed->SetFilter( pFilter );
 322
 323                     // We need to have a Layout for the HTMLFilter, so that
 324                     // TextFrames/Controls/OLE objects can be exported correctly as graphics.
 325                     if( SPLITDOC_TO_HTML == eDocType &&
 326                         !pDoc->GetSpzFrameFormats()->empty() )
 327                     {
 328                             SfxViewFrame::LoadHiddenDocument( *xDocSh, SFX_INTERFACE_NONE );
 329                     }
 330                     xDocSh->DoSaveAs( *pTmpMed );
 331                     xDocSh->DoSaveCompleted( pTmpMed );
 332
 333                     // do not insert a FileLinkSection in case of error
 334                     if( xDocSh->GetError() )
 335                         sFileName.clear();
 336                 }
 337                 xDocSh->DoClose();
 338             }
 339
 340             // We can now insert the section
 341             if( !sFileName.isEmpty() )
 342             {
 343                 switch( eDocType )
 344                 {
 345                 case SPLITDOC_TO_HTML:
 346                     {
 347                         // Delete all nodes in the section and, in the "start node",
 348                         // set the Link to the saved document.
 349                         SwNodeOffset nNodeDiff = aEndIdx.GetIndex() -
 350                                             pStartNd->GetIndex() - 1;
 351                         if( nNodeDiff )
 352                         {
 353                             SwPaM aTmp( *pStartNd, aEndIdx.GetNode(), SwNodeOffset(1), SwNodeOffset(-1) );
 354                             SwNodeIndex aSIdx( aTmp.GetMark()->GetNode() );
 355                             SwNodeIndex aEIdx( aTmp.GetPoint()->GetNode() );
 356
 357                             // Try to move past the end
 358                             if( !aTmp.Move( fnMoveForward, GoInNode ) )
 359                             {
 360                                 // well then, back to the beginning
 361                                 aTmp.Exchange();
 362                                 if( !aTmp.Move( fnMoveBackward, GoInNode ))
 363                                 {
 364                                     OSL_FAIL( "no more Nodes!" );
 365                                 }
 366                             }
 367                             // Move Bookmarks and so forth
 368                             CorrAbs( aSIdx, aEIdx, *aTmp.GetPoint(), true);
 369
 370                             // If FlyFrames are still around, delete these too
 371                             auto& rSpzs = *GetSpzFrameFormats();
 372                             for(sw::FrameFormats<sw::SpzFrameFormat*>::size_type n = 0; n < GetSpzFrameFormats()->size(); ++n)
 373                             {
 374                                 auto pFly = rSpzs[n];
 375                                 const SwFormatAnchor* pAnchor = &pFly->GetAnchor();
 376                                 SwNode const*const pAnchorNode =
 377                                     pAnchor->GetAnchorNode();
 378                                 if (pAnchorNode &&
 379                                     ((RndStdIds::FLY_AT_PARA == pAnchor->GetAnchorId()) ||
 380                                      (RndStdIds::FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
 381                                     aSIdx <= *pAnchorNode &&
 382                                     *pAnchorNode < aEIdx.GetNode() )
 383                                 {
 384                                     getIDocumentLayoutAccess().DelLayoutFormat( pFly );
 385                                     --n;
 386                                 }
 387                             }
 388
 389                             GetNodes().Delete( aSIdx, nNodeDiff );
 390                         }
 391
 392                         // set the link in the StartNode
 393                         SwFormatINetFormat aINet( sFileName , OUString() );
 394                         SwTextNode* pTNd = pStartNd->GetTextNode();
 395                         pTNd->InsertItem(aINet, 0, pTNd->GetText().getLength());
 396
 397                         // If the link cannot be found anymore,
 398                         // it has to be a bug!
 399                         if( !pOutlNds->Seek_Entry( pStartNd, &nOutl ))
 400                             pStartNd = nullptr;
 401                         ++nOutl ;
 402                     }
 403                     break;
 404
 405                 default:
 406                     {
 407                         const OUString sNm(INetURLObject(sFileName).GetLastName());
 408                         SwSectionData aSectData( SectionType::FileLink,
 409                                         GetUniqueSectionName( &sNm ));
 410                         SwSectionFormat* pFormat = MakeSectionFormat();
 411                         aSectData.SetLinkFileName(sFileName);
 412                         aSectData.SetProtectFlag(true);
 413
 414                         --aEndIdx;  // in the InsertSection the end is inclusive
 415                         while( aEndIdx.GetNode().IsStartNode() )
 416                             --aEndIdx;
 417
 418                         // If any Section ends or starts in the new sectionrange,
 419                         // they must end or start before or after the range!
 420                         SwSectionNode* pSectNd = pStartNd->FindSectionNode();
 421                         while( pSectNd && pSectNd->EndOfSectionIndex()
 422                                 <= aEndIdx.GetIndex() )
 423                         {
 424                             const SwNode* pSectEnd = pSectNd->EndOfSectionNode();
 425                             if( pSectNd->GetIndex() + 1 ==
 426                                     pStartNd->GetIndex() )
 427                             {
 428                                 bool bMvIdx = aEndIdx == *pSectEnd;
 429                                 DelSectionFormat( pSectNd->GetSection().GetFormat() );
 430                                 if( bMvIdx )
 431                                     --aEndIdx;
 432                             }
 433                             else
 434                             {
 435                                 SwNodeRange aRg( *pStartNd, *pSectEnd );
 436                                 SwNodeIndex aIdx( *pSectEnd, 1 );
 437                                 GetNodes().MoveNodes( aRg, GetNodes(), aIdx.GetNode() );
 438                             }
 439                             pSectNd = pStartNd->FindSectionNode();
 440                         }
 441
 442                         pSectNd = aEndIdx.GetNode().FindSectionNode();
 443                         while( pSectNd && pSectNd->GetIndex() >
 444                                 pStartNd->GetIndex() )
 445                         {
 446                             // #i15712# don't attempt to split sections if
 447                             // they are fully enclosed in [pSectNd,aEndIdx].
 448                             if( aEndIdx < pSectNd->EndOfSectionIndex() )
 449                             {
 450                                 SwNodeRange aRg( *pSectNd, SwNodeOffset(1), aEndIdx.GetNode(), SwNodeOffset(1) );
 451                                 GetNodes().MoveNodes( aRg, GetNodes(), *pSectNd );
 452                             }
 453
 454                             pSectNd = pStartNd->FindSectionNode();
 455                         }
 456
 457                         // -> #i26762#
 458                         // Ensure order of start and end of section is sane.
 459                         SwNodeIndex aStartIdx(*pStartNd);
 460
 461                         if (aEndIdx >= aStartIdx)
 462                         {
 463                             pSectNd = GetNodes().InsertTextSection(aStartIdx.GetNode(),
 464                                 *pFormat, aSectData, nullptr, &aEndIdx.GetNode(), false);
 465                         }
 466                         else
 467                         {
 468                             pSectNd = GetNodes().InsertTextSection(aEndIdx.GetNode(),
 469                                 *pFormat, aSectData, nullptr, &aStartIdx.GetNode(), false);
 470                         }
 471                         // <- #i26762#
 472
 473                         pSectNd->GetSection().CreateLink( LinkCreateType::Connect );
 474                     }
 475                     break;
 476                 }
 477             }
 478         }
 479     } while( pStartNd );
 480
 481     xTmpOutlNds.reset();
 482
 483     switch( eDocType )
 484     {
 485     case SPLITDOC_TO_HTML:
 486         if( GetDocumentSettingManager().get(DocumentSettingId::GLOBAL_DOCUMENT) )
 487         {
 488             // save all remaining sections
 489             while( !GetSections().empty() )
 490                 DelSectionFormat( GetSections().front() );
 491
 492             SfxFilterContainer* pFCntnr = mpDocShell->GetFactory().GetFilterContainer();
 493             pFilter = pFCntnr->GetFilter4EA( pFilter->GetTypeName(), SfxFilterFlags::EXPORT );
 494         }
 495         break;
 496
 497     default:
 498         // save the Globaldoc
 499         GetDocumentSettingManager().set(DocumentSettingId::GLOBAL_DOCUMENT, true);
 500         GetDocumentSettingManager().set(DocumentSettingId::GLOBAL_DOCUMENT_SAVE_LINKS, false);
 501     }
 502
 503     // The medium isn't locked after reopening the document.
 504     SfxRequest aReq( SID_SAVEASDOC, SfxCallMode::SYNCHRON, GetAttrPool() );
 505     aReq.AppendItem( SfxStringItem( SID_FILE_NAME, rPath ) );
 506     aReq.AppendItem( SfxBoolItem( SID_SAVETO, true ) );
 507     if(pFilter)
 508         aReq.AppendItem( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) );
 509     const SfxBoolItem *pRet = static_cast<const SfxBoolItem*>(mpDocShell->ExecuteSlot( aReq ));
 510
 511     return pRet && pRet->GetValue();
 512 }
 513
 514 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */