sc/source/core/data/clipcontext.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 "clipcontext.hxx"
  11 #include "document.hxx"
  12 #include "mtvelements.hxx"
  13 #include <column.hxx>
  14 #include <scitems.hxx>
  15 #include <tokenarray.hxx>
  16 #include <editutil.hxx>
  17 #include <clipparam.hxx>
  18
  19 #include <svl/intitem.hxx>
  20
  21 namespace sc {
  22
  23 ClipContextBase::ClipContextBase(ScDocument& rDoc) :
  24     mpSet(new ColumnBlockPositionSet(rDoc)) {}
  25
  26 ClipContextBase::~ClipContextBase() {}
  27
  28 ColumnBlockPosition* ClipContextBase::getBlockPosition(SCTAB nTab, SCCOL nCol)
  29 {
  30     return mpSet->getBlockPosition(nTab, nCol);
  31 }
  32
  33 CopyFromClipContext::CopyFromClipContext(ScDocument& rDoc,
  34     ScDocument* pRefUndoDoc, ScDocument* pClipDoc, InsertDeleteFlags nInsertFlag,
  35     bool bAsLink, bool bSkipAttrForEmptyCells) :
  36     ClipContextBase(rDoc),
  37     mnDestCol1(-1), mnDestCol2(-1),
  38     mnDestRow1(-1), mnDestRow2(-1),
  39     mnTabStart(-1), mnTabEnd(-1),
  40     mrDestDoc(rDoc),
  41     mpRefUndoDoc(pRefUndoDoc), mpClipDoc(pClipDoc),
  42     mnInsertFlag(nInsertFlag), mnDeleteFlag(IDF_NONE),
  43     mpCondFormatList(NULL),
  44     mbAsLink(bAsLink), mbSkipAttrForEmptyCells(bSkipAttrForEmptyCells),
  45     mbCloneNotes (mnInsertFlag & (IDF_NOTE|IDF_ADDNOTES)),
  46     mbTableProtected(false)
  47 {
  48 }
  49
  50 CopyFromClipContext::~CopyFromClipContext()
  51 {
  52 }
  53
  54 void CopyFromClipContext::setTabRange(SCTAB nStart, SCTAB nEnd)
  55 {
  56     mnTabStart = nStart;
  57     mnTabEnd = nEnd;
  58 }
  59
  60 SCTAB CopyFromClipContext::getTabStart() const
  61 {
  62     return mnTabStart;
  63 }
  64
  65 SCTAB CopyFromClipContext::getTabEnd() const
  66 {
  67     return mnTabEnd;
  68 }
  69
  70 void CopyFromClipContext::setDestRange( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
  71 {
  72     mnDestCol1 = nCol1;
  73     mnDestRow1 = nRow1;
  74     mnDestCol2 = nCol2;
  75     mnDestRow2 = nRow2;
  76 }
  77
  78 CopyFromClipContext::Range CopyFromClipContext::getDestRange() const
  79 {
  80     Range aRet;
  81     aRet.mnCol1 = mnDestCol1;
  82     aRet.mnCol2 = mnDestCol2;
  83     aRet.mnRow1 = mnDestRow1;
  84     aRet.mnRow2 = mnDestRow2;
  85     return aRet;
  86 }
  87
  88 ScDocument* CopyFromClipContext::getUndoDoc()
  89 {
  90     return mpRefUndoDoc;
  91 }
  92
  93 ScDocument* CopyFromClipContext::getClipDoc()
  94 {
  95     return mpClipDoc;
  96 }
  97
  98 InsertDeleteFlags CopyFromClipContext::getInsertFlag() const
  99 {
 100     return mnInsertFlag;
 101 }
 102
 103 void CopyFromClipContext::setDeleteFlag( InsertDeleteFlags nFlag )
 104 {
 105     mnDeleteFlag = nFlag;
 106 }
 107
 108 InsertDeleteFlags CopyFromClipContext::getDeleteFlag() const
 109 {
 110     return mnDeleteFlag;
 111 }
 112
 113 void CopyFromClipContext::setSingleCellColumnSize( size_t nSize )
 114 {
 115     maSingleCells.resize(nSize);
 116     maSingleCellAttrs.resize(nSize);
 117     maSinglePatterns.resize(nSize, NULL);
 118     maSingleNotes.resize(nSize, NULL);
 119 }
 120
 121 ScCellValue& CopyFromClipContext::getSingleCell( size_t nColOffset )
 122 {
 123     assert(nColOffset < maSingleCells.size());
 124     return maSingleCells[nColOffset];
 125 }
 126
 127 sc::CellTextAttr& CopyFromClipContext::getSingleCellAttr( size_t nColOffset )
 128 {
 129     assert(nColOffset < maSingleCellAttrs.size());
 130     return maSingleCellAttrs[nColOffset];
 131 }
 132
 133 void CopyFromClipContext::setSingleCell( const ScAddress& rSrcPos, const ScColumn& rSrcCol )
 134 {
 135     SCCOL nColOffset = rSrcPos.Col() - mpClipDoc->GetClipParam().getWholeRange().aStart.Col();
 136     ScCellValue& rSrcCell = getSingleCell(nColOffset);
 137
 138     const sc::CellTextAttr* pAttr = rSrcCol.GetCellTextAttr(rSrcPos.Row());
 139
 140     if (pAttr)
 141     {
 142         sc::CellTextAttr& rAttr = getSingleCellAttr(nColOffset);
 143         rAttr = *pAttr;
 144     }
 145
 146     if (mbAsLink)
 147     {
 148         ScSingleRefData aRef;
 149         aRef.InitAddress(rSrcPos);
 150         aRef.SetFlag3D(true);
 151
 152         ScTokenArray aArr;
 153         aArr.AddSingleReference(aRef);
 154         rSrcCell.set(new ScFormulaCell(mpClipDoc, rSrcPos, aArr));
 155         return;
 156     }
 157
 158     rSrcCell.assign(*mpClipDoc, rSrcPos);
 159
 160     // Check the paste flag to see whether we want to paste this cell.  If the
 161     // flag says we don't want to paste this cell, we'll return with true.
 162     InsertDeleteFlags nFlags = getInsertFlag();
 163     bool bNumeric  = (nFlags & IDF_VALUE) != IDF_NONE;
 164     bool bDateTime = (nFlags & IDF_DATETIME) != IDF_NONE;
 165     bool bString   = (nFlags & IDF_STRING) != IDF_NONE;
 166     bool bBoolean  = (nFlags & IDF_SPECIAL_BOOLEAN) != IDF_NONE;
 167     bool bFormula  = (nFlags & IDF_FORMULA) != IDF_NONE;
 168
 169     switch (rSrcCell.meType)
 170     {
 171         case CELLTYPE_VALUE:
 172         {
 173             bool bPaste = isDateCell(rSrcCol, rSrcPos.Row()) ? bDateTime : bNumeric;
 174             if (!bPaste)
 175                 // Don't paste this.
 176                 rSrcCell.clear();
 177         }
 178         break;
 179         case CELLTYPE_STRING:
 180         case CELLTYPE_EDIT:
 181         {
 182             if (!bString)
 183                 // Skip pasting.
 184                 rSrcCell.clear();
 185         }
 186         break;
 187         case CELLTYPE_FORMULA:
 188         {
 189             if (bBoolean)
 190             {
 191                 // Check if this formula cell is a boolean cell, and if so, go ahead and paste it.
 192                 ScTokenArray* pCode = rSrcCell.mpFormula->GetCode();
 193                 if (pCode && pCode->GetLen() == 1)
 194                 {
 195                     const formula::FormulaToken* p = pCode->First();
 196                     if (p->GetOpCode() == ocTrue || p->GetOpCode() == ocFalse)
 197                         // This is a boolean formula. Good.
 198                         break;
 199                 }
 200             }
 201
 202             if (bFormula)
 203                 // Good.
 204                 break;
 205
 206             sal_uInt16 nErr = rSrcCell.mpFormula->GetErrCode();
 207             if (nErr)
 208             {
 209                 // error codes are cloned with values
 210                 if (!bNumeric)
 211                     // Error code is treated as numeric value. Don't paste it.
 212                     rSrcCell.clear();
 213             }
 214             else if (rSrcCell.mpFormula->IsValue())
 215             {
 216                 bool bPaste = isDateCell(rSrcCol, rSrcPos.Row()) ? bDateTime : bNumeric;
 217                 if (!bPaste)
 218                 {
 219                     // Don't paste this.
 220                     rSrcCell.clear();
 221                     break;
 222                 }
 223
 224                 // Turn this into a numeric cell.
 225                 rSrcCell.set(rSrcCell.mpFormula->GetValue());
 226             }
 227             else if (bString)
 228             {
 229                 svl::SharedString aStr = rSrcCell.mpFormula->GetString();
 230                 if (aStr.isEmpty())
 231                 {
 232                     // do not clone empty string
 233                     rSrcCell.clear();
 234                     break;
 235                 }
 236
 237                 // Turn this into a string or edit cell.
 238                 if (rSrcCell.mpFormula->IsMultilineResult())
 239                 {
 240                     // TODO : Add shared string support to the edit engine to
 241                     // make this process simpler.
 242                     ScFieldEditEngine& rEngine = mrDestDoc.GetEditEngine();
 243                     rEngine.SetText(rSrcCell.mpFormula->GetString().getString());
 244                     boost::scoped_ptr<EditTextObject> pObj(rEngine.CreateTextObject());
 245                     pObj->NormalizeString(mrDestDoc.GetSharedStringPool());
 246                     rSrcCell.set(*pObj);
 247                 }
 248                 else
 249                     rSrcCell.set(rSrcCell.mpFormula->GetString());
 250             }
 251             else
 252                 // We don't want to paste this.
 253                 rSrcCell.clear();
 254         }
 255         break;
 256         case CELLTYPE_NONE:
 257         default:
 258             // There is nothing to paste.
 259             rSrcCell.clear();
 260     }
 261 }
 262
 263 const ScPatternAttr* CopyFromClipContext::getSingleCellPattern( size_t nColOffset ) const
 264 {
 265     assert(nColOffset < maSinglePatterns.size());
 266     return maSinglePatterns[nColOffset];
 267 }
 268
 269 void CopyFromClipContext::setSingleCellPattern( size_t nColOffset, const ScPatternAttr* pAttr )
 270 {
 271     assert(nColOffset < maSinglePatterns.size());
 272     maSinglePatterns[nColOffset] = pAttr;
 273 }
 274
 275 const ScPostIt* CopyFromClipContext::getSingleCellNote( size_t nColOffset ) const
 276 {
 277     assert(nColOffset < maSingleNotes.size());
 278     return maSingleNotes[nColOffset];
 279 }
 280
 281 void CopyFromClipContext::setSingleCellNote( size_t nColOffset, const ScPostIt* pNote )
 282 {
 283     assert(nColOffset < maSingleNotes.size());
 284     maSingleNotes[nColOffset] = pNote;
 285 }
 286
 287 void CopyFromClipContext::setCondFormatList( ScConditionalFormatList* pCondFormatList )
 288 {
 289     mpCondFormatList = pCondFormatList;
 290 }
 291
 292 ScConditionalFormatList* CopyFromClipContext::getCondFormatList()
 293 {
 294     return mpCondFormatList;
 295 }
 296
 297 void CopyFromClipContext::setTableProtected( bool b )
 298 {
 299     mbTableProtected = b;
 300 }
 301
 302 bool CopyFromClipContext::isTableProtected() const
 303 {
 304     return mbTableProtected;
 305 }
 306
 307 bool CopyFromClipContext::isAsLink() const
 308 {
 309     return mbAsLink;
 310 }
 311
 312 bool CopyFromClipContext::isSkipAttrForEmptyCells() const
 313 {
 314     return mbSkipAttrForEmptyCells;
 315 }
 316
 317 bool CopyFromClipContext::isCloneNotes() const
 318 {
 319     return mbCloneNotes;
 320 }
 321
 322 bool CopyFromClipContext::isDateCell( const ScColumn& rCol, SCROW nRow ) const
 323 {
 324     sal_uLong nNumIndex = static_cast<const SfxUInt32Item*>(rCol.GetAttr(nRow, ATTR_VALUE_FORMAT))->GetValue();
 325     short nType = mpClipDoc->GetFormatTable()->GetType(nNumIndex);
 326     return (nType == css::util::NumberFormat::DATE) || (nType == css::util::NumberFormat::TIME) || (nType == css::util::NumberFormat::DATETIME);
 327 }
 328
 329 CopyToClipContext::CopyToClipContext(
 330     ScDocument& rDoc, bool bKeepScenarioFlags, bool bCloneNotes) :
 331     ClipContextBase(rDoc), mbKeepScenarioFlags(bKeepScenarioFlags), mbCloneNotes(bCloneNotes) {}
 332
 333 CopyToClipContext::~CopyToClipContext() {}
 334
 335 bool CopyToClipContext::isKeepScenarioFlags() const
 336 {
 337     return mbKeepScenarioFlags;
 338 }
 339
 340 bool CopyToClipContext::isCloneNotes() const
 341 {
 342     return mbCloneNotes;
 343 }
 344
 345 CopyToDocContext::CopyToDocContext(ScDocument& rDoc) :
 346     ClipContextBase(rDoc), mbStartListening(true) {}
 347
 348 CopyToDocContext::~CopyToDocContext() {}
 349
 350 void CopyToDocContext::setStartListening( bool b )
 351 {
 352     mbStartListening = b;
 353 }
 354
 355 bool CopyToDocContext::isStartListening() const
 356 {
 357     return mbStartListening;
 358 }
 359
 360 MixDocContext::MixDocContext(ScDocument& rDoc) : ClipContextBase(rDoc) {}
 361 MixDocContext::~MixDocContext() {}
 362
 363 }
 364
 365 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */