sc/source/core/data/cellvalue.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
  10 #include "cellvalue.hxx"
  11 #include "document.hxx"
  12 #include "column.hxx"
  13 #include "formulacell.hxx"
  14 #include "editeng/editobj.hxx"
  15 #include "editeng/editstat.hxx"
  16 #include "stringutil.hxx"
  17 #include "editutil.hxx"
  18 #include "tokenarray.hxx"
  19 #include "formula/token.hxx"
  20 #include "svl/sharedstring.hxx"
  21
  22 namespace {
  23
  24 CellType adjustCellType( CellType eOrig )
  25 {
  26     switch (eOrig)
  27     {
  28         case CELLTYPE_EDIT:
  29             return CELLTYPE_STRING;
  30         default:
  31             ;
  32     }
  33     return eOrig;
  34 }
  35
  36 template<typename _T>
  37 OUString getString( const _T& rVal )
  38 {
  39     if (rVal.meType == CELLTYPE_STRING)
  40         return rVal.mpString->getString();
  41
  42     if (rVal.meType == CELLTYPE_EDIT)
  43     {
  44         OUStringBuffer aRet;
  45         sal_Int32 n = rVal.mpEditText->GetParagraphCount();
  46         for (sal_Int32 i = 0; i < n; ++i)
  47         {
  48             if (i > 0)
  49                 aRet.append('\n');
  50             aRet.append(rVal.mpEditText->GetText(i));
  51         }
  52         return aRet.makeStringAndClear();
  53     }
  54
  55     return EMPTY_OUSTRING;
  56 }
  57
  58 bool equalsFormulaCells( const ScFormulaCell* p1, const ScFormulaCell* p2 )
  59 {
  60     const ScTokenArray* pCode1 = p1->GetCode();
  61     const ScTokenArray* pCode2 = p2->GetCode();
  62
  63     if (pCode1->GetLen() != pCode2->GetLen())
  64         return false;
  65
  66     sal_uInt16 n = pCode1->GetLen();
  67     formula::FormulaToken** ppToken1 = pCode1->GetArray();
  68     formula::FormulaToken** ppToken2 = pCode2->GetArray();
  69     for (sal_uInt16 i = 0; i < n; ++i)
  70     {
  71         if (!ppToken1[i]->TextEqual(*(ppToken2[i])))
  72             return false;
  73     }
  74
  75     return true;
  76 }
  77
  78 template<typename _T>
  79 bool equalsWithoutFormatImpl( const _T& left, const _T& right )
  80 {
  81     CellType eType1 = adjustCellType(left.meType);
  82     CellType eType2 = adjustCellType(right.meType);
  83     if (eType1 != eType2)
  84         return false;
  85
  86     switch (eType1)
  87     {
  88         case CELLTYPE_NONE:
  89             return true;
  90         case CELLTYPE_VALUE:
  91             return left.mfValue == right.mfValue;
  92         case CELLTYPE_STRING:
  93         {
  94             OUString aStr1 = getString(left);
  95             OUString aStr2 = getString(right);
  96             return aStr1 == aStr2;
  97         }
  98         case CELLTYPE_FORMULA:
  99             return equalsFormulaCells(left.mpFormula, right.mpFormula);
 100         default:
 101             ;
 102     }
 103     return false;
 104 }
 105
 106 template<typename _T>
 107 void commitToColumn( const _T& rCell, ScColumn& rColumn, SCROW nRow )
 108 {
 109     switch (rCell.meType)
 110     {
 111         case CELLTYPE_STRING:
 112             rColumn.SetRawString(nRow, *rCell.mpString);
 113         break;
 114         case CELLTYPE_EDIT:
 115             rColumn.SetEditText(nRow, ScEditUtil::Clone(*rCell.mpEditText, rColumn.GetDoc()));
 116         break;
 117         case CELLTYPE_VALUE:
 118             rColumn.SetValue(nRow, rCell.mfValue);
 119         break;
 120         case CELLTYPE_FORMULA:
 121         {
 122             ScAddress aDestPos(rColumn.GetCol(), nRow, rColumn.GetTab());
 123             rColumn.SetFormulaCell(nRow, new ScFormulaCell(*rCell.mpFormula, rColumn.GetDoc(), aDestPos));
 124         }
 125         break;
 126         default:
 127             rColumn.Delete(nRow);
 128     }
 129 }
 130
 131 bool hasStringImpl( CellType eType, ScFormulaCell* pFormula )
 132 {
 133     switch (eType)
 134     {
 135         case CELLTYPE_STRING:
 136         case CELLTYPE_EDIT:
 137             return true;
 138         case CELLTYPE_FORMULA:
 139             return !pFormula->IsValue();
 140         default:
 141             return false;
 142     }
 143 }
 144
 145 bool hasNumericImpl( CellType eType, ScFormulaCell* pFormula )
 146 {
 147     switch (eType)
 148     {
 149         case CELLTYPE_VALUE:
 150             return true;
 151         case CELLTYPE_FORMULA:
 152             return pFormula->IsValue();
 153         default:
 154             return false;
 155     }
 156 }
 157
 158 }
 159
 160 ScCellValue::ScCellValue() : meType(CELLTYPE_NONE), mfValue(0.0) {}
 161
 162 ScCellValue::ScCellValue( const ScRefCellValue& rCell ) : meType(rCell.meType), mfValue(rCell.mfValue)
 163 {
 164     switch (rCell.meType)
 165     {
 166         case CELLTYPE_STRING:
 167             mpString = new svl::SharedString(*rCell.mpString);
 168         break;
 169         case CELLTYPE_EDIT:
 170             mpEditText = rCell.mpEditText->Clone();
 171         break;
 172         case CELLTYPE_FORMULA:
 173             mpFormula = rCell.mpFormula->Clone();
 174         break;
 175         default:
 176             ;
 177     }
 178 }
 179
 180 ScCellValue::ScCellValue( double fValue ) : meType(CELLTYPE_VALUE), mfValue(fValue) {}
 181 ScCellValue::ScCellValue( const svl::SharedString& rString ) : meType(CELLTYPE_STRING), mpString(new svl::SharedString(rString)) {}
 182 ScCellValue::ScCellValue( const EditTextObject& rEditText ) : meType(CELLTYPE_EDIT), mpEditText(rEditText.Clone()) {}
 183 ScCellValue::ScCellValue( const ScFormulaCell& rFormula ) : meType(CELLTYPE_FORMULA), mpFormula(rFormula.Clone()) {}
 184
 185 ScCellValue::ScCellValue( const ScCellValue& r ) : meType(r.meType), mfValue(r.mfValue)
 186 {
 187     switch (r.meType)
 188     {
 189         case CELLTYPE_STRING:
 190             mpString = new svl::SharedString(*r.mpString);
 191         break;
 192         case CELLTYPE_EDIT:
 193             mpEditText = r.mpEditText->Clone();
 194         break;
 195         case CELLTYPE_FORMULA:
 196             mpFormula = r.mpFormula->Clone();
 197         break;
 198         default:
 199             ;
 200     }
 201 }
 202
 203 ScCellValue::~ScCellValue()
 204 {
 205     clear();
 206 }
 207
 208 void ScCellValue::clear()
 209 {
 210     switch (meType)
 211     {
 212         case CELLTYPE_STRING:
 213             delete mpString;
 214         break;
 215         case CELLTYPE_EDIT:
 216             delete mpEditText;
 217         break;
 218         case CELLTYPE_FORMULA:
 219             delete mpFormula;
 220         break;
 221         default:
 222             ;
 223     }
 224
 225     // Reset to empty value.
 226     meType = CELLTYPE_NONE;
 227     mfValue = 0.0;
 228 }
 229
 230 void ScCellValue::set( double fValue )
 231 {
 232     clear();
 233     meType = CELLTYPE_VALUE;
 234     mfValue = fValue;
 235 }
 236
 237 void ScCellValue::set( const svl::SharedString& rStr )
 238 {
 239     clear();
 240     meType = CELLTYPE_STRING;
 241     mpString = new svl::SharedString(rStr);
 242 }
 243
 244 void ScCellValue::set( const EditTextObject& rEditText )
 245 {
 246     clear();
 247     meType = CELLTYPE_EDIT;
 248     mpEditText = rEditText.Clone();
 249 }
 250
 251 void ScCellValue::set( const ScFormulaCell& rFormula )
 252 {
 253     clear();
 254     meType = CELLTYPE_FORMULA;
 255     mpFormula = rFormula.Clone();
 256 }
 257
 258 void ScCellValue::set( ScFormulaCell* pFormula )
 259 {
 260     clear();
 261     meType = CELLTYPE_FORMULA;
 262     mpFormula = pFormula;
 263 }
 264
 265 void ScCellValue::assign( const ScDocument& rDoc, const ScAddress& rPos )
 266 {
 267     clear();
 268
 269     ScRefCellValue aRefVal;
 270     aRefVal.assign(const_cast<ScDocument&>(rDoc), rPos);
 271
 272     meType = aRefVal.meType;
 273     switch (meType)
 274     {
 275         case CELLTYPE_STRING:
 276             mpString = new svl::SharedString(*aRefVal.mpString);
 277         break;
 278         case CELLTYPE_EDIT:
 279             if (aRefVal.mpEditText)
 280                 mpEditText = aRefVal.mpEditText->Clone();
 281         break;
 282         case CELLTYPE_VALUE:
 283             mfValue = aRefVal.mfValue;
 284         break;
 285         case CELLTYPE_FORMULA:
 286             mpFormula = aRefVal.mpFormula->Clone();
 287         break;
 288         default:
 289             meType = CELLTYPE_NONE; // reset to empty.
 290     }
 291 }
 292
 293 void ScCellValue::assign( const ScCellValue& rOther, ScDocument& rDestDoc, int nCloneFlags )
 294 {
 295     clear();
 296
 297     meType = rOther.meType;
 298     switch (meType)
 299     {
 300         case CELLTYPE_STRING:
 301             mpString = new svl::SharedString(*rOther.mpString);
 302         break;
 303         case CELLTYPE_EDIT:
 304         {
 305             // Switch to the pool of the destination document.
 306             ScFieldEditEngine& rEngine = rDestDoc.GetEditEngine();
 307             if (rOther.mpEditText->HasOnlineSpellErrors())
 308             {
 309                 sal_uLong nControl = rEngine.GetControlWord();
 310                 const sal_uLong nSpellControl = EE_CNTRL_ONLINESPELLING | EE_CNTRL_ALLOWBIGOBJS;
 311                 bool bNewControl = ((nControl & nSpellControl) != nSpellControl);
 312                 if (bNewControl)
 313                     rEngine.SetControlWord(nControl | nSpellControl);
 314                 rEngine.SetText(*rOther.mpEditText);
 315                 mpEditText = rEngine.CreateTextObject();
 316                 if (bNewControl)
 317                     rEngine.SetControlWord(nControl);
 318             }
 319             else
 320             {
 321                 rEngine.SetText(*rOther.mpEditText);
 322                 mpEditText = rEngine.CreateTextObject();
 323             }
 324         }
 325         break;
 326         case CELLTYPE_VALUE:
 327             mfValue = rOther.mfValue;
 328         break;
 329         case CELLTYPE_FORMULA:
 330             // Switch to the destination document.
 331             mpFormula = new ScFormulaCell(*rOther.mpFormula, rDestDoc, rOther.mpFormula->aPos, nCloneFlags);
 332         break;
 333         default:
 334             meType = CELLTYPE_NONE; // reset to empty.
 335     }
 336 }
 337
 338 void ScCellValue::commit( ScDocument& rDoc, const ScAddress& rPos ) const
 339 {
 340     switch (meType)
 341     {
 342         case CELLTYPE_STRING:
 343         {
 344             ScSetStringParam aParam;
 345             aParam.setTextInput();
 346             rDoc.SetString(rPos, mpString->getString(), &aParam);
 347         }
 348         break;
 349         case CELLTYPE_EDIT:
 350             rDoc.SetEditText(rPos, mpEditText->Clone());
 351         break;
 352         case CELLTYPE_VALUE:
 353             rDoc.SetValue(rPos, mfValue);
 354         break;
 355         case CELLTYPE_FORMULA:
 356             rDoc.SetFormulaCell(rPos, mpFormula->Clone());
 357         break;
 358         default:
 359             rDoc.SetEmptyCell(rPos);
 360     }
 361 }
 362
 363 void ScCellValue::commit( ScColumn& rColumn, SCROW nRow ) const
 364 {
 365     commitToColumn(*this, rColumn, nRow);
 366 }
 367
 368 void ScCellValue::release( ScDocument& rDoc, const ScAddress& rPos )
 369 {
 370     switch (meType)
 371     {
 372         case CELLTYPE_STRING:
 373         {
 374             // Currently, string cannot be placed without copying.
 375             ScSetStringParam aParam;
 376             aParam.setTextInput();
 377             rDoc.SetString(rPos, mpString->getString(), &aParam);
 378             delete mpString;
 379         }
 380         break;
 381         case CELLTYPE_EDIT:
 382             // Cell takes the ownership of the text object.
 383             rDoc.SetEditText(rPos, mpEditText);
 384         break;
 385         case CELLTYPE_VALUE:
 386             rDoc.SetValue(rPos, mfValue);
 387         break;
 388         case CELLTYPE_FORMULA:
 389             // This formula cell instance is directly placed in the document without copying.
 390             rDoc.SetFormulaCell(rPos, mpFormula);
 391         break;
 392         default:
 393             rDoc.SetEmptyCell(rPos);
 394     }
 395
 396     meType = CELLTYPE_NONE;
 397     mfValue = 0.0;
 398 }
 399
 400 void ScCellValue::release( ScColumn& rColumn, SCROW nRow )
 401 {
 402     switch (meType)
 403     {
 404         case CELLTYPE_STRING:
 405         {
 406             // Currently, string cannot be placed without copying.
 407             rColumn.SetRawString(nRow, *mpString);
 408             delete mpString;
 409         }
 410         break;
 411         case CELLTYPE_EDIT:
 412             // Cell takes the ownership of the text object.
 413             rColumn.SetEditText(nRow, mpEditText);
 414         break;
 415         case CELLTYPE_VALUE:
 416             rColumn.SetValue(nRow, mfValue);
 417         break;
 418         case CELLTYPE_FORMULA:
 419             // This formula cell instance is directly placed in the document without copying.
 420             rColumn.SetFormulaCell(nRow, mpFormula);
 421         break;
 422         default:
 423             rColumn.Delete(nRow);
 424     }
 425
 426     meType = CELLTYPE_NONE;
 427     mfValue = 0.0;
 428 }
 429
 430 bool ScCellValue::hasString() const
 431 {
 432     return hasStringImpl(meType, mpFormula);
 433 }
 434
 435 bool ScCellValue::hasNumeric() const
 436 {
 437     return hasNumericImpl(meType, mpFormula);
 438 }
 439
 440 bool ScCellValue::isEmpty() const
 441 {
 442     return meType == CELLTYPE_NONE;
 443 }
 444
 445 bool ScCellValue::equalsWithoutFormat( const ScCellValue& r ) const
 446 {
 447     return equalsWithoutFormatImpl(*this, r);
 448 }
 449
 450 ScCellValue& ScCellValue::operator= ( const ScCellValue& r )
 451 {
 452     ScCellValue aTmp(r);
 453     swap(aTmp);
 454     return *this;
 455 }
 456
 457 ScCellValue& ScCellValue::operator= ( const ScRefCellValue& r )
 458 {
 459     ScCellValue aTmp(r);
 460     swap(aTmp);
 461     return *this;
 462 }
 463
 464 void ScCellValue::swap( ScCellValue& r )
 465 {
 466     std::swap(meType, r.meType);
 467
 468     // double is 8 bytes, whereas a pointer may be 4 or 8 bytes depending on
 469     // the platform. Swap by double values.
 470     std::swap(mfValue, r.mfValue);
 471 }
 472
 473 ScRefCellValue::ScRefCellValue() : meType(CELLTYPE_NONE), mfValue(0.0) {}
 474 ScRefCellValue::ScRefCellValue( double fValue ) : meType(CELLTYPE_VALUE), mfValue(fValue) {}
 475 ScRefCellValue::ScRefCellValue( const svl::SharedString* pString ) : meType(CELLTYPE_STRING), mpString(pString) {}
 476 ScRefCellValue::ScRefCellValue( const EditTextObject* pEditText ) : meType(CELLTYPE_EDIT), mpEditText(pEditText) {}
 477 ScRefCellValue::ScRefCellValue( ScFormulaCell* pFormula ) : meType(CELLTYPE_FORMULA), mpFormula(pFormula) {}
 478
 479 // It should be enough to copy the double value, which is at least as large
 480 // as the pointer values.
 481 ScRefCellValue::ScRefCellValue( const ScRefCellValue& r ) : meType(r.meType), mfValue(r.mfValue) {}
 482
 483 ScRefCellValue::~ScRefCellValue()
 484 {
 485     clear();
 486 }
 487
 488 void ScRefCellValue::clear()
 489 {
 490     // Reset to empty value.
 491     meType = CELLTYPE_NONE;
 492     mfValue = 0.0;
 493 }
 494
 495 void ScRefCellValue::assign( ScDocument& rDoc, const ScAddress& rPos )
 496 {
 497     *this = rDoc.GetRefCellValue(rPos);
 498 }
 499
 500 void ScRefCellValue::commit( ScDocument& rDoc, const ScAddress& rPos ) const
 501 {
 502     switch (meType)
 503     {
 504         case CELLTYPE_STRING:
 505         {
 506             ScSetStringParam aParam;
 507             aParam.setTextInput();
 508             rDoc.SetString(rPos, mpString->getString(), &aParam);
 509         }
 510         break;
 511         case CELLTYPE_EDIT:
 512             rDoc.SetEditText(rPos, ScEditUtil::Clone(*mpEditText, rDoc));
 513         break;
 514         case CELLTYPE_VALUE:
 515             rDoc.SetValue(rPos, mfValue);
 516         break;
 517         case CELLTYPE_FORMULA:
 518             rDoc.SetFormulaCell(rPos, new ScFormulaCell(*mpFormula, rDoc, rPos));
 519         break;
 520         default:
 521             rDoc.SetEmptyCell(rPos);
 522     }
 523 }
 524
 525 void ScRefCellValue::commit( ScColumn& rColumn, SCROW nRow ) const
 526 {
 527     commitToColumn(*this, rColumn, nRow);
 528 }
 529
 530 bool ScRefCellValue::hasString() const
 531 {
 532     return hasStringImpl(meType, mpFormula);
 533 }
 534
 535 bool ScRefCellValue::hasNumeric() const
 536 {
 537     return hasNumericImpl(meType, mpFormula);
 538 }
 539
 540 double ScRefCellValue::getValue()
 541 {
 542     switch (meType)
 543     {
 544         case CELLTYPE_VALUE:
 545             return mfValue;
 546         case CELLTYPE_FORMULA:
 547             return mpFormula->GetValue();
 548         default:
 549             ;
 550     }
 551     return 0.0;
 552 }
 553
 554 OUString ScRefCellValue::getString( const ScDocument* pDoc )
 555 {
 556     switch (meType)
 557     {
 558         case CELLTYPE_VALUE:
 559             return OUString::number(mfValue);
 560         case CELLTYPE_STRING:
 561             return mpString->getString();
 562         case CELLTYPE_EDIT:
 563             if (mpEditText)
 564                 return ScEditUtil::GetString(*mpEditText, pDoc);
 565         break;
 566         case CELLTYPE_FORMULA:
 567             return mpFormula->GetString().getString();
 568         default:
 569             ;
 570     }
 571     return EMPTY_OUSTRING;
 572 }
 573
 574 bool ScRefCellValue::isEmpty() const
 575 {
 576     return meType == CELLTYPE_NONE;
 577 }
 578
 579 bool ScRefCellValue::hasEmptyValue()
 580 {
 581     if (isEmpty())
 582         return true;
 583
 584     if (meType == CELLTYPE_FORMULA)
 585         return mpFormula->IsEmpty();
 586
 587     return false;
 588 }
 589
 590 bool ScRefCellValue::equalsWithoutFormat( const ScRefCellValue& r ) const
 591 {
 592     return equalsWithoutFormatImpl(*this, r);
 593 }
 594
 595 ScRefCellValue& ScRefCellValue::operator= ( const ScRefCellValue& r )
 596 {
 597     ScRefCellValue aTmp(r);
 598     swap(aTmp);
 599     return *this;
 600 }
 601
 602 void ScRefCellValue::swap( ScRefCellValue& r )
 603 {
 604     std::swap(meType, r.meType);
 605
 606     // double is 8 bytes, whereas a pointer may be 4 or 8 bytes depending on
 607     // the platform. Swap by double values.
 608     std::swap(mfValue, r.mfValue);
 609 }
 610
 611 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */