sc/source/core/data/table6.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 <com/sun/star/i18n/TransliterationModules.hpp>
  21
  22 #include <unotools/textsearch.hxx>
  23 #include <svl/srchitem.hxx>
  24 #include <editeng/editobj.hxx>
  25
  26 #include "table.hxx"
  27 #include "formulacell.hxx"
  28 #include "document.hxx"
  29 #include "stlpool.hxx"
  30 #include "markdata.hxx"
  31 #include "editutil.hxx"
  32 #include "detfunc.hxx"
  33 #include "postit.hxx"
  34 #include "stringutil.hxx"
  35
  36 //--------------------------------------------------------------------------
  37
  38
  39 using ::com::sun::star::util::SearchOptions;
  40
  41 namespace {
  42
  43 bool lcl_GetTextWithBreaks( const EditTextObject& rData, ScDocument* pDoc, OUString& rVal )
  44 {
  45     //  true = more than 1 paragraph
  46
  47     EditEngine& rEngine = pDoc->GetEditEngine();
  48     rEngine.SetText(rData);
  49     rVal = rEngine.GetText( LINEEND_LF );
  50     return ( rEngine.GetParagraphCount() > 1 );
  51 }
  52
  53 }
  54
  55 bool ScTable::SearchCell(const SvxSearchItem& rSearchItem, SCCOL nCol, SCROW nRow,
  56                          const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
  57 {
  58     bool    bFound = false;
  59     bool    bDoSearch = true;
  60     bool    bDoBack = rSearchItem.GetBackward();
  61
  62     OUString  aString;
  63     ScRefCellValue aCell;
  64     if (rSearchItem.GetSelection())
  65         bDoSearch = rMark.IsCellMarked(nCol, nRow);
  66
  67     if (!bDoSearch)
  68         return false;
  69
  70     aCell = aCol[nCol].GetCellValue(nRow);
  71     if (aCell.isEmpty())
  72         return false;
  73
  74     bool bMultiLine = false;
  75     CellType eCellType = aCell.meType;
  76     switch (rSearchItem.GetCellType())
  77     {
  78         case SVX_SEARCHIN_FORMULA:
  79         {
  80             if ( eCellType == CELLTYPE_FORMULA )
  81                 aCell.mpFormula->GetFormula(aString, pDocument->GetGrammar());
  82             else if ( eCellType == CELLTYPE_EDIT )
  83                 bMultiLine = lcl_GetTextWithBreaks(*aCell.mpEditText, pDocument, aString);
  84             else
  85             {
  86                 aCol[nCol].GetInputString( nRow, aString );
  87             }
  88         }
  89         break;
  90         case SVX_SEARCHIN_VALUE:
  91             if ( eCellType == CELLTYPE_EDIT )
  92                 bMultiLine = lcl_GetTextWithBreaks(*aCell.mpEditText, pDocument, aString);
  93             else
  94             {
  95                 aCol[nCol].GetInputString( nRow, aString );
  96             }
  97             break;
  98         case SVX_SEARCHIN_NOTE:
  99             break; // don't search this case here
 100         default:
 101             break;
 102     }
 103     sal_Int32 nStart = 0;
 104     sal_Int32 nEnd = aString.getLength();
 105     ::com::sun::star::util::SearchResult aSearchResult;
 106     if (pSearchText)
 107     {
 108         if ( bDoBack )
 109         {
 110            sal_Int32 nTemp=nStart; nStart=nEnd; nEnd=nTemp;
 111             bFound = pSearchText->SearchBackward(aString, &nStart, &nEnd, &aSearchResult);
 112             // change results to definition before 614:
 113             --nEnd;
 114         }
 115         else
 116         {
 117             bFound = pSearchText->SearchForward(aString, &nStart, &nEnd, &aSearchResult);
 118             // change results to definition before 614:
 119             --nEnd;
 120         }
 121
 122         if (bFound && rSearchItem.GetWordOnly())
 123             bFound = (nStart == 0 && nEnd == aString.getLength() - 1);
 124     }
 125     else
 126     {
 127         OSL_FAIL("pSearchText == NULL");
 128         return bFound;
 129     }
 130
 131     sal_uInt8 cMatrixFlag = MM_NONE;
 132     if ( bFound &&
 133         ( (rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE)
 134         ||(rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL) ) &&
 135             // Matrix nicht zerreissen, nur Matrixformel ersetzen
 136             !( (eCellType == CELLTYPE_FORMULA &&
 137             ((cMatrixFlag = aCell.mpFormula->GetMatrixFlag()) == MM_REFERENCE))
 138             // kein UndoDoc => Matrix nicht wiederherstellbar => nicht ersetzen
 139             || (cMatrixFlag != MM_NONE && !pUndoDoc) ) &&
 140          IsBlockEditable(nCol, nRow, nCol, nRow)
 141         )
 142     {
 143         if ( cMatrixFlag == MM_NONE && rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE )
 144             rUndoStr = aString;
 145         else if (pUndoDoc)
 146         {
 147             ScAddress aAdr( nCol, nRow, nTab );
 148             aCell.commit(*pUndoDoc, aAdr);
 149         }
 150         bool bRepeat = !rSearchItem.GetWordOnly();
 151         do
 152         {
 153             //  wenn der gefundene Text leer ist, nicht weitersuchen,
 154             //  sonst wuerde man nie mehr aufhoeren (#35410#)
 155             if ( nEnd < nStart )
 156                 bRepeat = false;
 157
 158             OUString sReplStr = rSearchItem.GetReplaceString();
 159             if (rSearchItem.GetRegExp())
 160             {
 161                 pSearchText->ReplaceBackReferences( sReplStr, aString, aSearchResult );
 162                 OUStringBuffer aStrBuffer(aString);
 163                 aStrBuffer.remove(nStart, nEnd-nStart+1);
 164                 aStrBuffer.insert(nStart, sReplStr);
 165                 aString = aStrBuffer.makeStringAndClear();
 166             }
 167             else
 168             {
 169                 OUStringBuffer aStrBuffer(aString);
 170                 aStrBuffer.remove(nStart, nEnd-nStart+1);
 171                 aStrBuffer.insert(nStart, rSearchItem.GetReplaceString());
 172                 aString = aStrBuffer.makeStringAndClear();
 173             }
 174
 175                     //  Indizes anpassen
 176             if (bDoBack)
 177             {
 178                 nEnd = nStart;
 179                 nStart = 0;
 180             }
 181             else
 182             {
 183                 nStart = nStart + sReplStr.getLength();
 184                 nEnd = aString.getLength();
 185             }
 186
 187                     //  weitersuchen ?
 188             if (bRepeat)
 189             {
 190                 if ( rSearchItem.GetCommand() != SVX_SEARCHCMD_REPLACE_ALL || nStart >= nEnd )
 191                     bRepeat = false;
 192                 else if (bDoBack)
 193                 {
 194                     sal_Int32 nTemp=nStart; nStart=nEnd; nEnd=nTemp;
 195                     bRepeat = pSearchText->SearchBackward(aString, &nStart, &nEnd, &aSearchResult);
 196                     // change results to definition before 614:
 197                     --nEnd;
 198                 }
 199                 else
 200                 {
 201                     bRepeat = pSearchText->SearchForward(aString, &nStart, &nEnd, &aSearchResult);
 202                     // change results to definition before 614:
 203                     --nEnd;
 204                 }
 205             }
 206         }
 207         while (bRepeat);
 208
 209         if ( cMatrixFlag != MM_NONE )
 210         {   // Matrix nicht zerreissen
 211             if ( aString.getLength() > 2 )
 212             {   // {} raus, erst hier damit auch "{=" durch "{=..." ersetzt werden kann
 213                 if ( aString[ aString.getLength()-1 ] == '}' )
 214                     aString = aString.copy( 0, aString.getLength()-1 );
 215                 if ( aString[0] == '{' )
 216                     aString = aString.copy( 1 );
 217             }
 218             ScAddress aAdr( nCol, nRow, nTab );
 219             ScFormulaCell* pFCell = new ScFormulaCell( pDocument, aAdr,
 220                 aString, pDocument->GetGrammar(), cMatrixFlag );
 221             SCCOL nMatCols;
 222             SCROW nMatRows;
 223             aCell.mpFormula->GetMatColsRows(nMatCols, nMatRows);
 224             pFCell->SetMatColsRows( nMatCols, nMatRows );
 225             aCol[nCol].SetFormulaCell(nRow, pFCell);
 226         }
 227         else if ( bMultiLine && aString.indexOf('\n') != -1 )
 228         {
 229             ScFieldEditEngine& rEngine = pDocument->GetEditEngine();
 230             rEngine.SetText(aString);
 231             SetEditText(nCol, nRow, rEngine.CreateTextObject());
 232         }
 233         else
 234             aCol[nCol].SetString(nRow, nTab, aString, pDocument->GetAddressConvention());
 235         // pCell is invalid now (deleted)
 236     }
 237     return bFound;
 238 }
 239
 240 void ScTable::SkipFilteredRows(SCROW& rRow, SCROW& rLastNonFilteredRow, bool bForward)
 241 {
 242     if (bForward)
 243     {
 244         // forward search
 245
 246         if (rRow <= rLastNonFilteredRow)
 247             return;
 248
 249         SCROW nLastRow = rRow;
 250         if (RowFiltered(rRow, NULL, &nLastRow))
 251             // move to the first non-filtered row.
 252             rRow = nLastRow + 1;
 253         else
 254             // record the last non-filtered row to avoid checking
 255             // the filtered state for each and every row.
 256             rLastNonFilteredRow = nLastRow;
 257     }
 258     else
 259     {
 260         // backward search
 261
 262         if (rRow >= rLastNonFilteredRow)
 263             return;
 264
 265         SCROW nFirstRow = rRow;
 266         if (RowFiltered(rRow, &nFirstRow, NULL))
 267             // move to the first non-filtered row.
 268             rRow = nFirstRow - 1;
 269         else
 270             // record the last non-filtered row to avoid checking
 271             // the filtered state for each and every row.
 272             rLastNonFilteredRow = nFirstRow;
 273     }
 274 }
 275
 276 bool ScTable::Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 277                      const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
 278 {
 279     bool bFound = false;
 280     bool bAll =  (rSearchItem.GetCommand() == SVX_SEARCHCMD_FIND_ALL)
 281                ||(rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL);
 282     SCCOL nCol = rCol;
 283     SCROW nRow = rRow;
 284     SCCOL nLastCol;
 285     SCROW nLastRow;
 286     GetLastDataPos(nLastCol, nLastRow);
 287     bool bSkipFiltered = !rSearchItem.IsSearchFiltered();
 288     if (!bAll && rSearchItem.GetBackward())
 289     {
 290         SCROW nLastNonFilteredRow = MAXROW + 1;
 291         nCol = std::min(nCol, (SCCOL)(nLastCol + 1));
 292         nRow = std::min(nRow, (SCROW)(nLastRow + 1));
 293         if (rSearchItem.GetRowDirection())
 294         {
 295             nCol--;
 296             while (!bFound && ((SCsROW)nRow >= 0))
 297             {
 298                 if (bSkipFiltered)
 299                     SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 300
 301                 while (!bFound && ((SCsCOL)nCol >= 0))
 302                 {
 303                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 304                     if (!bFound)
 305                     {
 306                         bool bIsEmpty;
 307                         do
 308                         {
 309                             nCol--;
 310                             if ((SCsCOL)nCol >= 0)
 311                                 bIsEmpty = aCol[nCol].IsEmptyData();
 312                             else
 313                                 bIsEmpty = true;
 314                         }
 315                         while (((SCsCOL)nCol >= 0) && bIsEmpty);
 316                     }
 317                 }
 318                 if (!bFound)
 319                 {
 320                     nCol = nLastCol;
 321                     nRow--;
 322                 }
 323             }
 324         }
 325         else
 326         {
 327             nRow--;
 328             while (!bFound && ((SCsCOL)nCol >= 0))
 329             {
 330                 while (!bFound && ((SCsROW)nRow >= 0))
 331                 {
 332                     if (bSkipFiltered)
 333                         SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 334
 335                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 336                     if (!bFound)
 337                     {
 338                          if (!aCol[nCol].GetPrevDataPos(nRow))
 339                             nRow = -1;
 340                     }
 341                 }
 342                 if (!bFound)
 343                 {
 344                     // Not found in this column.  Move to the next column.
 345                     bool bIsEmpty;
 346                     nRow = nLastRow;
 347                     nLastNonFilteredRow = MAXROW + 1;
 348                     do
 349                     {
 350                         nCol--;
 351                         if ((SCsCOL)nCol >= 0)
 352                             bIsEmpty = aCol[nCol].IsEmptyData();
 353                         else
 354                             bIsEmpty = true;
 355                     }
 356                     while (((SCsCOL)nCol >= 0) && bIsEmpty);
 357                 }
 358             }
 359         }
 360     }
 361     else
 362     {
 363         SCROW nLastNonFilteredRow = -1;
 364         if (!bAll && rSearchItem.GetRowDirection())
 365         {
 366             nCol++;
 367             while (!bFound && (nRow <= nLastRow))
 368             {
 369                 if (bSkipFiltered)
 370                     SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 371
 372                 while (!bFound && (nCol <= nLastCol))
 373                 {
 374                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 375                     if (!bFound)
 376                     {
 377                         nCol++;
 378                         while ((nCol <= nLastCol) && aCol[nCol].IsEmptyData()) nCol++;
 379                     }
 380                 }
 381                 if (!bFound)
 382                 {
 383                     nCol = 0;
 384                     nRow++;
 385                 }
 386             }
 387         }
 388         else
 389         {
 390             nRow++;
 391             while (!bFound && (nCol <= nLastCol))
 392             {
 393                 while (!bFound && (nRow <= nLastRow))
 394                 {
 395                     if (bSkipFiltered)
 396                         SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 397
 398                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 399                     if (!bFound)
 400                     {
 401                          if (!aCol[nCol].GetNextDataPos(nRow))
 402                             nRow = MAXROW + 1;
 403                     }
 404                 }
 405                 if (!bFound)
 406                 {
 407                     // Not found in this column.  Move to the next column.
 408                     nRow = 0;
 409                     nLastNonFilteredRow = -1;
 410                     nCol++;
 411                     while ((nCol <= nLastCol) && aCol[nCol].IsEmptyData()) nCol++;
 412                 }
 413             }
 414         }
 415     }
 416     if (bFound)
 417     {
 418         rCol = nCol;
 419         rRow = nRow;
 420     }
 421     return bFound;
 422 }
 423
 424 bool ScTable::SearchAll(const SvxSearchItem& rSearchItem, const ScMarkData& rMark,
 425                         ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc)
 426 {
 427     bool bFound = true;
 428     SCCOL nCol = 0;
 429     SCROW nRow = -1;
 430     bool bEverFound = false;
 431
 432     do
 433     {
 434         bFound = Search(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 435         if (bFound)
 436         {
 437             bEverFound = true;
 438             rMatchedRanges.Join(ScRange(nCol, nRow, nTab));
 439         }
 440     }
 441     while (bFound);
 442
 443     return bEverFound;
 444 }
 445
 446 void ScTable::UpdateSearchItemAddressForReplace( const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow )
 447 {
 448     if (rSearchItem.GetBackward())
 449     {
 450         if (rSearchItem.GetRowDirection())
 451             rCol += 1;
 452         else
 453             rRow += 1;
 454     }
 455     else
 456     {
 457         if (rSearchItem.GetRowDirection())
 458             rCol -= 1;
 459         else
 460             rRow -= 1;
 461     }
 462 }
 463
 464 bool ScTable::Replace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 465                       const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
 466 {
 467     SCCOL nCol = rCol;
 468     SCROW nRow = rRow;
 469
 470     UpdateSearchItemAddressForReplace( rSearchItem, nCol, nRow );
 471     bool bFound = Search(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 472     if (bFound)
 473     {
 474         rCol = nCol;
 475         rRow = nRow;
 476     }
 477     return bFound;
 478 }
 479
 480 bool ScTable::ReplaceAll(
 481     const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,
 482     OUString& rUndoStr, ScDocument* pUndoDoc)
 483 {
 484     SCCOL nCol = 0;
 485     SCROW nRow = -1;
 486
 487     bool bEverFound = false;
 488     while (true)
 489     {
 490         bool bFound = Search(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 491
 492         if (bFound)
 493         {
 494             bEverFound = true;
 495             rMatchedRanges.Join(ScRange(nCol, nRow, nTab));
 496         }
 497         else
 498             break;
 499     }
 500     return bEverFound;
 501 }
 502
 503 bool ScTable::SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 504                           const ScMarkData& rMark)
 505 {
 506     const ScStyleSheet* pSearchStyle = (const ScStyleSheet*)
 507                                         pDocument->GetStyleSheetPool()->Find(
 508                                         rSearchItem.GetSearchString(), SFX_STYLE_FAMILY_PARA );
 509
 510     SCsCOL nCol = rCol;
 511     SCsROW nRow = rRow;
 512     bool bFound = false;
 513
 514     bool bSelect = rSearchItem.GetSelection();
 515     bool bRows = rSearchItem.GetRowDirection();
 516     bool bBack = rSearchItem.GetBackward();
 517     short nAdd = bBack ? -1 : 1;
 518
 519     if (bRows)                                      // zeilenweise
 520     {
 521         nRow += nAdd;
 522         do
 523         {
 524             SCsROW nNextRow = aCol[nCol].SearchStyle( nRow, pSearchStyle, bBack, bSelect, rMark );
 525             if (!ValidRow(nNextRow))
 526             {
 527                 nRow = bBack ? MAXROW : 0;
 528                 nCol = sal::static_int_cast<SCsCOL>( nCol + nAdd );
 529             }
 530             else
 531             {
 532                 nRow = nNextRow;
 533                 bFound = true;
 534             }
 535         }
 536         while (!bFound && ValidCol(nCol));
 537     }
 538     else                                            // spaltenweise
 539     {
 540         SCsROW nNextRows[MAXCOLCOUNT];
 541         SCsCOL i;
 542         for (i=0; i<=MAXCOL; i++)
 543         {
 544             SCsROW nSRow = nRow;
 545             if (bBack)  { if (i>=nCol) --nSRow; }
 546             else        { if (i<=nCol) ++nSRow; }
 547             nNextRows[i] = aCol[i].SearchStyle( nSRow, pSearchStyle, bBack, bSelect, rMark );
 548         }
 549         if (bBack)                          // rueckwaerts
 550         {
 551             nRow = -1;
 552             for (i=MAXCOL; i>=0; i--)
 553                 if (nNextRows[i]>nRow)
 554                 {
 555                     nCol = i;
 556                     nRow = nNextRows[i];
 557                     bFound = true;
 558                 }
 559         }
 560         else                                // vorwaerts
 561         {
 562             nRow = MAXROW+1;
 563             for (i=0; i<=MAXCOL; i++)
 564                 if (nNextRows[i]<nRow)
 565                 {
 566                     nCol = i;
 567                     nRow = nNextRows[i];
 568                     bFound = true;
 569                 }
 570         }
 571     }
 572
 573     if (bFound)
 574     {
 575         rCol = (SCCOL) nCol;
 576         rRow = (SCROW) nRow;
 577     }
 578     return bFound;
 579 }
 580
 581 //!     einzelnes Pattern fuer Undo zurueckgeben
 582
 583 bool ScTable::ReplaceStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 584                            const ScMarkData& rMark, bool bIsUndo)
 585 {
 586     bool bRet;
 587     if (bIsUndo)
 588         bRet = true;
 589     else
 590         bRet = SearchStyle(rSearchItem, rCol, rRow, rMark);
 591     if (bRet)
 592     {
 593         const ScStyleSheet* pReplaceStyle = (const ScStyleSheet*)
 594                                         pDocument->GetStyleSheetPool()->Find(
 595                                         rSearchItem.GetReplaceString(), SFX_STYLE_FAMILY_PARA );
 596
 597         if (pReplaceStyle)
 598             ApplyStyle( rCol, rRow, *pReplaceStyle );
 599         else
 600         {
 601             OSL_FAIL("pReplaceStyle==0");
 602         }
 603     }
 604
 605     return bRet;
 606 }
 607
 608 bool ScTable::SearchAllStyle(
 609     const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges)
 610 {
 611     const ScStyleSheet* pSearchStyle = (const ScStyleSheet*)
 612                                         pDocument->GetStyleSheetPool()->Find(
 613                                         rSearchItem.GetSearchString(), SFX_STYLE_FAMILY_PARA );
 614     bool bSelect = rSearchItem.GetSelection();
 615     bool bBack = rSearchItem.GetBackward();
 616     bool bEverFound = false;
 617
 618     for (SCCOL i=0; i<=MAXCOL; i++)
 619     {
 620         bool bFound = true;
 621         SCsROW nRow = 0;
 622         SCsROW nEndRow;
 623         while (bFound && nRow <= MAXROW)
 624         {
 625             bFound = aCol[i].SearchStyleRange( nRow, nEndRow, pSearchStyle, bBack, bSelect, rMark );
 626             if (bFound)
 627             {
 628                 if (nEndRow<nRow)
 629                 {
 630                     SCsROW nTemp = nRow;
 631                     nRow = nEndRow;
 632                     nEndRow = nTemp;
 633                 }
 634                 rMatchedRanges.Join(ScRange(i, nRow, nTab, i, nEndRow, nTab));
 635                 nRow = nEndRow + 1;
 636                 bEverFound = true;
 637             }
 638         }
 639     }
 640
 641     return bEverFound;
 642 }
 643
 644 bool ScTable::ReplaceAllStyle(
 645     const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,
 646     ScDocument* pUndoDoc)
 647 {
 648     bool bRet = SearchAllStyle(rSearchItem, rMark, rMatchedRanges);
 649     if (bRet)
 650     {
 651         const ScStyleSheet* pReplaceStyle = (const ScStyleSheet*)
 652                                         pDocument->GetStyleSheetPool()->Find(
 653                                         rSearchItem.GetReplaceString(), SFX_STYLE_FAMILY_PARA );
 654
 655         if (pReplaceStyle)
 656         {
 657             if (pUndoDoc)
 658                 pDocument->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab,
 659                                             IDF_ATTRIB, true, pUndoDoc, &rMark );
 660             ApplySelectionStyle( *pReplaceStyle, rMark );
 661         }
 662         else
 663         {
 664             OSL_FAIL("pReplaceStyle==0");
 665         }
 666     }
 667
 668     return bRet;
 669 }
 670
 671 bool ScTable::SearchAndReplace(
 672     const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark,
 673     ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc)
 674 {
 675     sal_uInt16 nCommand = rSearchItem.GetCommand();
 676     bool bFound = false;
 677     if ( ValidColRow(rCol, rRow) ||
 678          ((nCommand == SVX_SEARCHCMD_FIND || nCommand == SVX_SEARCHCMD_REPLACE) &&
 679            (((rCol == MAXCOLCOUNT || rCol == -1) && ValidRow(rRow)) ||
 680             ((rRow == MAXROWCOUNT || rRow == -1) && ValidCol(rCol))
 681            )
 682          )
 683        )
 684     {
 685         bool bStyles = rSearchItem.GetPattern();
 686         if (bStyles)
 687         {
 688             if (nCommand == SVX_SEARCHCMD_FIND)
 689                 bFound = SearchStyle(rSearchItem, rCol, rRow, rMark);
 690             else if (nCommand == SVX_SEARCHCMD_REPLACE)
 691                 bFound = ReplaceStyle(rSearchItem, rCol, rRow, rMark, false);
 692             else if (nCommand == SVX_SEARCHCMD_FIND_ALL)
 693                 bFound = SearchAllStyle(rSearchItem, rMark, rMatchedRanges);
 694             else if (nCommand == SVX_SEARCHCMD_REPLACE_ALL)
 695                 bFound = ReplaceAllStyle(rSearchItem, rMark, rMatchedRanges, pUndoDoc);
 696         }
 697         else
 698         {
 699             //  SearchParam no longer needed - SearchOptions contains all settings
 700             com::sun::star::util::SearchOptions aSearchOptions = rSearchItem.GetSearchOptions();
 701             aSearchOptions.Locale = *ScGlobal::GetLocale();
 702
 703             if (aSearchOptions.searchString.isEmpty())
 704             {
 705                 // Search for empty cells.
 706                 return SearchAndReplaceEmptyCells(rSearchItem, rCol, rRow, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
 707             }
 708
 709             //  reflect UseAsianOptions flag in SearchOptions
 710             //  (use only ignore case and width if asian options are disabled).
 711             //  This is also done in SvxSearchDialog CommandHdl, but not in API object.
 712             if ( !rSearchItem.IsUseAsianOptions() )
 713                 aSearchOptions.transliterateFlags &=
 714                     ( com::sun::star::i18n::TransliterationModules_IGNORE_CASE |
 715                       com::sun::star::i18n::TransliterationModules_IGNORE_WIDTH );
 716
 717             pSearchText = new utl::TextSearch( aSearchOptions );
 718
 719             if (nCommand == SVX_SEARCHCMD_FIND)
 720                 bFound = Search(rSearchItem, rCol, rRow, rMark, rUndoStr, pUndoDoc);
 721             else if (nCommand == SVX_SEARCHCMD_FIND_ALL)
 722                 bFound = SearchAll(rSearchItem, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
 723             else if (nCommand == SVX_SEARCHCMD_REPLACE)
 724                 bFound = Replace(rSearchItem, rCol, rRow, rMark, rUndoStr, pUndoDoc);
 725             else if (nCommand == SVX_SEARCHCMD_REPLACE_ALL)
 726                 bFound = ReplaceAll(rSearchItem, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
 727
 728             delete pSearchText;
 729             pSearchText = NULL;
 730         }
 731     }
 732     return bFound;
 733 }
 734
 735 bool ScTable::SearchAndReplaceEmptyCells(
 736     const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark,
 737     ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc)
 738 {
 739     SCCOL nColStart, nColEnd;
 740     SCROW nRowStart, nRowEnd;
 741     GetFirstDataPos(nColStart, nRowStart);
 742     GetLastDataPos(nColEnd, nRowEnd);
 743
 744     ScRangeList aRanges;
 745     aRanges.Append(ScRange(nColStart, nRowStart, nTab, nColEnd, nRowEnd, nTab));
 746
 747     if (rSearchItem.GetSelection())
 748     {
 749         // current selection only.
 750         if (!rMark.IsMarked() && !rMark.IsMultiMarked())
 751             // There is no selection.  Bail out.
 752             return false;
 753
 754         ScRangeList aMarkedRanges, aNewRanges;
 755         rMark.FillRangeListWithMarks(&aMarkedRanges, true);
 756         for ( size_t i = 0, n = aMarkedRanges.size(); i < n; ++i )
 757         {
 758             ScRange* p = aMarkedRanges[ i ];
 759             if (p->aStart.Col() > nColEnd || p->aStart.Row() > nRowEnd)
 760                 // This range is outside the data area.  Skip it.
 761                 continue;
 762
 763             // Shrink the range into data area only.
 764             if (p->aStart.Col() < nColStart)
 765                 p->aStart.SetCol(rCol);
 766             if (p->aStart.Row() < nRowStart)
 767                 p->aStart.SetRow(rRow);
 768
 769             if (p->aEnd.Col() > nColEnd)
 770                 p->aEnd.SetCol(nColEnd);
 771             if (p->aEnd.Row() > nRowEnd)
 772                 p->aEnd.SetRow(nRowEnd);
 773
 774             aNewRanges.Append(*p);
 775         }
 776         aRanges = aNewRanges;
 777     }
 778
 779     sal_uInt16 nCommand = rSearchItem.GetCommand();
 780     if (nCommand == SVX_SEARCHCMD_FIND || nCommand == SVX_SEARCHCMD_REPLACE)
 781     {
 782         if (rSearchItem.GetBackward())
 783         {
 784             for ( size_t i = aRanges.size(); i > 0; --i )
 785             {
 786                 ScRange* p = aRanges[ i - 1 ];
 787                 if (SearchRangeForEmptyCell(*p, rSearchItem, rCol, rRow, rUndoStr))
 788                     return true;
 789             }
 790         }
 791         else
 792         {
 793             for ( size_t i = 0, nListSize = aRanges.size(); i < nListSize; ++i )
 794             {
 795                 ScRange* p = aRanges[ i ];
 796                 if (SearchRangeForEmptyCell(*p, rSearchItem, rCol, rRow, rUndoStr))
 797                     return true;
 798             }
 799         }
 800     }
 801     else if (nCommand == SVX_SEARCHCMD_FIND_ALL || nCommand == SVX_SEARCHCMD_REPLACE_ALL)
 802     {
 803         bool bFound = false;
 804         for ( size_t i = 0, nListSize = aRanges.size(); i < nListSize; ++i )
 805         {
 806             ScRange* p = aRanges[ i ];
 807             bFound |= SearchRangeForAllEmptyCells(*p, rSearchItem, rMatchedRanges, rUndoStr, pUndoDoc);
 808         }
 809         return bFound;
 810     }
 811     return false;
 812 }
 813
 814 namespace {
 815
 816 bool lcl_maybeReplaceCellString(
 817     ScColumn& rColObj, SCCOL& rCol, SCROW& rRow, OUString& rUndoStr, SCCOL nCol, SCROW nRow, const SvxSearchItem& rSearchItem)
 818 {
 819     ScRefCellValue aCell = rColObj.GetCellValue(nRow);
 820     if (aCell.isEmpty())
 821     {
 822         // empty cell found.
 823         rCol = nCol;
 824         rRow = nRow;
 825         if (rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE &&
 826             !rSearchItem.GetReplaceString().isEmpty())
 827         {
 828             rColObj.SetRawString(nRow, rSearchItem.GetReplaceString());
 829             rUndoStr = OUString();
 830         }
 831         return true;
 832     }
 833     return false;
 834 }
 835
 836 }
 837
 838 bool ScTable::SearchRangeForEmptyCell(
 839     const ScRange& rRange, const SvxSearchItem& rSearchItem,
 840     SCCOL& rCol, SCROW& rRow, OUString& rUndoStr)
 841 {
 842     sal_uInt16 nCmd = rSearchItem.GetCommand();
 843     bool bSkipFiltered = rSearchItem.IsSearchFiltered();
 844     if (rSearchItem.GetBackward())
 845     {
 846         // backward search
 847         if (rSearchItem.GetRowDirection())
 848         {
 849             // row direction.
 850             SCROW nLastNonFilteredRow = MAXROW + 1;
 851             SCROW nBeginRow = rRange.aEnd.Row() > rRow ? rRow : rRange.aEnd.Row();
 852             for (SCROW nRow = nBeginRow; nRow >= rRange.aStart.Row(); --nRow)
 853             {
 854                 if (bSkipFiltered)
 855                     SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 856                 if (nRow < rRange.aStart.Row())
 857                     break;
 858
 859                 SCCOL nBeginCol = rRange.aEnd.Col();
 860                 if (nRow == rRow && nBeginCol >= rCol)
 861                     // always start from one cell before the cursor.
 862                     nBeginCol = rCol - (nCmd == SVX_SEARCHCMD_FIND ? 1 : 0);
 863
 864                 for (SCCOL nCol = nBeginCol; nCol >= rRange.aStart.Col(); --nCol)
 865                 {
 866                     if (lcl_maybeReplaceCellString(aCol[nCol], rCol, rRow, rUndoStr, nCol, nRow, rSearchItem))
 867                         return true;
 868                 }
 869             }
 870         }
 871         else
 872         {
 873             // column direction.
 874             SCCOL nBeginCol = rRange.aEnd.Col() > rCol ? rCol : rRange.aEnd.Col();
 875             for (SCCOL nCol = nBeginCol; nCol >= rRange.aStart.Col(); --nCol)
 876             {
 877                 SCROW nLastNonFilteredRow = MAXROW + 1;
 878                 SCROW nBeginRow = rRange.aEnd.Row();
 879                 if (nCol == rCol && nBeginRow >= rRow)
 880                     // always start from one cell before the cursor.
 881                     nBeginRow = rRow - (nCmd == SVX_SEARCHCMD_FIND ? 1 : 0);
 882                 for (SCROW nRow = nBeginRow; nRow >= rRange.aStart.Row(); --nRow)
 883                 {
 884                     if (bSkipFiltered)
 885                         SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 886                     if (nRow < rRange.aStart.Row())
 887                         break;
 888
 889                     if (lcl_maybeReplaceCellString(aCol[nCol], rCol, rRow, rUndoStr, nCol, nRow, rSearchItem))
 890                         return true;
 891                 }
 892             }
 893         }
 894     }
 895     else
 896     {
 897         // forward search
 898         if (rSearchItem.GetRowDirection())
 899         {
 900             // row direction.
 901             SCROW nLastNonFilteredRow = -1;
 902             SCROW nBeginRow = rRange.aStart.Row() < rRow ? rRow : rRange.aStart.Row();
 903             for (SCROW nRow = nBeginRow; nRow <= rRange.aEnd.Row(); ++nRow)
 904             {
 905                 if (bSkipFiltered)
 906                     SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 907                 if (nRow > rRange.aEnd.Row())
 908                     break;
 909
 910                 SCCOL nBeginCol = rRange.aStart.Col();
 911                 if (nRow == rRow && nBeginCol <= rCol)
 912                     // always start from one cell past the cursor.
 913                     nBeginCol = rCol + (nCmd == SVX_SEARCHCMD_FIND ? 1 : 0);
 914                 for (SCCOL nCol = nBeginCol; nCol <= rRange.aEnd.Col(); ++nCol)
 915                 {
 916                     if (lcl_maybeReplaceCellString(aCol[nCol], rCol, rRow, rUndoStr, nCol, nRow, rSearchItem))
 917                         return true;
 918                 }
 919             }
 920         }
 921         else
 922         {
 923             // column direction.
 924             SCCOL nBeginCol = rRange.aStart.Col() < rCol ? rCol : rRange.aStart.Col();
 925             for (SCCOL nCol = nBeginCol; nCol <= rRange.aEnd.Col(); ++nCol)
 926             {
 927                 SCROW nLastNonFilteredRow = -1;
 928                 SCROW nBeginRow = rRange.aStart.Row();
 929                 if (nCol == rCol && nBeginRow <= rRow)
 930                     // always start from one cell past the cursor.
 931                     nBeginRow = rRow + (nCmd == SVX_SEARCHCMD_FIND ? 1 : 0);
 932                 for (SCROW nRow = nBeginRow; nRow <= rRange.aEnd.Row(); ++nRow)
 933                 {
 934                     if (bSkipFiltered)
 935                         SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 936                     if (nRow > rRange.aEnd.Row())
 937                         break;
 938
 939                     if (lcl_maybeReplaceCellString(aCol[nCol], rCol, rRow, rUndoStr, nCol, nRow, rSearchItem))
 940                         return true;
 941                 }
 942             }
 943         }
 944     }
 945     return false;
 946 }
 947
 948 bool ScTable::SearchRangeForAllEmptyCells(
 949     const ScRange& rRange, const SvxSearchItem& rSearchItem,
 950     ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc)
 951 {
 952     bool bFound = false;
 953     bool bReplace = (rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL) &&
 954                     !rSearchItem.GetReplaceString().isEmpty();
 955     bool bSkipFiltered = rSearchItem.IsSearchFiltered();
 956
 957     for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
 958     {
 959         SCROW nLastNonFilteredRow = -1;
 960         if (aCol[nCol].IsEmptyData())
 961         {
 962             // The entire column is empty.
 963             for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
 964             {
 965                 SCROW nLastRow;
 966                 if (!RowFiltered(nRow, NULL, &nLastRow))
 967                 {
 968                     rMatchedRanges.Join(ScRange(nCol, nRow, nTab, nCol, nLastRow, nTab));
 969                     if (bReplace)
 970                     {
 971                         const OUString& rNewStr = rSearchItem.GetReplaceString();
 972                         for (SCROW i = nRow; i <= nLastRow; ++i)
 973                         {
 974                             aCol[nCol].SetRawString(i, rNewStr);
 975                             if (pUndoDoc)
 976                             {
 977                                 // TODO: I'm using a string cell with empty content to
 978                                 // trigger deletion of cell instance on undo.  Maybe I
 979                                 // should create a new cell type for this?
 980                                 ScSetStringParam aParam;
 981                                 aParam.setTextInput();
 982                                 pUndoDoc->SetString(ScAddress(nCol, i, nTab), EMPTY_OUSTRING);
 983                             }
 984                         }
 985                         rUndoStr = OUString();
 986                     }
 987                 }
 988
 989                 nRow = nLastRow; // move to the last filtered row.
 990             }
 991             bFound = true;
 992             continue;
 993         }
 994
 995         for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
 996         {
 997             if (bSkipFiltered)
 998                 SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 999             if (nRow > rRange.aEnd.Row())
1000                 break;
1001
1002             ScRefCellValue aCell = aCol[nCol].GetCellValue(nRow);
1003             if (aCell.isEmpty())
1004             {
1005                 // empty cell found
1006                 rMatchedRanges.Join(ScRange(nCol, nRow, nTab));
1007                 bFound = true;
1008
1009                 if (bReplace)
1010                 {
1011                     aCol[nCol].SetRawString(nRow, rSearchItem.GetReplaceString());
1012                     if (pUndoDoc)
1013                     {
1014                         // TODO: I'm using a string cell with empty content to
1015                         // trigger deletion of cell instance on undo.  Maybe I
1016                         // should create a new cell type for this?
1017                         ScSetStringParam aParam;
1018                         aParam.setTextInput();
1019                         pUndoDoc->SetString(ScAddress(nCol, nRow, nTab), EMPTY_OUSTRING);
1020                     }
1021                 }
1022             }
1023         }
1024     }
1025     return bFound;
1026 }
1027
1028 void ScTable::RebuildFormulaGroups()
1029 {
1030     for (SCCOL i=0; i<=MAXCOL; i++)
1031         aCol[i].RegroupFormulaCells();
1032 }
1033
1034 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */