sc/inc/global.hxx | 89 ++++++++------------------- sc/inc/scabstdlg.hxx | 4 - sc/qa/unit/copy_paste_test.cxx | 2 sc/qa/unit/subsequent_filters-test.cxx | 4 - sc/qa/unit/ucalc.cxx | 74 +++++++++++----------- sc/qa/unit/ucalc_formula.cxx | 2 sc/qa/unit/ucalc_sharedformula.cxx | 2 sc/source/core/data/clipcontext.cxx | 14 ++-- sc/source/core/data/column.cxx | 52 +++++++-------- sc/source/core/data/column3.cxx | 52 +++++++-------- sc/source/core/data/column4.cxx | 18 ++--- sc/source/core/data/documen2.cxx | 6 - sc/source/core/data/documen3.cxx | 2 sc/source/core/data/document.cxx | 62 +++++++++--------- sc/source/core/data/document10.cxx | 4 - sc/source/core/data/dpobject.cxx | 2 sc/source/core/data/dpoutput.cxx | 4 - sc/source/core/data/table2.cxx | 34 +++++----- sc/source/core/data/table4.cxx | 10 +-- sc/source/core/data/table6.cxx | 2 sc/source/core/tool/chgtrack.cxx | 4 - sc/source/ui/app/transobj.cxx | 4 - sc/source/ui/attrdlg/scdlgfact.hxx | 4 - sc/source/ui/docshell/arealink.cxx | 12 +-- sc/source/ui/docshell/dbdocfun.cxx | 32 ++++----- sc/source/ui/docshell/dbdocimp.cxx | 24 +++---- sc/source/ui/docshell/docfunc.cxx | 74 +++++++++++----------- sc/source/ui/docshell/docfuncutil.cxx | 16 ++-- sc/source/ui/docshell/docsh5.cxx | 18 ++--- sc/source/ui/docshell/impex.cxx | 12 +-- sc/source/ui/docshell/olinefun.cxx | 28 ++++---- sc/source/ui/docshell/tablink.cxx | 4 - sc/source/ui/inc/delcodlg.hxx | 2 sc/source/ui/inc/docfuncutil.hxx | 2 sc/source/ui/inc/inscodlg.hxx | 2 sc/source/ui/inc/viewfunc.hxx | 2 sc/source/ui/miscdlgs/delcodlg.cxx | 40 ++++++------ sc/source/ui/miscdlgs/inscodlg.cxx | 44 ++++++------- sc/source/ui/undo/undobase.cxx | 2 sc/source/ui/undo/undoblk.cxx | 69 ++++++++++----------- sc/source/ui/undo/undoblk2.cxx | 4 - sc/source/ui/undo/undoblk3.cxx | 84 ++++++++++++------------- sc/source/ui/undo/undodat.cxx | 108 ++++++++++++++++----------------- sc/source/ui/undo/undotab.cxx | 6 - sc/source/ui/unoobj/cellsuno.cxx | 26 +++---- sc/source/ui/unoobj/docuno.cxx | 2 sc/source/ui/unoobj/funcuno.cxx | 6 - sc/source/ui/vba/excelvbahelper.cxx | 2 sc/source/ui/vba/vbahelper.cxx | 2 sc/source/ui/vba/vbarange.cxx | 16 ++-- sc/source/ui/view/cellsh1.cxx | 108 ++++++++++++++++----------------- sc/source/ui/view/cellsh3.cxx | 2 sc/source/ui/view/cliputil.cxx | 6 - sc/source/ui/view/dbfunc3.cxx | 18 ++--- sc/source/ui/view/gridwin.cxx | 6 - sc/source/ui/view/viewfun2.cxx | 10 +-- sc/source/ui/view/viewfun3.cxx | 90 +++++++++++++-------------- sc/source/ui/view/viewfun4.cxx | 12 +-- sc/source/ui/view/viewfun5.cxx | 8 +- sc/source/ui/view/viewfunc.cxx | 24 +++---- 60 files changed, 670 insertions(+), 704 deletions(-)
New commits: commit eaa34b4e29478770c4707d56aa102491bc8e058a Author: Noel Grandin <[email protected]> Date: Mon Oct 26 10:19:25 2015 +0200 convert InsertDeleteFlags to use o3tl::typed_flags Change-Id: I3f6a97195d3364b2a0964f62f11e9c0de9493d64 diff --git a/sc/inc/global.hxx b/sc/inc/global.hxx index 8ecfedf..c61b209 100644 --- a/sc/inc/global.hxx +++ b/sc/inc/global.hxx @@ -135,72 +135,37 @@ const ScBreakType BREAK_NONE = 0; const ScBreakType BREAK_PAGE = 1; const ScBreakType BREAK_MANUAL = 2; -// insert/delete flags - typesafe bitfield -struct InsertDeleteFlags final { -private: - sal_uInt16 v; - // hidden so that it doesn't accidentally get called in constructor initialiser lists - explicit InsertDeleteFlags(sal_uInt16 _v) : v(_v) {} -public: - static InsertDeleteFlags fromInt(sal_uInt16 v) { return InsertDeleteFlags(v); } - operator bool() const { return v != 0; } - sal_uInt16 val() const { return v; } - bool operator ==(const InsertDeleteFlags& other) const { return v == other.v; } - bool operator !=(const InsertDeleteFlags& other) const { return v != other.v; } -private: - // disallow implicit conversion to int - operator int() const { return v; } -}; -// make combining these type-safe -inline InsertDeleteFlags operator| (const InsertDeleteFlags& lhs, const InsertDeleteFlags& rhs) -{ - return InsertDeleteFlags::fromInt(lhs.val() | rhs.val()); -} -inline InsertDeleteFlags operator& (const InsertDeleteFlags& lhs, const InsertDeleteFlags& rhs) -{ - return InsertDeleteFlags::fromInt(lhs.val() & rhs.val()); -} -inline InsertDeleteFlags& operator|= (InsertDeleteFlags& lhs, const InsertDeleteFlags& rhs) +enum class InsertDeleteFlags : sal_uInt16 { - lhs = InsertDeleteFlags::fromInt(lhs.val() | rhs.val()); - return lhs; -} -inline InsertDeleteFlags& operator&= (InsertDeleteFlags& lhs, const InsertDeleteFlags& rhs) -{ - lhs = InsertDeleteFlags::fromInt(lhs.val() & rhs.val()); - return lhs; -} - -const InsertDeleteFlags IDF_NONE = InsertDeleteFlags::fromInt(0x0000); -const InsertDeleteFlags IDF_VALUE = InsertDeleteFlags::fromInt(0x0001); /// Numeric values (and numeric results if IDF_FORMULA is not set). -const InsertDeleteFlags IDF_DATETIME = InsertDeleteFlags::fromInt(0x0002); /// Dates, times, datetime values. -const InsertDeleteFlags IDF_STRING = InsertDeleteFlags::fromInt(0x0004); /// Strings (and string results if IDF_FORMULA is not set). -const InsertDeleteFlags IDF_NOTE = InsertDeleteFlags::fromInt(0x0008); /// Cell notes. -const InsertDeleteFlags IDF_FORMULA = InsertDeleteFlags::fromInt(0x0010); /// Formula cells. -const InsertDeleteFlags IDF_HARDATTR = InsertDeleteFlags::fromInt(0x0020); /// Hard cell attributes. -const InsertDeleteFlags IDF_STYLES = InsertDeleteFlags::fromInt(0x0040); /// Cell styles. -const InsertDeleteFlags IDF_OBJECTS = InsertDeleteFlags::fromInt(0x0080); /// Drawing objects. -const InsertDeleteFlags IDF_EDITATTR = InsertDeleteFlags::fromInt(0x0100); /// Rich-text attributes. -const InsertDeleteFlags IDF_OUTLINE = InsertDeleteFlags::fromInt(0x0800); /// Sheet / outlining (grouping) information -const InsertDeleteFlags IDF_NOCAPTIONS = InsertDeleteFlags::fromInt(0x0200); /// Internal use only (undo etc.): do not copy/delete caption objects of cell notes. -const InsertDeleteFlags IDF_ADDNOTES = InsertDeleteFlags::fromInt(0x0400); /// Internal use only (copy from clip): do not delete existing cell contents when pasting notes. -const InsertDeleteFlags IDF_SPECIAL_BOOLEAN = InsertDeleteFlags::fromInt(0x1000); -const InsertDeleteFlags IDF_FORGETCAPTIONS = InsertDeleteFlags::fromInt(0x2000); /// Internal use only (d&d undo): do not delete caption objects of cell notes. -const InsertDeleteFlags IDF_ATTRIB = IDF_HARDATTR | IDF_STYLES; -const InsertDeleteFlags IDF_CONTENTS = IDF_VALUE | IDF_DATETIME | IDF_STRING | IDF_NOTE | IDF_FORMULA | IDF_OUTLINE; -const InsertDeleteFlags IDF_ALL = IDF_CONTENTS | IDF_ATTRIB | IDF_OBJECTS; -const InsertDeleteFlags IDF_ALL_USED_BITS = IDF_ALL | IDF_EDITATTR | IDF_NOCAPTIONS | IDF_ADDNOTES | IDF_SPECIAL_BOOLEAN | IDF_FORGETCAPTIONS; - -inline InsertDeleteFlags operator~ (const InsertDeleteFlags& rhs) + NONE = 0x0000, + VALUE = 0x0001, /// Numeric values (and numeric results if InsertDeleteFlags::FORMULA is not set). + DATETIME = 0x0002, /// Dates, times, datetime values. + STRING = 0x0004, /// Strings (and string results if InsertDeleteFlags::FORMULA is not set). + NOTE = 0x0008, /// Cell notes. + FORMULA = 0x0010, /// Formula cells. + HARDATTR = 0x0020, /// Hard cell attributes. + STYLES = 0x0040, /// Cell styles. + OBJECTS = 0x0080, /// Drawing objects. + EDITATTR = 0x0100, /// Rich-text attributes. + OUTLINE = 0x0800, /// Sheet / outlining (grouping) information + NOCAPTIONS = 0x0200, /// Internal use only (undo etc.): do not copy/delete caption objects of cell notes. + ADDNOTES = 0x0400, /// Internal use only (copy from clip): do not delete existing cell contents when pasting notes. + SPECIAL_BOOLEAN = 0x1000, + FORGETCAPTIONS = 0x2000, /// Internal use only (d&d undo): do not delete caption objects of cell notes. + ATTRIB = HARDATTR | STYLES, + CONTENTS = VALUE | DATETIME | STRING | NOTE | FORMULA | OUTLINE, + ALL = CONTENTS | ATTRIB | OBJECTS, + ALL_USED_BITS = ALL | EDITATTR | NOCAPTIONS | ADDNOTES | SPECIAL_BOOLEAN | FORGETCAPTIONS, + /// Copy flags for auto/series fill functions: do not touch notes and drawing objects. + AUTOFILL = ALL & ~(NOTE | OBJECTS) +}; +namespace o3tl { - return IDF_ALL_USED_BITS & InsertDeleteFlags::fromInt(~rhs.val()); + template<> struct typed_flags<InsertDeleteFlags> : is_typed_flags<InsertDeleteFlags, 0x3fff> {}; } +// This doesn't work at the moment, perhaps when we have constexpr we can modify InsertDeleteFlags to make it work. +//static_assert((InsertDeleteFlags::ATTRIB & InsertDeleteFlags::CONTENTS) == InsertDeleteFlags::NONE, "these must match"); -// This doesnt work at the moment, perhaps when we have constexpr we can modify InsertDeleteFlags to make it work. -//static_assert((IDF_ATTRIB & IDF_CONTENTS) == IDF_NONE, "these must match"); - -/// Copy flags for auto/series fill functions: do not touch notes and drawing objects. -const InsertDeleteFlags IDF_AUTOFILL = IDF_ALL & ~(IDF_NOTE | IDF_OBJECTS); enum class ScPasteFunc { NONE, ADD, SUB, MUL, DIV diff --git a/sc/inc/scabstdlg.hxx b/sc/inc/scabstdlg.hxx index 1fd7e12..82c866e 100644 --- a/sc/inc/scabstdlg.hxx +++ b/sc/inc/scabstdlg.hxx @@ -361,7 +361,7 @@ public: ScTabViewShell* pTabViewShell) = 0; virtual AbstractScDeleteContentsDlg * CreateScDeleteContentsDlg(vcl::Window* pParent, - InsertDeleteFlags nCheckDefaults = IDF_NONE) = 0; + InsertDeleteFlags nCheckDefaults = InsertDeleteFlags::NONE) = 0; virtual AbstractScFillSeriesDlg * CreateScFillSeriesDlg( vcl::Window* pParent, ScDocument& rDocument, FillDir eFillDir, @@ -381,7 +381,7 @@ public: bool bDisallowCellMove = false ) = 0; virtual AbstractScInsertContentsDlg * CreateScInsertContentsDlg( vcl::Window* pParent, - InsertDeleteFlags nCheckDefaults = IDF_NONE, + InsertDeleteFlags nCheckDefaults = InsertDeleteFlags::NONE, const OUString* pStrTitle = NULL ) = 0; virtual AbstractScInsertTableDlg * CreateScInsertTableDlg(vcl::Window* pParent, ScViewData& rViewData, diff --git a/sc/qa/unit/copy_paste_test.cxx b/sc/qa/unit/copy_paste_test.cxx index 1cd559b..9d933a3 100644 --- a/sc/qa/unit/copy_paste_test.cxx +++ b/sc/qa/unit/copy_paste_test.cxx @@ -116,7 +116,7 @@ void ScCopyPasteTest::testCopyPasteXLS() CPPUNIT_ASSERT(pViewShell != NULL); // 6. Paste - pViewShell->GetViewData().GetView()->PasteFromClip(IDF_ALL, &aClipDoc); + pViewShell->GetViewData().GetView()->PasteFromClip(InsertDeleteFlags::ALL, &aClipDoc); xDocSh->DoClose(); } diff --git a/sc/qa/unit/subsequent_filters-test.cxx b/sc/qa/unit/subsequent_filters-test.cxx index d88a1cc..d362b2d5 100644 --- a/sc/qa/unit/subsequent_filters-test.cxx +++ b/sc/qa/unit/subsequent_filters-test.cxx @@ -719,7 +719,7 @@ void ScFiltersTest::testFormulaDepDeleteContentsODS() ScMarkData aMark; aMark.SetMarkArea(aRange); aMark.MarkToMulti(); - bool bGood = rFunc.DeleteContents(aMark, IDF_ALL, true, true); + bool bGood = rFunc.DeleteContents(aMark, InsertDeleteFlags::ALL, true, true); CPPUNIT_ASSERT(bGood); CPPUNIT_ASSERT_EQUAL(0.0, rDoc.GetValue(ScAddress(3,1,0))); CPPUNIT_ASSERT_EQUAL(0.0, rDoc.GetValue(ScAddress(3,2,0))); @@ -2623,7 +2623,7 @@ void ScFiltersTest::testOptimalHeightReset() ScRange aDelRange(0,0,0,0,0,0); ScMarkData aMark; aMark.SetMarkArea(aDelRange); - bool bRet = rFunc.DeleteContents( aMark, IDF_ALL, false, true ); + bool bRet = rFunc.DeleteContents( aMark, InsertDeleteFlags::ALL, false, true ); CPPUNIT_ASSERT_MESSAGE("DeleteContents failed", bRet); // get the new height of A1 diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx index f473903..0ef8cdc 100644 --- a/sc/qa/unit/ucalc.cxx +++ b/sc/qa/unit/ucalc.cxx @@ -269,7 +269,7 @@ void Test::testPerf() ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(ScRange(aPos), IDF_CONTENTS, false, pUndoDoc, &aMark); + m_pDoc->CopyToDocument(ScRange(aPos), InsertDeleteFlags::CONTENTS, false, pUndoDoc, &aMark); // Paste it to A2:A100000, and measure its duration. ScRange aPasteRange(0,1,0,0,99999,0); @@ -277,17 +277,17 @@ void Test::testPerf() { MeasureTimeSwitch aTime(diff); - m_pDoc->CopyFromClip(aPasteRange, aMark, IDF_CONTENTS, pUndoDoc, &aClipDoc); + m_pDoc->CopyFromClip(aPasteRange, aMark, InsertDeleteFlags::CONTENTS, pUndoDoc, &aClipDoc); } PERF_ASSERT(diff, scale, 1500.0, "Pasting a single cell to A2:A100000"); ScDocument* pRedoDoc = new ScDocument(SCDOCMODE_UNDO); pRedoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aPasteRange, IDF_CONTENTS, false, pRedoDoc, &aMark); + m_pDoc->CopyToDocument(aPasteRange, InsertDeleteFlags::CONTENTS, false, pRedoDoc, &aMark); // Create an undo object for this. ScRefUndoData* pRefUndoData = new ScRefUndoData(m_pDoc); - ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, IDF_CONTENTS, pRefUndoData); + ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, InsertDeleteFlags::CONTENTS, pRefUndoData); // Make sure it did what it's supposed to do. CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(aPos), m_pDoc->GetString(aPasteRange.aStart)); @@ -340,7 +340,7 @@ void Test::testPerf() ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aSrcRange, IDF_CONTENTS, false, pUndoDoc, &aMark); + m_pDoc->CopyToDocument(aSrcRange, InsertDeleteFlags::CONTENTS, false, pUndoDoc, &aMark); // Paste it to A3:A100001, and measure its duration. ScRange aPasteRange(0,2,0,0,100000,0); @@ -348,17 +348,17 @@ void Test::testPerf() { MeasureTimeSwitch aTime(diff); - m_pDoc->CopyFromClip(aPasteRange, aMark, IDF_CONTENTS, pUndoDoc, &aClipDoc); + m_pDoc->CopyFromClip(aPasteRange, aMark, InsertDeleteFlags::CONTENTS, pUndoDoc, &aClipDoc); } PERF_ASSERT(diff, scale, 1000.0, "Pasting A1:A2 to A3:A100001"); ScDocument* pRedoDoc = new ScDocument(SCDOCMODE_UNDO); pRedoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aPasteRange, IDF_CONTENTS, false, pRedoDoc, &aMark); + m_pDoc->CopyToDocument(aPasteRange, InsertDeleteFlags::CONTENTS, false, pRedoDoc, &aMark); // Create an undo object for this. ScRefUndoData* pRefUndoData = new ScRefUndoData(m_pDoc); - ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, IDF_CONTENTS, pRefUndoData); + ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, InsertDeleteFlags::CONTENTS, pRefUndoData); // Make sure it did what it's supposed to do. CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(aPos), m_pDoc->GetString(aPasteRange.aStart)); @@ -417,7 +417,7 @@ void Test::testPerf() ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aSrcRange, IDF_CONTENTS, false, pUndoDoc, &aMark); + m_pDoc->CopyToDocument(aSrcRange, InsertDeleteFlags::CONTENTS, false, pUndoDoc, &aMark); // Paste it to A3:A50001, and measure its duration. ScRange aPasteRange(0,2,0,0,50000,0); @@ -425,17 +425,17 @@ void Test::testPerf() { MeasureTimeSwitch aTime(diff); - m_pDoc->CopyFromClip(aPasteRange, aMark, IDF_CONTENTS, pUndoDoc, &aClipDoc); + m_pDoc->CopyFromClip(aPasteRange, aMark, InsertDeleteFlags::CONTENTS, pUndoDoc, &aClipDoc); } PERF_ASSERT(diff, scale, 2000.0, "Pasting"); ScDocument* pRedoDoc = new ScDocument(SCDOCMODE_UNDO); pRedoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aPasteRange, IDF_CONTENTS, false, pRedoDoc, &aMark); + m_pDoc->CopyToDocument(aPasteRange, InsertDeleteFlags::CONTENTS, false, pRedoDoc, &aMark); // Create an undo object for this. ScRefUndoData* pRefUndoData = new ScRefUndoData(m_pDoc); - ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, IDF_CONTENTS, pRefUndoData); + ScUndoPaste aUndo(&getDocShell(), aPasteRange, aMark, pUndoDoc, pRedoDoc, InsertDeleteFlags::CONTENTS, pRefUndoData); // Make sure it did what it's supposed to do. CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(aPasteRange.aStart)); @@ -3259,7 +3259,7 @@ void Test::testCopyPaste() std::unique_ptr<ScUndoPaste> pUndo(createUndoPaste(getDocShell(), aRange, pUndoDoc)); ScMarkData aMark; aMark.SetMarkArea(aRange); - m_pDoc->CopyFromClip(aRange, aMark, IDF_ALL, NULL, &aClipDoc); + m_pDoc->CopyFromClip(aRange, aMark, InsertDeleteFlags::ALL, NULL, &aClipDoc); //check values after copying OUString aString; @@ -3342,7 +3342,7 @@ void Test::testCopyPasteAsLink() ScMarkData aMark; aMark.SetMarkArea(aRange); // Paste range as link. - m_pDoc->CopyFromClip(aRange, aMark, IDF_CONTENTS, NULL, &aClipDoc, true, true); + m_pDoc->CopyFromClip(aRange, aMark, InsertDeleteFlags::CONTENTS, NULL, &aClipDoc, true, true); // Check pasted content to make sure they reference the correct cells. ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,1,1)); @@ -3393,13 +3393,13 @@ void Test::testCopyPasteTranspose() ::std::unique_ptr<ScDocument> pTransClip; pTransClip.reset(new ScDocument(SCDOCMODE_CLIP)); - aNewClipDoc.TransposeClip(pTransClip.get(), IDF_ALL, false); + aNewClipDoc.TransposeClip(pTransClip.get(), InsertDeleteFlags::ALL, false); ScDocument* pTransposedClip = pTransClip.release(); ScRange aDestRange = ScRange(3,1,1,3,3,1);//target: Sheet2.D2:D4 ScMarkData aMark; aMark.SetMarkArea(aDestRange); - m_pDoc->CopyFromClip(aDestRange, aMark, IDF_ALL, NULL, pTransposedClip); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, NULL, pTransposedClip); //check cell content after transposed copy/paste OUString aString = m_pDoc->GetString(3, 3, 1); @@ -3464,7 +3464,7 @@ void Test::testCopyPasteMultiRange() m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark); // Paste to D9:E11, and make sure it won't crash (rhbz#1080196). - m_pDoc->CopyMultiRangeFromClip(ScAddress(3,8,0), aMark, IDF_CONTENTS, &aClipDoc); + m_pDoc->CopyMultiRangeFromClip(ScAddress(3,8,0), aMark, InsertDeleteFlags::CONTENTS, &aClipDoc); CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(3,8,0))); CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(4,8,0))); CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,9,0))); @@ -3608,20 +3608,20 @@ void Test::testCopyPasteSkipEmpty() // Create undo document. ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aDestRange, IDF_ALL, false, pUndoDoc, &aMark); + m_pDoc->CopyToDocument(aDestRange, InsertDeleteFlags::ALL, false, pUndoDoc, &aMark); // Paste clipboard content onto A1:A5 but skip empty cells. bool bSkipEmpty = true; - m_pDoc->CopyFromClip(aDestRange, aMark, IDF_ALL, pUndoDoc, &aClipDoc, true, false, false, bSkipEmpty); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, pUndoDoc, &aClipDoc, true, false, false, bSkipEmpty); // Create redo document. ScDocument* pRedoDoc = new ScDocument(SCDOCMODE_UNDO); pRedoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aDestRange, IDF_ALL, false, pRedoDoc, &aMark); + m_pDoc->CopyToDocument(aDestRange, InsertDeleteFlags::ALL, false, pRedoDoc, &aMark); // Create an undo object for this. ScRefUndoData* pRefUndoData = new ScRefUndoData(m_pDoc); - ScUndoPaste aUndo(&getDocShell(), aDestRange, aMark, pUndoDoc, pRedoDoc, IDF_ALL, pRefUndoData); + ScUndoPaste aUndo(&getDocShell(), aDestRange, aMark, pUndoDoc, pRedoDoc, InsertDeleteFlags::ALL, pRefUndoData); // Check the content after the paste. { @@ -3686,7 +3686,7 @@ void Test::testCopyPasteSkipEmpty2() ScRange aDestRange(0,2,0,2,2,0); ScMarkData aMark; aMark.SetMarkArea(aDestRange); - m_pDoc->CopyFromClip(aDestRange, aMark, IDF_ALL, NULL, &aClipDoc, false, false, true, true); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, NULL, &aClipDoc, false, false, true, true); CPPUNIT_ASSERT_EQUAL(OUString("A"), m_pDoc->GetString(ScAddress(0,2,0))); CPPUNIT_ASSERT_MESSAGE("B3 should be empty.", m_pDoc->GetCellType(ScAddress(1,2,0)) == CELLTYPE_NONE); @@ -3737,11 +3737,11 @@ void Test::testCopyPasteSkipEmptyConditionalFormatting() // Create undo document. ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aDestRange, IDF_CONTENTS, false, pUndoDoc, &aMark); + m_pDoc->CopyToDocument(aDestRange, InsertDeleteFlags::CONTENTS, false, pUndoDoc, &aMark); // Paste clipboard content onto A1:A5 but skip empty cells. bool bSkipEmpty = true; - m_pDoc->CopyFromClip(aDestRange, aMark, IDF_CONTENTS, pUndoDoc, &aClipDoc, true, false, false, bSkipEmpty); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::CONTENTS, pUndoDoc, &aClipDoc, true, false, false, bSkipEmpty); ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0); CPPUNIT_ASSERT_EQUAL(size_t(2), pList->size()); @@ -3790,7 +3790,7 @@ void Test::testCutPasteRefUndo() pUndoDoc->InitUndo(m_pDoc, 0, 0); // Do the pasting of 12 into C2. This should update A2 to reference C2. - m_pDoc->CopyFromClip(ScAddress(2,1,0), aMark, IDF_CONTENTS, pUndoDoc, &aClipDoc); + m_pDoc->CopyFromClip(ScAddress(2,1,0), aMark, InsertDeleteFlags::CONTENTS, pUndoDoc, &aClipDoc); CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(0,1,0)); if (!checkFormula(*m_pDoc, ScAddress(0,1,0), "C2")) @@ -3800,7 +3800,7 @@ void Test::testCutPasteRefUndo() if (!checkFormula(*pUndoDoc, ScAddress(0,1,0), "B2")) CPPUNIT_FAIL("A2 in the undo document should be referencing B2."); - ScUndoPaste aUndo(&getDocShell(), ScRange(ScAddress(2,1,0)), aMark, pUndoDoc, NULL, IDF_CONTENTS, NULL, false, NULL); + ScUndoPaste aUndo(&getDocShell(), ScRange(ScAddress(2,1,0)), aMark, pUndoDoc, NULL, InsertDeleteFlags::CONTENTS, NULL, false, NULL); aUndo.Undo(); // Now A2 should be referencing B2 once again. @@ -3876,14 +3876,14 @@ void Test::testUndoCut() // Set up an undo object for cutting A1:A3. ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0 ,0); - m_pDoc->CopyToDocument(aRange, IDF_ALL, false, pUndoDoc); + m_pDoc->CopyToDocument(aRange, InsertDeleteFlags::ALL, false, pUndoDoc); CPPUNIT_ASSERT_EQUAL( 1.0, pUndoDoc->GetValue(ScAddress(0,0,0))); CPPUNIT_ASSERT_EQUAL( 10.0, pUndoDoc->GetValue(ScAddress(0,1,0))); CPPUNIT_ASSERT_EQUAL(100.0, pUndoDoc->GetValue(ScAddress(0,2,0))); ScUndoCut aUndo(&getDocShell(), aRange, aRange.aEnd, aMark, pUndoDoc); // "Cut" the selection. - m_pDoc->DeleteSelection(IDF_ALL, aMark); + m_pDoc->DeleteSelection(InsertDeleteFlags::ALL, aMark); CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(0,3,0)); // The SUM should be zero after the "cut". // Undo it, and check the result. @@ -3986,7 +3986,7 @@ void Test::testCopyPasteRelativeFormula() m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark); // Paste it to B1:B2. - InsertDeleteFlags nFlags = IDF_ALL; + InsertDeleteFlags nFlags = InsertDeleteFlags::ALL; ScRange aDestRange(1,0,0,1,1,0); aMark.SetMarkArea(aDestRange); m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, NULL, &aClipDoc); @@ -4069,7 +4069,7 @@ void Test::testCopyPasteRepeatOneFormula() m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark); // Paste it to C2:C10. - InsertDeleteFlags nFlags = IDF_CONTENTS; + InsertDeleteFlags nFlags = InsertDeleteFlags::CONTENTS; ScRange aDestRange(2,1,0,2,9,0); aMark.SetMarkArea(aDestRange); m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, NULL, &aClipDoc); @@ -4719,7 +4719,7 @@ void Test::testCopyPasteFormulasExternalDoc() ScDocument* pClipDoc = new ScDocument(SCDOCMODE_CLIP); m_pDoc->CopyToClip(aClipParam, pClipDoc, &aMark); - InsertDeleteFlags nFlags = IDF_ALL; + InsertDeleteFlags nFlags = InsertDeleteFlags::ALL; aRange = ScRange(1,1,1,1,6,1); ScMarkData aMarkData2; aMarkData2.SetMarkArea(aRange); @@ -5223,7 +5223,7 @@ void Test::testNoteCopyPaste() // Paste to B6:B8 but only cell notes. ScRange aDestRange(1,5,0,1,7,0); - m_pDoc->CopyFromClip(aDestRange, aMark, IDF_NOTE, NULL, &aClipDoc); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::NOTE, NULL, &aClipDoc); // Make sure the notes are there. pNote = m_pDoc->GetNote(ScAddress(1,5,0)); @@ -6214,8 +6214,8 @@ void Test::testDeleteContents() std::unique_ptr<ScDocument> pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); pUndoDoc->InitUndo(m_pDoc, 0, 0); - m_pDoc->CopyToDocument(aRange, IDF_CONTENTS, false, pUndoDoc.get(), &aMark); - ScUndoDeleteContents aUndo(&getDocShell(), aMark, aRange, std::move(pUndoDoc), false, IDF_CONTENTS, true); + m_pDoc->CopyToDocument(aRange, InsertDeleteFlags::CONTENTS, false, pUndoDoc.get(), &aMark); + ScUndoDeleteContents aUndo(&getDocShell(), aMark, aRange, std::move(pUndoDoc), false, InsertDeleteFlags::CONTENTS, true); clearRange(m_pDoc, aRange); CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,15,0))); // formula @@ -6822,7 +6822,7 @@ void Test::clearRange(ScDocument* pDoc, const ScRange& rRange) aMarkData.SetMarkArea(rRange); pDoc->DeleteArea( rRange.aStart.Col(), rRange.aStart.Row(), - rRange.aEnd.Col(), rRange.aEnd.Row(), aMarkData, IDF_CONTENTS); + rRange.aEnd.Col(), rRange.aEnd.Row(), aMarkData, InsertDeleteFlags::CONTENTS); } void Test::clearSheet(ScDocument* pDoc, SCTAB nTab) @@ -6843,7 +6843,7 @@ void Test::pasteFromClip(ScDocument* pDestDoc, const ScRange& rDestRange, ScDocu { ScMarkData aMark; aMark.SetMarkArea(rDestRange); - pDestDoc->CopyFromClip(rDestRange, aMark, IDF_ALL, NULL, pClipDoc); + pDestDoc->CopyFromClip(rDestRange, aMark, InsertDeleteFlags::ALL, NULL, pClipDoc); } ScUndoPaste* Test::createUndoPaste(ScDocShell& rDocSh, const ScRange& rRange, ScDocument* pUndoDoc) @@ -6854,7 +6854,7 @@ ScUndoPaste* Test::createUndoPaste(ScDocShell& rDocSh, const ScRange& rRange, Sc ScRefUndoData* pRefUndoData = new ScRefUndoData(&rDoc); return new ScUndoPaste( - &rDocSh, rRange, aMarkData, pUndoDoc, NULL, IDF_ALL, pRefUndoData, false); + &rDocSh, rRange, aMarkData, pUndoDoc, NULL, InsertDeleteFlags::ALL, pRefUndoData, false); } void Test::setExpandRefs(bool bExpand) diff --git a/sc/qa/unit/ucalc_formula.cxx b/sc/qa/unit/ucalc_formula.cxx index 1e0c06b..a8e9100 100644 --- a/sc/qa/unit/ucalc_formula.cxx +++ b/sc/qa/unit/ucalc_formula.cxx @@ -2214,7 +2214,7 @@ void Test::testFormulaRefUpdateDeleteContent() ScDocFunc& rFunc = getDocShell().GetDocFunc(); ScMarkData aMark; aMark.SetMarkArea(ScAddress(1,1,0)); - rFunc.DeleteContents(aMark, IDF_CONTENTS, true, true); + rFunc.DeleteContents(aMark, InsertDeleteFlags::CONTENTS, true, true); CPPUNIT_ASSERT_MESSAGE("B2 should be empty.", m_pDoc->GetCellType(ScAddress(1,1,0)) == CELLTYPE_NONE); CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,1,0))); diff --git a/sc/qa/unit/ucalc_sharedformula.cxx b/sc/qa/unit/ucalc_sharedformula.cxx index 3c1a0e3..63cc3b1 100644 --- a/sc/qa/unit/ucalc_sharedformula.cxx +++ b/sc/qa/unit/ucalc_sharedformula.cxx @@ -1317,7 +1317,7 @@ void Test::testSharedFormulasCopyPaste() ScRange aRange(1,0,0,1,9,0); // B1:B10 ScDocument* pUndoDoc = new ScDocument(SCDOCMODE_UNDO); pUndoDoc->InitUndo(m_pDoc, 0, 0, true, true); - m_pDoc->CopyToDocument(aRange, IDF_CONTENTS, false, pUndoDoc); + m_pDoc->CopyToDocument(aRange, InsertDeleteFlags::CONTENTS, false, pUndoDoc); std::unique_ptr<ScUndoPaste> pUndo(createUndoPaste(getDocShell(), aRange, pUndoDoc)); // First, make sure the formula cells are shared in the undo document. diff --git a/sc/source/core/data/clipcontext.cxx b/sc/source/core/data/clipcontext.cxx index 4bdb0e7..25479d5 100644 --- a/sc/source/core/data/clipcontext.cxx +++ b/sc/source/core/data/clipcontext.cxx @@ -39,10 +39,10 @@ CopyFromClipContext::CopyFromClipContext(ScDocument& rDoc, mnTabStart(-1), mnTabEnd(-1), mrDestDoc(rDoc), mpRefUndoDoc(pRefUndoDoc), mpClipDoc(pClipDoc), - mnInsertFlag(nInsertFlag), mnDeleteFlag(IDF_NONE), + mnInsertFlag(nInsertFlag), mnDeleteFlag(InsertDeleteFlags::NONE), mpCondFormatList(NULL), mbAsLink(bAsLink), mbSkipAttrForEmptyCells(bSkipAttrForEmptyCells), - mbCloneNotes (mnInsertFlag & (IDF_NOTE|IDF_ADDNOTES)), + mbCloneNotes (mnInsertFlag & (InsertDeleteFlags::NOTE|InsertDeleteFlags::ADDNOTES)), mbTableProtected(false) { } @@ -160,11 +160,11 @@ void CopyFromClipContext::setSingleCell( const ScAddress& rSrcPos, const ScColum // Check the paste flag to see whether we want to paste this cell. If the // flag says we don't want to paste this cell, we'll return with true. InsertDeleteFlags nFlags = getInsertFlag(); - bool bNumeric = (nFlags & IDF_VALUE) != IDF_NONE; - bool bDateTime = (nFlags & IDF_DATETIME) != IDF_NONE; - bool bString = (nFlags & IDF_STRING) != IDF_NONE; - bool bBoolean = (nFlags & IDF_SPECIAL_BOOLEAN) != IDF_NONE; - bool bFormula = (nFlags & IDF_FORMULA) != IDF_NONE; + bool bNumeric = (nFlags & InsertDeleteFlags::VALUE) != InsertDeleteFlags::NONE; + bool bDateTime = (nFlags & InsertDeleteFlags::DATETIME) != InsertDeleteFlags::NONE; + bool bString = (nFlags & InsertDeleteFlags::STRING) != InsertDeleteFlags::NONE; + bool bBoolean = (nFlags & InsertDeleteFlags::SPECIAL_BOOLEAN) != InsertDeleteFlags::NONE; + bool bFormula = (nFlags & InsertDeleteFlags::FORMULA) != InsertDeleteFlags::NONE; switch (rSrcCell.meType) { diff --git a/sc/source/core/data/column.cxx b/sc/source/core/data/column.cxx index 33e0a3b..7bb8d77 100644 --- a/sc/source/core/data/column.cxx +++ b/sc/source/core/data/column.cxx @@ -1226,9 +1226,9 @@ bool canCopyValue(const ScDocument& rDoc, const ScAddress& rPos, InsertDeleteFla sal_uInt32 nNumIndex = static_cast<const SfxUInt32Item*>(rDoc.GetAttr(rPos, ATTR_VALUE_FORMAT))->GetValue(); short nType = rDoc.GetFormatTable()->GetType(nNumIndex); if ((nType == css::util::NumberFormat::DATE) || (nType == css::util::NumberFormat::TIME) || (nType == css::util::NumberFormat::DATETIME)) - return ((nFlags & IDF_DATETIME) != IDF_NONE); + return ((nFlags & InsertDeleteFlags::DATETIME) != InsertDeleteFlags::NONE); - return (nFlags & IDF_VALUE) != IDF_NONE; + return (nFlags & InsertDeleteFlags::VALUE) != InsertDeleteFlags::NONE; } class CopyAsLinkHandler @@ -1310,9 +1310,9 @@ public: { size_t nRow = aNode.position + nOffset; - if (mnCopyFlags & (IDF_NOTE|IDF_ADDNOTES)) + if (mnCopyFlags & (InsertDeleteFlags::NOTE|InsertDeleteFlags::ADDNOTES)) { - bool bCloneCaption = (mnCopyFlags & IDF_NOCAPTIONS) == IDF_NONE; + bool bCloneCaption = (mnCopyFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE; duplicateNotes(nRow, nDataSize, bCloneCaption ); } @@ -1320,7 +1320,7 @@ public: { case sc::element_type_numeric: { - if ((mnCopyFlags & (IDF_DATETIME|IDF_VALUE)) == IDF_NONE) + if ((mnCopyFlags & (InsertDeleteFlags::DATETIME|InsertDeleteFlags::VALUE)) == InsertDeleteFlags::NONE) return; sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data); @@ -1342,7 +1342,7 @@ public: case sc::element_type_string: case sc::element_type_edittext: { - if (!(mnCopyFlags & IDF_STRING)) + if (!(mnCopyFlags & InsertDeleteFlags::STRING)) return; createRefBlock(aNode, nOffset, nDataSize); @@ -1350,7 +1350,7 @@ public: break; case sc::element_type_formula: { - if (!(mnCopyFlags & IDF_FORMULA)) + if (!(mnCopyFlags & InsertDeleteFlags::FORMULA)) return; createRefBlock(aNode, nOffset, nDataSize); @@ -1390,11 +1390,11 @@ class CopyByCloneHandler { ScAddress aDestPos(mrDestCol.GetCol(), nRow, mrDestCol.GetTab()); - bool bCloneValue = (mnCopyFlags & IDF_VALUE) != IDF_NONE; - bool bCloneDateTime = (mnCopyFlags & IDF_DATETIME) != IDF_NONE; - bool bCloneString = (mnCopyFlags & IDF_STRING) != IDF_NONE; - bool bCloneSpecialBoolean = (mnCopyFlags & IDF_SPECIAL_BOOLEAN) != IDF_NONE; - bool bCloneFormula = (mnCopyFlags & IDF_FORMULA) != IDF_NONE; + bool bCloneValue = (mnCopyFlags & InsertDeleteFlags::VALUE) != InsertDeleteFlags::NONE; + bool bCloneDateTime = (mnCopyFlags & InsertDeleteFlags::DATETIME) != InsertDeleteFlags::NONE; + bool bCloneString = (mnCopyFlags & InsertDeleteFlags::STRING) != InsertDeleteFlags::NONE; + bool bCloneSpecialBoolean = (mnCopyFlags & InsertDeleteFlags::SPECIAL_BOOLEAN) != InsertDeleteFlags::NONE; + bool bCloneFormula = (mnCopyFlags & InsertDeleteFlags::FORMULA) != InsertDeleteFlags::NONE; bool bForceFormula = false; @@ -1512,9 +1512,9 @@ public: { size_t nRow = aNode.position + nOffset; - if (mnCopyFlags & (IDF_NOTE|IDF_ADDNOTES)) + if (mnCopyFlags & (InsertDeleteFlags::NOTE|InsertDeleteFlags::ADDNOTES)) { - bool bCloneCaption = (mnCopyFlags & IDF_NOCAPTIONS) == IDF_NONE; + bool bCloneCaption = (mnCopyFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE; duplicateNotes(nRow, nDataSize, bCloneCaption ); } @@ -1522,7 +1522,7 @@ public: { case sc::element_type_numeric: { - if ((mnCopyFlags & (IDF_DATETIME|IDF_VALUE)) == IDF_NONE) + if ((mnCopyFlags & (InsertDeleteFlags::DATETIME|InsertDeleteFlags::VALUE)) == InsertDeleteFlags::NONE) return; sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data); @@ -1543,7 +1543,7 @@ public: break; case sc::element_type_string: { - if (!(mnCopyFlags & IDF_STRING)) + if (!(mnCopyFlags & InsertDeleteFlags::STRING)) return; sc::string_block::const_iterator it = sc::string_block::begin(*aNode.data); @@ -1583,7 +1583,7 @@ public: break; case sc::element_type_edittext: { - if (!(mnCopyFlags & IDF_STRING)) + if (!(mnCopyFlags & InsertDeleteFlags::STRING)) return; sc::edittext_block::const_iterator it = sc::edittext_block::begin(*aNode.data); @@ -1647,9 +1647,9 @@ void ScColumn::CopyToColumn( return; } - if ( (nFlags & IDF_ATTRIB) != IDF_NONE ) + if ( (nFlags & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE ) { - if ( (nFlags & IDF_STYLES) != IDF_STYLES ) + if ( (nFlags & InsertDeleteFlags::STYLES) != InsertDeleteFlags::STYLES ) { // keep the StyleSheets in the target document // e.g. DIF and RTF Clipboard-Import for ( SCROW nRow = nRow1; nRow <= nRow2; nRow++ ) @@ -1666,7 +1666,7 @@ void ScColumn::CopyToColumn( pAttrArray->CopyArea( nRow1, nRow2, 0, *rColumn.pAttrArray); } - if ((nFlags & IDF_CONTENTS) != IDF_NONE) + if ((nFlags & InsertDeleteFlags::CONTENTS) != InsertDeleteFlags::NONE) { if (bAsLink) { @@ -1696,12 +1696,12 @@ void ScColumn::UndoToColumn( ScColumn& rColumn, const ScMarkData* pMarkData ) const { if (nRow1 > 0) - CopyToColumn(rCxt, 0, nRow1-1, IDF_FORMULA, false, rColumn); + CopyToColumn(rCxt, 0, nRow1-1, InsertDeleteFlags::FORMULA, false, rColumn); CopyToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, rColumn, pMarkData); //TODO: bMarked ???? if (nRow2 < MAXROW) - CopyToColumn(rCxt, nRow2+1, MAXROW, IDF_FORMULA, false, rColumn); + CopyToColumn(rCxt, nRow2+1, MAXROW, InsertDeleteFlags::FORMULA, false, rColumn); } void ScColumn::CopyUpdated( const ScColumn& rPosCol, ScColumn& rDestCol ) const @@ -1738,10 +1738,10 @@ void ScColumn::CopyScenarioFrom( const ScColumn& rSrcCol ) { if ( static_cast<const ScMergeFlagAttr&>(pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() ) { - DeleteArea( nStart, nEnd, IDF_CONTENTS ); + DeleteArea( nStart, nEnd, InsertDeleteFlags::CONTENTS ); sc::CopyToDocContext aCxt(*pDocument); ((ScColumn&)rSrcCol). - CopyToColumn(aCxt, nStart, nEnd, IDF_CONTENTS, false, *this); + CopyToColumn(aCxt, nStart, nEnd, InsertDeleteFlags::CONTENTS, false, *this); // UpdateUsed not needed, already done in TestCopyScenario (obsolete comment ?) @@ -1769,9 +1769,9 @@ void ScColumn::CopyScenarioTo( ScColumn& rDestCol ) const { if ( static_cast<const ScMergeFlagAttr&>(pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() ) { - rDestCol.DeleteArea( nStart, nEnd, IDF_CONTENTS ); + rDestCol.DeleteArea( nStart, nEnd, InsertDeleteFlags::CONTENTS ); sc::CopyToDocContext aCxt(*rDestCol.pDocument); - CopyToColumn(aCxt, nStart, nEnd, IDF_CONTENTS, false, rDestCol); + CopyToColumn(aCxt, nStart, nEnd, InsertDeleteFlags::CONTENTS, false, rDestCol); // UpdateUsed not needed, is already done in TestCopyScenario (obsolete comment ?) diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx index c4d2e4e..065f0d5 100644 --- a/sc/source/core/data/column3.cxx +++ b/sc/source/core/data/column3.cxx @@ -545,9 +545,9 @@ class DeleteAreaHandler public: DeleteAreaHandler(ScDocument& rDoc, InsertDeleteFlags nDelFlag) : mrDoc(rDoc), - mbNumeric(nDelFlag & IDF_VALUE), - mbString(nDelFlag & IDF_STRING), - mbFormula(nDelFlag & IDF_FORMULA) {} + mbNumeric(nDelFlag & InsertDeleteFlags::VALUE), + mbString(nDelFlag & InsertDeleteFlags::STRING), + mbFormula(nDelFlag & InsertDeleteFlags::FORMULA) {} void operator() (const sc::CellStoreType::value_type& node, size_t nOffset, size_t nDataSize) { @@ -659,10 +659,10 @@ void ScColumn::DeleteArea( SCROW nStartRow, SCROW nEndRow, InsertDeleteFlags nDelFlag, bool bBroadcast, sc::ColumnSpanSet* pBroadcastSpans ) { - InsertDeleteFlags nContMask = IDF_CONTENTS; - // IDF_NOCAPTIONS needs to be passed too, if IDF_NOTE is set - if( nDelFlag & IDF_NOTE ) - nContMask |= IDF_NOCAPTIONS; + InsertDeleteFlags nContMask = InsertDeleteFlags::CONTENTS; + // InsertDeleteFlags::NOCAPTIONS needs to be passed too, if InsertDeleteFlags::NOTE is set + if( nDelFlag & InsertDeleteFlags::NOTE ) + nContMask |= InsertDeleteFlags::NOCAPTIONS; InsertDeleteFlags nContFlag = nDelFlag & nContMask; sc::SingleColumnSpanSet aDeletedRows; @@ -670,7 +670,7 @@ void ScColumn::DeleteArea( sc::ColumnBlockPosition aBlockPos; InitBlockPosition(aBlockPos); - if (!IsEmptyData() && nContFlag) + if (!IsEmptyData() && nContFlag != InsertDeleteFlags::NONE) { DeleteCells(aBlockPos, nStartRow, nEndRow, nDelFlag, aDeletedRows); if (pBroadcastSpans) @@ -683,22 +683,22 @@ void ScColumn::DeleteArea( } } - if (nDelFlag & IDF_NOTE) + if (nDelFlag & InsertDeleteFlags::NOTE) { - bool bForgetCaptionOwnership = ((nDelFlag & IDF_FORGETCAPTIONS) != IDF_NONE); + bool bForgetCaptionOwnership = ((nDelFlag & InsertDeleteFlags::FORGETCAPTIONS) != InsertDeleteFlags::NONE); DeleteCellNotes(aBlockPos, nStartRow, nEndRow, bForgetCaptionOwnership); } - if ( nDelFlag & IDF_EDITATTR ) + if ( nDelFlag & InsertDeleteFlags::EDITATTR ) { - OSL_ENSURE( nContFlag == IDF_NONE, "DeleteArea: Wrong Flags" ); + OSL_ENSURE( nContFlag == InsertDeleteFlags::NONE, "DeleteArea: Wrong Flags" ); RemoveEditAttribs( nStartRow, nEndRow ); } // Delete attributes just now - if ((nDelFlag & IDF_ATTRIB) == IDF_ATTRIB) + if ((nDelFlag & InsertDeleteFlags::ATTRIB) == InsertDeleteFlags::ATTRIB) pAttrArray->DeleteArea( nStartRow, nEndRow ); - else if ((nDelFlag & IDF_HARDATTR) == IDF_HARDATTR) + else if ((nDelFlag & InsertDeleteFlags::HARDATTR) == InsertDeleteFlags::HARDATTR) pAttrArray->DeleteHardAttr( nStartRow, nEndRow ); if (bBroadcast) @@ -818,17 +818,17 @@ public: { if (bCopyCellNotes && !mrCxt.isSkipAttrForEmptyCells()) { - bool bCloneCaption = (nFlags & IDF_NOCAPTIONS) == IDF_NONE; + bool bCloneCaption = (nFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE; duplicateNotes(nSrcRow1, nDataSize, bCloneCaption ); } return; } - bool bNumeric = (nFlags & IDF_VALUE) != IDF_NONE; - bool bDateTime = (nFlags & IDF_DATETIME) != IDF_NONE; - bool bString = (nFlags & IDF_STRING) != IDF_NONE; - bool bBoolean = (nFlags & IDF_SPECIAL_BOOLEAN) != IDF_NONE; - bool bFormula = (nFlags & IDF_FORMULA) != IDF_NONE; + bool bNumeric = (nFlags & InsertDeleteFlags::VALUE) != InsertDeleteFlags::NONE; + bool bDateTime = (nFlags & InsertDeleteFlags::DATETIME) != InsertDeleteFlags::NONE; + bool bString = (nFlags & InsertDeleteFlags::STRING) != InsertDeleteFlags::NONE; + bool bBoolean = (nFlags & InsertDeleteFlags::SPECIAL_BOOLEAN) != InsertDeleteFlags::NONE; + bool bFormula = (nFlags & InsertDeleteFlags::FORMULA) != InsertDeleteFlags::NONE; bool bAsLink = mrCxt.isAsLink(); @@ -1001,7 +1001,7 @@ public: } if (bCopyCellNotes) { - bool bCloneCaption = (nFlags & IDF_NOCAPTIONS) == IDF_NONE; + bool bCloneCaption = (nFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE; duplicateNotes(nSrcRow1, nDataSize, bCloneCaption ); } } @@ -1040,7 +1040,7 @@ public: void ScColumn::CopyFromClip( sc::CopyFromClipContext& rCxt, SCROW nRow1, SCROW nRow2, long nDy, ScColumn& rColumn ) { - if ((rCxt.getInsertFlag() & IDF_ATTRIB) != IDF_NONE) + if ((rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE) { if (rCxt.isSkipAttrForEmptyCells()) { @@ -1055,13 +1055,13 @@ void ScColumn::CopyFromClip( else rColumn.pAttrArray->CopyAreaSafe( nRow1, nRow2, nDy, *pAttrArray ); } - if ((rCxt.getInsertFlag() & IDF_CONTENTS) == IDF_NONE) + if ((rCxt.getInsertFlag() & InsertDeleteFlags::CONTENTS) == InsertDeleteFlags::NONE) return; - if (rCxt.isAsLink() && rCxt.getInsertFlag() == IDF_ALL) + if (rCxt.isAsLink() && rCxt.getInsertFlag() == InsertDeleteFlags::ALL) { // We also reference empty cells for "ALL" - // IDF_ALL must always contain more flags when compared to "Insert contents" as + // InsertDeleteFlags::ALL must always contain more flags when compared to "Insert contents" as // contents can be selected one by one! ScAddress aDestPos( nCol, 0, nTab ); // Adapt Row @@ -2353,7 +2353,7 @@ void ScColumn::RemoveProtected( SCROW nStartRow, SCROW nEndRow ) { const ScProtectionAttr* pAttr = static_cast<const ScProtectionAttr*>(&pPattern->GetItem(ATTR_PROTECTION)); if ( pAttr->GetHideCell() ) - DeleteArea( nTop, nBottom, IDF_CONTENTS ); + DeleteArea( nTop, nBottom, InsertDeleteFlags::CONTENTS ); else if ( pAttr->GetHideFormula() ) { // Replace all formula cells between nTop and nBottom with raw value cells. diff --git a/sc/source/core/data/column4.cxx b/sc/source/core/data/column4.cxx index bd7c60b..b374d52 100644 --- a/sc/source/core/data/column4.cxx +++ b/sc/source/core/data/column4.cxx @@ -104,21 +104,21 @@ void ScColumn::DeleteBeforeCopyFromClip( SCROW nRow1 = it->mnRow1; SCROW nRow2 = it->mnRow2; - if (nDelFlag & IDF_CONTENTS) + if (nDelFlag & InsertDeleteFlags::CONTENTS) { sc::SingleColumnSpanSet aDeletedRows; DeleteCells(aBlockPos, nRow1, nRow2, nDelFlag, aDeletedRows); rBroadcastSpans.set(nTab, nCol, aDeletedRows, true); } - if (nDelFlag & IDF_NOTE) + if (nDelFlag & InsertDeleteFlags::NOTE) DeleteCellNotes(aBlockPos, nRow1, nRow2, false); - if (nDelFlag & IDF_EDITATTR) + if (nDelFlag & InsertDeleteFlags::EDITATTR) RemoveEditAttribs(nRow1, nRow2); // Delete attributes just now - if (nDelFlag & IDF_ATTRIB) + if (nDelFlag & InsertDeleteFlags::ATTRIB) { pAttrArray->DeleteArea(nRow1, nRow2); @@ -133,7 +133,7 @@ void ScColumn::DeleteBeforeCopyFromClip( if (pCondList) pCondList->DeleteArea(nCol, nRow1, nCol, nRow2); } - else if ((nDelFlag & IDF_HARDATTR) == IDF_HARDATTR) + else if ((nDelFlag & InsertDeleteFlags::HARDATTR) == InsertDeleteFlags::HARDATTR) pAttrArray->DeleteHardAttr(nRow1, nRow2); } } @@ -154,7 +154,7 @@ void ScColumn::CopyOneCellFromClip( sc::CopyFromClipContext& rCxt, SCROW nRow1, InsertDeleteFlags nFlags = rCxt.getInsertFlag(); - if ((nFlags & IDF_ATTRIB) != IDF_NONE) + if ((nFlags & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE) { if (!rCxt.isSkipAttrForEmptyCells() || rSrcCell.meType != CELLTYPE_NONE) { @@ -164,7 +164,7 @@ void ScColumn::CopyOneCellFromClip( sc::CopyFromClipContext& rCxt, SCROW nRow1, } } - if ((nFlags & IDF_CONTENTS) != IDF_NONE) + if ((nFlags & InsertDeleteFlags::CONTENTS) != InsertDeleteFlags::NONE) { std::vector<sc::CellTextAttr> aTextAttrs(nDestSize, rSrcAttr); @@ -225,7 +225,7 @@ void ScColumn::CopyOneCellFromClip( sc::CopyFromClipContext& rCxt, SCROW nRow1, } const ScPostIt* pNote = rCxt.getSingleCellNote(nColOffset); - if (pNote && (nFlags & (IDF_NOTE | IDF_ADDNOTES)) != IDF_NONE) + if (pNote && (nFlags & (InsertDeleteFlags::NOTE | InsertDeleteFlags::ADDNOTES)) != InsertDeleteFlags::NONE) { // Duplicate the cell note over the whole pasted range. @@ -236,7 +236,7 @@ void ScColumn::CopyOneCellFromClip( sc::CopyFromClipContext& rCxt, SCROW nRow1, aNotes.reserve(nDestSize); for (size_t i = 0; i < nDestSize; ++i) { - bool bCloneCaption = (nFlags & IDF_NOCAPTIONS) == IDF_NONE; + bool bCloneCaption = (nFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE; aNotes.push_back(pNote->Clone(rSrcPos, *pDocument, aDestPos, bCloneCaption)); aDestPos.IncRow(); } diff --git a/sc/source/core/data/documen2.cxx b/sc/source/core/data/documen2.cxx index dbf9686..5774c33 100644 --- a/sc/source/core/data/documen2.cxx +++ b/sc/source/core/data/documen2.cxx @@ -886,7 +886,7 @@ bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyM { SetNoListening( true ); // noch nicht bei CopyToTable/Insert sc::CopyToDocContext aCopyDocCxt(*this); - maTabs[nOldPos]->CopyToTable(aCopyDocCxt, 0, 0, MAXCOL, MAXROW, IDF_ALL, (pOnlyMarked != NULL), + maTabs[nOldPos]->CopyToTable(aCopyDocCxt, 0, 0, MAXCOL, MAXROW, InsertDeleteFlags::ALL, (pOnlyMarked != NULL), maTabs[nNewPos], pOnlyMarked ); maTabs[nNewPos]->SetTabBgColor(maTabs[nOldPos]->GetTabBgColor()); @@ -965,7 +965,7 @@ sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos, { if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos]) { - maTabs[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, IDF_ALL ); + maTabs[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, InsertDeleteFlags::ALL ); } else bValid = false; @@ -991,7 +991,7 @@ sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos, { // scope for bulk broadcast ScBulkBroadcast aBulkBroadcast( pBASM); pSrcDoc->maTabs[nSrcPos]->CopyToTable(aCxt, 0, 0, MAXCOL, MAXROW, - ( bResultsOnly ? IDF_ALL & ~IDF_FORMULA : IDF_ALL), + ( bResultsOnly ? InsertDeleteFlags::ALL & ~InsertDeleteFlags::FORMULA : InsertDeleteFlags::ALL), false, maTabs[nDestPos] ); } } diff --git a/sc/source/core/data/documen3.cxx b/sc/source/core/data/documen3.cxx index e9b2f55..e939264 100644 --- a/sc/source/core/data/documen3.cxx +++ b/sc/source/core/data/documen3.cxx @@ -1988,7 +1988,7 @@ void ScDocument::DoMerge( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, ApplyFlagsTab( nStartCol+1, nStartRow+1, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER ); // Remove all covered notes (removed captions are collected by drawing undo if active) - InsertDeleteFlags nDelFlag = IDF_NOTE | (bDeleteCaptions ? IDF_NONE : IDF_NOCAPTIONS); + InsertDeleteFlags nDelFlag = InsertDeleteFlags::NOTE | (bDeleteCaptions ? InsertDeleteFlags::NONE : InsertDeleteFlags::NOCAPTIONS); if( nStartCol < nEndCol ) DeleteAreaTab( nStartCol + 1, nStartRow, nEndCol, nStartRow, nTab, nDelFlag ); if( nStartRow < nEndRow ) diff --git a/sc/source/core/data/document.cxx b/sc/source/core/data/document.cxx index 53f5b30..9786c2a 100644 --- a/sc/source/core/data/document.cxx +++ b/sc/source/core/data/document.cxx @@ -1747,7 +1747,7 @@ bool ScDocument::CanFitBlock( const ScRange& rOld, const ScRange& rNew ) void ScDocument::FitBlock( const ScRange& rOld, const ScRange& rNew, bool bClear ) { if (bClear) - DeleteAreaTab( rOld, IDF_ALL ); + DeleteAreaTab( rOld, InsertDeleteFlags::ALL ); bool bInsCol,bDelCol,bInsRow,bDelRow; ScRange aColRange,aRowRange; @@ -1787,7 +1787,7 @@ void ScDocument::DeleteArea( std::vector<ScAddress> aGroupPos; // Destroy and reconstruct listeners only if content is affected. - bool bDelContent = ((nDelFlag & ~IDF_CONTENTS) != nDelFlag); + bool bDelContent = ((nDelFlag & ~InsertDeleteFlags::CONTENTS) != nDelFlag); if (bDelContent) { // Record the positions of top and/or bottom formula groups that intersect @@ -1985,7 +1985,7 @@ void ScDocument::UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, sc::AutoCalcSwitch aACSwitch(*pDestDoc, false); // avoid multiple calculations if (nTab1 > 0) - CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, false, pDestDoc, pMarks ); + CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, InsertDeleteFlags::FORMULA, false, pDestDoc, pMarks ); sc::CopyToDocContext aCxt(*pDestDoc); OSL_ASSERT( nTab2 < static_cast<SCTAB>(maTabs.size()) && nTab2 < static_cast<SCTAB>(pDestDoc->maTabs.size())); @@ -1997,7 +1997,7 @@ void ScDocument::UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, } if (nTab2 < MAXTAB) - CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA, false, pDestDoc, pMarks ); + CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,MAXTAB, InsertDeleteFlags::FORMULA, false, pDestDoc, pMarks ); } } @@ -2045,7 +2045,7 @@ void ScDocument::UndoToDocument(const ScRange& rRange, sc::CopyToDocContext aCxt(*pDestDoc); if (nTab1 > 0) - CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, false, pDestDoc, pMarks ); + CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, InsertDeleteFlags::FORMULA, false, pDestDoc, pMarks ); SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pDestDoc->maTabs.size())); for (SCTAB i = nTab1; i <= nTab2 && i < nMinSizeBothTabs; i++) @@ -2057,7 +2057,7 @@ void ScDocument::UndoToDocument(const ScRange& rRange, } if (nTab2 < static_cast<SCTAB>(maTabs.size())) - CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,maTabs.size(), IDF_FORMULA, false, pDestDoc, pMarks ); + CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,maTabs.size(), InsertDeleteFlags::FORMULA, false, pDestDoc, pMarks ); } // bUseRangeForVBA added for VBA api support to allow content of a specified @@ -2268,7 +2268,7 @@ void ScDocument::TransposeClip( ScDocument* pTransClip, InsertDeleteFlags nFlags aClipRange.aEnd.Col(), aClipRange.aEnd.Row(), pTransClip->maTabs[i], nFlags, bAsLink ); - if ( pDrawLayer && ( nFlags & IDF_OBJECTS ) ) + if ( pDrawLayer && ( nFlags & InsertDeleteFlags::OBJECTS ) ) { // Drawing objects are copied to the new area without transposing. // CopyFromClip is used to adjust the objects to the transposed block's @@ -2466,7 +2466,7 @@ void ScDocument::StartListeningFromClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark, InsertDeleteFlags nInsFlag ) { - if (nInsFlag & IDF_CONTENTS) + if (nInsFlag & InsertDeleteFlags::CONTENTS) { std::shared_ptr<sc::ColumnBlockPositionSet> pSet( new sc::ColumnBlockPositionSet(*this)); @@ -2486,7 +2486,7 @@ void ScDocument::SetDirtyFromClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark, InsertDeleteFlags nInsFlag, sc::ColumnSpanSet& rBroadcastSpans ) { - if (nInsFlag & IDF_CONTENTS) + if (nInsFlag & InsertDeleteFlags::CONTENTS) { SCTAB nMax = static_cast<SCTAB>(maTabs.size()); ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end(); @@ -2520,7 +2520,7 @@ void ScDocument::CopyBlockFromClip( maTabs[i]->CopyFromClip( rCxt, nCol1, nRow1, nCol2, nRow2, nDx, nDy, rClipTabs[nClipTab]); - if (rCxt.getClipDoc()->pDrawLayer && (rCxt.getInsertFlag() & IDF_OBJECTS)) + if (rCxt.getClipDoc()->pDrawLayer && (rCxt.getInsertFlag() & InsertDeleteFlags::OBJECTS)) { // also copy drawing objects @@ -2544,7 +2544,7 @@ void ScDocument::CopyBlockFromClip( nClipTab = (nClipTab+1) % (static_cast<SCTAB>(rClipTabs.size())); } } - if (rCxt.getInsertFlag() & IDF_CONTENTS) + if (rCxt.getInsertFlag() & InsertDeleteFlags::CONTENTS) { nClipTab = 0; for (SCTAB i = rCxt.getTabStart(); i <= nTabEnd && i < static_cast<SCTAB>(maTabs.size()); i++) @@ -2726,18 +2726,18 @@ void ScDocument::CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMar /* Decide which contents to delete before copying. Delete all contents if nInsFlag contains any real content flag. #i102056# Notes are pasted from clipboard in a second pass, - together with the special flag IDF_ADDNOTES that states to not + together with the special flag InsertDeleteFlags::ADDNOTES that states to not overwrite/delete existing cells but to insert the notes into these cells. In this case, just delete old notes from the destination area. */ - InsertDeleteFlags nDelFlag = IDF_NONE; - if ( (nInsFlag & (IDF_CONTENTS | IDF_ADDNOTES)) == (IDF_NOTE | IDF_ADDNOTES) ) - nDelFlag |= IDF_NOTE; - else if ( nInsFlag & IDF_CONTENTS ) - nDelFlag |= IDF_CONTENTS; + InsertDeleteFlags nDelFlag = InsertDeleteFlags::NONE; + if ( (nInsFlag & (InsertDeleteFlags::CONTENTS | InsertDeleteFlags::ADDNOTES)) == (InsertDeleteFlags::NOTE | InsertDeleteFlags::ADDNOTES) ) + nDelFlag |= InsertDeleteFlags::NOTE; + else if ( nInsFlag & InsertDeleteFlags::CONTENTS ) + nDelFlag |= InsertDeleteFlags::CONTENTS; - if (nInsFlag & IDF_ATTRIB) - nDelFlag |= IDF_ATTRIB; + if (nInsFlag & InsertDeleteFlags::ATTRIB) + nDelFlag |= InsertDeleteFlags::ATTRIB; sc::CopyFromClipContext aCxt(*this, pRefUndoDoc, pClipDoc, nInsFlag, bAsLink, bSkipAttrForEmpty); std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(maTabs, rMark); @@ -2788,7 +2788,7 @@ void ScDocument::CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMar nR2 = nRow2; const SCCOLROW nThreshold = 8192; - bool bPreallocatePattern = ((nInsFlag & IDF_ATTRIB) && (nRow2 - nRow1 > nThreshold)); + bool bPreallocatePattern = ((nInsFlag & InsertDeleteFlags::ATTRIB) && (nRow2 - nRow1 > nThreshold)); std::vector< SCTAB > vTables; if (bPreallocatePattern) @@ -2918,7 +2918,7 @@ void ScDocument::CopyMultiRangeFromClip( if (!bSkipAttrForEmpty) { // Do the deletion first. - InsertDeleteFlags nDelFlag = IDF_CONTENTS; + InsertDeleteFlags nDelFlag = InsertDeleteFlags::CONTENTS; SCCOL nColSize = rClipParam.getPasteColSize(); SCROW nRowSize = rClipParam.getPasteRowSize(); @@ -3107,8 +3107,8 @@ void ScDocument::FillTab( const ScRange& rSrcArea, const ScMarkData& rMark, bool bSkipEmpty, bool bAsLink ) { InsertDeleteFlags nDelFlags = nFlags; - if (nDelFlags & IDF_CONTENTS) - nDelFlags |= IDF_CONTENTS; // Either all contents or delete nothing! + if (nDelFlags & InsertDeleteFlags::CONTENTS) + nDelFlags |= InsertDeleteFlags::CONTENTS; // Either all contents or delete nothing! SCTAB nSrcTab = rSrcArea.aStart.Tab(); @@ -3119,7 +3119,7 @@ void ScDocument::FillTab( const ScRange& rSrcArea, const ScMarkData& rMark, SCCOL nEndCol = rSrcArea.aEnd.Col(); SCROW nEndRow = rSrcArea.aEnd.Row(); std::unique_ptr<ScDocument> pMixDoc; - bool bDoMix = ( bSkipEmpty || nFunction != ScPasteFunc::NONE ) && ( nFlags & IDF_CONTENTS ); + bool bDoMix = ( bSkipEmpty || nFunction != ScPasteFunc::NONE ) && ( nFlags & InsertDeleteFlags::CONTENTS ); bool bOldAutoCalc = GetAutoCalc(); SetAutoCalc( false ); // avoid multiple calculations @@ -3146,7 +3146,7 @@ void ScDocument::FillTab( const ScRange& rSrcArea, const ScMarkData& rMark, // context used for copying content to the temporary mix document. sc::CopyToDocContext aMixCxt(*pMixDoc); maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow, - IDF_CONTENTS, false, pMixDoc->maTabs[i] ); + InsertDeleteFlags::CONTENTS, false, pMixDoc->maTabs[i] ); } maTabs[i]->DeleteArea( nStartCol,nStartRow, nEndCol,nEndRow, nDelFlags); maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow, @@ -3170,13 +3170,13 @@ void ScDocument::FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark, bool bSkipEmpty, bool bAsLink ) { InsertDeleteFlags nDelFlags = nFlags; - if (nDelFlags & IDF_CONTENTS) - nDelFlags |= IDF_CONTENTS; // Either all contents or delete nothing! + if (nDelFlags & InsertDeleteFlags::CONTENTS) + nDelFlags |= InsertDeleteFlags::CONTENTS; // Either all contents or delete nothing! if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nSrcTab]) { std::unique_ptr<ScDocument> pMixDoc; - bool bDoMix = ( bSkipEmpty || nFunction != ScPasteFunc::NONE ) && ( nFlags & IDF_CONTENTS ); + bool bDoMix = ( bSkipEmpty || nFunction != ScPasteFunc::NONE ) && ( nFlags & InsertDeleteFlags::CONTENTS ); bool bOldAutoCalc = GetAutoCalc(); SetAutoCalc( false ); // avoid multiple calculations @@ -3208,7 +3208,7 @@ void ScDocument::FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark, sc::CopyToDocContext aMixCxt(*pMixDoc); maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow, - IDF_CONTENTS, true, pMixDoc->maTabs[i], &rMark ); + InsertDeleteFlags::CONTENTS, true, pMixDoc->maTabs[i], &rMark ); } maTabs[i]->DeleteSelection( nDelFlags, rMark ); @@ -5663,7 +5663,7 @@ void ScDocument::DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& std::vector<ScAddress> aGroupPos; // Destroy and reconstruct listeners only if content is affected. - bool bDelContent = ((nDelFlag & ~IDF_CONTENTS) != nDelFlag); + bool bDelContent = ((nDelFlag & ~InsertDeleteFlags::CONTENTS) != nDelFlag); if (bDelContent) { // Record the positions of top and/or bottom formula groups that @@ -5703,7 +5703,7 @@ void ScDocument::DeleteSelectionTab( std::vector<ScAddress> aGroupPos; // Destroy and reconstruct listeners only if content is affected. - bool bDelContent = ((nDelFlag & ~IDF_CONTENTS) != nDelFlag); + bool bDelContent = ((nDelFlag & ~InsertDeleteFlags::CONTENTS) != nDelFlag); if (bDelContent) { // Record the positions of top and/or bottom formula groups that diff --git a/sc/source/core/data/document10.cxx b/sc/source/core/data/document10.cxx index dd3572c..d520a0f 100644 --- a/sc/source/core/data/document10.cxx +++ b/sc/source/core/data/document10.cxx @@ -103,7 +103,7 @@ bool ScDocument::CopyOneCellFromClip( const ScPatternAttr* pAttr = pClipDoc->GetPattern(aSrcPos); rCxt.setSingleCellPattern(nColOffset, pAttr); - if ((rCxt.getInsertFlag() & (IDF_NOTE | IDF_ADDNOTES)) != IDF_NONE) + if ((rCxt.getInsertFlag() & (InsertDeleteFlags::NOTE | InsertDeleteFlags::ADDNOTES)) != InsertDeleteFlags::NONE) rCxt.setSingleCellNote(nColOffset, pClipDoc->GetNote(aSrcPos)); ScColumn& rSrcCol = pSrcTab->aCol[aSrcPos.Col()]; @@ -118,7 +118,7 @@ bool ScDocument::CopyOneCellFromClip( for (SCTAB i = rCxt.getTabStart(); i <= nTabEnd && i < static_cast<SCTAB>(maTabs.size()); ++i) { maTabs[i]->CopyOneCellFromClip(rCxt, nCol1, nRow1, nCol2, nRow2); - if (rCxt.getInsertFlag() & IDF_ATTRIB) + if (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow) { maTabs[i]->CopyConditionalFormat(nCol1, nRow, nCol2, nRow, nCol1 - aClipRange.aStart.Col(), diff --git a/sc/source/core/data/dpobject.cxx b/sc/source/core/data/dpobject.cxx index 316a878..0ba7b27 100644 --- a/sc/source/core/data/dpobject.cxx +++ b/sc/source/core/data/dpobject.cxx @@ -909,7 +909,7 @@ void ScDPObject::Output( const ScAddress& rPos ) // clear old output area pDoc->DeleteAreaTab( aOutRange.aStart.Col(), aOutRange.aStart.Row(), aOutRange.aEnd.Col(), aOutRange.aEnd.Row(), - aOutRange.aStart.Tab(), IDF_ALL ); + aOutRange.aStart.Tab(), InsertDeleteFlags::ALL ); pDoc->RemoveFlagsTab( aOutRange.aStart.Col(), aOutRange.aStart.Row(), aOutRange.aEnd.Col(), aOutRange.aEnd.Row(), aOutRange.aStart.Tab(), SC_MF_AUTO ); diff --git a/sc/source/core/data/dpoutput.cxx b/sc/source/core/data/dpoutput.cxx index a2c13f8..a277ab5 100644 --- a/sc/source/core/data/dpoutput.cxx +++ b/sc/source/core/data/dpoutput.cxx @@ -978,8 +978,8 @@ void ScDPOutput::Output() // clear whole (new) output area // when modifying table, clear old area ! - //TODO: include IDF_OBJECTS ??? - pDoc->DeleteAreaTab( aStartPos.Col(), aStartPos.Row(), nTabEndCol, nTabEndRow, nTab, IDF_ALL ); + //TODO: include InsertDeleteFlags::OBJECTS ??? + pDoc->DeleteAreaTab( aStartPos.Col(), aStartPos.Row(), nTabEndCol, nTabEndRow, nTab, InsertDeleteFlags::ALL ); if ( bDoFilter ) lcl_DoFilterButton( pDoc, aStartPos.Col(), aStartPos.Row(), nTab ); diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx index b4f143e..38208ec 100644 --- a/sc/source/core/data/table2.cxx +++ b/sc/source/core/data/table2.cxx @@ -334,7 +334,7 @@ void ScTable::InsertCol( sc::CopyToDocContext aCxt(*pDocument); for (SCSIZE i=0; i<nSize; i++) { - aCol[nStartCol-1].CopyToColumn(aCxt, nStartRow, nEndRow, IDF_ATTRIB, + aCol[nStartCol-1].CopyToColumn(aCxt, nStartRow, nEndRow, InsertDeleteFlags::ATTRIB, false, aCol[nStartCol+i] ); aCol[nStartCol+i].RemoveFlags( nStartRow, nEndRow, SC_MF_HOR | SC_MF_VER | SC_MF_AUTO ); @@ -394,7 +394,7 @@ void ScTable::DeleteCol( } for (SCSIZE i = 0; i < nSize; i++) - aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, IDF_ALL, false); + aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, InsertDeleteFlags::ALL, false); if ((nStartRow == 0) && (nEndRow == MAXROW)) { @@ -436,14 +436,14 @@ void ScTable::DeleteArea( // Do not set protected cell in a protected table - if ( IsProtected() && (nDelFlag & IDF_ATTRIB) ) + if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) ) { ScPatternAttr aPattern(pDocument->GetPool()); aPattern.GetItemSet().Put( ScProtectionAttr( false ) ); ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern ); } - if( nDelFlag & IDF_ATTRIB ) + if( nDelFlag & InsertDeleteFlags::ATTRIB ) mpCondFormatList->DeleteArea( nCol1, nRow1, nCol2, nRow2 ); } @@ -468,13 +468,13 @@ void ScTable::DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMa { ScRange* pRange = aRangeList[i]; - if((nDelFlag & IDF_ATTRIB) && pRange && pRange->aStart.Tab() == nTab) + if((nDelFlag & InsertDeleteFlags::ATTRIB) && pRange && pRange->aStart.Tab() == nTab) mpCondFormatList->DeleteArea( pRange->aStart.Col(), pRange->aStart.Row(), pRange->aEnd.Col(), pRange->aEnd.Row() ); } // Do not set protected cell in a protected sheet - if ( IsProtected() && (nDelFlag & IDF_ATTRIB) ) + if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) ) { ScDocumentPool* pPool = pDocument->GetPool(); SfxItemSet aSet( *pPool, ATTR_PATTERN_START, ATTR_PATTERN_END ); @@ -659,7 +659,7 @@ void ScTable::CopyFromClip( for ( SCCOL i = nCol1; i <= nCol2; i++) aCol[i].CopyFromClip(rCxt, nRow1, nRow2, nDy, pTable->aCol[i - nDx]); // notes are handles at column level - if (rCxt.getInsertFlag() & IDF_ATTRIB) + if (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) { // make sure that there are no old references to the cond formats sal_uInt16 nWhichArray[2]; @@ -669,7 +669,7 @@ void ScTable::CopyFromClip( aCol[i].ClearItems(nRow1, nRow2, nWhichArray); } - if ((rCxt.getInsertFlag() & IDF_ATTRIB) != IDF_NONE) + if ((rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE) { if (nRow1==0 && nRow2==MAXROW && pColWidth && pTable->pColWidth) for (SCCOL i=nCol1; i<=nCol2; i++) @@ -690,7 +690,7 @@ void ScTable::CopyFromClip( } // Do not set protected cell in a protected sheet - if (IsProtected() && (rCxt.getInsertFlag() & IDF_ATTRIB)) + if (IsProtected() && (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB)) { ScPatternAttr aPattern(pDocument->GetPool()); aPattern.GetItemSet().Put( ScProtectionAttr( false ) ); @@ -831,9 +831,9 @@ void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, for (SCCOL nCol=nCol1; nCol<=nCol2; nCol++) { SCROW nRow; - if ( bAsLink && nFlags == IDF_ALL ) + if ( bAsLink && nFlags == InsertDeleteFlags::ALL ) { - // with IDF_ALL, also create links (formulas) for empty cells + // with InsertDeleteFlags::ALL, also create links (formulas) for empty cells for ( nRow=nRow1; nRow<=nRow2; nRow++ ) { @@ -1080,7 +1080,7 @@ void ScTable::CopyToTable( if (!ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2)) return; - if (nFlags) + if (nFlags != InsertDeleteFlags::NONE) for (SCCOL i = nCol1; i <= nCol2; i++) aCol[i].CopyToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, pDestTab->aCol[i], pMarkData, bAsLink); @@ -1088,7 +1088,7 @@ void ScTable::CopyToTable( if (!bColRowFlags) // Column widths/Row heights/Flags return; - if(pDestTab->pDocument->IsUndo() && (nFlags & IDF_ATTRIB)) + if(pDestTab->pDocument->IsUndo() && (nFlags & InsertDeleteFlags::ATTRIB)) { pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList)); } @@ -1182,13 +1182,13 @@ void ScTable::CopyToTable( if (bFlagChange) pDestTab->InvalidatePageBreaks(); - if(nFlags & IDF_ATTRIB) + if(nFlags & InsertDeleteFlags::ATTRIB) { pDestTab->mpCondFormatList->DeleteArea(nCol1, nRow1, nCol2, nRow2); pDestTab->CopyConditionalFormat(nCol1, nRow1, nCol2, nRow2, 0, 0, this); } - if(nFlags & IDF_OUTLINE) // also only when bColRowFlags + if(nFlags & InsertDeleteFlags::OUTLINE) // also only when bColRowFlags pDestTab->SetOutlineTable( pOutlineTable ); } @@ -1206,10 +1206,10 @@ void ScTable::UndoToTable( if ( i >= nCol1 && i <= nCol2 ) aCol[i].UndoToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, pDestTab->aCol[i], pMarkData); else - aCol[i].CopyToColumn(rCxt, 0, MAXROW, IDF_FORMULA, false, pDestTab->aCol[i]); + aCol[i].CopyToColumn(rCxt, 0, MAXROW, InsertDeleteFlags::FORMULA, false, pDestTab->aCol[i]); } - if (nFlags & IDF_ATTRIB) + if (nFlags & InsertDeleteFlags::ATTRIB) pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList)); if (bWidth||bHeight) diff --git a/sc/source/core/data/table4.cxx b/sc/source/core/data/table4.cxx index ee1a29a..b8f3a95 100644 --- a/sc/source/core/data/table4.cxx +++ b/sc/source/core/data/table4.cxx @@ -545,9 +545,9 @@ void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, if (!bHasFiltered) { if (bVertical) - DeleteArea(nCol1, static_cast<SCROW>(nIMin), nCol2, static_cast<SCROW>(nIMax), IDF_AUTOFILL); + DeleteArea(nCol1, static_cast<SCROW>(nIMin), nCol2, static_cast<SCROW>(nIMax), InsertDeleteFlags::AUTOFILL); else - DeleteArea(static_cast<SCCOL>(nIMin), nRow1, static_cast<SCCOL>(nIMax), nRow2, IDF_AUTOFILL); + DeleteArea(static_cast<SCCOL>(nIMin), nRow1, static_cast<SCCOL>(nIMax), nRow2, InsertDeleteFlags::AUTOFILL); } sal_uLong nProgress = 0; @@ -632,7 +632,7 @@ void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, if ( bHasFiltered ) DeleteArea(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), - static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), IDF_AUTOFILL); + static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), InsertDeleteFlags::AUTOFILL); if ( pSrcPattern != aCol[nCol].GetPattern( static_cast<SCROW>(nRow) ) ) { @@ -1175,7 +1175,7 @@ void ScTable::FillFormulaVertical( if (aSpans.empty()) return; - aCol[nCol].DeleteRanges(aSpans, IDF_VALUE | IDF_DATETIME | IDF_STRING | IDF_FORMULA | IDF_OUTLINE, false); + aCol[nCol].DeleteRanges(aSpans, InsertDeleteFlags::VALUE | InsertDeleteFlags::DATETIME | InsertDeleteFlags::STRING | InsertDeleteFlags::FORMULA | InsertDeleteFlags::OUTLINE, false); aCol[nCol].CloneFormulaCell(rSrcCell, sc::CellTextAttr(), aSpans, NULL); std::shared_ptr<sc::ColumnBlockPositionSet> pSet(new sc::ColumnBlockPositionSet(*pDocument)); @@ -1528,7 +1528,7 @@ void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCCOLROW nIMin = nIStart; SCCOLROW nIMax = nIEnd; PutInOrder(nIMin,nIMax); - InsertDeleteFlags nDel = bAttribs ? IDF_AUTOFILL : (IDF_AUTOFILL & IDF_CONTENTS); + InsertDeleteFlags nDel = bAttribs ? InsertDeleteFlags::AUTOFILL : (InsertDeleteFlags::AUTOFILL & InsertDeleteFlags::CONTENTS); bool bIsFiltered = IsDataFiltered(aFillRange); if (!bIsFiltered) diff --git a/sc/source/core/data/table6.cxx b/sc/source/core/data/table6.cxx index 859b1b1..4fb4216 100644 --- a/sc/source/core/data/table6.cxx +++ b/sc/source/core/data/table6.cxx @@ -686,7 +686,7 @@ bool ScTable::ReplaceAllStyle( { if (pUndoDoc) pDocument->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, - IDF_ATTRIB, true, pUndoDoc, &rMark ); + InsertDeleteFlags::ATTRIB, true, pUndoDoc, &rMark ); ApplySelectionStyle( *pReplaceStyle, rMark ); } else diff --git a/sc/source/core/tool/chgtrack.cxx b/sc/source/core/tool/chgtrack.cxx index 381e0ab..53129011 100644 --- a/sc/source/core/tool/chgtrack.cxx +++ b/sc/source/core/tool/chgtrack.cxx @@ -1247,8 +1247,8 @@ bool ScChangeActionMove::Reject( ScDocument* pDoc ) pTrack->LookUpContents( aToRange, pDoc, 0, 0, 0 ); // Contents to be moved - pDoc->DeleteAreaTab( aToRange, IDF_ALL ); - pDoc->DeleteAreaTab( aFrmRange, IDF_ALL ); + pDoc->DeleteAreaTab( aToRange, InsertDeleteFlags::ALL ); + pDoc->DeleteAreaTab( aFrmRange, InsertDeleteFlags::ALL ); // Adjust formula in the Document sc::RefUpdateContext aCxt(*pDoc); aCxt.meMode = URM_MOVE; diff --git a/sc/source/ui/app/transobj.cxx b/sc/source/ui/app/transobj.cxx index 017d68b..1154c66 100644 --- a/sc/source/ui/app/transobj.cxx +++ b/sc/source/ui/app/transobj.cxx @@ -498,7 +498,7 @@ void ScTransferObj::DragFinished( sal_Int8 nDropAction ) ScMarkData aMarkData = GetSourceMarkData(); // external drag&drop doesn't copy objects, so they also aren't deleted: // bApi=TRUE, don't show error messages from drag&drop - pSourceSh->GetDocFunc().DeleteContents( aMarkData, IDF_ALL & ~IDF_OBJECTS, true, true ); + pSourceSh->GetDocFunc().DeleteContents( aMarkData, InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS, true, true ); } } @@ -646,7 +646,7 @@ void ScTransferObj::InitDocShell(bool bLimitToPageSize) bool bWasCut = pDoc->IsCutMode(); if (!bWasCut) pDoc->SetClipArea( aDestRange, true ); // Cut - rDestDoc.CopyFromClip( aDestRange, aDestMark, IDF_ALL, NULL, pDoc, false ); + rDestDoc.CopyFromClip( aDestRange, aDestMark, InsertDeleteFlags::ALL, NULL, pDoc, false ); pDoc->SetClipArea( aDestRange, bWasCut ); StripRefs( pDoc, nStartX,nStartY, nEndX,nEndY, &rDestDoc ); diff --git a/sc/source/ui/attrdlg/scdlgfact.hxx b/sc/source/ui/attrdlg/scdlgfact.hxx index 5932e94..491514e 100644 --- a/sc/source/ui/attrdlg/scdlgfact.hxx +++ b/sc/source/ui/attrdlg/scdlgfact.hxx @@ -426,7 +426,7 @@ public: ScTabViewShell* pTabViewShell) override; virtual AbstractScDeleteContentsDlg * CreateScDeleteContentsDlg(vcl::Window* pParent, - InsertDeleteFlags nCheckDefaults = IDF_NONE) override; + InsertDeleteFlags nCheckDefaults = InsertDeleteFlags::NONE) override; virtual AbstractScFillSeriesDlg * CreateScFillSeriesDlg( vcl::Window* pParent, ScDocument& rDocument, @@ -446,7 +446,7 @@ public: bool bDisallowCellMove = false ) override; virtual AbstractScInsertContentsDlg * CreateScInsertContentsDlg( vcl::Window* pParent, - InsertDeleteFlags nCheckDefaults = IDF_NONE, + InsertDeleteFlags nCheckDefaults = InsertDeleteFlags::NONE, const OUString* pStrTitle = NULL ) override; virtual AbstractScInsertTableDlg * CreateScInsertTableDlg(vcl::Window* pParent, ScViewData& rViewData, diff --git a/sc/source/ui/docshell/arealink.cxx b/sc/source/ui/docshell/arealink.cxx index 016cd79..314181a 100644 --- a/sc/source/ui/docshell/arealink.cxx +++ b/sc/source/ui/docshell/arealink.cxx @@ -334,16 +334,16 @@ bool ScAreaLink::Refresh( const OUString& rNewFile, const OUString& rNewFilter, { pUndoDoc->InitUndo( &rDoc, 0, rDoc.GetTableCount()-1 ); rDoc.CopyToDocument( 0,0,0,MAXCOL,MAXROW,MAXTAB, - IDF_FORMULA, false, pUndoDoc ); // alle Formeln + InsertDeleteFlags::FORMULA, false, pUndoDoc ); // alle Formeln } else pUndoDoc->InitUndo( &rDoc, nDestTab, nDestTab ); // nur Zieltabelle - rDoc.CopyToDocument( aOldRange, IDF_ALL & ~IDF_NOTE, false, pUndoDoc ); + rDoc.CopyToDocument( aOldRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, pUndoDoc ); } else // ohne Einfuegen { pUndoDoc->InitUndo( &rDoc, nDestTab, nDestTab ); // nur Zieltabelle - rDoc.CopyToDocument( aMaxRange, IDF_ALL & ~IDF_NOTE, false, pUndoDoc ); + rDoc.CopyToDocument( aMaxRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, pUndoDoc ); } } @@ -353,7 +353,7 @@ bool ScAreaLink::Refresh( const OUString& rNewFile, const OUString& rNewFilter, if (bDoInsert) rDoc.FitBlock( aOldRange, aNewRange ); // incl. loeschen else - rDoc.DeleteAreaTab( aMaxRange, IDF_ALL & ~IDF_NOTE ); + rDoc.DeleteAreaTab( aMaxRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE ); // Daten kopieren @@ -392,7 +392,7 @@ bool ScAreaLink::Refresh( const OUString& rNewFile, const OUString& rNewFilter, ScMarkData aDestMark; aDestMark.SelectOneTable( nDestTab ); aDestMark.SetMarkArea( aNewTokenRange ); - rDoc.CopyFromClip( aNewTokenRange, aDestMark, IDF_ALL, NULL, &aClipDoc, false ); + rDoc.CopyFromClip( aNewTokenRange, aDestMark, InsertDeleteFlags::ALL, NULL, &aClipDoc, false ); aNewTokenRange.aStart.SetRow( aNewTokenRange.aEnd.Row() + 2 ); } } @@ -409,7 +409,7 @@ bool ScAreaLink::Refresh( const OUString& rNewFile, const OUString& rNewFilter, { ScDocument* pRedoDoc = new ScDocument( SCDOCMODE_UNDO ); pRedoDoc->InitUndo( &rDoc, nDestTab, nDestTab ); - rDoc.CopyToDocument( aNewRange, IDF_ALL & ~IDF_NOTE, false, pRedoDoc ); + rDoc.CopyToDocument( aNewRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, pRedoDoc ); pImpl->m_pDocSh->GetUndoManager()->AddUndoAction( new ScUndoUpdateAreaLink( pImpl->m_pDocSh, diff --git a/sc/source/ui/docshell/dbdocfun.cxx b/sc/source/ui/docshell/dbdocfun.cxx index 2d762ea..9b26bad 100644 --- a/sc/source/ui/docshell/dbdocfun.cxx +++ b/sc/source/ui/docshell/dbdocfun.cxx @@ -363,19 +363,19 @@ bool ScDBDocFunc::RepeatDB( const OUString& rDBName, bool bRecord, bool bApi, bo pUndoDoc->InitUndo( &rDoc, nTab, nTab, true, true ); rDoc.CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, - IDF_NONE, false, pUndoDoc ); + InsertDeleteFlags::NONE, false, pUndoDoc ); rDoc.CopyToDocument( 0, static_cast<SCROW>(nOutStartRow), nTab, MAXCOL, static_cast<SCROW>(nOutEndRow), nTab, - IDF_NONE, false, pUndoDoc ); + InsertDeleteFlags::NONE, false, pUndoDoc ); } else pUndoDoc->InitUndo( &rDoc, nTab, nTab, false, true ); // Datenbereich sichern - incl. Filter-Ergebnis - rDoc.CopyToDocument( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab, IDF_ALL, false, pUndoDoc ); + rDoc.CopyToDocument( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab, InsertDeleteFlags::ALL, false, pUndoDoc ); // alle Formeln wegen Referenzen - rDoc.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, IDF_FORMULA, false, pUndoDoc ); + rDoc.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, InsertDeleteFlags::FORMULA, false, pUndoDoc ); // DB- und andere Bereiche ScRangeName* pDocRange = rDoc.GetRangeName(); @@ -737,12 +737,12 @@ bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam, pUndoDoc->InitUndo( &rDoc, nDestTab, nDestTab, false, true ); rDoc.CopyToDocument( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab, aLocalParam.nCol2, aLocalParam.nRow2, nDestTab, - IDF_ALL, false, pUndoDoc ); + InsertDeleteFlags::ALL, false, pUndoDoc ); // Attribute sichern, falls beim Filtern mitkopiert if (pDestData) { - rDoc.CopyToDocument( aOldDest, IDF_ALL, false, pUndoDoc ); + rDoc.CopyToDocument( aOldDest, InsertDeleteFlags::ALL, false, pUndoDoc ); pOld = &aOldDest; } } @@ -750,7 +750,7 @@ bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam, { pUndoDoc->InitUndo( &rDoc, nTab, nTab, false, true ); rDoc.CopyToDocument( 0, rQueryParam.nRow1, nTab, MAXCOL, rQueryParam.nRow2, nTab, - IDF_NONE, false, pUndoDoc ); + InsertDeleteFlags::NONE, false, pUndoDoc ); } ScDBCollection* pDocDB = rDoc.GetDBCollection(); @@ -778,13 +778,13 @@ bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam, pAttribDoc = new ScDocument( SCDOCMODE_UNDO ); pAttribDoc->InitUndo( &rDoc, nDestTab, nDestTab, false, true ); - rDoc.CopyToDocument( aAttribRange, IDF_ATTRIB, false, pAttribDoc ); + rDoc.CopyToDocument( aAttribRange, InsertDeleteFlags::ATTRIB, false, pAttribDoc ); } if ( bDoSize ) rDoc.FitBlock( aOldDest, aDestTotal ); else - rDoc.DeleteAreaTab(aOldDest, IDF_ALL); // einfach loeschen + rDoc.DeleteAreaTab(aOldDest, InsertDeleteFlags::ALL); // einfach loeschen } // Filtern am Dokument ausfuehren @@ -838,7 +838,7 @@ bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam, { ScRange aHdrRange = aAttribRange; aHdrRange.aEnd.SetRow( aHdrRange.aStart.Row() ); - pAttribDoc->CopyToDocument( aHdrRange, IDF_ATTRIB, false, &rDoc ); + pAttribDoc->CopyToDocument( aHdrRange, InsertDeleteFlags::ATTRIB, false, &rDoc ); } // Daten @@ -1026,19 +1026,19 @@ bool ScDBDocFunc::DoSubTotals( SCTAB nTab, const ScSubTotalParam& rParam, pTable->GetRowArray().GetRange( nOutStartRow, nOutEndRow ); pUndoDoc->InitUndo( &rDoc, nTab, nTab, true, true ); - rDoc.CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, false, pUndoDoc ); - rDoc.CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, false, pUndoDoc ); + rDoc.CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, InsertDeleteFlags::NONE, false, pUndoDoc ); + rDoc.CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, InsertDeleteFlags::NONE, false, pUndoDoc ); } else pUndoDoc->InitUndo( &rDoc, nTab, nTab, false, bOldFilter ); // Datenbereich sichern - incl. Filter-Ergebnis rDoc.CopyToDocument( 0,rParam.nRow1+1,nTab, MAXCOL,rParam.nRow2,nTab, - IDF_ALL, false, pUndoDoc ); + InsertDeleteFlags::ALL, false, pUndoDoc ); // alle Formeln wegen Referenzen rDoc.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, - IDF_FORMULA, false, pUndoDoc ); + InsertDeleteFlags::FORMULA, false, pUndoDoc ); // DB- und andere Bereiche ScRangeName* pDocRange = rDoc.GetRangeName(); @@ -1161,7 +1161,7 @@ void createUndoDoc(std::unique_ptr<ScDocument>& pUndoDoc, ScDocument* pDoc, cons SCTAB nTab = rRange.aStart.Tab(); pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO)); pUndoDoc->InitUndo(pDoc, nTab, nTab); - pDoc->CopyToDocument(rRange, IDF_ALL, false, pUndoDoc.get()); + pDoc->CopyToDocument(rRange, InsertDeleteFlags::ALL, false, pUndoDoc.get()); } bool checkNewOutputRange(ScDPObject& rDPObj, ScDocShell& rDocShell, ScRange& rNewOut, bool bApi) @@ -1340,7 +1340,7 @@ bool ScDBDocFunc::RemovePivotTable(ScDPObject& rDPObj, bool bRecord, bool bApi) rDoc.DeleteAreaTab( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), - nTab, IDF_ALL ); + nTab, InsertDeleteFlags::ALL ); rDoc.RemoveFlagsTab( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), nTab, SC_MF_AUTO ); diff --git a/sc/source/ui/docshell/dbdocimp.cxx b/sc/source/ui/docshell/dbdocimp.cxx index bb48cd0..b168270 100644 --- a/sc/source/ui/docshell/dbdocimp.cxx +++ b/sc/source/ui/docshell/dbdocimp.cxx @@ -449,10 +449,10 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, SCCOL nMinEndCol = std::min( rParam.nCol2, nEndCol ); // not too much nMinEndCol = sal::static_int_cast<SCCOL>( nMinEndCol + nFormulaCols ); // only if column count unchanged - pImportDoc->DeleteAreaTab( 0,0, MAXCOL,MAXROW, nTab, IDF_ATTRIB ); + pImportDoc->DeleteAreaTab( 0,0, MAXCOL,MAXROW, nTab, InsertDeleteFlags::ATTRIB ); rDoc.CopyToDocument( rParam.nCol1, rParam.nRow1, nTab, nMinEndCol, rParam.nRow1, nTab, - IDF_ATTRIB, false, pImportDoc ); + InsertDeleteFlags::ATTRIB, false, pImportDoc ); SCROW nDataStartRow = rParam.nRow1+1; for (SCCOL nCopyCol=rParam.nCol1; nCopyCol<=nMinEndCol; nCopyCol++) @@ -498,7 +498,7 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, if (bRecord) { // do not touch notes (ScUndoImportData does not support drawing undo) - InsertDeleteFlags nCopyFlags = IDF_ALL & ~IDF_NOTE; + InsertDeleteFlags nCopyFlags = InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE; // nFormulaCols is set only if column count is unchanged rDoc.CopyToDocument( rParam.nCol1, rParam.nRow1, nTab, @@ -523,7 +523,7 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, ScRange aDelRange( rParam.nCol1, rParam.nRow1, nTab, rParam.nCol2, rParam.nRow2, nTab ); - rDoc.DeleteAreaTab( aDelRange, IDF_ALL & ~IDF_NOTE ); // ohne die Formeln + rDoc.DeleteAreaTab( aDelRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE ); // ohne die Formeln ScRange aOld( rParam.nCol1, rParam.nRow1, nTab, rParam.nCol2+nFormulaCols, rParam.nRow2, nTab ); @@ -533,10 +533,10 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, } else if ( nEndCol < rParam.nCol2 ) // DeleteArea calls PutInOrder rDoc.DeleteArea( nEndCol+1, rParam.nRow1, rParam.nCol2, rParam.nRow2, - aNewMark, IDF_CONTENTS & ~IDF_NOTE ); + aNewMark, InsertDeleteFlags::CONTENTS & ~InsertDeleteFlags::NOTE ); // CopyToDocument doesn't remove contents - rDoc.DeleteAreaTab( rParam.nCol1, rParam.nRow1, nEndCol, nEndRow, nTab, IDF_CONTENTS & ~IDF_NOTE ); + rDoc.DeleteAreaTab( rParam.nCol1, rParam.nRow1, nEndCol, nEndRow, nTab, InsertDeleteFlags::CONTENTS & ~InsertDeleteFlags::NOTE ); // remove each column from ImportDoc after copying to reduce memory usage bool bOldAutoCalc = rDoc.GetAutoCalc(); @@ -544,8 +544,8 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, for (SCCOL nCopyCol = rParam.nCol1; nCopyCol <= nEndCol; nCopyCol++) { pImportDoc->CopyToDocument( nCopyCol, rParam.nRow1, nTab, nCopyCol, nEndRow, nTab, - IDF_ALL, false, &rDoc ); - pImportDoc->DeleteAreaTab( nCopyCol, rParam.nRow1, nCopyCol, nEndRow, nTab, IDF_CONTENTS ); + InsertDeleteFlags::ALL, false, &rDoc ); + pImportDoc->DeleteAreaTab( nCopyCol, rParam.nRow1, nCopyCol, nEndRow, nTab, InsertDeleteFlags::CONTENTS ); } rDoc.SetAutoCalc( bOldAutoCalc ); @@ -554,7 +554,7 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, if (bKeepFormat) // formats for formulas pImportDoc->CopyToDocument( nEndCol+1, rParam.nRow1, nTab, nEndCol+nFormulaCols, nEndRow, nTab, - IDF_ATTRIB, false, &rDoc ); + InsertDeleteFlags::ATTRIB, false, &rDoc ); // fill formulas ScMarkData aMark; aMark.SelectOneTable(nTab); @@ -574,10 +574,10 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, { if ( rParam.nCol2 > nEndCol ) rDoc.DeleteArea( nEndCol+1, rParam.nRow1, rParam.nCol2, rParam.nRow2, - aNewMark, IDF_CONTENTS ); + aNewMark, InsertDeleteFlags::CONTENTS ); if ( rParam.nRow2 > nEndRow ) rDoc.DeleteArea( rParam.nCol1, nEndRow+1, rParam.nCol2, rParam.nRow2, - aNewMark, IDF_CONTENTS ); + aNewMark, InsertDeleteFlags::CONTENTS ); } if( !bAddrInsert ) // update database range @@ -598,7 +598,7 @@ bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam, if (nFormulaCols > 0) // include filled formulas for redo rDoc.CopyToDocument( rParam.nCol1, rParam.nRow1, nTab, nEndCol+nFormulaCols, nEndRow, nTab, - IDF_ALL & ~IDF_NOTE, false, pRedoDoc ); + InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, pRedoDoc ); ScDBData* pRedoDBData = pDBData ? new ScDBData( *pDBData ) : NULL; diff --git a/sc/source/ui/docshell/docfunc.cxx b/sc/source/ui/docshell/docfunc.cxx index 86422ae..9815276 100644 --- a/sc/source/ui/docshell/docfunc.cxx +++ b/sc/source/ui/docshell/docfunc.cxx @@ -591,10 +591,10 @@ bool ScDocFunc::DeleteContents( bMulti = false; // no objects on protected tabs - bool bObjects = (nFlags & IDF_OBJECTS) && !sc::DocFuncUtil::hasProtectedTab(rDoc, rMark); + bool bObjects = (nFlags & InsertDeleteFlags::OBJECTS) && !sc::DocFuncUtil::hasProtectedTab(rDoc, rMark); sal_uInt16 nExtFlags = 0; // extra flags are needed only if attributes are deleted - if ( nFlags & IDF_ATTRIB ) + if ( nFlags & InsertDeleteFlags::ATTRIB ) rDocShell.UpdatePaintExt( nExtFlags, aMarkRange ); // Reihenfolge: @@ -603,7 +603,7 @@ bool ScDocFunc::DeleteContents( // 3) Inhalte fuer Undo kopieren und Undo-Aktion anlegen // 4) Inhalte loeschen - bool bDrawUndo = bObjects || (nFlags & IDF_NOTE); + bool bDrawUndo = bObjects || (nFlags & InsertDeleteFlags::NOTE); if (bRecord && bDrawUndo) rDoc.BeginDrawUndo(); @@ -665,10 +665,10 @@ bool ScDocFunc::DeleteCell( } // no objects on protected tabs - bool bObjects = (nFlags & IDF_OBJECTS) && !sc::DocFuncUtil::hasProtectedTab(rDoc, rMark); + bool bObjects = (nFlags & InsertDeleteFlags::OBJECTS) && !sc::DocFuncUtil::hasProtectedTab(rDoc, rMark); sal_uInt16 nExtFlags = 0; // extra flags are needed only if attributes are deleted - if (nFlags & IDF_ATTRIB) + if (nFlags & InsertDeleteFlags::ATTRIB) rDocShell.UpdatePaintExt(nExtFlags, rPos); // order op opeeration: @@ -678,7 +678,7 @@ bool ScDocFunc::DeleteCell( // 4) delete contents // 5) add undo-action - bool bDrawUndo = bObjects || (nFlags & IDF_NOTE); // needed for shown notes + bool bDrawUndo = bObjects || (nFlags & InsertDeleteFlags::NOTE); // needed for shown notes if (bDrawUndo && bRecord) rDoc.BeginDrawUndo(); @@ -752,7 +752,7 @@ bool ScDocFunc::TransliterateText( const ScMarkData& rMark, sal_Int32 nType, ScRange aCopyRange = aMarkRange; aCopyRange.aStart.SetTab(0); aCopyRange.aEnd.SetTab(nTabCount-1); - rDoc.CopyToDocument( aCopyRange, IDF_CONTENTS, true, pUndoDoc, &aMultiMark ); + rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::CONTENTS, true, pUndoDoc, &aMultiMark ); rDocShell.GetUndoManager()->AddUndoAction( new ScUndoTransliterate( &rDocShell, aMultiMark, pUndoDoc, nType ) ); @@ -1356,7 +1356,7 @@ bool ScDocFunc::ApplyAttributes( const ScMarkData& rMark, const ScPatternAttr& r { ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( &rDoc, aMultiRange.aStart.Tab(), aMultiRange.aEnd.Tab() ); - rDoc.CopyToDocument( aMultiRange, IDF_ATTRIB, bMulti, pUndoDoc, &rMark ); + rDoc.CopyToDocument( aMultiRange, InsertDeleteFlags::ATTRIB, bMulti, pUndoDoc, &rMark ); rDocShell.GetUndoManager()->AddUndoAction( new ScUndoSelectionAttr( @@ -1431,7 +1431,7 @@ bool ScDocFunc::ApplyStyle( const ScMarkData& rMark, const OUString& rStyleName, ScRange aCopyRange = aMultiRange; aCopyRange.aStart.SetTab(0); aCopyRange.aEnd.SetTab(nTabCount-1); - rDoc.CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &rMark ); + rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ATTRIB, bMulti, pUndoDoc, &rMark ); rDocShell.GetUndoManager()->AddUndoAction( new ScUndoSelectionStyle( @@ -2351,7 +2351,7 @@ bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMark, nScenarioCount ++; rDoc.CopyToDocument( nUndoStartCol, nUndoStartRow, *itr, nUndoEndCol, nUndoEndRow, *itr+nScenarioCount, - IDF_ALL | IDF_NOCAPTIONS, false, pUndoDoc ); + InsertDeleteFlags::ALL | InsertDeleteFlags::NOCAPTIONS, false, pUndoDoc ); } pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO ); @@ -2405,13 +2405,13 @@ bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMark, { itr = aFullMark.begin(), itrEnd = aFullMark.end(); for (; itr != itrEnd && *itr < nTabCount; ++itr) - pRefUndoDoc->DeleteAreaTab(nUndoStartCol,nUndoStartRow,nUndoEndCol,nUndoEndRow, *itr, IDF_ALL); + pRefUndoDoc->DeleteAreaTab(nUndoStartCol,nUndoStartRow,nUndoEndCol,nUndoEndRow, *itr, InsertDeleteFlags::ALL); // alle Tabellen anlegen, damit Formeln kopiert werden koennen: pUndoDoc->AddUndoTab( 0, nTabCount-1 ); // kopieren mit bColRowFlags=false (#54194#) - pRefUndoDoc->CopyToDocument(0,0,0,MAXCOL,MAXROW,MAXTAB,IDF_FORMULA,false,pUndoDoc,NULL,false); + pRefUndoDoc->CopyToDocument(0,0,0,MAXCOL,MAXROW,MAXTAB,InsertDeleteFlags::FORMULA,false,pUndoDoc,NULL,false); delete pRefUndoDoc; SCTAB* pTabs = new SCTAB[nSelCount]; @@ -2698,7 +2698,7 @@ bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos, { bool bWholeCols = ( nStartRow == 0 && nEndRow == MAXROW ); bool bWholeRows = ( nStartCol == 0 && nEndCol == MAXCOL ); - InsertDeleteFlags nUndoFlags = (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS; + InsertDeleteFlags nUndoFlags = (InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS) | InsertDeleteFlags::NOCAPTIONS; pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( &rDoc, nStartTab, nEndTab, bWholeCols, bWholeRows ); @@ -2723,7 +2723,7 @@ bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos, ScMarkData aDelMark; // only for tables for (nTab=nStartTab; nTab<=nEndTab; nTab++) { - rDoc.DeleteAreaTab( nStartCol,nStartRow, nOldEndCol,nOldEndRow, nTab, IDF_ALL ); + rDoc.DeleteAreaTab( nStartCol,nStartRow, nOldEndCol,nOldEndRow, nTab, InsertDeleteFlags::ALL ); aDelMark.SelectTable( nTab, true ); } rDoc.DeleteObjectsInArea( nStartCol,nStartRow, nOldEndCol,nOldEndRow, aDelMark ); @@ -2735,7 +2735,7 @@ bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos, nUndoEndCol,nUndoEndRow,nDestEndTab, HASATTR_MERGED | HASATTR_OVERLAPPED )) { - rDoc.CopyFromClip( rSource, aSourceMark, IDF_ALL, NULL, pClipDoc ); + rDoc.CopyFromClip( rSource, aSourceMark, InsertDeleteFlags::ALL, NULL, pClipDoc ); for (nTab=nStartTab; nTab<=nEndTab; nTab++) { SCCOL nTmpEndCol = nEndCol; @@ -2766,7 +2766,7 @@ bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos, function ScDocument::UpdateReference() is called which calls ScDrawLayer::MoveCells() which may move away inserted objects to wrong positions (e.g. if source and destination range overlaps).*/ - rDoc.CopyFromClip( aPasteDest, aDestMark, IDF_ALL & ~(IDF_OBJECTS), + rDoc.CopyFromClip( aPasteDest, aDestMark, InsertDeleteFlags::ALL & ~(InsertDeleteFlags::OBJECTS), NULL, pClipDoc, true, false, bIncludeFiltered ); // skipped rows and merged cells don't mix @@ -2781,7 +2781,7 @@ bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos, and row heights. There are no cell notes or drawing objects, if the clipdoc does not contain a drawing layer.*/ if ( pClipDoc->GetDrawLayer() ) - rDoc.CopyFromClip( aPasteDest, aDestMark, IDF_OBJECTS, + rDoc.CopyFromClip( aPasteDest, aDestMark, InsertDeleteFlags::OBJECTS, NULL, pClipDoc, true, false, bIncludeFiltered ); if (bRecord) @@ -3057,7 +3057,7 @@ bool ScDocFunc::DeleteTable( SCTAB nTab, bool bRecord, bool /* bApi */ ) pUndoDoc->InitUndo( &rDoc, nTab, nTab, true, true ); // nur nTab mit Flags pUndoDoc->AddUndoTab( 0, nCount-1 ); // alle Tabs fuer Referenzen - rDoc.CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,false, pUndoDoc ); + rDoc.CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, InsertDeleteFlags::ALL,false, pUndoDoc ); ... etc. - the rest is truncated _______________________________________________ Libreoffice-commits mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
