Line data    Source code

       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 <com/sun/star/util/SearchOptions.hpp>
      21             : #include <com/sun/star/util/SearchFlags.hpp>
      22             : #include <com/sun/star/i18n/TransliterationModules.hpp>
      23             : #include <comphelper/string.hxx>
      24             : #include <svl/fstathelper.hxx>
      25             : #include <osl/thread.h>
      26             : #include <unotools/textsearch.hxx>
      27             : #include <unotools/syslocale.hxx>
      28             : 
      29             : #include <sfx2/docfile.hxx>
      30             : 
      31             : #include <xmloff/odffields.hxx>
      32             : 
      33             : #include <editeng/unolingu.hxx>
      34             : 
      35             : #include <swtypes.hxx>
      36             : #include <editsh.hxx>
      37             : #include <doc.hxx>
      38             : #include <IDocumentUndoRedo.hxx>
      39             : #include <pam.hxx>
      40             : #include <viewopt.hxx>
      41             : #include <ndtxt.hxx>
      42             : #include <swundo.hxx>
      43             : #include <txttxmrk.hxx>
      44             : #include <edimp.hxx>
      45             : #include <tox.hxx>
      46             : #include <doctxm.hxx>
      47             : #include <docary.hxx>
      48             : #include <mdiexp.hxx>
      49             : #include <statstr.hrc>
      50             : #include <bookmrk.hxx>
      51             : 
      52             : using namespace ::com::sun::star;
      53             : using namespace ::com::sun::star::i18n;
      54             : using namespace ::com::sun::star::lang;
      55             : using namespace ::com::sun::star::util;
      56             : 
      57             : // Add/delete listing markers to a document
      58             : 
      59           0 : void SwEditShell::Insert(const SwTOXMark& rMark)
      60             : {
      61           0 :     bool bInsAtPos = rMark.IsAlternativeText();
      62           0 :     StartAllAction();
      63           0 :     for(SwPaM& rPaM : GetCrsr()->GetRingContainer())
      64             :     {
      65           0 :         const SwPosition *pStt = rPaM.Start(),
      66           0 :                          *pEnd = rPaM.End();
      67           0 :         if( bInsAtPos )
      68             :         {
      69           0 :             SwPaM aTmp( *pStt );
      70           0 :             GetDoc()->getIDocumentContentOperations().InsertPoolItem( aTmp, rMark );
      71             :         }
      72           0 :         else if( *pEnd != *pStt )
      73             :         {
      74           0 :             GetDoc()->getIDocumentContentOperations().InsertPoolItem(
      75           0 :                 rPaM, rMark, SetAttrMode::DONTEXPAND );
      76             :         }
      77             : 
      78             :     }
      79           0 :     EndAllAction();
      80           0 : }
      81             : 
      82           0 : void SwEditShell::DeleteTOXMark( SwTOXMark* pMark )
      83             : {
      84           0 :     SET_CURR_SHELL( this );
      85           0 :     StartAllAction();
      86             : 
      87           0 :     mpDoc->DeleteTOXMark( pMark );
      88             : 
      89           0 :     EndAllAction();
      90           0 : }
      91             : 
      92             : /// Collect all listing markers
      93         690 : sal_uInt16 SwEditShell::GetCurTOXMarks(SwTOXMarks& rMarks) const
      94             : {
      95         690 :     return SwDoc::GetCurTOXMark( *GetCrsr()->Start(), rMarks );
      96             : }
      97             : 
      98           0 : bool SwEditShell::IsTOXBaseReadonly(const SwTOXBase& rTOXBase)
      99             : {
     100             :     OSL_ENSURE( rTOXBase.ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
     101           0 :     const SwTOXBaseSection& rTOXSect = static_cast<const SwTOXBaseSection&>(rTOXBase);
     102           0 :     return  rTOXSect.IsProtect();
     103             : }
     104             : 
     105           0 : void SwEditShell::SetTOXBaseReadonly(const SwTOXBase& rTOXBase, bool bReadonly)
     106             : {
     107             :     OSL_ENSURE( rTOXBase.ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
     108           0 :     const SwTOXBaseSection& rTOXSect = static_cast<const SwTOXBaseSection&>(rTOXBase);
     109           0 :     const_cast<SwTOXBase&>(rTOXBase).SetProtected(bReadonly);
     110             :     OSL_ENSURE( rTOXSect.SwSection::GetType() == TOX_CONTENT_SECTION, "not a TOXContentSection" );
     111             : 
     112           0 :     SwSectionData aSectionData(rTOXSect);
     113           0 :     aSectionData.SetProtectFlag(bReadonly);
     114           0 :     UpdateSection( GetSectionFormatPos( *rTOXSect.GetFormat()  ), aSectionData, 0 );
     115           0 : }
     116             : 
     117           0 : const SwTOXBase*    SwEditShell::GetDefaultTOXBase( TOXTypes eTyp, bool bCreate )
     118             : {
     119           0 :     return GetDoc()->GetDefaultTOXBase( eTyp, bCreate );
     120             : }
     121             : 
     122           0 : void    SwEditShell::SetDefaultTOXBase(const SwTOXBase& rBase)
     123             : {
     124           0 :     GetDoc()->SetDefaultTOXBase(rBase);
     125           0 : }
     126             : 
     127             : /// Insert listing and create content
     128           0 : void SwEditShell::InsertTableOf( const SwTOXBase& rTOX, const SfxItemSet* pSet )
     129             : {
     130           0 :     SET_CURR_SHELL( this );
     131           0 :     StartAllAction();
     132             : 
     133           0 :     SwDocShell* pDocSh = GetDoc()->GetDocShell();
     134           0 :     ::StartProgress( STR_STATSTR_TOX_INSERT, 0, 0, pDocSh );
     135           0 :     ::SetProgressText( STR_STATSTR_TOX_INSERT, pDocSh );
     136             : 
     137             :     // Insert listing
     138             :     const SwTOXBaseSection* pTOX = mpDoc->InsertTableOf(
     139           0 :                                         *GetCrsr()->GetPoint(), rTOX, pSet, true );
     140             :     OSL_ENSURE(pTOX, "No current TOx");
     141             : 
     142             :     // start formatting
     143           0 :     CalcLayout();
     144             : 
     145             :     // insert page numbering
     146           0 :     const_cast<SwTOXBaseSection*>(pTOX)->UpdatePageNum();
     147             : 
     148           0 :     pTOX->SetPosAtStartEnd( *GetCrsr()->GetPoint() );
     149             : 
     150             :     // Fix for empty listing
     151           0 :     InvalidateWindows( maVisArea );
     152           0 :     ::EndProgress( pDocSh );
     153           0 :     EndAllAction();
     154           0 : }
     155             : 
     156             : /// update tables of content
     157           0 : bool SwEditShell::UpdateTableOf( const SwTOXBase& rTOX, const SfxItemSet* pSet )
     158             : {
     159           0 :     bool bRet = false;
     160             : 
     161             :     OSL_ENSURE( rTOX.ISA( SwTOXBaseSection ),  "no TOXBaseSection!" );
     162           0 :     SwTOXBaseSection* pTOX = const_cast<SwTOXBaseSection*>(static_cast<const SwTOXBaseSection*>(&rTOX));
     163             :     OSL_ENSURE(pTOX, "no current listing");
     164           0 :     if( pTOX && 0 != pTOX->GetFormat()->GetSectionNode() )
     165             :     {
     166           0 :         SwDoc* pMyDoc = GetDoc();
     167           0 :         SwDocShell* pDocSh = pMyDoc->GetDocShell();
     168             : 
     169           0 :         bool bInIndex = pTOX == GetCurTOX();
     170           0 :         SET_CURR_SHELL( this );
     171           0 :         StartAllAction();
     172             : 
     173           0 :         ::StartProgress( STR_STATSTR_TOX_UPDATE, 0, 0, pDocSh );
     174           0 :         ::SetProgressText( STR_STATSTR_TOX_UPDATE, pDocSh );
     175             : 
     176           0 :         pMyDoc->GetIDocumentUndoRedo().StartUndo(UNDO_TOXCHANGE, NULL);
     177             : 
     178             :         // create listing stub
     179           0 :         pTOX->Update(pSet);
     180             : 
     181             :         // correct Cursor
     182           0 :         if( bInIndex )
     183           0 :             pTOX->SetPosAtStartEnd( *GetCrsr()->GetPoint() );
     184             : 
     185             :         // start formatting
     186           0 :         CalcLayout();
     187             : 
     188             :         // insert page numbering
     189           0 :         pTOX->UpdatePageNum();
     190             : 
     191           0 :         pMyDoc->GetIDocumentUndoRedo().EndUndo(UNDO_TOXCHANGE, NULL);
     192             : 
     193           0 :         ::EndProgress( pDocSh );
     194           0 :         EndAllAction();
     195             :     }
     196           0 :     return bRet;
     197             : }
     198             : 
     199             : /// Get current listing before or at the Cursor
     200        2355 : const SwTOXBase* SwEditShell::GetCurTOX() const
     201             : {
     202        2355 :     return SwDoc::GetCurTOX( *GetCrsr()->GetPoint() );
     203             : }
     204             : 
     205           0 : bool SwEditShell::DeleteTOX( const SwTOXBase& rTOXBase, bool bDelNodes )
     206             : {
     207           0 :     return GetDoc()->DeleteTOX( (SwTOXBase&)rTOXBase, bDelNodes );
     208             : }
     209             : 
     210             : // manage types of listings
     211             : 
     212           0 : const SwTOXType* SwEditShell::GetTOXType(TOXTypes eTyp, sal_uInt16 nId) const
     213             : {
     214           0 :     return mpDoc->GetTOXType(eTyp, nId);
     215             : }
     216             : 
     217             : // manage keys for the alphabetical index
     218             : 
     219           0 : sal_uInt16 SwEditShell::GetTOIKeys( SwTOIKeyType eTyp, std::vector<OUString>& rArr ) const
     220             : {
     221           0 :     return GetDoc()->GetTOIKeys( eTyp, rArr );
     222             : }
     223             : 
     224          40 : sal_uInt16 SwEditShell::GetTOXCount() const
     225             : {
     226          40 :     const SwSectionFormats& rFormats = GetDoc()->GetSections();
     227          40 :     sal_uInt16 nRet = 0;
     228          80 :     for( auto n = rFormats.size(); n; )
     229             :     {
     230           0 :         const SwSection* pSect = rFormats[ --n ]->GetSection();
     231           0 :         if( TOX_CONTENT_SECTION == pSect->GetType() &&
     232           0 :             pSect->GetFormat()->GetSectionNode() )
     233           0 :             ++nRet;
     234             :     }
     235          40 :     return nRet;
     236             : }
     237             : 
     238           0 : const SwTOXBase* SwEditShell::GetTOX( sal_uInt16 nPos ) const
     239             : {
     240           0 :     const SwSectionFormats& rFormats = GetDoc()->GetSections();
     241           0 :     sal_uInt16 nCnt {0};
     242           0 :     for( const SwSectionFormat *pFormat : rFormats )
     243             :     {
     244           0 :         const SwSection* pSect = pFormat->GetSection();
     245           0 :         if( TOX_CONTENT_SECTION == pSect->GetType() &&
     246           0 :             pSect->GetFormat()->GetSectionNode() &&
     247           0 :             nCnt++ == nPos )
     248             :         {
     249             :             OSL_ENSURE( pSect->ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
     250           0 :             return static_cast<const SwTOXBaseSection*>(pSect);
     251             :         }
     252             :     }
     253           0 :     return 0;
     254             : }
     255             : 
     256             : /** Update of all listings after reading-in a file */
     257           0 : void SwEditShell::SetUpdateTOX( bool bFlag )
     258             : {
     259           0 :     GetDoc()->SetUpdateTOX( bFlag );
     260           0 : }
     261             : 
     262           0 : bool SwEditShell::IsUpdateTOX() const
     263             : {
     264           0 :     return GetDoc()->IsUpdateTOX();
     265             : }
     266             : 
     267           0 : OUString SwEditShell::GetTOIAutoMarkURL() const
     268             : {
     269           0 :     return GetDoc()->GetTOIAutoMarkURL();
     270             : }
     271             : 
     272           0 : void SwEditShell::SetTOIAutoMarkURL(const OUString& rSet)
     273             : {
     274           0 :     GetDoc()->SetTOIAutoMarkURL(rSet);
     275           0 : }
     276             : 
     277           0 : void SwEditShell::ApplyAutoMark()
     278             : {
     279           0 :     StartAllAction();
     280           0 :     bool bDoesUndo = DoesUndo();
     281           0 :     DoUndo(false);
     282             :     //1. remove all automatic generated index entries if AutoMarkURL has a
     283             :     //   length and the file exists
     284             :     //2. load file
     285             :     //3. select all occurrences of the searched words
     286             :     //4. apply index entries
     287             : 
     288           0 :     OUString sAutoMarkURL(GetDoc()->GetTOIAutoMarkURL());
     289           0 :     if( !sAutoMarkURL.isEmpty() && FStatHelper::IsDocument( sAutoMarkURL ))
     290             :     {
     291             :         //1.
     292           0 :         const SwTOXType* pTOXType = GetTOXType(TOX_INDEX, 0);
     293             : 
     294           0 :         SwTOXMarks aMarks;
     295           0 :         SwTOXMark::InsertTOXMarks( aMarks, *pTOXType );
     296           0 :         for( SwTOXMark* pMark : aMarks )
     297             :         {
     298           0 :             if(pMark->IsAutoGenerated() && pMark->GetTextTOXMark())
     299             :                 // mba: test iteration; objects are deleted in iteration
     300           0 :                 DeleteTOXMark(pMark);
     301             :         }
     302             : 
     303             :         //2.
     304           0 :         SfxMedium aMedium( sAutoMarkURL, STREAM_STD_READ );
     305           0 :         SvStream& rStrm = *aMedium.GetInStream();
     306           0 :         const sal_Unicode cZero('0');
     307           0 :         Push();
     308           0 :         rtl_TextEncoding eChrSet = ::osl_getThreadTextEncoding();
     309             : 
     310             :         // SearchOptions to be used in loop below
     311           0 :         sal_Int32 nLEV_Other    = 2;    //  -> changedChars;
     312           0 :         sal_Int32 nLEV_Longer   = 3;    //! -> deletedChars;
     313           0 :         sal_Int32 nLEV_Shorter  = 1;    //! -> insertedChars;
     314           0 :         sal_Int32 nTransliterationFlags = 0;
     315             : 
     316           0 :         sal_Int32 nSrchFlags = SearchFlags::LEV_RELAXED;
     317             : 
     318           0 :         OUString sEmpty;
     319             :         SearchOptions aSearchOpt(
     320             :                             SearchAlgorithms_ABSOLUTE, nSrchFlags,
     321             :                             sEmpty, sEmpty,
     322           0 :                             SvtSysLocale().GetLanguageTag().getLocale(),
     323             :                             nLEV_Other, nLEV_Longer, nLEV_Shorter,
     324           0 :                             nTransliterationFlags );
     325             : 
     326           0 :         while( !rStrm.GetError() && !rStrm.IsEof() )
     327             :         {
     328           0 :             OString aRdLine;
     329           0 :             rStrm.ReadLine( aRdLine );
     330             : 
     331             :             // # -> comment
     332             :             // ; -> delimiter between entries ->
     333             :             // Format: TextToSearchFor;AlternativeString;PrimaryKey;SecondaryKey;CaseSensitive;WordOnly
     334             :             // Leading and trailing blanks are ignored
     335           0 :             if( !aRdLine.isEmpty() && '#' != aRdLine[0] )
     336             :             {
     337           0 :                 OUString sLine(OStringToOUString(aRdLine, eChrSet));
     338             : 
     339           0 :                 sal_Int32 nTokenPos = 0;
     340           0 :                 OUString sToSelect( sLine.getToken(0, ';', nTokenPos ) );
     341           0 :                 if( !sToSelect.isEmpty() )
     342             :                 {
     343           0 :                     OUString sAlternative = sLine.getToken(0, ';', nTokenPos);
     344           0 :                     OUString sPrimary     = sLine.getToken(0, ';', nTokenPos);
     345           0 :                     OUString sSecondary   = sLine.getToken(0, ';', nTokenPos);
     346           0 :                     OUString sCase        = sLine.getToken(0, ';', nTokenPos);
     347           0 :                     OUString sWordOnly    = sLine.getToken(0, ';', nTokenPos);
     348             : 
     349             :                     //3.
     350           0 :                     bool bCaseSensitive = !sCase.isEmpty() && !comphelper::string::equals(sCase, cZero);
     351           0 :                     bool bWordOnly = !sWordOnly.isEmpty() && !comphelper::string::equals(sWordOnly, cZero);
     352             : 
     353           0 :                     if (!bCaseSensitive)
     354             :                     {
     355             :                         aSearchOpt.transliterateFlags |=
     356           0 :                                      TransliterationModules_IGNORE_CASE;
     357             :                     }
     358             :                     else
     359             :                     {
     360             :                         aSearchOpt.transliterateFlags &=
     361           0 :                                     ~TransliterationModules_IGNORE_CASE;
     362             :                     }
     363           0 :                     if ( bWordOnly)
     364           0 :                         aSearchOpt.searchFlag |=  SearchFlags::NORM_WORD_ONLY;
     365             :                     else
     366           0 :                         aSearchOpt.searchFlag &= ~SearchFlags::NORM_WORD_ONLY;
     367             : 
     368           0 :                     aSearchOpt.searchString = sToSelect;
     369             : 
     370           0 :                     KillPams();
     371             :                     bool bCancel;
     372             : 
     373             :                     // todo/mba: assuming that notes shouldn't be searched
     374           0 :                     bool bSearchInNotes = false;
     375             :                     sal_uLong nRet = Find( aSearchOpt,  bSearchInNotes, DOCPOS_START, DOCPOS_END, bCancel,
     376           0 :                                     (FindRanges)(FND_IN_SELALL), false );
     377             : 
     378           0 :                     if(nRet)
     379             :                     {
     380           0 :                         SwTOXMark* pTmpMark = new SwTOXMark(pTOXType);
     381           0 :                         if( !sPrimary.isEmpty() )
     382             :                         {
     383           0 :                             pTmpMark->SetPrimaryKey( sPrimary );
     384           0 :                             if( !sSecondary.isEmpty() )
     385           0 :                                 pTmpMark->SetSecondaryKey( sSecondary );
     386             :                         }
     387           0 :                         if( !sAlternative.isEmpty() )
     388           0 :                             pTmpMark->SetAlternativeText(sAlternative);
     389           0 :                         pTmpMark->SetMainEntry(false);
     390           0 :                         pTmpMark->SetAutoGenerated(true);
     391             :                         //4.
     392           0 :                         SwEditShell::Insert(*pTmpMark);
     393           0 :                     }
     394           0 :                 }
     395             :             }
     396           0 :         }
     397           0 :         KillPams();
     398           0 :         Pop(false);
     399             :     }
     400           0 :     DoUndo(bDoesUndo);
     401           0 :     EndAllAction();
     402         177 : }
     403             : 
     404             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */