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 ScEditCell& rCell, ScDocument* pDoc, OUString& rVal )
  44 {
  45     //  true = more than 1 paragraph
  46
  47     const EditTextObject* pData = rCell.GetData();
  48     EditEngine& rEngine = pDoc->GetEditEngine();
  49     rEngine.SetText( *pData );
  50     rVal = rEngine.GetText( LINEEND_LF );
  51     return ( rEngine.GetParagraphCount() > 1 );
  52 }
  53
  54 }
  55
  56 bool ScTable::SearchCell(const SvxSearchItem& rSearchItem, SCCOL nCol, SCROW nRow,
  57                          const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
  58 {
  59     bool    bFound = false;
  60     bool    bDoSearch = true;
  61     bool    bDoBack = rSearchItem.GetBackward();
  62
  63     OUString  aString;
  64     ScBaseCell* pCell;
  65     if (rSearchItem.GetSelection())
  66         bDoSearch = rMark.IsCellMarked(nCol, nRow);
  67     if ( bDoSearch && ((pCell = aCol[nCol].GetCell( nRow )) != NULL) )
  68     {
  69         bool bMultiLine = false;
  70         CellType eCellType = pCell->GetCellType();
  71         switch (rSearchItem.GetCellType())
  72         {
  73             case SVX_SEARCHIN_FORMULA:
  74             {
  75                 if ( eCellType == CELLTYPE_FORMULA )
  76                     static_cast<ScFormulaCell*>(pCell)->GetFormula(aString, pDocument->GetGrammar());
  77                 else if ( eCellType == CELLTYPE_EDIT )
  78                     bMultiLine = lcl_GetTextWithBreaks(
  79                         *(const ScEditCell*)pCell, pDocument, aString );
  80                 else
  81                 {
  82                     aCol[nCol].GetInputString( nRow, aString );
  83                 }
  84             }
  85             break;
  86             case SVX_SEARCHIN_VALUE:
  87                 if ( eCellType == CELLTYPE_EDIT )
  88                     bMultiLine = lcl_GetTextWithBreaks(
  89                         *(const ScEditCell*)pCell, pDocument, aString );
  90                 else
  91                 {
  92                     aCol[nCol].GetInputString( nRow, aString );
  93                 }
  94                 break;
  95             case SVX_SEARCHIN_NOTE:
  96                 break; // don't search this case here
  97             default:
  98                 break;
  99         }
 100         xub_StrLen nStart = 0;
 101         xub_StrLen nEnd = aString.getLength();
 102         ::com::sun::star::util::SearchResult aSearchResult;
 103         if (pSearchText)
 104         {
 105             if ( bDoBack )
 106             {
 107                 xub_StrLen nTemp=nStart; nStart=nEnd; nEnd=nTemp;
 108                 bFound = (bool)(pSearchText->SearchBkwrd(aString, &nStart, &nEnd, &aSearchResult));
 109                 // change results to definition before 614:
 110                 --nEnd;
 111             }
 112             else
 113             {
 114                 bFound = (bool)(pSearchText->SearchFrwrd(aString, &nStart, &nEnd, &aSearchResult));
 115                 // change results to definition before 614:
 116                 --nEnd;
 117             }
 118
 119             if (bFound && rSearchItem.GetWordOnly())
 120                 bFound = (nStart == 0 && nEnd == aString.getLength() - 1);
 121         }
 122         else
 123         {
 124             OSL_FAIL("pSearchText == NULL");
 125             return bFound;
 126         }
 127
 128         sal_uInt8 cMatrixFlag = MM_NONE;
 129         if ( bFound &&
 130             ( (rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE)
 131             ||(rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL) ) &&
 132                 // Matrix nicht zerreissen, nur Matrixformel ersetzen
 133                 !( (eCellType == CELLTYPE_FORMULA &&
 134                 ((cMatrixFlag = ((ScFormulaCell*)pCell)->GetMatrixFlag()) == MM_REFERENCE))
 135                 // kein UndoDoc => Matrix nicht wiederherstellbar => nicht ersetzen
 136                 || (cMatrixFlag != MM_NONE && !pUndoDoc) ) &&
 137              IsBlockEditable(nCol, nRow, nCol, nRow)
 138             )
 139         {
 140             if ( cMatrixFlag == MM_NONE && rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE )
 141                 rUndoStr = aString;
 142             else if (pUndoDoc)
 143             {
 144                 ScAddress aAdr( nCol, nRow, nTab );
 145                 ScBaseCell* pUndoCell = pCell->Clone( *pUndoDoc );
 146                 pUndoDoc->PutCell( aAdr, pUndoCell);
 147             }
 148             bool bRepeat = !rSearchItem.GetWordOnly();
 149             do
 150             {
 151                 //  wenn der gefundene Text leer ist, nicht weitersuchen,
 152                 //  sonst wuerde man nie mehr aufhoeren (#35410#)
 153                 if ( nEnd < nStart || nEnd == STRING_MAXLEN )
 154                     bRepeat = false;
 155
 156                 String sReplStr = rSearchItem.GetReplaceString();
 157                 if (rSearchItem.GetRegExp())
 158                 {
 159                     pSearchText->ReplaceBackReferences( sReplStr, aString, aSearchResult );
 160                     OUStringBuffer aStrBuffer(aString);
 161                     aStrBuffer.remove(nStart, nEnd-nStart+1);
 162                     aStrBuffer.insert(nStart, sReplStr);
 163                     aString = aStrBuffer.makeStringAndClear();
 164                 }
 165                 else
 166                 {
 167                     OUStringBuffer aStrBuffer(aString);
 168                     aStrBuffer.remove(nStart, nEnd-nStart+1);
 169                     aStrBuffer.insert(nStart, rSearchItem.GetReplaceString());
 170                     aString = aStrBuffer.makeStringAndClear();
 171                 }
 172
 173                         //  Indizes anpassen
 174                 if (bDoBack)
 175                 {
 176                     nEnd = nStart;
 177                     nStart = 0;
 178                 }
 179                 else
 180                 {
 181                     nStart = sal::static_int_cast<xub_StrLen>( nStart + sReplStr.Len() );
 182                     nEnd = aString.getLength();
 183                 }
 184
 185                         //  weitersuchen ?
 186                 if (bRepeat)
 187                 {
 188                     if ( rSearchItem.GetCommand() != SVX_SEARCHCMD_REPLACE_ALL || nStart >= nEnd )
 189                         bRepeat = false;
 190                     else if (bDoBack)
 191                     {
 192                         xub_StrLen nTemp=nStart; nStart=nEnd; nEnd=nTemp;
 193                         bRepeat = ((bool)(pSearchText->SearchBkwrd(aString, &nStart, &nEnd, &aSearchResult)));
 194                         // change results to definition before 614:
 195                         --nEnd;
 196                     }
 197                     else
 198                     {
 199                         bRepeat = ((bool)(pSearchText->SearchFrwrd(aString, &nStart, &nEnd, &aSearchResult)));
 200                         // change results to definition before 614:
 201                         --nEnd;
 202                     }
 203                 }
 204             }
 205             while (bRepeat);
 206
 207             if ( cMatrixFlag != MM_NONE )
 208             {   // Matrix nicht zerreissen
 209                 if ( aString.getLength() > 2 )
 210                 {   // {} raus, erst hier damit auch "{=" durch "{=..." ersetzt werden kann
 211                     if ( aString[ aString.getLength()-1 ] == '}' )
 212                         aString = aString.copy( 0, aString.getLength()-1 );
 213                     if ( aString[0] == '{' )
 214                         aString = aString.copy( 1 );
 215                 }
 216                 ScAddress aAdr( nCol, nRow, nTab );
 217                 ScFormulaCell* pFCell = new ScFormulaCell( pDocument, aAdr,
 218                     aString, pDocument->GetGrammar(), cMatrixFlag );
 219                 SCCOL nMatCols;
 220                 SCROW nMatRows;
 221                 ((ScFormulaCell*)pCell)->GetMatColsRows( nMatCols, nMatRows );
 222                 pFCell->SetMatColsRows( nMatCols, nMatRows );
 223                 aCol[nCol].Insert( nRow, pFCell );
 224             }
 225             else if ( bMultiLine && aString.indexOf('\n') != -1 )
 226             {
 227                 ScFieldEditEngine& rEngine = pDocument->GetEditEngine();
 228                 rEngine.SetText(aString);
 229                 SetEditText(nCol, nRow, rEngine.CreateTextObject());
 230             }
 231             else
 232                 aCol[nCol].SetString(nRow, nTab, aString, pDocument->GetAddressConvention());
 233             // pCell is invalid now (deleted)
 234         }
 235     }
 236     return bFound;
 237 }
 238
 239 void ScTable::SkipFilteredRows(SCROW& rRow, SCROW& rLastNonFilteredRow, bool bForward)
 240 {
 241     if (bForward)
 242     {
 243         // forward search
 244
 245         if (rRow <= rLastNonFilteredRow)
 246             return;
 247
 248         SCROW nLastRow = rRow;
 249         if (RowFiltered(rRow, NULL, &nLastRow))
 250             // move to the first non-filtered row.
 251             rRow = nLastRow + 1;
 252         else
 253             // record the last non-filtered row to avoid checking
 254             // the filtered state for each and every row.
 255             rLastNonFilteredRow = nLastRow;
 256     }
 257     else
 258     {
 259         // backward search
 260
 261         if (rRow >= rLastNonFilteredRow)
 262             return;
 263
 264         SCROW nFirstRow = rRow;
 265         if (RowFiltered(rRow, &nFirstRow, NULL))
 266             // move to the first non-filtered row.
 267             rRow = nFirstRow - 1;
 268         else
 269             // record the last non-filtered row to avoid checking
 270             // the filtered state for each and every row.
 271             rLastNonFilteredRow = nFirstRow;
 272     }
 273 }
 274
 275 bool ScTable::Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 276                      const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
 277 {
 278     bool bFound = false;
 279     bool bAll =  (rSearchItem.GetCommand() == SVX_SEARCHCMD_FIND_ALL)
 280                ||(rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL);
 281     SCCOL nCol = rCol;
 282     SCROW nRow = rRow;
 283     SCCOL nLastCol;
 284     SCROW nLastRow;
 285     GetLastDataPos(nLastCol, nLastRow);
 286     bool bSkipFiltered = !rSearchItem.IsSearchFiltered();
 287     if (!bAll && rSearchItem.GetBackward())
 288     {
 289         SCROW nLastNonFilteredRow = MAXROW + 1;
 290         nCol = std::min(nCol, (SCCOL)(nLastCol + 1));
 291         nRow = std::min(nRow, (SCROW)(nLastRow + 1));
 292         if (rSearchItem.GetRowDirection())
 293         {
 294             nCol--;
 295             while (!bFound && ((SCsROW)nRow >= 0))
 296             {
 297                 if (bSkipFiltered)
 298                     SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 299
 300                 while (!bFound && ((SCsCOL)nCol >= 0))
 301                 {
 302                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 303                     if (!bFound)
 304                     {
 305                         bool bIsEmpty;
 306                         do
 307                         {
 308                             nCol--;
 309                             if ((SCsCOL)nCol >= 0)
 310                                 bIsEmpty = aCol[nCol].IsEmptyData();
 311                             else
 312                                 bIsEmpty = true;
 313                         }
 314                         while (((SCsCOL)nCol >= 0) && bIsEmpty);
 315                     }
 316                 }
 317                 if (!bFound)
 318                 {
 319                     nCol = nLastCol;
 320                     nRow--;
 321                 }
 322             }
 323         }
 324         else
 325         {
 326             nRow--;
 327             while (!bFound && ((SCsCOL)nCol >= 0))
 328             {
 329                 while (!bFound && ((SCsROW)nRow >= 0))
 330                 {
 331                     if (bSkipFiltered)
 332                         SkipFilteredRows(nRow, nLastNonFilteredRow, false);
 333
 334                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 335                     if (!bFound)
 336                     {
 337                          if (!aCol[nCol].GetPrevDataPos(nRow))
 338                             nRow = -1;
 339                     }
 340                 }
 341                 if (!bFound)
 342                 {
 343                     // Not found in this column.  Move to the next column.
 344                     bool bIsEmpty;
 345                     nRow = nLastRow;
 346                     nLastNonFilteredRow = MAXROW + 1;
 347                     do
 348                     {
 349                         nCol--;
 350                         if ((SCsCOL)nCol >= 0)
 351                             bIsEmpty = aCol[nCol].IsEmptyData();
 352                         else
 353                             bIsEmpty = true;
 354                     }
 355                     while (((SCsCOL)nCol >= 0) && bIsEmpty);
 356                 }
 357             }
 358         }
 359     }
 360     else
 361     {
 362         SCROW nLastNonFilteredRow = -1;
 363         if (!bAll && rSearchItem.GetRowDirection())
 364         {
 365             nCol++;
 366             while (!bFound && (nRow <= nLastRow))
 367             {
 368                 if (bSkipFiltered)
 369                     SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 370
 371                 while (!bFound && (nCol <= nLastCol))
 372                 {
 373                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 374                     if (!bFound)
 375                     {
 376                         nCol++;
 377                         while ((nCol <= nLastCol) && aCol[nCol].IsEmptyData()) nCol++;
 378                     }
 379                 }
 380                 if (!bFound)
 381                 {
 382                     nCol = 0;
 383                     nRow++;
 384                 }
 385             }
 386         }
 387         else
 388         {
 389             nRow++;
 390             while (!bFound && (nCol <= nLastCol))
 391             {
 392                 while (!bFound && (nRow <= nLastRow))
 393                 {
 394                     if (bSkipFiltered)
 395                         SkipFilteredRows(nRow, nLastNonFilteredRow, true);
 396
 397                     bFound = SearchCell(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 398                     if (!bFound)
 399                     {
 400                          if (!aCol[nCol].GetNextDataPos(nRow))
 401                             nRow = MAXROW + 1;
 402                     }
 403                 }
 404                 if (!bFound)
 405                 {
 406                     // Not found in this column.  Move to the next column.
 407                     nRow = 0;
 408                     nLastNonFilteredRow = -1;
 409                     nCol++;
 410                     while ((nCol <= nLastCol) && aCol[nCol].IsEmptyData()) nCol++;
 411                 }
 412             }
 413         }
 414     }
 415     if (bFound)
 416     {
 417         rCol = nCol;
 418         rRow = nRow;
 419     }
 420     return bFound;
 421 }
 422
 423 bool ScTable::SearchAll(const SvxSearchItem& rSearchItem, const ScMarkData& rMark,
 424                         ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc)
 425 {
 426     bool bFound = true;
 427     SCCOL nCol = 0;
 428     SCROW nRow = -1;
 429     bool bEverFound = false;
 430
 431     do
 432     {
 433         bFound = Search(rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc);
 434         if (bFound)
 435         {
 436             bEverFound = true;
 437             rMatchedRanges.Join(ScRange(nCol, nRow, nTab));
 438         }
 439     }
 440     while (bFound);
 441
 442     return bEverFound;
 443 }
 444
 445 void ScTable::UpdateSearchItemAddressForReplace( const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow )
 446 {
 447     if (rSearchItem.GetBackward())
 448     {
 449         if (rSearchItem.GetRowDirection())
 450             rCol += 1;
 451         else
 452             rRow += 1;
 453     }
 454     else
 455     {
 456         if (rSearchItem.GetRowDirection())
 457             rCol -= 1;
 458         else
 459             rRow -= 1;
 460     }
 461 }
 462
 463 bool ScTable::Replace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
 464                       const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc)
 465 {
 466     bool bFound = false;
 467     SCCOL nCol = rCol;
 468     SCROW nRow = rRow;
 469
 470     UpdateSearchItemAddressForReplace( rSearchItem, nCol, nRow );
 471     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     ScBaseCell* pCell = rColObj.GetCell(nRow);
 820     if (!pCell)
 821     {
 822         // empty cell found.
 823         rCol = nCol;
 824         rRow = nRow;
 825         if (rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE &&
 826             rSearchItem.GetReplaceString().Len())
 827         {
 828             rColObj.Insert(nRow, new ScStringCell(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().Len() > 0);
 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 String& rNewStr = rSearchItem.GetReplaceString();
 972                         for (SCROW i = nRow; i <= nLastRow; ++i)
 973                         {
 974                             aCol[nCol].Insert(i, new ScStringCell(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 = String();
 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             ScBaseCell* pCell = aCol[nCol].GetCell(nRow);
1003             if (!pCell)
1004             {
1005                 // empty cell found
1006                 rMatchedRanges.Join(ScRange(nCol, nRow, nTab));
1007                 bFound = true;
1008
1009                 if (bReplace)
1010                 {
1011                     aCol[nCol].Insert(nRow, new ScStringCell(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].RebuildFormulaGroups();
1032 }
1033
1034 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */