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