sw/source/core/edit/edglss.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 <sal/config.h>
  21
  22 #include <o3tl/safeint.hxx>
  23 #include <osl/diagnose.h>
  24 #include <osl/endian.h>
  25 #include <tools/urlobj.hxx>
  26 #include <doc.hxx>
  27 #include <IDocumentRedlineAccess.hxx>
  28 #include <IDocumentFieldsAccess.hxx>
  29 #include <pam.hxx>
  30 #include <editsh.hxx>
  31 #include <frmfmt.hxx>
  32 #include <rootfrm.hxx>
  33 #include <ndtxt.hxx>
  34 #include <swtable.hxx>
  35 #include <shellio.hxx>
  36 #include <iodetect.hxx>
  37 #include <frameformats.hxx>
  38
  39 void SwEditShell::InsertGlossary( SwTextBlocks& rGlossary, const OUString& rStr )
  40 {
  41     StartAllAction();
  42     GetDoc()->InsertGlossary( rGlossary, rStr, *GetCursor(), this );
  43     EndAllAction();
  44 }
  45
  46 /// convert current selection into text block and add to the text block document, incl. templates
  47 sal_uInt16 SwEditShell::MakeGlossary( SwTextBlocks& rBlks, const OUString& rName, const OUString& rShortName,
  48                                     bool bSaveRelFile, const OUString* pOnlyText )
  49 {
  50     SwDoc* pGDoc = rBlks.GetDoc();
  51
  52     OUString sBase;
  53     if(bSaveRelFile)
  54     {
  55         INetURLObject aURL( rBlks.GetFileName() );
  56         sBase = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
  57     }
  58     rBlks.SetBaseURL( sBase );
  59
  60     if( pOnlyText )
  61         return rBlks.PutText( rShortName, rName, *pOnlyText );
  62
  63     rBlks.ClearDoc();
  64     if( rBlks.BeginPutDoc( rShortName, rName ) )
  65     {
  66         rBlks.GetDoc()->getIDocumentRedlineAccess().SetRedlineFlags_intern( RedlineFlags::DeleteRedlines );
  67         CopySelToDoc(*pGDoc);
  68         rBlks.GetDoc()->getIDocumentRedlineAccess().SetRedlineFlags_intern( RedlineFlags::NONE );
  69         return rBlks.PutDoc();
  70     }
  71
  72     return USHRT_MAX;
  73 }
  74
  75 sal_uInt16 SwEditShell::SaveGlossaryDoc( SwTextBlocks& rBlock,
  76                                     const OUString& rName,
  77                                     const OUString& rShortName,
  78                                     bool bSaveRelFile,
  79                                     bool bOnlyText )
  80 {
  81     StartAllAction();
  82
  83     SwDoc* pGDoc = rBlock.GetDoc();
  84     SwDoc* pMyDoc = GetDoc();
  85
  86     OUString sBase;
  87     if(bSaveRelFile)
  88     {
  89         INetURLObject aURL( rBlock.GetFileName() );
  90         sBase = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
  91     }
  92     rBlock.SetBaseURL( sBase );
  93     sal_uInt16 nRet = USHRT_MAX;
  94
  95     if( bOnlyText )
  96     {
  97         KillPams();
  98
  99         SwPaM* pCursor = GetCursor();
 100
 101         SwNodeIndex aStt( pMyDoc->GetNodes().GetEndOfExtras(), 1 );
 102         SwContentNode* pContentNd = SwNodes::GoNext(&aStt);
 103         const SwNode* pNd = pContentNd->FindTableNode();
 104         if( !pNd )
 105             pNd = pContentNd;
 106
 107         pCursor->GetPoint()->Assign(*pNd);
 108         pCursor->SetMark();
 109
 110         // then until the end of the Node array
 111         pCursor->GetPoint()->Assign(pMyDoc->GetNodes().GetEndOfContent().GetIndex()-1);
 112         pContentNd = pCursor->GetPointContentNode();
 113         if( pContentNd )
 114             pCursor->GetPoint()->SetContent( pContentNd->Len() );
 115
 116         OUString sBuf;
 117         GetSelectedText( sBuf, ParaBreakType::ToOnlyCR );
 118         if( !sBuf.isEmpty() )
 119             nRet = rBlock.PutText( rShortName, rName, sBuf );
 120     }
 121     else
 122     {
 123         rBlock.ClearDoc();
 124         if( rBlock.BeginPutDoc( rShortName, rName ) )
 125         {
 126             SwNodeIndex aStt( pMyDoc->GetNodes().GetEndOfExtras(), 1 );
 127             SwContentNode* pContentNd = SwNodes::GoNext(&aStt);
 128             const SwNode* pNd = pContentNd->FindTableNode();
 129             if( !pNd ) pNd = pContentNd;
 130             SwPaM aCpyPam( *pNd );
 131             aCpyPam.SetMark();
 132
 133             // then until the end of the nodes array
 134             aCpyPam.GetPoint()->Assign(pMyDoc->GetNodes().GetEndOfContent().GetIndex()-1);
 135             pContentNd = aCpyPam.GetPointContentNode();
 136             if(pContentNd)
 137                 aCpyPam.GetPoint()->SetContent( pContentNd->Len() );
 138
 139             aStt = pGDoc->GetNodes().GetEndOfExtras();
 140             pContentNd = SwNodes::GoNext(&aStt);
 141             SwPosition aInsPos( aStt );
 142             pMyDoc->getIDocumentContentOperations().CopyRange(aCpyPam, aInsPos, SwCopyFlags::CheckPosInFly);
 143
 144             nRet = rBlock.PutDoc();
 145         }
 146     }
 147     EndAllAction();
 148     return nRet;
 149 }
 150
 151 /// copy all selections to the doc
 152 bool SwEditShell::CopySelToDoc( SwDoc& rInsDoc )
 153 {
 154     SwNodes& rNds = rInsDoc.GetNodes();
 155
 156     SwNodeIndex aIdx( rNds.GetEndOfContent(), -1 );
 157     SwContentNode *const pContentNode = aIdx.GetNode().GetContentNode();
 158     SwPosition aPos( aIdx, pContentNode, pContentNode ? pContentNode->Len() : 0);
 159
 160     bool bRet = false;
 161     CurrShell aCurr( this );
 162
 163     rInsDoc.getIDocumentFieldsAccess().LockExpFields();
 164
 165     if( IsTableMode() )
 166     {
 167         // Copy parts of a table: create a table with the width of the original one and copy the
 168         // selected boxes. The sizes are corrected on a percentage basis.
 169
 170         // search boxes using the layout
 171         SwTableNode* pTableNd;
 172         SwSelBoxes aBoxes;
 173         GetTableSel( *this, aBoxes );
 174         if( !aBoxes.empty() && nullptr != (pTableNd = const_cast<SwTableNode*>(aBoxes[0]
 175             ->GetSttNd()->FindTableNode()) ))
 176         {
 177             // check if the table name can be copied
 178             bool bCpyTableNm = aBoxes.size() == pTableNd->GetTable().GetTabSortBoxes().size();
 179             if( bCpyTableNm )
 180             {
 181                 const OUString rTableName = pTableNd->GetTable().GetFrameFormat()->GetName();
 182                 const sw::TableFrameFormats& rTableFormats = *rInsDoc.GetTableFrameFormats();
 183                 for( auto n = rTableFormats.size(); n; )
 184                     if( rTableFormats[ --n ]->GetName() == rTableName )
 185                     {
 186                         bCpyTableNm = false;
 187                         break;
 188                     }
 189             }
 190             bRet = rInsDoc.InsCopyOfTable( aPos, aBoxes, nullptr, bCpyTableNm, false, pTableNd->GetTable().GetTableStyleName() );
 191         }
 192         else
 193             bRet = false;
 194     }
 195     else
 196     {
 197         bool bColSel = GetCursor_()->IsColumnSelection();
 198         if( bColSel && rInsDoc.IsClipBoard() )
 199             rInsDoc.SetColumnSelection( true );
 200         const ExtendedSelection oSelectAll(StartsWith_() != SwCursorShell::StartsWith::None
 201             ? ExtendedSelectedAll()
 202             : ExtendedSelection{});
 203         {
 204             for(SwPaM& rPaM : GetCursor()->GetRingContainer())
 205             {
 206                 if( !rPaM.HasMark() )
 207                 {
 208                     SwContentNode *const pNd = rPaM.GetPointContentNode();
 209                     if (nullptr != pNd &&
 210                         ( bColSel || !pNd->GetTextNode() ) )
 211                     {
 212                         rPaM.SetMark();
 213                         rPaM.Move( fnMoveForward, GoInContent );
 214                         bRet = GetDoc()->getIDocumentContentOperations().CopyRange(rPaM, aPos, SwCopyFlags::CheckPosInFly)
 215                             || bRet;
 216                         rPaM.Exchange();
 217                         rPaM.DeleteMark();
 218                     }
 219                 }
 220                 else
 221                 {
 222                     // Make a copy, so that in case we need to adjust the selection
 223                     // for the purpose of copying, our shell cursor is not touched.
 224                     // (Otherwise we would have to restore it.)
 225                     SwPaM aPaM(*rPaM.GetMark(), *rPaM.GetPoint());
 226                     if (oSelectAll)
 227                     {
 228                         // Selection starts at the first para of the first cell,
 229                         // but we want to copy the table and the start node before
 230                         // the first cell as well.
 231                         aPaM.Start()->Assign(*oSelectAll->first);
 232                         if (SwSectionNode const* pSection = oSelectAll->first->GetSectionNode())
 233                         {
 234                             if (aPaM.End()->GetNodeIndex() < pSection->EndOfSectionIndex())
 235                             {
 236                                 // include section end so that section is copied
 237                                 aPaM.End()->Assign(*oSelectAll->first->GetNodes()[pSection->EndOfSectionIndex() + 1]);
 238                             }
 239                         }
 240                     }
 241                     bRet = GetDoc()->getIDocumentContentOperations().CopyRange( aPaM, aPos, SwCopyFlags::CheckPosInFly)
 242                         || bRet;
 243                 }
 244             }
 245         }
 246     }
 247
 248     rInsDoc.getIDocumentFieldsAccess().UnlockExpFields();
 249     if( !rInsDoc.getIDocumentFieldsAccess().IsExpFieldsLocked() )
 250         rInsDoc.getIDocumentFieldsAccess().UpdateExpFields(nullptr, true);
 251
 252     return bRet;
 253 }
 254
 255 /** Get text in a Selection
 256  */
 257 void SwEditShell::GetSelectedText( OUString &rBuf, ParaBreakType nHndlParaBrk )
 258 {
 259     GetCursor();  // creates all cursors if needed
 260     if( IsSelOnePara() )
 261     {
 262         rBuf = GetSelText();
 263         if( ParaBreakType::ToBlank == nHndlParaBrk )
 264         {
 265             rBuf = rBuf.replaceAll("\x0a", " ");
 266         }
 267         else if( IsSelFullPara() &&
 268             ParaBreakType::ToOnlyCR != nHndlParaBrk )
 269         {
 270             rBuf += SAL_NEWLINE_STRING;
 271         }
 272     }
 273     else if( IsSelection() )
 274     {
 275         SvMemoryStream aStream;
 276 #ifdef OSL_BIGENDIAN
 277         aStream.SetEndian( SvStreamEndian::BIG );
 278 #else
 279         aStream.SetEndian( SvStreamEndian::LITTLE );
 280 #endif
 281         WriterRef xWrt;
 282         SwReaderWriter::GetWriter( FILTER_TEXT, OUString(), xWrt );
 283         if( xWrt.is() )
 284         {
 285             // write selected areas into an ASCII document
 286             SwWriter aWriter( aStream, *this);
 287             xWrt->SetShowProgress(false);
 288
 289             switch( nHndlParaBrk )
 290             {
 291             case ParaBreakType::ToBlank:
 292                 xWrt->m_bASCII_ParaAsBlank = true;
 293                 xWrt->m_bASCII_NoLastLineEnd = true;
 294                 break;
 295
 296             case ParaBreakType::ToOnlyCR:
 297                 xWrt->m_bASCII_ParaAsCR = true;
 298                 xWrt->m_bASCII_NoLastLineEnd = true;
 299                 break;
 300             }
 301
 302             //JP 09.05.00: write as UNICODE ! (and not as ANSI)
 303             SwAsciiOptions aAsciiOpt( xWrt->GetAsciiOptions() );
 304             aAsciiOpt.SetCharSet( RTL_TEXTENCODING_UCS2 );
 305             xWrt->SetAsciiOptions( aAsciiOpt );
 306             xWrt->m_bUCS2_WithStartChar = false;
 307             xWrt->m_bHideDeleteRedlines = GetLayout()->IsHideRedlines();
 308
 309             if ( ! aWriter.Write(xWrt).IsError() )
 310             {
 311                 aStream.WriteUInt16( '\0' );
 312
 313                 const sal_Unicode *p = static_cast<sal_Unicode const *>(aStream.GetData());
 314                 if (p)
 315                     rBuf = OUString(p);
 316                 else
 317                 {
 318                     const sal_uInt64 nLen = aStream.GetSize();
 319                     OSL_ENSURE( nLen/sizeof( sal_Unicode )<o3tl::make_unsigned(SAL_MAX_INT32), "Stream can't fit in OUString" );
 320                     rtl_uString *pStr = rtl_uString_alloc(static_cast<sal_Int32>(nLen / sizeof( sal_Unicode )));
 321                     aStream.Seek( 0 );
 322                     aStream.ResetError();
 323                     //endian specific?, yipes!
 324                     aStream.ReadBytes(pStr->buffer, nLen);
 325                     rBuf = OUString(pStr, SAL_NO_ACQUIRE);
 326                 }
 327             }
 328         }
 329     }
 330 }
 331
 332 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */