From 720560335c2e3a8e72026d87d8d5f0056f4df188 Mon Sep 17 00:00:00 2001 From: Kohei Yoshida Date: Thu, 11 May 2017 18:07:56 -0400 Subject: tdf#43535: support additional sheet protection options. New options are: * insert columns. * insert rows. * delete columns. * delete rows. Change-Id: I076b0d01bee0fff0623e2f1137c09938a6110939 Reviewed-on: https://gerrit.libreoffice.org/37695 Tested-by: Jenkins Reviewed-by: Kohei Yoshida (cherry picked from commit 034be10413ed4915090678ad4f1d48596cf5e206) --- sc/source/core/data/document10.cxx | 23 +++++++++ sc/source/core/data/table7.cxx | 82 +++++++++++++++++++++++++++++++++ sc/source/filter/xml/xmlexprt.cxx | 10 ++++ sc/source/filter/xml/xmlimprt.cxx | 4 ++ sc/source/filter/xml/xmlimprt.hxx | 6 ++- sc/source/filter/xml/xmlsubti.cxx | 10 +++- sc/source/filter/xml/xmlsubti.hxx | 4 ++ sc/source/filter/xml/xmltabi.cxx | 24 +++++++++- sc/source/ui/docshell/docfunc.cxx | 46 +++++++++++++++++- sc/source/ui/docshell/editable.cxx | 22 +++++++++ sc/source/ui/inc/editable.hxx | 14 ++++++ sc/source/ui/inc/protectiondlg.hxx | 4 ++ sc/source/ui/miscdlgs/protectiondlg.cxx | 24 ++++++++-- sc/source/ui/view/cellsh.cxx | 26 +++++++++++ 14 files changed, 289 insertions(+), 10 deletions(-) (limited to 'sc/source') diff --git a/sc/source/core/data/document10.cxx b/sc/source/core/data/document10.cxx index 7b6ce1cc4a7a..35632d44536f 100644 --- a/sc/source/core/data/document10.cxx +++ b/sc/source/core/data/document10.cxx @@ -880,4 +880,27 @@ bool ScDocument::CopyAdjustRangeName( SCTAB& rSheet, sal_uInt16& rIndex, ScRange return true; } +bool ScDocument::IsEditActionAllowed( + sc::ColRowEditAction eAction, SCTAB nTab, SCCOLROW nStart, SCCOLROW nEnd ) const +{ + const ScTable* pTab = FetchTable(nTab); + if (!pTab) + return false; + + return pTab->IsEditActionAllowed(eAction, nStart, nEnd); +} + +bool ScDocument::IsEditActionAllowed( + sc::ColRowEditAction eAction, const ScMarkData& rMark, SCCOLROW nStart, SCCOLROW nEnd ) const +{ + ScMarkData::const_iterator it = rMark.begin(), itEnd = rMark.end(); + for (; it != itEnd; ++it) + { + if (!IsEditActionAllowed(eAction, *it, nStart, nEnd)) + return false; + } + + return true; +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/data/table7.cxx b/sc/source/core/data/table7.cxx index f66be85f75cc..6179737aec93 100644 --- a/sc/source/core/data/table7.cxx +++ b/sc/source/core/data/table7.cxx @@ -16,6 +16,7 @@ #include #include #include "olinetab.hxx" +#include bool ScTable::IsMerged( SCCOL nCol, SCROW nRow ) const { @@ -310,6 +311,87 @@ void ScTable::SetNeedsListeningGroup( SCCOL nCol, SCROW nRow ) aCol[nCol].SetNeedsListeningGroup(nRow); } +bool ScTable::IsEditActionAllowed( + sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd ) const +{ + if (!IsProtected()) + { + SCCOL nCol1 = 0, nCol2 = MAXCOL; + SCROW nRow1 = 0, nRow2 = MAXROW; + + switch (eAction) + { + case sc::ColRowEditAction::InsertColumnsBefore: + case sc::ColRowEditAction::InsertColumnsAfter: + case sc::ColRowEditAction::DeleteColumns: + { + nCol1 = nStart; + nCol2 = nEnd; + break; + } + case sc::ColRowEditAction::InsertRowsBefore: + case sc::ColRowEditAction::InsertRowsAfter: + case sc::ColRowEditAction::DeleteRows: + { + nRow1 = nStart; + nRow2 = nEnd; + break; + } + default: + ; + } + + return IsBlockEditable(nCol1, nRow1, nCol2, nRow2, nullptr); + } + + if (IsScenario()) + // TODO: I don't even know what this scenario thingie is. Perhaps we + // should check it against the scenario ranges? + return false; + + assert(pTabProtection); + + switch (eAction) + { + case sc::ColRowEditAction::InsertColumnsBefore: + case sc::ColRowEditAction::InsertColumnsAfter: + { + // TODO: improve the matrix range handling for the insert-before action. + if (HasBlockMatrixFragment(nStart, 0, nEnd, MAXROW)) + return false; + + return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_COLUMNS); + } + case sc::ColRowEditAction::InsertRowsBefore: + case sc::ColRowEditAction::InsertRowsAfter: + { + // TODO: improve the matrix range handling for the insert-before action. + if (HasBlockMatrixFragment(0, nStart, MAXCOL, nEnd)) + return false; + + return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_ROWS); + } + case sc::ColRowEditAction::DeleteColumns: + { + if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_COLUMNS)) + return false; + + return !HasAttrib(nStart, 0, nEnd, MAXROW, HasAttrFlags::Protected); + } + case sc::ColRowEditAction::DeleteRows: + { + if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_ROWS)) + return false; + + return !HasAttrib(0, nStart, MAXCOL, nEnd, HasAttrFlags::Protected); + } + default: + ; + } + + return false; +} + void ScTable::finalizeOutlineImport() { if (pOutlineTable && pRowFlags) diff --git a/sc/source/filter/xml/xmlexprt.cxx b/sc/source/filter/xml/xmlexprt.cxx index 2dca58bf1bc0..948c4a8442f8 100644 --- a/sc/source/filter/xml/xmlexprt.cxx +++ b/sc/source/filter/xml/xmlexprt.cxx @@ -2898,6 +2898,16 @@ void ScXMLExport::WriteTable(sal_Int32 nTable, const ReferenceisOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS)) AddAttribute(XML_NAMESPACE_LO_EXT, XML_SELECT_UNPROTECTED_CELLS, XML_TRUE); + if (pProtect->isOptionEnabled(ScTableProtection::INSERT_COLUMNS)) + AddAttribute(XML_NAMESPACE_LO_EXT, XML_INSERT_COLUMNS, XML_TRUE); + if (pProtect->isOptionEnabled(ScTableProtection::INSERT_ROWS)) + AddAttribute(XML_NAMESPACE_LO_EXT, XML_INSERT_ROWS, XML_TRUE); + + if (pProtect->isOptionEnabled(ScTableProtection::DELETE_COLUMNS)) + AddAttribute(XML_NAMESPACE_LO_EXT, XML_DELETE_COLUMNS, XML_TRUE); + if (pProtect->isOptionEnabled(ScTableProtection::DELETE_ROWS)) + AddAttribute(XML_NAMESPACE_LO_EXT, XML_DELETE_ROWS, XML_TRUE); + OUString aElemName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_LO_EXT, GetXMLToken(XML_TABLE_PROTECTION)); diff --git a/sc/source/filter/xml/xmlimprt.cxx b/sc/source/filter/xml/xmlimprt.cxx index f1a81868992d..0747d294e00f 100644 --- a/sc/source/filter/xml/xmlimprt.cxx +++ b/sc/source/filter/xml/xmlimprt.cxx @@ -827,6 +827,10 @@ const SvXMLTokenMap& ScXMLImport::GetTableProtectionAttrTokenMap() { XML_NAMESPACE_LO_EXT, XML_SELECT_PROTECTED_CELLS, XML_TOK_TABLE_SELECT_PROTECTED_CELLS_EXT }, { XML_NAMESPACE_OFFICE_EXT, XML_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT }, { XML_NAMESPACE_LO_EXT, XML_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT }, + { XML_NAMESPACE_LO_EXT, XML_INSERT_COLUMNS, XML_TOK_TABLE_INSERT_COLUMNS_EXT, }, + { XML_NAMESPACE_LO_EXT, XML_INSERT_ROWS, XML_TOK_TABLE_INSERT_ROWS_EXT, }, + { XML_NAMESPACE_LO_EXT, XML_DELETE_COLUMNS, XML_TOK_TABLE_DELETE_COLUMNS_EXT, }, + { XML_NAMESPACE_LO_EXT, XML_DELETE_ROWS, XML_TOK_TABLE_DELETE_ROWS_EXT, }, XML_TOKEN_MAP_END }; pTableProtectionElemTokenMap = new SvXMLTokenMap(aTableProtectionTokenMap); diff --git a/sc/source/filter/xml/xmlimprt.hxx b/sc/source/filter/xml/xmlimprt.hxx index 28f9ae99d144..3eef0217308e 100644 --- a/sc/source/filter/xml/xmlimprt.hxx +++ b/sc/source/filter/xml/xmlimprt.hxx @@ -248,7 +248,11 @@ enum ScXMLTokenProtectionTokens XML_TOK_TABLE_SELECT_PROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_PROTECTED_CELLS_EXT, - XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT + XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT, + XML_TOK_TABLE_INSERT_COLUMNS_EXT, + XML_TOK_TABLE_INSERT_ROWS_EXT, + XML_TOK_TABLE_DELETE_COLUMNS_EXT, + XML_TOK_TABLE_DELETE_ROWS_EXT, }; enum ScXMLTableRowsTokens diff --git a/sc/source/filter/xml/xmlsubti.cxx b/sc/source/filter/xml/xmlsubti.cxx index c145cc2a6cad..25e484cd0a39 100644 --- a/sc/source/filter/xml/xmlsubti.cxx +++ b/sc/source/filter/xml/xmlsubti.cxx @@ -51,7 +51,11 @@ ScXMLTabProtectionData::ScXMLTabProtectionData() : meHash2(PASSHASH_UNSPECIFIED), mbProtected(false), mbSelectProtectedCells(true), - mbSelectUnprotectedCells(true) + mbSelectUnprotectedCells(true), + mbInsertColumns(false), + mbInsertRows(false), + mbDeleteColumns(false), + mbDeleteRows(false) { } @@ -203,6 +207,10 @@ void ScMyTables::DeleteTable() pProtect->setPasswordHash(aHash, maProtectionData.meHash1, maProtectionData.meHash2); pProtect->setOption(ScTableProtection::SELECT_LOCKED_CELLS, maProtectionData.mbSelectProtectedCells); pProtect->setOption(ScTableProtection::SELECT_UNLOCKED_CELLS, maProtectionData.mbSelectUnprotectedCells); + pProtect->setOption(ScTableProtection::INSERT_COLUMNS, maProtectionData.mbInsertColumns); + pProtect->setOption(ScTableProtection::INSERT_ROWS, maProtectionData.mbInsertRows); + pProtect->setOption(ScTableProtection::DELETE_COLUMNS, maProtectionData.mbDeleteColumns); + pProtect->setOption(ScTableProtection::DELETE_ROWS, maProtectionData.mbDeleteRows); rImport.GetDocument()->SetTabProtection(maCurrentCellPos.Tab(), pProtect.get()); } } diff --git a/sc/source/filter/xml/xmlsubti.hxx b/sc/source/filter/xml/xmlsubti.hxx index 48f7a92fbbd6..fc1be1654401 100644 --- a/sc/source/filter/xml/xmlsubti.hxx +++ b/sc/source/filter/xml/xmlsubti.hxx @@ -40,6 +40,10 @@ struct ScXMLTabProtectionData bool mbProtected; bool mbSelectProtectedCells; bool mbSelectUnprotectedCells; + bool mbInsertColumns; + bool mbInsertRows; + bool mbDeleteColumns; + bool mbDeleteRows; ScXMLTabProtectionData(); }; diff --git a/sc/source/filter/xml/xmltabi.cxx b/sc/source/filter/xml/xmltabi.cxx index 162bacdb5793..fbff43c4362c 100644 --- a/sc/source/filter/xml/xmltabi.cxx +++ b/sc/source/filter/xml/xmltabi.cxx @@ -422,6 +422,10 @@ ScXMLTableProtectionContext::ScXMLTableProtectionContext( const SvXMLTokenMap& rAttrTokenMap = GetScImport().GetTableProtectionAttrTokenMap(); bool bSelectProtectedCells = false; bool bSelectUnprotectedCells = false; + bool bInsertColumns = false; + bool bInsertRows = false; + bool bDeleteColumns = false; + bool bDeleteRows = false; sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; @@ -439,11 +443,23 @@ ScXMLTableProtectionContext::ScXMLTableProtectionContext( case XML_TOK_TABLE_SELECT_PROTECTED_CELLS: case XML_TOK_TABLE_SELECT_PROTECTED_CELLS_EXT: bSelectProtectedCells = IsXMLToken(aValue, XML_TRUE); - break; + break; case XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS: case XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT: bSelectUnprotectedCells = IsXMLToken(aValue, XML_TRUE); - break; + break; + case XML_TOK_TABLE_INSERT_COLUMNS_EXT: + bInsertColumns = IsXMLToken(aValue, XML_TRUE); + break; + case XML_TOK_TABLE_INSERT_ROWS_EXT: + bInsertRows = IsXMLToken(aValue, XML_TRUE); + break; + case XML_TOK_TABLE_DELETE_COLUMNS_EXT: + bDeleteColumns = IsXMLToken(aValue, XML_TRUE); + break; + case XML_TOK_TABLE_DELETE_ROWS_EXT: + bDeleteRows = IsXMLToken(aValue, XML_TRUE); + break; default: SAL_WARN("sc", "unknown attribute: " << aAttrName); } @@ -452,6 +468,10 @@ ScXMLTableProtectionContext::ScXMLTableProtectionContext( ScXMLTabProtectionData& rProtectData = GetScImport().GetTables().GetCurrentProtectionData(); rProtectData.mbSelectProtectedCells = bSelectProtectedCells; rProtectData.mbSelectUnprotectedCells = bSelectUnprotectedCells; + rProtectData.mbInsertColumns = bInsertColumns; + rProtectData.mbInsertRows = bInsertRows; + rProtectData.mbDeleteColumns = bDeleteColumns; + rProtectData.mbDeleteRows = bDeleteRows; } ScXMLTableProtectionContext::~ScXMLTableProtectionContext() diff --git a/sc/source/ui/docshell/docfunc.cxx b/sc/source/ui/docshell/docfunc.cxx index d6ed891bdd72..7f9d67f62104 100644 --- a/sc/source/ui/docshell/docfunc.cxx +++ b/sc/source/ui/docshell/docfunc.cxx @@ -1767,7 +1767,32 @@ bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMark, SCCOL nEditTestEndCol = (eCmd==INS_INSCOLS_BEFORE || eCmd==INS_INSCOLS_AFTER) ? MAXCOL : nMergeTestEndCol; SCROW nEditTestEndRow = (eCmd==INS_INSROWS_BEFORE || eCmd==INS_INSROWS_AFTER) ? MAXROW : nMergeTestEndRow; - ScEditableTester aTester( &rDoc, nMergeTestStartCol, nMergeTestStartRow, nEditTestEndCol, nEditTestEndRow, aMark ); + + ScEditableTester aTester; + + switch (eCmd) + { + case INS_INSCOLS_BEFORE: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::InsertColumnsBefore, nMergeTestStartCol, nMergeTestEndCol, aMark); + break; + case INS_INSCOLS_AFTER: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::InsertColumnsAfter, nMergeTestStartCol, nMergeTestEndCol, aMark); + break; + case INS_INSROWS_BEFORE: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::InsertRowsBefore, nMergeTestStartRow, nMergeTestEndRow, aMark); + break; + case INS_INSROWS_AFTER: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::InsertRowsAfter, nMergeTestStartRow, nMergeTestEndRow, aMark); + break; + default: + aTester = ScEditableTester( + &rDoc, nMergeTestStartCol, nMergeTestStartRow, nEditTestEndCol, nEditTestEndRow, aMark); + } + if (!aTester.IsEditable()) { if (!bApi) @@ -2223,7 +2248,24 @@ bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMark, SCROW nEditTestEndY = nUndoEndRow; if ( eCmd==DEL_DELROWS || eCmd==DEL_CELLSUP ) nEditTestEndY = MAXROW; - ScEditableTester aTester( &rDoc, nUndoStartCol, nUndoStartRow, nEditTestEndX, nEditTestEndY, aMark ); + + ScEditableTester aTester; + + switch (eCmd) + { + case DEL_DELCOLS: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::DeleteColumns, nUndoStartCol, nUndoEndCol, aMark); + break; + case DEL_DELROWS: + aTester = ScEditableTester( + rDoc, sc::ColRowEditAction::DeleteRows, nUndoStartRow, nUndoEndRow, aMark); + break; + default: + aTester = ScEditableTester( + &rDoc, nUndoStartCol, nUndoStartRow, nEditTestEndX, nEditTestEndY, aMark); + } + if (!aTester.IsEditable()) { if (!bApi) diff --git a/sc/source/ui/docshell/editable.cxx b/sc/source/ui/docshell/editable.cxx index 05d4f19ebc89..2a06c82dc322 100644 --- a/sc/source/ui/docshell/editable.cxx +++ b/sc/source/ui/docshell/editable.cxx @@ -73,6 +73,13 @@ ScEditableTester::ScEditableTester( ScViewFunc* pView ) : } } +ScEditableTester::ScEditableTester( + const ScDocument& rDoc, sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd, const ScMarkData& rMark ) : + ScEditableTester() +{ + TestBlockForAction(rDoc, eAction, nStart, nEnd, rMark); +} + void ScEditableTester::TestBlock( ScDocument* pDoc, SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) { @@ -124,6 +131,21 @@ void ScEditableTester::TestSelection( ScDocument* pDoc, const ScMarkData& rMark } } +void ScEditableTester::TestBlockForAction( + const ScDocument& rDoc, sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd, + const ScMarkData& rMark ) +{ + mbOnlyMatrix = false; + + for (ScMarkData::const_iterator it = rMark.begin(), itEnd = rMark.end(); it != itEnd; ++it) + { + if (!mbIsEditable) + return; + + mbIsEditable = rDoc.IsEditActionAllowed(eAction, *it, nStart, nEnd); + } +} + sal_uInt16 ScEditableTester::GetMessageId() const { if (mbIsEditable) diff --git a/sc/source/ui/inc/editable.hxx b/sc/source/ui/inc/editable.hxx index 10a03032c5ac..e47e2d473060 100644 --- a/sc/source/ui/inc/editable.hxx +++ b/sc/source/ui/inc/editable.hxx @@ -27,6 +27,12 @@ class ScViewFunc; class ScMarkData; class ScRange; +namespace sc { + +enum class ColRowEditAction; + +} + class ScEditableTester { bool mbIsEditable; @@ -53,6 +59,10 @@ public: // calls TestView ScEditableTester( ScViewFunc* pView ); + ScEditableTester( + const ScDocument& rDoc, sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd, + const ScMarkData& rMark ); + // Several calls to the Test... methods check if *all* of the ranges // are editable. For several independent checks, Reset() has to be used. void TestBlock( ScDocument* pDoc, SCTAB nTab, @@ -63,6 +73,10 @@ public: void TestRange( ScDocument* pDoc, const ScRange& rRange ); void TestSelection( ScDocument* pDoc, const ScMarkData& rMark ); + void TestBlockForAction( + const ScDocument& rDoc, sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd, + const ScMarkData& rMark ); + bool IsEditable() const { return mbIsEditable; } bool IsFormatEditable() const { return mbIsEditable || mbOnlyMatrix; } sal_uInt16 GetMessageId() const; diff --git a/sc/source/ui/inc/protectiondlg.hxx b/sc/source/ui/inc/protectiondlg.hxx index 752fee048706..351a733e31d0 100644 --- a/sc/source/ui/inc/protectiondlg.hxx +++ b/sc/source/ui/inc/protectiondlg.hxx @@ -62,6 +62,10 @@ private: OUString m_aSelectLockedCells; OUString m_aSelectUnlockedCells; + OUString m_aInsertColumns; + OUString m_aInsertRows; + OUString m_aDeleteColumns; + OUString m_aDeleteRows; DECL_LINK( OKHdl, Button*, void ); DECL_LINK( CheckBoxHdl, Button*, void ); diff --git a/sc/source/ui/miscdlgs/protectiondlg.cxx b/sc/source/ui/miscdlgs/protectiondlg.cxx index ddfd337a220b..082aec5a87c6 100644 --- a/sc/source/ui/miscdlgs/protectiondlg.cxx +++ b/sc/source/ui/miscdlgs/protectiondlg.cxx @@ -23,13 +23,21 @@ #include #include +#include + +namespace { // The order must match that of the list box. -static const ScTableProtection::Option aOptions[] = { +const std::vector aOptions = { ScTableProtection::SELECT_LOCKED_CELLS, ScTableProtection::SELECT_UNLOCKED_CELLS, + ScTableProtection::INSERT_COLUMNS, + ScTableProtection::INSERT_ROWS, + ScTableProtection::DELETE_COLUMNS, + ScTableProtection::DELETE_ROWS, }; -static const sal_uInt16 nOptionCount = SAL_N_ELEMENTS(aOptions); + +} ScTableProtectionDlg::ScTableProtectionDlg(vcl::Window* pParent) : ModalDialog( pParent, "ProtectSheetDialog", "modules/scalc/ui/protectsheetdlg.ui" ) @@ -44,6 +52,10 @@ ScTableProtectionDlg::ScTableProtectionDlg(vcl::Window* pParent) m_aSelectLockedCells = get("protected")->GetText(); m_aSelectUnlockedCells = get("unprotected")->GetText(); + m_aInsertColumns = get("insert-columns")->GetText(); + m_aInsertRows = get("insert-rows")->GetText(); + m_aDeleteColumns = get("delete-columns")->GetText(); + m_aDeleteRows = get("delete-rows")->GetText(); Init(); } @@ -67,7 +79,7 @@ void ScTableProtectionDlg::dispose() void ScTableProtectionDlg::SetDialogData(const ScTableProtection& rData) { - for (sal_uInt16 i = 0; i < nOptionCount; ++i) + for (size_t i = 0; i < aOptions.size(); ++i) m_pOptionsListBox->CheckEntryPos(i, rData.isOptionEnabled(aOptions[i])); } @@ -78,7 +90,7 @@ void ScTableProtectionDlg::WriteData(ScTableProtection& rData) const // We assume that the two password texts match. rData.setPassword(m_pPassword1Edit->GetText()); - for (sal_uInt16 i = 0; i < nOptionCount; ++i) + for (size_t i = 0; i < aOptions.size(); ++i) rData.setOption(aOptions[i], m_pOptionsListBox->IsChecked(i)); } @@ -97,6 +109,10 @@ void ScTableProtectionDlg::Init() m_pOptionsListBox->InsertEntry(m_aSelectLockedCells); m_pOptionsListBox->InsertEntry(m_aSelectUnlockedCells); + m_pOptionsListBox->InsertEntry(m_aInsertColumns); + m_pOptionsListBox->InsertEntry(m_aInsertRows); + m_pOptionsListBox->InsertEntry(m_aDeleteColumns); + m_pOptionsListBox->InsertEntry(m_aDeleteRows); m_pOptionsListBox->CheckEntryPos(0); m_pOptionsListBox->CheckEntryPos(1); diff --git a/sc/source/ui/view/cellsh.cxx b/sc/source/ui/view/cellsh.cxx index 4c297af272ab..58fd0ee27ace 100644 --- a/sc/source/ui/view/cellsh.cxx +++ b/sc/source/ui/view/cellsh.cxx @@ -231,6 +231,19 @@ void ScCellShell::GetBlockState( SfxItemSet& rSet ) case FID_INS_ROW: case FID_INS_ROWS_BEFORE: // insert rows case FID_INS_ROWS_AFTER: + { + sc::ColRowEditAction eAction = sc::ColRowEditAction::InsertRowsBefore; + if (nWhich == FID_INS_ROWS_AFTER) + eAction = sc::ColRowEditAction::InsertRowsAfter; + + bDisable = (!bSimpleArea) || GetViewData()->SimpleColMarked(); + if (!bEditable && nCol1 == 0 && nCol2 == MAXCOL) + { + // See if row insertions are allowed. + bEditable = pDoc->IsEditActionAllowed(eAction, rMark, nRow1, nRow2); + } + break; + } case FID_INS_CELLSDOWN: case SID_ROW_OPERATIONS: bDisable = (!bSimpleArea) || GetViewData()->SimpleColMarked(); @@ -239,6 +252,19 @@ void ScCellShell::GetBlockState( SfxItemSet& rSet ) case FID_INS_COLUMN: case FID_INS_COLUMNS_BEFORE: // insert columns case FID_INS_COLUMNS_AFTER: + { + sc::ColRowEditAction eAction = sc::ColRowEditAction::InsertColumnsBefore; + if (nWhich == FID_INS_COLUMNS_AFTER) + eAction = sc::ColRowEditAction::InsertColumnsAfter; + + bDisable = (!bSimpleArea) || GetViewData()->SimpleRowMarked(); + if (!bEditable && nRow1 == 0 && nRow2 == MAXROW) + { + // See if row insertions are allowed. + bEditable = pDoc->IsEditActionAllowed(eAction, rMark, nCol1, nCol2); + } + break; + } case FID_INS_CELLSRIGHT: case SID_COLUMN_OPERATIONS: bDisable = (!bSimpleArea) || GetViewData()->SimpleRowMarked(); -- cgit