sw/source/core/edit/edtox.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: edtox.cxx,v $
  10  * $Revision: 1.19 $
  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_sw.hxx"
  33 #include <com/sun/star/util/SearchOptions.hpp>
  34 #include <com/sun/star/util/SearchFlags.hpp>
  35 #include <com/sun/star/i18n/TransliterationModules.hpp>
  36
  37
  38 #include <tools/urlobj.hxx>
  39 #include <svtools/txtcmp.hxx>
  40 #ifndef SVTOOLS_FSTATHELPER_HXX
  41 #include <svtools/fstathelper.hxx>
  42 #endif
  43 #include <sfx2/docfile.hxx>
  44 #include "svx/unolingu.hxx"
  45 #include <swtypes.hxx>
  46 #include <editsh.hxx>
  47 #include <doc.hxx>
  48 #include <pam.hxx>
  49 #include <viewopt.hxx>
  50 #include <ndtxt.hxx>
  51 #include <errhdl.hxx>
  52 #include <swundo.hxx>
  53 #include <undobj.hxx>
  54 #include <txttxmrk.hxx>
  55 #include <edimp.hxx>
  56 #include <tox.hxx>
  57 #include <doctxm.hxx>
  58 #include <docary.hxx>
  59 #include <mdiexp.hxx>
  60 #ifndef _STATSTR_HRC
  61 #include <statstr.hrc>
  62 #endif
  63 #include <bookmrk.hxx>
  64 #include <ecmaflds.hxx>
  65
  66
  67 using namespace ::com::sun::star;
  68 using namespace ::com::sun::star::i18n;
  69 using namespace ::com::sun::star::lang;
  70 using namespace ::com::sun::star::util;
  71
  72 /*--------------------------------------------------------------------
  73      Beschreibung: Verzeichnismarkierung ins Dokument einfuegen/loeschen
  74  --------------------------------------------------------------------*/
  75
  76
  77 void SwEditShell::Insert(const SwTOXMark& rMark)
  78 {
  79     BOOL bInsAtPos = rMark.IsAlternativeText();
  80     StartAllAction();
  81     FOREACHPAM_START(this)
  82
  83         const SwPosition *pStt = PCURCRSR->Start(),
  84                          *pEnd = PCURCRSR->End();
  85         if( bInsAtPos )
  86         {
  87             SwPaM aTmp( *pStt );
  88             GetDoc()->Insert( aTmp, rMark, 0 );
  89         }
  90         else if( *pEnd != *pStt )
  91             GetDoc()->Insert( *PCURCRSR, rMark, nsSetAttrMode::SETATTR_DONTEXPAND );
  92
  93     FOREACHPAM_END()
  94     EndAllAction();
  95 }
  96
  97
  98
  99 void SwEditShell::DeleteTOXMark( SwTOXMark* pMark )
 100 {
 101     SET_CURR_SHELL( this );
 102     StartAllAction();
 103
 104     pDoc->Delete( pMark );
 105
 106     EndAllAction();
 107 }
 108
 109
 110 /*--------------------------------------------------------------------
 111      Beschreibung: Alle Verzeichnismarkierungen am SPoint zusammensuchen
 112  --------------------------------------------------------------------*/
 113
 114 USHORT SwEditShell::GetCurTOXMarks(SwTOXMarks& rMarks) const
 115 {
 116     return GetDoc()->GetCurTOXMark( *GetCrsr()->Start(), rMarks );
 117 }
 118
 119 /* -----------------01.09.99 16:05-------------------
 120
 121  --------------------------------------------------*/
 122 BOOL SwEditShell::IsTOXBaseReadonly(const SwTOXBase& rTOXBase) const
 123 {
 124     ASSERT( rTOXBase.ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
 125     const SwTOXBaseSection& rTOXSect = (const SwTOXBaseSection&)rTOXBase;
 126     return      rTOXSect.IsProtect();
 127 }
 128 /* -----------------18.10.99 15:53-------------------
 129
 130  --------------------------------------------------*/
 131 void SwEditShell::SetTOXBaseReadonly(const SwTOXBase& rTOXBase, BOOL bReadonly)
 132 {
 133     ASSERT( rTOXBase.ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
 134     const SwTOXBaseSection& rTOXSect = (const SwTOXBaseSection&)rTOXBase;
 135     ((SwTOXBase&)rTOXBase).SetProtected(bReadonly);
 136     ASSERT( rTOXSect.SwSection::GetType() == TOX_CONTENT_SECTION, "not a TOXContentSection" );
 137
 138     SwSection aSect(TOX_CONTENT_SECTION, rTOXSect.GetName());
 139     aSect = rTOXSect;
 140     aSect.SetProtect(bReadonly);
 141     ChgSection( GetSectionFmtPos( *rTOXSect.GetFmt()  ), aSect, 0 );
 142 }
 143
 144 /* -----------------02.09.99 07:47-------------------
 145
 146  --------------------------------------------------*/
 147 const SwTOXBase*        SwEditShell::GetDefaultTOXBase( TOXTypes eTyp, BOOL bCreate )
 148 {
 149     return GetDoc()->GetDefaultTOXBase( eTyp, bCreate );
 150 }
 151 /* -----------------02.09.99 08:05-------------------
 152
 153  --------------------------------------------------*/
 154 void    SwEditShell::SetDefaultTOXBase(const SwTOXBase& rBase)
 155 {
 156     GetDoc()->SetDefaultTOXBase(rBase);
 157 }
 158
 159 /*--------------------------------------------------------------------
 160      Beschreibung: Verzeichnis einfuegen, und Inhalt erzeugen
 161  --------------------------------------------------------------------*/
 162
 163 void SwEditShell::InsertTableOf( const SwTOXBase& rTOX, const SfxItemSet* pSet )
 164 {
 165     SET_CURR_SHELL( this );
 166     StartAllAction();
 167
 168     SwDocShell* pDocSh = GetDoc()->GetDocShell();
 169     ::StartProgress( STR_STATSTR_TOX_INSERT, 0, 0, pDocSh );
 170     ::SetProgressText( STR_STATSTR_TOX_INSERT, pDocSh );
 171
 172     // Einfuegen des Verzeichnisses
 173     const SwTOXBaseSection* pTOX = pDoc->InsertTableOf(
 174                                         *GetCrsr()->GetPoint(), rTOX, pSet, TRUE );
 175     ASSERT(pTOX, "Kein aktuelles Verzeichnis");
 176
 177     // Formatierung anstossen
 178     CalcLayout();
 179
 180     // Seitennummern eintragen
 181     ((SwTOXBaseSection*)pTOX)->UpdatePageNum();
 182
 183     pTOX->SetPosAtStartEnd( *GetCrsr()->GetPoint() );
 184
 185     // Fix fuer leere Verzeichnisse
 186     InvalidateWindows( aVisArea );
 187     ::EndProgress( pDocSh );
 188     EndAllAction();
 189 }
 190
 191 /*--------------------------------------------------------------------
 192      Beschreibung: Verzeichnisinhalt erneuern
 193  --------------------------------------------------------------------*/
 194
 195 BOOL SwEditShell::UpdateTableOf( const SwTOXBase& rTOX, const SfxItemSet* pSet )
 196 {
 197     BOOL bRet = FALSE;
 198
 199     ASSERT( rTOX.ISA( SwTOXBaseSection ),  "keine TOXBaseSection!" );
 200     SwTOXBaseSection* pTOX = (SwTOXBaseSection*)&rTOX;
 201     ASSERT(pTOX, "Keine aktuelles Verzeichnis");
 202     const SwSectionNode* pSectNd;
 203     if( pTOX && 0 != ( pSectNd = pTOX->GetFmt()->GetSectionNode() ) )
 204     {
 205         SwDoc* pMyDoc = GetDoc();
 206         SwDocShell* pDocSh = pMyDoc->GetDocShell();
 207
 208         BOOL bInIndex = pTOX == GetCurTOX();
 209         SET_CURR_SHELL( this );
 210         StartAllAction();
 211
 212         ::StartProgress( STR_STATSTR_TOX_UPDATE, 0, 0, pDocSh );
 213         ::SetProgressText( STR_STATSTR_TOX_UPDATE, pDocSh );
 214
 215         pMyDoc->StartUndo(UNDO_TOXCHANGE, NULL);
 216
 217         // Verzeichnisrumpf erzeugen
 218         pTOX->Update(pSet);
 219
 220         // Cursor korrigieren
 221         if( bInIndex )
 222             pTOX->SetPosAtStartEnd( *GetCrsr()->GetPoint() );
 223
 224         // Formatierung anstossen
 225         CalcLayout();
 226
 227         // Seitennummern eintragen
 228         pTOX->UpdatePageNum();
 229
 230         pMyDoc->EndUndo(UNDO_TOXCHANGE, NULL);
 231
 232         ::EndProgress( pDocSh );
 233         EndAllAction();
 234     }
 235     return bRet;
 236 }
 237
 238 BOOL SwEditShell::UpdateField( sw::mark::IFieldmark &fieldBM)
 239 {
 240 //    SwDocShell* pDocSh = pDoc->GetDocShell();
 241     //@TODO implement me...; add undo etc...
 242     if ( pDoc && fieldBM.IsExpanded( ) ) {
 243         SwPosition aSttPos = fieldBM.GetMarkStart( );
 244         aSttPos.nContent++;
 245
 246         SwPosition aEndPos = fieldBM.GetMarkEnd( );
 247         aEndPos.nContent--;
 248
 249         SwPaM aPaM( aSttPos, aEndPos );
 250             pDoc->Delete(aPaM);
 251         pDoc->Insert(aPaM, String::CreateFromAscii("Implement me ;-)"), false);
 252     }
 253     return TRUE;
 254 }
 255
 256
 257 /*--------------------------------------------------------------------
 258      Beschreibung: Aktuelles Verzeichnis vor oder in dem der Cursor
 259                                    steht
 260  --------------------------------------------------------------------*/
 261
 262 const SwTOXBase* SwEditShell::GetCurTOX() const
 263 {
 264     return GetDoc()->GetCurTOX( *GetCrsr()->GetPoint() );
 265 }
 266
 267 BOOL SwEditShell::DeleteTOX( const SwTOXBase& rTOXBase, BOOL bDelNodes )
 268 {
 269     return GetDoc()->DeleteTOX( (SwTOXBase&)rTOXBase, bDelNodes );
 270 }
 271
 272 /*--------------------------------------------------------------------
 273      Beschreibung: Typen der Verzeichnisse verwalten
 274  --------------------------------------------------------------------*/
 275
 276 const SwTOXType* SwEditShell::GetTOXType(TOXTypes eTyp, USHORT nId) const
 277 {
 278     return pDoc->GetTOXType(eTyp, nId);
 279 }
 280
 281 /*--------------------------------------------------------------------
 282      Beschreibung: Schluessel fuer Stichwortverzeichnisse verwalten
 283  --------------------------------------------------------------------*/
 284
 285 USHORT SwEditShell::GetTOIKeys( SwTOIKeyType eTyp, SvStringsSort& rArr ) const
 286 {
 287     return GetDoc()->GetTOIKeys( eTyp, rArr );
 288 }
 289
 290
 291 USHORT SwEditShell::GetTOXCount() const
 292 {
 293     const SwSectionFmts& rFmts = GetDoc()->GetSections();
 294     USHORT nRet = 0;
 295     for( USHORT n = rFmts.Count(); n; )
 296     {
 297         const SwSection* pSect = rFmts[ --n ]->GetSection();
 298         if( TOX_CONTENT_SECTION == pSect->GetType() &&
 299             pSect->GetFmt()->GetSectionNode() )
 300             ++nRet;
 301     }
 302     return nRet;
 303 }
 304
 305
 306 const SwTOXBase* SwEditShell::GetTOX( USHORT nPos ) const
 307 {
 308     const SwSectionFmts& rFmts = GetDoc()->GetSections();
 309     for( USHORT n = 0, nCnt = 0; n < rFmts.Count(); ++n )
 310     {
 311         const SwSection* pSect = rFmts[ n ]->GetSection();
 312         if( TOX_CONTENT_SECTION == pSect->GetType() &&
 313             pSect->GetFmt()->GetSectionNode() &&
 314             nCnt++ == nPos )
 315         {
 316             ASSERT( pSect->ISA( SwTOXBaseSection ), "keine TOXBaseSection!" );
 317             return (SwTOXBaseSection*)pSect;
 318         }
 319     }
 320     return 0;
 321 }
 322
 323
 324     // nach einlesen einer Datei alle Verzeichnisse updaten
 325 void SwEditShell::SetUpdateTOX( BOOL bFlag )
 326 {
 327     GetDoc()->SetUpdateTOX( bFlag );
 328 }
 329
 330
 331 BOOL SwEditShell::IsUpdateTOX() const
 332 {
 333     return GetDoc()->IsUpdateTOX();
 334 }
 335
 336 /* -----------------26.08.99 13:49-------------------
 337
 338  --------------------------------------------------*/
 339 const String&   SwEditShell::GetTOIAutoMarkURL() const
 340 {
 341     return GetDoc()->GetTOIAutoMarkURL();
 342 }
 343 /* -----------------26.08.99 13:49-------------------
 344
 345  --------------------------------------------------*/
 346 void SwEditShell::SetTOIAutoMarkURL(const String& rSet)
 347 {
 348     GetDoc()->SetTOIAutoMarkURL(rSet);
 349 }
 350 /* -----------------26.08.99 09:29-------------------
 351
 352  --------------------------------------------------*/
 353 void SwEditShell::ApplyAutoMark()
 354 {
 355     StartAllAction();
 356     BOOL bDoesUndo = DoesUndo();
 357     DoUndo(FALSE);
 358     //1. remove all automatic generated index entries if AutoMarkURL has a
 359     //   length and the file exists
 360     //2. load file
 361     //3. select all occurrences of the searched words
 362     //4. apply index entries
 363
 364     String sAutoMarkURL(GetDoc()->GetTOIAutoMarkURL());
 365     if( sAutoMarkURL.Len() && FStatHelper::IsDocument( sAutoMarkURL ))
 366     {
 367         //1.
 368         const SwTOXType* pTOXType = GetTOXType(TOX_INDEX, 0);
 369         SwClientIter aIter(*(SwTOXType*)pTOXType);
 370         SwTOXMark* pMark = (SwTOXMark*)aIter.First(TYPE(SwTOXMark));
 371         while( pMark )
 372         {
 373             if(pMark->IsAutoGenerated() && pMark->GetTxtTOXMark())
 374                 DeleteTOXMark(pMark);
 375             pMark = (SwTOXMark*)aIter.Next();
 376         }
 377
 378         //2.
 379         SfxMedium aMedium( sAutoMarkURL, STREAM_STD_READ, TRUE );
 380         SvStream& rStrm = *aMedium.GetInStream();
 381         const String sZero('0');
 382         Push();
 383         rtl_TextEncoding eChrSet = ::gsl_getSystemTextEncoding();
 384
 385         //
 386         // SearchOptions to be used in loop below
 387         //
 388         //SearchAlgorithms eSrchType    = SearchAlgorithms_ABSOLUTE;
 389         //OUString aSrchStr     = rText;
 390         BOOL bCaseSensitive     = TRUE;
 391         BOOL bWordOnly          = FALSE;
 392         BOOL bSrchInSel         = FALSE;
 393         BOOL bLEV_Relaxed       = TRUE;
 394         INT32 nLEV_Other        = 2;    //  -> changedChars;
 395         INT32 nLEV_Longer       = 3;    //! -> deletedChars;
 396         INT32 nLEV_Shorter      = 1;    //!     -> insertedChars;
 397         INT32 nTransliterationFlags = 0;
 398         //
 399         INT32 nSrchFlags = 0;
 400         if (!bCaseSensitive)
 401         {
 402             nSrchFlags |= SearchFlags::ALL_IGNORE_CASE;
 403             nTransliterationFlags |= TransliterationModules_IGNORE_CASE;
 404         }
 405         if ( bWordOnly)
 406             nSrchFlags |= SearchFlags::NORM_WORD_ONLY;
 407         if ( bLEV_Relaxed)
 408             nSrchFlags |= SearchFlags::LEV_RELAXED;
 409         if ( bSrchInSel)
 410             nSrchFlags |= (SearchFlags::REG_NOT_BEGINOFLINE |
 411                             SearchFlags::REG_NOT_ENDOFLINE );
 412         //
 413         rtl::OUString sEmpty;
 414         SearchOptions aSearchOpt(
 415                             SearchAlgorithms_ABSOLUTE, nSrchFlags,
 416                             sEmpty, sEmpty,
 417                             SvxCreateLocale( LANGUAGE_SYSTEM ),
 418                             nLEV_Other, nLEV_Longer, nLEV_Shorter,
 419                             nTransliterationFlags );
 420
 421         while( !rStrm.GetError() && !rStrm.IsEof() )
 422         {
 423             ByteString aRdLine;
 424             rStrm.ReadLine( aRdLine );
 425
 426             // # -> comment
 427             // ; -> delimiter between entries ->
 428             // Format: TextToSearchFor;AlternativeString;PrimaryKey;SecondaryKey;CaseSensitive;WordOnly
 429             // Leading and trailing blanks are ignored
 430             if( aRdLine.Len() && '#' != aRdLine.GetChar(0) )
 431             {
 432                 String sLine( aRdLine, eChrSet );
 433
 434                 xub_StrLen nTokenPos = 0;
 435                 String sToSelect( sLine.GetToken(0, ';', nTokenPos ) );
 436                 if( sToSelect.Len() )
 437                 {
 438                     String sAlternative = sLine.GetToken(0, ';', nTokenPos);
 439                     String sPrimary     = sLine.GetToken(0, ';', nTokenPos);
 440                     String sSecondary   = sLine.GetToken(0, ';', nTokenPos);
 441                     String sCase        = sLine.GetToken(0, ';', nTokenPos);
 442                     String sWordOnly    = sLine.GetToken(0, ';', nTokenPos);
 443
 444                     //3.
 445                     bCaseSensitive      = sCase.Len() && sCase != sZero;
 446                     bWordOnly           = sWordOnly.Len() && sWordOnly != sZero;
 447                     //
 448                     if (!bCaseSensitive)
 449                     {
 450                         //nSrchFlags |= SearchFlags::ALL_IGNORE_CASE;
 451                         aSearchOpt.transliterateFlags |=
 452                                      TransliterationModules_IGNORE_CASE;
 453                     }
 454                     else
 455                     {
 456                         //aSearchOpt.searchFlag &= ~SearchFlags::ALL_IGNORE_CASE;
 457                         aSearchOpt.transliterateFlags &=
 458                                     ~TransliterationModules_IGNORE_CASE;
 459                     }
 460                     if ( bWordOnly)
 461                         aSearchOpt.searchFlag |=  SearchFlags::NORM_WORD_ONLY;
 462                     else
 463                         aSearchOpt.searchFlag &= ~SearchFlags::NORM_WORD_ONLY;
 464                     //
 465                     aSearchOpt.searchString = sToSelect;
 466
 467                     KillPams();
 468                     BOOL bCancel;
 469
 470                     // todo/mba: assuming that notes shouldn't be searched
 471                     BOOL bSearchInNotes = FALSE;
 472                     ULONG nRet = Find( aSearchOpt,  bSearchInNotes, DOCPOS_START, DOCPOS_END, bCancel,
 473                                     (FindRanges)(FND_IN_SELALL|FND_IN_BODYONLY),
 474                                     FALSE );
 475
 476                     if(nRet)
 477                     {
 478                         SwTOXMark* pTmpMark = new SwTOXMark(pTOXType);
 479                         if( sPrimary.Len() )
 480                         {
 481                             pTmpMark->SetPrimaryKey( sPrimary );
 482                             if( sSecondary.Len() )
 483                                 pTmpMark->SetSecondaryKey( sSecondary );
 484                         }
 485                         if(sAlternative.Len())
 486                             pTmpMark->SetAlternativeText(sAlternative);
 487                         pTmpMark->SetMainEntry(FALSE);
 488                         pTmpMark->SetAutoGenerated(TRUE);
 489                         //4.
 490                         SwEditShell::Insert(*pTmpMark);
 491                     }
 492                 }
 493             }
 494         }
 495         KillPams();
 496         Pop(FALSE);
 497     }
 498     DoUndo(bDoesUndo);
 499     EndAllAction();
 500 }
 501
 502
 503