svtools/source/edit/xtextedt.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: xtextedt.cxx,v $
  10  * $Revision: 1.15 $
  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_svtools.hxx"
  33
  34 #include <svtools/xtextedt.hxx>
  35 #include <vcl/svapp.hxx>  // International
  36 #include <unotools/textsearch.hxx>
  37 #include <com/sun/star/util/SearchOptions.hpp>
  38 #include <com/sun/star/util/SearchFlags.hpp>
  39
  40 using namespace ::com::sun::star;
  41
  42
  43
  44 \f// -------------------------------------------------------------------------
  45 // class ExtTextEngine
  46 // -------------------------------------------------------------------------
  47 ExtTextEngine::ExtTextEngine() : maGroupChars( String::CreateFromAscii( "(){}[]", 6 ) )
  48 {
  49 }
  50
  51 ExtTextEngine::~ExtTextEngine()
  52 {
  53 }
  54
  55 TextSelection ExtTextEngine::MatchGroup( const TextPaM& rCursor ) const
  56 {
  57     TextSelection aSel( rCursor );
  58     USHORT nPos = rCursor.GetIndex();
  59     ULONG nPara = rCursor.GetPara();
  60     ULONG nParas = GetParagraphCount();
  61     if ( ( nPara < nParas ) && ( nPos < GetTextLen( nPara ) ) )
  62     {
  63         USHORT nMatchChar = maGroupChars.Search( GetText( rCursor.GetPara() ).GetChar( nPos ) );
  64         if ( nMatchChar != STRING_NOTFOUND )
  65         {
  66             if ( ( nMatchChar % 2 ) == 0 )
  67             {
  68                 // Vorwaerts suchen...
  69                 sal_Unicode nSC = maGroupChars.GetChar( nMatchChar );
  70                 sal_Unicode nEC = maGroupChars.GetChar( nMatchChar+1 );
  71
  72                 USHORT nCur = nPos+1;
  73                 USHORT nLevel = 1;
  74                 while ( nLevel && ( nPara < nParas ) )
  75                 {
  76                     XubString aStr = GetText( nPara );
  77                     while ( nCur < aStr.Len() )
  78                     {
  79                         if ( aStr.GetChar( nCur ) == nSC )
  80                             nLevel++;
  81                         else if ( aStr.GetChar( nCur ) == nEC )
  82                         {
  83                             nLevel--;
  84                             if ( !nLevel )
  85                                 break;  // while nCur...
  86                         }
  87                         nCur++;
  88                     }
  89
  90                     if ( nLevel )
  91                     {
  92                         nPara++;
  93                         nCur = 0;
  94                     }
  95                 }
  96                 if ( nLevel == 0 )      // gefunden
  97                 {
  98                     aSel.GetStart() = rCursor;
  99                     aSel.GetEnd() = TextPaM( nPara, nCur+1 );
 100                 }
 101             }
 102             else
 103             {
 104                 // Rueckwaerts suchen...
 105                 xub_Unicode nEC = maGroupChars.GetChar( nMatchChar );
 106                 xub_Unicode nSC = maGroupChars.GetChar( nMatchChar-1 );
 107
 108                 USHORT nCur = rCursor.GetIndex()-1;
 109                 USHORT nLevel = 1;
 110                 while ( nLevel )
 111                 {
 112                     if ( GetTextLen( nPara ) )
 113                     {
 114                         XubString aStr = GetText( nPara );
 115                         while ( nCur )
 116                         {
 117                             if ( aStr.GetChar( nCur ) == nSC )
 118                             {
 119                                 nLevel--;
 120                                 if ( !nLevel )
 121                                     break;      // while nCur...
 122                             }
 123                             else if ( aStr.GetChar( nCur ) == nEC )
 124                                 nLevel++;
 125
 126                             nCur--;
 127                         }
 128                     }
 129
 130                     if ( nLevel )
 131                     {
 132                         if ( nPara )
 133                         {
 134                             nPara--;
 135                             nCur = GetTextLen( nPara )-1;       // egal ob negativ, weil if Len()
 136                         }
 137                         else
 138                             break;
 139                     }
 140                 }
 141
 142                 if ( nLevel == 0 )      // gefunden
 143                 {
 144                     aSel.GetStart() = rCursor;
 145                     aSel.GetStart().GetIndex()++;       // hinter das Zeichen
 146                     aSel.GetEnd() = TextPaM( nPara, nCur );
 147                 }
 148             }
 149         }
 150     }
 151     return aSel;
 152 }
 153
 154 BOOL ExtTextEngine::Search( TextSelection& rSel, const util::SearchOptions& rSearchOptions, BOOL bForward )
 155 {
 156     TextSelection aSel( rSel );
 157     aSel.Justify();
 158
 159     BOOL bSearchInSelection = (0 != (rSearchOptions.searchFlag & util::SearchFlags::REG_NOT_BEGINOFLINE) );
 160
 161     TextPaM aStartPaM( aSel.GetEnd() );
 162     if ( aSel.HasRange() && ( ( bSearchInSelection && bForward ) || ( !bSearchInSelection && !bForward ) ) )
 163     {
 164         aStartPaM = aSel.GetStart();
 165     }
 166
 167     bool bFound = false;
 168     ULONG nStartNode, nEndNode;
 169
 170     if ( bSearchInSelection )
 171         nEndNode = bForward ? aSel.GetEnd().GetPara() : aSel.GetStart().GetPara();
 172     else
 173         nEndNode = bForward ? (GetParagraphCount()-1) : 0;
 174
 175     nStartNode = aStartPaM.GetPara();
 176
 177     util::SearchOptions aOptions( rSearchOptions );
 178     aOptions.Locale = Application::GetSettings().GetLocale();
 179     utl::TextSearch aSearcher( rSearchOptions );
 180
 181     // ueber die Absaetze iterieren...
 182     for ( ULONG nNode = nStartNode;
 183             bForward ?  ( nNode <= nEndNode) : ( nNode >= nEndNode );
 184             bForward ? nNode++ : nNode-- )
 185     {
 186         String aText = GetText( nNode );
 187         USHORT nStartPos = 0;
 188         USHORT nEndPos = aText.Len();
 189         if ( nNode == nStartNode )
 190         {
 191             if ( bForward )
 192                 nStartPos = aStartPaM.GetIndex();
 193             else
 194                 nEndPos = aStartPaM.GetIndex();
 195         }
 196         if ( ( nNode == nEndNode ) && bSearchInSelection )
 197         {
 198             if ( bForward )
 199                 nEndPos = aSel.GetEnd().GetIndex();
 200             else
 201                 nStartPos = aSel.GetStart().GetIndex();
 202         }
 203
 204         if ( bForward )
 205             bFound = aSearcher.SearchFrwrd( aText, &nStartPos, &nEndPos );
 206         else
 207             bFound = aSearcher.SearchBkwrd( aText, &nEndPos, &nStartPos );
 208
 209         if ( bFound )
 210         {
 211             rSel.GetStart().GetPara() = nNode;
 212             rSel.GetStart().GetIndex() = nStartPos;
 213             rSel.GetEnd().GetPara() = nNode;
 214             rSel.GetEnd().GetIndex() = nEndPos;
 215             // Ueber den Absatz selektieren?
 216             // Select over the paragraph?
 217             // FIXME  This should be max long...
 218             if( nEndPos == sal::static_int_cast<USHORT>(-1) ) // USHORT for 0 and -1 !
 219             {
 220                 if ( (rSel.GetEnd().GetPara()+1) < GetParagraphCount() )
 221                 {
 222                     rSel.GetEnd().GetPara()++;
 223                     rSel.GetEnd().GetIndex() = 0;
 224                 }
 225                 else
 226                 {
 227                     rSel.GetEnd().GetIndex() = nStartPos;
 228                     bFound = false;
 229                 }
 230             }
 231
 232             break;
 233         }
 234
 235         if ( !bForward && !nNode )      // Bei rueckwaertsuche, wenn nEndNode = 0:
 236             break;
 237     }
 238
 239     return bFound;
 240 }
 241
 242
 243 \f// -------------------------------------------------------------------------
 244 // class ExtTextView
 245 // -------------------------------------------------------------------------
 246 ExtTextView::ExtTextView( ExtTextEngine* pEng, Window* pWindow )
 247     : TextView( pEng, pWindow )
 248 {
 249 }
 250
 251 ExtTextView::~ExtTextView()
 252 {
 253 }
 254
 255 BOOL ExtTextView::MatchGroup()
 256 {
 257     TextSelection aTmpSel( GetSelection() );
 258     aTmpSel.Justify();
 259     if ( ( aTmpSel.GetStart().GetPara() != aTmpSel.GetEnd().GetPara() ) ||
 260          ( ( aTmpSel.GetEnd().GetIndex() - aTmpSel.GetStart().GetIndex() ) > 1 ) )
 261     {
 262         return FALSE;
 263     }
 264
 265     TextSelection aMatchSel = ((ExtTextEngine*)GetTextEngine())->MatchGroup( aTmpSel.GetStart() );
 266     if ( aMatchSel.HasRange() )
 267         SetSelection( aMatchSel );
 268
 269     return aMatchSel.HasRange() ? TRUE : FALSE;
 270 }
 271
 272 BOOL ExtTextView::Search( const util::SearchOptions& rSearchOptions, BOOL bForward )
 273 {
 274     BOOL bFound = FALSE;
 275     TextSelection aSel( GetSelection() );
 276     if ( ((ExtTextEngine*)GetTextEngine())->Search( aSel, rSearchOptions, bForward ) )
 277     {
 278         bFound = TRUE;
 279         // Erstmal den Anfang des Wortes als Selektion einstellen,
 280         // damit das ganze Wort in den sichtbaren Bereich kommt.
 281         SetSelection( aSel.GetStart() );
 282         ShowCursor( TRUE, FALSE );
 283     }
 284     else
 285     {
 286         aSel = GetSelection().GetEnd();
 287     }
 288
 289     SetSelection( aSel );
 290     ShowCursor();
 291
 292     return bFound;
 293 }
 294
 295 USHORT ExtTextView::Replace( const util::SearchOptions& rSearchOptions, BOOL bAll, BOOL bForward )
 296 {
 297     USHORT nFound = 0;
 298
 299     if ( !bAll )
 300     {
 301         if ( GetSelection().HasRange() )
 302         {
 303             InsertText( rSearchOptions.replaceString );
 304             nFound = 1;
 305             Search( rSearchOptions, bForward ); // gleich zum naechsten
 306         }
 307         else
 308         {
 309             if( Search( rSearchOptions, bForward ) )
 310                 nFound = 1;
 311         }
 312     }
 313     else
 314     {
 315         // Der Writer ersetzt alle, vom Anfang bis Ende...
 316
 317         ExtTextEngine* pTextEngine = (ExtTextEngine*)GetTextEngine();
 318
 319         // HideSelection();
 320         TextSelection aSel;
 321
 322         BOOL bSearchInSelection = (0 != (rSearchOptions.searchFlag & util::SearchFlags::REG_NOT_BEGINOFLINE) );
 323         if ( bSearchInSelection )
 324         {
 325             aSel = GetSelection();
 326             aSel.Justify();
 327         }
 328
 329         TextSelection aSearchSel( aSel );
 330
 331         BOOL bFound = pTextEngine->Search( aSel, rSearchOptions, TRUE );
 332         if ( bFound )
 333             pTextEngine->UndoActionStart( XTEXTUNDO_REPLACEALL );
 334         while ( bFound )
 335         {
 336             nFound++;
 337
 338             TextPaM aNewStart = pTextEngine->ImpInsertText( aSel, rSearchOptions.replaceString );
 339             aSel = aSearchSel;
 340             aSel.GetStart() = aNewStart;
 341             bFound = pTextEngine->Search( aSel, rSearchOptions, TRUE );
 342         }
 343         if ( nFound )
 344         {
 345             SetSelection( aSel.GetStart() );
 346             pTextEngine->FormatAndUpdate( this );
 347             pTextEngine->UndoActionEnd( XTEXTUNDO_REPLACEALL );
 348         }
 349     }
 350     return nFound;
 351 }
 352
 353 BOOL ExtTextView::ImpIndentBlock( BOOL bRight )
 354 {
 355     BOOL bDone = FALSE;
 356
 357     TextSelection aSel = GetSelection();
 358     aSel.Justify();
 359
 360     HideSelection();
 361     GetTextEngine()->UndoActionStart( bRight ? XTEXTUNDO_INDENTBLOCK : XTEXTUNDO_UNINDENTBLOCK );
 362
 363     ULONG nStartPara = aSel.GetStart().GetPara();
 364     ULONG nEndPara = aSel.GetEnd().GetPara();
 365     if ( aSel.HasRange() && !aSel.GetEnd().GetIndex() )
 366     {
 367         nEndPara--;     // den dann nicht einruecken...
 368     }
 369
 370     for ( ULONG nPara = nStartPara; nPara <= nEndPara; nPara++ )
 371     {
 372         if ( bRight )
 373         {
 374             // Tabs hinzufuegen
 375             GetTextEngine()->ImpInsertText( TextPaM( nPara, 0 ), '\t' );
 376             bDone = TRUE;
 377         }
 378         else
 379         {
 380             // Tabs/Blanks entfernen
 381             String aText = GetTextEngine()->GetText( nPara );
 382             if ( aText.Len() && (
 383                     ( aText.GetChar( 0 ) == '\t' ) ||
 384                     ( aText.GetChar( 0 ) == ' ' ) ) )
 385             {
 386                 GetTextEngine()->ImpDeleteText( TextSelection( TextPaM( nPara, 0 ), TextPaM( nPara, 1 ) ) );
 387                 bDone = TRUE;
 388             }
 389         }
 390     }
 391
 392     GetTextEngine()->UndoActionEnd( bRight ? XTEXTUNDO_INDENTBLOCK : XTEXTUNDO_UNINDENTBLOCK );
 393
 394     BOOL bRange = aSel.HasRange();
 395     if ( bRight )
 396     {
 397         aSel.GetStart().GetIndex()++;
 398         if ( bRange && ( aSel.GetEnd().GetPara() == nEndPara ) )
 399             aSel.GetEnd().GetIndex()++;
 400     }
 401     else
 402     {
 403         if ( aSel.GetStart().GetIndex() )
 404             aSel.GetStart().GetIndex()--;
 405         if ( bRange && aSel.GetEnd().GetIndex() )
 406             aSel.GetEnd().GetIndex()--;
 407     }
 408
 409     ImpSetSelection( aSel );
 410     GetTextEngine()->FormatAndUpdate( this );
 411
 412     return bDone;
 413 }
 414
 415 BOOL ExtTextView::IndentBlock()
 416 {
 417     return ImpIndentBlock( TRUE );
 418 }
 419
 420 BOOL ExtTextView::UnindentBlock()
 421 {
 422     return ImpIndentBlock( FALSE );
 423 }
 424