Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

32 files changed, 14349 insertions, 0 deletions

diff --git a/sc/source/ui/dbgui/PivotLayoutDialog.cxx b/sc/source/ui/dbgui/PivotLayoutDialog.cxx
new file mode 100644
index 000000000..9244a4d7e
--- /dev/null
+++ b/sc/source/ui/dbgui/PivotLayoutDialog.cxx
@@ -0,0 +1,719 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ */
+
+#include <PivotLayoutTreeList.hxx>
+#include <PivotLayoutDialog.hxx>
+#include <reffact.hxx>
+
+#include <rangeutl.hxx>
+#include <uiitems.hxx>
+#include <dputil.hxx>
+#include <dbdocfun.hxx>
+#include <dpsave.hxx>
+#include <dpshttab.hxx>
+#include <scmod.hxx>
+
+#include <memory>
+#include <vector>
+
+#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
+#include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
+
+using namespace css::uno;
+using namespace css::sheet;
+
+ScItemValue::ScItemValue(OUString const & aName, SCCOL nColumn, PivotFunc nFunctionMask) :
+    maName(aName),
+    maFunctionData(nColumn, nFunctionMask),
+    mpOriginalItemValue(this)
+{}
+
+ScItemValue::ScItemValue(const ScItemValue* pInputItemValue) :
+    maName(pInputItemValue->maName),
+    maFunctionData(pInputItemValue->maFunctionData),
+    mpOriginalItemValue(this)
+{}
+
+ScItemValue::~ScItemValue()
+{}
+
+namespace
+{
+
+ScRange lclGetRangeForNamedRange(OUString const & aName, const ScDocument& rDocument)
+{
+    ScRange aInvalidRange(ScAddress::INITIALIZE_INVALID);
+    ScRangeName* pRangeName = rDocument.GetRangeName();
+    if (pRangeName == nullptr)
+        return aInvalidRange;
+
+    const ScRangeData* pData = pRangeName->findByUpperName(aName.toAsciiUpperCase());
+    if (pData == nullptr)
+        return aInvalidRange;
+
+    ScRange aRange;
+    if (pData->IsReference(aRange))
+        return aRange;
+
+    return aInvalidRange;
+}
+
+}
+
+ScPivotLayoutDialog::ScPivotLayoutDialog(
+                            SfxBindings* pSfxBindings, SfxChildWindow* pChildWindow, weld::Window* pParent,
+                            ScViewData* pViewData, const ScDPObject* pPivotTableObject, bool bNewPivotTable)
+    : ScAnyRefDlgController(pSfxBindings, pChildWindow, pParent, "modules/scalc/ui/pivottablelayoutdialog.ui", "PivotTableLayout")
+    , maPivotTableObject(*pPivotTableObject)
+    , mpPreviouslyFocusedListBox(nullptr)
+    , mpViewData(pViewData)
+    , mrDocument(pViewData->GetDocument())
+    , mbNewPivotTable(bNewPivotTable)
+    , maAddressDetails(mrDocument.GetAddressConvention(), 0, 0)
+    , mbDialogLostFocus(false)
+    , mpActiveEdit(nullptr)
+    , mxListBoxField(new ScPivotLayoutTreeListLabel(m_xBuilder->weld_tree_view("listbox-fields")))
+    , mxListBoxPage(new ScPivotLayoutTreeList(m_xBuilder->weld_tree_view("listbox-page")))
+    , mxListBoxColumn(new ScPivotLayoutTreeList(m_xBuilder->weld_tree_view("listbox-column")))
+    , mxListBoxRow(new ScPivotLayoutTreeList(m_xBuilder->weld_tree_view("listbox-row")))
+    , mxListBoxData(new ScPivotLayoutTreeListData(m_xBuilder->weld_tree_view("listbox-data")))
+    , mxCheckIgnoreEmptyRows(m_xBuilder->weld_check_button("check-ignore-empty-rows"))
+    , mxCheckTotalColumns(m_xBuilder->weld_check_button("check-total-columns"))
+    , mxCheckAddFilter(m_xBuilder->weld_check_button("check-add-filter"))
+    , mxCheckIdentifyCategories(m_xBuilder->weld_check_button("check-identify-categories"))
+    , mxCheckTotalRows(m_xBuilder->weld_check_button("check-total-rows"))
+    , mxCheckDrillToDetail(m_xBuilder->weld_check_button("check-drill-to-details"))
+    , mxSourceRadioNamedRange(m_xBuilder->weld_radio_button("source-radio-named-range"))
+    , mxSourceRadioSelection(m_xBuilder->weld_radio_button("source-radio-selection"))
+    , mxSourceListBox(m_xBuilder->weld_combo_box("source-list"))
+    , mxSourceEdit(new formula::RefEdit(m_xBuilder->weld_entry("source-edit")))
+    , mxSourceButton(new formula::RefButton(m_xBuilder->weld_button("source-button")))
+    , mxDestinationRadioNewSheet(m_xBuilder->weld_radio_button("destination-radio-new-sheet"))
+    , mxDestinationRadioNamedRange(m_xBuilder->weld_radio_button("destination-radio-named-range"))
+    , mxDestinationRadioSelection(m_xBuilder->weld_radio_button("destination-radio-selection"))
+    , mxDestinationListBox(m_xBuilder->weld_combo_box("destination-list"))
+    , mxDestinationEdit(new formula::RefEdit(m_xBuilder->weld_entry("destination-edit")))
+    , mxDestinationButton(new formula::RefButton(m_xBuilder->weld_button("destination-button")))
+    , mxBtnOK(m_xBuilder->weld_button("ok"))
+    , mxBtnCancel(m_xBuilder->weld_button("cancel"))
+    , mxSourceFrame(m_xBuilder->weld_frame("frame2"))
+    , mxSourceLabel(mxSourceFrame->weld_label_widget())
+    , mxDestFrame(m_xBuilder->weld_frame("frame1"))
+    , mxDestLabel(mxDestFrame->weld_label_widget())
+    , mxOptions(m_xBuilder->weld_expander("options"))
+    , mxMore(m_xBuilder->weld_expander("more"))
+{
+    // Source UI
+    Link<weld::Toggleable&,void> aLink2 = LINK(this, ScPivotLayoutDialog, ToggleSource);
+    mxSourceRadioNamedRange->connect_toggled(aLink2);
+    mxSourceRadioSelection->connect_toggled(aLink2);
+
+    mxSourceEdit->SetReferences(this, mxSourceLabel.get());
+    mxSourceButton->SetReferences(this, mxSourceEdit.get());
+
+    Link<formula::RefEdit&,void> aEditLink = LINK(this, ScPivotLayoutDialog, GetEditFocusHandler);
+    mxDestinationEdit->SetGetFocusHdl(aEditLink);
+    mxSourceEdit->SetGetFocusHdl(aEditLink);
+
+    aEditLink = LINK(this, ScPivotLayoutDialog, LoseEditFocusHandler);
+    mxDestinationEdit->SetLoseFocusHdl(aEditLink);
+    mxSourceEdit->SetLoseFocusHdl(aEditLink);
+
+    mxSourceEdit->SetModifyHdl(LINK(this, ScPivotLayoutDialog, SourceEditModified));
+    mxSourceListBox->connect_changed(LINK(this, ScPivotLayoutDialog, SourceListSelected));
+
+    // Destination UI
+    aLink2 = LINK(this, ScPivotLayoutDialog, ToggleDestination);
+    mxDestinationRadioNewSheet->connect_toggled(aLink2);
+    mxDestinationRadioNamedRange->connect_toggled(aLink2);
+    mxDestinationRadioSelection->connect_toggled(aLink2);
+
+    mxDestinationEdit->SetReferences(this, mxDestLabel.get());
+    mxDestinationButton->SetReferences(this, mxDestinationEdit.get());
+
+    Link<formula::RefButton&,void> aButtonLink = LINK(this, ScPivotLayoutDialog, GetButtonFocusHandler);
+    mxSourceButton->SetGetFocusHdl(aButtonLink);
+    mxDestinationButton->SetGetFocusHdl(aButtonLink);
+
+    aButtonLink = LINK(this, ScPivotLayoutDialog, LoseButtonFocusHandler);
+    mxSourceButton->SetLoseFocusHdl(aButtonLink);
+    mxDestinationButton->SetLoseFocusHdl(aButtonLink);
+
+    // Buttons
+    mxBtnCancel->connect_clicked(LINK(this, ScPivotLayoutDialog, CancelClicked));
+    mxBtnOK->connect_clicked(LINK(this, ScPivotLayoutDialog, OKClicked));
+
+    // Initialize Data
+    maPivotTableObject.FillOldParam(maPivotParameters);
+    maPivotTableObject.FillLabelData(maPivotParameters);
+
+    mxListBoxField->Setup (this);
+    mxListBoxPage->Setup  (this, ScPivotLayoutTreeList::PAGE_LIST);
+    mxListBoxColumn->Setup(this, ScPivotLayoutTreeList::COLUMN_LIST);
+    mxListBoxRow->Setup   (this, ScPivotLayoutTreeList::ROW_LIST);
+    mxListBoxData->Setup  (this);
+
+    FillValuesToListBoxes();
+
+    // Initialize Options
+    const ScDPSaveData* pSaveData = maPivotTableObject.GetSaveData();
+    if (pSaveData == nullptr)
+    {
+        mxCheckAddFilter->set_active(false);
+        mxCheckDrillToDetail->set_active(false);
+    }
+    else
+    {
+        mxCheckAddFilter->set_active(pSaveData->GetFilterButton());
+        mxCheckDrillToDetail->set_active(pSaveData->GetDrillDown());
+    }
+
+    mxCheckIgnoreEmptyRows->set_active(maPivotParameters.bIgnoreEmptyRows);
+    mxCheckIdentifyCategories->set_active(maPivotParameters.bDetectCategories);
+    mxCheckTotalColumns->set_active(maPivotParameters.bMakeTotalCol);
+    mxCheckTotalRows->set_active(maPivotParameters.bMakeTotalRow);
+
+    SetupSource();
+    SetupDestination();
+}
+
+ScPivotLayoutDialog::~ScPivotLayoutDialog()
+{
+}
+
+void ScPivotLayoutDialog::SetupSource()
+{
+    mxSourceListBox->clear();
+
+    ScRange aSourceRange;
+    OUString sSourceNamedRangeName;
+
+    if (maPivotTableObject.GetSheetDesc())
+    {
+        const ScSheetSourceDesc* pSheetSourceDesc = maPivotTableObject.GetSheetDesc();
+        aSourceRange = pSheetSourceDesc->GetSourceRange();
+
+        if(!aSourceRange.IsValid())
+        {
+            // Source is probably a DB Range
+            mxSourceRadioNamedRange->set_sensitive(false);
+            mxSourceRadioSelection->set_sensitive(false);
+            ToggleSource();
+            return;
+        }
+        else
+        {
+            OUString aSourceRangeName = aSourceRange.Format(mrDocument, ScRefFlags::RANGE_ABS_3D, maAddressDetails);
+            mxSourceEdit->SetText(aSourceRangeName);
+        }
+    }
+    else
+    {
+        mxSourceRadioNamedRange->set_sensitive(false);
+        mxSourceRadioSelection->set_sensitive(false);
+        ToggleSource();
+        return;
+    }
+
+    // Setup Named Ranges
+    bool bIsNamedRange = false;
+
+    ScAreaNameIterator aIterator(mrDocument);
+    OUString aEachName;
+    ScRange aEachRange;
+
+    while (aIterator.Next(aEachName, aEachRange))
+    {
+        if (!aIterator.WasDBName())
+        {
+            mxSourceListBox->append_text(aEachName);
+            if (aEachRange == aSourceRange)
+            {
+                sSourceNamedRangeName = aEachName;
+                bIsNamedRange = true;
+            }
+        }
+    }
+
+    bool bSourceBoxHasEntries = mxSourceListBox->get_count() > 0;
+
+    if (bIsNamedRange)
+    {
+        mxSourceListBox->set_active_text(sSourceNamedRangeName);
+        mxSourceRadioNamedRange->set_active(true);
+    }
+    else
+    {
+        // If entries - select first entry
+        mxSourceListBox->set_active(bSourceBoxHasEntries ? 0 : -1);
+        mxSourceRadioSelection->set_active(true);
+    }
+
+    // If no entries disable the radio button.
+    if (!bSourceBoxHasEntries)
+        mxSourceRadioNamedRange->set_sensitive(false);
+
+    ToggleSource();
+}
+
+void ScPivotLayoutDialog::SetupDestination()
+{
+    mxDestinationListBox->clear();
+
+    // Fill up named ranges
+    ScAreaNameIterator aIterator(mrDocument);
+    OUString aName;
+    ScRange aRange;
+
+    while (aIterator.Next(aName, aRange))
+    {
+        if (!aIterator.WasDBName())
+        {
+            mxDestinationListBox->append_text(aName);
+        }
+    }
+
+    // If entries - select first entry, otherwise disable the radio button.
+    if (mxDestinationListBox->get_count() > 0)
+        mxDestinationListBox->set_active(0);
+    else
+        mxDestinationRadioNamedRange->set_sensitive(false);
+
+    //
+    if (mbNewPivotTable)
+    {
+        mxDestinationRadioNewSheet->set_active(true);
+    }
+    else
+    {
+        if (maPivotParameters.nTab != MAXTAB + 1)
+        {
+            ScAddress aAddress(maPivotParameters.nCol, maPivotParameters.nRow, maPivotParameters.nTab);
+            OUString aAddressString = aAddress.Format(ScRefFlags::ADDR_ABS_3D, &mrDocument, maAddressDetails);
+            mxDestinationEdit->SetText(aAddressString);
+            mxDestinationRadioSelection->set_active(true);
+        }
+    }
+
+    ToggleDestination();
+}
+
+void ScPivotLayoutDialog::FillValuesToListBoxes()
+{
+    mxListBoxField->FillLabelFields(maPivotParameters.maLabelArray);
+    mxListBoxData->FillDataField(maPivotParameters.maDataFields);
+    mxListBoxColumn->FillFields(maPivotParameters.maColFields);
+    mxListBoxRow->FillFields(maPivotParameters.maRowFields);
+    mxListBoxPage->FillFields(maPivotParameters.maPageFields);
+}
+
+void ScPivotLayoutDialog::SetActive()
+{
+    if (mbDialogLostFocus)
+    {
+        mbDialogLostFocus = false;
+        if(mpActiveEdit != nullptr)
+        {
+            mpActiveEdit->GrabFocus();
+            if (mpActiveEdit == mxSourceEdit.get())
+                UpdateSourceRange();
+        }
+    }
+    else
+    {
+        m_xDialog->grab_focus();
+    }
+
+    RefInputDone();
+}
+
+void ScPivotLayoutDialog::SetReference(const ScRange& rReferenceRange, ScDocument& rDocument)
+{
+    if (!mbDialogLostFocus)
+        return;
+
+    if (mpActiveEdit == nullptr)
+        return;
+
+    if (rReferenceRange.aStart != rReferenceRange.aEnd)
+        RefInputStart(mpActiveEdit);
+
+    OUString aReferenceString = rReferenceRange.Format(rDocument, ScRefFlags::RANGE_ABS_3D, maAddressDetails);
+
+    if (mpActiveEdit == mxSourceEdit.get())
+    {
+        mxSourceEdit->SetRefString(aReferenceString);
+    }
+    else if (mpActiveEdit == mxDestinationEdit.get())
+    {
+        mxDestinationEdit->SetRefString(aReferenceString);
+    }
+}
+
+bool ScPivotLayoutDialog::IsRefInputMode() const
+{
+    return mbDialogLostFocus;
+}
+
+void ScPivotLayoutDialog::ItemInserted(const ScItemValue* pItemValue, ScPivotLayoutTreeList::SvPivotTreeListType eType)
+{
+    if (pItemValue == nullptr)
+        return;
+
+    switch (eType)
+    {
+        case ScPivotLayoutTreeList::ROW_LIST:
+        case ScPivotLayoutTreeList::COLUMN_LIST:
+        case ScPivotLayoutTreeList::PAGE_LIST:
+        {
+            mxListBoxRow->RemoveEntryForItem(pItemValue);
+            mxListBoxColumn->RemoveEntryForItem(pItemValue);
+            mxListBoxPage->RemoveEntryForItem(pItemValue);
+        }
+        break;
+        case ScPivotLayoutTreeList::LABEL_LIST:
+        {
+            mxListBoxRow->RemoveEntryForItem(pItemValue);
+            mxListBoxColumn->RemoveEntryForItem(pItemValue);
+            mxListBoxPage->RemoveEntryForItem(pItemValue);
+            mxListBoxData->RemoveEntryForItem(pItemValue);
+        }
+        break;
+        default:
+            break;
+    }
+}
+
+void ScPivotLayoutDialog::UpdateSourceRange()
+{
+    if (!maPivotTableObject.GetSheetDesc())
+       return;
+
+    ScSheetSourceDesc aSourceSheet = *maPivotTableObject.GetSheetDesc();
+
+    if (mxSourceRadioNamedRange->get_active())
+    {
+        OUString aEntryString = mxSourceListBox->get_active_text();
+        ScRange aSourceRange = lclGetRangeForNamedRange(aEntryString, mrDocument);
+        if (!aSourceRange.IsValid() || aSourceSheet.GetSourceRange() == aSourceRange)
+            return;
+        aSourceSheet.SetRangeName(aEntryString);
+    }
+    else if (mxSourceRadioSelection->get_active())
+    {
+        OUString aSourceString = mxSourceEdit->GetText();
+        ScRange aSourceRange;
+        ScRefFlags nResult = aSourceRange.Parse(aSourceString, mrDocument, maAddressDetails);
+
+        bool bIsValid = (nResult & ScRefFlags::VALID) == ScRefFlags::VALID; // aSourceString is valid
+
+        mxSourceEdit->SetRefValid(true);
+
+        if (bIsValid)
+        {
+            ScRefAddress aStart;
+            ScRefAddress aEnd;
+
+            ConvertDoubleRef(mrDocument, aSourceString, 1, aStart, aEnd, maAddressDetails);
+            aSourceRange.aStart = aStart.GetAddress();
+            aSourceRange.aEnd = aEnd.GetAddress();
+        }
+        else
+        {
+            aSourceRange = lclGetRangeForNamedRange(aSourceString, mrDocument);
+        }
+
+        if (!aSourceRange.IsValid())
+        {
+            mxSourceEdit->SetRefValid(false);
+            return;
+        }
+
+        if (aSourceSheet.GetSourceRange() == aSourceRange)
+                return;
+
+        aSourceSheet.SetSourceRange(aSourceRange);
+        if (aSourceSheet.CheckSourceRange())
+        {
+            mxSourceEdit->SetRefValid(false);
+            return;
+        }
+    }
+    else
+    {
+        return;
+    }
+
+    maPivotTableObject.SetSheetDesc(aSourceSheet);
+    maPivotTableObject.FillOldParam(maPivotParameters);
+    maPivotTableObject.FillLabelData(maPivotParameters);
+
+    FillValuesToListBoxes();
+}
+
+void ScPivotLayoutDialog::ApplyChanges()
+{
+    ScDPSaveData aSaveData;
+    ApplySaveData(aSaveData);
+    ApplyLabelData(aSaveData);
+
+    ScDPObject *pOldDPObj = mrDocument.GetDPAtCursor( maPivotParameters.nCol, maPivotParameters.nRow, maPivotParameters.nTab);
+    ScRange aDestinationRange;
+    bool bToNewSheet = false;
+
+    if (!GetDestination(aDestinationRange, bToNewSheet))
+        return;
+
+    SetDispatcherLock(false);
+    SwitchToDocument();
+
+    sal_uInt16 nWhichPivot = SC_MOD()->GetPool().GetWhich(SID_PIVOT_TABLE);
+    ScPivotItem aPivotItem(nWhichPivot, &aSaveData, &aDestinationRange, bToNewSheet);
+    mpViewData->GetViewShell()->SetDialogDPObject(std::make_unique<ScDPObject>(maPivotTableObject));
+
+
+    SfxDispatcher* pDispatcher = GetBindings().GetDispatcher();
+    SfxCallMode const nCallMode = SfxCallMode::SLOT | SfxCallMode::RECORD;
+    const SfxPoolItem* pResult = pDispatcher->ExecuteList(SID_PIVOT_TABLE,
+            nCallMode, { &aPivotItem });
+
+    if (pResult != nullptr)
+    {
+        // existing pivot table might have moved to a new range or a new sheet
+        if ( pOldDPObj != nullptr  )
+        {
+            const ScRange& rOldRange = pOldDPObj->GetOutRange();
+
+            ScDPObject *pDPObj = nullptr;
+            // FIXME: if the new range overlaps with the old one, the table actually doesn't move
+            // and shouldn't therefore be deleted
+            if ( ( ( rOldRange != aDestinationRange ) && !rOldRange.Contains( aDestinationRange ) )
+                 || bToNewSheet )
+            {
+                pDPObj = mrDocument.GetDPAtCursor( maPivotParameters.nCol, maPivotParameters.nRow, maPivotParameters.nTab);
+            }
+            if (pDPObj)
+            {
+                ScDBDocFunc aFunc( *(mpViewData->GetDocShell() ));
+                aFunc.RemovePivotTable( *pDPObj, true, false);
+                mpViewData->GetView()->CursorPosChanged();
+            }
+        }
+        return;
+    }
+
+    SetDispatcherLock(true);
+}
+
+void ScPivotLayoutDialog::ApplySaveData(ScDPSaveData& rSaveData)
+{
+    rSaveData.SetIgnoreEmptyRows(mxCheckIgnoreEmptyRows->get_active());
+    rSaveData.SetRepeatIfEmpty(mxCheckIdentifyCategories->get_active());
+    rSaveData.SetColumnGrand(mxCheckTotalColumns->get_active());
+    rSaveData.SetRowGrand(mxCheckTotalRows->get_active());
+    rSaveData.SetFilterButton(mxCheckAddFilter->get_active());
+    rSaveData.SetDrillDown(mxCheckDrillToDetail->get_active());
+
+    Reference<XDimensionsSupplier> xSource = maPivotTableObject.GetSource();
+
+    ScPivotFieldVector aPageFieldVector;
+    mxListBoxPage->PushEntriesToPivotFieldVector(aPageFieldVector);
+    ScDPObject::ConvertOrientation(rSaveData, aPageFieldVector, DataPilotFieldOrientation_PAGE,
+                                   xSource, maPivotParameters.maLabelArray);
+
+    ScPivotFieldVector aColFieldVector;
+    mxListBoxColumn->PushEntriesToPivotFieldVector(aColFieldVector);
+    ScDPObject::ConvertOrientation(rSaveData, aColFieldVector, DataPilotFieldOrientation_COLUMN,
+                                   xSource, maPivotParameters.maLabelArray);
+
+    ScPivotFieldVector aRowFieldVector;
+    mxListBoxRow->PushEntriesToPivotFieldVector(aRowFieldVector);
+    ScDPObject::ConvertOrientation(rSaveData, aRowFieldVector, DataPilotFieldOrientation_ROW,
+                                   xSource, maPivotParameters.maLabelArray);
+
+    ScPivotFieldVector aDataFieldVector;
+    mxListBoxData->PushEntriesToPivotFieldVector(aDataFieldVector);
+    ScDPObject::ConvertOrientation(rSaveData, aDataFieldVector, DataPilotFieldOrientation_DATA,
+                                   xSource, maPivotParameters.maLabelArray,
+                                   &aColFieldVector, &aRowFieldVector, &aPageFieldVector);
+}
+
+void ScPivotLayoutDialog::ApplyLabelData(const ScDPSaveData& rSaveData)
+{
+    ScDPLabelDataVector& rLabelDataVector = GetLabelDataVector();
+
+    for (std::unique_ptr<ScDPLabelData> const & pLabelData : rLabelDataVector)
+    {
+        OUString aUnoName = ScDPUtil::createDuplicateDimensionName(pLabelData->maName, pLabelData->mnDupCount);
+        ScDPSaveDimension* pSaveDimensions = rSaveData.GetExistingDimensionByName(aUnoName);
+
+        if (pSaveDimensions == nullptr)
+            continue;
+
+        pSaveDimensions->SetUsedHierarchy(pLabelData->mnUsedHier);
+        pSaveDimensions->SetShowEmpty(pLabelData->mbShowAll);
+        pSaveDimensions->SetRepeatItemLabels(pLabelData->mbRepeatItemLabels);
+        pSaveDimensions->SetSortInfo(&pLabelData->maSortInfo);
+        pSaveDimensions->SetLayoutInfo(&pLabelData->maLayoutInfo);
+        pSaveDimensions->SetAutoShowInfo(&pLabelData->maShowInfo);
+
+        bool bManualSort = (pLabelData->maSortInfo.Mode == DataPilotFieldSortMode::MANUAL);
+
+        for (ScDPLabelData::Member const & rLabelMember : pLabelData->maMembers)
+        {
+            ScDPSaveMember* pMember = pSaveDimensions->GetMemberByName(rLabelMember.maName);
+
+            if (bManualSort || !rLabelMember.mbVisible || !rLabelMember.mbShowDetails)
+            {
+                pMember->SetIsVisible(rLabelMember.mbVisible);
+                pMember->SetShowDetails(rLabelMember.mbShowDetails);
+            }
+        }
+    }
+}
+
+bool ScPivotLayoutDialog::GetDestination(ScRange& aDestinationRange, bool& bToNewSheet)
+{
+    bToNewSheet = false;
+
+    if (mxDestinationRadioNamedRange->get_active())
+    {
+        OUString aName = mxDestinationListBox->get_active_text();
+        aDestinationRange = lclGetRangeForNamedRange(aName, mrDocument);
+        if (!aDestinationRange.IsValid())
+            return false;
+    }
+    else if (mxDestinationRadioSelection->get_active())
+    {
+        ScAddress aAddress;
+        aAddress.Parse(mxDestinationEdit->GetText(), mrDocument, maAddressDetails);
+        aDestinationRange = ScRange(aAddress);
+    }
+    else
+    {
+        bToNewSheet = true;
+        aDestinationRange = ScRange(maPivotParameters.nCol, maPivotParameters.nRow, maPivotParameters.nTab);
+    }
+    return true;
+}
+
+ScItemValue* ScPivotLayoutDialog::GetItem(SCCOL nColumn)
+{
+    return mxListBoxField->GetItem(nColumn);
+}
+
+bool ScPivotLayoutDialog::IsDataElement(SCCOL nColumn)
+{
+    return mxListBoxField->IsDataElement(nColumn);
+}
+
+ScDPLabelData& ScPivotLayoutDialog::GetLabelData(SCCOL nColumn)
+{
+    return *maPivotParameters.maLabelArray[nColumn];
+}
+
+void ScPivotLayoutDialog::PushDataFieldNames(std::vector<ScDPName>& rDataFieldNames)
+{
+    mxListBoxData->PushDataFieldNames(rDataFieldNames);
+}
+
+void ScPivotLayoutDialog::Close()
+{
+    DoClose(ScPivotLayoutWrapper::GetChildWindowId());
+    SfxDialogController::Close();
+}
+
+IMPL_LINK_NOARG( ScPivotLayoutDialog, OKClicked, weld::Button&, void )
+{
+    /* tdf#137726 hide so it's not a candidate to be parent of any error
+       messages that may appear because this dialog is going to disappear on
+       response(RET_OK) and the error dialog is not run in its own event loop
+       but instead async */
+    m_xDialog->hide();
+
+    ApplyChanges();
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK_NOARG( ScPivotLayoutDialog, CancelClicked, weld::Button&, void )
+{
+    m_xDialog->response(RET_CANCEL);
+}
+
+IMPL_LINK(ScPivotLayoutDialog, GetEditFocusHandler, formula::RefEdit&, rCtrl, void)
+{
+    mpActiveEdit = &rCtrl;
+    mpActiveEdit->SelectAll();
+}
+
+IMPL_LINK(ScPivotLayoutDialog, GetButtonFocusHandler, formula::RefButton&, rCtrl, void)
+{
+    mpActiveEdit = nullptr;
+
+    if (&rCtrl == mxSourceButton.get())
+        mpActiveEdit = mxSourceEdit.get();
+    else if (&rCtrl == mxDestinationButton.get())
+        mpActiveEdit = mxDestinationEdit.get();
+
+    if (mpActiveEdit)
+        mpActiveEdit->SelectAll();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, LoseEditFocusHandler, formula::RefEdit&, void)
+{
+    mbDialogLostFocus = !m_xDialog->has_toplevel_focus();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, LoseButtonFocusHandler, formula::RefButton&, void)
+{
+    mbDialogLostFocus = !m_xDialog->has_toplevel_focus();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, SourceListSelected, weld::ComboBox&, void)
+{
+    UpdateSourceRange();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, SourceEditModified, formula::RefEdit&, void)
+{
+    UpdateSourceRange();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, ToggleSource, weld::Toggleable&, void)
+{
+    ToggleSource();
+}
+
+void ScPivotLayoutDialog::ToggleSource()
+{
+    bool bNamedRange = mxSourceRadioNamedRange->get_active();
+    bool bSelection = mxSourceRadioSelection->get_active();
+    mxSourceListBox->set_sensitive(bNamedRange);
+    mxSourceButton->GetWidget()->set_sensitive(bSelection);
+    mxSourceEdit->GetWidget()->set_sensitive(bSelection);
+    UpdateSourceRange();
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutDialog, ToggleDestination, weld::Toggleable&, void)
+{
+    ToggleDestination();
+}
+
+void ScPivotLayoutDialog::ToggleDestination()
+{
+    bool bNamedRange = mxDestinationRadioNamedRange->get_active();
+    bool bSelection = mxDestinationRadioSelection->get_active();
+    mxDestinationListBox->set_sensitive(bNamedRange);
+    mxDestinationButton->GetWidget()->set_sensitive(bSelection);
+    mxDestinationEdit->GetWidget()->set_sensitive(bSelection);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/PivotLayoutTreeList.cxx b/sc/source/ui/dbgui/PivotLayoutTreeList.cxx
new file mode 100644
index 000000000..c173d7ca7
--- /dev/null
+++ b/sc/source/ui/dbgui/PivotLayoutTreeList.cxx
@@ -0,0 +1,132 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ */
+
+#include <memory>
+#include <PivotLayoutTreeList.hxx>
+#include <PivotLayoutDialog.hxx>
+
+#include <vcl/event.hxx>
+#include <pivot.hxx>
+
+ScPivotLayoutTreeList::ScPivotLayoutTreeList(std::unique_ptr<weld::TreeView> xControl)
+    : ScPivotLayoutTreeListBase(std::move(xControl))
+{
+    mxControl->connect_key_press(LINK(this, ScPivotLayoutTreeList, KeyInputHdl));
+    mxControl->connect_row_activated(LINK(this, ScPivotLayoutTreeList, DoubleClickHdl));
+}
+
+ScPivotLayoutTreeList::~ScPivotLayoutTreeList()
+{
+    if (mpSubtotalDlg)
+    {
+        mpSubtotalDlg->Response(RET_CANCEL);
+        mpSubtotalDlg.clear();
+    }
+}
+
+void ScPivotLayoutTreeList::Setup(ScPivotLayoutDialog* pParent, SvPivotTreeListType eType)
+{
+    mpParent = pParent;
+    meType = eType;
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutTreeList, DoubleClickHdl, weld::TreeView&, bool)
+{
+    int nEntry = mxControl->get_cursor_index();
+    if (nEntry == -1)
+        return true;
+
+    ScItemValue* pCurrentItemValue = weld::fromId<ScItemValue*>(mxControl->get_id(nEntry));
+    ScPivotFuncData& rCurrentFunctionData = pCurrentItemValue->maFunctionData;
+    SCCOL nCurrentColumn = rCurrentFunctionData.mnCol;
+
+    if (mpParent->IsDataElement(nCurrentColumn))
+        return true;
+
+    ScDPLabelData& rCurrentLabelData = mpParent->GetLabelData(nCurrentColumn);
+
+    ScAbstractDialogFactory* pFactory = ScAbstractDialogFactory::Create();
+
+    maDataFieldNames.clear();
+    mpParent->PushDataFieldNames(maDataFieldNames);
+
+    mpSubtotalDlg = pFactory->CreateScDPSubtotalDlg(mxControl.get(), mpParent->maPivotTableObject,
+                                                    rCurrentLabelData, rCurrentFunctionData,
+                                                    maDataFieldNames);
+
+    mpSubtotalDlg->StartExecuteAsync([this, pCurrentItemValue, nCurrentColumn](int nResult) {
+        if (nResult == RET_OK)
+        {
+            mpSubtotalDlg->FillLabelData(mpParent->GetLabelData(nCurrentColumn));
+            pCurrentItemValue->maFunctionData.mnFuncMask = mpSubtotalDlg->GetFuncMask();
+        }
+
+        mpSubtotalDlg.disposeAndClear();
+    });
+
+    return true;
+}
+
+void ScPivotLayoutTreeList::FillFields(ScPivotFieldVector& rFieldVector)
+{
+    mxControl->clear();
+    maItemValues.clear();
+
+    for (const ScPivotField& rField : rFieldVector)
+    {
+        OUString aLabel = mpParent->GetItem(rField.nCol)->maName;
+        ScItemValue* pItemValue = new ScItemValue(aLabel, rField.nCol, rField.nFuncMask);
+        maItemValues.push_back(std::unique_ptr<ScItemValue>(pItemValue));
+        OUString sId(weld::toId(pItemValue));
+        mxControl->append(sId, pItemValue->maName);
+    }
+}
+
+void ScPivotLayoutTreeList::InsertEntryForSourceTarget(weld::TreeView& rSource, int nTarget)
+{
+    ScItemValue* pItemValue = weld::fromId<ScItemValue*>(rSource.get_selected_id());
+    ScItemValue* pOriginalItemValue = pItemValue->mpOriginalItemValue;
+
+    // Don't allow to add "Data" element to page fields
+    if (meType == PAGE_LIST && mpParent->IsDataElement(pItemValue->maFunctionData.mnCol))
+        return;
+
+    mpParent->ItemInserted(pOriginalItemValue, meType);
+
+    InsertEntryForItem(pOriginalItemValue, nTarget);
+}
+
+void ScPivotLayoutTreeList::InsertEntryForItem(const ScItemValue* pItemValue, int nPosition)
+{
+    ScItemValue* pListItemValue = new ScItemValue(pItemValue);
+    maItemValues.push_back(std::unique_ptr<ScItemValue>(pListItemValue));
+    OUString sName = pListItemValue->maName;
+    OUString sId(weld::toId(pListItemValue));
+    mxControl->insert(nullptr, nPosition, &sName, &sId, nullptr, nullptr, false, nullptr);
+}
+
+IMPL_LINK(ScPivotLayoutTreeList, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
+{
+    vcl::KeyCode aCode = rKeyEvent.GetKeyCode();
+    sal_uInt16 nCode = aCode.GetCode();
+
+    if (nCode == KEY_DELETE)
+    {
+        const int nEntry = mxControl->get_cursor_index();
+        if (nEntry != -1)
+            mxControl->remove(nEntry);
+        return true;
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/PivotLayoutTreeListBase.cxx b/sc/source/ui/dbgui/PivotLayoutTreeListBase.cxx
new file mode 100644
index 000000000..45af29a4f
--- /dev/null
+++ b/sc/source/ui/dbgui/PivotLayoutTreeListBase.cxx
@@ -0,0 +1,122 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ */
+
+#include <PivotLayoutTreeListBase.hxx>
+#include <PivotLayoutDialog.hxx>
+
+ScPivotLayoutTreeListBase::ScPivotLayoutTreeListBase(std::unique_ptr<weld::TreeView> xControl, SvPivotTreeListType eType)
+    : mxControl(std::move(xControl))
+    , maDropTargetHelper(*this)
+    , meType(eType)
+    , mpParent(nullptr)
+{
+    mxControl->connect_focus_in(LINK(this, ScPivotLayoutTreeListBase, GetFocusHdl));
+    mxControl->connect_mnemonic_activate(LINK(this, ScPivotLayoutTreeListBase, MnemonicActivateHdl));
+    mxControl->connect_focus_out(LINK(this, ScPivotLayoutTreeListBase, LoseFocusHdl));
+}
+
+ScPivotLayoutTreeListBase::~ScPivotLayoutTreeListBase()
+{
+}
+
+void ScPivotLayoutTreeListBase::Setup(ScPivotLayoutDialog* pParent)
+{
+    mpParent = pParent;
+}
+
+ScPivotLayoutTreeDropTarget::ScPivotLayoutTreeDropTarget(ScPivotLayoutTreeListBase& rTreeView)
+    : DropTargetHelper(rTreeView.get_widget().get_drop_target())
+    , m_rTreeView(rTreeView)
+{
+}
+
+sal_Int8 ScPivotLayoutTreeDropTarget::AcceptDrop(const AcceptDropEvent& rEvt)
+{
+    // to enable the autoscroll when we're close to the edges
+    weld::TreeView& rWidget = m_rTreeView.get_widget();
+    rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true);
+    return DND_ACTION_MOVE;
+}
+
+sal_Int8 ScPivotLayoutTreeDropTarget::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    weld::TreeView& rWidget = m_rTreeView.get_widget();
+    weld::TreeView* pSource = rWidget.get_drag_source();
+    if (!pSource)
+        return DND_ACTION_NONE;
+
+    std::unique_ptr<weld::TreeIter> xTarget(rWidget.make_iterator());
+    int nTargetPos = -1;
+    if (rWidget.get_dest_row_at_pos(rEvt.maPosPixel, xTarget.get(), true))
+        nTargetPos = rWidget.get_iter_index_in_parent(*xTarget);
+    m_rTreeView.InsertEntryForSourceTarget(*pSource, nTargetPos);
+    rWidget.unset_drag_dest_row();
+    return DND_ACTION_NONE;
+}
+
+void ScPivotLayoutTreeListBase::PushEntriesToPivotFieldVector(ScPivotFieldVector& rVector)
+{
+    std::unique_ptr<weld::TreeIter> xEachEntry(mxControl->make_iterator());
+    if (!mxControl->get_iter_first(*xEachEntry))
+        return;
+    do
+    {
+        ScItemValue* pItemValue = weld::fromId<ScItemValue*>(mxControl->get_id(*xEachEntry));
+        ScPivotFuncData& rFunctionData = pItemValue->maFunctionData;
+
+        ScPivotField aField;
+        aField.nCol          = rFunctionData.mnCol;
+        aField.mnOriginalDim = rFunctionData.mnOriginalDim;
+        aField.nFuncMask     = rFunctionData.mnFuncMask;
+        aField.mnDupCount    = rFunctionData.mnDupCount;
+        aField.maFieldRef    = rFunctionData.maFieldRef;
+        rVector.push_back(aField);
+    } while (mxControl->iter_next(*xEachEntry));
+}
+
+void ScPivotLayoutTreeListBase::InsertEntryForSourceTarget(weld::TreeView& /*pSource*/, int /*nTarget*/)
+{
+}
+
+void ScPivotLayoutTreeListBase::RemoveEntryForItem(const ScItemValue* pItemValue)
+{
+    OUString sId(weld::toId(pItemValue));
+    int nPos = mxControl->find_id(sId);
+    if (nPos == -1)
+        return;
+    mxControl->remove(nPos);
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutTreeListBase, GetFocusHdl, weld::Widget&, void)
+{
+    if (!mpParent)
+        return;
+    mpParent->mpPreviouslyFocusedListBox = this;
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutTreeListBase, MnemonicActivateHdl, weld::Widget&, bool)
+{
+    if (!mpParent || !mpParent->mpPreviouslyFocusedListBox)
+        return false;
+    weld::TreeView& rSource = mpParent->mpPreviouslyFocusedListBox->get_widget();
+    int nEntry = rSource.get_cursor_index();
+    if (nEntry != -1)
+        InsertEntryForSourceTarget(rSource, -1);
+    return true;
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutTreeListBase, LoseFocusHdl, weld::Widget&, void)
+{
+    if (!mpParent)
+        return;
+    mpParent->mpPreviouslyFocusedListBox = nullptr;
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/PivotLayoutTreeListData.cxx b/sc/source/ui/dbgui/PivotLayoutTreeListData.cxx
new file mode 100644
index 000000000..19992fc31
--- /dev/null
+++ b/sc/source/ui/dbgui/PivotLayoutTreeListData.cxx
@@ -0,0 +1,287 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ */
+
+#include <memory>
+#include <string_view>
+
+#include <PivotLayoutTreeListData.hxx>
+#include <PivotLayoutDialog.hxx>
+
+#include <vcl/event.hxx>
+#include <pivot.hxx>
+#include <globstr.hrc>
+#include <scresid.hxx>
+
+namespace
+{
+
+OUString lclGetFunctionMaskName(const PivotFunc nFunctionMask)
+{
+    TranslateId pStrId;
+    switch (nFunctionMask)
+    {
+        case PivotFunc::Sum:        pStrId = STR_FUN_TEXT_SUM;      break;
+        case PivotFunc::Count:      pStrId = STR_FUN_TEXT_COUNT;    break;
+        case PivotFunc::Average:    pStrId = STR_FUN_TEXT_AVG;      break;
+        case PivotFunc::Median:     pStrId = STR_FUN_TEXT_MEDIAN;   break;
+        case PivotFunc::Max:        pStrId = STR_FUN_TEXT_MAX;      break;
+        case PivotFunc::Min:        pStrId = STR_FUN_TEXT_MIN;      break;
+        case PivotFunc::Product:    pStrId = STR_FUN_TEXT_PRODUCT;  break;
+        case PivotFunc::CountNum:   pStrId = STR_FUN_TEXT_COUNT;    break;
+        case PivotFunc::StdDev:     pStrId = STR_FUN_TEXT_STDDEV;   break;
+        case PivotFunc::StdDevP:    pStrId = STR_FUN_TEXT_STDDEV;   break;
+        case PivotFunc::StdVar:     pStrId = STR_FUN_TEXT_VAR;      break;
+        case PivotFunc::StdVarP:    pStrId = STR_FUN_TEXT_VAR;      break;
+        default:
+            assert(false);
+            break;
+    }
+    if (pStrId)
+        return ScResId(pStrId);
+    else
+        return OUString();
+}
+
+OUString lclCreateDataItemName(const PivotFunc nFunctionMask, std::u16string_view rName, const sal_uInt8 nDuplicationCount)
+{
+    OUString aBuffer = lclGetFunctionMaskName(nFunctionMask) + " - " + rName;
+    if(nDuplicationCount > 0)
+    {
+        aBuffer += " " + OUString::number(nDuplicationCount);
+    }
+    return aBuffer;
+}
+
+} // anonymous namespace
+
+ScPivotLayoutTreeListData::ScPivotLayoutTreeListData(std::unique_ptr<weld::TreeView> xControl)
+    : ScPivotLayoutTreeListBase(std::move(xControl))
+{
+    mxControl->connect_key_press(LINK(this, ScPivotLayoutTreeListData, KeyInputHdl));
+    mxControl->connect_row_activated(LINK(this, ScPivotLayoutTreeListData, DoubleClickHdl));
+}
+
+ScPivotLayoutTreeListData::~ScPivotLayoutTreeListData()
+{
+    if (mpFunctionDlg)
+    {
+        mpFunctionDlg->Response(RET_CANCEL);
+        mpFunctionDlg.clear();
+    }
+}
+
+IMPL_LINK_NOARG(ScPivotLayoutTreeListData, DoubleClickHdl, weld::TreeView&, bool)
+{
+    int nEntry = mxControl->get_cursor_index();
+    if (nEntry == -1)
+        return true;
+
+    ScItemValue* pCurrentItemValue = weld::fromId<ScItemValue*>(mxControl->get_id(nEntry));
+    ScPivotFuncData& rCurrentFunctionData = pCurrentItemValue->maFunctionData;
+
+    SCCOL nCurrentColumn = rCurrentFunctionData.mnCol;
+    ScDPLabelData& rCurrentLabelData = mpParent->GetLabelData(nCurrentColumn);
+
+    ScAbstractDialogFactory* pFactory = ScAbstractDialogFactory::Create();
+
+    mpFunctionDlg = pFactory->CreateScDPFunctionDlg(mxControl.get(), mpParent->GetLabelDataVector(), rCurrentLabelData, rCurrentFunctionData);
+
+    mpFunctionDlg->StartExecuteAsync([this, pCurrentItemValue,
+                                rCurrentLabelData, nEntry](int nResult) mutable {
+        if (nResult == RET_OK)
+        {
+            ScPivotFuncData& rFunctionData = pCurrentItemValue->maFunctionData;
+            rFunctionData.mnFuncMask = mpFunctionDlg->GetFuncMask();
+            rCurrentLabelData.mnFuncMask = mpFunctionDlg->GetFuncMask();
+
+            rFunctionData.maFieldRef = mpFunctionDlg->GetFieldRef();
+
+            ScDPLabelData& rDFData = mpParent->GetLabelData(rFunctionData.mnCol);
+
+            AdjustDuplicateCount(pCurrentItemValue);
+
+            OUString sDataItemName = lclCreateDataItemName(
+                                        rFunctionData.mnFuncMask,
+                                        rDFData.maName,
+                                        rFunctionData.mnDupCount);
+
+            mxControl->set_text(nEntry, sDataItemName);
+        }
+
+        mpFunctionDlg->disposeOnce();
+    });
+
+    return true;
+}
+
+void ScPivotLayoutTreeListData::FillDataField(ScPivotFieldVector& rDataFields)
+{
+    mxControl->clear();
+    maDataItemValues.clear();
+
+    for (const ScPivotField& rField : rDataFields)
+    {
+        if (rField.nCol == PIVOT_DATA_FIELD)
+            continue;
+
+        SCCOL nColumn;
+        if (rField.mnOriginalDim >= 0)
+            nColumn = rField.mnOriginalDim;
+        else
+            nColumn = rField.nCol;
+
+        ScItemValue* pOriginalItemValue = mpParent->GetItem(nColumn);
+        ScItemValue* pItemValue = new ScItemValue(pOriginalItemValue->maName, nColumn, rField.nFuncMask);
+
+        pItemValue->mpOriginalItemValue = pOriginalItemValue;
+        pItemValue->maFunctionData.mnOriginalDim = rField.mnOriginalDim;
+        pItemValue->maFunctionData.maFieldRef = rField.maFieldRef;
+
+        AdjustDuplicateCount(pItemValue);
+        OUString sDataItemName = lclCreateDataItemName(pItemValue->maFunctionData.mnFuncMask,
+                                                       pItemValue->maName,
+                                                       pItemValue->maFunctionData.mnDupCount);
+
+        maDataItemValues.push_back(std::unique_ptr<ScItemValue>(pItemValue));
+        OUString sId(weld::toId(pItemValue));
+        mxControl->append(sId, sDataItemName);
+    }
+}
+
+void ScPivotLayoutTreeListData::PushDataFieldNames(std::vector<ScDPName>& rDataFieldNames)
+{
+    std::unique_ptr<weld::TreeIter> xLoopEntry(mxControl->make_iterator());
+    if (!mxControl->get_iter_first(*xLoopEntry))
+        return;
+
+    do
+    {
+        ScItemValue* pEachItemValue = weld::fromId<ScItemValue*>(mxControl->get_id(*xLoopEntry));
+        SCCOL nColumn = pEachItemValue->maFunctionData.mnCol;
+
+        ScDPLabelData& rLabelData = mpParent->GetLabelData(nColumn);
+
+        if (rLabelData.maName.isEmpty())
+            continue;
+
+        OUString sLayoutName = rLabelData.maLayoutName;
+        if (sLayoutName.isEmpty())
+        {
+            sLayoutName = lclCreateDataItemName(
+                            pEachItemValue->maFunctionData.mnFuncMask,
+                            pEachItemValue->maName,
+                            pEachItemValue->maFunctionData.mnDupCount);
+        }
+
+        rDataFieldNames.emplace_back(rLabelData.maName, sLayoutName, rLabelData.mnDupCount);
+    } while (mxControl->iter_next(*xLoopEntry));
+}
+
+void ScPivotLayoutTreeListData::InsertEntryForSourceTarget(weld::TreeView& rSource, int nTarget)
+{
+    if (rSource.count_selected_rows() <=0)
+        return;
+
+    ScItemValue* pItemValue = weld::fromId<ScItemValue*>(rSource.get_selected_id());
+
+    if (mpParent->IsDataElement(pItemValue->maFunctionData.mnCol))
+        return;
+
+    if (&rSource == mxControl.get())
+    {
+        OUString sText = mxControl->get_selected_text();
+        OUString sId(weld::toId(pItemValue));
+        mxControl->remove_id(sId);
+        mxControl->insert(nullptr, nTarget, &sText, &sId, nullptr, nullptr, false, nullptr);
+    }
+    else
+    {
+        InsertEntryForItem(pItemValue->mpOriginalItemValue, nTarget);
+    }
+}
+
+void ScPivotLayoutTreeListData::InsertEntryForItem(ScItemValue* pItemValue, int nPosition)
+{
+    ScItemValue* pDataItemValue = new ScItemValue(pItemValue);
+    pDataItemValue->mpOriginalItemValue = pItemValue;
+    maDataItemValues.push_back(std::unique_ptr<ScItemValue>(pDataItemValue));
+
+    ScPivotFuncData& rFunctionData = pDataItemValue->maFunctionData;
+
+    if (rFunctionData.mnFuncMask == PivotFunc::NONE ||
+        rFunctionData.mnFuncMask == PivotFunc::Auto)
+    {
+        rFunctionData.mnFuncMask = PivotFunc::Sum;
+    }
+
+    AdjustDuplicateCount(pDataItemValue);
+
+    OUString sDataName = lclCreateDataItemName(
+                            rFunctionData.mnFuncMask,
+                            pDataItemValue->maName,
+                            rFunctionData.mnDupCount);
+
+    OUString sId(weld::toId(pDataItemValue));
+    mxControl->insert(nullptr, nPosition, &sDataName, &sId, nullptr, nullptr, false, nullptr);
+}
+
+void ScPivotLayoutTreeListData::AdjustDuplicateCount(ScItemValue* pInputItemValue)
+{
+    ScPivotFuncData& rInputFunctionData = pInputItemValue->maFunctionData;
+
+    bool bFoundDuplicate = false;
+
+    rInputFunctionData.mnDupCount = 0;
+    sal_uInt8 nMaxDuplicateCount = 0;
+
+    std::unique_ptr<weld::TreeIter> xEachEntry(mxControl->make_iterator());
+    if (!mxControl->get_iter_first(*xEachEntry))
+        return;
+    do
+    {
+        ScItemValue* pItemValue = weld::fromId<ScItemValue*>(mxControl->get_id(*xEachEntry));
+        if (pItemValue == pInputItemValue)
+            continue;
+
+        ScPivotFuncData& rFunctionData = pItemValue->maFunctionData;
+
+        if (rFunctionData.mnCol      == rInputFunctionData.mnCol &&
+            rFunctionData.mnFuncMask == rInputFunctionData.mnFuncMask)
+        {
+            bFoundDuplicate = true;
+            if(rFunctionData.mnDupCount > nMaxDuplicateCount)
+                nMaxDuplicateCount = rFunctionData.mnDupCount;
+        }
+    } while (mxControl->iter_next(*xEachEntry));
+
+    if(bFoundDuplicate)
+    {
+        rInputFunctionData.mnDupCount = nMaxDuplicateCount + 1;
+    }
+}
+
+IMPL_LINK(ScPivotLayoutTreeListData, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
+{
+    vcl::KeyCode aCode = rKeyEvent.GetKeyCode();
+    sal_uInt16 nCode = aCode.GetCode();
+
+    if (nCode == KEY_DELETE)
+    {
+        int nEntry = mxControl->get_cursor_index();
+        if (nEntry != -1)
+            mxControl->remove(nEntry);
+        return true;
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/PivotLayoutTreeListLabel.cxx b/sc/source/ui/dbgui/PivotLayoutTreeListLabel.cxx
new file mode 100644
index 000000000..e4a2276da
--- /dev/null
+++ b/sc/source/ui/dbgui/PivotLayoutTreeListLabel.cxx
@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ */
+
+#include <memory>
+#include <PivotLayoutTreeListLabel.hxx>
+#include <PivotLayoutDialog.hxx>
+
+#include <vcl/event.hxx>
+#include <pivot.hxx>
+
+ScPivotLayoutTreeListLabel::ScPivotLayoutTreeListLabel(std::unique_ptr<weld::TreeView> xControl)
+    : ScPivotLayoutTreeListBase(std::move(xControl), LABEL_LIST)
+    , maDataItem(0)
+{
+    mxControl->connect_key_press(LINK(this, ScPivotLayoutTreeListLabel, KeyInputHdl));
+}
+
+ScPivotLayoutTreeListLabel::~ScPivotLayoutTreeListLabel()
+{}
+
+void ScPivotLayoutTreeListLabel::FillLabelFields(ScDPLabelDataVector& rLabelVector)
+{
+    mxControl->clear();
+    maItemValues.clear();
+
+    for (std::unique_ptr<ScDPLabelData> const & pLabelData : rLabelVector)
+    {
+        ScItemValue* pValue = new ScItemValue(pLabelData->maName, pLabelData->mnCol, pLabelData->mnFuncMask);
+        maItemValues.push_back(std::unique_ptr<ScItemValue>(pValue));
+        if (pLabelData->mbDataLayout)
+        {
+            maDataItem = maItemValues.size() - 1;
+        }
+
+        if (pLabelData->mnOriginalDim < 0 && !pLabelData->mbDataLayout)
+        {
+            mxControl->append(weld::toId(pValue), pLabelData->maName);
+        }
+    }
+}
+
+void ScPivotLayoutTreeListLabel::InsertEntryForSourceTarget(weld::TreeView& rSource, int /*nTarget*/)
+{
+    if (&rSource == mxControl.get())
+        return;
+    rSource.remove(rSource.get_selected_index());
+}
+
+bool ScPivotLayoutTreeListLabel::IsDataElement(SCCOL nColumn)
+{
+    return (nColumn == PIVOT_DATA_FIELD || nColumn == maDataItem);
+}
+
+ScItemValue* ScPivotLayoutTreeListLabel::GetItem(SCCOL nColumn)
+{
+    if (nColumn == PIVOT_DATA_FIELD)
+        return maItemValues[maDataItem].get();
+    return maItemValues[nColumn].get();
+}
+
+IMPL_LINK(ScPivotLayoutTreeListLabel, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
+{
+    vcl::KeyCode aCode = rKeyEvent.GetKeyCode();
+    sal_uInt16 nCode = aCode.GetCode();
+
+    if (nCode == KEY_DELETE)
+    {
+        int nEntry = mxControl->get_cursor_index();
+        if (nEntry != -1)
+            mxControl->remove(nEntry);
+        return true;
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/asciiopt.cxx b/sc/source/ui/dbgui/asciiopt.cxx
new file mode 100644
index 000000000..933491efb
--- /dev/null
+++ b/sc/source/ui/dbgui/asciiopt.cxx
@@ -0,0 +1,296 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <global.hxx>
+#include <asciiopt.hxx>
+#include <comphelper/string.hxx>
+#include <osl/thread.h>
+#include <o3tl/string_view.hxx>
+
+constexpr std::u16string_view pStrFix = u"FIX";
+constexpr std::u16string_view pStrMrg = u"MRG";
+
+ScAsciiOptions::ScAsciiOptions() :
+    bFixedLen       ( false ),
+    aFieldSeps      ( OUString(';') ),
+    bMergeFieldSeps ( false ),
+    bRemoveSpace    ( false ),
+    bQuotedFieldAsText(false),
+    bDetectSpecialNumber(false),
+    bEvaluateFormulas(true),
+    bSkipEmptyCells(false),
+    bSaveAsShown(true),
+    bSaveFormulas(false),
+    cTextSep        ( cDefaultTextSep ),
+    eCharSet        ( osl_getThreadTextEncoding() ),
+    eLang           ( LANGUAGE_SYSTEM ),
+    bCharSetSystem  ( false ),
+    nStartRow       ( 1 )
+{
+}
+
+void ScAsciiOptions::SetColumnInfo( const ScCsvExpDataVec& rDataVec )
+{
+    sal_uInt16 nInfoCount = static_cast< sal_uInt16 >( rDataVec.size() );
+    mvColStart.resize(nInfoCount);
+    mvColFormat.resize(nInfoCount);
+    for( sal_uInt16 nIx = 0; nIx < nInfoCount; ++nIx )
+    {
+        mvColStart[ nIx ] = rDataVec[ nIx ].mnIndex;
+        mvColFormat[ nIx ] = rDataVec[ nIx ].mnType;
+    }
+}
+
+static OUString lcl_decodeSepString( std::u16string_view rSepNums, bool & o_bMergeFieldSeps )
+{
+    if ( rSepNums.empty() )
+        return OUString();
+
+    OUStringBuffer aFieldSeps;
+    sal_Int32 nPos = 0;
+    do
+    {
+        const std::u16string_view aCode = o3tl::getToken(rSepNums, 0, '/', nPos );
+        if ( aCode == pStrMrg )
+            o_bMergeFieldSeps = true;
+        else
+        {
+            sal_Int32 nVal = o3tl::toInt32(aCode);
+            if ( nVal )
+                aFieldSeps.append(sal_Unicode(nVal));
+        }
+    }
+    while ( nPos >= 0 );
+
+    return aFieldSeps.makeStringAndClear();
+}
+
+// The options string must not contain semicolons (because of the pick list),
+// use comma as separator.
+
+void ScAsciiOptions::ReadFromString( std::u16string_view rString )
+{
+    sal_Int32 nPos = rString.empty() ? -1 : 0;
+
+    // Token 0: Field separator.
+    if ( nPos >= 0 )
+    {
+        bFixedLen = bMergeFieldSeps = false;
+
+        const std::u16string_view aToken = o3tl::getToken(rString, 0, ',', nPos);
+        if ( aToken == pStrFix )
+            bFixedLen = true;
+        aFieldSeps = lcl_decodeSepString( aToken, bMergeFieldSeps);
+    }
+
+    // Token 1: Text separator.
+    if ( nPos >= 0 )
+    {
+        const sal_Int32 nVal = o3tl::toInt32(o3tl::getToken(rString, 0, ',', nPos));
+        cTextSep = static_cast<sal_Unicode>(nVal);
+    }
+
+    // Token 2: Text encoding.
+    if ( nPos >= 0 )
+    {
+        eCharSet = ScGlobal::GetCharsetValue( o3tl::getToken(rString, 0, ',', nPos) );
+    }
+
+    // Token 3: Number of start row.
+    if ( nPos >= 0 )
+    {
+        nStartRow = o3tl::toInt32(o3tl::getToken(rString, 0, ',', nPos));
+    }
+
+    // Token 4: Column info.
+    if ( nPos >= 0 )
+    {
+        const std::u16string_view aToken = o3tl::getToken(rString, 0, ',', nPos);
+        const sal_Int32 nInfoCount = comphelper::string::getTokenCount(aToken, '/')/2;
+        mvColStart.resize(nInfoCount);
+        mvColFormat.resize(nInfoCount);
+        sal_Int32 nP = 0;
+        for (sal_Int32 nInfo=0; nInfo<nInfoCount; ++nInfo)
+        {
+            mvColStart[nInfo]  = o3tl::toInt32(o3tl::getToken(aToken, 0, '/', nP));
+            mvColFormat[nInfo] = static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(aToken, 0, '/', nP)));
+        }
+    }
+
+    // Token 5: Language.
+    if (nPos >= 0)
+    {
+        eLang = static_cast<LanguageType>(o3tl::toInt32(o3tl::getToken(rString, 0, ',', nPos)));
+    }
+
+    // Token 6: Import quoted field as text.
+    if (nPos >= 0)
+    {
+        bQuotedFieldAsText = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+
+    // Token 7: Detect special numbers.
+    if (nPos >= 0)
+    {
+        bDetectSpecialNumber = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+    else
+        bDetectSpecialNumber = true;    // default of versions that didn't add the parameter
+
+    // Token 8: used for "Save as shown" in export options
+    if ( nPos >= 0 )
+    {
+        bSaveAsShown = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+    else
+        bSaveAsShown = true;    // default value
+
+    // Token 9: used for "Save cell formulas" in export options
+    if ( nPos >= 0 )
+    {
+        bSaveFormulas = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+    else
+        bSaveFormulas = false;
+
+    // Token 10: Boolean for Trim spaces.
+    if (nPos >= 0)
+    {
+        bRemoveSpace = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+    else
+        bRemoveSpace = false;
+
+    // Token 11: sheet to export for --convert-to csv
+    // Does not need to be evaluated here but may be present.
+    if (nPos >= 0)
+    {
+        o3tl::getToken(rString, 0, ',', nPos);
+    }
+
+    // Token 12: evaluate formulas.
+    if (nPos >= 0)
+    {
+        // If present, defaults to "false".
+        bEvaluateFormulas = o3tl::getToken(rString, 0, ',', nPos) == u"true";
+    }
+    else
+        bEvaluateFormulas = true;   // default of versions that didn't add the parameter
+}
+
+OUString ScAsciiOptions::WriteToString() const
+{
+    OUStringBuffer aOutStr;
+
+    // Token 0: Field separator.
+    if ( bFixedLen )
+        aOutStr.append(pStrFix);
+    else if ( aFieldSeps.isEmpty() )
+        aOutStr.append("0");
+    else
+    {
+        sal_Int32 nLen = aFieldSeps.getLength();
+        for (sal_Int32 i=0; i<nLen; i++)
+        {
+            if (i)
+                aOutStr.append("/");
+            aOutStr.append(OUString::number(aFieldSeps[i]));
+        }
+        if ( bMergeFieldSeps )
+        {
+            aOutStr.append("/");
+            aOutStr.append(pStrMrg);
+        }
+    }
+
+    // Token 1: Text Quote character.
+    aOutStr.append("," + OUString::number(cTextSep) + ",");
+
+    //Token 2: Text encoding.
+    if ( bCharSetSystem )           // force "SYSTEM"
+        aOutStr.append(ScGlobal::GetCharsetString( RTL_TEXTENCODING_DONTKNOW ));
+    else
+        aOutStr.append(ScGlobal::GetCharsetString( eCharSet ));
+
+    //Token 3: Number of start row.
+    aOutStr.append("," + OUString::number(nStartRow) + ",");
+
+    //Token 4: Column info.
+    for (size_t nInfo=0; nInfo<mvColStart.size(); nInfo++)
+    {
+        if (nInfo)
+            aOutStr.append("/");
+        aOutStr.append(OUString::number(mvColStart[nInfo]) +
+                "/" +
+               OUString::number(mvColFormat[nInfo]));
+    }
+
+    // #i112025# the options string is used in macros and linked sheets,
+    // so new options must be added at the end, to remain compatible
+    // Always keep in sync with ScImportOptions.
+
+    aOutStr.append("," +
+               // Token 5: Language
+               OUString::number(static_cast<sal_uInt16>(eLang)) + "," +
+               // Token 6: Import quoted field as text.
+               OUString::boolean( bQuotedFieldAsText ) + "," +
+               // Token 7: Detect special numbers.
+               OUString::boolean( bDetectSpecialNumber ) + "," +
+               // Token 8: used for "Save as shown" in export options
+               OUString::boolean( bSaveAsShown ) +"," +
+               // Token 9: used for "Save cell formulas" in export options
+               OUString::boolean( bSaveFormulas ) + "," +
+               // Token 10: Trim Space
+               OUString::boolean( bRemoveSpace ) +
+               // Token 11: sheet to export, always 0 for current sheet
+               ",0," +
+               // Token 12: evaluate formulas in import
+               OUString::boolean( bEvaluateFormulas )
+            );
+    return aOutStr.makeStringAndClear();
+}
+
+// static
+sal_Unicode ScAsciiOptions::GetWeightedFieldSep( const OUString & rFieldSeps, bool bDecodeNumbers )
+{
+    bool bMergeFieldSeps = false;
+    OUString aFieldSeps( bDecodeNumbers ? lcl_decodeSepString( rFieldSeps, bMergeFieldSeps) : rFieldSeps);
+    if (aFieldSeps.isEmpty())
+    {
+        return 0;
+    }
+    else if (aFieldSeps.getLength() == 1)
+        return aFieldSeps[0];
+    else
+    {
+        // There can be only one separator for output. See also fdo#53449
+        if (aFieldSeps.indexOf(',') != -1)
+            return ',';
+        else if (aFieldSeps.indexOf('\t') != -1)
+            return '\t';
+        else if (aFieldSeps.indexOf(';') != -1)
+            return ';';
+        else if (aFieldSeps.indexOf(' ') != -1)
+            return ' ';
+        else
+            return aFieldSeps[0];
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/consdlg.cxx b/sc/source/ui/dbgui/consdlg.cxx
new file mode 100644
index 000000000..1dde53c18
--- /dev/null
+++ b/sc/source/ui/dbgui/consdlg.cxx
@@ -0,0 +1,535 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sfx2/dispatch.hxx>
+
+#include <tabvwsh.hxx>
+#include <uiitems.hxx>
+#include <dbdata.hxx>
+#include <rangenam.hxx>
+#include <rangeutl.hxx>
+#include <reffact.hxx>
+#include <document.hxx>
+#include <scresid.hxx>
+
+#include <globstr.hrc>
+#include <strings.hrc>
+
+#include <consdlg.hxx>
+#include <o3tl/safeint.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+namespace
+{
+    void INFOBOX(weld::Window* pWindow, TranslateId id)
+    {
+        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pWindow,
+                                                      VclMessageType::Info, VclButtonsType::Ok,
+                                                      ScResId(id)));
+        xInfoBox->run();
+    }
+}
+
+class ScAreaData
+{
+public:
+    ScAreaData()
+    {
+    }
+
+    void Set( const OUString& rName, const OUString& rArea )
+    {
+        aStrName  = rName;
+        aStrArea  = rArea;
+    }
+
+    OUString  aStrName;
+    OUString  aStrArea;
+};
+
+ScConsolidateDlg::ScConsolidateDlg(SfxBindings* pB, SfxChildWindow* pCW, weld::Window* pParent,
+                                   const SfxItemSet& rArgSet)
+
+    : ScAnyRefDlgController(pB, pCW, pParent, "modules/scalc/ui/consolidatedialog.ui", "ConsolidateDialog")
+    , aStrUndefined   ( ScResId( SCSTR_UNDEFINED ) )
+    , theConsData     ( static_cast<const ScConsolidateItem&>(
+                         rArgSet.Get( rArgSet.GetPool()->
+                                          GetWhich( SID_CONSOLIDATE ) )
+                                    ).GetData() )
+    , rViewData       ( static_cast<ScTabViewShell*>(SfxViewShell::Current())->
+                              GetViewData() )
+    , rDoc            ( static_cast<ScTabViewShell*>(SfxViewShell::Current())->
+                              GetViewData().GetDocument() )
+    , nAreaDataCount  ( 0 )
+    , nWhichCons      ( rArgSet.GetPool()->GetWhich( SID_CONSOLIDATE ) )
+    , bDlgLostFocus   ( false )
+    , m_xLbFunc(m_xBuilder->weld_combo_box("func"))
+    , m_xLbConsAreas(m_xBuilder->weld_tree_view("consareas"))
+    , m_xLbDataArea(m_xBuilder->weld_combo_box("lbdataarea"))
+    , m_xEdDataArea(new formula::RefEdit(m_xBuilder->weld_entry("eddataarea")))
+    , m_xRbDataArea(new formula::RefButton(m_xBuilder->weld_button("rbdataarea")))
+    , m_xLbDestArea(m_xBuilder->weld_combo_box("lbdestarea"))
+    , m_xEdDestArea(new formula::RefEdit(m_xBuilder->weld_entry("eddestarea")))
+    , m_xRbDestArea(new formula::RefButton(m_xBuilder->weld_button("rbdestarea")))
+    , m_xExpander(m_xBuilder->weld_expander("more"))
+    , m_xBtnByRow(m_xBuilder->weld_check_button("byrow"))
+    , m_xBtnByCol(m_xBuilder->weld_check_button("bycol"))
+    , m_xBtnRefs(m_xBuilder->weld_check_button("refs"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel"))
+    , m_xBtnAdd(m_xBuilder->weld_button("add"))
+    , m_xBtnRemove(m_xBuilder->weld_button("delete"))
+    , m_xDataFT(m_xBuilder->weld_label("ftdataarea"))
+    , m_xDestFT(m_xBuilder->weld_label("ftdestarea"))
+{
+    m_pRefInputEdit = m_xEdDataArea.get();
+    Init();
+}
+
+ScConsolidateDlg::~ScConsolidateDlg()
+{
+}
+
+void ScConsolidateDlg::Init()
+{
+    OUString aStr;
+    sal_uInt16 i=0;
+
+    m_xRbDataArea->SetReferences(this, m_xEdDataArea.get());
+    m_xEdDataArea->SetReferences(this, m_xDataFT.get());
+    m_xRbDestArea->SetReferences(this, m_xEdDestArea.get());
+    m_xEdDestArea->SetReferences(this, m_xDestFT.get());
+
+    m_xEdDataArea->SetGetFocusHdl( LINK( this, ScConsolidateDlg, GetEditFocusHdl ) );
+    m_xEdDestArea->SetGetFocusHdl( LINK( this, ScConsolidateDlg, GetEditFocusHdl ) );
+    m_xLbDataArea->connect_focus_in( LINK( this, ScConsolidateDlg, GetFocusHdl ) );
+    m_xLbDestArea->connect_focus_in( LINK( this, ScConsolidateDlg, GetFocusHdl ) );
+    m_xEdDataArea->SetModifyHdl( LINK( this, ScConsolidateDlg, ModifyHdl ) );
+    m_xEdDestArea->SetModifyHdl( LINK( this, ScConsolidateDlg, ModifyHdl ) );
+    m_xLbConsAreas->connect_changed( LINK( this, ScConsolidateDlg, SelectTVHdl ) );
+    m_xLbDataArea->connect_changed( LINK( this, ScConsolidateDlg, SelectCBHdl ) );
+    m_xLbDestArea->connect_changed( LINK( this, ScConsolidateDlg, SelectCBHdl ) );
+    m_xBtnOk->connect_clicked( LINK( this, ScConsolidateDlg, OkHdl ) );
+    m_xBtnCancel->connect_clicked( LINK( this, ScConsolidateDlg, ClickHdl ) );
+    m_xBtnAdd->connect_clicked( LINK( this, ScConsolidateDlg, ClickHdl ) );
+    m_xBtnRemove->connect_clicked( LINK( this, ScConsolidateDlg, ClickHdl ) );
+
+    m_xBtnAdd->set_sensitive(false);
+    m_xBtnRemove->set_sensitive(false);
+
+    m_xBtnByRow->set_active( theConsData.bByRow );
+    m_xBtnByCol->set_active( theConsData.bByCol );
+    m_xBtnRefs->set_active( theConsData.bReferenceData );
+
+    m_xLbFunc->set_active( FuncToLbPos( theConsData.eFunction ) );
+
+    m_xLbConsAreas->set_selection_mode(SelectionMode::Multiple);
+    m_xLbConsAreas->set_size_request(m_xLbConsAreas->get_approximate_digit_width() * 16,
+                                     m_xLbConsAreas->get_height_rows(5));
+
+    // read consolidation areas
+    m_xLbConsAreas->clear();
+    const formula::FormulaGrammar::AddressConvention eConv = rDoc.GetAddressConvention();
+    for ( i=0; i<theConsData.nDataAreaCount; i++ )
+    {
+        const ScArea& rArea = theConsData.pDataAreas[i];
+        if ( rArea.nTab < rDoc.GetTableCount() )
+        {
+            aStr = ScRange( rArea.nColStart, rArea.nRowStart, rArea.nTab,
+                    rArea.nColEnd, rArea.nRowEnd, rArea.nTab ).Format( rDoc,
+                        ScRefFlags::RANGE_ABS_3D, eConv );
+            m_xLbConsAreas->append_text(aStr);
+        }
+    }
+
+    if ( theConsData.nTab < rDoc.GetTableCount() )
+    {
+        aStr = ScAddress( theConsData.nCol, theConsData.nRow, theConsData.nTab
+                ).Format( ScRefFlags::ADDR_ABS_3D, &rDoc, eConv );
+        m_xEdDestArea->SetText( aStr );
+    }
+    else
+        m_xEdDestArea->SetText(OUString());
+
+    // Use the ScAreaData helper class to save those range names from the
+    // RangeNames and database ranges that appear in the ListBoxes.
+
+    ScRangeName*    pRangeNames  = rDoc.GetRangeName();
+    ScDBCollection* pDbNames     = rDoc.GetDBCollection();
+    size_t nRangeCount = pRangeNames ? pRangeNames->size() : 0;
+    size_t nDbCount = pDbNames ? pDbNames->getNamedDBs().size() : 0;
+
+    nAreaDataCount = nRangeCount+nDbCount;
+    pAreaData      = nullptr;
+
+    if ( nAreaDataCount > 0 )
+    {
+        pAreaData.reset( new ScAreaData[nAreaDataCount] );
+
+        OUString aStrName;
+        sal_uInt16 nAt = 0;
+        ScRange aRange;
+        ScAreaNameIterator aIter( rDoc );
+        while ( aIter.Next( aStrName, aRange ) )
+        {
+            OUString aStrArea(aRange.Format(rDoc, ScRefFlags::ADDR_ABS_3D, eConv));
+            pAreaData[nAt++].Set( aStrName, aStrArea );
+        }
+    }
+
+    FillAreaLists();
+    ModifyHdl( *m_xEdDestArea );
+    m_xLbDataArea->set_active( 0 );
+    m_xEdDataArea->SetText(OUString());
+    m_xEdDataArea->GrabFocus();
+
+    //aFlSep.SetStyle( aFlSep.GetStyle() | WB_VERT );
+
+    //@BugID 54702 enable/disable only in base class
+    //SFX_APPWINDOW->set_sensitive(true);
+}
+
+void ScConsolidateDlg::FillAreaLists()
+{
+    m_xLbDataArea->clear();
+    m_xLbDestArea->clear();
+    m_xLbDataArea->append_text( aStrUndefined );
+    m_xLbDestArea->append_text( aStrUndefined );
+
+    if ( pAreaData && (nAreaDataCount > 0) )
+    {
+        for ( size_t i=0;
+              (i<nAreaDataCount) && (!pAreaData[i].aStrName.isEmpty());
+              i++ )
+        {
+            m_xLbDataArea->append_text(pAreaData[i].aStrName);
+            m_xLbDestArea->append_text(pAreaData[i].aStrName);
+        }
+    }
+}
+
+// Handover of a range within a table that has been selected by the mouse.
+// This range is then shown in the reference window as new selection.
+
+void ScConsolidateDlg::SetReference( const ScRange& rRef, ScDocument& rDocP )
+{
+    if ( !m_pRefInputEdit )
+        return;
+
+    if ( rRef.aStart != rRef.aEnd )
+        RefInputStart( m_pRefInputEdit );
+
+    OUString      aStr;
+    ScRefFlags      nFmt = ScRefFlags::RANGE_ABS_3D;       //!!! nCurTab is still missing
+    const formula::FormulaGrammar::AddressConvention eConv = rDocP.GetAddressConvention();
+
+    if ( rRef.aStart.Tab() != rRef.aEnd.Tab() )
+        nFmt |= ScRefFlags::TAB2_3D;
+
+    if ( m_pRefInputEdit == m_xEdDataArea.get())
+        aStr = rRef.Format(rDocP, nFmt, eConv);
+    else if ( m_pRefInputEdit == m_xEdDestArea.get() )
+        aStr = rRef.aStart.Format(nFmt, &rDocP, eConv);
+
+    m_pRefInputEdit->SetRefString( aStr );
+    ModifyHdl( *m_pRefInputEdit );
+}
+
+void ScConsolidateDlg::Close()
+{
+    DoClose( ScConsolidateDlgWrapper::GetChildWindowId() );
+}
+
+void ScConsolidateDlg::SetActive()
+{
+    if ( bDlgLostFocus )
+    {
+        bDlgLostFocus = false;
+
+        if ( m_pRefInputEdit )
+        {
+            m_pRefInputEdit->GrabFocus();
+            ModifyHdl( *m_pRefInputEdit );
+        }
+    }
+    else
+        m_xDialog->grab_focus();
+
+    RefInputDone();
+}
+
+void ScConsolidateDlg::Deactivate()
+{
+    bDlgLostFocus = true;
+}
+
+bool ScConsolidateDlg::VerifyEdit( formula::RefEdit* pEd )
+{
+    if (pEd != m_xEdDataArea.get() && pEd != m_xEdDestArea.get())
+        return false;
+
+    SCTAB    nTab    = rViewData.GetTabNo();
+    bool bEditOk = false;
+    OUString theCompleteStr;
+    const formula::FormulaGrammar::AddressConvention eConv = rDoc.GetAddressConvention();
+
+    if ( pEd == m_xEdDataArea.get() )
+    {
+        bEditOk = ScRangeUtil::IsAbsArea( pEd->GetText(), rDoc,
+                                         nTab, &theCompleteStr, nullptr, nullptr, eConv );
+    }
+    else if ( pEd == m_xEdDestArea.get() )
+    {
+        OUString aPosStr;
+
+        ScRangeUtil::CutPosString( pEd->GetText(), aPosStr );
+        bEditOk = ScRangeUtil::IsAbsPos( aPosStr, rDoc,
+                                        nTab, &theCompleteStr, nullptr, eConv );
+    }
+
+    if ( bEditOk )
+        pEd->SetText( theCompleteStr );
+
+    return bEditOk;
+}
+
+// Handler:
+
+IMPL_LINK( ScConsolidateDlg, GetEditFocusHdl, formula::RefEdit&, rControl, void )
+{
+    m_pRefInputEdit = &rControl;
+}
+
+IMPL_LINK( ScConsolidateDlg, GetFocusHdl, weld::Widget&, rControl, void )
+{
+    if (&rControl == m_xLbDataArea.get())
+        m_pRefInputEdit = m_xEdDataArea.get();
+    else if (&rControl == m_xLbDestArea.get())
+        m_pRefInputEdit = m_xEdDestArea.get();
+}
+
+IMPL_LINK_NOARG(ScConsolidateDlg, OkHdl, weld::Button&, void)
+{
+    const sal_Int32 nDataAreaCount = m_xLbConsAreas->n_children();
+
+    if ( nDataAreaCount > 0 )
+    {
+        ScRefAddress aDestAddress;
+        SCTAB       nTab = rViewData.GetTabNo();
+        OUString    aDestPosStr( m_xEdDestArea->GetText() );
+        const formula::FormulaGrammar::AddressConvention eConv = rDoc.GetAddressConvention();
+
+        if ( ScRangeUtil::IsAbsPos( aDestPosStr, rDoc, nTab, nullptr, &aDestAddress, eConv ) )
+        {
+            ScConsolidateParam  theOutParam( theConsData );
+            std::unique_ptr<ScArea[]> pDataAreas(new ScArea[nDataAreaCount]);
+
+            for ( sal_Int32 i=0; i<nDataAreaCount; ++i )
+            {
+                ScRangeUtil::MakeArea(m_xLbConsAreas->get_text(i),
+                                      pDataAreas[i], rDoc, nTab, eConv);
+            }
+
+            theOutParam.nCol            = aDestAddress.Col();
+            theOutParam.nRow            = aDestAddress.Row();
+            theOutParam.nTab            = aDestAddress.Tab();
+            theOutParam.eFunction       = LbPosToFunc( m_xLbFunc->get_active() );
+            theOutParam.bByCol          = m_xBtnByCol->get_active();
+            theOutParam.bByRow          = m_xBtnByRow->get_active();
+            theOutParam.bReferenceData  = m_xBtnRefs->get_active();
+            theOutParam.SetAreas( std::move(pDataAreas), nDataAreaCount );
+
+            ScConsolidateItem aOutItem( nWhichCons, &theOutParam );
+
+            SetDispatcherLock( false );
+            SwitchToDocument();
+            GetBindings().GetDispatcher()->ExecuteList(SID_CONSOLIDATE,
+                                      SfxCallMode::SLOT | SfxCallMode::RECORD,
+                                      { &aOutItem });
+            response(RET_OK);
+        }
+        else
+        {
+            INFOBOX(m_xDialog.get(), STR_INVALID_TABREF);
+            m_xEdDestArea->GrabFocus();
+        }
+    }
+    else
+        response(RET_CANCEL); // no area defined -> Cancel
+}
+
+IMPL_LINK( ScConsolidateDlg, ClickHdl, weld::Button&, rBtn, void )
+{
+    if ( &rBtn == m_xBtnCancel.get() )
+        response(RET_CANCEL);
+    else if ( &rBtn == m_xBtnAdd.get() )
+    {
+        if ( !m_xEdDataArea->GetText().isEmpty() )
+        {
+            OUString    aNewEntry( m_xEdDataArea->GetText() );
+            std::unique_ptr<ScArea[]> ppAreas;
+            sal_uInt16      nAreaCount = 0;
+            const formula::FormulaGrammar::AddressConvention eConv = rDoc.GetAddressConvention();
+
+            if ( ScRangeUtil::IsAbsTabArea( aNewEntry, &rDoc, &ppAreas, &nAreaCount, true, eConv ) )
+            {
+                // IsAbsTabArea() creates an array of ScArea pointers,
+                // which have been created dynamically as well.
+                // These objects need to be deleted here.
+
+                for ( sal_uInt16 i=0; i<nAreaCount; i++ )
+                {
+                    const ScArea& rArea = ppAreas[i];
+                    OUString aNewArea = ScRange( rArea.nColStart, rArea.nRowStart, rArea.nTab,
+                            rArea.nColEnd, rArea.nRowEnd, rArea.nTab
+                            ).Format(rDoc, ScRefFlags::RANGE_ABS_3D, eConv);
+
+                    if (m_xLbConsAreas->find_text(aNewArea) == -1)
+                    {
+                        m_xLbConsAreas->append_text( aNewArea );
+                    }
+                }
+            }
+            else if ( VerifyEdit( m_xEdDataArea.get() ) )
+            {
+                OUString aNewArea( m_xEdDataArea->GetText() );
+
+                if (m_xLbConsAreas->find_text(aNewArea) == -1)
+                    m_xLbConsAreas->append_text(aNewArea);
+                else
+                    INFOBOX(m_xDialog.get(), STR_AREA_ALREADY_INSERTED);
+            }
+            else
+            {
+                INFOBOX(m_xDialog.get(), STR_INVALID_TABREF);
+                m_xEdDataArea->GrabFocus();
+            }
+        }
+    }
+    else if ( &rBtn == m_xBtnRemove.get() )
+    {
+        std::vector<int> aSelectedRows(m_xLbConsAreas->get_selected_rows());
+        std::sort(aSelectedRows.begin(), aSelectedRows.end());
+        for (auto it = aSelectedRows.rbegin(); it != aSelectedRows.rend(); ++it)
+            m_xLbConsAreas->remove(*it);
+        m_xBtnRemove->set_sensitive(false);
+    }
+}
+
+IMPL_LINK( ScConsolidateDlg, SelectTVHdl, weld::TreeView&, rLb, void )
+{
+    if (rLb.get_selected_index() != -1)
+        m_xBtnRemove->set_sensitive(true);
+    else
+        m_xBtnRemove->set_sensitive(false);
+}
+
+IMPL_LINK( ScConsolidateDlg, SelectCBHdl, weld::ComboBox&, rLb, void )
+{
+    formula::RefEdit* pEd = (&rLb == m_xLbDataArea.get()) ? m_xEdDataArea.get() : m_xEdDestArea.get();
+    const sal_Int32 nSelPos = rLb.get_active();
+
+    if (   (nSelPos > 0)
+        && (nAreaDataCount > 0)
+        && (pAreaData != nullptr) )
+    {
+        if ( o3tl::make_unsigned(nSelPos) <= nAreaDataCount )
+        {
+            OUString aString( pAreaData[nSelPos-1].aStrArea );
+
+            if ( &rLb == m_xLbDestArea.get() )
+                ScRangeUtil::CutPosString( aString, aString );
+
+            pEd->SetText( aString );
+
+            if ( pEd == m_xEdDataArea.get() )
+                m_xBtnAdd->set_sensitive(true);
+        }
+    }
+    else
+    {
+        pEd->SetText( OUString() );
+        if ( pEd == m_xEdDataArea.get() )
+            m_xBtnAdd->set_sensitive(true);
+    }
+}
+
+IMPL_LINK( ScConsolidateDlg, ModifyHdl, formula::RefEdit&, rEd, void )
+{
+    if ( &rEd == m_xEdDataArea.get() )
+    {
+        OUString aAreaStr( rEd.GetText() );
+        if ( !aAreaStr.isEmpty() )
+            m_xBtnAdd->set_sensitive(true);
+        else
+            m_xBtnAdd->set_sensitive(false);
+    }
+    else if ( &rEd == m_xEdDestArea.get() )
+    {
+        m_xLbDestArea->set_active(0);
+    }
+}
+
+// TODO: generalize!
+// Resource of the ListBox and these two conversion methods are also in
+// tpsubt and everywhere, where StarCalc functions are selectable.
+
+ScSubTotalFunc ScConsolidateDlg::LbPosToFunc( sal_Int32 nPos )
+{
+    switch ( nPos )
+    {
+        case  2:    return SUBTOTAL_FUNC_AVE;
+        case  6:    return SUBTOTAL_FUNC_CNT;
+        case  1:    return SUBTOTAL_FUNC_CNT2;
+        case  3:    return SUBTOTAL_FUNC_MAX;
+        case  4:    return SUBTOTAL_FUNC_MIN;
+        case  5:    return SUBTOTAL_FUNC_PROD;
+        case  7:    return SUBTOTAL_FUNC_STD;
+        case  8:    return SUBTOTAL_FUNC_STDP;
+        case  9:    return SUBTOTAL_FUNC_VAR;
+        case 10:    return SUBTOTAL_FUNC_VARP;
+        case  0:
+        default:
+            return SUBTOTAL_FUNC_SUM;
+    }
+}
+
+sal_Int32 ScConsolidateDlg::FuncToLbPos( ScSubTotalFunc eFunc )
+{
+    switch ( eFunc )
+    {
+        case SUBTOTAL_FUNC_AVE:     return 2;
+        case SUBTOTAL_FUNC_CNT:     return 6;
+        case SUBTOTAL_FUNC_CNT2:    return 1;
+        case SUBTOTAL_FUNC_MAX:     return 3;
+        case SUBTOTAL_FUNC_MIN:     return 4;
+        case SUBTOTAL_FUNC_PROD:    return 5;
+        case SUBTOTAL_FUNC_STD:     return 7;
+        case SUBTOTAL_FUNC_STDP:    return 8;
+        case SUBTOTAL_FUNC_VAR:     return 9;
+        case SUBTOTAL_FUNC_VARP:    return 10;
+        case SUBTOTAL_FUNC_NONE:
+        case SUBTOTAL_FUNC_SUM:
+        default:
+            return 0;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/csvcontrol.cxx b/sc/source/ui/dbgui/csvcontrol.cxx
new file mode 100644
index 000000000..409e898b4
--- /dev/null
+++ b/sc/source/ui/dbgui/csvcontrol.cxx
@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <csvcontrol.hxx>
+#include <vcl/keycodes.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/settings.hxx>
+
+ScCsvLayoutData::ScCsvLayoutData() :
+    mnPosCount( 1 ),
+    mnPosOffset( 0 ),
+    mnWinWidth( 1 ),
+    mnHdrWidth( 0 ),
+    mnCharWidth( 1 ),
+    mnLineCount( 1 ),
+    mnLineOffset( 0 ),
+    mnWinHeight( 1 ),
+    mnHdrHeight( 0 ),
+    mnLineHeight( 1 ),
+    mnPosCursor( CSV_POS_INVALID ),
+    mnColCursor( 0 ),
+    mnNoRepaint( 0 ),
+    mbAppRTL( AllSettings::GetLayoutRTL() )
+{
+}
+
+ScCsvDiff ScCsvLayoutData::GetDiff( const ScCsvLayoutData& rData ) const
+{
+    ScCsvDiff nRet = ScCsvDiff::Equal;
+    if( mnPosCount != rData.mnPosCount )        nRet |= ScCsvDiff::PosCount;
+    if( mnPosOffset != rData.mnPosOffset )      nRet |= ScCsvDiff::PosOffset;
+    if( mnHdrWidth != rData.mnHdrWidth )        nRet |= ScCsvDiff::HeaderWidth;
+    if( mnCharWidth != rData.mnCharWidth )      nRet |= ScCsvDiff::CharWidth;
+    if( mnLineCount != rData.mnLineCount )      nRet |= ScCsvDiff::LineCount;
+    if( mnLineOffset != rData.mnLineOffset )    nRet |= ScCsvDiff::LineOffset;
+    if( mnHdrHeight != rData.mnHdrHeight )      nRet |= ScCsvDiff::HeaderHeight;
+    if( mnLineHeight != rData.mnLineHeight )    nRet |= ScCsvDiff::LineHeight;
+    if( mnPosCursor != rData.mnPosCursor )      nRet |= ScCsvDiff::RulerCursor;
+    if( mnColCursor != rData.mnColCursor )      nRet |= ScCsvDiff::GridCursor;
+    return nRet;
+}
+
+ScCsvControl::ScCsvControl(const ScCsvLayoutData& rData)
+    : mrData(rData)
+    , mbValidGfx(false)
+{
+}
+
+ScCsvControl::~ScCsvControl()
+{
+    if( mxAccessible.is() )
+        mxAccessible->dispose();
+    mxAccessible = nullptr; // lp#1566050: prevent cyclic reference zombies
+}
+
+// event handling -------------------------------------------------------------
+
+void ScCsvControl::GetFocus()
+{
+    weld::CustomWidgetController::GetFocus();
+    AccSendFocusEvent( true );
+}
+
+void ScCsvControl::LoseFocus()
+{
+    weld::CustomWidgetController::LoseFocus();
+    AccSendFocusEvent( false );
+}
+
+void ScCsvControl::AccSendFocusEvent( bool bFocused )
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendFocusEvent( bFocused );
+}
+
+void ScCsvControl::AccSendCaretEvent()
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendCaretEvent();
+}
+
+void ScCsvControl::AccSendVisibleEvent()
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendVisibleEvent();
+}
+
+void ScCsvControl::AccSendSelectionEvent()
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendSelectionEvent();
+}
+
+void ScCsvControl::AccSendTableUpdateEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn, bool bAllRows )
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendTableUpdateEvent( nFirstColumn, nLastColumn, bAllRows );
+}
+
+void ScCsvControl::AccSendInsertColumnEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn )
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendInsertColumnEvent( nFirstColumn, nLastColumn );
+}
+
+void ScCsvControl::AccSendRemoveColumnEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn )
+{
+    if( mxAccessible.is() )
+        mxAccessible->SendRemoveColumnEvent( nFirstColumn, nLastColumn );
+}
+
+// repaint helpers ------------------------------------------------------------
+
+void ScCsvControl::Repaint( bool bInvalidate )
+{
+    if( bInvalidate )
+        InvalidateGfx();
+    if( !IsNoRepaint() )
+        Execute( CSVCMD_REPAINT );
+}
+
+void ScCsvControl::DisableRepaint()
+{
+    ++mrData.mnNoRepaint;
+}
+
+void ScCsvControl::EnableRepaint()
+{
+    OSL_ENSURE( IsNoRepaint(), "ScCsvControl::EnableRepaint - invalid call" );
+    --mrData.mnNoRepaint;
+    Repaint();
+}
+
+// command handling -----------------------------------------------------------
+
+void ScCsvControl::Execute( ScCsvCmdType eType, sal_Int32 nParam1, sal_Int32 nParam2 )
+{
+    maCmd.Set( eType, nParam1, nParam2 );
+    maCmdHdl.Call( *this );
+}
+
+// layout helpers -------------------------------------------------------------
+
+sal_Int32 ScCsvControl::GetVisPosCount() const
+{
+    return (mrData.mnWinWidth - GetHdrWidth()) / GetCharWidth();
+}
+
+sal_Int32 ScCsvControl::GetMaxPosOffset() const
+{
+    return std::max<sal_Int32>( GetPosCount() - GetVisPosCount() + 2, 0 );
+}
+
+bool ScCsvControl::IsValidSplitPos( sal_Int32 nPos ) const
+{
+    return (0 < nPos) && (nPos < GetPosCount() );
+}
+
+bool ScCsvControl::IsVisibleSplitPos( sal_Int32 nPos ) const
+{
+    return IsValidSplitPos( nPos ) && (GetFirstVisPos() <= nPos) && (nPos <= GetLastVisPos());
+}
+
+sal_Int32 ScCsvControl::GetHdrX() const
+{
+    return IsRTL() ? (mrData.mnWinWidth - GetHdrWidth()) : 0;
+}
+
+sal_Int32 ScCsvControl::GetFirstX() const
+{
+    return IsRTL() ? 0 : GetHdrWidth();
+}
+
+sal_Int32 ScCsvControl::GetLastX() const
+{
+    return mrData.mnWinWidth - (IsRTL() ? GetHdrWidth() : 0) - 1;
+}
+
+sal_Int32 ScCsvControl::GetX( sal_Int32 nPos ) const
+{
+    return GetFirstX() + (nPos - GetFirstVisPos()) * GetCharWidth();
+}
+
+sal_Int32 ScCsvControl::GetPosFromX( sal_Int32 nX ) const
+{
+    return (nX - GetFirstX() + GetCharWidth() / 2) / GetCharWidth() + GetFirstVisPos();
+}
+
+sal_Int32 ScCsvControl::GetVisLineCount() const
+{
+    return (mrData.mnWinHeight - GetHdrHeight() - 2) / GetLineHeight() + 1;
+}
+
+sal_Int32 ScCsvControl::GetLastVisLine() const
+{
+    return std::min( GetFirstVisLine() + GetVisLineCount(), GetLineCount() ) - 1;
+}
+
+sal_Int32 ScCsvControl::GetMaxLineOffset() const
+{
+    return std::max<sal_Int32>( GetLineCount() - GetVisLineCount() + 1, 0 );
+}
+
+bool ScCsvControl::IsValidLine( sal_Int32 nLine ) const
+{
+    return (0 <= nLine) && (nLine < GetLineCount());
+}
+
+bool ScCsvControl::IsVisibleLine( sal_Int32 nLine ) const
+{
+    return IsValidLine( nLine ) && (GetFirstVisLine() <= nLine) && (nLine <= GetLastVisLine());
+}
+
+sal_Int32 ScCsvControl::GetY( sal_Int32 nLine ) const
+{
+    return GetHdrHeight() + (nLine - GetFirstVisLine()) * GetLineHeight();
+}
+
+sal_Int32 ScCsvControl::GetLineFromY( sal_Int32 nY ) const
+{
+    return (nY - GetHdrHeight()) / GetLineHeight() + GetFirstVisLine();
+}
+
+// static helpers -------------------------------------------------------------
+
+void ScCsvControl::ImplInvertRect( OutputDevice& rOutDev, const tools::Rectangle& rRect )
+{
+    rOutDev.Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR | vcl::PushFlags::RASTEROP );
+    rOutDev.SetLineColor( COL_BLACK );
+    rOutDev.SetFillColor( COL_BLACK );
+    rOutDev.SetRasterOp( RasterOp::Invert );
+    rOutDev.DrawRect( rRect );
+    rOutDev.Pop();
+}
+
+ScMoveMode ScCsvControl::GetHorzDirection( sal_uInt16 nCode, bool bHomeEnd )
+{
+    switch( nCode )
+    {
+        case KEY_LEFT:  return MOVE_PREV;
+        case KEY_RIGHT: return MOVE_NEXT;
+    }
+    if( bHomeEnd ) switch( nCode )
+    {
+        case KEY_HOME:  return MOVE_FIRST;
+        case KEY_END:   return MOVE_LAST;
+    }
+    return MOVE_NONE;
+}
+
+ScMoveMode ScCsvControl::GetVertDirection( sal_uInt16 nCode, bool bHomeEnd )
+{
+    switch( nCode )
+    {
+        case KEY_UP:        return MOVE_PREV;
+        case KEY_DOWN:      return MOVE_NEXT;
+        case KEY_PAGEUP:    return MOVE_PREVPAGE;
+        case KEY_PAGEDOWN:  return MOVE_NEXTPAGE;
+    }
+    if( bHomeEnd ) switch( nCode )
+    {
+        case KEY_HOME:      return MOVE_FIRST;
+        case KEY_END:       return MOVE_LAST;
+    }
+    return MOVE_NONE;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/csvgrid.cxx b/sc/source/ui/dbgui/csvgrid.cxx
new file mode 100644
index 000000000..6752fcb78
--- /dev/null
+++ b/sc/source/ui/dbgui/csvgrid.cxx
@@ -0,0 +1,1418 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <csvgrid.hxx>
+#include <csvtablebox.hxx>
+
+#include <algorithm>
+#include <memory>
+
+#include <svtools/colorcfg.hxx>
+#include <sal/macros.h>
+#include <tools/poly.hxx>
+#include <scmod.hxx>
+#include <asciiopt.hxx>
+#include <impex.hxx>
+#include <AccessibleCsvControl.hxx>
+
+// *** edit engine ***
+#include <editeng/eeitem.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/event.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/weldutils.hxx>
+
+#include <editeng/colritem.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/fontitem.hxx>
+#include <editeng/wghtitem.hxx>
+#include <editeng/postitem.hxx>
+#include <editeng/langitem.hxx>
+#include <svl/itempool.hxx>
+#include <svl/itemset.hxx>
+#include <editutil.hxx>
+// *** edit engine ***
+
+namespace {
+
+struct Func_SetType
+{
+    sal_Int32                   mnType;
+    explicit                    Func_SetType( sal_Int32 nType ) : mnType( nType ) {}
+    void                 operator()( ScCsvColState& rState ) const
+        { rState.mnType = mnType; }
+};
+
+struct Func_Select
+{
+    bool                        mbSelect;
+    explicit                    Func_Select( bool bSelect ) : mbSelect( bSelect ) {}
+    void                 operator()( ScCsvColState& rState ) const
+        { rState.Select( mbSelect ); }
+};
+
+}
+
+ScCsvGrid::ScCsvGrid(const ScCsvLayoutData& rData, std::unique_ptr<weld::Menu> xPopup, ScCsvTableBox* pTableBox)
+    : ScCsvControl(rData)
+    , mpTableBox(pTableBox)
+    , mpBackgrDev( VclPtr<VirtualDevice>::Create() )
+    , mpGridDev( VclPtr<VirtualDevice>::Create() )
+    , mxPopup(std::move(xPopup))
+    , mpColorConfig( nullptr )
+    , mpEditEngine( new ScEditEngineDefaulter( EditEngine::CreatePool().get(), true ) )
+    , maColStates( 1 )
+    , maTypeNames( 1 )
+    , mnFirstImpLine( 0 )
+    , mnRecentSelCol( CSV_COLUMN_INVALID )
+    , mnMTCurrCol( SAL_MAX_UINT32 )
+    , mbTracking( false )
+    , mbMTSelecting( false )
+{
+    mpEditEngine->SetRefDevice( mpBackgrDev.get() );
+    mpEditEngine->SetRefMapMode( MapMode( MapUnit::MapPixel ) );
+    maEdEngSize = mpEditEngine->GetPaperSize();
+}
+
+void ScCsvGrid::SetDrawingArea(weld::DrawingArea* pDrawingArea)
+{
+    OutputDevice& rRefDevice = pDrawingArea->get_ref_device();
+    maHeaderFont = Application::GetSettings().GetStyleSettings().GetAppFont();
+
+    // expand the point size of the desired font to the equivalent pixel size
+    weld::SetPointFont(rRefDevice, maHeaderFont);
+    maHeaderFont = rRefDevice.GetFont();
+
+    // Because this is an always LeftToRight layout widget the initial size of
+    // this widget needs to be smaller than the size of the parent scrolling
+    // window (ScCsvTableBox ctor) because in RTL mode the alignment is against
+    // the right edge of the parent, and if larger than the scrolling window
+    // the left edge will be lost. If this widget is smaller than the scrolling
+    // window it is stretched to fit the parent and the problem doesn't arise.
+    Size aInitialSize(10, 10);
+    ScCsvControl::SetDrawingArea(pDrawingArea);
+    pDrawingArea->set_size_request(aInitialSize.Width(), aInitialSize.Height());
+    SetOutputSizePixel(aInitialSize);
+
+    EnableRTL( false ); // RTL
+
+    InitFonts();
+    ImplClearSplits();
+}
+
+ScCsvGrid::~ScCsvGrid()
+{
+    OSL_ENSURE(mpColorConfig, "the object hasn't been initialized properly");
+    if (mpColorConfig)
+        mpColorConfig->RemoveListener(this);
+    mpBackgrDev.disposeAndClear();
+    mpGridDev.disposeAndClear();
+}
+
+void
+ScCsvGrid::Init()
+{
+    OSL_PRECOND(!mpColorConfig, "the object has already been initialized");
+    mpColorConfig = &SC_MOD()->GetColorConfig();
+    InitColors();
+    mpColorConfig->AddListener(this);
+}
+
+// common grid handling -------------------------------------------------------
+
+void ScCsvGrid::UpdateLayoutData()
+{
+    DisableRepaint();
+    OutputDevice& rRefDevice = GetDrawingArea()->get_ref_device();
+    rRefDevice.SetFont(maMonoFont);
+    Execute(CSVCMD_SETCHARWIDTH, rRefDevice.GetTextWidth(OUString('X')));
+    Execute(CSVCMD_SETLINEHEIGHT, rRefDevice.GetTextHeight() + 1);
+    rRefDevice.SetFont(maHeaderFont);
+    Execute(CSVCMD_SETHDRHEIGHT, rRefDevice.GetTextHeight() + 1);
+    UpdateOffsetX();
+    EnableRepaint();
+}
+
+void ScCsvGrid::UpdateOffsetX()
+{
+    sal_Int32 nLastLine = GetLastVisLine() + 1;
+    sal_Int32 nDigits = 2;
+    for (;;)
+    {
+        nLastLine /= 10;
+        if (!nLastLine)
+            break;
+        ++nDigits;
+    }
+    nDigits = std::max( nDigits, sal_Int32( 3 ) );
+    Execute(CSVCMD_SETHDRWIDTH, GetDrawingArea()->get_approximate_digit_width() * nDigits);
+}
+
+void ScCsvGrid::ApplyLayout( const ScCsvLayoutData& rOldData )
+{
+    ScCsvDiff nDiff = GetLayoutData().GetDiff( rOldData );
+    if( nDiff == ScCsvDiff::Equal ) return;
+
+    DisableRepaint();
+
+    if( nDiff & ScCsvDiff::RulerCursor )
+    {
+        ImplInvertCursor( rOldData.mnPosCursor );
+        ImplInvertCursor( GetRulerCursorPos() );
+    }
+
+    if( nDiff & ScCsvDiff::PosCount )
+    {
+        if( GetPosCount() < rOldData.mnPosCount )
+        {
+            SelectAll( false );
+            maSplits.RemoveRange( GetPosCount(), rOldData.mnPosCount );
+        }
+        else
+            maSplits.Remove( rOldData.mnPosCount );
+        maSplits.Insert( GetPosCount() );
+        maColStates.resize( maSplits.Count() - 1 );
+    }
+
+    if( nDiff & ScCsvDiff::LineOffset )
+    {
+        Execute( CSVCMD_UPDATECELLTEXTS );
+        UpdateOffsetX();
+    }
+
+    ScCsvDiff nHVDiff = nDiff & (ScCsvDiff::HorizontalMask | ScCsvDiff::VerticalMask);
+    if( nHVDiff == ScCsvDiff::PosOffset )
+        ImplDrawHorzScrolled( rOldData.mnPosOffset );
+    else if( nHVDiff != ScCsvDiff::Equal )
+        InvalidateGfx();
+
+    EnableRepaint();
+
+    if( nDiff & (ScCsvDiff::PosOffset | ScCsvDiff::LineOffset) )
+        AccSendVisibleEvent();
+}
+
+void ScCsvGrid::SetFirstImportedLine( sal_Int32 nLine )
+{
+    ImplDrawFirstLineSep( false );
+    mnFirstImpLine = nLine;
+    ImplDrawFirstLineSep( true );
+    ImplDrawGridDev();
+    Repaint();
+}
+
+sal_Int32 ScCsvGrid::GetNoScrollCol( sal_Int32 nPos ) const
+{
+    sal_Int32 nNewPos = nPos;
+    if( nNewPos != CSV_POS_INVALID )
+    {
+        if( nNewPos < GetFirstVisPos() + CSV_SCROLL_DIST )
+        {
+            sal_Int32 nScroll = (GetFirstVisPos() > 0) ? CSV_SCROLL_DIST : 0;
+            nNewPos = GetFirstVisPos() + nScroll;
+        }
+        else if( nNewPos > GetLastVisPos() - CSV_SCROLL_DIST - 1 )
+        {
+            sal_Int32 nScroll = (GetFirstVisPos() < GetMaxPosOffset()) ? CSV_SCROLL_DIST : 0;
+            nNewPos = GetLastVisPos() - nScroll - 1;
+        }
+    }
+    return nNewPos;
+}
+
+void ScCsvGrid::InitColors()
+{
+    OSL_PRECOND(mpColorConfig, "the object hasn't been initialized properly");
+    if ( !mpColorConfig )
+        return;
+    maBackColor = mpColorConfig->GetColorValue( ::svtools::DOCCOLOR ).nColor;
+    maGridColor = mpColorConfig->GetColorValue( ::svtools::CALCGRID ).nColor;
+    maGridPBColor = mpColorConfig->GetColorValue( ::svtools::CALCPAGEBREAK ).nColor;
+    maAppBackColor = mpColorConfig->GetColorValue( ::svtools::APPBACKGROUND ).nColor;
+    maTextColor = mpColorConfig->GetColorValue( ::svtools::FONTCOLOR ).nColor;
+
+    const StyleSettings& rSett = Application::GetSettings().GetStyleSettings();
+    maHeaderBackColor = rSett.GetFaceColor();
+    maHeaderGridColor = rSett.GetDarkShadowColor();
+    maHeaderTextColor = rSett.GetButtonTextColor();
+    maSelectColor = rSett.GetActiveColor();
+
+    InvalidateGfx();
+}
+
+void ScCsvGrid::InitFonts()
+{
+    maMonoFont = OutputDevice::GetDefaultFont( DefaultFontType::FIXED, LANGUAGE_ENGLISH_US, GetDefaultFontFlags::NONE );
+    maMonoFont.SetFontSize( Size( maMonoFont.GetFontSize().Width(), maHeaderFont.GetFontSize().Height() ) );
+
+    /* *** Set edit engine defaults ***
+        maMonoFont for Latin script, smaller default font for Asian and Complex script. */
+
+    // get default fonts
+    SvxFontItem aLatinItem( EE_CHAR_FONTINFO );
+    SvxFontItem aAsianItem( EE_CHAR_FONTINFO_CJK );
+    SvxFontItem aComplexItem( EE_CHAR_FONTINFO_CTL );
+    ::GetDefaultFonts( aLatinItem, aAsianItem, aComplexItem );
+
+    // create item set for defaults
+    SfxItemSet aDefSet( mpEditEngine->GetEmptyItemSet() );
+    EditEngine::SetFontInfoInItemSet( aDefSet, maMonoFont );
+    aDefSet.Put( aAsianItem );
+    aDefSet.Put( aComplexItem );
+
+    // set Asian/Complex font size to height of character in Latin font
+    sal_uLong nFontHt = static_cast< sal_uLong >( maMonoFont.GetFontSize().Height() );
+    aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CJK ) );
+    aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CTL ) );
+
+    // copy other items from default font
+    const SfxPoolItem& rWeightItem = aDefSet.Get( EE_CHAR_WEIGHT );
+    std::unique_ptr<SfxPoolItem> pNewItem(rWeightItem.Clone());
+    pNewItem->SetWhich(EE_CHAR_WEIGHT_CJK);
+    aDefSet.Put( *pNewItem );
+    pNewItem->SetWhich(EE_CHAR_WEIGHT_CTL);
+    aDefSet.Put( *pNewItem );
+    const SfxPoolItem& rItalicItem = aDefSet.Get( EE_CHAR_ITALIC );
+    pNewItem.reset(rItalicItem.Clone());
+    pNewItem->SetWhich(EE_CHAR_ITALIC_CJK);
+    aDefSet.Put( *pNewItem );
+    pNewItem->SetWhich(EE_CHAR_ITALIC_CTL);
+    aDefSet.Put( *pNewItem );
+    const SfxPoolItem& rLangItem = aDefSet.Get( EE_CHAR_LANGUAGE );
+    pNewItem.reset(rLangItem.Clone());
+    pNewItem->SetWhich(EE_CHAR_LANGUAGE_CJK);
+    aDefSet.Put( *pNewItem );
+    pNewItem->SetWhich(EE_CHAR_LANGUAGE_CTL);
+    aDefSet.Put( *pNewItem );
+
+    mpEditEngine->SetDefaults( aDefSet );
+    InvalidateGfx();
+}
+
+void ScCsvGrid::InitSizeData()
+{
+    maWinSize = GetOutputSizePixel();
+    mpBackgrDev->SetOutputSizePixel( maWinSize );
+    mpGridDev->SetOutputSizePixel( maWinSize );
+    InvalidateGfx();
+}
+
+// split handling -------------------------------------------------------------
+
+void ScCsvGrid::InsertSplit( sal_Int32 nPos )
+{
+    if( ImplInsertSplit( nPos ) )
+    {
+        DisableRepaint();
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+        Execute( CSVCMD_UPDATECELLTEXTS );
+        sal_uInt32 nColIx = GetColumnFromPos( nPos );
+        ImplDrawColumn( nColIx - 1 );
+        ImplDrawColumn( nColIx );
+        ValidateGfx();  // performance: do not redraw all columns
+        EnableRepaint();
+    }
+}
+
+void ScCsvGrid::RemoveSplit( sal_Int32 nPos )
+{
+    if( ImplRemoveSplit( nPos ) )
+    {
+        DisableRepaint();
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+        Execute( CSVCMD_UPDATECELLTEXTS );
+        ImplDrawColumn( GetColumnFromPos( nPos ) );
+        ValidateGfx();  // performance: do not redraw all columns
+        EnableRepaint();
+    }
+}
+
+void ScCsvGrid::MoveSplit( sal_Int32 nPos, sal_Int32 nNewPos )
+{
+    sal_uInt32 nColIx = GetColumnFromPos( nPos );
+    if( nColIx == CSV_COLUMN_INVALID )
+        return;
+
+    DisableRepaint();
+    if( (GetColumnPos( nColIx - 1 ) < nNewPos) && (nNewPos < GetColumnPos( nColIx + 1 )) )
+    {
+        // move a split in the range between 2 others -> keep selection state of both columns
+        maSplits.Remove( nPos );
+        maSplits.Insert( nNewPos );
+        Execute( CSVCMD_UPDATECELLTEXTS );
+        ImplDrawColumn( nColIx - 1 );
+        ImplDrawColumn( nColIx );
+        ValidateGfx();  // performance: do not redraw all columns
+        AccSendTableUpdateEvent( nColIx - 1, nColIx );
+    }
+    else
+    {
+        ImplRemoveSplit( nPos );
+        ImplInsertSplit( nNewPos );
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+        Execute( CSVCMD_UPDATECELLTEXTS );
+    }
+    EnableRepaint();
+}
+
+void ScCsvGrid::RemoveAllSplits()
+{
+    DisableRepaint();
+    ImplClearSplits();
+    Execute( CSVCMD_EXPORTCOLUMNTYPE );
+    Execute( CSVCMD_UPDATECELLTEXTS );
+    EnableRepaint();
+}
+
+void ScCsvGrid::SetSplits( const ScCsvSplits& rSplits )
+{
+    DisableRepaint();
+    ImplClearSplits();
+    sal_uInt32 nCount = rSplits.Count();
+    for( sal_uInt32 nIx = 0; nIx < nCount; ++nIx )
+        maSplits.Insert( rSplits[ nIx ] );
+    maColStates.clear();
+    maColStates.resize( maSplits.Count() - 1 );
+    Execute( CSVCMD_EXPORTCOLUMNTYPE );
+    Execute( CSVCMD_UPDATECELLTEXTS );
+    EnableRepaint();
+}
+
+bool ScCsvGrid::ImplInsertSplit( sal_Int32 nPos )
+{
+    sal_uInt32 nColIx = GetColumnFromPos( nPos );
+    bool bRet = (nColIx < GetColumnCount()) && maSplits.Insert( nPos );
+    if( bRet )
+    {
+        ScCsvColState aState( GetColumnType( nColIx ) );
+        aState.Select( IsSelected( nColIx ) && IsSelected( nColIx + 1 ) );
+        maColStates.insert( maColStates.begin() + nColIx + 1, aState );
+        AccSendInsertColumnEvent( nColIx + 1, nColIx + 1 );
+        AccSendTableUpdateEvent( nColIx, nColIx );
+    }
+    return bRet;
+}
+
+bool ScCsvGrid::ImplRemoveSplit( sal_Int32 nPos )
+{
+    bool bRet = maSplits.Remove( nPos );
+    if( bRet )
+    {
+        sal_uInt32 nColIx = GetColumnFromPos( nPos );
+        bool bSel = IsSelected( nColIx ) || IsSelected( nColIx + 1 );
+        maColStates.erase( maColStates.begin() + nColIx + 1 );
+        maColStates[ nColIx ].Select( bSel );
+        AccSendRemoveColumnEvent( nColIx + 1, nColIx + 1 );
+        AccSendTableUpdateEvent( nColIx, nColIx );
+    }
+    return bRet;
+}
+
+void ScCsvGrid::ImplClearSplits()
+{
+    sal_uInt32 nColumns = GetColumnCount();
+    maSplits.Clear();
+    maSplits.Insert( 0 );
+    maSplits.Insert( GetPosCount() );
+    maColStates.resize( 1 );
+    InvalidateGfx();
+    AccSendRemoveColumnEvent( 1, nColumns - 1 );
+}
+
+// columns/column types -------------------------------------------------------
+
+sal_uInt32 ScCsvGrid::GetFirstVisColumn() const
+{
+    return GetColumnFromPos( GetFirstVisPos() );
+}
+
+sal_uInt32 ScCsvGrid::GetLastVisColumn() const
+{
+    return GetColumnFromPos( std::min( GetLastVisPos(), GetPosCount() ) - 1 );
+}
+
+bool ScCsvGrid::IsValidColumn( sal_uInt32 nColIndex ) const
+{
+    return nColIndex < GetColumnCount();
+}
+
+bool ScCsvGrid::IsVisibleColumn( sal_uInt32 nColIndex ) const
+{
+    return  IsValidColumn( nColIndex ) &&
+            (GetColumnPos( nColIndex ) < GetLastVisPos()) &&
+            (GetFirstVisPos() < GetColumnPos( nColIndex + 1 ));
+}
+
+sal_Int32 ScCsvGrid::GetColumnX( sal_uInt32 nColIndex ) const
+{
+    return GetX( GetColumnPos( nColIndex ) );
+}
+
+sal_uInt32 ScCsvGrid::GetColumnFromX( sal_Int32 nX ) const
+{
+    sal_Int32 nPos = (nX - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
+    return ((GetFirstVisPos() <= nPos) && (nPos <= GetLastVisPos())) ?
+        GetColumnFromPos( nPos ) : CSV_COLUMN_INVALID;
+}
+
+sal_uInt32 ScCsvGrid::GetColumnFromPos( sal_Int32 nPos ) const
+{
+    return maSplits.UpperBound( nPos );
+}
+
+sal_Int32 ScCsvGrid::GetColumnWidth( sal_uInt32 nColIndex ) const
+{
+    return IsValidColumn( nColIndex ) ? (GetColumnPos( nColIndex + 1 ) - GetColumnPos( nColIndex )) : 0;
+}
+
+void ScCsvGrid::SetColumnStates( ScCsvColStateVec&& rStates )
+{
+    maColStates = std::move(rStates);
+    maColStates.resize( maSplits.Count() - 1 );
+    Execute( CSVCMD_EXPORTCOLUMNTYPE );
+    AccSendTableUpdateEvent( 0, GetColumnCount(), false );
+    AccSendSelectionEvent();
+}
+
+sal_Int32 ScCsvGrid::GetColumnType( sal_uInt32 nColIndex ) const
+{
+    return IsValidColumn( nColIndex ) ? maColStates[ nColIndex ].mnType : CSV_TYPE_NOSELECTION;
+}
+
+void ScCsvGrid::SetColumnType( sal_uInt32 nColIndex, sal_Int32 nColType )
+{
+    if( IsValidColumn( nColIndex ) )
+    {
+        maColStates[ nColIndex ].mnType = nColType;
+        AccSendTableUpdateEvent( nColIndex, nColIndex, false );
+    }
+}
+
+sal_Int32 ScCsvGrid::GetSelColumnType() const
+{
+    sal_uInt32 nColIx = GetFirstSelected();
+    if( nColIx == CSV_COLUMN_INVALID )
+        return CSV_TYPE_NOSELECTION;
+
+    sal_Int32 nType = GetColumnType( nColIx );
+    while( (nColIx != CSV_COLUMN_INVALID) && (nType != CSV_TYPE_MULTI) )
+    {
+        if( nType != GetColumnType( nColIx ) )
+            nType = CSV_TYPE_MULTI;
+        nColIx = GetNextSelected( nColIx );
+    }
+    return nType;
+}
+
+void ScCsvGrid::SetSelColumnType( sal_Int32 nType )
+{
+    if( (nType != CSV_TYPE_MULTI) && (nType != CSV_TYPE_NOSELECTION) )
+    {
+        for( sal_uInt32 nColIx = GetFirstSelected(); nColIx != CSV_COLUMN_INVALID; nColIx = GetNextSelected( nColIx ) )
+            SetColumnType( nColIx, nType );
+        Repaint( true );
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+    }
+}
+
+void ScCsvGrid::SetTypeNames( std::vector<OUString>&& rTypeNames )
+{
+    OSL_ENSURE( !rTypeNames.empty(), "ScCsvGrid::SetTypeNames - vector is empty" );
+    maTypeNames = std::move(rTypeNames);
+    Repaint( true );
+
+    mxPopup->clear();
+    sal_uInt32 nCount = maTypeNames.size();
+    for (sal_uInt32 nIx = 0; nIx < nCount; ++nIx)
+        mxPopup->append(OUString::number(nIx), maTypeNames[nIx]);
+
+    ::std::for_each( maColStates.begin(), maColStates.end(), Func_SetType( CSV_TYPE_DEFAULT ) );
+}
+
+OUString ScCsvGrid::GetColumnTypeName( sal_uInt32 nColIndex ) const
+{
+    sal_uInt32 nTypeIx = static_cast< sal_uInt32 >( GetColumnType( nColIndex ) );
+    return (nTypeIx < maTypeNames.size()) ? maTypeNames[ nTypeIx ] : OUString();
+}
+
+static sal_uInt8 lcl_GetExtColumnType( sal_Int32 nIntType )
+{
+    static const sal_uInt8 pExtTypes[] =
+        { SC_COL_STANDARD, SC_COL_TEXT, SC_COL_DMY, SC_COL_MDY, SC_COL_YMD, SC_COL_ENGLISH, SC_COL_SKIP };
+    static const sal_Int32 nExtTypeCount = SAL_N_ELEMENTS(pExtTypes);
+    return pExtTypes[ ((0 <= nIntType) && (nIntType < nExtTypeCount)) ? nIntType : 0 ];
+}
+
+void ScCsvGrid::FillColumnDataSep( ScAsciiOptions& rOptions ) const
+{
+    sal_uInt32 nCount = GetColumnCount();
+    ScCsvExpDataVec aDataVec;
+
+    for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
+    {
+        if( GetColumnType( nColIx ) != CSV_TYPE_DEFAULT )
+            // 1-based column index
+            aDataVec.emplace_back(
+                static_cast< sal_Int32 >( nColIx + 1 ),
+                lcl_GetExtColumnType( GetColumnType( nColIx ) ) );
+    }
+    rOptions.SetColumnInfo( aDataVec );
+}
+
+void ScCsvGrid::FillColumnDataFix( ScAsciiOptions& rOptions ) const
+{
+    sal_uInt32 nCount = std::min( GetColumnCount(), static_cast<sal_uInt32>(MAXCOLCOUNT) );
+    ScCsvExpDataVec aDataVec( nCount + 1 );
+
+    for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
+    {
+        ScCsvExpData& rData = aDataVec[ nColIx ];
+        rData.mnIndex = GetColumnPos( nColIx );
+        rData.mnType = lcl_GetExtColumnType( GetColumnType( nColIx ) );
+    }
+    aDataVec[ nCount ].mnIndex = SAL_MAX_INT32;
+    aDataVec[ nCount ].mnType = SC_COL_SKIP;
+    rOptions.SetColumnInfo( aDataVec );
+}
+
+void ScCsvGrid::ScrollVertRel( ScMoveMode eDir )
+{
+    sal_Int32 nLine = GetFirstVisLine();
+    switch( eDir )
+    {
+        case MOVE_PREV:     --nLine;                        break;
+        case MOVE_NEXT:     ++nLine;                        break;
+        case MOVE_FIRST:    nLine = 0;                      break;
+        case MOVE_LAST:     nLine = GetMaxLineOffset();     break;
+        case MOVE_PREVPAGE: nLine -= GetVisLineCount() - 2; break;
+        case MOVE_NEXTPAGE: nLine += GetVisLineCount() - 2; break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+    Execute( CSVCMD_SETLINEOFFSET, nLine );
+}
+
+void ScCsvGrid::ExecutePopup( const Point& rPos )
+{
+    OString sItemId = mxPopup->popup_at_rect(GetDrawingArea(), tools::Rectangle(rPos, Size(1, 1)));
+    if (!sItemId.isEmpty())   // empty = cancelled
+        Execute(CSVCMD_SETCOLUMNTYPE, sItemId.toInt32());
+}
+
+// selection handling ---------------------------------------------------------
+
+bool ScCsvGrid::IsSelected( sal_uInt32 nColIndex ) const
+{
+    return IsValidColumn( nColIndex ) && maColStates[ nColIndex ].IsSelected();
+}
+
+sal_uInt32 ScCsvGrid::GetFirstSelected() const
+{
+    return IsSelected( 0 ) ? 0 : GetNextSelected( 0 );
+}
+
+sal_uInt32 ScCsvGrid::GetNextSelected( sal_uInt32 nFromIndex ) const
+{
+    sal_uInt32 nColCount = GetColumnCount();
+    for( sal_uInt32 nColIx = nFromIndex + 1; nColIx < nColCount; ++nColIx )
+        if( IsSelected( nColIx ) )
+            return nColIx;
+    return CSV_COLUMN_INVALID;
+}
+
+void ScCsvGrid::Select( sal_uInt32 nColIndex, bool bSelect )
+{
+    if( IsValidColumn( nColIndex ) )
+    {
+        maColStates[ nColIndex ].Select( bSelect );
+        ImplDrawColumnSelection( nColIndex );
+        Repaint();
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+        if( bSelect )
+            mnRecentSelCol = nColIndex;
+        AccSendSelectionEvent();
+    }
+}
+
+void ScCsvGrid::ToggleSelect( sal_uInt32 nColIndex )
+{
+    Select( nColIndex, !IsSelected( nColIndex ) );
+}
+
+void ScCsvGrid::SelectRange( sal_uInt32 nColIndex1, sal_uInt32 nColIndex2, bool bSelect )
+{
+    if( nColIndex1 == CSV_COLUMN_INVALID )
+        Select( nColIndex2 );
+    else if( nColIndex2 == CSV_COLUMN_INVALID )
+        Select( nColIndex1 );
+    else if( nColIndex1 > nColIndex2 )
+    {
+        SelectRange( nColIndex2, nColIndex1, bSelect );
+        if( bSelect )
+            mnRecentSelCol = nColIndex1;
+    }
+    else if( IsValidColumn( nColIndex1 ) && IsValidColumn( nColIndex2 ) )
+    {
+        for( sal_uInt32 nColIx = nColIndex1; nColIx <= nColIndex2; ++nColIx )
+        {
+            maColStates[ nColIx ].Select( bSelect );
+            ImplDrawColumnSelection( nColIx );
+        }
+        Repaint();
+        Execute( CSVCMD_EXPORTCOLUMNTYPE );
+        if( bSelect )
+            mnRecentSelCol = nColIndex1;
+        AccSendSelectionEvent();
+    }
+}
+
+void ScCsvGrid::SelectAll( bool bSelect )
+{
+    SelectRange( 0, GetColumnCount() - 1, bSelect );
+}
+
+void ScCsvGrid::MoveCursor( sal_uInt32 nColIndex )
+{
+    DisableRepaint();
+    if( IsValidColumn( nColIndex ) )
+    {
+        sal_Int32 nPosBeg = GetColumnPos( nColIndex );
+        sal_Int32 nPosEnd = GetColumnPos( nColIndex + 1 );
+        sal_Int32 nMinPos = std::max( nPosBeg - CSV_SCROLL_DIST, sal_Int32( 0 ) );
+        sal_Int32 nMaxPos = std::min( nPosEnd - GetVisPosCount() + CSV_SCROLL_DIST + sal_Int32( 1 ), nMinPos );
+        if( nPosBeg - CSV_SCROLL_DIST + 1 <= GetFirstVisPos() )
+            Execute( CSVCMD_SETPOSOFFSET, nMinPos );
+        else if( nPosEnd + CSV_SCROLL_DIST >= GetLastVisPos() )
+            Execute( CSVCMD_SETPOSOFFSET, nMaxPos );
+    }
+    Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
+    EnableRepaint();
+}
+
+void ScCsvGrid::MoveCursorRel( ScMoveMode eDir )
+{
+    if( GetFocusColumn() == CSV_COLUMN_INVALID )
+        return;
+
+    switch( eDir )
+    {
+        case MOVE_FIRST:
+            MoveCursor( 0 );
+        break;
+        case MOVE_LAST:
+            MoveCursor( GetColumnCount() - 1 );
+        break;
+        case MOVE_PREV:
+            if( GetFocusColumn() > 0 )
+                MoveCursor( GetFocusColumn() - 1 );
+        break;
+        case MOVE_NEXT:
+            if( GetFocusColumn() < GetColumnCount() - 1 )
+                MoveCursor( GetFocusColumn() + 1 );
+        break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+}
+
+void ScCsvGrid::ImplClearSelection()
+{
+    ::std::for_each( maColStates.begin(), maColStates.end(), Func_Select( false ) );
+    ImplDrawGridDev();
+}
+
+void ScCsvGrid::DoSelectAction( sal_uInt32 nColIndex, sal_uInt16 nModifier )
+{
+    if( !(nModifier & KEY_MOD1) )
+        ImplClearSelection();
+    if( nModifier & KEY_SHIFT )             // SHIFT always expands
+        SelectRange( mnRecentSelCol, nColIndex );
+    else if( !(nModifier & KEY_MOD1) )      // no SHIFT/CTRL always selects 1 column
+        Select( nColIndex );
+    else if( mbTracking )                 // CTRL in tracking does not toggle
+        Select( nColIndex, mbMTSelecting );
+    else                                    // CTRL only toggles
+        ToggleSelect( nColIndex );
+    Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
+}
+
+// cell contents --------------------------------------------------------------
+
+void ScCsvGrid::ImplSetTextLineSep(
+        sal_Int32 nLine, const OUString& rTextLine,
+        const OUString& rSepChars, sal_Unicode cTextSep, bool bMergeSep, bool bRemoveSpace )
+{
+    if( nLine < GetFirstVisLine() ) return;
+
+    sal_uInt32 nLineIx = nLine - GetFirstVisLine();
+    while( maTexts.size() <= nLineIx )
+        maTexts.emplace_back( );
+    std::vector<OUString>& rStrVec = maTexts[ nLineIx ];
+    rStrVec.clear();
+
+    // scan for separators
+    OUString aCellText;
+    const sal_Unicode* pSepChars = rSepChars.getStr();
+    const sal_Unicode* pChar = rTextLine.getStr();
+    sal_uInt32 nColIx = 0;
+
+    while( *pChar && (nColIx < sal::static_int_cast<sal_uInt32>(CSV_MAXCOLCOUNT)) )
+    {
+        // scan for next cell text
+        bool bIsQuoted = false;
+        bool bOverflowCell = false;
+        pChar = ScImportExport::ScanNextFieldFromString( pChar, aCellText,
+                cTextSep, pSepChars, bMergeSep, bIsQuoted, bOverflowCell, bRemoveSpace );
+        /* TODO: signal overflow somewhere in UI */
+
+        // update column width
+        sal_Int32 nWidth = std::max( CSV_MINCOLWIDTH, ScImportExport::CountVisualWidth( aCellText ) + 1 );
+        if( IsValidColumn( nColIx ) )
+        {
+            // expand existing column
+            sal_Int32 nDiff = nWidth - GetColumnWidth( nColIx );
+            if( nDiff > 0 )
+            {
+                Execute( CSVCMD_SETPOSCOUNT, GetPosCount() + nDiff );
+                for( sal_uInt32 nSplitIx = GetColumnCount() - 1; nSplitIx > nColIx; --nSplitIx )
+                {
+                    sal_Int32 nPos = maSplits[ nSplitIx ];
+                    maSplits.Remove( nPos );
+                    maSplits.Insert( nPos + nDiff );
+                }
+            }
+        }
+        else
+        {
+            // append new column
+            sal_Int32 nLastPos = GetPosCount();
+            Execute( CSVCMD_SETPOSCOUNT, nLastPos + nWidth );
+            ImplInsertSplit( nLastPos );
+        }
+
+        if( aCellText.getLength() <= CSV_MAXSTRLEN )
+            rStrVec.push_back( aCellText );
+        else
+            rStrVec.push_back( aCellText.copy( 0, CSV_MAXSTRLEN ) );
+        ++nColIx;
+    }
+    InvalidateGfx();
+}
+
+void ScCsvGrid::ImplSetTextLineFix( sal_Int32 nLine, const OUString& rTextLine )
+{
+    if( nLine < GetFirstVisLine() ) return;
+
+    sal_Int32 nWidth = ScImportExport::CountVisualWidth( rTextLine );
+    if( nWidth > GetPosCount() )
+        Execute( CSVCMD_SETPOSCOUNT, nWidth );
+
+    sal_uInt32 nLineIx = nLine - GetFirstVisLine();
+    while( maTexts.size() <= nLineIx )
+        maTexts.emplace_back( );
+
+    std::vector<OUString>& rStrVec = maTexts[ nLineIx ];
+    rStrVec.clear();
+    sal_uInt32 nColCount = GetColumnCount();
+    sal_Int32 nStrLen = rTextLine.getLength();
+    sal_Int32 nStrIx = 0;
+    for( sal_uInt32 nColIx = 0; (nColIx < nColCount) && (nStrIx < nStrLen); ++nColIx )
+    {
+        sal_Int32 nColWidth = GetColumnWidth( nColIx );
+        sal_Int32 nLastIx = nStrIx;
+        ScImportExport::CountVisualWidth( rTextLine, nLastIx, nColWidth );
+        sal_Int32 nLen = std::min( CSV_MAXSTRLEN, nLastIx - nStrIx );
+        rStrVec.push_back( rTextLine.copy( nStrIx, nLen ) );
+        nStrIx = nStrIx + nLen;
+    }
+    InvalidateGfx();
+}
+
+OUString ScCsvGrid::GetCellText( sal_uInt32 nColIndex, sal_Int32 nLine ) const
+{
+    if( nLine < GetFirstVisLine() ) return OUString();
+
+    sal_uInt32 nLineIx = nLine - GetFirstVisLine();
+    if( nLineIx >= maTexts.size() ) return OUString();
+
+    const std::vector<OUString>& rStrVec = maTexts[ nLineIx ];
+    if( nColIndex >= rStrVec.size() ) return OUString();
+
+    return rStrVec[ nColIndex ];
+}
+
+// event handling -------------------------------------------------------------
+
+void ScCsvGrid::Resize()
+{
+    mpTableBox->InitControls();
+
+    ScCsvControl::Resize();
+    InitSizeData();
+    Execute( CSVCMD_UPDATECELLTEXTS );
+}
+
+void ScCsvGrid::GetFocus()
+{
+    ScCsvControl::GetFocus();
+    Execute( CSVCMD_MOVEGRIDCURSOR, GetNoScrollCol( GetGridCursorPos() ) );
+    Repaint();
+}
+
+void ScCsvGrid::LoseFocus()
+{
+    ScCsvControl::LoseFocus();
+    Repaint();
+}
+
+bool ScCsvGrid::MouseButtonDown( const MouseEvent& rMEvt )
+{
+    DisableRepaint();
+    if( !HasFocus() )
+        GrabFocus();
+
+    Point aPos( rMEvt.GetPosPixel() );
+    sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
+
+    if( rMEvt.IsLeft() )
+    {
+        if( (GetFirstX() > aPos.X()) || (aPos.X() > GetLastX()) )   // in header column
+        {
+            if( aPos.Y() <= GetHdrHeight() )
+                SelectAll();
+        }
+        else if( IsValidColumn( nColIx ) )
+        {
+            DoSelectAction( nColIx, rMEvt.GetModifier() );
+            mnMTCurrCol = nColIx;
+            mbMTSelecting = IsSelected( nColIx );
+            mbTracking = true;
+        }
+    }
+    EnableRepaint();
+    return true;
+}
+
+bool ScCsvGrid::MouseButtonUp( const MouseEvent& )
+{
+    mbTracking = false;
+    return true;
+}
+
+bool ScCsvGrid::MouseMove( const MouseEvent& rMEvt )
+{
+    if (!mbTracking)
+        return true;
+
+    DisableRepaint();
+
+    sal_Int32 nPos = (rMEvt.GetPosPixel().X() - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
+    // on mouse tracking: keep position valid
+    nPos = std::clamp( nPos, sal_Int32(0), GetPosCount() - 1 );
+    Execute( CSVCMD_MAKEPOSVISIBLE, nPos );
+
+    sal_uInt32 nColIx = GetColumnFromPos( nPos );
+    if( mnMTCurrCol != nColIx )
+    {
+        DoSelectAction( nColIx, rMEvt.GetModifier() );
+        mnMTCurrCol = nColIx;
+    }
+    EnableRepaint();
+
+    return true;
+}
+
+bool ScCsvGrid::KeyInput( const KeyEvent& rKEvt )
+{
+    const vcl::KeyCode& rKCode = rKEvt.GetKeyCode();
+    sal_uInt16 nCode = rKCode.GetCode();
+    bool bShift = rKCode.IsShift();
+    bool bMod1 = rKCode.IsMod1();
+
+    if( !rKCode.IsMod2() )
+    {
+        ScMoveMode eHDir = GetHorzDirection( nCode, !bMod1 );
+        ScMoveMode eVDir = GetVertDirection( nCode, bMod1 );
+
+        if( eHDir != MOVE_NONE )
+        {
+            DisableRepaint();
+            MoveCursorRel( eHDir );
+            if( !bMod1 )
+                ImplClearSelection();
+            if( bShift )
+                SelectRange( mnRecentSelCol, GetFocusColumn() );
+            else if( !bMod1 )
+                Select( GetFocusColumn() );
+            EnableRepaint();
+        }
+        else if( eVDir != MOVE_NONE )
+            ScrollVertRel( eVDir );
+        else if( nCode == KEY_SPACE )
+        {
+            if( !bMod1 )
+                ImplClearSelection();
+            if( bShift )
+                SelectRange( mnRecentSelCol, GetFocusColumn() );
+            else if( bMod1 )
+                ToggleSelect( GetFocusColumn() );
+            else
+                Select( GetFocusColumn() );
+        }
+        else if( !bShift && bMod1 )
+        {
+            if( nCode == KEY_A )
+                SelectAll();
+            else if( (KEY_1 <= nCode) && (nCode <= KEY_9) )
+            {
+                sal_uInt32 nType = nCode - KEY_1;
+                if( nType < maTypeNames.size() )
+                    Execute( CSVCMD_SETCOLUMNTYPE, nType );
+            }
+        }
+    }
+
+    return rKCode.GetGroup() == KEYGROUP_CURSOR;
+}
+
+bool ScCsvGrid::Command( const CommandEvent& rCEvt )
+{
+    bool bConsumed = true;
+    switch( rCEvt.GetCommand() )
+    {
+        case CommandEventId::ContextMenu:
+        {
+            if( rCEvt.IsMouseEvent() )
+            {
+                Point aPos( rCEvt.GetMousePosPixel() );
+                sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
+                if( IsValidColumn( nColIx ) && (GetFirstX() <= aPos.X()) && (aPos.X() <= GetLastX()) )
+                {
+                    if( !IsSelected( nColIx ) )
+                        DoSelectAction( nColIx, 0 );    // focus & select
+                    ExecutePopup( aPos );
+                }
+            }
+            else
+            {
+                sal_uInt32 nColIx = GetFocusColumn();
+                if( !IsSelected( nColIx ) )
+                    Select( nColIx );
+                sal_Int32 nX1 = std::max( GetColumnX( nColIx ), GetFirstX() );
+                sal_Int32 nX2 = std::min( GetColumnX( nColIx + 1 ), GetWidth() );
+                ExecutePopup( Point( (nX1 + nX2) / 2, GetHeight() / 2 ) );
+            }
+            break;
+        }
+        case CommandEventId::Wheel:
+        {
+            tools::Rectangle aRect( Point(), maWinSize );
+            if( aRect.Contains( rCEvt.GetMousePosPixel() ) )
+            {
+                const CommandWheelData* pData = rCEvt.GetWheelData();
+                if( pData && (pData->GetMode() == CommandWheelMode::SCROLL) && !pData->IsHorz() )
+                    Execute( CSVCMD_SETLINEOFFSET, GetFirstVisLine() - pData->GetNotchDelta() );
+            }
+            break;
+        }
+        default:
+            bConsumed = false;
+            break;
+    }
+    return bConsumed;
+}
+
+void ScCsvGrid::StyleUpdated()
+{
+    InitColors();
+    InitFonts();
+    UpdateLayoutData();
+    Execute( CSVCMD_UPDATECELLTEXTS );
+
+    ScCsvControl::StyleUpdated();
+}
+
+void ScCsvGrid::ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints )
+{
+    InitColors();
+    Repaint();
+}
+
+// painting -------------------------------------------------------------------
+
+void ScCsvGrid::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
+{
+    ImplRedraw(rRenderContext);
+}
+
+void ScCsvGrid::ImplRedraw(vcl::RenderContext& rRenderContext)
+{
+    if( IsVisible() )
+    {
+        if( !IsValidGfx() )
+        {
+            ValidateGfx();
+            ImplDrawBackgrDev();
+            ImplDrawGridDev();
+        }
+        rRenderContext.DrawOutDev( Point(), maWinSize, Point(), maWinSize, *mpGridDev );
+    }
+}
+
+EditEngine* ScCsvGrid::GetEditEngine()
+{
+    return mpEditEngine.get();
+}
+
+void ScCsvGrid::ImplSetColumnClipRegion( OutputDevice& rOutDev, sal_uInt32 nColIndex )
+{
+    rOutDev.SetClipRegion( vcl::Region( tools::Rectangle(
+        std::max( GetColumnX( nColIndex ), GetFirstX() ) + 1, 0,
+        std::min( GetColumnX( nColIndex + 1 ), GetLastX() ), GetHeight() - 1 ) ) );
+}
+
+void ScCsvGrid::ImplDrawColumnHeader( OutputDevice& rOutDev, sal_uInt32 nColIndex, Color aFillColor )
+{
+    sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
+    sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
+    sal_Int32 nHdrHt = GetHdrHeight();
+
+    rOutDev.SetLineColor();
+    rOutDev.SetFillColor( aFillColor );
+    rOutDev.DrawRect( tools::Rectangle( nX1, 0, nX2, nHdrHt ) );
+
+    rOutDev.SetFont( maHeaderFont );
+    rOutDev.SetTextColor( maHeaderTextColor );
+    rOutDev.SetTextFillColor();
+    rOutDev.DrawText( Point( nX1 + 1, 0 ), GetColumnTypeName( nColIndex ) );
+
+    rOutDev.SetLineColor( maHeaderGridColor );
+    rOutDev.DrawLine( Point( nX1, nHdrHt ), Point( nX2, nHdrHt ) );
+    rOutDev.DrawLine( Point( nX2, 0 ), Point( nX2, nHdrHt ) );
+}
+
+void ScCsvGrid::ImplDrawCellText( const Point& rPos, const OUString& rText )
+{
+    OUString aPlainText = rText.replaceAll( "\t", " " );
+    aPlainText = aPlainText.replaceAll( "\n", " " );
+    mpEditEngine->SetPaperSize( maEdEngSize );
+
+    /*  #i60296# If string contains mixed script types, the space character
+        U+0020 may be drawn with a wrong width (from non-fixed-width Asian or
+        Complex font). Now we draw every non-space portion separately. */
+    sal_Int32 nCharIxInt {aPlainText.isEmpty() ? -1 : 0};
+    while (nCharIxInt>=0)
+    {
+        sal_Int32 nBeginIx = nCharIxInt;
+        const OUString aToken = aPlainText.getToken( 0, ' ', nCharIxInt );
+        if( !aToken.isEmpty() )
+        {
+            sal_Int32 nX = rPos.X() + GetCharWidth() * nBeginIx;
+            mpEditEngine->SetTextCurrentDefaults( aToken );
+            mpEditEngine->Draw(*mpBackgrDev, Point(nX, rPos.Y()));
+        }
+    }
+
+    sal_Int32 nCharIx = 0;
+    while( (nCharIx = rText.indexOf( '\t', nCharIx )) != -1 )
+    {
+        sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
+        sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
+        sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
+        Color aColor( maTextColor );
+        mpBackgrDev->SetLineColor( aColor );
+        mpBackgrDev->DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
+        mpBackgrDev->DrawLine( Point( nX2 - 2, nY - 2 ), Point( nX2, nY ) );
+        mpBackgrDev->DrawLine( Point( nX2 - 2, nY + 2 ), Point( nX2, nY ) );
+        ++nCharIx;
+    }
+    nCharIx = 0;
+    while( (nCharIx = rText.indexOf( '\n', nCharIx )) != -1 )
+    {
+        sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
+        sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
+        sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
+        Color aColor( maTextColor );
+        mpBackgrDev->SetLineColor( aColor );
+        mpBackgrDev->DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
+        mpBackgrDev->DrawLine( Point( nX1 + 2, nY - 2 ), Point( nX1, nY ) );
+        mpBackgrDev->DrawLine( Point( nX1 + 2, nY + 2 ), Point( nX1, nY ) );
+        mpBackgrDev->DrawLine( Point( nX2, nY - 2 ), Point( nX2, nY ) );
+        ++nCharIx;
+    }
+}
+
+void ScCsvGrid::ImplDrawFirstLineSep( bool bSet )
+{
+    if( IsVisibleLine( mnFirstImpLine ) && (mnFirstImpLine != GetFirstVisLine() ) )
+    {
+        sal_Int32 nY = GetY( mnFirstImpLine );
+        sal_Int32 nX = std::min( GetColumnX( GetLastVisColumn() + 1 ), GetLastX() );
+        mpBackgrDev->SetLineColor( bSet ? maGridPBColor : maGridColor );
+        mpBackgrDev->DrawLine( Point( GetFirstX() + 1, nY ), Point( nX, nY ) );
+    }
+}
+
+void ScCsvGrid::ImplDrawColumnBackgr( sal_uInt32 nColIndex )
+{
+    if( !IsVisibleColumn( nColIndex ) )
+        return;
+
+    ImplSetColumnClipRegion( *mpBackgrDev, nColIndex );
+
+    // grid
+    mpBackgrDev->SetLineColor();
+    mpBackgrDev->SetFillColor( maBackColor );
+    sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
+    sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
+    sal_Int32 nY2 = GetY( GetLastVisLine() + 1 );
+    sal_Int32 nHdrHt = GetHdrHeight();
+    tools::Rectangle aRect( nX1, nHdrHt, nX2, nY2 );
+    mpBackgrDev->DrawRect( aRect );
+    mpBackgrDev->SetLineColor( maGridColor );
+    mpBackgrDev->DrawGrid( aRect, Size( 1, GetLineHeight() ), DrawGridFlags::HorzLines );
+    mpBackgrDev->DrawLine( Point( nX2, nHdrHt ), Point( nX2, nY2 ) );
+    ImplDrawFirstLineSep( true );
+
+    // cell texts
+    mpEditEngine->SetDefaultItem( SvxColorItem( maTextColor, EE_CHAR_COLOR ) );
+    size_t nLineCount = ::std::min( static_cast< size_t >( GetLastVisLine() - GetFirstVisLine() + 1 ), maTexts.size() );
+    // #i67432# cut string to avoid edit engine performance problems with very large strings
+    sal_Int32 nFirstVisPos = ::std::max( GetColumnPos( nColIndex ), GetFirstVisPos() );
+    sal_Int32 nLastVisPos = ::std::min( GetColumnPos( nColIndex + 1 ), GetLastVisPos() );
+    sal_Int32 nStrPos = nFirstVisPos - GetColumnPos( nColIndex );
+    sal_Int32 nStrLen = nLastVisPos - nFirstVisPos + 1;
+    sal_Int32 nStrX = GetX( nFirstVisPos );
+    for( size_t nLine = 0; nLine < nLineCount; ++nLine )
+    {
+        std::vector<OUString>& rStrVec = maTexts[ nLine ];
+        if( (nColIndex < rStrVec.size()) && (rStrVec[ nColIndex ].getLength() > nStrPos) )
+        {
+            const OUString& rStr = rStrVec[ nColIndex ];
+            OUString aText = rStr.copy( nStrPos, ::std::min( nStrLen, rStr.getLength() - nStrPos) );
+            ImplDrawCellText( Point( nStrX, GetY( GetFirstVisLine() + nLine ) ), aText );
+        }
+    }
+
+    // header
+    ImplDrawColumnHeader( *mpBackgrDev, nColIndex, maHeaderBackColor );
+
+    mpBackgrDev->SetClipRegion();
+}
+
+void ScCsvGrid::ImplDrawRowHeaders()
+{
+    mpBackgrDev->SetLineColor();
+    mpBackgrDev->SetFillColor( maAppBackColor );
+    Point aPoint( GetHdrX(), 0 );
+    tools::Rectangle aRect( aPoint, Size( GetHdrWidth() + 1, GetHeight() ) );
+    mpBackgrDev->DrawRect( aRect );
+
+    mpBackgrDev->SetFillColor( maHeaderBackColor );
+    aRect.SetBottom( GetY( GetLastVisLine() + 1 ) );
+    mpBackgrDev->DrawRect( aRect );
+
+    // line numbers
+    mpBackgrDev->SetFont( maHeaderFont );
+    mpBackgrDev->SetTextColor( maHeaderTextColor );
+    mpBackgrDev->SetTextFillColor();
+    sal_Int32 nLastLine = GetLastVisLine();
+    for( sal_Int32 nLine = GetFirstVisLine(); nLine <= nLastLine; ++nLine )
+    {
+        OUString aText( OUString::number( nLine + 1 ) );
+        sal_Int32 nX = GetHdrX() + (GetHdrWidth() - mpBackgrDev->GetTextWidth( aText )) / 2;
+        mpBackgrDev->DrawText( Point( nX, GetY( nLine ) ), aText );
+    }
+
+    // grid
+    mpBackgrDev->SetLineColor( maHeaderGridColor );
+    if( IsRTL() )
+    {
+        mpBackgrDev->DrawLine( Point( 0, 0 ), Point( 0, GetHeight() - 1 ) );
+        mpBackgrDev->DrawLine( aRect.TopLeft(), aRect.BottomLeft() );
+    }
+    else
+        mpBackgrDev->DrawLine( aRect.TopRight(), aRect.BottomRight() );
+    aRect.SetTop( GetHdrHeight() );
+    mpBackgrDev->DrawGrid( aRect, Size( 1, GetLineHeight() ), DrawGridFlags::HorzLines );
+}
+
+void ScCsvGrid::ImplDrawBackgrDev()
+{
+    mpBackgrDev->SetLineColor();
+    mpBackgrDev->SetFillColor( maAppBackColor );
+    mpBackgrDev->DrawRect( tools::Rectangle(
+        Point( GetFirstX() + 1, 0 ), Size( GetWidth() - GetHdrWidth(), GetHeight() ) ) );
+
+    sal_uInt32 nLastCol = GetLastVisColumn();
+    if (nLastCol == CSV_COLUMN_INVALID)
+        return;
+    for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
+        ImplDrawColumnBackgr( nColIx );
+
+    ImplDrawRowHeaders();
+}
+
+void ScCsvGrid::ImplDrawColumnSelection( sal_uInt32 nColIndex )
+{
+    ImplInvertCursor( GetRulerCursorPos() );
+    ImplSetColumnClipRegion( *mpGridDev, nColIndex );
+    mpGridDev->DrawOutDev( Point(), maWinSize, Point(), maWinSize, *mpBackgrDev );
+
+    if( IsSelected( nColIndex ) )
+    {
+        sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
+        sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
+
+        // header
+        tools::Rectangle aRect( nX1, 0, nX2, GetHdrHeight() );
+        mpGridDev->SetLineColor();
+        if( maHeaderBackColor.IsDark() )
+            // redraw with light gray background in dark mode
+            ImplDrawColumnHeader( *mpGridDev, nColIndex, COL_LIGHTGRAY );
+        else
+        {
+            // use transparent active color
+            mpGridDev->SetFillColor( maSelectColor );
+            mpGridDev->DrawTransparent( tools::PolyPolygon( tools::Polygon( aRect ) ), CSV_HDR_TRANSPARENCY );
+        }
+
+        // column selection
+        aRect = tools::Rectangle( nX1, GetHdrHeight() + 1, nX2, GetY( GetLastVisLine() + 1 ) - 1 );
+        ImplInvertRect( *mpGridDev, aRect );
+    }
+
+    mpGridDev->SetClipRegion();
+    ImplInvertCursor( GetRulerCursorPos() );
+}
+
+void ScCsvGrid::ImplDrawGridDev()
+{
+    mpGridDev->DrawOutDev( Point(), maWinSize, Point(), maWinSize, *mpBackgrDev );
+    sal_uInt32 nLastCol = GetLastVisColumn();
+    if (nLastCol == CSV_COLUMN_INVALID)
+        return;
+    for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
+        ImplDrawColumnSelection( nColIx );
+}
+
+void ScCsvGrid::ImplDrawColumn( sal_uInt32 nColIndex )
+{
+    ImplDrawColumnBackgr( nColIndex );
+    ImplDrawColumnSelection( nColIndex );
+}
+
+void ScCsvGrid::ImplDrawHorzScrolled( sal_Int32 nOldPos )
+{
+    sal_Int32 nPos = GetFirstVisPos();
+    if( !IsValidGfx() || (nPos == nOldPos) )
+        return;
+    if( std::abs( nPos - nOldPos ) > GetVisPosCount() / 2 )
+    {
+        ImplDrawBackgrDev();
+        ImplDrawGridDev();
+        return;
+    }
+
+    Point aSrc, aDest;
+    sal_uInt32 nFirstColIx, nLastColIx;
+    if( nPos < nOldPos )
+    {
+        aSrc = Point( GetFirstX() + 1, 0 );
+        aDest = Point( GetFirstX() + GetCharWidth() * (nOldPos - nPos) + 1, 0 );
+        nFirstColIx = GetColumnFromPos( nPos );
+        nLastColIx = GetColumnFromPos( nOldPos );
+    }
+    else
+    {
+        aSrc = Point( GetFirstX() + GetCharWidth() * (nPos - nOldPos) + 1, 0 );
+        aDest = Point( GetFirstX() + 1, 0 );
+        nFirstColIx = GetColumnFromPos( std::min( nOldPos + GetVisPosCount(), GetPosCount() ) - 1 );
+        nLastColIx = GetColumnFromPos( std::min( nPos + GetVisPosCount(), GetPosCount() ) - 1 );
+    }
+
+    ImplInvertCursor( GetRulerCursorPos() + (nPos - nOldPos) );
+    tools::Rectangle aRectangle( GetFirstX(), 0, GetLastX(), GetHeight() - 1 );
+    vcl::Region aClipReg( aRectangle );
+    mpBackgrDev->SetClipRegion( aClipReg );
+    mpBackgrDev->CopyArea( aDest, aSrc, maWinSize );
+    mpBackgrDev->SetClipRegion();
+    mpGridDev->SetClipRegion( aClipReg );
+    mpGridDev->CopyArea( aDest, aSrc, maWinSize );
+    mpGridDev->SetClipRegion();
+    ImplInvertCursor( GetRulerCursorPos() );
+
+    for( sal_uInt32 nColIx = nFirstColIx; nColIx <= nLastColIx; ++nColIx )
+        ImplDrawColumn( nColIx );
+
+    sal_Int32 nLastX = GetX( GetPosCount() ) + 1;
+    if( nLastX <= GetLastX() )
+    {
+        tools::Rectangle aRect( nLastX, 0, GetLastX(), GetHeight() - 1 );
+        mpBackgrDev->SetLineColor();
+        mpBackgrDev->SetFillColor( maAppBackColor );
+        mpBackgrDev->DrawRect( aRect );
+        mpGridDev->SetLineColor();
+        mpGridDev->SetFillColor( maAppBackColor );
+        mpGridDev->DrawRect( aRect );
+    }
+}
+
+void ScCsvGrid::ImplInvertCursor( sal_Int32 nPos )
+{
+    if( IsVisibleSplitPos( nPos ) )
+    {
+        sal_Int32 nX = GetX( nPos ) - 1;
+        tools::Rectangle aRect( Point( nX, 0 ), Size( 3, GetHdrHeight() ) );
+        ImplInvertRect( *mpGridDev, aRect );
+        aRect.SetTop( GetHdrHeight() + 1 );
+        aRect.SetBottom( GetY( GetLastVisLine() + 1 ) );
+        ImplInvertRect( *mpGridDev, aRect );
+    }
+}
+
+tools::Rectangle ScCsvGrid::GetFocusRect()
+{
+    auto nColIndex = GetFocusColumn();
+    if( HasFocus() && IsVisibleColumn( nColIndex ) )
+    {
+        sal_Int32 nX1 = std::max( GetColumnX( nColIndex ), GetFirstX() ) + 1;
+        sal_Int32 nX2 = std::min( GetColumnX( nColIndex + 1 ) - sal_Int32( 1 ), GetLastX() );
+        sal_Int32 nY2 = std::min( GetY( GetLastVisLine() + 1 ), GetHeight() ) - 1;
+        return tools::Rectangle( nX1, 0, nX2, nY2 );
+    }
+    return weld::CustomWidgetController::GetFocusRect();
+}
+
+// accessibility ==============================================================
+
+css::uno::Reference<css::accessibility::XAccessible> ScCsvGrid::CreateAccessible()
+{
+    rtl::Reference<ScAccessibleCsvGrid> xRef(new ScAccessibleCsvGrid(*this));
+    mxAccessible = xRef;
+    return xRef;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/csvruler.cxx b/sc/source/ui/dbgui/csvruler.cxx
new file mode 100644
index 000000000..3af7645e2
--- /dev/null
+++ b/sc/source/ui/dbgui/csvruler.cxx
@@ -0,0 +1,666 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <csvruler.hxx>
+#include <AccessibleCsvControl.hxx>
+
+#include <optutil.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <vcl/event.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/ptrstyle.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <o3tl/string_view.hxx>
+
+using namespace com::sun::star::uno;
+
+constexpr OUStringLiteral SEP_PATH = u"Office.Calc/Dialogs/CSVImport";
+constexpr OUStringLiteral FIXED_WIDTH_LIST = u"FixedWidthList";
+
+static void load_FixedWidthList(ScCsvSplits &rSplits)
+{
+    Sequence<Any>aValues;
+    const Any *pProperties;
+    Sequence<OUString> aNames { FIXED_WIDTH_LIST };
+    ScLinkConfigItem aItem( SEP_PATH );
+
+    aValues = aItem.GetProperties( aNames );
+    pProperties = aValues.getConstArray();
+
+    if( !pProperties[0].hasValue() )
+        return;
+
+    rSplits.Clear();
+
+    OUString sFixedWidthLists;
+    pProperties[0] >>= sFixedWidthLists;
+
+    sal_Int32 nIdx {0};
+    for(;;)
+    {
+        const sal_Int32 n = o3tl::toInt32(o3tl::getToken(sFixedWidthLists, 0, ';', nIdx));
+        if (nIdx<0)
+        {
+            // String ends with a semi-colon so there
+            // is no useful 'int' after the last one.
+            // This also works in case of empty string
+            break;
+        }
+        rSplits.Insert(n);
+    }
+}
+static void save_FixedWidthList(const ScCsvSplits& rSplits)
+{
+    OUStringBuffer sSplits;
+    // Create a semi-colon separated string to save the splits
+    sal_uInt32 n = rSplits.Count();
+    for (sal_uInt32 i = 0; i < n; ++i)
+    {
+        sSplits.append(rSplits[i]);
+        sSplits.append(";");
+    }
+
+    OUString sFixedWidthLists = sSplits.makeStringAndClear();
+    Sequence<Any> aValues;
+    Any *pProperties;
+    Sequence<OUString> aNames { FIXED_WIDTH_LIST };
+    ScLinkConfigItem aItem( SEP_PATH );
+
+    aValues = aItem.GetProperties( aNames );
+    pProperties = aValues.getArray();
+    pProperties[0] <<= sFixedWidthLists;
+
+    aItem.PutProperties(aNames, aValues);
+}
+
+ScCsvRuler::ScCsvRuler(const ScCsvLayoutData& rData, ScCsvTableBox* pTableBox)
+    : ScCsvControl(rData)
+    , mpTableBox(pTableBox)
+    , mnPosCursorLast(1)
+    , mnPosMTStart(0)
+    , mnPosMTCurr(0)
+    , mbPosMTMoved(false)
+    , mnSplitSize(0)
+    , mbTracking(false)
+{
+}
+
+void ScCsvRuler::SetDrawingArea(weld::DrawingArea* pDrawingArea)
+{
+    ScCsvControl::SetDrawingArea(pDrawingArea);
+
+    UpdateSplitSize();
+
+    Size aSize(1, GetTextHeight() + mnSplitSize + 2);
+    pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
+    SetOutputSizePixel(aSize);
+
+    EnableRTL( false ); // RTL
+    InitColors();
+    InitSizeData();
+
+    OutputDevice& rRefDevice = pDrawingArea->get_ref_device();
+    maBackgrDev->SetFont( rRefDevice.GetFont() );
+    maRulerDev->SetFont( rRefDevice.GetFont() );
+    load_FixedWidthList( maSplits );
+}
+
+ScCsvRuler::~ScCsvRuler()
+{
+    save_FixedWidthList( maSplits );
+}
+
+// common ruler handling ------------------------------------------------------
+
+void ScCsvRuler::ApplyLayout( const ScCsvLayoutData& rOldData )
+{
+    ScCsvDiff nDiff = GetLayoutData().GetDiff( rOldData ) & (ScCsvDiff::HorizontalMask | ScCsvDiff::RulerCursor);
+    if( nDiff == ScCsvDiff::Equal ) return;
+
+    DisableRepaint();
+    if( nDiff & ScCsvDiff::HorizontalMask )
+    {
+        InitSizeData();
+        if( GetRulerCursorPos() >= GetPosCount() )
+            MoveCursor( GetPosCount() - 1 );
+    }
+    if( nDiff & ScCsvDiff::RulerCursor )
+    {
+        ImplInvertCursor( rOldData.mnPosCursor );
+        ImplInvertCursor( GetRulerCursorPos() );
+    }
+    EnableRepaint();
+
+    if( nDiff & ScCsvDiff::PosOffset )
+        AccSendVisibleEvent();
+}
+
+void ScCsvRuler::InitColors()
+{
+    const StyleSettings& rSett = Application::GetSettings().GetStyleSettings();
+    maBackColor = rSett.GetFaceColor();
+    maActiveColor = rSett.GetWindowColor();
+    maTextColor = rSett.GetLabelTextColor();
+    maSplitColor = maBackColor.IsDark() ? maTextColor : COL_LIGHTRED;
+    InvalidateGfx();
+}
+
+void ScCsvRuler::UpdateSplitSize()
+{
+    mnSplitSize = (GetCharWidth() * 3 / 5) | 1; // make an odd number
+}
+
+void ScCsvRuler::InitSizeData()
+{
+    maWinSize = GetOutputSizePixel();
+
+    UpdateSplitSize();
+
+    sal_Int32 nActiveWidth = std::min( GetWidth() - GetHdrWidth(), GetPosCount() * GetCharWidth() );
+    sal_Int32 nActiveHeight = GetTextHeight();
+
+    maActiveRect.SetPos( Point( GetFirstX(), (GetHeight() - nActiveHeight - 1) / 2 ) );
+    maActiveRect.SetSize( Size( nActiveWidth, nActiveHeight ) );
+
+    maBackgrDev->SetOutputSizePixel( maWinSize );
+    maRulerDev->SetOutputSizePixel( maWinSize );
+
+    InvalidateGfx();
+}
+
+void ScCsvRuler::MoveCursor( sal_Int32 nPos, bool bScroll )
+{
+    DisableRepaint();
+    if( bScroll )
+        Execute( CSVCMD_MAKEPOSVISIBLE, nPos );
+    Execute( CSVCMD_MOVERULERCURSOR, IsVisibleSplitPos( nPos ) ? nPos : CSV_POS_INVALID );
+    EnableRepaint();
+    AccSendCaretEvent();
+}
+
+void ScCsvRuler::MoveCursorRel( ScMoveMode eDir )
+{
+    if( GetRulerCursorPos() == CSV_POS_INVALID )
+        return;
+
+    switch( eDir )
+    {
+        case MOVE_FIRST:
+            MoveCursor( 1 );
+        break;
+        case MOVE_LAST:
+            MoveCursor( GetPosCount() - 1 );
+        break;
+        case MOVE_PREV:
+            if( GetRulerCursorPos() > 1 )
+                MoveCursor( GetRulerCursorPos() - 1 );
+        break;
+        case MOVE_NEXT:
+            if( GetRulerCursorPos() < GetPosCount() - 1 )
+                MoveCursor( GetRulerCursorPos() + 1 );
+        break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+}
+
+void ScCsvRuler::MoveCursorToSplit( ScMoveMode eDir )
+{
+    if( GetRulerCursorPos() == CSV_POS_INVALID )
+        return;
+
+    sal_uInt32 nIndex = CSV_VEC_NOTFOUND;
+    switch( eDir )
+    {
+        case MOVE_FIRST:    nIndex = maSplits.LowerBound( 0 );                          break;
+        case MOVE_LAST:     nIndex = maSplits.UpperBound( GetPosCount() );              break;
+        case MOVE_PREV:     nIndex = maSplits.UpperBound( GetRulerCursorPos() - 1 );    break;
+        case MOVE_NEXT:     nIndex = maSplits.LowerBound( GetRulerCursorPos() + 1 );    break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+    sal_Int32 nPos = maSplits[ nIndex ];
+    if( nPos != CSV_POS_INVALID )
+        MoveCursor( nPos );
+}
+
+void ScCsvRuler::ScrollVertRel( ScMoveMode eDir )
+{
+    sal_Int32 nLine = GetFirstVisLine();
+    switch( eDir )
+    {
+        case MOVE_PREV:     --nLine;                        break;
+        case MOVE_NEXT:     ++nLine;                        break;
+        case MOVE_PREVPAGE: nLine -= GetVisLineCount() - 1; break;
+        case MOVE_NEXTPAGE: nLine += GetVisLineCount() - 1; break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+    Execute( CSVCMD_SETLINEOFFSET, nLine );
+}
+
+// split handling -------------------------------------------------------------
+
+sal_Int32 ScCsvRuler::GetNoScrollPos( sal_Int32 nPos ) const
+{
+    sal_Int32 nNewPos = nPos;
+    if( nNewPos != CSV_POS_INVALID )
+    {
+        if( nNewPos < GetFirstVisPos() + CSV_SCROLL_DIST )
+        {
+            sal_Int32 nScroll = (GetFirstVisPos() > 0) ? CSV_SCROLL_DIST : 0;
+            nNewPos = std::max( nPos, GetFirstVisPos() + nScroll );
+        }
+        else if( nNewPos > GetLastVisPos() - CSV_SCROLL_DIST - 1 )
+        {
+            sal_Int32 nScroll = (GetFirstVisPos() < GetMaxPosOffset()) ? CSV_SCROLL_DIST : 0;
+            nNewPos = std::min( nNewPos, GetLastVisPos() - nScroll - sal_Int32( 1 ) );
+        }
+    }
+    return nNewPos;
+}
+
+void ScCsvRuler::InsertSplit( sal_Int32 nPos )
+{
+    if( maSplits.Insert( nPos ) )
+    {
+        ImplDrawSplit( nPos );
+        Repaint();
+    }
+}
+
+void ScCsvRuler::RemoveSplit( sal_Int32 nPos )
+{
+    if( maSplits.Remove( nPos ) )
+    {
+        ImplEraseSplit( nPos );
+        Repaint();
+    }
+}
+
+void ScCsvRuler::MoveSplit( sal_Int32 nPos, sal_Int32 nNewPos )
+{
+    bool bRemove = maSplits.Remove( nPos );
+    bool bInsert = maSplits.Insert( nNewPos );
+    if( bRemove || bInsert )
+    {
+        ImplEraseSplit( nPos );
+        ImplDrawSplit( nNewPos );
+        Repaint();
+    }
+}
+
+void ScCsvRuler::RemoveAllSplits()
+{
+    maSplits.Clear();
+    Repaint( true );
+}
+
+sal_Int32 ScCsvRuler::FindEmptyPos( sal_Int32 nPos, ScMoveMode eDir ) const
+{
+    sal_Int32 nNewPos = nPos;
+    if( nNewPos != CSV_POS_INVALID )
+    {
+        switch( eDir )
+        {
+            case MOVE_FIRST:
+                nNewPos = std::min( nPos, FindEmptyPos( 0, MOVE_NEXT ) );
+            break;
+            case MOVE_LAST:
+                nNewPos = std::max( nPos, FindEmptyPos( GetPosCount(), MOVE_PREV ) );
+            break;
+            case MOVE_PREV:
+                while( HasSplit( --nNewPos ) ) ;
+            break;
+            case MOVE_NEXT:
+                while( HasSplit( ++nNewPos ) ) ;
+            break;
+            default:
+            {
+                // added to avoid warnings
+            }
+        }
+    }
+    return IsValidSplitPos( nNewPos ) ? nNewPos : CSV_POS_INVALID;
+}
+
+void ScCsvRuler::MoveCurrSplit( sal_Int32 nNewPos )
+{
+    DisableRepaint();
+    Execute( CSVCMD_MOVESPLIT, GetRulerCursorPos(), nNewPos );
+    MoveCursor( nNewPos );
+    EnableRepaint();
+}
+
+void ScCsvRuler::MoveCurrSplitRel( ScMoveMode eDir )
+{
+    if( HasSplit( GetRulerCursorPos() ) )
+    {
+        sal_Int32 nNewPos = FindEmptyPos( GetRulerCursorPos(), eDir );
+        if( nNewPos != CSV_POS_INVALID )
+            MoveCurrSplit( nNewPos );
+    }
+}
+
+// event handling -------------------------------------------------------------
+
+void ScCsvRuler::Resize()
+{
+    ScCsvControl::Resize();
+    InitSizeData();
+    Repaint();
+}
+
+void ScCsvRuler::GetFocus()
+{
+    ScCsvControl::GetFocus();
+    DisableRepaint();
+    if( GetRulerCursorPos() == CSV_POS_INVALID )
+        MoveCursor( GetNoScrollPos( mnPosCursorLast ) );
+    EnableRepaint();
+}
+
+void ScCsvRuler::LoseFocus()
+{
+    ScCsvControl::LoseFocus();
+    mnPosCursorLast = GetRulerCursorPos();
+    MoveCursor( CSV_POS_INVALID );
+}
+
+void ScCsvRuler::StyleUpdated()
+{
+    InitColors();
+    Repaint();
+
+    ScCsvControl::StyleUpdated();
+}
+
+bool ScCsvRuler::MouseButtonDown( const MouseEvent& rMEvt )
+{
+    DisableRepaint();
+    if( !HasFocus() )
+        GrabFocus();
+    if( rMEvt.IsLeft() )
+    {
+        sal_Int32 nPos = GetPosFromX( rMEvt.GetPosPixel().X() );
+        if( IsVisibleSplitPos( nPos ) )
+            StartMouseTracking( nPos );
+        ImplSetMousePointer( nPos );
+    }
+    EnableRepaint();
+    return true;
+}
+
+bool ScCsvRuler::MouseButtonUp( const MouseEvent& )
+{
+    if (mbTracking)
+    {
+        EndMouseTracking();
+        mbTracking = false;
+    }
+    return true;
+}
+
+bool ScCsvRuler::MouseMove( const MouseEvent& rMEvt )
+{
+    if( !rMEvt.IsModifierChanged() )
+    {
+        sal_Int32 nPos = GetPosFromX( rMEvt.GetPosPixel().X() );
+        if( mbTracking )
+        {
+            // on mouse tracking: keep position valid
+            nPos = std::clamp( nPos, sal_Int32(1), GetPosCount() - 1 );
+            MoveMouseTracking( nPos );
+        }
+        else
+        {
+            tools::Rectangle aRect( Point(), maWinSize );
+            if( !IsVisibleSplitPos( nPos ) || !aRect.Contains( rMEvt.GetPosPixel() ) )
+                // if focused, keep old cursor position for key input
+                nPos = HasFocus() ? GetRulerCursorPos() : CSV_POS_INVALID;
+            MoveCursor( nPos, false );
+        }
+        ImplSetMousePointer( nPos );
+    }
+    return true;
+}
+
+bool ScCsvRuler::KeyInput( const KeyEvent& rKEvt )
+{
+    const vcl::KeyCode& rKCode = rKEvt.GetKeyCode();
+    sal_uInt16 nCode = rKCode.GetCode();
+    bool bNoMod = !rKCode.GetModifier();
+    bool bShift = (rKCode.GetModifier() == KEY_SHIFT);
+    bool bJump = (rKCode.GetModifier() == KEY_MOD1);
+    bool bMove = (rKCode.GetModifier() == (KEY_MOD1 | KEY_SHIFT));
+
+    ScMoveMode eHDir = GetHorzDirection( nCode, true );
+    ScMoveMode eVDir = GetVertDirection( nCode, false );
+
+    if( bNoMod )
+    {
+        if( eHDir != MOVE_NONE )
+            MoveCursorRel( eHDir );
+        else if( eVDir != MOVE_NONE )
+            ScrollVertRel( eVDir );
+        else switch( nCode )
+        {
+            case KEY_SPACE:     Execute( CSVCMD_TOGGLESPLIT, GetRulerCursorPos() ); break;
+            case KEY_INSERT:    Execute( CSVCMD_INSERTSPLIT, GetRulerCursorPos() ); break;
+            case KEY_DELETE:    Execute( CSVCMD_REMOVESPLIT, GetRulerCursorPos() ); break;
+        }
+    }
+    else if( bJump && (eHDir != MOVE_NONE) )
+        MoveCursorToSplit( eHDir );
+    else if( bMove && (eHDir != MOVE_NONE) )
+        MoveCurrSplitRel( eHDir );
+    else if( bShift && (nCode == KEY_DELETE) )
+        Execute( CSVCMD_REMOVEALLSPLITS );
+
+    return rKCode.GetGroup() == KEYGROUP_CURSOR;
+}
+
+void ScCsvRuler::StartMouseTracking( sal_Int32 nPos )
+{
+    mnPosMTStart = mnPosMTCurr = nPos;
+    mbPosMTMoved = false;
+    maOldSplits = maSplits;
+    Execute( CSVCMD_INSERTSPLIT, nPos );
+    if( HasSplit( nPos ) )
+        mbTracking = true;
+}
+
+void ScCsvRuler::MoveMouseTracking( sal_Int32 nPos )
+{
+    if( mnPosMTCurr != nPos )
+    {
+        DisableRepaint();
+        MoveCursor( nPos );
+        if( (mnPosMTCurr != mnPosMTStart) && maOldSplits.HasSplit( mnPosMTCurr ) )
+            Execute( CSVCMD_INSERTSPLIT, nPos );
+        else
+            Execute( CSVCMD_MOVESPLIT, mnPosMTCurr, nPos );
+        mnPosMTCurr = nPos;
+        mbPosMTMoved = true;
+        EnableRepaint();
+    }
+}
+
+void ScCsvRuler::EndMouseTracking()
+{
+    // remove on simple click on an existing split
+    if( (mnPosMTCurr == mnPosMTStart) && maOldSplits.HasSplit( mnPosMTCurr ) && !mbPosMTMoved )
+        Execute( CSVCMD_REMOVESPLIT, mnPosMTCurr );
+    mnPosMTStart = CSV_POS_INVALID;
+}
+
+// painting -------------------------------------------------------------------
+
+void ScCsvRuler::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& )
+{
+    ImplRedraw(rRenderContext);
+}
+
+void ScCsvRuler::ImplRedraw(vcl::RenderContext& rRenderContext)
+{
+    if( IsVisible() )
+    {
+        if( !IsValidGfx() )
+        {
+            ValidateGfx();
+            ImplDrawBackgrDev();
+            ImplDrawRulerDev();
+        }
+        rRenderContext.DrawOutDev( Point(), maWinSize, Point(), maWinSize, *maRulerDev );
+    }
+}
+
+tools::Rectangle ScCsvRuler::GetFocusRect()
+{
+    /* Draws directly tracking rectangle to the column with the specified index. */
+    if(HasFocus())
+        return tools::Rectangle(0, 0, GetWidth() - 1, GetHeight() - 2);
+    return weld::CustomWidgetController::GetFocusRect();
+}
+
+void ScCsvRuler::ImplDrawArea( sal_Int32 nPosX, sal_Int32 nWidth )
+{
+    maBackgrDev->SetLineColor();
+    tools::Rectangle aRect( Point( nPosX, 0 ), Size( nWidth, GetHeight() ) );
+    maBackgrDev->SetFillColor( maBackColor );
+    maBackgrDev->DrawRect( aRect );
+
+    aRect = maActiveRect;
+    aRect.SetLeft( std::max( GetFirstX(), nPosX ) );
+    aRect.SetRight( std::min( std::min( GetX( GetPosCount() ), GetLastX() ), nPosX + nWidth - sal_Int32( 1 ) ) );
+    if( aRect.Left() <= aRect.Right() )
+    {
+        maBackgrDev->SetFillColor( maActiveColor );
+        maBackgrDev->DrawRect( aRect );
+    }
+
+    maBackgrDev->SetLineColor( maTextColor );
+    sal_Int32 nY = GetHeight() - 1;
+    maBackgrDev->DrawLine( Point( nPosX, nY ), Point( nPosX + nWidth - 1, nY ) );
+}
+
+void ScCsvRuler::ImplDrawBackgrDev()
+{
+    ImplDrawArea( 0, GetWidth() );
+
+    // scale
+    maBackgrDev->SetLineColor( maTextColor );
+    maBackgrDev->SetFillColor();
+    sal_Int32 nPos;
+
+    sal_Int32 nFirstPos = std::max( GetPosFromX( 0 ) - 1, sal_Int32(0) );
+    sal_Int32 nLastPos = GetPosFromX( GetWidth() );
+    sal_Int32 nY = (maActiveRect.Top() + maActiveRect.Bottom()) / 2;
+    for( nPos = nFirstPos; nPos <= nLastPos; ++nPos )
+    {
+        sal_Int32 nX = GetX( nPos );
+        if( nPos % 5 )
+            maBackgrDev->DrawPixel( Point( nX, nY ) );
+        else
+            maBackgrDev->DrawLine( Point( nX, nY - 1 ), Point( nX, nY + 1 ) );
+    }
+
+    // texts
+    maBackgrDev->SetTextColor( maTextColor );
+    maBackgrDev->SetTextFillColor();
+    for( nPos = ((nFirstPos + 9) / 10) * 10; nPos <= nLastPos; nPos += 10 )
+    {
+        OUString aText( OUString::number( nPos ) );
+        sal_Int32 nTextWidth = maBackgrDev->GetTextWidth( aText );
+        sal_Int32 nTextX = GetX( nPos ) - nTextWidth / 2;
+        ImplDrawArea( nTextX - 1, nTextWidth + 2 );
+        maBackgrDev->DrawText( Point( nTextX, maActiveRect.Top() ), aText );
+    }
+}
+
+void ScCsvRuler::ImplDrawSplit( sal_Int32 nPos )
+{
+    if( IsVisibleSplitPos( nPos ) )
+    {
+        Point aPos( GetX( nPos ) - mnSplitSize / 2, GetHeight() - mnSplitSize - 2 );
+        Size aSize( mnSplitSize, mnSplitSize );
+        maRulerDev->SetLineColor( maTextColor );
+        maRulerDev->SetFillColor( maSplitColor );
+        maRulerDev->DrawEllipse( tools::Rectangle( aPos, aSize ) );
+        maRulerDev->DrawPixel( Point( GetX( nPos ), GetHeight() - 2 ) );
+    }
+}
+
+void ScCsvRuler::ImplEraseSplit( sal_Int32 nPos )
+{
+    if( IsVisibleSplitPos( nPos ) )
+    {
+        ImplInvertCursor( GetRulerCursorPos() );
+        Point aPos( GetX( nPos ) - mnSplitSize / 2, 0 );
+        Size aSize( mnSplitSize, GetHeight() );
+        maRulerDev->DrawOutDev( aPos, aSize, aPos, aSize, *maBackgrDev );
+        ImplInvertCursor( GetRulerCursorPos() );
+    }
+}
+
+void ScCsvRuler::ImplDrawRulerDev()
+{
+    maRulerDev->DrawOutDev( Point(), maWinSize, Point(), maWinSize, *maBackgrDev );
+    ImplInvertCursor( GetRulerCursorPos() );
+
+    sal_uInt32 nFirst = maSplits.LowerBound( GetFirstVisPos() );
+    sal_uInt32 nLast = maSplits.UpperBound( GetLastVisPos() );
+    if( (nFirst != CSV_VEC_NOTFOUND) && (nLast != CSV_VEC_NOTFOUND) )
+        for( sal_uInt32 nIndex = nFirst; nIndex <= nLast; ++nIndex )
+            ImplDrawSplit( GetSplitPos( nIndex ) );
+}
+
+void ScCsvRuler::ImplInvertCursor( sal_Int32 nPos )
+{
+    if( IsVisibleSplitPos( nPos ) )
+    {
+        ImplInvertRect( *maRulerDev, tools::Rectangle( Point( GetX( nPos ) - 1, 0 ), Size( 3, GetHeight() - 1 ) ) );
+        if( HasSplit( nPos ) )
+            ImplDrawSplit( nPos );
+    }
+}
+
+void ScCsvRuler::ImplSetMousePointer( sal_Int32 nPos )
+{
+    SetPointer( HasSplit( nPos ) ? PointerStyle::HSplit : PointerStyle::Arrow );
+}
+
+// accessibility ==============================================================
+
+css::uno::Reference<css::accessibility::XAccessible> ScCsvRuler::CreateAccessible()
+{
+    rtl::Reference<ScAccessibleCsvRuler> xRef(new ScAccessibleCsvRuler(*this));
+    mxAccessible = xRef;
+    return xRef;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/csvsplits.cxx b/sc/source/ui/dbgui/csvsplits.cxx
new file mode 100644
index 000000000..575bd53d0
--- /dev/null
+++ b/sc/source/ui/dbgui/csvsplits.cxx
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <csvsplits.hxx>
+
+#include <algorithm>
+
+#include <sal/log.hxx>
+
+bool ScCsvSplits::Insert( sal_Int32 nPos )
+{
+    if (nPos < 0)
+        return false;
+
+    const auto aIter = ::std::lower_bound( maVec.begin(), maVec.end(), nPos );
+
+    if (aIter != maVec.end() && *aIter == nPos)
+        return false;
+
+    SAL_WARN_IF(maVec.size()>=static_cast<std::size_t>(SAL_MAX_UINT32-1),
+                "sc.ui", "ScCsvSplits::Insert: too many elements in vector");
+
+    maVec.insert( aIter, nPos );
+    return true;
+}
+
+bool ScCsvSplits::Remove( sal_Int32 nPos )
+{
+    sal_uInt32 nIndex = GetIndex( nPos );
+    if (nIndex == CSV_VEC_NOTFOUND)
+        return false;
+
+    maVec.erase( maVec.begin() + nIndex );
+    return true;
+}
+
+void ScCsvSplits::RemoveRange( sal_Int32 nPosStart, sal_Int32 nPosEnd )
+{
+    sal_uInt32 nStartIx = LowerBound( nPosStart );
+    sal_uInt32 nEndIx = UpperBound( nPosEnd );
+    if( (nStartIx != CSV_VEC_NOTFOUND) && (nEndIx != CSV_VEC_NOTFOUND) && (nStartIx <= nEndIx) )
+        maVec.erase( maVec.begin() + nStartIx, maVec.begin() + nEndIx + 1 );
+}
+
+void ScCsvSplits::Clear()
+{
+    maVec.clear();
+}
+
+bool ScCsvSplits::HasSplit( sal_Int32 nPos ) const
+{
+    return GetIndex( nPos ) != CSV_VEC_NOTFOUND;
+}
+
+sal_uInt32 ScCsvSplits::GetIndex( sal_Int32 nPos ) const
+{
+    auto aIter = ::std::lower_bound( maVec.cbegin(), maVec.cend(), nPos );
+    return GetIterIndex( ((aIter != maVec.end()) && (*aIter == nPos)) ? aIter : maVec.end() );
+}
+
+sal_uInt32 ScCsvSplits::LowerBound( sal_Int32 nPos ) const
+{
+    return GetIterIndex( ::std::lower_bound( maVec.begin(), maVec.end(), nPos ) );
+}
+
+sal_uInt32 ScCsvSplits::UpperBound( sal_Int32 nPos ) const
+{
+    sal_uInt32 nIndex = LowerBound( nPos );
+    if( nIndex == CSV_VEC_NOTFOUND )
+        return Count() ? (Count() - 1) : CSV_VEC_NOTFOUND;
+    if( GetPos( nIndex ) == nPos )
+        return nIndex;
+    return nIndex ? (nIndex - 1) : CSV_VEC_NOTFOUND;
+}
+
+sal_Int32 ScCsvSplits::GetPos( sal_uInt32 nIndex ) const
+{
+    return (nIndex < Count()) ? maVec[ nIndex ] : CSV_POS_INVALID;
+}
+
+sal_uInt32 ScCsvSplits::GetIterIndex( const_iterator const & aIter ) const
+{
+    return (aIter == maVec.end()) ? CSV_VEC_NOTFOUND : (aIter - maVec.begin());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/csvtablebox.cxx b/sc/source/ui/dbgui/csvtablebox.cxx
new file mode 100644
index 000000000..10dba1b81
--- /dev/null
+++ b/sc/source/ui/dbgui/csvtablebox.cxx
@@ -0,0 +1,369 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <csvtablebox.hxx>
+#include <vcl/settings.hxx>
+
+ScCsvTableBox::ScCsvTableBox(weld::Builder& rBuilder)
+    : mxRuler(new ScCsvRuler(maData, this))
+    , mxGrid(new ScCsvGrid(maData, rBuilder.weld_menu("popup"), this))
+    , mxScroll(rBuilder.weld_scrolled_window("scrolledwindow", true))
+    , mxRulerWeld(new weld::CustomWeld(rBuilder, "csvruler", *mxRuler))
+    , mxGridWeld(new weld::CustomWeld(rBuilder, "csvgrid", *mxGrid))
+    , maEndScrollIdle("ScCsvTableBox maEndScrollIdle")
+{
+    Size aSize(mxScroll->get_approximate_digit_width() * 67,
+               mxScroll->get_text_height() * 10);
+    // this needs to be larger than the ScCsvGrid initial size to get it
+    // to stretch to fit, see ScCsvGrid::SetDrawingArea
+    mxScroll->set_size_request(aSize.Width(), aSize.Height());
+
+    mbFixedMode = false;
+    mnFixedWidth = 1;
+
+    Link<ScCsvControl&,void> aLink = LINK( this, ScCsvTableBox, CsvCmdHdl );
+    mxRuler->SetCmdHdl( aLink );
+    mxGrid->SetCmdHdl( aLink );
+
+    mxScroll->connect_hadjustment_changed(LINK(this, ScCsvTableBox, HScrollHdl));
+    mxScroll->connect_vadjustment_changed(LINK(this, ScCsvTableBox, VScrollHdl));
+
+    maEndScrollIdle.SetPriority(TaskPriority::LOWEST);
+    maEndScrollIdle.SetInvokeHandler(LINK(this,ScCsvTableBox,ScrollEndHdl));
+
+    InitControls();
+}
+
+ScCsvTableBox::~ScCsvTableBox()
+{
+}
+
+// common table box handling --------------------------------------------------
+
+void ScCsvTableBox::SetSeparatorsMode()
+{
+    if( !mbFixedMode )
+        return;
+
+    // rescue data for fixed width mode
+    mnFixedWidth = mxGrid->GetPosCount();
+    maFixColStates = mxGrid->GetColumnStates();
+    // switch to separators mode
+    mbFixedMode = false;
+    // reset and reinitialize controls
+    mxGrid->DisableRepaint();
+    mxGrid->Execute( CSVCMD_SETLINEOFFSET, 0 );
+    mxGrid->Execute( CSVCMD_SETPOSCOUNT, 1 );
+    mxGrid->Execute( CSVCMD_NEWCELLTEXTS );
+    mxGrid->SetColumnStates( std::vector(maSepColStates) );
+    InitControls();
+    mxGrid->EnableRepaint();
+}
+
+void ScCsvTableBox::SetFixedWidthMode()
+{
+    if( mbFixedMode )
+        return;
+
+    // rescue data for separators mode
+    maSepColStates = mxGrid->GetColumnStates();
+    // switch to fixed width mode
+    mbFixedMode = true;
+    // reset and reinitialize controls
+    mxGrid->DisableRepaint();
+    mxGrid->Execute( CSVCMD_SETLINEOFFSET, 0 );
+    mxGrid->Execute( CSVCMD_SETPOSCOUNT, mnFixedWidth );
+    mxGrid->SetSplits( mxRuler->GetSplits() );
+    mxGrid->SetColumnStates( std::vector(maFixColStates) );
+    InitControls();
+    mxGrid->EnableRepaint();
+}
+
+void ScCsvTableBox::Init()
+{
+    mxGrid->Init();
+}
+
+void ScCsvTableBox::InitControls()
+{
+    mxGrid->UpdateLayoutData();
+
+    mxGrid->Show();
+    if (mbFixedMode)
+        mxRuler->Show();
+    else
+        mxRuler->Hide();
+
+    Size aWinSize = mxGrid->GetOutputSizePixel();
+    maData.mnWinWidth = aWinSize.Width();
+    maData.mnWinHeight = aWinSize.Height();
+
+    // scrollbars always visible
+    InitHScrollBar();
+
+    // scrollbars always visible
+    InitVScrollBar();
+
+    // let the controls self-adjust to visible area
+    mxGrid->Execute( CSVCMD_SETPOSOFFSET, mxGrid->GetFirstVisPos() );
+    mxGrid->Execute( CSVCMD_SETLINEOFFSET, mxGrid->GetFirstVisLine() );
+}
+
+void ScCsvTableBox::InitHScrollBar()
+{
+    int nLower = 0;
+    int nValue = mxGrid->GetFirstVisPos();
+    int nUpper = mxGrid->GetPosCount() + 2;
+    int nPageSize = mxGrid->GetVisPosCount();
+
+    // Undo scrollbar RTL
+    if (AllSettings::GetLayoutRTL())
+        nValue = nUpper - (nValue - nLower + nPageSize);
+
+    mxScroll->hadjustment_configure(nValue, nLower, nUpper,
+                                    1, mxGrid->GetVisPosCount() * 3 / 4,
+                                    nPageSize);
+}
+
+void ScCsvTableBox::InitVScrollBar()
+{
+    mxScroll->vadjustment_configure(mxGrid->GetFirstVisLine(), 0, mxGrid->GetLineCount() + 1,
+                                    1, mxGrid->GetVisLineCount() - 2,
+                                    mxGrid->GetVisLineCount());
+}
+
+void ScCsvTableBox::MakePosVisible( sal_Int32 nPos )
+{
+    if( (0 <= nPos) && (nPos < mxGrid->GetPosCount()) )
+    {
+        if( nPos - CSV_SCROLL_DIST + 1 <= mxGrid->GetFirstVisPos() )
+            mxGrid->Execute( CSVCMD_SETPOSOFFSET, nPos - CSV_SCROLL_DIST );
+        else if( nPos + CSV_SCROLL_DIST >= mxGrid->GetLastVisPos() )
+            mxGrid->Execute( CSVCMD_SETPOSOFFSET, nPos - mxGrid->GetVisPosCount() + CSV_SCROLL_DIST );
+    }
+}
+
+// cell contents --------------------------------------------------------------
+
+void ScCsvTableBox::SetUniStrings(
+        const OUString* pTextLines, const OUString& rSepChars,
+        sal_Unicode cTextSep, bool bMergeSep, bool bRemoveSpace )
+{
+    // assuming that pTextLines is a string array with size CSV_PREVIEW_LINES
+    // -> will be dynamic sometime
+    mxGrid->DisableRepaint();
+    sal_Int32 nEndLine = mxGrid->GetFirstVisLine() + CSV_PREVIEW_LINES;
+    const OUString* pString = pTextLines;
+    for( sal_Int32 nLine = mxGrid->GetFirstVisLine(); nLine < nEndLine; ++nLine, ++pString )
+    {
+        if( mbFixedMode )
+            mxGrid->ImplSetTextLineFix( nLine, *pString );
+        else
+            mxGrid->ImplSetTextLineSep( nLine, *pString, rSepChars, cTextSep, bMergeSep, bRemoveSpace );
+    }
+    mxGrid->EnableRepaint();
+}
+
+// column settings ------------------------------------------------------------
+
+void ScCsvTableBox::InitTypes(const weld::ComboBox& rListBox)
+{
+    const sal_Int32 nTypeCount = rListBox.get_count();
+    std::vector<OUString> aTypeNames( nTypeCount );
+    for( sal_Int32 nIndex = 0; nIndex < nTypeCount; ++nIndex )
+        aTypeNames[ nIndex ] = rListBox.get_text( nIndex );
+    mxGrid->SetTypeNames( std::move(aTypeNames) );
+}
+
+void ScCsvTableBox::FillColumnData( ScAsciiOptions& rOptions ) const
+{
+    if( mbFixedMode )
+        mxGrid->FillColumnDataFix( rOptions );
+    else
+        mxGrid->FillColumnDataSep( rOptions );
+}
+
+// event handling -------------------------------------------------------------
+
+IMPL_LINK( ScCsvTableBox, CsvCmdHdl, ScCsvControl&, rCtrl, void )
+{
+    const ScCsvCmd& rCmd = rCtrl.GetCmd();
+    ScCsvCmdType eType = rCmd.GetType();
+    sal_Int32 nParam1 = rCmd.GetParam1();
+    sal_Int32 nParam2 = rCmd.GetParam2();
+
+    bool bFound = true;
+    switch( eType )
+    {
+        case CSVCMD_REPAINT:
+            if( !mxGrid->IsNoRepaint() )
+            {
+                mxGrid->Invalidate();
+                mxRuler->Invalidate();
+                InitHScrollBar();
+                InitVScrollBar();
+            }
+        break;
+        case CSVCMD_MAKEPOSVISIBLE:
+            MakePosVisible( nParam1 );
+        break;
+
+        case CSVCMD_NEWCELLTEXTS:
+            if( mbFixedMode )
+                mxGrid->Execute( CSVCMD_UPDATECELLTEXTS );
+            else
+            {
+                mxGrid->DisableRepaint();
+                ScCsvColStateVec aStates( mxGrid->GetColumnStates() );
+                sal_Int32 nPos = mxGrid->GetFirstVisPos();
+                mxGrid->Execute( CSVCMD_SETPOSCOUNT, 1 );
+                mxGrid->Execute( CSVCMD_UPDATECELLTEXTS );
+                mxGrid->Execute( CSVCMD_SETPOSOFFSET, nPos );
+                mxGrid->SetColumnStates( std::move(aStates) );
+                mxGrid->EnableRepaint();
+            }
+        break;
+        case CSVCMD_UPDATECELLTEXTS:
+            maUpdateTextHdl.Call( *this );
+        break;
+        case CSVCMD_SETCOLUMNTYPE:
+            mxGrid->SetSelColumnType( nParam1 );
+        break;
+        case CSVCMD_EXPORTCOLUMNTYPE:
+            maColTypeHdl.Call( *this );
+        break;
+        case CSVCMD_SETFIRSTIMPORTLINE:
+            mxGrid->SetFirstImportedLine( nParam1 );
+        break;
+
+        case CSVCMD_INSERTSPLIT:
+            OSL_ENSURE( mbFixedMode, "ScCsvTableBox::CsvCmdHdl::InsertSplit - invalid call" );
+            if( mxRuler->GetSplitCount() + 1 < sal::static_int_cast<sal_uInt32>(CSV_MAXCOLCOUNT) )
+            {
+                mxRuler->InsertSplit( nParam1 );
+                mxGrid->InsertSplit( nParam1 );
+            }
+        break;
+        case CSVCMD_REMOVESPLIT:
+            OSL_ENSURE( mbFixedMode, "ScCsvTableBox::CsvCmdHdl::RemoveSplit - invalid call" );
+            mxRuler->RemoveSplit( nParam1 );
+            mxGrid->RemoveSplit( nParam1 );
+        break;
+        case CSVCMD_TOGGLESPLIT:
+            mxGrid->Execute( mxRuler->HasSplit( nParam1 ) ? CSVCMD_REMOVESPLIT : CSVCMD_INSERTSPLIT, nParam1 );
+        break;
+        case CSVCMD_MOVESPLIT:
+            OSL_ENSURE( mbFixedMode, "ScCsvTableBox::CsvCmdHdl::MoveSplit - invalid call" );
+            mxRuler->MoveSplit( nParam1, nParam2 );
+            mxGrid->MoveSplit( nParam1, nParam2 );
+        break;
+        case CSVCMD_REMOVEALLSPLITS:
+            OSL_ENSURE( mbFixedMode, "ScCsvTableBox::CsvCmdHdl::RemoveAllSplits - invalid call" );
+            mxRuler->RemoveAllSplits();
+            mxGrid->RemoveAllSplits();
+        break;
+        default:
+            bFound = false;
+    }
+    if( bFound )
+        return;
+
+    const ScCsvLayoutData aOldData( maData );
+    switch( eType )
+    {
+        case CSVCMD_SETPOSCOUNT:
+            maData.mnPosCount = std::max( nParam1, sal_Int32( 1 ) );
+            ImplSetPosOffset( mxGrid->GetFirstVisPos() );
+        break;
+        case CSVCMD_SETPOSOFFSET:
+            ImplSetPosOffset( nParam1 );
+        break;
+        case CSVCMD_SETHDRWIDTH:
+            maData.mnHdrWidth = std::max( nParam1, sal_Int32( 0 ) );
+            ImplSetPosOffset( mxGrid->GetFirstVisPos() );
+        break;
+        case CSVCMD_SETCHARWIDTH:
+            maData.mnCharWidth = std::max( nParam1, sal_Int32( 1 ) );
+            ImplSetPosOffset( mxGrid->GetFirstVisPos() );
+        break;
+        case CSVCMD_SETLINECOUNT:
+            maData.mnLineCount = std::max( nParam1, sal_Int32( 1 ) );
+            ImplSetLineOffset( mxGrid->GetFirstVisLine() );
+        break;
+        case CSVCMD_SETLINEOFFSET:
+            ImplSetLineOffset( nParam1 );
+        break;
+        case CSVCMD_SETHDRHEIGHT:
+            maData.mnHdrHeight = std::max( nParam1, sal_Int32( 0 ) );
+            ImplSetLineOffset( mxGrid->GetFirstVisLine() );
+        break;
+        case CSVCMD_SETLINEHEIGHT:
+            maData.mnLineHeight = std::max( nParam1, sal_Int32( 1 ) );
+            ImplSetLineOffset( mxGrid->GetFirstVisLine() );
+        break;
+        case CSVCMD_MOVERULERCURSOR:
+            maData.mnPosCursor = mxGrid->IsVisibleSplitPos( nParam1 ) ? nParam1 : CSV_POS_INVALID;
+        break;
+        case CSVCMD_MOVEGRIDCURSOR:
+            maData.mnColCursor = ((0 <= nParam1) && (nParam1 < mxGrid->GetPosCount())) ? nParam1 : CSV_POS_INVALID;
+        break;
+        default:
+        {
+            // added to avoid warnings
+        }
+    }
+
+    if( maData != aOldData )
+    {
+        mxGrid->DisableRepaint();
+        mxRuler->ApplyLayout( aOldData );
+        mxGrid->ApplyLayout( aOldData );
+        mxGrid->EnableRepaint();
+    }
+}
+
+IMPL_LINK(ScCsvTableBox, HScrollHdl, weld::ScrolledWindow&, rScroll, void)
+{
+    int nLower = 0;
+    int nValue = rScroll.hadjustment_get_value();
+    int nUpper = mxGrid->GetPosCount() + 2;
+    int nPageSize = mxGrid->GetVisPosCount();
+
+    // Undo scrollbar RTL
+    if (AllSettings::GetLayoutRTL())
+        nValue = nUpper - (nValue - nLower + nPageSize);
+
+    mxGrid->Execute(CSVCMD_SETPOSOFFSET, nValue);
+    maEndScrollIdle.Start();
+}
+
+IMPL_LINK(ScCsvTableBox, VScrollHdl, weld::ScrolledWindow&, rScroll, void)
+{
+    mxGrid->Execute(CSVCMD_SETLINEOFFSET, rScroll.vadjustment_get_value());
+}
+
+IMPL_LINK_NOARG(ScCsvTableBox, ScrollEndHdl, Timer*, void)
+{
+    if( mxGrid->GetRulerCursorPos() != CSV_POS_INVALID )
+        mxGrid->Execute( CSVCMD_MOVERULERCURSOR, mxRuler->GetNoScrollPos( mxGrid->GetRulerCursorPos() ) );
+    if( mxGrid->GetGridCursorPos() != CSV_POS_INVALID )
+        mxGrid->Execute( CSVCMD_MOVEGRIDCURSOR, mxGrid->GetNoScrollCol( mxGrid->GetGridCursorPos() ) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/dapidata.cxx b/sc/source/ui/dbgui/dapidata.cxx
new file mode 100644
index 000000000..198d82783
--- /dev/null
+++ b/sc/source/ui/dbgui/dapidata.cxx
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <comphelper/processfactory.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <com/sun/star/sheet/DataImportMode.hpp>
+#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
+#include <com/sun/star/sdb/DatabaseContext.hpp>
+#include <com/sun/star/sdb/XQueriesSupplier.hpp>
+#include <com/sun/star/sdb/XCompletedConnection.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+
+using namespace com::sun::star;
+
+#include <dapidata.hxx>
+#include <dpsdbtab.hxx>
+
+//  entries in the "type" ListBox
+#define DP_TYPELIST_TABLE   0
+#define DP_TYPELIST_QUERY   1
+#define DP_TYPELIST_SQLNAT  3
+
+ScDataPilotDatabaseDlg::ScDataPilotDatabaseDlg(weld::Window* pParent)
+    : GenericDialogController(pParent, "modules/scalc/ui/selectdatasource.ui", "SelectDataSourceDialog")
+    , m_xLbDatabase(m_xBuilder->weld_combo_box("database"))
+    , m_xCbObject(m_xBuilder->weld_combo_box("datasource"))
+    , m_xLbType(m_xBuilder->weld_combo_box("type"))
+{
+    weld::WaitObject aWait(pParent);       // initializing the database service the first time takes a while
+
+    try
+    {
+        //  get database names
+
+        uno::Reference<sdb::XDatabaseContext> xContext = sdb::DatabaseContext::create(
+                comphelper::getProcessComponentContext() );
+        const uno::Sequence<OUString> aNames = xContext->getElementNames();
+        for( const OUString& aName : aNames )
+        {
+            m_xLbDatabase->append_text(aName);
+        }
+    }
+    catch(uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION( "sc", "exception in database");
+    }
+
+    m_xLbDatabase->set_active(0);
+    m_xLbType->set_active(0);
+
+    FillObjects();
+
+    m_xLbDatabase->connect_changed( LINK( this, ScDataPilotDatabaseDlg, SelectHdl ) );
+    m_xLbType->connect_changed( LINK( this, ScDataPilotDatabaseDlg, SelectHdl ) );
+}
+
+ScDataPilotDatabaseDlg::~ScDataPilotDatabaseDlg()
+{
+}
+
+void ScDataPilotDatabaseDlg::GetValues( ScImportSourceDesc& rDesc )
+{
+    const sal_Int32 nSelect = m_xLbType->get_active();
+
+    rDesc.aDBName = m_xLbDatabase->get_active_text();
+    rDesc.aObject = m_xCbObject->get_active_text();
+
+    if (rDesc.aDBName.isEmpty() || rDesc.aObject.isEmpty())
+        rDesc.nType = sheet::DataImportMode_NONE;
+    else if ( nSelect == DP_TYPELIST_TABLE )
+        rDesc.nType = sheet::DataImportMode_TABLE;
+    else if ( nSelect == DP_TYPELIST_QUERY )
+        rDesc.nType = sheet::DataImportMode_QUERY;
+    else
+        rDesc.nType = sheet::DataImportMode_SQL;
+
+    rDesc.bNative = ( nSelect == DP_TYPELIST_SQLNAT );
+}
+
+IMPL_LINK_NOARG(ScDataPilotDatabaseDlg, SelectHdl, weld::ComboBox&, void)
+{
+    FillObjects();
+}
+
+void ScDataPilotDatabaseDlg::FillObjects()
+{
+    m_xCbObject->clear();
+
+    OUString aDatabaseName = m_xLbDatabase->get_active_text();
+    if (aDatabaseName.isEmpty())
+        return;
+
+    const int nSelect = m_xLbType->get_active();
+    if ( nSelect > DP_TYPELIST_QUERY )
+        return;                                 // only tables and queries
+
+    try
+    {
+        //  open connection (for tables or queries)
+
+        uno::Reference<sdb::XDatabaseContext> xContext = sdb::DatabaseContext::create(
+                comphelper::getProcessComponentContext() );
+
+        uno::Any aSourceAny = xContext->getByName( aDatabaseName );
+        uno::Reference<sdb::XCompletedConnection> xSource(aSourceAny, uno::UNO_QUERY);
+        if ( !xSource.is() ) return;
+
+        uno::Reference<task::XInteractionHandler> xHandler(
+            task::InteractionHandler::createWithParent(comphelper::getProcessComponentContext(), nullptr),
+            uno::UNO_QUERY_THROW);
+
+        uno::Reference<sdbc::XConnection> xConnection = xSource->connectWithCompletion( xHandler );
+
+        uno::Reference<container::XNameAccess> xItems;
+        if ( nSelect == DP_TYPELIST_TABLE )
+        {
+            //  get all tables
+
+            uno::Reference<sdbcx::XTablesSupplier> xTablesSupp( xConnection, uno::UNO_QUERY );
+            if ( !xTablesSupp.is() ) return;
+
+            xItems = xTablesSupp->getTables();
+        }
+        else
+        {
+            //  get all queries
+
+            uno::Reference<sdb::XQueriesSupplier> xQueriesSupp( xConnection, uno::UNO_QUERY );
+            if ( !xQueriesSupp.is() ) return;
+
+            xItems = xQueriesSupp->getQueries();
+        }
+
+        if ( !xItems.is() ) return;
+
+        //  fill list
+        const uno::Sequence<OUString> aNames = xItems->getElementNames();
+        for( const OUString& aName : aNames )
+        {
+            m_xCbObject->append_text(aName);
+        }
+    }
+    catch(uno::Exception&)
+    {
+        //  this may happen if an invalid database is selected -> no DBG_ERROR
+        TOOLS_WARN_EXCEPTION( "sc", "exception in database");
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/dapitype.cxx b/sc/source/ui/dbgui/dapitype.cxx
new file mode 100644
index 000000000..9843a2bb9
--- /dev/null
+++ b/sc/source/ui/dbgui/dapitype.cxx
@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <dapitype.hxx>
+#include <comphelper/lok.hxx>
+
+using namespace com::sun::star;
+
+ScDataPilotSourceTypeDlg::ScDataPilotSourceTypeDlg(weld::Window* pParent, bool bEnableExternal)
+    : GenericDialogController(pParent, "modules/scalc/ui/selectsource.ui", "SelectSourceDialog")
+    , m_xBtnSelection(m_xBuilder->weld_radio_button("selection"))
+    , m_xBtnNamedRange(m_xBuilder->weld_radio_button("namedrange"))
+    , m_xBtnDatabase(m_xBuilder->weld_radio_button("database"))
+    , m_xBtnExternal(m_xBuilder->weld_radio_button("external"))
+    , m_xLbNamedRange(m_xBuilder->weld_combo_box("rangelb"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok")) // for LOK jsdialog
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel")) // for LOK jsdialog
+{
+    m_xBtnSelection->connect_toggled( LINK(this, ScDataPilotSourceTypeDlg, RadioClickHdl) );
+    m_xBtnNamedRange->connect_toggled( LINK(this, ScDataPilotSourceTypeDlg, RadioClickHdl) );
+    m_xBtnDatabase->connect_toggled( LINK(this, ScDataPilotSourceTypeDlg, RadioClickHdl) );
+    m_xBtnExternal->connect_toggled( LINK(this, ScDataPilotSourceTypeDlg, RadioClickHdl) );
+
+    m_xBtnOk->connect_clicked( LINK(this, ScDataPilotSourceTypeDlg, ResponseHdl ) );
+    m_xBtnCancel->connect_clicked( LINK(this, ScDataPilotSourceTypeDlg, ResponseHdl ) );
+
+    if (!bEnableExternal)
+        m_xBtnExternal->set_sensitive(false);
+
+    m_xBtnSelection->set_active(true);
+
+    // Disabled unless at least one named range exists.
+    m_xLbNamedRange->set_sensitive(false);
+    m_xBtnNamedRange->set_sensitive(false);
+
+    // Intentionally hide this button to see if anyone complains.
+    m_xBtnExternal->hide();
+
+    if (comphelper::LibreOfficeKit::isActive())
+        m_xBtnDatabase->hide();
+}
+
+IMPL_LINK(ScDataPilotSourceTypeDlg, ResponseHdl, weld::Button&, rButton, void)
+{
+    if (&rButton == m_xBtnOk.get())
+        m_xDialog->response(RET_OK);
+    else
+        m_xDialog->response(RET_CANCEL);
+}
+
+ScDataPilotSourceTypeDlg::~ScDataPilotSourceTypeDlg()
+{
+}
+
+bool ScDataPilotSourceTypeDlg::IsDatabase() const
+{
+    return m_xBtnDatabase->get_active();
+}
+
+bool ScDataPilotSourceTypeDlg::IsExternal() const
+{
+    return m_xBtnExternal->get_active();
+}
+
+bool ScDataPilotSourceTypeDlg::IsNamedRange() const
+{
+    return m_xBtnNamedRange->get_active();
+}
+
+OUString ScDataPilotSourceTypeDlg::GetSelectedNamedRange() const
+{
+    return m_xLbNamedRange->get_active_text();
+}
+
+void ScDataPilotSourceTypeDlg::AppendNamedRange(const OUString& rName)
+{
+    m_xLbNamedRange->append_text(rName);
+    if (m_xLbNamedRange->get_count() == 1)
+    {
+        // Select position 0 only for the first time.
+        m_xLbNamedRange->set_active(0);
+        m_xBtnNamedRange->set_sensitive(true);
+    }
+}
+
+IMPL_LINK_NOARG(ScDataPilotSourceTypeDlg, RadioClickHdl, weld::Toggleable&, void)
+{
+    m_xLbNamedRange->set_sensitive(m_xBtnNamedRange->get_active());
+}
+
+ScDataPilotServiceDlg::ScDataPilotServiceDlg(weld::Window* pParent, const std::vector<OUString>& rServices)
+    : GenericDialogController(pParent, "modules/scalc/ui/dapiservicedialog.ui", "DapiserviceDialog")
+    , m_xLbService(m_xBuilder->weld_combo_box("service"))
+    , m_xEdSource(m_xBuilder->weld_entry("source"))
+    , m_xEdName(m_xBuilder->weld_entry("name"))
+    , m_xEdUser(m_xBuilder->weld_entry("user"))
+    , m_xEdPasswd(m_xBuilder->weld_entry("password"))
+{
+    for (const OUString& aName : rServices)
+    {
+        m_xLbService->append_text(aName);
+    }
+    m_xLbService->set_active(0);
+}
+
+ScDataPilotServiceDlg::~ScDataPilotServiceDlg()
+{
+}
+
+OUString ScDataPilotServiceDlg::GetServiceName() const
+{
+    return m_xLbService->get_active_text();
+}
+
+OUString ScDataPilotServiceDlg::GetParSource() const
+{
+    return m_xEdSource->get_text();
+}
+
+OUString ScDataPilotServiceDlg::GetParName() const
+{
+    return m_xEdName->get_text();
+}
+
+OUString ScDataPilotServiceDlg::GetParUser() const
+{
+    return m_xEdUser->get_text();
+}
+
+OUString ScDataPilotServiceDlg::GetParPass() const
+{
+    return m_xEdPasswd->get_text();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/dbnamdlg.cxx b/sc/source/ui/dbgui/dbnamdlg.cxx
new file mode 100644
index 000000000..a2ac72209
--- /dev/null
+++ b/sc/source/ui/dbgui/dbnamdlg.cxx
@@ -0,0 +1,645 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <sal/config.h>
+
+#include <cassert>
+
+#include <comphelper/string.hxx>
+#include <unotools/charclass.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <reffact.hxx>
+#include <document.hxx>
+#include <globstr.hrc>
+#include <scresid.hxx>
+#include <rangenam.hxx>
+#include <globalnames.hxx>
+#include <dbnamdlg.hxx>
+#include <dbdocfun.hxx>
+
+namespace {
+
+class DBSaveData;
+
+}
+
+static std::unique_ptr<DBSaveData> xSaveObj;
+
+namespace
+{
+    void ERRORBOX(weld::Window* pParent, const OUString& rString)
+    {
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent,
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  rString));
+        xBox->run();
+    }
+
+
+class DBSaveData
+{
+public:
+    DBSaveData( formula::RefEdit& rEd, weld::CheckButton& rHdr, weld::CheckButton& rTot, weld::CheckButton& rSize, weld::CheckButton& rFmt,
+                            weld::CheckButton& rStrip, ScRange& rArea )
+        : rEdAssign(rEd)
+        , rBtnHeader(rHdr)
+        , rBtnTotals(rTot)
+        , rBtnSize(rSize)
+        , rBtnFormat(rFmt)
+        , rBtnStrip(rStrip)
+        , rCurArea(rArea)
+        , bHeader(false)
+        , bTotals(false)
+        , bSize(false)
+        , bFormat(false)
+        , bStrip(false)
+        , bDirty(false)
+    {
+    }
+    void Save();
+    void Restore();
+
+private:
+    formula::RefEdit& rEdAssign;
+    weld::CheckButton& rBtnHeader;
+    weld::CheckButton& rBtnTotals;
+    weld::CheckButton& rBtnSize;
+    weld::CheckButton& rBtnFormat;
+    weld::CheckButton& rBtnStrip;
+    ScRange&    rCurArea;
+    OUString    aStr;
+    ScRange     aArea;
+    bool        bHeader:1;
+    bool        bTotals:1;
+    bool        bSize:1;
+    bool        bFormat:1;
+    bool        bStrip:1;
+    bool        bDirty:1;
+};
+
+}
+
+void DBSaveData::Save()
+{
+    aArea   = rCurArea;
+    aStr    = rEdAssign.GetText();
+    bHeader = rBtnHeader.get_active();
+    bTotals = rBtnTotals.get_active();
+    bSize   = rBtnSize.get_active();
+    bFormat = rBtnFormat.get_active();
+    bStrip  = rBtnStrip.get_active();
+    bDirty  = true;
+}
+
+void DBSaveData::Restore()
+{
+    if ( bDirty )
+    {
+        rCurArea = aArea;
+        rEdAssign.SetText( aStr );
+        rBtnHeader.set_active ( bHeader );
+        rBtnTotals.set_active ( bTotals );
+        rBtnSize.set_active   ( bSize );
+        rBtnFormat.set_active ( bFormat );
+        rBtnStrip.set_active  ( bStrip );
+        bDirty = false;
+    }
+}
+
+
+ScDbNameDlg::ScDbNameDlg(SfxBindings* pB, SfxChildWindow* pCW, weld::Window* pParent,
+    ScViewData& rViewData)
+    : ScAnyRefDlgController(pB, pCW, pParent,
+        "modules/scalc/ui/definedatabaserangedialog.ui", "DefineDatabaseRangeDialog")
+    , m_rViewData(rViewData)
+    , rDoc(rViewData.GetDocument())
+    , bRefInputMode(false)
+    , aAddrDetails(rDoc.GetAddressConvention(), 0, 0)
+    , aLocalDbCol(*(rDoc.GetDBCollection()))
+    , m_xEdName(m_xBuilder->weld_entry_tree_view("entrygrid", "entry", "entry-list"))
+    , m_xAssignFrame(m_xBuilder->weld_frame("RangeFrame"))
+    , m_xEdAssign(new formula::RefEdit(m_xBuilder->weld_entry("assign")))
+    , m_xRbAssign(new formula::RefButton(m_xBuilder->weld_button("assignrb")))
+    , m_xOptions(m_xBuilder->weld_widget("Options"))
+    , m_xBtnHeader(m_xBuilder->weld_check_button("ContainsColumnLabels"))
+    , m_xBtnTotals(m_xBuilder->weld_check_button("ContainsTotalsRow"))
+    , m_xBtnDoSize(m_xBuilder->weld_check_button("InsertOrDeleteCells"))
+    , m_xBtnKeepFmt(m_xBuilder->weld_check_button("KeepFormatting"))
+    , m_xBtnStripData(m_xBuilder->weld_check_button("DontSaveImportedData"))
+    , m_xFTSource(m_xBuilder->weld_label("Source"))
+    , m_xFTOperations(m_xBuilder->weld_label("Operations"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel"))
+    , m_xBtnAdd(m_xBuilder->weld_button("add"))
+    , m_xBtnRemove(m_xBuilder->weld_button("delete"))
+    , m_xModifyPB(m_xBuilder->weld_button("modify"))
+    , m_xInvalidFT(m_xBuilder->weld_label("invalid"))
+    , m_xFrameLabel(m_xAssignFrame->weld_label_widget())
+    , m_xExpander(m_xBuilder->weld_expander("more"))
+{
+    m_xEdName->set_height_request_by_rows(4);
+    m_xEdAssign->SetReferences(this, m_xFrameLabel.get());
+    m_xRbAssign->SetReferences(this, m_xEdAssign.get());
+    aStrAdd = m_xBtnAdd->get_label();
+    aStrModify = m_xModifyPB->get_label();
+    aStrInvalid = m_xInvalidFT->get_label();
+
+    //  so that the strings in the resource can stay with fixed texts:
+    aStrSource      = m_xFTSource->get_label();
+    aStrOperations  = m_xFTOperations->get_label();
+
+    xSaveObj.reset(new DBSaveData( *m_xEdAssign, *m_xBtnHeader, *m_xBtnTotals,
+                        *m_xBtnDoSize, *m_xBtnKeepFmt, *m_xBtnStripData, theCurArea ));
+    Init();
+}
+
+ScDbNameDlg::~ScDbNameDlg()
+{
+    xSaveObj.reset();
+}
+
+void ScDbNameDlg::Init()
+{
+    m_xBtnHeader->set_active(true);          // Default: with column headers
+    m_xBtnTotals->set_active( false );   // Default: without totals row
+    m_xBtnDoSize->set_active(true);
+    m_xBtnKeepFmt->set_active(true);
+
+    m_xBtnOk->connect_clicked      ( LINK( this, ScDbNameDlg, OkBtnHdl ) );
+    m_xBtnCancel->connect_clicked  ( LINK( this, ScDbNameDlg, CancelBtnHdl ) );
+    m_xBtnAdd->connect_clicked     ( LINK( this, ScDbNameDlg, AddBtnHdl ) );
+    m_xBtnRemove->connect_clicked  ( LINK( this, ScDbNameDlg, RemoveBtnHdl ) );
+    m_xEdName->connect_changed( LINK( this, ScDbNameDlg, NameModifyHdl ) );
+    m_xEdAssign->SetModifyHdl  ( LINK( this, ScDbNameDlg, AssModifyHdl ) );
+    UpdateNames();
+
+    OUString  theAreaStr;
+
+    SCCOL   nStartCol   = 0;
+    SCROW   nStartRow   = 0;
+    SCTAB   nStartTab   = 0;
+    SCCOL   nEndCol     = 0;
+    SCROW   nEndRow     = 0;
+    SCTAB   nEndTab     = 0;
+
+    ScDBCollection* pDBColl = rDoc.GetDBCollection();
+
+    m_rViewData.GetSimpleArea( nStartCol, nStartRow, nStartTab,
+                              nEndCol,   nEndRow,  nEndTab );
+
+    theCurArea = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
+
+    theAreaStr = theCurArea.Format(rDoc, ScRefFlags::RANGE_ABS_3D, aAddrDetails);
+
+    if ( pDBColl )
+    {
+        // determine if the defined DB area has been marked:
+        ScDBData* pDBData = pDBColl->GetDBAtCursor( nStartCol, nStartRow, nStartTab, ScDBDataPortion::TOP_LEFT );
+        if ( pDBData )
+        {
+            ScAddress&  rStart = theCurArea.aStart;
+            ScAddress&  rEnd   = theCurArea.aEnd;
+            SCCOL nCol1;
+            SCCOL  nCol2;
+            SCROW  nRow1;
+            SCROW  nRow2;
+            SCTAB  nTab;
+
+            pDBData->GetArea( nTab, nCol1, nRow1, nCol2, nRow2 );
+
+            if (   (rStart.Tab() == nTab)
+                && (rStart.Col() == nCol1) && (rStart.Row() == nRow1)
+                && (rEnd.Col()   == nCol2) && (rEnd.Row()   == nRow2 ) )
+            {
+                OUString aDBName = pDBData->GetName();
+                if ( aDBName != STR_DB_LOCAL_NONAME )
+                    m_xEdName->set_entry_text(aDBName);
+
+                m_xBtnHeader->set_active( pDBData->HasHeader() );
+                m_xBtnTotals->set_active( pDBData->HasTotals() );
+                m_xBtnDoSize->set_active( pDBData->IsDoSize() );
+                m_xBtnKeepFmt->set_active( pDBData->IsKeepFmt() );
+                m_xBtnStripData->set_active( pDBData->IsStripData() );
+                SetInfoStrings( pDBData );
+            }
+        }
+    }
+
+    m_xEdAssign->SetText( theAreaStr );
+    m_xEdName->grab_focus();
+    bSaved = true;
+    xSaveObj->Save();
+    NameModifyHdl( *m_xEdName );
+    bInvalid = false;
+}
+
+void ScDbNameDlg::SetInfoStrings( const ScDBData* pDBData )
+{
+    OUStringBuffer aBuf;
+    aBuf.append(aStrSource);
+    if (pDBData)
+    {
+        aBuf.append(' ');
+        aBuf.append(pDBData->GetSourceString());
+    }
+    m_xFTSource->set_label(aBuf.makeStringAndClear());
+
+    aBuf.append(aStrOperations);
+    if (pDBData)
+    {
+        aBuf.append(' ');
+        aBuf.append(pDBData->GetOperations());
+    }
+    m_xFTOperations->set_label(aBuf.makeStringAndClear());
+}
+
+// Transfer of a table area selected with the mouse, which is then displayed
+// as a new selection in the reference window.
+
+void ScDbNameDlg::SetReference( const ScRange& rRef, ScDocument& rDocP )
+{
+    if (!m_xEdAssign->GetWidget()->get_sensitive())
+        return;
+
+    if ( rRef.aStart != rRef.aEnd )
+        RefInputStart(m_xEdAssign.get());
+
+    theCurArea = rRef;
+
+    OUString aRefStr(theCurArea.Format(rDocP, ScRefFlags::RANGE_ABS_3D, aAddrDetails));
+    m_xEdAssign->SetRefString( aRefStr );
+    m_xOptions->set_sensitive(true);
+    m_xBtnAdd->set_sensitive(true);
+    bSaved = true;
+    xSaveObj->Save();
+}
+
+void ScDbNameDlg::Close()
+{
+    DoClose( ScDbNameDlgWrapper::GetChildWindowId() );
+}
+
+void ScDbNameDlg::SetActive()
+{
+    m_xEdAssign->GrabFocus();
+
+    //  No NameModifyHdl, because otherwise areas can not be changed
+    //  (the old content would be displayed again after the reference selection is pulled)
+    //  (the selected DB name has not changed either)
+
+    RefInputDone();
+}
+
+void ScDbNameDlg::UpdateNames()
+{
+    typedef ScDBCollection::NamedDBs DBsType;
+
+    const DBsType& rDBs = aLocalDbCol.getNamedDBs();
+
+    m_xEdName->freeze();
+
+    m_xEdName->clear();
+    m_xEdAssign->SetText( OUString() );
+
+    if (!rDBs.empty())
+    {
+        for (const auto& rxDB : rDBs)
+            m_xEdName->append_text(rxDB->GetName());
+    }
+    else
+    {
+        m_xBtnAdd->set_label( aStrAdd );
+        m_xBtnAdd->set_sensitive(false);
+        m_xBtnRemove->set_sensitive(false);
+    }
+
+    m_xEdName->thaw();
+}
+
+void ScDbNameDlg::UpdateDBData( const OUString& rStrName )
+{
+
+    const ScDBData* pData = aLocalDbCol.getNamedDBs().findByUpperName(ScGlobal::getCharClass().uppercase(rStrName));
+
+    if ( pData )
+    {
+        SCCOL nColStart = 0;
+        SCROW nRowStart = 0;
+        SCCOL nColEnd    = 0;
+        SCROW nRowEnd    = 0;
+        SCTAB nTab       = 0;
+
+        pData->GetArea( nTab, nColStart, nRowStart, nColEnd, nRowEnd );
+        theCurArea = ScRange( ScAddress( nColStart, nRowStart, nTab ),
+                              ScAddress( nColEnd,   nRowEnd,   nTab ) );
+        OUString theArea(theCurArea.Format(rDoc, ScRefFlags::RANGE_ABS_3D, aAddrDetails));
+        m_xEdAssign->SetText( theArea );
+        m_xBtnAdd->set_label( aStrModify );
+        m_xBtnHeader->set_active( pData->HasHeader() );
+        m_xBtnTotals->set_active( pData->HasTotals() );
+        m_xBtnDoSize->set_active( pData->IsDoSize() );
+        m_xBtnKeepFmt->set_active( pData->IsKeepFmt() );
+        m_xBtnStripData->set_active( pData->IsStripData() );
+        SetInfoStrings( pData );
+    }
+
+    m_xBtnAdd->set_label( aStrModify );
+    m_xBtnAdd->set_sensitive(true);
+    m_xBtnRemove->set_sensitive(true);
+    m_xOptions->set_sensitive(true);
+}
+
+bool ScDbNameDlg::IsRefInputMode() const
+{
+    return bRefInputMode;
+}
+
+// Handler:
+
+IMPL_LINK_NOARG(ScDbNameDlg, OkBtnHdl, weld::Button&, void)
+{
+    bInvalid = false;
+    AddBtnHdl(*m_xBtnAdd);
+
+    // Pass the changes and the remove list to the view: both are
+    // transferred as a reference only, so that no dead memory can
+    // be created at this point:
+    if (!bInvalid)
+    {
+        ScDBDocFunc aFunc(*m_rViewData.GetDocShell());
+        aFunc.ModifyAllDBData(aLocalDbCol, aRemoveList);
+        response(RET_OK);
+    }
+}
+
+IMPL_LINK_NOARG(ScDbNameDlg, CancelBtnHdl, weld::Button&, void)
+{
+    response(RET_CANCEL);
+}
+
+IMPL_LINK_NOARG(ScDbNameDlg, AddBtnHdl, weld::Button&, void)
+{
+    OUString aNewName = comphelper::string::strip(m_xEdName->get_active_text(), ' ');
+    OUString aNewArea = m_xEdAssign->GetText();
+
+    if ( aNewName.isEmpty() || aNewArea.isEmpty() )
+        return;
+
+    if (ScRangeData::IsNameValid(aNewName, rDoc) == ScRangeData::IsNameValidType::NAME_VALID
+        && aNewName != STR_DB_LOCAL_NONAME)
+    {
+        //  because editing can be done now, parsing is needed first
+        ScRange aTmpRange;
+        OUString aText = m_xEdAssign->GetText();
+        if ( aTmpRange.ParseAny( aText, rDoc, aAddrDetails ) & ScRefFlags::VALID )
+        {
+            theCurArea = aTmpRange;
+            ScAddress aStart = theCurArea.aStart;
+            ScAddress aEnd   = theCurArea.aEnd;
+
+            ScDBData* pOldEntry = aLocalDbCol.getNamedDBs().findByUpperName(ScGlobal::getCharClass().uppercase(aNewName));
+            if (pOldEntry)
+            {
+                //  modify area
+
+                pOldEntry->MoveTo( aStart.Tab(), aStart.Col(), aStart.Row(),
+                                                    aEnd.Col(), aEnd.Row() );
+                pOldEntry->SetByRow( true );
+                pOldEntry->SetHeader( m_xBtnHeader->get_active() );
+                pOldEntry->SetTotals( m_xBtnTotals->get_active() );
+                pOldEntry->SetDoSize( m_xBtnDoSize->get_active() );
+                pOldEntry->SetKeepFmt( m_xBtnKeepFmt->get_active() );
+                pOldEntry->SetStripData( m_xBtnStripData->get_active() );
+            }
+            else
+            {
+                //  insert new area
+
+                std::unique_ptr<ScDBData> pNewEntry(new ScDBData( aNewName, aStart.Tab(),
+                                                    aStart.Col(), aStart.Row(),
+                                                    aEnd.Col(), aEnd.Row(),
+                                                    true, m_xBtnHeader->get_active(),
+                                                    m_xBtnTotals->get_active() ));
+                pNewEntry->SetDoSize( m_xBtnDoSize->get_active() );
+                pNewEntry->SetKeepFmt( m_xBtnKeepFmt->get_active() );
+                pNewEntry->SetStripData( m_xBtnStripData->get_active() );
+
+                bool ins = aLocalDbCol.getNamedDBs().insert(std::move(pNewEntry));
+                assert(ins); (void)ins;
+            }
+
+            UpdateNames();
+
+            m_xEdName->set_entry_text( OUString() );
+            m_xEdName->grab_focus();
+            m_xBtnAdd->set_label( aStrAdd );
+            m_xBtnAdd->set_sensitive(false);
+            m_xBtnRemove->set_sensitive(false);
+            m_xEdAssign->SetText( OUString() );
+            m_xBtnHeader->set_active(true);             // Default: with column headers
+            m_xBtnTotals->set_active( false );      // Default: without totals row
+            m_xBtnDoSize->set_active( false );
+            m_xBtnKeepFmt->set_active( false );
+            m_xBtnStripData->set_active( false );
+            SetInfoStrings( nullptr );     // empty
+            theCurArea = ScRange();
+            bSaved = true;
+            xSaveObj->Save();
+            NameModifyHdl( *m_xEdName );
+        }
+        else
+        {
+            ERRORBOX(m_xDialog.get(), aStrInvalid);
+            m_xEdAssign->SelectAll();
+            m_xEdAssign->GrabFocus();
+            bInvalid = true;
+        }
+    }
+    else
+    {
+        ERRORBOX(m_xDialog.get(), ScResId(STR_INVALIDNAME));
+        m_xEdName->select_entry_region(0, -1);
+        m_xEdName->grab_focus();
+        bInvalid = true;
+    }
+}
+
+namespace {
+
+class FindByName
+{
+    const OUString& mrName;
+public:
+    explicit FindByName(const OUString& rName) : mrName(rName) {}
+    bool operator() (std::unique_ptr<ScDBData> const& p) const
+    {
+        return p->GetName() == mrName;
+    }
+};
+
+}
+
+IMPL_LINK_NOARG(ScDbNameDlg, RemoveBtnHdl, weld::Button&, void)
+{
+    OUString aStrEntry = m_xEdName->get_active_text();
+    ScDBCollection::NamedDBs& rDBs = aLocalDbCol.getNamedDBs();
+    ScDBCollection::NamedDBs::iterator itr =
+        ::std::find_if(rDBs.begin(), rDBs.end(), FindByName(aStrEntry));
+
+    if (itr == rDBs.end())
+        return;
+
+    OUString aStrDelMsg = ScResId( STR_QUERY_DELENTRY );
+    OUString sMsg{ o3tl::getToken(aStrDelMsg, 0, '#') + aStrEntry + o3tl::getToken(aStrDelMsg, 1, '#') };
+    std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                   VclMessageType::Question, VclButtonsType::YesNo,
+                                                   sMsg));
+    xQueryBox->set_default_response(RET_YES);
+    if (RET_YES != xQueryBox->run())
+        return;
+
+    SCTAB nTab;
+    SCCOL nColStart, nColEnd;
+    SCROW nRowStart, nRowEnd;
+    (*itr)->GetArea( nTab, nColStart, nRowStart, nColEnd, nRowEnd );
+    aRemoveList.emplace_back( ScAddress( nColStart, nRowStart, nTab ),
+                 ScAddress( nColEnd,   nRowEnd,   nTab ) );
+
+    rDBs.erase(itr);
+
+    UpdateNames();
+
+    m_xEdName->set_entry_text( OUString() );
+    m_xEdName->grab_focus();
+    m_xBtnAdd->set_label( aStrAdd );
+    m_xBtnAdd->set_sensitive(false);
+    m_xBtnRemove->set_sensitive(false);
+    m_xEdAssign->SetText( OUString() );
+    theCurArea = ScRange();
+    m_xBtnHeader->set_active(true);             // Default: with column headers
+    m_xBtnTotals->set_active( false );      // Default: without totals row
+    m_xBtnDoSize->set_active( false );
+    m_xBtnKeepFmt->set_active( false );
+    m_xBtnStripData->set_active( false );
+    SetInfoStrings( nullptr );     // empty
+    bSaved=false;
+    xSaveObj->Restore();
+    NameModifyHdl( *m_xEdName );
+}
+
+IMPL_LINK_NOARG(ScDbNameDlg, NameModifyHdl, weld::ComboBox&, void)
+{
+    OUString  theName     = m_xEdName->get_active_text();
+    bool    bNameFound  = m_xEdName->find_text(theName) != -1;
+
+    if ( theName.isEmpty() )
+    {
+        if (m_xBtnAdd->get_label() != aStrAdd)
+            m_xBtnAdd->set_label( aStrAdd );
+        m_xBtnAdd->set_sensitive(false);
+        m_xBtnRemove->set_sensitive(false);
+        m_xAssignFrame->set_sensitive(false);
+        m_xOptions->set_sensitive(false);
+        //bSaved=sal_False;
+        //xSaveObj->Restore();
+        //@BugID 54702 enable/disable in the base class only
+        //SFX_APPWINDOW->Disable(sal_False);        //! general method in ScAnyRefDlg
+        bRefInputMode = false;
+    }
+    else
+    {
+        if ( bNameFound )
+        {
+            if (m_xBtnAdd->get_label() != aStrModify)
+                m_xBtnAdd->set_label( aStrModify );
+
+            if(!bSaved)
+            {
+                bSaved = true;
+                xSaveObj->Save();
+            }
+            UpdateDBData( theName );
+        }
+        else
+        {
+            if (m_xBtnAdd->get_label() != aStrAdd)
+                m_xBtnAdd->set_label( aStrAdd );
+
+            bSaved=false;
+            xSaveObj->Restore();
+
+            if ( !m_xEdAssign->GetText().isEmpty() )
+            {
+                m_xBtnAdd->set_sensitive(true);
+                m_xOptions->set_sensitive(true);
+            }
+            else
+            {
+                m_xBtnAdd->set_sensitive(false);
+                m_xOptions->set_sensitive(false);
+            }
+            m_xBtnRemove->set_sensitive(false);
+        }
+
+        m_xAssignFrame->set_sensitive(true);
+
+        //@BugID 54702 enable/disable in the base class only
+        //SFX_APPWINDOW->set_sensitive(true);
+        bRefInputMode = true;
+    }
+}
+
+IMPL_LINK_NOARG(ScDbNameDlg, AssModifyHdl, formula::RefEdit&, void)
+{
+    //  parse here for Save(), etc.
+
+    ScRange aTmpRange;
+    OUString aText = m_xEdAssign->GetText();
+    if ( aTmpRange.ParseAny( aText, rDoc, aAddrDetails ) & ScRefFlags::VALID )
+        theCurArea = aTmpRange;
+
+    if (!aText.isEmpty() && !m_xEdName->get_active_text().isEmpty())
+    {
+        m_xBtnAdd->set_sensitive(true);
+        m_xBtnHeader->set_sensitive(true);
+        m_xBtnTotals->set_sensitive(true);
+        m_xBtnDoSize->set_sensitive(true);
+        m_xBtnKeepFmt->set_sensitive(true);
+        m_xBtnStripData->set_sensitive(true);
+        m_xFTSource->set_sensitive(true);
+        m_xFTOperations->set_sensitive(true);
+    }
+    else
+    {
+        m_xBtnAdd->set_sensitive(false);
+        m_xBtnHeader->set_sensitive(false);
+        m_xBtnTotals->set_sensitive(false);
+        m_xBtnDoSize->set_sensitive(false);
+        m_xBtnKeepFmt->set_sensitive(false);
+        m_xBtnStripData->set_sensitive(false);
+        m_xFTSource->set_sensitive(false);
+        m_xFTOperations->set_sensitive(false);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/dpgroupdlg.cxx b/sc/source/ui/dbgui/dpgroupdlg.cxx
new file mode 100644
index 000000000..550695cc3
--- /dev/null
+++ b/sc/source/ui/dbgui/dpgroupdlg.cxx
@@ -0,0 +1,353 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifdef SC_DLLIMPLEMENTATION
+#undef SC_DLLIMPLEMENTATION
+#endif
+
+#include <dpgroupdlg.hxx>
+#include <globstr.hrc>
+#include <scresid.hxx>
+#include <editfield.hxx>
+
+#include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
+#include <svtools/ctrlbox.hxx>
+
+namespace {
+
+/** Date part flags in order of the list box entries. */
+const sal_Int32 spnDateParts[] =
+{
+    css::sheet::DataPilotFieldGroupBy::SECONDS,
+    css::sheet::DataPilotFieldGroupBy::MINUTES,
+    css::sheet::DataPilotFieldGroupBy::HOURS,
+    css::sheet::DataPilotFieldGroupBy::DAYS,
+    css::sheet::DataPilotFieldGroupBy::MONTHS,
+    css::sheet::DataPilotFieldGroupBy::QUARTERS,
+    css::sheet::DataPilotFieldGroupBy::YEARS
+};
+
+const TranslateId aDatePartResIds[] =
+{
+    STR_DPFIELD_GROUP_BY_SECONDS,
+    STR_DPFIELD_GROUP_BY_MINUTES,
+    STR_DPFIELD_GROUP_BY_HOURS,
+    STR_DPFIELD_GROUP_BY_DAYS,
+    STR_DPFIELD_GROUP_BY_MONTHS,
+    STR_DPFIELD_GROUP_BY_QUARTERS,
+    STR_DPFIELD_GROUP_BY_YEARS
+};
+
+} // namespace
+
+ScDPGroupEditHelper::ScDPGroupEditHelper(weld::RadioButton& rRbAuto, weld::RadioButton& rRbMan, weld::Widget& rEdValue)
+    : mrRbAuto(rRbAuto)
+    , mrRbMan(rRbMan)
+    , mrEdValue(rEdValue)
+{
+    mrRbAuto.connect_toggled( LINK( this, ScDPGroupEditHelper, ToggleHdl ) );
+    mrRbMan.connect_toggled( LINK( this, ScDPGroupEditHelper, ToggleHdl ) );
+}
+
+bool ScDPGroupEditHelper::IsAuto() const
+{
+    return mrRbAuto.get_active();
+}
+
+double ScDPGroupEditHelper::GetValue() const
+{
+    double fValue;
+    if( !ImplGetValue( fValue ) )
+        fValue = 0.0;
+    return fValue;
+}
+
+void ScDPGroupEditHelper::SetValue( bool bAuto, double fValue )
+{
+    if( bAuto )
+    {
+        mrRbAuto.set_active(true);
+        ToggleHdl(mrRbAuto);
+    }
+    else
+    {
+        mrRbMan.set_active(true);
+        ToggleHdl(mrRbMan);
+    }
+    ImplSetValue( fValue );
+}
+
+IMPL_LINK(ScDPGroupEditHelper, ToggleHdl, weld::Toggleable&, rButton, void)
+{
+    if (!rButton.get_active())
+        return;
+
+    if (mrRbAuto.get_active())
+    {
+        // disable edit field on clicking "automatic" radio button
+        mrEdValue.set_sensitive(false);
+    }
+    else if (mrRbMan.get_active())
+    {
+        // enable and set focus to edit field on clicking "manual" radio button
+        mrEdValue.set_sensitive(true);
+        mrEdValue.grab_focus();
+    }
+}
+
+ScDPNumGroupEditHelper::ScDPNumGroupEditHelper(weld::RadioButton& rRbAuto,
+    weld::RadioButton& rRbMan, ScDoubleField& rEdValue)
+    : ScDPGroupEditHelper(rRbAuto, rRbMan, rEdValue.get_widget())
+    , mrEdValue(rEdValue)
+{
+}
+
+bool ScDPNumGroupEditHelper::ImplGetValue( double& rfValue ) const
+{
+    return mrEdValue.GetValue(rfValue);
+}
+
+void ScDPNumGroupEditHelper::ImplSetValue( double fValue )
+{
+    mrEdValue.SetValue(fValue);
+}
+
+ScDPDateGroupEditHelper::ScDPDateGroupEditHelper(weld::RadioButton& rRbAuto, weld::RadioButton& rRbMan,
+                                                 SvtCalendarBox& rEdValue, const Date& rNullDate)
+    : ScDPGroupEditHelper(rRbAuto, rRbMan, rEdValue.get_button())
+    , mrEdValue(rEdValue)
+    , maNullDate(rNullDate)
+{
+}
+
+bool ScDPDateGroupEditHelper::ImplGetValue( double& rfValue ) const
+{
+    rfValue = mrEdValue.get_date() - maNullDate;
+    return true;
+}
+
+void ScDPDateGroupEditHelper::ImplSetValue( double fValue )
+{
+    Date aDate( maNullDate );
+    aDate.AddDays( fValue );
+    mrEdValue.set_date( aDate );
+}
+
+ScDPNumGroupDlg::ScDPNumGroupDlg(weld::Window* pParent, const ScDPNumGroupInfo& rInfo)
+    : GenericDialogController(pParent, "modules/scalc/ui/groupbynumber.ui", "PivotTableGroupByNumber")
+    , mxRbAutoStart(m_xBuilder->weld_radio_button("auto_start"))
+    , mxRbManStart(m_xBuilder->weld_radio_button("manual_start"))
+    , mxEdStart(new ScDoubleField(m_xBuilder->weld_entry("edit_start")))
+    , mxRbAutoEnd(m_xBuilder->weld_radio_button("auto_end"))
+    , mxRbManEnd(m_xBuilder->weld_radio_button("manual_end"))
+    , mxEdEnd(new ScDoubleField(m_xBuilder->weld_entry("edit_end")))
+    , mxEdBy(new ScDoubleField(m_xBuilder->weld_entry("edit_by")))
+    , maStartHelper(*mxRbAutoStart, *mxRbManStart, *mxEdStart)
+    , maEndHelper(*mxRbAutoEnd, *mxRbManEnd, *mxEdEnd)
+{
+    maStartHelper.SetValue( rInfo.mbAutoStart, rInfo.mfStart );
+    maEndHelper.SetValue( rInfo.mbAutoEnd, rInfo.mfEnd );
+    mxEdBy->SetValue( (rInfo.mfStep <= 0.0) ? 1.0 : rInfo.mfStep );
+
+    /*  Set the initial focus, currently it is somewhere after calling all the radio
+        button click handlers. Now the first enabled editable control is focused. */
+    if (mxEdStart->get_sensitive())
+        mxEdStart->grab_focus();
+    else if (mxEdEnd->get_sensitive())
+        mxEdEnd->grab_focus();
+    else
+        mxEdBy->grab_focus();
+}
+
+ScDPNumGroupDlg::~ScDPNumGroupDlg()
+{
+}
+
+ScDPNumGroupInfo ScDPNumGroupDlg::GetGroupInfo() const
+{
+    ScDPNumGroupInfo aInfo;
+    aInfo.mbEnable = true;
+    aInfo.mbDateValues = false;
+    aInfo.mbAutoStart = maStartHelper.IsAuto();
+    aInfo.mbAutoEnd = maEndHelper.IsAuto();
+
+    // get values and silently auto-correct them, if they are not valid
+    // TODO: error messages in OK event?
+    aInfo.mfStart = maStartHelper.GetValue();
+    aInfo.mfEnd = maEndHelper.GetValue();
+    if( !mxEdBy->GetValue( aInfo.mfStep ) || (aInfo.mfStep <= 0.0) )
+        aInfo.mfStep = 1.0;
+    if( aInfo.mfEnd <= aInfo.mfStart )
+        aInfo.mfEnd = aInfo.mfStart + aInfo.mfStep;
+
+    return aInfo;
+}
+
+ScDPDateGroupDlg::ScDPDateGroupDlg(weld::Window* pParent,
+        const ScDPNumGroupInfo& rInfo, sal_Int32 nDatePart, const Date& rNullDate)
+    : GenericDialogController(pParent, "modules/scalc/ui/groupbydate.ui", "PivotTableGroupByDate")
+    , mxRbAutoStart(m_xBuilder->weld_radio_button("auto_start"))
+    , mxRbManStart(m_xBuilder->weld_radio_button("manual_start"))
+    , mxEdStart(new SvtCalendarBox(m_xBuilder->weld_menu_button("start_date")))
+    , mxRbAutoEnd(m_xBuilder->weld_radio_button("auto_end"))
+    , mxRbManEnd(m_xBuilder->weld_radio_button("manual_end"))
+    , mxEdEnd(new SvtCalendarBox(m_xBuilder->weld_menu_button("end_date")))
+    , mxRbNumDays(m_xBuilder->weld_radio_button("days"))
+    , mxRbUnits(m_xBuilder->weld_radio_button("intervals"))
+    , mxEdNumDays(m_xBuilder->weld_spin_button("days_value"))
+    , mxLbUnits(m_xBuilder->weld_tree_view("interval_list"))
+    , mxBtnOk(m_xBuilder->weld_button("ok"))
+    , maStartHelper(*mxRbAutoStart, *mxRbManStart, *mxEdStart, rNullDate)
+    , maEndHelper(*mxRbAutoEnd, *mxRbManEnd, *mxEdEnd, rNullDate)
+{
+    maStartHelper.SetValue( rInfo.mbAutoStart, rInfo.mfStart );
+    maEndHelper.SetValue( rInfo.mbAutoEnd, rInfo.mfEnd );
+
+    mxLbUnits->enable_toggle_buttons(weld::ColumnToggleType::Check);
+
+    if( nDatePart == 0 )
+        nDatePart = css::sheet::DataPilotFieldGroupBy::MONTHS;
+    for (size_t nIdx = 0; nIdx < SAL_N_ELEMENTS(aDatePartResIds); ++nIdx)
+    {
+        mxLbUnits->append();
+        mxLbUnits->set_toggle(nIdx, (nDatePart & spnDateParts[ nIdx ]) ? TRISTATE_TRUE : TRISTATE_FALSE);
+        mxLbUnits->set_text(nIdx, ScResId(aDatePartResIds[nIdx]), 0);
+    }
+
+    if( rInfo.mbDateValues )
+    {
+        mxRbNumDays->set_active(true);
+        ToggleHdl(*mxRbNumDays );
+
+        double fNumDays = rInfo.mfStep;
+        if( fNumDays < 1.0 )
+            fNumDays = 1.0;
+        else if( fNumDays > 32767.0 )
+            fNumDays = 32767.0;
+        mxEdNumDays->set_value(fNumDays);
+    }
+    else
+    {
+        mxRbUnits->set_active(true);
+        ToggleHdl(*mxRbUnits);
+    }
+
+    /*  Set the initial focus, currently it is somewhere after calling all the radio
+        button click handlers. Now the first enabled editable control is focused. */
+    if( mxEdStart->get_sensitive() )
+        mxEdStart->grab_focus();
+    else if( mxEdEnd->get_sensitive() )
+        mxEdEnd->grab_focus();
+    else if( mxEdNumDays->get_sensitive() )
+        mxEdNumDays->grab_focus();
+    else if( mxLbUnits->get_sensitive() )
+        mxLbUnits->grab_focus();
+
+    mxRbNumDays->connect_toggled( LINK( this, ScDPDateGroupDlg, ToggleHdl ) );
+    mxRbUnits->connect_toggled( LINK( this, ScDPDateGroupDlg, ToggleHdl ) );
+    mxLbUnits->connect_toggled( LINK( this, ScDPDateGroupDlg, CheckHdl ) );
+}
+
+ScDPDateGroupDlg::~ScDPDateGroupDlg()
+{
+}
+
+ScDPNumGroupInfo ScDPDateGroupDlg::GetGroupInfo() const
+{
+    ScDPNumGroupInfo aInfo;
+    aInfo.mbEnable = true;
+    aInfo.mbDateValues = mxRbNumDays->get_active();
+    aInfo.mbAutoStart = maStartHelper.IsAuto();
+    aInfo.mbAutoEnd = maEndHelper.IsAuto();
+
+    // get values and silently auto-correct them, if they are not valid
+    // TODO: error messages in OK event?
+    aInfo.mfStart = maStartHelper.GetValue();
+    aInfo.mfEnd = maEndHelper.GetValue();
+    sal_Int64 nNumDays = mxEdNumDays->get_value();
+    aInfo.mfStep = static_cast<double>( aInfo.mbDateValues ? nNumDays : 0L );
+    if( aInfo.mfEnd <= aInfo.mfStart )
+        aInfo.mfEnd = aInfo.mfStart + nNumDays;
+
+    return aInfo;
+}
+
+sal_Int32 ScDPDateGroupDlg::GetDatePart() const
+{
+    // return DAYS for special "number of days" mode
+    if( mxRbNumDays->get_active() )
+        return css::sheet::DataPilotFieldGroupBy::DAYS;
+
+    // return listbox contents for "units" mode
+    sal_Int32 nDatePart = 0;
+    for (int nIdx = 0, nCount = mxLbUnits->n_children(); nIdx < nCount; ++nIdx )
+        if (mxLbUnits->get_toggle(nIdx) == TRISTATE_TRUE)
+            nDatePart |= spnDateParts[ nIdx ];
+    return nDatePart;
+}
+
+IMPL_LINK(ScDPDateGroupDlg, ToggleHdl, weld::Toggleable&, rButton, void)
+{
+    if (!rButton.get_active())
+        return;
+    if (mxRbNumDays->get_active())
+    {
+        mxLbUnits->set_sensitive(false);
+        // enable and set focus to edit field on clicking "num of days" radio button
+        mxEdNumDays->set_sensitive(true);
+        mxEdNumDays->grab_focus();
+        mxBtnOk->set_sensitive(true);
+    }
+    else if (mxRbUnits->get_active())
+    {
+        mxEdNumDays->set_sensitive(false);
+        // enable and set focus to listbox on clicking "units" radio button
+        mxLbUnits->set_sensitive(true);
+        mxLbUnits->grab_focus();
+        // disable OK button if no date part selected
+        Check();
+    }
+}
+
+namespace
+{
+    bool HasCheckedEntryCount(const weld::TreeView& rView)
+    {
+        for (int i = 0; i < rView.n_children(); ++i)
+        {
+            if (rView.get_toggle(i) == TRISTATE_TRUE)
+                return true;
+        }
+        return false;
+    }
+}
+
+IMPL_LINK_NOARG(ScDPDateGroupDlg, CheckHdl, const weld::TreeView::iter_col&, void)
+{
+    Check();
+}
+
+void ScDPDateGroupDlg::Check()
+{
+    // enable/disable OK button on modifying check list box
+    mxBtnOk->set_sensitive(HasCheckedEntryCount(*mxLbUnits));
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/filtdlg.cxx b/sc/source/ui/dbgui/filtdlg.cxx
new file mode 100644
index 000000000..2af415670
--- /dev/null
+++ b/sc/source/ui/dbgui/filtdlg.cxx
@@ -0,0 +1,1571 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sfx2/dispatch.hxx>
+#include <sal/log.hxx>
+
+#include <uiitems.hxx>
+#include <reffact.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <docsh.hxx>
+#include <scresid.hxx>
+#include <queryentry.hxx>
+
+#include <foptmgr.hxx>
+
+#include <globstr.hrc>
+#include <strings.hrc>
+
+#include <filtdlg.hxx>
+#include <svx/colorwindow.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/weld.hxx>
+#include <svl/numformat.hxx>
+#include <svl/sharedstringpool.hxx>
+
+#include <limits>
+
+#define QUERY_ENTRY_COUNT 4
+#define INVALID_HEADER_POS std::numeric_limits<size_t>::max()
+
+ScFilterDlg::EntryList::EntryList() :
+    mnHeaderPos(INVALID_HEADER_POS) {}
+
+ScFilterDlg::ScFilterDlg(SfxBindings* pB, SfxChildWindow* pCW, weld::Window* pParent,
+    const SfxItemSet& rArgSet)
+    : ScAnyRefDlgController(pB, pCW, pParent,
+        "modules/scalc/ui/standardfilterdialog.ui", "StandardFilterDialog")
+    , aStrUndefined(ScResId(SCSTR_UNDEFINED))
+    , aStrNone(ScResId(SCSTR_NONE))
+    , aStrEmpty(ScResId(SCSTR_FILTER_EMPTY))
+    , aStrNotEmpty(ScResId(SCSTR_FILTER_NOTEMPTY))
+    , aStrColumn(ScResId(SCSTR_COLUMN_LETTER))
+    , aStrTextColor(ScResId(SCSTR_FILTER_TEXT_COLOR_COND))
+    , aStrBackgroundColor(ScResId(SCSTR_FILTER_BACKGROUND_COLOR_COND))
+    , nWhichQuery(rArgSet.GetPool()->GetWhich(SID_QUERY))
+    , theQueryData(static_cast<const ScQueryItem&>(rArgSet.Get(nWhichQuery)).GetQueryData())
+    , pViewData(nullptr)
+    , pDoc(nullptr)
+    , nSrcTab(0)
+    , bRefInputMode(false)
+    , m_xLbConnect1(m_xBuilder->weld_combo_box("connect1"))
+    , m_xLbField1(m_xBuilder->weld_combo_box("field1"))
+    , m_xLbCond1(m_xBuilder->weld_combo_box("cond1"))
+    , m_xEdVal1(m_xBuilder->weld_combo_box("val1"))
+    , m_xLbColor1(m_xBuilder->weld_combo_box("color1"))
+    , m_xBtnRemove1(m_xBuilder->weld_button("remove1"))
+    , m_xLbConnect2(m_xBuilder->weld_combo_box("connect2"))
+    , m_xLbField2(m_xBuilder->weld_combo_box("field2"))
+    , m_xLbCond2(m_xBuilder->weld_combo_box("cond2"))
+    , m_xEdVal2(m_xBuilder->weld_combo_box("val2"))
+    , m_xLbColor2(m_xBuilder->weld_combo_box("color2"))
+    , m_xBtnRemove2(m_xBuilder->weld_button("remove2"))
+    , m_xLbConnect3(m_xBuilder->weld_combo_box("connect3"))
+    , m_xLbField3(m_xBuilder->weld_combo_box("field3"))
+    , m_xLbCond3(m_xBuilder->weld_combo_box("cond3"))
+    , m_xEdVal3(m_xBuilder->weld_combo_box("val3"))
+    , m_xLbColor3(m_xBuilder->weld_combo_box("color3"))
+    , m_xBtnRemove3(m_xBuilder->weld_button("remove3"))
+    , m_xLbConnect4(m_xBuilder->weld_combo_box("connect4"))
+    , m_xLbField4(m_xBuilder->weld_combo_box("field4"))
+    , m_xLbCond4(m_xBuilder->weld_combo_box("cond4"))
+    , m_xEdVal4(m_xBuilder->weld_combo_box("val4"))
+    , m_xLbColor4(m_xBuilder->weld_combo_box("color4"))
+    , m_xBtnRemove4(m_xBuilder->weld_button("remove4"))
+    , m_xContents(m_xBuilder->weld_widget("grid"))
+    , m_xScrollBar(m_xBuilder->weld_scrolled_window("scrollbar", true))
+    , m_xExpander(m_xBuilder->weld_expander("more"))
+    , m_xBtnClear(m_xBuilder->weld_button("clear"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel"))
+    , m_xBtnCase(m_xBuilder->weld_check_button("case"))
+    , m_xBtnRegExp(m_xBuilder->weld_check_button("regexp"))
+    , m_xBtnHeader(m_xBuilder->weld_check_button("header"))
+    , m_xBtnUnique(m_xBuilder->weld_check_button("unique"))
+    , m_xBtnCopyResult(m_xBuilder->weld_check_button("copyresult"))
+    , m_xLbCopyArea(m_xBuilder->weld_combo_box("lbcopyarea"))
+    , m_xEdCopyArea(new formula::RefEdit(m_xBuilder->weld_entry("edcopyarea")))
+    , m_xRbCopyArea(new formula::RefButton(m_xBuilder->weld_button("rbcopyarea")))
+    , m_xBtnDestPers(m_xBuilder->weld_check_button("destpers"))
+    , m_xFtDbAreaLabel(m_xBuilder->weld_label("dbarealabel"))
+    , m_xFtDbArea(m_xBuilder->weld_label("dbarea"))
+{
+    m_xExpander->connect_expanded(LINK(this, ScFilterDlg, MoreExpandedHdl));
+    m_xEdCopyArea->SetReferences(this, m_xFtDbAreaLabel.get());
+    m_xRbCopyArea->SetReferences(this, m_xEdCopyArea.get());
+
+    assert(m_xLbCond1->find_text(aStrTextColor) != -1);
+    assert(m_xLbCond1->find_text(aStrBackgroundColor) != -1);
+
+    Init( rArgSet );
+
+    // Hack: RefInput control
+    pTimer.reset( new Timer("ScFilterTimer") );
+    pTimer->SetTimeout( 50 ); // Wait 50ms
+    pTimer->SetInvokeHandler( LINK( this, ScFilterDlg, TimeOutHdl ) );
+}
+
+ScFilterDlg::~ScFilterDlg()
+{
+    pOptionsMgr.reset();
+    pOutItem.reset();
+
+    // Hack: RefInput control
+    pTimer->Stop();
+    pTimer.reset();
+}
+
+namespace {
+VirtualDevice* lcl_getColorImage(const Color &rColor)
+{
+    const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
+    Size aImageSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
+
+    VclPtrInstance<VirtualDevice> xDevice;
+    xDevice->SetOutputSize(aImageSize);
+    const tools::Rectangle aRect(Point(0, 0), aImageSize);
+    if (rColor == COL_NONE_COLOR)
+    {
+        const Color aW(COL_WHITE);
+        const Color aG(0xef, 0xef, 0xef);
+        xDevice->DrawCheckered(aRect.TopLeft(), aRect.GetSize(), 8, aW, aG);
+        xDevice->SetFillColor();
+    }
+    else
+    {
+        xDevice->SetFillColor(rColor);
+    }
+
+    xDevice->DrawRect(aRect);
+
+    return xDevice.get();
+}
+}
+
+void ScFilterDlg::Init( const SfxItemSet& rArgSet )
+{
+    const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(
+                                    rArgSet.Get( nWhichQuery ));
+
+    m_xBtnClear->connect_clicked   ( LINK( this, ScFilterDlg, BtnClearHdl ) );
+    m_xBtnOk->connect_clicked      ( LINK( this, ScFilterDlg, EndDlgHdl ) );
+    m_xBtnCancel->connect_clicked  ( LINK( this, ScFilterDlg, EndDlgHdl ) );
+    m_xBtnHeader->connect_toggled  ( LINK( this, ScFilterDlg, CheckBoxHdl ) );
+    m_xBtnCase->connect_toggled    ( LINK( this, ScFilterDlg, CheckBoxHdl ) );
+
+    m_xLbField1->connect_changed  ( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbField2->connect_changed  ( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbField3->connect_changed  ( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbField4->connect_changed  ( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbConnect1->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbConnect2->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbConnect3->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbConnect4->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+
+    m_xLbField1->append_text("0000000000");
+    m_xLbField1->set_active(0);
+    auto nPrefWidth = m_xLbField1->get_preferred_size().Width();
+    m_xLbField1->clear();
+
+    m_xLbField1->set_size_request(nPrefWidth, -1);
+    m_xLbField2->set_size_request(nPrefWidth, -1);
+    m_xLbField3->set_size_request(nPrefWidth, -1);
+    m_xLbField4->set_size_request(nPrefWidth, -1);
+
+    m_xLbCond1->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbCond2->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbCond3->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbCond4->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+
+    m_xLbColor1->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbColor2->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbColor3->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+    m_xLbColor4->connect_changed( LINK( this, ScFilterDlg, LbSelectHdl ) );
+
+    m_xBtnRemove1->connect_clicked( LINK( this, ScFilterDlg, BtnRemoveHdl ) );
+    m_xBtnRemove2->connect_clicked( LINK( this, ScFilterDlg, BtnRemoveHdl ) );
+    m_xBtnRemove3->connect_clicked( LINK( this, ScFilterDlg, BtnRemoveHdl ) );
+    m_xBtnRemove4->connect_clicked( LINK( this, ScFilterDlg, BtnRemoveHdl ) );
+
+    pViewData   = rQueryItem.GetViewData();
+    pDoc        = pViewData ? &pViewData->GetDocument() : nullptr;
+    nSrcTab     = pViewData ? pViewData->GetTabNo() : static_cast<SCTAB>(0);
+
+    // for easier access:
+    maFieldLbArr.reserve(QUERY_ENTRY_COUNT);
+    maFieldLbArr.push_back(m_xLbField1.get());
+    maFieldLbArr.push_back(m_xLbField2.get());
+    maFieldLbArr.push_back(m_xLbField3.get());
+    maFieldLbArr.push_back(m_xLbField4.get());
+    maValueEdArr.reserve(QUERY_ENTRY_COUNT);
+    maValueEdArr.push_back(m_xEdVal1.get());
+    maValueEdArr.push_back(m_xEdVal2.get());
+    maValueEdArr.push_back(m_xEdVal3.get());
+    maValueEdArr.push_back(m_xEdVal4.get());
+    maCondLbArr.reserve(QUERY_ENTRY_COUNT);
+    maCondLbArr.push_back(m_xLbCond1.get());
+    maCondLbArr.push_back(m_xLbCond2.get());
+    maCondLbArr.push_back(m_xLbCond3.get());
+    maCondLbArr.push_back(m_xLbCond4.get());
+    maConnLbArr.reserve(QUERY_ENTRY_COUNT);
+    maConnLbArr.push_back(m_xLbConnect1.get());
+    maConnLbArr.push_back(m_xLbConnect2.get());
+    maConnLbArr.push_back(m_xLbConnect3.get());
+    maConnLbArr.push_back(m_xLbConnect4.get());
+    maColorLbArr.reserve(QUERY_ENTRY_COUNT);
+    maColorLbArr.push_back(m_xLbColor1.get());
+    maColorLbArr.push_back(m_xLbColor2.get());
+    maColorLbArr.push_back(m_xLbColor3.get());
+    maColorLbArr.push_back(m_xLbColor4.get());
+    maRemoveBtnArr.reserve(QUERY_ENTRY_COUNT);
+    maRemoveBtnArr.push_back(m_xBtnRemove1.get());
+    maRemoveBtnArr.push_back(m_xBtnRemove2.get());
+    maRemoveBtnArr.push_back(m_xBtnRemove3.get());
+    maRemoveBtnArr.push_back(m_xBtnRemove4.get());
+
+    // Option initialization:
+    pOptionsMgr.reset( new ScFilterOptionsMgr(
+                            pViewData,
+                            theQueryData,
+                            m_xBtnCase.get(),
+                            m_xBtnRegExp.get(),
+                            m_xBtnHeader.get(),
+                            m_xBtnUnique.get(),
+                            m_xBtnCopyResult.get(),
+                            m_xBtnDestPers.get(),
+                            m_xLbCopyArea.get(),
+                            m_xEdCopyArea.get(),
+                            m_xRbCopyArea.get(),
+                            m_xFtDbAreaLabel.get(),
+                            m_xFtDbArea.get(),
+                            aStrUndefined ) );
+    // Read in field lists and select entries
+
+    FillFieldLists();
+
+    for (size_t i = 0; i < QUERY_ENTRY_COUNT; ++i)
+    {
+        OUString aValStr;
+        size_t nCondPos = 0;
+        size_t nFieldSelPos = 0;
+
+        maColorLbArr[i]->set_visible(false);
+
+        ScQueryEntry& rEntry = theQueryData.GetEntry(i);
+        if ( rEntry.bDoQuery )
+        {
+            nCondPos = static_cast<size_t>(rEntry.eOp);
+            nFieldSelPos = GetFieldSelPos( static_cast<SCCOL>(rEntry.nField) );
+            if (rEntry.IsQueryByEmpty())
+            {
+                aValStr = aStrEmpty;
+                maCondLbArr[i]->set_sensitive(false);
+            }
+            else if (rEntry.IsQueryByNonEmpty())
+            {
+                aValStr = aStrNotEmpty;
+                maCondLbArr[i]->set_sensitive(false);
+            }
+            else if (rEntry.IsQueryByTextColor() || rEntry.IsQueryByBackgroundColor())
+            {
+                nCondPos = maCondLbArr[i]->find_text(
+                    rEntry.IsQueryByTextColor() ? aStrTextColor : aStrBackgroundColor);
+                maValueEdArr[i]->set_visible(false);
+                maColorLbArr[i]->set_visible(true);
+                maColorLbArr[i]->set_sensitive(true);
+            }
+            else
+            {
+                const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
+                OUString aQueryStr = rItem.maString.getString();
+                SetValString(aQueryStr, rItem, aValStr);
+            }
+        }
+        else if ( i == 0 )
+        {
+            nFieldSelPos = pViewData ? GetFieldSelPos(pViewData->GetCurX()) : 0;
+            rEntry.nField = nFieldSelPos ? (theQueryData.nCol1 +
+                static_cast<SCCOL>(nFieldSelPos) - 1) : static_cast<SCCOL>(0);
+            rEntry.bDoQuery=true;
+            if (maRefreshExceptQuery.size() < i + 1)
+                maRefreshExceptQuery.resize(i + 1, false);
+            maRefreshExceptQuery[i] = true;
+
+        }
+        maFieldLbArr[i]->set_active( nFieldSelPos );
+        maCondLbArr [i]->set_active( nCondPos );
+        maValueEdArr[i]->set_entry_text( aValStr );
+        maValueEdArr[i]->set_entry_completion(false);
+        maValueEdArr[i]->connect_changed( LINK( this, ScFilterDlg, ValModifyHdl ) );
+        UpdateValueList(i+1);
+        UpdateColorList(i+1);
+    }
+
+    m_xScrollBar->connect_vadjustment_changed( LINK( this, ScFilterDlg, ScrollHdl ) );
+    m_xScrollBar->vadjustment_configure(0, 0, 8, 1, 3, 4);
+    Size aSize(m_xContents->get_preferred_size());
+    m_xContents->set_size_request(aSize.Width(), aSize.Height());
+
+    m_xLbConnect1->hide();
+    // Disable/Enable Logic:
+
+    (m_xLbField1->get_active() != 0)
+    && (m_xLbField2->get_active() != 0)
+        ? m_xLbConnect2->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(1).eConnect) )
+        : m_xLbConnect2->set_active(-1);
+
+    (m_xLbField2->get_active() != 0)
+    && (m_xLbField3->get_active() != 0)
+        ? m_xLbConnect3->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(2).eConnect) )
+        : m_xLbConnect3->set_active(-1);
+
+    (m_xLbField3->get_active() != 0)
+    && (m_xLbField4->get_active() != 0)
+        ? m_xLbConnect4->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(3).eConnect) )
+        : m_xLbConnect4->set_active(-1);
+    if ( m_xLbField1->get_active() == 0 )
+    {
+        m_xLbConnect2->set_sensitive(false);
+        m_xLbField2->set_sensitive(false);
+        m_xLbCond2->set_sensitive(false);
+        m_xEdVal2->set_sensitive(false);
+        m_xLbColor2->set_sensitive(false);
+        m_xBtnRemove2->set_sensitive(false);
+    }
+    else if ( m_xLbConnect2->get_active() == -1 )
+    {
+        m_xLbField2->set_sensitive(false);
+        m_xLbCond2->set_sensitive(false);
+        m_xEdVal2->set_sensitive(false);
+        m_xLbColor2->set_sensitive(false);
+        m_xBtnRemove2->set_sensitive(false);
+    }
+
+    if ( m_xLbField2->get_active() == 0 )
+    {
+        m_xLbConnect3->set_sensitive(false);
+        m_xLbField3->set_sensitive(false);
+        m_xLbCond3->set_sensitive(false);
+        m_xEdVal3->set_sensitive(false);
+        m_xLbColor3->set_sensitive(false);
+        m_xBtnRemove3->set_sensitive(false);
+    }
+    else if ( m_xLbConnect3->get_active() == -1 )
+    {
+        m_xLbField3->set_sensitive(false);
+        m_xLbCond3->set_sensitive(false);
+        m_xEdVal3->set_sensitive(false);
+        m_xLbColor3->set_sensitive(false);
+        m_xBtnRemove3->set_sensitive(false);
+    }
+    if ( m_xLbField3->get_active() == 0 )
+    {
+        m_xLbConnect4->set_sensitive(false);
+        m_xLbField4->set_sensitive(false);
+        m_xLbCond4->set_sensitive(false);
+        m_xEdVal4->set_sensitive(false);
+        m_xLbColor4->set_sensitive(false);
+        m_xBtnRemove4->set_sensitive(false);
+    }
+    else if ( m_xLbConnect4->get_active() == -1 )
+    {
+        m_xLbField4->set_sensitive(false);
+        m_xLbCond4->set_sensitive(false);
+        m_xEdVal4->set_sensitive(false);
+        m_xLbColor4->set_sensitive(false);
+        m_xBtnRemove4->set_sensitive(false);
+    }
+
+    m_xEdVal1->set_entry_width_chars(10);
+    m_xEdVal2->set_entry_width_chars(10);
+    m_xEdVal3->set_entry_width_chars(10);
+    m_xEdVal4->set_entry_width_chars(10);
+
+    if (pDoc != nullptr && pDoc->GetChangeTrack() != nullptr)
+        m_xBtnCopyResult->set_sensitive(false);
+}
+
+void ScFilterDlg::Close()
+{
+    if (pViewData)
+        pViewData->GetDocShell()->CancelAutoDBRange();
+
+    DoClose( ScFilterDlgWrapper::GetChildWindowId() );
+}
+
+// Mouse-selected cell area becomes the new selection and is shown in the
+// reference text box
+
+void ScFilterDlg::SetReference( const ScRange& rRef, ScDocument& rDocP )
+{
+    if ( bRefInputMode )    // Only possible if in reference edit mode
+    {
+        if ( rRef.aStart != rRef.aEnd )
+            RefInputStart( m_xEdCopyArea.get() );
+        OUString aRefStr(rRef.aStart.Format(ScRefFlags::ADDR_ABS_3D, &rDocP, rDocP.GetAddressConvention()));
+        m_xEdCopyArea->SetRefString( aRefStr );
+    }
+}
+
+void ScFilterDlg::SetActive()
+{
+    if ( bRefInputMode )
+    {
+        m_xEdCopyArea->GrabFocus();
+        m_xEdCopyArea->GetModifyHdl().Call( *m_xEdCopyArea );
+    }
+    else
+        m_xDialog->grab_focus();
+
+    RefInputDone();
+}
+
+void ScFilterDlg::FillFieldLists()
+{
+    m_xLbField1->freeze();
+    m_xLbField2->freeze();
+    m_xLbField3->freeze();
+    m_xLbField4->freeze();
+
+    m_xLbField1->clear();
+    m_xLbField2->clear();
+    m_xLbField3->clear();
+    m_xLbField4->clear();
+    m_xLbField1->append_text( aStrNone );
+    m_xLbField2->append_text( aStrNone );
+    m_xLbField3->append_text( aStrNone );
+    m_xLbField4->append_text( aStrNone );
+
+    if ( pDoc )
+    {
+        OUString aFieldName;
+        SCTAB   nTab        = nSrcTab;
+        SCCOL   nFirstCol   = theQueryData.nCol1;
+        SCROW   nFirstRow   = theQueryData.nRow1;
+        SCCOL   nMaxCol     = theQueryData.nCol2;
+        SCCOL   col = 0;
+
+        for ( col=nFirstCol; col<=nMaxCol; col++ )
+        {
+            aFieldName = pDoc->GetString(col, nFirstRow, nTab);
+            if (!m_xBtnHeader->get_active() || aFieldName.isEmpty())
+            {
+                aFieldName = ScGlobal::ReplaceOrAppend( aStrColumn, u"%1", ScColToAlpha( col ));
+            }
+            m_xLbField1->append_text( aFieldName );
+            m_xLbField2->append_text( aFieldName );
+            m_xLbField3->append_text( aFieldName );
+            m_xLbField4->append_text( aFieldName );
+        }
+    }
+
+    m_xLbField4->thaw();
+    m_xLbField3->thaw();
+    m_xLbField2->thaw();
+    m_xLbField1->thaw();
+}
+
+void ScFilterDlg::UpdateValueList( size_t nList )
+{
+    bool bCaseSens = m_xBtnCase->get_active();
+
+    if (pDoc && nList > 0 && nList <= QUERY_ENTRY_COUNT)
+    {
+        weld::ComboBox* pValList = maValueEdArr[nList-1];
+        const sal_Int32 nFieldSelPos = maFieldLbArr[nList-1]->get_active();
+        OUString aCurValue = pValList->get_active_text();
+
+        std::unique_ptr<weld::WaitObject> xWaiter;
+        std::vector<weld::ComboBoxEntry> aEntries;
+        aEntries.emplace_back(aStrNotEmpty);
+        aEntries.emplace_back(aStrEmpty);
+
+        if (nFieldSelPos)
+        {
+            xWaiter.reset(new weld::WaitObject(m_xDialog.get()));     // even if only the list box has content
+            SCCOL nColumn = theQueryData.nCol1 + static_cast<SCCOL>(nFieldSelPos) - 1;
+            EntryList* pList = nullptr;
+            if (!m_EntryLists.count(nColumn))
+            {
+                size_t nOffset = GetSliderPos();
+                SCTAB nTab       = nSrcTab;
+                SCROW nFirstRow = theQueryData.nRow1;
+                SCROW nLastRow   = theQueryData.nRow2;
+                if (maHasDates.size() < nOffset+nList)
+                    maHasDates.resize(nOffset+nList, false);
+                maHasDates[nOffset+nList-1] = false;
+
+                // first without the first line
+                std::pair<EntryListsMap::iterator, bool> r =
+                    m_EntryLists.insert(std::make_pair(nColumn, std::make_unique<EntryList>()));
+                if (!r.second)
+                    // insertion failed.
+                    return;
+
+                pList = r.first->second.get();
+                pDoc->GetFilterEntriesArea(
+                    nColumn, nFirstRow+1, nLastRow,
+                    nTab, bCaseSens, pList->maFilterEntries);
+                maHasDates[nOffset+nList-1] = pList->maFilterEntries.mbHasDates;
+
+                // Entry for the first line
+                //! Entry (pHdrEntry) doesn't generate collection?
+
+                pList->mnHeaderPos = INVALID_HEADER_POS;
+                ScFilterEntries aHdrColl;
+                pDoc->GetFilterEntriesArea(
+                    nColumn, nFirstRow, nFirstRow, nTab, true, aHdrColl );
+                if (!aHdrColl.empty())
+                {
+                    // See if the header value is already in the list.
+                    std::vector<ScTypedStrData>::iterator itBeg = pList->maFilterEntries.begin(), itEnd = pList->maFilterEntries.end();
+                    if (std::none_of(itBeg, itEnd, FindTypedStrData(aHdrColl.front(), bCaseSens)))
+                    {
+                        // Not in the list. Insert it.
+                        pList->maFilterEntries.push_back(aHdrColl.front());
+                        if (bCaseSens)
+                            std::sort(pList->maFilterEntries.begin(), pList->maFilterEntries.end(), ScTypedStrData::LessCaseSensitive());
+                        else
+                            std::sort(pList->maFilterEntries.begin(), pList->maFilterEntries.end(), ScTypedStrData::LessCaseInsensitive());
+
+                        // Record its position.
+                        itBeg = pList->maFilterEntries.begin();
+                        itEnd = pList->maFilterEntries.end();
+                        auto it = std::find_if(itBeg, itEnd, FindTypedStrData(aHdrColl.front(), bCaseSens));
+                        pList->mnHeaderPos = std::distance(itBeg, it);
+                    }
+                }
+            }
+            else
+                pList = m_EntryLists[nColumn].get();
+
+            assert(pList);
+
+            for (const auto& rEntry : pList->maFilterEntries)
+                aEntries.emplace_back(rEntry.GetString());
+        }
+        pValList->insert_vector(aEntries, false);
+        pValList->set_entry_text(aCurValue);
+    }
+
+    UpdateHdrInValueList( nList );
+}
+
+void ScFilterDlg::UpdateHdrInValueList( size_t nList )
+{
+    //! GetText / SetText ??
+
+    if (!pDoc)
+        return;
+
+    if (nList == 0 || nList > QUERY_ENTRY_COUNT)
+        return;
+
+    size_t nFieldSelPos = maFieldLbArr[nList-1]->get_active();
+    if (!nFieldSelPos)
+        return;
+
+    SCCOL nColumn = theQueryData.nCol1 + static_cast<SCCOL>(nFieldSelPos) - 1;
+    if (!m_EntryLists.count(nColumn))
+    {
+        OSL_FAIL("column not yet initialized");
+        return;
+    }
+
+    size_t const nPos = m_EntryLists[nColumn]->mnHeaderPos;
+    if (nPos == INVALID_HEADER_POS)
+        return;
+
+    weld::ComboBox* pValList = maValueEdArr[nList-1];
+    int nListPos = nPos + 2;                 // for "empty" and "non-empty"
+
+    const ScTypedStrData& rHdrEntry = m_EntryLists[nColumn]->maFilterEntries.maStrData[nPos];
+
+    const OUString& aHdrStr = rHdrEntry.GetString();
+    bool bWasThere = nListPos < pValList->get_count() && aHdrStr == pValList->get_text(nListPos);
+    bool bInclude = !m_xBtnHeader->get_active();
+
+    if (bInclude)           // Include entry
+    {
+        if (!bWasThere)
+            pValList->insert_text(nListPos, aHdrStr);
+    }
+    else                    // Omit entry
+    {
+        if (bWasThere)
+            pValList->remove(nListPos);
+    }
+}
+
+void ScFilterDlg::ClearValueList( size_t nList )
+{
+    if (nList > 0 && nList <= QUERY_ENTRY_COUNT)
+    {
+        weld::ComboBox* pValList = maValueEdArr[nList-1];
+        pValList->clear();
+        pValList->append_text( aStrNotEmpty );
+        pValList->append_text( aStrEmpty );
+        pValList->set_entry_text( OUString() );
+    }
+}
+
+void ScFilterDlg::UpdateColorList(size_t nList)
+{
+    if (!pDoc || nList <= 0 || nList > QUERY_ENTRY_COUNT)
+        return;
+
+    size_t nPos = nList - 1;
+    ScQueryEntry& rEntry = theQueryData.GetEntry(nPos);
+    const sal_Int32 nFieldSelPos = maFieldLbArr[nPos]->get_active();
+    if (!nFieldSelPos)
+        return;
+
+    SCCOL nColumn = theQueryData.nCol1 + static_cast<SCCOL>(nFieldSelPos) - 1;
+    EntryList* pList = m_EntryLists[nColumn].get();
+    if (!pList)
+        return;
+
+    std::set<Color> aColors;
+    OUString sSelectedCondition = maCondLbArr[nPos]->get_active_text();
+    if (sSelectedCondition == aStrTextColor)
+        aColors = pList->maFilterEntries.getTextColors();
+    else if (sSelectedCondition == aStrBackgroundColor)
+        aColors = pList->maFilterEntries.getBackgroundColors();
+    else
+        return;
+
+    maColorLbArr[nPos]->clear();
+    for (const auto& rColor : aColors)
+    {
+        OUString sId = rColor.AsRGBHexString();
+        if (rColor == COL_AUTO)
+        {
+            OUString sText = sSelectedCondition == aStrTextColor
+                                 ? ScResId(SCSTR_FILTER_AUTOMATIC_COLOR)
+                                 : ScResId(SCSTR_FILTER_NO_FILL);
+            maColorLbArr[nPos]->append(sId, sText);
+        }
+        else
+        {
+            VirtualDevice* pDev = lcl_getColorImage(rColor);
+            maColorLbArr[nPos]->append(sId, OUString(), *pDev);
+        }
+
+        auto aItem = rEntry.GetQueryItem();
+        if (aItem.maColor == rColor
+            && ((sSelectedCondition == aStrTextColor && aItem.meType == ScQueryEntry::ByTextColor)
+                || (sSelectedCondition == aStrBackgroundColor
+                    && aItem.meType == ScQueryEntry::ByBackgroundColor)))
+        {
+            maColorLbArr[nPos]->set_active_id(sId);
+        }
+    }
+}
+
+size_t ScFilterDlg::GetFieldSelPos( SCCOL nField )
+{
+    if ( nField >= theQueryData.nCol1 && nField <= theQueryData.nCol2 )
+        return static_cast<size_t>(nField - theQueryData.nCol1 + 1);
+    else
+        return 0;
+}
+
+ScQueryItem* ScFilterDlg::GetOutputItem()
+{
+    ScAddress       theCopyPos;
+    ScQueryParam    theParam( theQueryData );
+    bool            bCopyPosOk = false;
+
+    if ( m_xBtnCopyResult->get_active() )
+    {
+        ScRefFlags nResult = theCopyPos.Parse(
+            m_xEdCopyArea->GetText(), *pDoc, pDoc->GetAddressConvention());
+        bCopyPosOk = (nResult & ScRefFlags::VALID) == ScRefFlags::VALID;
+    }
+
+    if ( m_xBtnCopyResult->get_active() && bCopyPosOk )
+    {
+        theParam.bInplace   = false;
+        theParam.nDestTab   = theCopyPos.Tab();
+        theParam.nDestCol   = theCopyPos.Col();
+        theParam.nDestRow   = theCopyPos.Row();
+    }
+    else
+    {
+        theParam.bInplace   = true;
+        theParam.nDestTab   = 0;
+        theParam.nDestCol   = 0;
+        theParam.nDestRow   = 0;
+    }
+
+    theParam.bHasHeader     = m_xBtnHeader->get_active();
+    theParam.bByRow         = true;
+    theParam.bDuplicate     = !m_xBtnUnique->get_active();
+    theParam.bCaseSens      = m_xBtnCase->get_active();
+    theParam.eSearchType    = m_xBtnRegExp->get_active() ? utl::SearchParam::SearchType::Regexp : utl::SearchParam::SearchType::Normal;
+    theParam.bDestPers      = m_xBtnDestPers->get_active();
+
+    // only set the three - reset everything else
+
+    pOutItem.reset( new ScQueryItem( nWhichQuery, &theParam ) );
+
+    return pOutItem.get();
+}
+
+bool ScFilterDlg::IsRefInputMode() const
+{
+    return bRefInputMode;
+}
+
+// Handler:
+
+IMPL_LINK( ScFilterDlg, BtnClearHdl, weld::Button&, rBtn, void )
+{
+    if ( &rBtn != m_xBtnClear.get() )
+        return;
+
+    // scroll to the top
+    m_xScrollBar->vadjustment_set_value(0);
+    size_t nOffset = 0;
+    RefreshEditRow( nOffset);
+
+    // clear all conditions
+    m_xLbConnect1->set_active(-1);
+    m_xLbConnect2->set_active(-1);
+    m_xLbConnect3->set_active(-1);
+    m_xLbConnect4->set_active(-1);
+    m_xLbField1->set_active(0);
+    m_xLbField2->set_active(0);
+    m_xLbField3->set_active(0);
+    m_xLbField4->set_active(0);
+    m_xLbCond1->set_active(0);
+    m_xLbCond2->set_active(0);
+    m_xLbCond3->set_active(0);
+    m_xLbCond4->set_active(0);
+    ClearValueList( 1 );
+    ClearValueList( 2 );
+    ClearValueList( 3 );
+    ClearValueList( 4 );
+
+    // disable fields for second row onward
+    m_xLbConnect2->set_sensitive(false);
+    m_xLbConnect3->set_sensitive(false);
+    m_xLbConnect4->set_sensitive(false);
+    m_xLbField2->set_sensitive(false);
+    m_xLbField3->set_sensitive(false);
+    m_xLbField4->set_sensitive(false);
+    m_xLbCond2->set_sensitive(false);
+    m_xLbCond3->set_sensitive(false);
+    m_xLbCond4->set_sensitive(false);
+    m_xEdVal2->set_sensitive(false);
+    m_xEdVal3->set_sensitive(false);
+    m_xEdVal4->set_sensitive(false);
+    m_xLbColor2->set_sensitive(false);
+    m_xLbColor3->set_sensitive(false);
+    m_xLbColor4->set_sensitive(false);
+    m_xBtnRemove2->set_sensitive(false);
+    m_xBtnRemove3->set_sensitive(false);
+    m_xBtnRemove4->set_sensitive(false);
+
+    // clear query data objects
+    SCSIZE nCount = theQueryData.GetEntryCount();
+    if (maRefreshExceptQuery.size() < nCount + 1)
+        maRefreshExceptQuery.resize(nCount + 1, false);
+    for (SCSIZE i = 0; i < nCount; ++i)
+    {
+        theQueryData.GetEntry(i).bDoQuery = false;
+        maRefreshExceptQuery[i] = false;
+        theQueryData.GetEntry(i).nField = static_cast<SCCOL>(0);
+    }
+    maRefreshExceptQuery[0] = true;
+}
+
+IMPL_LINK( ScFilterDlg, EndDlgHdl, weld::Button&, rBtn, void )
+{
+    if ( &rBtn == m_xBtnOk.get() )
+    {
+        bool bAreaInputOk = true;
+
+        if ( m_xBtnCopyResult->get_active() )
+        {
+            if ( !pOptionsMgr->VerifyPosStr( m_xEdCopyArea->GetText() ) )
+            {
+                if (!m_xExpander->get_expanded())
+                  m_xExpander->set_expanded(true);
+
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                          VclMessageType::Warning, VclButtonsType::Ok,
+                                                          ScResId(STR_INVALID_TABREF)));
+                xBox->run();
+                m_xEdCopyArea->GrabFocus();
+                bAreaInputOk = false;
+            }
+        }
+
+        if ( bAreaInputOk )
+        {
+            SetDispatcherLock( false );
+            SwitchToDocument();
+            GetBindings().GetDispatcher()->ExecuteList(FID_FILTER_OK,
+                                      SfxCallMode::SLOT | SfxCallMode::RECORD,
+                                      { GetOutputItem() });
+            response(RET_OK);
+        }
+    }
+    else if ( &rBtn == m_xBtnCancel.get() )
+    {
+        response(RET_CANCEL);
+    }
+}
+
+IMPL_LINK_NOARG(ScFilterDlg, MoreExpandedHdl, weld::Expander&, void)
+{
+    if ( m_xExpander->get_expanded() )
+        pTimer->Start();
+    else
+    {
+        pTimer->Stop();
+        bRefInputMode = false;
+        //@BugID 54702 Enable/disable only in Basic class
+        //SFX_APPWINDOW->Disable(FALSE);        //! general method in ScAnyRefDlg
+    }
+}
+
+IMPL_LINK( ScFilterDlg, TimeOutHdl, Timer*, _pTimer, void )
+{
+    // Check if RefInputMode is still true every 50ms
+    if (_pTimer == pTimer.get() && m_xDialog->has_toplevel_focus())
+        bRefInputMode = (m_xEdCopyArea->GetWidget()->has_focus() || m_xRbCopyArea->GetWidget()->has_focus());
+
+    if ( m_xExpander->get_expanded() )
+        pTimer->Start();
+}
+
+IMPL_LINK(ScFilterDlg, LbSelectHdl, weld::ComboBox&, rLb, void)
+{
+    /*
+     * Handle enable/disable logic depending on which ListBox was selected
+     */
+    sal_uInt16 nOffset = GetSliderPos();
+
+    if ( &rLb == m_xLbConnect1.get() )
+    {
+        m_xLbField1->set_sensitive(true);
+        m_xLbCond1->set_sensitive(true);
+        m_xEdVal1->set_sensitive(true);
+        m_xBtnRemove1->set_sensitive(true);
+
+        const sal_Int32 nConnect1 = m_xLbConnect1->get_active();
+        size_t nQE = nOffset;
+        theQueryData.GetEntry(nQE).eConnect =static_cast<ScQueryConnect>(nConnect1);
+        if (maRefreshExceptQuery.size() < nQE + 1)
+            maRefreshExceptQuery.resize(nQE + 1, false);
+        maRefreshExceptQuery[nQE] = true;
+    }
+    else if ( &rLb == m_xLbConnect2.get() )
+    {
+        m_xLbField2->set_sensitive(true);
+        m_xLbCond2->set_sensitive(true);
+        m_xEdVal2->set_sensitive(true);
+        m_xBtnRemove2->set_sensitive(true);
+
+        const sal_Int32 nConnect2 = m_xLbConnect2->get_active();
+        size_t nQE = 1+nOffset;
+        theQueryData.GetEntry(nQE).eConnect =static_cast<ScQueryConnect>(nConnect2);
+        if (maRefreshExceptQuery.size() < nQE + 1)
+            maRefreshExceptQuery.resize(nQE + 1, false);
+        maRefreshExceptQuery[nQE]=true;
+    }
+    else if ( &rLb == m_xLbConnect3.get() )
+    {
+        m_xLbField3->set_sensitive(true);
+        m_xLbCond3->set_sensitive(true);
+        m_xEdVal3->set_sensitive(true);
+        m_xBtnRemove3->set_sensitive(true);
+
+        const sal_Int32 nConnect3 = m_xLbConnect3->get_active();
+        size_t nQE = 2 + nOffset;
+        theQueryData.GetEntry(nQE).eConnect = static_cast<ScQueryConnect>(nConnect3);
+        if (maRefreshExceptQuery.size() < nQE + 1)
+            maRefreshExceptQuery.resize(nQE + 1, false);
+        maRefreshExceptQuery[nQE] = true;
+
+    }
+    else if ( &rLb == m_xLbConnect4.get() )
+    {
+        m_xLbField4->set_sensitive(true);
+        m_xLbCond4->set_sensitive(true);
+        m_xEdVal4->set_sensitive(true);
+        m_xLbColor4->set_sensitive(true);
+        m_xBtnRemove4->set_sensitive(true);
+
+        const sal_Int32 nConnect4 = m_xLbConnect4->get_active();
+        size_t nQE = 3 + nOffset;
+        theQueryData.GetEntry(nQE).eConnect = static_cast<ScQueryConnect>(nConnect4);
+        if (maRefreshExceptQuery.size() < nQE + 1)
+            maRefreshExceptQuery.resize(nQE + 1, false);
+        maRefreshExceptQuery[nQE] = true;
+    }
+    else if ( &rLb == m_xLbField1.get() )
+    {
+        if ( m_xLbField1->get_active() == 0 )
+        {
+            m_xLbConnect2->set_active(-1);
+            m_xLbConnect3->set_active(-1);
+            m_xLbConnect4->set_active(-1);
+            m_xLbField2->set_active( 0 );
+            m_xLbField3->set_active( 0 );
+            m_xLbField4->set_active( 0 );
+            m_xLbCond2->set_active( 0 );
+            m_xLbCond3->set_active( 0 );
+            m_xLbCond4->set_active( 0 );
+            ClearValueList( 1 );
+            ClearValueList( 2 );
+            ClearValueList( 3 );
+            ClearValueList( 4 );
+
+            m_xLbConnect2->set_sensitive(false);
+            m_xLbConnect3->set_sensitive(false);
+            m_xLbConnect4->set_sensitive(false);
+            m_xLbField2->set_sensitive(false);
+            m_xLbField3->set_sensitive(false);
+            m_xLbField4->set_sensitive(false);
+            m_xLbCond2->set_sensitive(false);
+            m_xLbCond3->set_sensitive(false);
+            m_xLbCond4->set_sensitive(false);
+            m_xEdVal2->set_sensitive(false);
+            m_xEdVal3->set_sensitive(false);
+            m_xEdVal4->set_sensitive(false);
+            m_xLbColor2->set_sensitive(false);
+            m_xLbColor3->set_sensitive(false);
+            m_xLbColor4->set_sensitive(false);
+            m_xBtnRemove2->set_sensitive(false);
+            m_xBtnRemove3->set_sensitive(false);
+            m_xBtnRemove4->set_sensitive(false);
+            SCSIZE nCount = theQueryData.GetEntryCount();
+            if (maRefreshExceptQuery.size() < nCount + 1)
+                maRefreshExceptQuery.resize(nCount + 1, false);
+            for (SCSIZE i = nOffset; i < nCount; ++i)
+            {
+                theQueryData.GetEntry(i).bDoQuery = false;
+                maRefreshExceptQuery[i] = false;
+                theQueryData.GetEntry(i).nField =  static_cast<SCCOL>(0);
+            }
+            maRefreshExceptQuery[nOffset] = true;
+        }
+        else
+        {
+            UpdateValueList( 1 );
+            UpdateColorList( 1 );
+            if ( !m_xLbConnect2->get_sensitive() )
+            {
+                m_xLbConnect2->set_sensitive(true);
+            }
+            theQueryData.GetEntry(nOffset).bDoQuery = true;
+            const sal_Int32 nField  = rLb.get_active();
+            theQueryData.GetEntry(nOffset).nField = theQueryData.nCol1 + static_cast<SCCOL>(nField) - 1 ;
+        }
+    }
+    else if ( &rLb == m_xLbField2.get() )
+    {
+        if ( m_xLbField2->get_active() == 0 )
+        {
+            m_xLbConnect3->set_active(-1);
+            m_xLbConnect4->set_active(-1);
+            m_xLbField3->set_active( 0 );
+            m_xLbField4->set_active( 0 );
+            m_xLbCond3->set_active( 0 );
+            m_xLbCond4->set_active( 0 );
+            ClearValueList( 2 );
+            ClearValueList( 3 );
+            ClearValueList( 4 );
+
+            m_xLbConnect3->set_sensitive(false);
+            m_xLbConnect4->set_sensitive(false);
+            m_xLbField3->set_sensitive(false);
+            m_xLbField4->set_sensitive(false);
+            m_xLbCond3->set_sensitive(false);
+            m_xLbCond4->set_sensitive(false);
+            m_xEdVal3->set_sensitive(false);
+            m_xEdVal4->set_sensitive(false);
+            m_xLbColor3->set_sensitive(false);
+            m_xLbColor4->set_sensitive(false);
+            m_xBtnRemove3->set_sensitive(false);
+            m_xBtnRemove4->set_sensitive(false);
+
+            sal_uInt16 nTemp=nOffset+1;
+            SCSIZE nCount = theQueryData.GetEntryCount();
+            if (maRefreshExceptQuery.size() < nCount)
+                maRefreshExceptQuery.resize(nCount, false);
+            for (SCSIZE i= nTemp; i< nCount; i++)
+            {
+                theQueryData.GetEntry(i).bDoQuery = false;
+                maRefreshExceptQuery[i] = false;
+                theQueryData.GetEntry(i).nField =  static_cast<SCCOL>(0);
+            }
+            maRefreshExceptQuery[nTemp] = true;
+        }
+        else
+        {
+            UpdateValueList( 2 );
+            UpdateColorList( 2 );
+            if ( !m_xLbConnect3->get_sensitive() )
+            {
+                m_xLbConnect3->set_sensitive(true);
+            }
+            const sal_Int32 nField = rLb.get_active();
+            sal_uInt16 nQ=1+nOffset;
+            theQueryData.GetEntry(nQ).bDoQuery = true;
+            theQueryData.GetEntry(nQ).nField = theQueryData.nCol1 + static_cast<SCCOL>(nField) - 1 ;
+        }
+    }
+    else if ( &rLb == m_xLbField3.get() )
+    {
+        if ( m_xLbField3->get_active() == 0 )
+        {
+            m_xLbConnect4->set_active(-1);
+            m_xLbField4->set_active( 0 );
+            m_xLbCond4->set_active( 0 );
+            ClearValueList( 3 );
+            ClearValueList( 4 );
+
+            m_xLbConnect4->set_sensitive(false);
+            m_xLbField4->set_sensitive(false);
+            m_xLbCond4->set_sensitive(false);
+            m_xEdVal4->set_sensitive(false);
+            m_xLbColor4->set_sensitive(false);
+            m_xBtnRemove4->set_sensitive(false);
+
+            sal_uInt16 nTemp=nOffset+2;
+            SCSIZE nCount = theQueryData.GetEntryCount();
+            if (maRefreshExceptQuery.size() < nCount)
+                maRefreshExceptQuery.resize(nCount, false);
+            for (SCSIZE i = nTemp; i < nCount; ++i)
+            {
+                theQueryData.GetEntry(i).bDoQuery = false;
+                maRefreshExceptQuery[i] = false;
+                theQueryData.GetEntry(i).nField =  static_cast<SCCOL>(0);
+            }
+            maRefreshExceptQuery[nTemp] = true;
+        }
+        else
+        {
+            UpdateValueList( 3 );
+            UpdateColorList( 3 );
+            if ( !m_xLbConnect4->get_sensitive() )
+            {
+                m_xLbConnect4->set_sensitive(true);
+            }
+
+            const sal_Int32 nField = rLb.get_active();
+            sal_uInt16 nQ=2+nOffset;
+            theQueryData.GetEntry(nQ).bDoQuery = true;
+            theQueryData.GetEntry(nQ).nField = theQueryData.nCol1 + static_cast<SCCOL>(nField) - 1 ;
+
+        }
+    }
+    else if ( &rLb == m_xLbField4.get() )
+    {
+        if ( m_xLbField4->get_active() == 0 )
+        {
+            ClearValueList( 4 );
+            sal_uInt16 nTemp=nOffset+3;
+            SCSIZE nCount = theQueryData.GetEntryCount();
+            if (maRefreshExceptQuery.size() < nCount)
+                maRefreshExceptQuery.resize(nCount, false);
+            for (SCSIZE i = nTemp; i < nCount; ++i)
+            {
+                theQueryData.GetEntry(i).bDoQuery = false;
+                maRefreshExceptQuery[i] = false;
+                theQueryData.GetEntry(i).nField =  static_cast<SCCOL>(0);
+            }
+            maRefreshExceptQuery[nTemp] = true;
+        }
+        else
+        {
+            UpdateValueList( 4 );
+            UpdateColorList( 4 );
+            const sal_Int32 nField = rLb.get_active();
+            sal_uInt16 nQ=3+nOffset;
+            theQueryData.GetEntry(nQ).bDoQuery = true;
+            theQueryData.GetEntry(nQ).nField = theQueryData.nCol1 + static_cast<SCCOL>(nField) - 1 ;
+        }
+
+    }
+    else if (&rLb == m_xLbCond1.get() || &rLb == m_xLbCond2.get() || &rLb == m_xLbCond3.get()
+             || &rLb == m_xLbCond4.get())
+    {
+        ScQueryOp op;
+        sal_uInt16 nQ = 0;
+        bool bEnableColorLb = false;
+        if (rLb.get_active_text() == aStrTextColor || rLb.get_active_text() == aStrBackgroundColor)
+        {
+            bEnableColorLb = true;
+            op = SC_EQUAL;
+        }
+        else
+        {
+            op = static_cast<ScQueryOp>(rLb.get_active());
+        }
+
+        if (&rLb == m_xLbCond1.get())
+        {
+            nQ = nOffset;
+            m_xLbColor1->set_visible(bEnableColorLb);
+            m_xLbColor1->set_sensitive(bEnableColorLb);
+            m_xEdVal1->set_visible(!bEnableColorLb);
+            UpdateColorList(1);
+        }
+        else if (&rLb == m_xLbCond2.get())
+        {
+            nQ = 1 + nOffset;
+            m_xLbColor2->set_visible(bEnableColorLb);
+            m_xLbColor2->set_sensitive(bEnableColorLb);
+            m_xEdVal2->set_visible(!bEnableColorLb);
+            UpdateColorList(2);
+        }
+        else if (&rLb == m_xLbCond3.get())
+        {
+            nQ = 2 + nOffset;
+            m_xLbColor3->set_visible(bEnableColorLb);
+            m_xLbColor3->set_sensitive(bEnableColorLb);
+            m_xEdVal3->set_visible(!bEnableColorLb);
+            UpdateColorList(3);
+        }
+        else if (&rLb == m_xLbCond4.get())
+        {
+            nQ = 3 + nOffset;
+            m_xLbColor4->set_visible(bEnableColorLb);
+            m_xLbColor4->set_sensitive(bEnableColorLb);
+            m_xEdVal4->set_visible(!bEnableColorLb);
+            UpdateColorList(4);
+        }
+
+        auto aEntry = theQueryData.GetEntry(nQ);
+        aEntry.eOp = op;
+    }
+    else if (&rLb == m_xLbColor1.get() || &rLb == m_xLbColor2.get() || &rLb == m_xLbColor3.get()
+             || &rLb == m_xLbColor4.get())
+    {
+        sal_uInt16 nQ = 0;
+        if (&rLb == m_xLbColor1.get())
+        {
+            nQ = nOffset;
+        }
+        else if (&rLb == m_xLbColor2.get())
+        {
+            nQ = 1 + nOffset;
+        }
+        else if (&rLb == m_xLbColor3.get())
+        {
+            nQ = 2 + nOffset;
+        }
+        else if (&rLb == m_xLbColor4.get())
+        {
+            nQ = 3 + nOffset;
+        }
+
+        ScQueryEntry& aEntry = theQueryData.GetEntry(nQ);
+        Color aColor = Color::STRtoRGB(maColorLbArr[nQ]->get_active_id());
+        if (maCondLbArr[nQ]->get_active_text() == aStrTextColor)
+        {
+            aEntry.SetQueryByTextColor(aColor);
+        }
+        else if (maCondLbArr[nQ]->get_active_text() == aStrBackgroundColor)
+        {
+            aEntry.SetQueryByBackgroundColor(aColor);
+        }
+    }
+}
+
+IMPL_LINK( ScFilterDlg, CheckBoxHdl, weld::Toggleable&, rBox, void )
+{
+    //  Column headers:
+    //      Field list: Columnxx <-> column header string
+    //      Value list: Column header value not applicable.
+    //  Upper/lower case:
+    //      Value list: completely new
+
+    if ( &rBox == m_xBtnHeader.get() )              // Field list and value list
+    {
+        const sal_Int32 nCurSel1 = m_xLbField1->get_active();
+        const sal_Int32 nCurSel2 = m_xLbField2->get_active();
+        const sal_Int32 nCurSel3 = m_xLbField3->get_active();
+        const sal_Int32 nCurSel4 = m_xLbField4->get_active();
+        FillFieldLists();
+        m_xLbField1->set_active( nCurSel1 );
+        m_xLbField2->set_active( nCurSel2 );
+        m_xLbField3->set_active( nCurSel3 );
+        m_xLbField4->set_active( nCurSel4 );
+
+        UpdateHdrInValueList( 1 );
+        UpdateHdrInValueList( 2 );
+        UpdateHdrInValueList( 3 );
+        UpdateHdrInValueList( 4 );
+    }
+
+    if ( &rBox != m_xBtnCase.get() )            // Complete value list
+        return;
+
+    m_EntryLists.clear();
+    UpdateValueList( 1 );       // current text is recorded
+    UpdateValueList( 2 );
+    UpdateValueList( 3 );
+    UpdateValueList( 4 );
+
+    UpdateColorList( 1 );
+    UpdateColorList( 2 );
+    UpdateColorList( 3 );
+    UpdateColorList( 4 );
+}
+
+IMPL_LINK( ScFilterDlg, ValModifyHdl, weld::ComboBox&, rEd, void )
+{
+    size_t nOffset = GetSliderPos();
+    size_t i = 0;
+    size_t nQE = i + nOffset;
+    OUString aStrVal = rEd.get_active_text();
+    weld::ComboBox*  pLbCond   = m_xLbCond1.get();
+    weld::ComboBox*  pLbField  = m_xLbField1.get();
+    if ( &rEd == m_xEdVal2.get() )
+    {
+        pLbCond  = m_xLbCond2.get();
+        pLbField = m_xLbField2.get();
+        i=1;
+        nQE=i+nOffset;
+    }
+    if ( &rEd == m_xEdVal3.get() )
+    {
+        pLbCond = m_xLbCond3.get();
+        pLbField = m_xLbField3.get();
+        i=2;
+        nQE=i+nOffset;
+    }
+    if ( &rEd == m_xEdVal4.get() )
+    {
+        pLbCond = m_xLbCond4.get();
+        pLbField = m_xLbField4.get();
+        i=3;
+        nQE=i+nOffset;
+    }
+
+    if ( aStrEmpty == aStrVal || aStrNotEmpty == aStrVal )
+    {
+        pLbCond->set_active_text(OUString('='));
+        pLbCond->set_sensitive(false);
+    }
+    else
+        pLbCond->set_sensitive(true);
+
+    if (maHasDates.size() < nQE + 1)
+        maHasDates.resize(nQE + 1, false);
+    if (maRefreshExceptQuery.size() < nQE + 1)
+        maRefreshExceptQuery.resize(nQE + 1, false);
+
+    ScQueryEntry& rEntry = theQueryData.GetEntry( nQE );
+    ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
+    bool bDoThis = (pLbField->get_active() != 0);
+    rEntry.bDoQuery = bDoThis;
+
+    if ( !(rEntry.bDoQuery || maRefreshExceptQuery[nQE]) )
+        return;
+
+    bool bByEmptyOrNotByEmpty = false;
+    if ( aStrEmpty == aStrVal )
+    {
+        bByEmptyOrNotByEmpty = true;
+        rEntry.SetQueryByEmpty();
+    }
+    else if ( aStrNotEmpty == aStrVal )
+    {
+        bByEmptyOrNotByEmpty = true;
+        rEntry.SetQueryByNonEmpty();
+    }
+    else
+    {
+        rItem.maString = pDoc->GetSharedStringPool().intern(aStrVal);
+        rItem.mfVal = 0.0;
+        rItem.meType = ScQueryEntry::ByString;
+    }
+
+    const sal_Int32 nField = pLbField->get_active();
+    rEntry.nField = nField ? (theQueryData.nCol1 +
+        static_cast<SCCOL>(nField) - 1) : static_cast<SCCOL>(0);
+
+    ScQueryOp eOp  = static_cast<ScQueryOp>(pLbCond->get_active());
+    rEntry.eOp     = eOp;
+    if (maHasDates[nQE] && !bByEmptyOrNotByEmpty)
+        rItem.meType = ScQueryEntry::ByDate;
+}
+
+IMPL_LINK( ScFilterDlg, BtnRemoveHdl, weld::Button&, rBtn, void )
+{
+    // Calculate the row to delete
+    sal_uInt16 nOffset = GetSliderPos();
+    int nButtonIndex = 0;
+    if ( &rBtn == m_xBtnRemove2.get() )
+        nButtonIndex = 1;
+    if ( &rBtn == m_xBtnRemove3.get() )
+        nButtonIndex = 2;
+    if ( &rBtn == m_xBtnRemove4.get() )
+        nButtonIndex = 3;
+    SCSIZE nRowToDelete = nOffset + nButtonIndex;
+
+    // Check that the index is sensible
+    SCSIZE nCount = theQueryData.GetEntryCount();
+    if (nRowToDelete >= nCount)
+    {
+        SAL_WARN( "sc", "ScFilterDlg::BtnRemoveHdl: could not delete row - invalid index.");
+        return;
+    }
+
+    // Resize maRefreshExceptQuery
+    if (maRefreshExceptQuery.size() < nCount + 1)
+        maRefreshExceptQuery.resize(nCount + 1, false);
+
+    // Move all the subsequent rows back one position;
+    // also find the last row, which we will delete
+    SCSIZE nRowToClear = nCount-1;
+    for (SCSIZE i = nRowToDelete; i < nCount-1; ++i)
+    {
+        if (theQueryData.GetEntry(i+1).bDoQuery)
+        {
+            theQueryData.GetEntry(i) = theQueryData.GetEntry(i+1);
+        }
+        else
+        {
+            nRowToClear = i;
+            break;
+        }
+    }
+
+    // If the next row is being edited, but not confirmed, move it back
+    // one position
+    if (nRowToClear < nCount-1  &&  maRefreshExceptQuery[nRowToClear+1])
+    {
+        theQueryData.GetEntry(nRowToClear) = theQueryData.GetEntry(nRowToClear+1);
+        maRefreshExceptQuery[nRowToClear] = true;
+        maRefreshExceptQuery[nRowToClear+1] = false;
+    }
+    else
+    {
+        // Remove the very last one, since everything has moved back
+        theQueryData.GetEntry(nRowToClear).bDoQuery = false;
+        theQueryData.GetEntry(nRowToClear).nField =  static_cast<SCCOL>(0);
+        maRefreshExceptQuery[nRowToClear] = false;
+    }
+
+    // Always enable the very first row
+    if (!theQueryData.GetEntry(0).bDoQuery)
+    {
+        maRefreshExceptQuery[0] = true;
+    }
+
+    // Refresh the UI
+    RefreshEditRow( nOffset );
+
+    // Special handling if the very first row was cleared
+    if (!theQueryData.GetEntry(0).bDoQuery)
+    {
+        m_xLbConnect1->set_active(-1);
+        m_xLbField1->set_active(0);
+        m_xLbField1->set_sensitive(true);
+        m_xLbCond1->set_active(0);
+        m_xLbCond1->set_sensitive(true);
+        ClearValueList(1);
+    }
+}
+
+IMPL_LINK_NOARG(ScFilterDlg, ScrollHdl, weld::ScrolledWindow&, void)
+{
+    SliderMoved();
+}
+
+void ScFilterDlg::SliderMoved()
+{
+    size_t nOffset = GetSliderPos();
+    RefreshEditRow( nOffset);
+}
+
+size_t ScFilterDlg::GetSliderPos() const
+{
+    return static_cast<size_t>(m_xScrollBar->vadjustment_get_value());
+}
+
+void ScFilterDlg::RefreshEditRow( size_t nOffset )
+{
+    if (nOffset==0)
+        maConnLbArr[0]->hide();
+    else
+        maConnLbArr[0]->show();
+
+    for (size_t i = 0; i < QUERY_ENTRY_COUNT; ++i)
+    {
+        OUString aValStr;
+        size_t nCondPos = 0;
+        size_t nFieldSelPos = 0;
+        size_t nQE = i + nOffset;
+
+        maColorLbArr[i]->set_visible(false);
+
+        if (maRefreshExceptQuery.size() < nQE + 1)
+            maRefreshExceptQuery.resize(nQE + 1, false);
+
+        ScQueryEntry& rEntry = theQueryData.GetEntry( nQE);
+        if ( rEntry.bDoQuery || maRefreshExceptQuery[nQE] )
+        {
+            nCondPos = static_cast<size_t>(rEntry.eOp);
+            if(rEntry.bDoQuery)
+               nFieldSelPos = GetFieldSelPos( static_cast<SCCOL>(rEntry.nField) );
+
+            const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
+            OUString aQueryStr = rItem.maString.getString();
+            if (rEntry.IsQueryByEmpty())
+            {
+                aValStr = aStrEmpty;
+                maCondLbArr[i]->set_sensitive(false);
+            }
+            else if (rEntry.IsQueryByNonEmpty())
+            {
+                aValStr = aStrNotEmpty;
+                maCondLbArr[i]->set_sensitive(false);
+            }
+            else if (rEntry.IsQueryByTextColor() || rEntry.IsQueryByBackgroundColor())
+            {
+                nCondPos = maCondLbArr[i]->find_text(
+                    rEntry.IsQueryByTextColor() ? aStrTextColor : aStrBackgroundColor);
+
+                maValueEdArr[i]->set_visible(false);
+                maColorLbArr[i]->set_visible(true);
+                maColorLbArr[i]->set_sensitive(true);
+            }
+            else
+            {
+                SetValString(aQueryStr, rItem, aValStr);
+                maCondLbArr[i]->set_sensitive(true);
+            }
+            maFieldLbArr[i]->set_sensitive(true);
+            maValueEdArr[i]->set_sensitive(true);
+            maRemoveBtnArr[i]->set_sensitive(true);
+
+            if (nOffset==0)
+            {
+                if (i<3)
+                {
+                    if(rEntry.bDoQuery)
+                        maConnLbArr[i+1]->set_sensitive(true);
+                    else
+                        maConnLbArr[i+1]->set_sensitive(false);
+                    size_t nQENext = nQE + 1;
+                    if (maRefreshExceptQuery.size() < nQENext + 1)
+                        maRefreshExceptQuery.resize(nQENext + 1, false);
+                    if (theQueryData.GetEntry(nQENext).bDoQuery || maRefreshExceptQuery[nQENext])
+                        maConnLbArr[i+1]->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(nQENext).eConnect) );
+                    else
+                        maConnLbArr[i+1]->set_active(-1);
+                }
+            }
+            else
+            {
+                if(theQueryData.GetEntry( nQE-1).bDoQuery)
+                    maConnLbArr[i]->set_sensitive(true);
+                else
+                    maConnLbArr[i]->set_sensitive(false);
+
+                if (maRefreshExceptQuery.size() < nQE + 1)
+                    maRefreshExceptQuery.resize(nQE + 1, false);
+                if(rEntry.bDoQuery || maRefreshExceptQuery[nQE])
+                    maConnLbArr[i]->set_active( static_cast<sal_uInt16>(rEntry.eConnect) );
+                else
+                    maConnLbArr[i]->set_active(-1);
+            }
+
+        }
+        else
+        {
+            if (nOffset==0)
+            {
+                if(i<3)
+                {
+                    maConnLbArr[i+1]->set_active(-1);
+                    maConnLbArr[i+1]->set_sensitive(false);
+                }
+            }
+            else
+            {
+                if(theQueryData.GetEntry( nQE-1).bDoQuery)
+                    maConnLbArr[i]->set_sensitive(true);
+                else
+                    maConnLbArr[i]->set_sensitive(false);
+                maConnLbArr[i]->set_active(-1);
+            }
+            maFieldLbArr[i]->set_sensitive(false);
+            maCondLbArr[i]->set_sensitive(false);
+            maValueEdArr[i]->set_sensitive(false);
+            maRemoveBtnArr[i]->set_sensitive(false);
+        }
+        maFieldLbArr[i]->set_active( nFieldSelPos );
+        maCondLbArr [i]->set_active( nCondPos );
+        maValueEdArr[i]->set_entry_text( aValStr );
+        UpdateValueList(i+1);
+        UpdateColorList(i+1);
+    }
+}
+
+void ScFilterDlg::SetValString( const OUString& rQueryStr, const ScQueryEntry::Item& rItem,
+    OUString& rValStr )
+{
+    if (rQueryStr.isEmpty())
+    {
+        pDoc = pViewData ? &pViewData->GetDocument() : nullptr;
+        if (rItem.meType == ScQueryEntry::ByValue)
+        {
+            if (pDoc)
+            {
+                pDoc->GetFormatTable()->GetInputLineString(rItem.mfVal, 0, rValStr);
+            }
+        }
+        else if (rItem.meType == ScQueryEntry::ByDate)
+        {
+            if (pDoc)
+            {
+                SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
+                pFormatter->GetInputLineString(rItem.mfVal,
+                                               pFormatter->GetStandardFormat( SvNumFormatType::DATE), rValStr);
+            }
+        }
+        else
+        {
+            SAL_WARN( "sc", "ScFilterDlg::SetValString: empty query string, really?");
+            rValStr = rQueryStr;
+        }
+    }
+    else
+    {
+        // XXX NOTE: if not ByString we just assume this has been
+        // set to a proper string corresponding to the numeric
+        // value earlier!
+        rValStr = rQueryStr;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/foptmgr.cxx b/sc/source/ui/dbgui/foptmgr.cxx
new file mode 100644
index 000000000..decaa622b
--- /dev/null
+++ b/sc/source/ui/dbgui/foptmgr.cxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <osl/diagnose.h>
+
+#include <rangeutl.hxx>
+#include <dbdata.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <queryparam.hxx>
+#include <globalnames.hxx>
+
+#include <foptmgr.hxx>
+#include <formula/funcutl.hxx>
+
+// ScFilterOptionsMgr (.ui's option helper)
+
+ScFilterOptionsMgr::ScFilterOptionsMgr(
+                                ScViewData*         ptrViewData,
+                                const ScQueryParam& refQueryData,
+                                weld::CheckButton* refBtnCase,
+                                weld::CheckButton* refBtnRegExp,
+                                weld::CheckButton* refBtnHeader,
+                                weld::CheckButton* refBtnUnique,
+                                weld::CheckButton* refBtnCopyResult,
+                                weld::CheckButton* refBtnDestPers,
+                                weld::ComboBox* refLbCopyArea,
+                                formula::RefEdit* refEdCopyArea,
+                                formula::RefButton* refRbCopyArea,
+                                weld::Label* refFtDbAreaLabel,
+                                weld::Label* refFtDbArea,
+                                const OUString&     refStrUndefined )
+
+    :   pViewData       ( ptrViewData ),
+        pDoc            ( ptrViewData ? &ptrViewData->GetDocument() : nullptr ),
+        pBtnCase        ( refBtnCase ),
+        pBtnRegExp      ( refBtnRegExp ),
+        pBtnHeader      ( refBtnHeader ),
+        pBtnUnique      ( refBtnUnique ),
+        pBtnCopyResult  ( refBtnCopyResult ),
+        pBtnDestPers    ( refBtnDestPers ),
+        pLbCopyArea      ( refLbCopyArea ),
+        pEdCopyArea      ( refEdCopyArea ),
+        pRbCopyArea      ( refRbCopyArea ),
+        pFtDbAreaLabel  ( refFtDbAreaLabel ),
+        pFtDbArea       ( refFtDbArea ),
+        rStrUndefined   ( refStrUndefined ),
+        rQueryData      ( refQueryData )
+{
+    Init();
+}
+
+void ScFilterOptionsMgr::Init()
+{
+//moggi:TODO
+    OSL_ENSURE( pViewData && pDoc, "Init failed :-/" );
+
+    pLbCopyArea->connect_changed( LINK( this, ScFilterOptionsMgr, LbAreaSelHdl ) );
+    pEdCopyArea->SetModifyHdl  ( LINK( this, ScFilterOptionsMgr, EdAreaModifyHdl ) );
+    pBtnCopyResult->connect_toggled( LINK( this, ScFilterOptionsMgr, BtnCopyResultHdl ) );
+
+    pBtnCase->set_active( rQueryData.bCaseSens );
+    pBtnHeader->set_active( rQueryData.bHasHeader );
+    pBtnRegExp->set_active( rQueryData.eSearchType == utl::SearchParam::SearchType::Regexp );
+    pBtnUnique->set_active( !rQueryData.bDuplicate );
+
+    if ( pViewData && pDoc )
+    {
+        OUString theAreaStr;
+        ScRange         theCurArea ( ScAddress( rQueryData.nCol1,
+                                                rQueryData.nRow1,
+                                                pViewData->GetTabNo() ),
+                                     ScAddress( rQueryData.nCol2,
+                                                rQueryData.nRow2,
+                                                pViewData->GetTabNo() ) );
+        ScDBCollection* pDBColl     = pDoc->GetDBCollection();
+        OUString theDbArea;
+        OUString   theDbName(STR_DB_LOCAL_NONAME);
+        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
+
+        theAreaStr = theCurArea.Format(*pDoc, ScRefFlags::RANGE_ABS_3D, eConv);
+
+        // fill the target area list
+
+        pLbCopyArea->clear();
+        pLbCopyArea->append_text(rStrUndefined);
+
+        ScAreaNameIterator aIter( *pDoc );
+        OUString aName;
+        ScRange aRange;
+        while ( aIter.Next( aName, aRange ) )
+        {
+            OUString aRefStr(aRange.aStart.Format(ScRefFlags::ADDR_ABS_3D, pDoc, eConv));
+            pLbCopyArea->append(aRefStr, aName);
+        }
+
+        pBtnDestPers->set_active(true);         // always on when called
+        pLbCopyArea->set_active( 0 );
+        pEdCopyArea->SetText( OUString() );
+
+        /*
+         * Check whether the transferred area is a database area:
+         */
+
+        theDbArea = theAreaStr;
+
+        if ( pDBColl )
+        {
+            ScAddress&  rStart  = theCurArea.aStart;
+            ScAddress&  rEnd    = theCurArea.aEnd;
+            const ScDBData* pDBData = pDBColl->GetDBAtArea(
+                rStart.Tab(), rStart.Col(), rStart.Row(), rEnd.Col(), rEnd.Row());
+
+            if ( pDBData )
+            {
+                pBtnHeader->set_active( pDBData->HasHeader() );
+                theDbName = pDBData->GetName();
+
+                pBtnHeader->set_sensitive(theDbName == STR_DB_LOCAL_NONAME);
+            }
+        }
+
+        if ( theDbName != STR_DB_LOCAL_NONAME )
+        {
+            theDbArea += " (" + theDbName + ")";
+
+            pFtDbArea->set_label( theDbArea );
+        }
+        else
+        {
+            pFtDbAreaLabel->set_label( OUString() );
+            pFtDbArea->set_label( OUString() );
+        }
+
+        // position to copy to:
+
+        if ( !rQueryData.bInplace )
+        {
+            OUString aString =
+                ScAddress( rQueryData.nDestCol,
+                           rQueryData.nDestRow,
+                           rQueryData.nDestTab
+                         ).Format(ScRefFlags::ADDR_ABS_3D, pDoc, eConv);
+
+            pBtnCopyResult->set_active(true);
+            pEdCopyArea->SetText( aString );
+            EdAreaModifyHdl( *pEdCopyArea );
+            pLbCopyArea->set_sensitive(true);
+            pEdCopyArea->GetWidget()->set_sensitive(true);
+            pRbCopyArea->GetWidget()->set_sensitive(true);
+            pBtnDestPers->set_sensitive(true);
+        }
+        else
+        {
+            pBtnCopyResult->set_active( false );
+            pEdCopyArea->SetText( OUString() );
+            pLbCopyArea->set_sensitive(false);
+            pEdCopyArea->GetWidget()->set_sensitive(false);
+            pRbCopyArea->GetWidget()->set_sensitive(false);
+            pBtnDestPers->set_sensitive(false);
+        }
+    }
+    else
+        pEdCopyArea->SetText( OUString() );
+}
+
+bool ScFilterOptionsMgr::VerifyPosStr( const OUString& rPosStr ) const
+{
+    OUString aPosStr( rPosStr );
+    sal_Int32 nColonPos = aPosStr.indexOf( ':' );
+
+    if ( -1 != nColonPos )
+        aPosStr = aPosStr.copy( 0, nColonPos );
+
+    ScRefFlags nResult = ScAddress().Parse( aPosStr, *pDoc, pDoc->GetAddressConvention() );
+
+    return (nResult & ScRefFlags::VALID) == ScRefFlags::VALID;
+}
+
+// Handler:
+
+IMPL_LINK( ScFilterOptionsMgr, LbAreaSelHdl, weld::ComboBox&, rLb, void )
+{
+    if ( &rLb == pLbCopyArea )
+    {
+        OUString aString;
+        const sal_Int32 nSelPos = pLbCopyArea->get_active();
+
+        if ( nSelPos > 0 )
+            aString = pLbCopyArea->get_id(nSelPos);
+
+        pEdCopyArea->SetText( aString );
+    }
+}
+
+IMPL_LINK( ScFilterOptionsMgr, EdAreaModifyHdl, formula::RefEdit&, rEd, void )
+{
+    if ( &rEd != pEdCopyArea )
+        return;
+
+    OUString  theCurPosStr = rEd.GetText();
+    ScRefFlags  nResult = ScAddress().Parse( theCurPosStr, *pDoc, pDoc->GetAddressConvention() );
+
+    if ( (nResult & ScRefFlags::VALID) == ScRefFlags::VALID)
+    {
+        const sal_Int32 nCount = pLbCopyArea->get_count();
+
+        for ( sal_Int32 i=2; i<nCount; ++i )
+        {
+            OUString aStr = pLbCopyArea->get_id(i);
+            if (theCurPosStr == aStr)
+            {
+                pLbCopyArea->set_active( i );
+                return;
+            }
+        }
+
+    }
+    pLbCopyArea->set_active( 0 );
+}
+
+IMPL_LINK( ScFilterOptionsMgr, BtnCopyResultHdl, weld::Toggleable&, rBox, void )
+{
+    if ( &rBox != pBtnCopyResult )
+        return;
+
+    if ( rBox.get_active() )
+    {
+        pBtnDestPers->set_sensitive(true);
+        pLbCopyArea->set_sensitive(true);
+        pEdCopyArea->GetWidget()->set_sensitive(true);
+        pRbCopyArea->GetWidget()->set_sensitive(true);
+        pEdCopyArea->GrabFocus();
+    }
+    else
+    {
+        pBtnDestPers->set_sensitive(false);
+        pLbCopyArea->set_sensitive(false);
+        pEdCopyArea->GetWidget()->set_sensitive(false);
+        pRbCopyArea->GetWidget()->set_sensitive(false);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/imoptdlg.cxx b/sc/source/ui/dbgui/imoptdlg.cxx
new file mode 100644
index 000000000..b285c6ae9
--- /dev/null
+++ b/sc/source/ui/dbgui/imoptdlg.cxx
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <imoptdlg.hxx>
+#include <asciiopt.hxx>
+#include <comphelper/string.hxx>
+#include <unotools/charclass.hxx>
+#include <osl/thread.h>
+#include <o3tl/string_view.hxx>
+#include <global.hxx>
+
+const char pStrFix[] = "FIX";
+
+//  The option string can no longer contain a semicolon (because of pick list),
+//  therefore, starting with version 336 comma instead
+
+ScImportOptions::ScImportOptions( std::u16string_view rStr )
+{
+    // Use the same string format as ScAsciiOptions,
+    // because the import options string is passed here when a CSV file is loaded and saved again.
+    // The old format is still supported because it might be used in macros.
+
+    bFixedWidth = false;
+    nFieldSepCode = 0;
+    nTextSepCode = 0;
+    eCharSet = RTL_TEXTENCODING_DONTKNOW;
+    bSaveAsShown = true;    // "true" if not in string (after CSV import)
+    bQuoteAllText = false;
+    bSaveNumberAsSuch = true;
+    bSaveFormulas = false;
+    bRemoveSpace = false;
+    nSheetToExport = 0;
+    bEvaluateFormulas = true;   // true if not present at all, for compatibility
+    sal_Int32 nTokenCount = comphelper::string::getTokenCount(rStr, ',');
+    if ( nTokenCount < 3 )
+        return;
+
+    sal_Int32 nIdx{ 0 };
+    // first 3 tokens: common
+    OUString aToken( o3tl::getToken(rStr, 0, ',', nIdx ) );
+    if( aToken.equalsIgnoreAsciiCase( pStrFix ) )
+        bFixedWidth = true;
+    else
+        nFieldSepCode = ScAsciiOptions::GetWeightedFieldSep( aToken, true);
+    nTextSepCode  = static_cast<sal_Unicode>(o3tl::toInt32(o3tl::getToken(rStr, 0, ',', nIdx)));
+    aStrFont      = o3tl::getToken(rStr, 0, ',', nIdx);
+    eCharSet      = ScGlobal::GetCharsetValue(aStrFont);
+
+    if ( nTokenCount == 4 )
+    {
+        // compatibility with old options string: "Save as shown" as 4th token, numeric
+        bSaveAsShown = o3tl::toInt32(o3tl::getToken(rStr, 0, ',', nIdx)) != 0;
+        bQuoteAllText = true;   // use old default then
+    }
+    else
+    {
+        // look at the same positions as in ScAsciiOptions
+        if ( nTokenCount >= 7 )
+            bQuoteAllText = o3tl::getToken(rStr, 3, ',', nIdx) == u"true";  // 7th token
+        if ( nTokenCount >= 8 )
+            bSaveNumberAsSuch = o3tl::getToken(rStr, 0, ',', nIdx) == u"true";
+        if ( nTokenCount >= 9 )
+            bSaveAsShown = o3tl::getToken(rStr, 0, ',', nIdx) == u"true";
+        if ( nTokenCount >= 10 )
+            bSaveFormulas = o3tl::getToken(rStr, 0, ',', nIdx) == u"true";
+        if ( nTokenCount >= 11 )
+            bRemoveSpace = o3tl::getToken(rStr, 0, ',', nIdx) == u"true";
+        if ( nTokenCount >= 12 )
+        {
+            const OUString aTok(o3tl::getToken(rStr,0, ',', nIdx));
+            if (aTok == "-1")
+                nSheetToExport = -1;    // all
+            else if (aTok.isEmpty() || CharClass::isAsciiNumeric(aTok))
+                nSheetToExport = aTok.toInt32();
+            else
+                nSheetToExport = -23;   // invalid, force error
+        }
+        if ( nTokenCount >= 13 )
+            // If present, defaults to "false".
+            bEvaluateFormulas = o3tl::getToken(rStr, 0, ',', nIdx) == u"true";
+    }
+}
+
+OUString ScImportOptions::BuildString() const
+{
+    OUString aResult;
+
+    if( bFixedWidth )
+        aResult += pStrFix;
+    else
+        aResult += OUString::number(nFieldSepCode);
+    aResult += "," + OUString::number(nTextSepCode) + "," + aStrFont +
+                                                 // use the same string format as ScAsciiOptions:
+            ",1,,0," +                           // first row, no column info, default language
+            OUString::boolean( bQuoteAllText ) + // same as "quoted field as text" in ScAsciiOptions
+            "," +
+            OUString::boolean( bSaveNumberAsSuch ) + // "save number as such": not in ScAsciiOptions
+            "," +
+            OUString::boolean( bSaveAsShown ) +  // "save as shown": not in ScAsciiOptions
+            "," +
+            OUString::boolean( bSaveFormulas ) +  // "save formulas": not in ScAsciiOptions
+            "," +
+            OUString::boolean( bRemoveSpace ) +  // same as "Remove space" in ScAsciiOptions
+            "," +
+            OUString::number(nSheetToExport) +  // Only available for command line --convert-to
+            "," +
+            OUString::boolean( bEvaluateFormulas ) ;  // same as "Evaluate formulas" in ScAsciiOptions
+
+    return aResult;
+}
+
+void ScImportOptions::SetTextEncoding( rtl_TextEncoding nEnc )
+{
+    eCharSet = (nEnc == RTL_TEXTENCODING_DONTKNOW ?
+        osl_getThreadTextEncoding() : nEnc);
+    aStrFont = ScGlobal::GetCharsetString( nEnc );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/pfiltdlg.cxx b/sc/source/ui/dbgui/pfiltdlg.cxx
new file mode 100644
index 000000000..e87d676b5
--- /dev/null
+++ b/sc/source/ui/dbgui/pfiltdlg.cxx
@@ -0,0 +1,507 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <uiitems.hxx>
+#include <global.hxx>
+#include <globalnames.hxx>
+#include <dbdata.hxx>
+#include <scresid.hxx>
+#include <queryentry.hxx>
+#include <filterentries.hxx>
+
+#include <sc.hrc>
+#include <strings.hrc>
+
+#include <pfiltdlg.hxx>
+#include <svl/sharedstringpool.hxx>
+#include <osl/diagnose.h>
+
+ScPivotFilterDlg::ScPivotFilterDlg(weld::Window* pParent, const SfxItemSet& rArgSet,
+                                   SCTAB nSourceTab )
+    : GenericDialogController(pParent, "modules/scalc/ui/pivotfilterdialog.ui", "PivotFilterDialog")
+    , aStrNone(ScResId(SCSTR_NONE))
+    , aStrEmpty(ScResId(SCSTR_FILTER_EMPTY))
+    , aStrNotEmpty(ScResId(SCSTR_FILTER_NOTEMPTY))
+    , aStrColumn(ScResId(SCSTR_COLUMN_LETTER))
+    , nWhichQuery(rArgSet.GetPool()->GetWhich(SID_QUERY))
+    , theQueryData(static_cast<const ScQueryItem&>(rArgSet.Get(nWhichQuery)).GetQueryData())
+    , pViewData(nullptr)
+    , pDoc(nullptr)
+    , nSrcTab(nSourceTab)     // is not in QueryParam
+    , m_xLbField1(m_xBuilder->weld_combo_box("field1"))
+    , m_xLbCond1(m_xBuilder->weld_combo_box("cond1"))
+    , m_xEdVal1(m_xBuilder->weld_combo_box("val1"))
+    , m_xLbConnect1(m_xBuilder->weld_combo_box("connect1"))
+    , m_xLbField2(m_xBuilder->weld_combo_box("field2"))
+    , m_xLbCond2(m_xBuilder->weld_combo_box("cond2"))
+    , m_xEdVal2(m_xBuilder->weld_combo_box("val2"))
+    , m_xLbConnect2(m_xBuilder->weld_combo_box("connect2"))
+    , m_xLbField3(m_xBuilder->weld_combo_box("field3"))
+    , m_xLbCond3(m_xBuilder->weld_combo_box("cond3"))
+    , m_xEdVal3(m_xBuilder->weld_combo_box("val3"))
+    , m_xBtnCase(m_xBuilder->weld_check_button("case"))
+    , m_xBtnRegExp(m_xBuilder->weld_check_button("regexp"))
+    , m_xBtnUnique(m_xBuilder->weld_check_button("unique"))
+    , m_xFtDbArea(m_xBuilder->weld_label("dbarea"))
+{
+    Init( rArgSet );
+}
+
+ScPivotFilterDlg::~ScPivotFilterDlg()
+{
+}
+
+void ScPivotFilterDlg::Init( const SfxItemSet& rArgSet )
+{
+    const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(
+                                    rArgSet.Get( nWhichQuery ));
+
+    m_xBtnCase->connect_toggled( LINK( this, ScPivotFilterDlg, CheckBoxHdl ) );
+
+    m_xLbField1->connect_changed  ( LINK( this, ScPivotFilterDlg, LbSelectHdl ) );
+    m_xLbField2->connect_changed  ( LINK( this, ScPivotFilterDlg, LbSelectHdl ) );
+    m_xLbField3->connect_changed  ( LINK( this, ScPivotFilterDlg, LbSelectHdl ) );
+    m_xLbConnect1->connect_changed( LINK( this, ScPivotFilterDlg, LbSelectHdl ) );
+    m_xLbConnect2->connect_changed( LINK( this, ScPivotFilterDlg, LbSelectHdl ) );
+
+    m_xBtnCase->set_active( theQueryData.bCaseSens );
+    m_xBtnRegExp->set_active( theQueryData.eSearchType == utl::SearchParam::SearchType::Regexp );
+    m_xBtnUnique->set_active( !theQueryData.bDuplicate );
+
+    pViewData   = rQueryItem.GetViewData();
+    pDoc        = pViewData ? &pViewData->GetDocument() : nullptr;
+
+    // for easier access:
+    aFieldLbArr  [0] = m_xLbField1.get();
+    aFieldLbArr  [1] = m_xLbField2.get();
+    aFieldLbArr  [2] = m_xLbField3.get();
+    aValueEdArr  [0] = m_xEdVal1.get();
+    aValueEdArr  [1] = m_xEdVal2.get();
+    aValueEdArr  [2] = m_xEdVal3.get();
+    aCondLbArr   [0] = m_xLbCond1.get();
+    aCondLbArr   [1] = m_xLbCond2.get();
+    aCondLbArr   [2] = m_xLbCond3.get();
+
+    if ( pViewData && pDoc )
+    {
+        ScRange         theCurArea ( ScAddress( theQueryData.nCol1,
+                                                theQueryData.nRow1,
+                                                nSrcTab ),
+                                     ScAddress( theQueryData.nCol2,
+                                                theQueryData.nRow2,
+                                                nSrcTab ) );
+        ScDBCollection* pDBColl     = pDoc->GetDBCollection();
+        OUString theDbName = STR_DB_LOCAL_NONAME;
+
+         // Check if the passed range is a database range
+
+        if ( pDBColl )
+        {
+            ScAddress&  rStart  = theCurArea.aStart;
+            ScAddress&  rEnd    = theCurArea.aEnd;
+            ScDBData*   pDBData = pDBColl->GetDBAtArea( rStart.Tab(),
+                                                        rStart.Col(), rStart.Row(),
+                                                        rEnd.Col(),   rEnd.Row() );
+            if ( pDBData )
+                theDbName = pDBData->GetName();
+        }
+
+        OUString sLabel = " (" + theDbName + ")";
+        m_xFtDbArea->set_label(sLabel);
+    }
+    else
+    {
+        m_xFtDbArea->set_label(OUString());
+    }
+
+    // Read the field lists and select the entries:
+
+    FillFieldLists();
+
+    for ( SCSIZE i=0; i<3; i++ )
+    {
+        if ( theQueryData.GetEntry(i).bDoQuery )
+        {
+            const ScQueryEntry& rEntry = theQueryData.GetEntry(i);
+            const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
+            OUString aValStr = rItem.maString.getString();
+            if (rEntry.IsQueryByEmpty())
+                aValStr = aStrEmpty;
+            else if (rEntry.IsQueryByNonEmpty())
+                aValStr = aStrNotEmpty;
+            sal_uInt16  nCondPos     = static_cast<sal_uInt16>(rEntry.eOp);
+            sal_uInt16  nFieldSelPos = GetFieldSelPos( static_cast<SCCOL>(rEntry.nField) );
+
+            aFieldLbArr[i]->set_active( nFieldSelPos );
+            aCondLbArr [i]->set_active( nCondPos );
+            UpdateValueList( static_cast<sal_uInt16>(i+1) );
+            aValueEdArr[i]->set_entry_text(aValStr);
+            if (aValStr == aStrEmpty || aValStr == aStrNotEmpty)
+                aCondLbArr[i]->set_sensitive(false);
+        }
+        else
+        {
+            aFieldLbArr[i]->set_active( 0 ); // "none" selected
+            aCondLbArr [i]->set_active( 0 ); // "=" selected
+            UpdateValueList( static_cast<sal_uInt16>(i) );
+            aValueEdArr[i]->set_entry_text(OUString());
+        }
+        aValueEdArr[i]->connect_changed( LINK( this, ScPivotFilterDlg, ValModifyHdl ) );
+    }
+
+    // disable/enable logic:
+
+    if (m_xLbField1->get_active() != 0 && m_xLbField2->get_active() != 0)
+        m_xLbConnect1->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(1).eConnect) );
+    else
+        m_xLbConnect1->set_active(-1);
+
+    if (m_xLbField2->get_active() != 0 && m_xLbField3->get_active() != 0)
+        m_xLbConnect2->set_active( static_cast<sal_uInt16>(theQueryData.GetEntry(2).eConnect) );
+    else
+        m_xLbConnect2->set_active(-1);
+
+    if (m_xLbField1->get_active() == 0)
+    {
+        m_xLbConnect1->set_sensitive(false);
+        m_xLbField2->set_sensitive(false);
+        m_xLbCond2->set_sensitive(false);
+        m_xEdVal2->set_sensitive(false);
+    }
+    else if (m_xLbConnect1->get_active() == -1)
+    {
+        m_xLbField2->set_sensitive(false);
+        m_xLbCond2->set_sensitive(false);
+        m_xEdVal2->set_sensitive(false);
+    }
+
+    if (m_xLbField2->get_active() == 0)
+    {
+        m_xLbConnect2->set_sensitive(false);
+        m_xLbField3->set_sensitive(false);
+        m_xLbCond3->set_sensitive(false);
+        m_xEdVal3->set_sensitive(false);
+    }
+    else if (m_xLbConnect2->get_active() == -1)
+    {
+        m_xLbField3->set_sensitive(false);
+        m_xLbCond3->set_sensitive(false);
+        m_xEdVal3->set_sensitive(false);
+    }
+}
+
+void ScPivotFilterDlg::FillFieldLists()
+{
+    m_xLbField1->clear();
+    m_xLbField2->clear();
+    m_xLbField3->clear();
+    m_xLbField1->append_text(aStrNone);
+    m_xLbField2->append_text(aStrNone);
+    m_xLbField3->append_text(aStrNone);
+
+    if ( !pDoc )
+        return;
+
+    OUString  aFieldName;
+    SCTAB   nTab        = nSrcTab;
+    SCCOL   nFirstCol   = theQueryData.nCol1;
+    SCROW   nFirstRow   = theQueryData.nRow1;
+    SCCOL   nMaxCol     = theQueryData.nCol2;
+    SCCOL   col = 0;
+
+    for ( col=nFirstCol; col<=nMaxCol; col++ )
+    {
+        aFieldName = pDoc->GetString(col, nFirstRow, nTab);
+        if ( aFieldName.isEmpty() )
+        {
+            aFieldName = ScGlobal::ReplaceOrAppend( aStrColumn, u"%1", ScColToAlpha( col ));
+        }
+        m_xLbField1->append_text(aFieldName);
+        m_xLbField2->append_text(aFieldName);
+        m_xLbField3->append_text(aFieldName);
+    }
+}
+
+void ScPivotFilterDlg::UpdateValueList( sal_uInt16 nList )
+{
+    if ( !(pDoc && nList>0 && nList<=3) )
+        return;
+
+    weld::ComboBox* pValList        = aValueEdArr[nList-1];
+    sal_Int32   nFieldSelPos    = aFieldLbArr[nList-1]->get_active();
+    OUString    aCurValue       = pValList->get_active_text();
+
+    pValList->clear();
+    pValList->append_text(aStrNotEmpty);
+    pValList->append_text(aStrEmpty);
+
+    if ( pDoc && nFieldSelPos )
+    {
+        SCCOL nColumn = theQueryData.nCol1 + static_cast<SCCOL>(nFieldSelPos) - 1;
+        if (!m_pEntryLists[nColumn])
+        {
+            weld::WaitObject aWaiter(m_xDialog.get());
+
+            SCTAB   nTab        = nSrcTab;
+            SCROW   nFirstRow   = theQueryData.nRow1;
+            SCROW   nLastRow    = theQueryData.nRow2;
+            nFirstRow++;
+            bool bCaseSens = m_xBtnCase->get_active();
+            m_pEntryLists[nColumn].reset( new ScFilterEntries);
+            pDoc->GetFilterEntriesArea(
+                nColumn, nFirstRow, nLastRow, nTab, bCaseSens, *m_pEntryLists[nColumn]);
+        }
+
+        const ScFilterEntries* pColl = m_pEntryLists[nColumn].get();
+        for (const auto& rEntry : *pColl)
+        {
+            pValList->append_text(rEntry.GetString());
+        }
+    }
+    pValList->set_entry_text(aCurValue);
+}
+
+void ScPivotFilterDlg::ClearValueList( sal_uInt16 nList )
+{
+    if ( nList>0 && nList<=3 )
+    {
+        weld::ComboBox* pValList = aValueEdArr[nList-1];
+        pValList->clear();
+        pValList->append_text(aStrNotEmpty);
+        pValList->append_text(aStrEmpty);
+        pValList->set_entry_text(OUString());
+    }
+}
+
+sal_uInt16 ScPivotFilterDlg::GetFieldSelPos( SCCOL nField )
+{
+    if ( nField >= theQueryData.nCol1 && nField <= theQueryData.nCol2 )
+        return static_cast<sal_uInt16>(nField - theQueryData.nCol1 + 1);
+    else
+        return 0;
+}
+
+const ScQueryItem& ScPivotFilterDlg::GetOutputItem()
+{
+    ScQueryParam    theParam( theQueryData );
+    sal_Int32          nConnect1 = m_xLbConnect1->get_active();
+    sal_Int32          nConnect2 = m_xLbConnect2->get_active();
+
+    svl::SharedStringPool& rPool = pViewData->GetDocument().GetSharedStringPool();
+
+    for ( SCSIZE i=0; i<3; i++ )
+    {
+        const sal_Int32 nField = aFieldLbArr[i]->get_active();
+        ScQueryOp   eOp     = static_cast<ScQueryOp>(aCondLbArr[i]->get_active());
+
+        bool bDoThis = (aFieldLbArr[i]->get_active() != 0);
+        theParam.GetEntry(i).bDoQuery = bDoThis;
+
+        if ( bDoThis )
+        {
+            ScQueryEntry& rEntry = theParam.GetEntry(i);
+            ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
+
+            OUString aStrVal = aValueEdArr[i]->get_active_text();
+
+            /*
+             * The dialog returns the specific field values "empty"/"non empty"
+             * as constant in nVal in connection with the bQueryByString switch
+             * set to false
+             */
+            if ( aStrVal == aStrEmpty )
+            {
+                OSL_ASSERT(eOp == SC_EQUAL);
+                rEntry.SetQueryByEmpty();
+            }
+            else if ( aStrVal == aStrNotEmpty )
+            {
+                OSL_ASSERT(eOp == SC_EQUAL);
+                rEntry.SetQueryByNonEmpty();
+            }
+            else
+            {
+                rItem.maString = rPool.intern(aStrVal);
+                rItem.mfVal = 0.0;
+                rItem.meType = ScQueryEntry::ByString;
+            }
+
+            rEntry.nField   = nField ? (theQueryData.nCol1 +
+                    static_cast<SCCOL>(nField) - 1) : static_cast<SCCOL>(0);
+            rEntry.eOp      = eOp;
+        }
+    }
+
+    theParam.GetEntry(1).eConnect = (nConnect1 != -1)
+                                    ? static_cast<ScQueryConnect>(nConnect1)
+                                    : SC_AND;
+    theParam.GetEntry(2).eConnect = (nConnect2 != -1)
+                                    ? static_cast<ScQueryConnect>(nConnect2)
+                                    : SC_AND;
+
+    theParam.bInplace   = false;
+    theParam.nDestTab   = 0;    // Where do those values come from?
+    theParam.nDestCol   = 0;
+    theParam.nDestRow   = 0;
+
+    theParam.bDuplicate     = !m_xBtnUnique->get_active();
+    theParam.bCaseSens      = m_xBtnCase->get_active();
+    theParam.eSearchType    = m_xBtnRegExp->get_active() ? utl::SearchParam::SearchType::Regexp : utl::SearchParam::SearchType::Normal;
+
+    pOutItem.reset( new ScQueryItem( nWhichQuery, &theParam ) );
+
+    return *pOutItem;
+}
+
+// Handler:
+
+IMPL_LINK( ScPivotFilterDlg, LbSelectHdl, weld::ComboBox&, rLb, void )
+{
+    /*
+     * Handling the enable/disable logic based on which ListBox was touched:
+     */
+    if (&rLb == m_xLbConnect1.get())
+    {
+        if ( !m_xLbField2->get_sensitive() )
+        {
+            m_xLbField2->set_sensitive(true);
+            m_xLbCond2->set_sensitive(true);
+            m_xEdVal2->set_sensitive(true);
+        }
+    }
+    else if (&rLb == m_xLbConnect2.get())
+    {
+        if ( !m_xLbField3->get_sensitive() )
+        {
+            m_xLbField3->set_sensitive(true);
+            m_xLbCond3->set_sensitive(true);
+            m_xEdVal3->set_sensitive(true);
+        }
+    }
+    else if (&rLb == m_xLbField1.get())
+    {
+        if ( m_xLbField1->get_active() == 0 )
+        {
+            m_xLbConnect1->set_active(-1);
+            m_xLbConnect2->set_active(-1);
+            m_xLbField2->set_active( 0 );
+            m_xLbField3->set_active( 0 );
+            m_xLbCond2->set_active( 0 );
+            m_xLbCond3->set_active( 0 );
+            ClearValueList( 1 );
+            ClearValueList( 2 );
+            ClearValueList( 3 );
+
+            m_xLbConnect1->set_sensitive(false);
+            m_xLbConnect2->set_sensitive(false);
+            m_xLbField2->set_sensitive(false);
+            m_xLbField3->set_sensitive(false);
+            m_xLbCond2->set_sensitive(false);
+            m_xLbCond3->set_sensitive(false);
+            m_xEdVal2->set_sensitive(false);
+            m_xEdVal3->set_sensitive(false);
+        }
+        else
+        {
+            UpdateValueList( 1 );
+            if ( !m_xLbConnect1->get_sensitive() )
+            {
+                m_xLbConnect1->set_sensitive(true);
+            }
+        }
+    }
+    else if (&rLb == m_xLbField2.get())
+    {
+        if ( m_xLbField2->get_active() == 0 )
+        {
+            m_xLbConnect2->set_active(-1);
+            m_xLbField3->set_active( 0 );
+            m_xLbCond3->set_active( 0 );
+            ClearValueList( 2 );
+            ClearValueList( 3 );
+
+            m_xLbConnect2->set_sensitive(false);
+            m_xLbField3->set_sensitive(false);
+            m_xLbCond3->set_sensitive(false);
+            m_xEdVal3->set_sensitive(false);
+        }
+        else
+        {
+            UpdateValueList( 2 );
+            if (!m_xLbConnect2->get_sensitive())
+            {
+                m_xLbConnect2->set_sensitive(true);
+            }
+        }
+    }
+    else if (&rLb == m_xLbField3.get())
+    {
+        if (m_xLbField3->get_active() == 0)
+            ClearValueList(3);
+        else
+            UpdateValueList(3);
+    }
+}
+
+IMPL_LINK(ScPivotFilterDlg, CheckBoxHdl, weld::Toggleable&, rBox, void)
+{
+    // update the value lists when dealing with uppercase/lowercase
+
+    if (&rBox != m_xBtnCase.get())                    // value lists
+        return;
+
+    for (auto& a : m_pEntryLists)
+        a.reset();
+
+    OUString aCurVal1 = m_xEdVal1->get_active_text();
+    OUString aCurVal2 = m_xEdVal2->get_active_text();
+    OUString aCurVal3 = m_xEdVal3->get_active_text();
+    UpdateValueList( 1 );
+    UpdateValueList( 2 );
+    UpdateValueList( 3 );
+    m_xEdVal1->set_entry_text(aCurVal1);
+    m_xEdVal2->set_entry_text(aCurVal2);
+    m_xEdVal3->set_entry_text(aCurVal3);
+}
+
+IMPL_LINK( ScPivotFilterDlg, ValModifyHdl, weld::ComboBox&, rEd, void )
+{
+    OUString aStrVal = rEd.get_active_text();
+    weld::ComboBox* pLb = m_xLbCond1.get();
+
+    if ( &rEd == m_xEdVal2.get() ) pLb = m_xLbCond2.get();
+    else if ( &rEd == m_xEdVal3.get() ) pLb = m_xLbCond3.get();
+
+    // if cond of the special values "empty"/"non-empty" was chosen only the
+    // =-operand makes sense:
+
+    if ( aStrEmpty == aStrVal || aStrNotEmpty == aStrVal )
+    {
+        pLb->set_active_text(OUString('='));
+        pLb->set_sensitive(false);
+    }
+    else
+        pLb->set_sensitive(true);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/pvfundlg.cxx b/sc/source/ui/dbgui/pvfundlg.cxx
new file mode 100644
index 000000000..90a13e920
--- /dev/null
+++ b/sc/source/ui/dbgui/pvfundlg.cxx
@@ -0,0 +1,973 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <pvfundlg.hxx>
+
+#include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp>
+#include <com/sun/star/sheet/DataPilotFieldReferenceItemType.hpp>
+#include <com/sun/star/sheet/DataPilotFieldLayoutMode.hpp>
+#include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
+#include <com/sun/star/sheet/DataPilotFieldShowItemsMode.hpp>
+
+#include <osl/diagnose.h>
+
+#include <scresid.hxx>
+#include <dpobject.hxx>
+#include <dpsave.hxx>
+#include <pvfundlg.hrc>
+#include <globstr.hrc>
+#include <dputil.hxx>
+
+#include <vector>
+
+using namespace ::com::sun::star::sheet;
+
+using ::com::sun::star::uno::Sequence;
+using ::std::vector;
+
+namespace {
+
+/** Appends all strings from the Sequence to the list box.
+
+    Empty strings are replaced by a localized "(empty)" entry and inserted at
+    the specified position.
+
+    @return  true = The passed string list contains an empty string entry.
+ */
+
+bool lclFillListBox(weld::ComboBox& rLBox, const Sequence< OUString >& rStrings)
+{
+    bool bEmpty = false;
+    for (const OUString& str : rStrings)
+    {
+        if (!str.isEmpty())
+            rLBox.append_text(str);
+        else
+        {
+            rLBox.append_text(ScResId(STR_EMPTYDATA));
+            bEmpty = true;
+        }
+    }
+    return bEmpty;
+}
+
+bool lclFillListBox(weld::ComboBox& rLBox, const vector<ScDPLabelData::Member>& rMembers, int nEmptyPos)
+{
+    bool bEmpty = false;
+    vector<ScDPLabelData::Member>::const_iterator itr = rMembers.begin(), itrEnd = rMembers.end();
+    for (; itr != itrEnd; ++itr)
+    {
+        OUString aName = itr->getDisplayName();
+        if (!aName.isEmpty())
+            rLBox.append_text(aName);
+        else
+        {
+            rLBox.insert_text(nEmptyPos, ScResId(STR_EMPTYDATA));
+            bEmpty = true;
+        }
+    }
+    return bEmpty;
+}
+
+bool lclFillListBox(weld::TreeView& rLBox, const vector<ScDPLabelData::Member>& rMembers)
+{
+    bool bEmpty = false;
+    for (const auto& rMember : rMembers)
+    {
+        rLBox.append();
+        int pos = rLBox.n_children() - 1;
+        rLBox.set_toggle(pos, TRISTATE_FALSE);
+        OUString aName = rMember.getDisplayName();
+        if (!aName.isEmpty())
+            rLBox.set_text(pos, aName, 0);
+        else
+        {
+            rLBox.set_text(pos, ScResId(STR_EMPTYDATA), 0);
+            bEmpty = true;
+        }
+    }
+    return bEmpty;
+}
+
+/** This table represents the order of the strings in the resource string array. */
+const PivotFunc spnFunctions[] =
+{
+    PivotFunc::Sum,
+    PivotFunc::Count,
+    PivotFunc::Average,
+    PivotFunc::Median,
+    PivotFunc::Max,
+    PivotFunc::Min,
+    PivotFunc::Product,
+    PivotFunc::CountNum,
+    PivotFunc::StdDev,
+    PivotFunc::StdDevP,
+    PivotFunc::StdVar,
+    PivotFunc::StdVarP
+};
+
+const sal_uInt16 SC_BASEITEM_PREV_POS = 0;
+const sal_uInt16 SC_BASEITEM_NEXT_POS = 1;
+const sal_uInt16 SC_BASEITEM_USER_POS = 2;
+
+const sal_uInt16 SC_SORTNAME_POS = 0;
+const sal_uInt16 SC_SORTDATA_POS = 1;
+
+const tools::Long SC_SHOW_DEFAULT = 10;
+
+} // namespace
+
+ScDPFunctionListBox::ScDPFunctionListBox(std::unique_ptr<weld::TreeView> xControl)
+    : m_xControl(std::move(xControl))
+{
+    FillFunctionNames();
+}
+
+void ScDPFunctionListBox::SetSelection( PivotFunc nFuncMask )
+{
+    if( (nFuncMask == PivotFunc::NONE) || (nFuncMask == PivotFunc::Auto) )
+        m_xControl->unselect_all();
+    else
+    {
+        for( sal_Int32 nEntry = 0, nCount = m_xControl->n_children(); nEntry < nCount; ++nEntry )
+        {
+            if (bool(nFuncMask & spnFunctions[ nEntry ]))
+                m_xControl->select(nEntry);
+            else
+                m_xControl->unselect(nEntry);
+        }
+    }
+}
+
+PivotFunc ScDPFunctionListBox::GetSelection() const
+{
+    PivotFunc nFuncMask = PivotFunc::NONE;
+    std::vector<int> aRows = m_xControl->get_selected_rows();
+    for (int nSel : aRows)
+        nFuncMask |= spnFunctions[nSel];
+    return nFuncMask;
+}
+
+void ScDPFunctionListBox::FillFunctionNames()
+{
+    OSL_ENSURE( !m_xControl->n_children(), "ScDPMultiFuncListBox::FillFunctionNames - do not add texts to resource" );
+    m_xControl->clear();
+    m_xControl->freeze();
+    for (size_t nIndex = 0; nIndex < SAL_N_ELEMENTS(SCSTR_DPFUNCLISTBOX); ++nIndex)
+        m_xControl->append_text(ScResId(SCSTR_DPFUNCLISTBOX[nIndex]));
+    m_xControl->thaw();
+    assert(m_xControl->n_children() == SAL_N_ELEMENTS(spnFunctions));
+}
+
+namespace
+{
+    int FromDataPilotFieldReferenceType(int eMode)
+    {
+        switch (eMode)
+        {
+            case DataPilotFieldReferenceType::NONE:
+                return 0;
+            case DataPilotFieldReferenceType::ITEM_DIFFERENCE:
+                return 1;
+            case DataPilotFieldReferenceType::ITEM_PERCENTAGE:
+                return 2;
+            case DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE:
+                return 3;
+            case DataPilotFieldReferenceType::RUNNING_TOTAL:
+                return 4;
+            case DataPilotFieldReferenceType::ROW_PERCENTAGE:
+                return 5;
+            case DataPilotFieldReferenceType::COLUMN_PERCENTAGE:
+                return 6;
+            case DataPilotFieldReferenceType::TOTAL_PERCENTAGE:
+                return 7;
+            case DataPilotFieldReferenceType::INDEX:
+                return 8;
+        }
+        return -1;
+    }
+
+    int ToDataPilotFieldReferenceType(int nPos)
+    {
+        switch (nPos)
+        {
+            case 0:
+                return DataPilotFieldReferenceType::NONE;
+            case 1:
+                return DataPilotFieldReferenceType::ITEM_DIFFERENCE;
+            case 2:
+                return DataPilotFieldReferenceType::ITEM_PERCENTAGE;
+            case 3:
+                return DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE;
+            case 4:
+                return DataPilotFieldReferenceType::RUNNING_TOTAL;
+            case 5:
+                return DataPilotFieldReferenceType::ROW_PERCENTAGE;
+            case 6:
+                return DataPilotFieldReferenceType::COLUMN_PERCENTAGE;
+            case 7:
+                return DataPilotFieldReferenceType::TOTAL_PERCENTAGE;
+            case 8:
+                return DataPilotFieldReferenceType::INDEX;
+        }
+        return DataPilotFieldReferenceType::NONE;
+
+    }
+}
+
+ScDPFunctionDlg::ScDPFunctionDlg(
+        weld::Widget* pParent, const ScDPLabelDataVector& rLabelVec,
+        const ScDPLabelData& rLabelData, const ScPivotFuncData& rFuncData)
+    : GenericDialogController(pParent, "modules/scalc/ui/datafielddialog.ui", "DataFieldDialog")
+    , mxLbFunc(new ScDPFunctionListBox(m_xBuilder->weld_tree_view("functions")))
+    , mxFtName(m_xBuilder->weld_label("name"))
+    , mxLbType(m_xBuilder->weld_combo_box("type"))
+    , mxFtBaseField(m_xBuilder->weld_label("basefieldft"))
+    , mxLbBaseField(m_xBuilder->weld_combo_box("basefield"))
+    , mxFtBaseItem(m_xBuilder->weld_label("baseitemft"))
+    , mxLbBaseItem(m_xBuilder->weld_combo_box("baseitem"))
+    , mxBtnOk(m_xBuilder->weld_button("ok"))
+    , mxBtnCancel(m_xBuilder->weld_button("cancel"))
+    , mxExpander(m_xBuilder->weld_expander("expander"))
+    , mrLabelVec(rLabelVec)
+    , mbEmptyItem(false)
+{
+    mxLbFunc->set_size_request(-1, mxLbFunc->get_height_rows(8));
+
+    Init(rLabelData, rFuncData);
+}
+
+ScDPFunctionDlg::~ScDPFunctionDlg()
+{
+}
+
+PivotFunc ScDPFunctionDlg::GetFuncMask() const
+{
+    return mxLbFunc->GetSelection();
+}
+
+DataPilotFieldReference ScDPFunctionDlg::GetFieldRef() const
+{
+    DataPilotFieldReference aRef;
+
+    aRef.ReferenceType = ToDataPilotFieldReferenceType(mxLbType->get_active());
+    aRef.ReferenceField = GetBaseFieldName(mxLbBaseField->get_active_text());
+
+    sal_Int32 nBaseItemPos = mxLbBaseItem->get_active();
+    switch( nBaseItemPos )
+    {
+        case SC_BASEITEM_PREV_POS:
+            aRef.ReferenceItemType = DataPilotFieldReferenceItemType::PREVIOUS;
+        break;
+        case SC_BASEITEM_NEXT_POS:
+            aRef.ReferenceItemType = DataPilotFieldReferenceItemType::NEXT;
+        break;
+        default:
+        {
+            aRef.ReferenceItemType = DataPilotFieldReferenceItemType::NAMED;
+            if( !mbEmptyItem || (nBaseItemPos > SC_BASEITEM_USER_POS) )
+                aRef.ReferenceItemName = GetBaseItemName(mxLbBaseItem->get_active_text());
+        }
+    }
+
+    return aRef;
+}
+
+void ScDPFunctionDlg::Init( const ScDPLabelData& rLabelData, const ScPivotFuncData& rFuncData )
+{
+    mxBtnOk->connect_clicked( LINK( this, ScDPFunctionDlg, ButtonClicked ) );
+    mxBtnCancel->connect_clicked( LINK( this, ScDPFunctionDlg, ButtonClicked ) );
+
+    // list box
+    PivotFunc nFuncMask = (rFuncData.mnFuncMask == PivotFunc::NONE) ? PivotFunc::Sum : rFuncData.mnFuncMask;
+    mxLbFunc->SetSelection( nFuncMask );
+
+    // field name
+    mxFtName->set_label(rLabelData.getDisplayName());
+
+    // handlers
+    mxLbFunc->connect_row_activated( LINK( this, ScDPFunctionDlg, DblClickHdl ) );
+    mxLbType->connect_changed( LINK( this, ScDPFunctionDlg, SelectHdl ) );
+    mxLbBaseField->connect_changed( LINK( this, ScDPFunctionDlg, SelectHdl ) );
+
+    // base field list box
+    OUString aSelectedEntry;
+    for( const auto& rxLabel : mrLabelVec )
+    {
+        mxLbBaseField->append_text(rxLabel->getDisplayName());
+        maBaseFieldNameMap.emplace(rxLabel->getDisplayName(), rxLabel->maName);
+        if (rxLabel->maName == rFuncData.maFieldRef.ReferenceField)
+            aSelectedEntry = rxLabel->getDisplayName();
+    }
+
+    // select field reference type
+    mxLbType->set_active(FromDataPilotFieldReferenceType(rFuncData.maFieldRef.ReferenceType));
+    SelectHdl( *mxLbType );         // enables base field/item list boxes
+
+    // select base field
+    mxLbBaseField->set_active_text(aSelectedEntry);
+    if (mxLbBaseField->get_active() == -1)
+        mxLbBaseField->set_active(0);
+    SelectHdl( *mxLbBaseField );    // fills base item list, selects base item
+
+    // select base item
+    switch( rFuncData.maFieldRef.ReferenceItemType )
+    {
+        case DataPilotFieldReferenceItemType::PREVIOUS:
+            mxLbBaseItem->set_active( SC_BASEITEM_PREV_POS );
+        break;
+        case DataPilotFieldReferenceItemType::NEXT:
+            mxLbBaseItem->set_active( SC_BASEITEM_NEXT_POS );
+        break;
+        default:
+        {
+            if( mbEmptyItem && rFuncData.maFieldRef.ReferenceItemName.isEmpty() )
+            {
+                // select special "(empty)" entry added before other items
+                mxLbBaseItem->set_active( SC_BASEITEM_USER_POS );
+            }
+            else
+            {
+                sal_Int32 nStartPos = mbEmptyItem ? (SC_BASEITEM_USER_POS + 1) : SC_BASEITEM_USER_POS;
+                sal_Int32 nPos = FindBaseItemPos( rFuncData.maFieldRef.ReferenceItemName, nStartPos );
+                if( nPos == -1)
+                    nPos = (mxLbBaseItem->get_count() > SC_BASEITEM_USER_POS) ? SC_BASEITEM_USER_POS : SC_BASEITEM_PREV_POS;
+                mxLbBaseItem->set_active( nPos );
+            }
+        }
+    }
+}
+
+const OUString& ScDPFunctionDlg::GetBaseFieldName(const OUString& rLayoutName) const
+{
+    NameMapType::const_iterator itr = maBaseFieldNameMap.find(rLayoutName);
+    return itr == maBaseFieldNameMap.end() ? rLayoutName : itr->second;
+}
+
+const OUString& ScDPFunctionDlg::GetBaseItemName(const OUString& rLayoutName) const
+{
+    NameMapType::const_iterator itr = maBaseItemNameMap.find(rLayoutName);
+    return itr == maBaseItemNameMap.end() ? rLayoutName : itr->second;
+}
+
+sal_Int32 ScDPFunctionDlg::FindBaseItemPos( std::u16string_view rEntry, sal_Int32 nStartPos ) const
+{
+    sal_Int32 nPos = nStartPos;
+    bool bFound = false;
+    while (nPos < mxLbBaseItem->get_count())
+    {
+        // translate the displayed field name back to its original field name.
+        const OUString& rInName = mxLbBaseItem->get_text(nPos);
+        const OUString& rName = GetBaseItemName(rInName);
+        if (rName == rEntry)
+        {
+            bFound = true;
+            break;
+        }
+        ++nPos;
+    }
+    return bFound ? nPos : -1;
+}
+
+IMPL_LINK( ScDPFunctionDlg, SelectHdl, weld::ComboBox&, rLBox, void )
+{
+    if (&rLBox == mxLbType.get())
+    {
+        bool bEnableField, bEnableItem;
+        switch (ToDataPilotFieldReferenceType(mxLbType->get_active()))
+        {
+            case DataPilotFieldReferenceType::ITEM_DIFFERENCE:
+            case DataPilotFieldReferenceType::ITEM_PERCENTAGE:
+            case DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE:
+                bEnableField = bEnableItem = true;
+            break;
+
+            case DataPilotFieldReferenceType::RUNNING_TOTAL:
+                bEnableField = true;
+                bEnableItem = false;
+            break;
+
+            default:
+                bEnableField = bEnableItem = false;
+        }
+
+        bEnableField &= (mxLbBaseField->get_count() > 0);
+        mxFtBaseField->set_sensitive( bEnableField );
+        mxLbBaseField->set_sensitive( bEnableField );
+
+        bEnableItem &= bEnableField;
+        mxFtBaseItem->set_sensitive( bEnableItem );
+        mxLbBaseItem->set_sensitive( bEnableItem );
+    }
+    else if (&rLBox == mxLbBaseField.get())
+    {
+        // keep "previous" and "next" entries
+        while (mxLbBaseItem->get_count() > SC_BASEITEM_USER_POS)
+             mxLbBaseItem->remove(SC_BASEITEM_USER_POS);
+
+        // update item list for current base field
+        mbEmptyItem = false;
+        size_t nBasePos = mxLbBaseField->get_active();
+        if (nBasePos < mrLabelVec.size())
+        {
+            const vector<ScDPLabelData::Member>& rMembers = mrLabelVec[nBasePos]->maMembers;
+            mbEmptyItem = lclFillListBox(*mxLbBaseItem, rMembers, SC_BASEITEM_USER_POS);
+            // build cache for base names.
+            NameMapType aMap;
+            for (const auto& rMember : rMembers)
+                aMap.emplace(rMember.getDisplayName(), rMember.maName);
+            maBaseItemNameMap.swap(aMap);
+        }
+
+        // select base item
+        sal_uInt16 nItemPos = (mxLbBaseItem->get_count() > SC_BASEITEM_USER_POS) ? SC_BASEITEM_USER_POS : SC_BASEITEM_PREV_POS;
+        mxLbBaseItem->set_active( nItemPos );
+    }
+}
+
+IMPL_LINK(ScDPFunctionDlg, ButtonClicked, weld::Button&, rButton, void)
+{
+    if (&rButton == mxBtnOk.get())
+        response(RET_OK);
+    else
+        response(RET_CANCEL);
+}
+
+IMPL_LINK_NOARG(ScDPFunctionDlg, DblClickHdl, weld::TreeView&, bool)
+{
+    m_xDialog->response(RET_OK);
+    return true;
+}
+
+ScDPSubtotalDlg::ScDPSubtotalDlg(weld::Widget* pParent, ScDPObject& rDPObj,
+        const ScDPLabelData& rLabelData, const ScPivotFuncData& rFuncData,
+        const ScDPNameVec& rDataFields, bool bEnableLayout)
+    : GenericDialogController(pParent, "modules/scalc/ui/pivotfielddialog.ui", "PivotFieldDialog")
+    , mrDPObj(rDPObj)
+    , mrDataFields(rDataFields)
+    , maLabelData(rLabelData)
+    , mbEnableLayout(bEnableLayout)
+    , mxRbNone(m_xBuilder->weld_radio_button("none"))
+    , mxRbAuto(m_xBuilder->weld_radio_button("auto"))
+    , mxRbUser(m_xBuilder->weld_radio_button("user"))
+    , mxLbFunc(new ScDPFunctionListBox(m_xBuilder->weld_tree_view("functions")))
+    , mxFtName(m_xBuilder->weld_label("name"))
+    , mxCbShowAll(m_xBuilder->weld_check_button("showall"))
+    , mxBtnOk(m_xBuilder->weld_button("ok"))
+    , mxBtnCancel(m_xBuilder->weld_button("cancel"))
+    , mxBtnOptions(m_xBuilder->weld_button("options"))
+{
+    mxLbFunc->set_selection_mode(SelectionMode::Multiple);
+    mxLbFunc->set_size_request(-1, mxLbFunc->get_height_rows(8));
+    Init(rLabelData, rFuncData);
+}
+
+ScDPSubtotalDlg::~ScDPSubtotalDlg()
+{
+    CloseSubdialog();
+}
+
+void ScDPSubtotalDlg::CloseSubdialog()
+{
+    if (mxOptionsDlg && mxOptionsDlg->getDialog())
+    {
+        mxOptionsDlg->getDialog()->response(RET_CANCEL);
+        mxOptionsDlg = nullptr;
+    }
+}
+
+PivotFunc ScDPSubtotalDlg::GetFuncMask() const
+{
+    PivotFunc nFuncMask = PivotFunc::NONE;
+
+    if (mxRbAuto->get_active())
+        nFuncMask = PivotFunc::Auto;
+    else if (mxRbUser->get_active())
+        nFuncMask = mxLbFunc->GetSelection();
+
+    return nFuncMask;
+}
+
+void ScDPSubtotalDlg::FillLabelData( ScDPLabelData& rLabelData ) const
+{
+    rLabelData.mnFuncMask = GetFuncMask();
+    rLabelData.mnUsedHier = maLabelData.mnUsedHier;
+    rLabelData.mbShowAll = mxCbShowAll->get_active();
+    rLabelData.maMembers = maLabelData.maMembers;
+    rLabelData.maSortInfo = maLabelData.maSortInfo;
+    rLabelData.maLayoutInfo = maLabelData.maLayoutInfo;
+    rLabelData.maShowInfo = maLabelData.maShowInfo;
+    rLabelData.mbRepeatItemLabels = maLabelData.mbRepeatItemLabels;
+}
+
+void ScDPSubtotalDlg::Init( const ScDPLabelData& rLabelData, const ScPivotFuncData& rFuncData )
+{
+    mxBtnOk->connect_clicked( LINK( this, ScDPSubtotalDlg, ButtonClicked ) );
+    mxBtnCancel->connect_clicked( LINK( this, ScDPSubtotalDlg, ButtonClicked ) );
+
+    // field name
+    mxFtName->set_label(rLabelData.getDisplayName());
+
+    // radio buttons
+    mxRbNone->connect_toggled( LINK( this, ScDPSubtotalDlg, RadioClickHdl ) );
+    mxRbAuto->connect_toggled( LINK( this, ScDPSubtotalDlg, RadioClickHdl ) );
+    mxRbUser->connect_toggled( LINK( this, ScDPSubtotalDlg, RadioClickHdl ) );
+
+    weld::RadioButton* pRBtn = nullptr;
+    switch( rFuncData.mnFuncMask )
+    {
+        case PivotFunc::NONE:   pRBtn = mxRbNone.get();  break;
+        case PivotFunc::Auto:   pRBtn = mxRbAuto.get();  break;
+        default:                pRBtn = mxRbUser.get();
+    }
+    pRBtn->set_active(true);
+    RadioClickHdl(*pRBtn);
+
+    // list box
+    mxLbFunc->SetSelection( rFuncData.mnFuncMask );
+    mxLbFunc->connect_row_activated( LINK( this, ScDPSubtotalDlg, DblClickHdl ) );
+
+    // show all
+    mxCbShowAll->set_active( rLabelData.mbShowAll );
+
+    // options
+    mxBtnOptions->connect_clicked( LINK( this, ScDPSubtotalDlg, ClickHdl ) );
+}
+
+IMPL_LINK(ScDPSubtotalDlg, ButtonClicked, weld::Button&, rButton, void)
+{
+    CloseSubdialog();
+
+    if (&rButton == mxBtnOk.get())
+        response(RET_OK);
+    else
+        response(RET_CANCEL);
+}
+
+IMPL_LINK(ScDPSubtotalDlg, RadioClickHdl, weld::Toggleable&, rBtn, void)
+{
+    if (!rBtn.get_active())
+        return;
+    mxLbFunc->set_sensitive(mxRbUser->get_active());
+}
+
+IMPL_LINK_NOARG(ScDPSubtotalDlg, DblClickHdl, weld::TreeView&, bool)
+{
+    m_xDialog->response(RET_OK);
+    return true;
+}
+
+IMPL_LINK(ScDPSubtotalDlg, ClickHdl, weld::Button&, rBtn, void)
+{
+    if (&rBtn == mxBtnOptions.get())
+    {
+        mxOptionsDlg = std::make_shared<ScDPSubtotalOptDlg>(m_xDialog.get(), mrDPObj, maLabelData, mrDataFields, mbEnableLayout);
+
+        weld::DialogController::runAsync(mxOptionsDlg, [this](int nResult) {
+            if (nResult == RET_OK)
+                mxOptionsDlg->FillLabelData(maLabelData);
+            mxOptionsDlg = nullptr;
+        });
+    }
+}
+
+namespace
+{
+    int FromDataPilotFieldLayoutMode(int eMode)
+    {
+        switch (eMode)
+        {
+            case DataPilotFieldLayoutMode::TABULAR_LAYOUT:
+                return 0;
+            case DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_TOP:
+                return 1;
+            case DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_BOTTOM:
+                return 2;
+        }
+        return -1;
+    }
+
+    int ToDataPilotFieldLayoutMode(int nPos)
+    {
+        switch (nPos)
+        {
+            case 0:
+                return DataPilotFieldLayoutMode::TABULAR_LAYOUT;
+            case 1:
+                return DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_TOP;
+            case 2:
+                return DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_BOTTOM;
+        }
+        return DataPilotFieldLayoutMode::TABULAR_LAYOUT;
+    }
+
+    int FromDataPilotFieldShowItemsMode(int eMode)
+    {
+        switch (eMode)
+        {
+            case DataPilotFieldShowItemsMode::FROM_TOP:
+                return 0;
+            case DataPilotFieldShowItemsMode::FROM_BOTTOM:
+                return 1;
+        }
+        return -1;
+    }
+
+    int ToDataPilotFieldShowItemsMode(int nPos)
+    {
+        switch (nPos)
+        {
+            case 0:
+                return DataPilotFieldShowItemsMode::FROM_TOP;
+            case 1:
+                return DataPilotFieldShowItemsMode::FROM_BOTTOM;
+        }
+        return DataPilotFieldShowItemsMode::FROM_TOP;
+    }
+}
+
+ScDPSubtotalOptDlg::ScDPSubtotalOptDlg(weld::Window* pParent, ScDPObject& rDPObj,
+        const ScDPLabelData& rLabelData, const ScDPNameVec& rDataFields,
+        bool bEnableLayout )
+    : GenericDialogController(pParent, "modules/scalc/ui/datafieldoptionsdialog.ui",
+                              "DataFieldOptionsDialog")
+    , m_xLbSortBy(m_xBuilder->weld_combo_box("sortby"))
+    , m_xRbSortAsc(m_xBuilder->weld_radio_button("ascending"))
+    , m_xRbSortDesc(m_xBuilder->weld_radio_button("descending"))
+    , m_xRbSortMan(m_xBuilder->weld_radio_button("manual"))
+    , m_xLayoutFrame(m_xBuilder->weld_widget("layoutframe"))
+    , m_xLbLayout(m_xBuilder->weld_combo_box("layout"))
+    , m_xCbLayoutEmpty(m_xBuilder->weld_check_button("emptyline"))
+    , m_xCbRepeatItemLabels(m_xBuilder->weld_check_button("repeatitemlabels"))
+    , m_xCbShow(m_xBuilder->weld_check_button("show"))
+    , m_xNfShow(m_xBuilder->weld_spin_button("items"))
+    , m_xFtShow(m_xBuilder->weld_label("showft"))
+    , m_xFtShowFrom(m_xBuilder->weld_label("showfromft"))
+    , m_xLbShowFrom(m_xBuilder->weld_combo_box("from"))
+    , m_xFtShowUsing(m_xBuilder->weld_label("usingft"))
+    , m_xLbShowUsing(m_xBuilder->weld_combo_box("using"))
+    , m_xHideFrame(m_xBuilder->weld_widget("hideframe"))
+    , m_xLbHide(m_xBuilder->weld_tree_view("hideitems"))
+    , m_xFtHierarchy(m_xBuilder->weld_label("hierarchyft"))
+    , m_xLbHierarchy(m_xBuilder->weld_combo_box("hierarchy"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel"))
+    , mrDPObj(rDPObj)
+    , maLabelData(rLabelData)
+{
+    m_xLbHide->enable_toggle_buttons(weld::ColumnToggleType::Check);
+
+    m_xLbSortBy->set_size_request(m_xLbSortBy->get_approximate_digit_width() * 18, -1);
+    m_xLbHide->set_size_request(-1, m_xLbHide->get_height_rows(5));
+    Init(rDataFields, bEnableLayout);
+}
+
+ScDPSubtotalOptDlg::~ScDPSubtotalOptDlg()
+{
+}
+
+void ScDPSubtotalOptDlg::FillLabelData( ScDPLabelData& rLabelData ) const
+{
+    // *** SORTING ***
+
+    if (m_xRbSortMan->get_active())
+        rLabelData.maSortInfo.Mode = DataPilotFieldSortMode::MANUAL;
+    else if (m_xLbSortBy->get_active() == SC_SORTNAME_POS)
+        rLabelData.maSortInfo.Mode = DataPilotFieldSortMode::NAME;
+    else
+        rLabelData.maSortInfo.Mode = DataPilotFieldSortMode::DATA;
+
+    ScDPName aFieldName = GetFieldName(m_xLbSortBy->get_active_text());
+    if (!aFieldName.maName.isEmpty())
+    {
+        rLabelData.maSortInfo.Field =
+            ScDPUtil::createDuplicateDimensionName(aFieldName.maName, aFieldName.mnDupCount);
+        rLabelData.maSortInfo.IsAscending = m_xRbSortAsc->get_active();
+    }
+
+    // *** LAYOUT MODE ***
+
+    rLabelData.maLayoutInfo.LayoutMode = ToDataPilotFieldLayoutMode(m_xLbLayout->get_active());
+    rLabelData.maLayoutInfo.AddEmptyLines = m_xCbLayoutEmpty->get_active();
+    rLabelData.mbRepeatItemLabels = m_xCbRepeatItemLabels->get_active();
+
+    // *** AUTO SHOW ***
+
+    aFieldName = GetFieldName(m_xLbShowUsing->get_active_text());
+    if (!aFieldName.maName.isEmpty())
+    {
+        rLabelData.maShowInfo.IsEnabled = m_xCbShow->get_active();
+        rLabelData.maShowInfo.ShowItemsMode = ToDataPilotFieldShowItemsMode(m_xLbShowFrom->get_active());
+        rLabelData.maShowInfo.ItemCount = sal::static_int_cast<sal_Int32>( m_xNfShow->get_value() );
+        rLabelData.maShowInfo.DataField =
+            ScDPUtil::createDuplicateDimensionName(aFieldName.maName, aFieldName.mnDupCount);
+    }
+
+    // *** HIDDEN ITEMS ***
+
+    rLabelData.maMembers = maLabelData.maMembers;
+    int nVisCount = m_xLbHide->n_children();
+    for (int nPos = 0; nPos < nVisCount; ++nPos)
+        rLabelData.maMembers[nPos].mbVisible = m_xLbHide->get_toggle(nPos) == TRISTATE_FALSE;
+
+    // *** HIERARCHY ***
+
+    rLabelData.mnUsedHier = m_xLbHierarchy->get_active() != -1 ? m_xLbHierarchy->get_active() : 0;
+}
+
+void ScDPSubtotalOptDlg::Init( const ScDPNameVec& rDataFields, bool bEnableLayout )
+{
+    m_xBtnOk->connect_clicked(LINK(this, ScDPSubtotalOptDlg, ButtonClicked));
+    m_xBtnCancel->connect_clicked(LINK(this, ScDPSubtotalOptDlg, ButtonClicked));
+
+    // *** SORTING ***
+
+    sal_Int32 nSortMode = maLabelData.maSortInfo.Mode;
+
+    // sort fields list box
+    m_xLbSortBy->append_text(maLabelData.getDisplayName());
+
+    for( const auto& rDataField : rDataFields )
+    {
+        // Cache names for later lookup.
+        maDataFieldNameMap.emplace(rDataField.maLayoutName, rDataField);
+
+        m_xLbSortBy->append_text(rDataField.maLayoutName);
+        m_xLbShowUsing->append_text(rDataField.maLayoutName);  // for AutoShow
+    }
+
+    sal_Int32 nSortPos = SC_SORTNAME_POS;
+    if( nSortMode == DataPilotFieldSortMode::DATA )
+    {
+        nSortPos = FindListBoxEntry( *m_xLbSortBy, maLabelData.maSortInfo.Field, SC_SORTDATA_POS );
+        if( nSortPos == -1 )
+        {
+            nSortPos = SC_SORTNAME_POS;
+            nSortMode = DataPilotFieldSortMode::MANUAL;
+        }
+    }
+    m_xLbSortBy->set_active(nSortPos);
+
+    // sorting mode
+    m_xRbSortAsc->connect_toggled( LINK( this, ScDPSubtotalOptDlg, RadioClickHdl ) );
+    m_xRbSortDesc->connect_toggled( LINK( this, ScDPSubtotalOptDlg, RadioClickHdl ) );
+    m_xRbSortMan->connect_toggled( LINK( this, ScDPSubtotalOptDlg, RadioClickHdl ) );
+
+    weld::RadioButton* pRBtn = nullptr;
+    switch( nSortMode )
+    {
+        case DataPilotFieldSortMode::NONE:
+        case DataPilotFieldSortMode::MANUAL:
+            pRBtn = m_xRbSortMan.get();
+        break;
+        default:
+            pRBtn = maLabelData.maSortInfo.IsAscending ? m_xRbSortAsc.get() : m_xRbSortDesc.get();
+    }
+    pRBtn->set_active(true);
+    RadioClickHdl(*pRBtn);
+
+    // *** LAYOUT MODE ***
+
+    m_xLayoutFrame->set_sensitive(bEnableLayout);
+
+    m_xLbLayout->set_active(FromDataPilotFieldLayoutMode(maLabelData.maLayoutInfo.LayoutMode));
+    m_xCbLayoutEmpty->set_active( maLabelData.maLayoutInfo.AddEmptyLines );
+    m_xCbRepeatItemLabels->set_active( maLabelData.mbRepeatItemLabels );
+
+    // *** AUTO SHOW ***
+
+    m_xCbShow->set_active( maLabelData.maShowInfo.IsEnabled );
+    m_xCbShow->connect_toggled( LINK( this, ScDPSubtotalOptDlg, CheckHdl ) );
+
+    m_xLbShowFrom->set_active(FromDataPilotFieldShowItemsMode(maLabelData.maShowInfo.ShowItemsMode));
+    tools::Long nCount = static_cast< tools::Long >( maLabelData.maShowInfo.ItemCount );
+    if( nCount < 1 )
+        nCount = SC_SHOW_DEFAULT;
+    m_xNfShow->set_value( nCount );
+
+    // m_xLbShowUsing already filled above
+    m_xLbShowUsing->set_active_text(maLabelData.maShowInfo.DataField);
+    if (m_xLbShowUsing->get_active() == -1)
+        m_xLbShowUsing->set_active(0);
+
+    CheckHdl(*m_xCbShow);      // enable/disable dependent controls
+
+    // *** HIDDEN ITEMS ***
+
+    InitHideListBox();
+
+    // *** HIERARCHY ***
+
+    if( maLabelData.maHiers.getLength() > 1 )
+    {
+        lclFillListBox(*m_xLbHierarchy, maLabelData.maHiers);
+        sal_Int32 nHier = maLabelData.mnUsedHier;
+        if( (nHier < 0) || (nHier >= maLabelData.maHiers.getLength()) ) nHier = 0;
+        m_xLbHierarchy->set_active( nHier );
+        m_xLbHierarchy->connect_changed( LINK( this, ScDPSubtotalOptDlg, SelectHdl ) );
+    }
+    else
+    {
+        m_xFtHierarchy->set_sensitive(false);
+        m_xLbHierarchy->set_sensitive(false);
+    }
+}
+
+void ScDPSubtotalOptDlg::InitHideListBox()
+{
+    m_xLbHide->clear();
+    lclFillListBox(*m_xLbHide, maLabelData.maMembers);
+    size_t n = maLabelData.maMembers.size();
+    for (size_t i = 0; i < n; ++i)
+        m_xLbHide->set_toggle(i, maLabelData.maMembers[i].mbVisible ? TRISTATE_FALSE : TRISTATE_TRUE);
+    bool bEnable = m_xLbHide->n_children() > 0;
+    m_xHideFrame->set_sensitive(bEnable);
+}
+
+ScDPName ScDPSubtotalOptDlg::GetFieldName(const OUString& rLayoutName) const
+{
+    NameMapType::const_iterator itr = maDataFieldNameMap.find(rLayoutName);
+    return itr == maDataFieldNameMap.end() ? ScDPName() : itr->second;
+}
+
+sal_Int32 ScDPSubtotalOptDlg::FindListBoxEntry(
+    const weld::ComboBox& rLBox, std::u16string_view rEntry, sal_Int32 nStartPos ) const
+{
+    sal_Int32 nPos = nStartPos;
+    bool bFound = false;
+    while (nPos < rLBox.get_count())
+    {
+        // translate the displayed field name back to its original field name.
+        ScDPName aName = GetFieldName(rLBox.get_text(nPos));
+        OUString aUnoName = ScDPUtil::createDuplicateDimensionName(aName.maName, aName.mnDupCount);
+        if (aUnoName == rEntry)
+        {
+            bFound = true;
+            break;
+        }
+        ++nPos;
+    }
+    return bFound ? nPos : -1;
+}
+
+IMPL_LINK(ScDPSubtotalOptDlg, ButtonClicked, weld::Button&, rButton, void)
+{
+    if (&rButton == m_xBtnOk.get())
+        response(RET_OK);
+    else
+        response(RET_CANCEL);
+}
+
+IMPL_LINK(ScDPSubtotalOptDlg, RadioClickHdl, weld::Toggleable&, rBtn, void)
+{
+    if (!rBtn.get_active())
+        return;
+
+    m_xLbSortBy->set_sensitive(m_xRbSortMan->get_active());
+}
+
+IMPL_LINK(ScDPSubtotalOptDlg, CheckHdl, weld::Toggleable&, rCBox, void)
+{
+    if (&rCBox == m_xCbShow.get())
+    {
+        bool bEnable = m_xCbShow->get_active();
+        m_xNfShow->set_sensitive( bEnable );
+        m_xFtShow->set_sensitive( bEnable );
+        m_xFtShowFrom->set_sensitive( bEnable );
+        m_xLbShowFrom->set_sensitive( bEnable );
+
+        bool bEnableUsing = bEnable && (m_xLbShowUsing->get_count() > 0);
+        m_xFtShowUsing->set_sensitive(bEnableUsing);
+        m_xLbShowUsing->set_sensitive(bEnableUsing);
+    }
+}
+
+IMPL_LINK_NOARG(ScDPSubtotalOptDlg, SelectHdl, weld::ComboBox&, void)
+{
+    mrDPObj.GetMembers(maLabelData.mnCol, m_xLbHierarchy->get_active(), maLabelData.maMembers);
+    InitHideListBox();
+}
+
+ScDPShowDetailDlg::ScDPShowDetailDlg(weld::Window* pParent, ScDPObject& rDPObj, css::sheet::DataPilotFieldOrientation nOrient)
+    : GenericDialogController(pParent, "modules/scalc/ui/showdetaildialog.ui", "ShowDetail")
+    , mrDPObj(rDPObj)
+    , mxLbDims(m_xBuilder->weld_tree_view("dimsTreeview"))
+{
+    ScDPSaveData* pSaveData = rDPObj.GetSaveData();
+    tools::Long nDimCount = rDPObj.GetDimCount();
+    for (tools::Long nDim=0; nDim<nDimCount; nDim++)
+    {
+        bool bIsDataLayout;
+        sal_Int32 nDimFlags = 0;
+        OUString aName = rDPObj.GetDimName( nDim, bIsDataLayout, &nDimFlags );
+        if ( !bIsDataLayout && !rDPObj.IsDuplicated( nDim ) && ScDPObject::IsOrientationAllowed( nOrient, nDimFlags ) )
+        {
+            const ScDPSaveDimension* pDimension = pSaveData ? pSaveData->GetExistingDimensionByName(aName) : nullptr;
+            if ( !pDimension || (pDimension->GetOrientation() != nOrient) )
+            {
+                if (pDimension)
+                {
+                    const std::optional<OUString> & pLayoutName = pDimension->GetLayoutName();
+                    if (pLayoutName)
+                        aName = *pLayoutName;
+                }
+                mxLbDims->append_text(aName);
+                maNameIndexMap.emplace(aName, nDim);
+            }
+        }
+    }
+    if (mxLbDims->n_children())
+       mxLbDims->select(0);
+
+    mxLbDims->connect_row_activated(LINK(this, ScDPShowDetailDlg, DblClickHdl));
+}
+
+ScDPShowDetailDlg::~ScDPShowDetailDlg()
+{
+}
+
+short ScDPShowDetailDlg::run()
+{
+    return mxLbDims->n_children() ? GenericDialogController::run() : static_cast<short>(RET_CANCEL);
+}
+
+OUString ScDPShowDetailDlg::GetDimensionName() const
+{
+    // Look up the internal dimension name which may be different from the
+    // displayed field name.
+    OUString aSelectedName = mxLbDims->get_selected_text();
+    DimNameIndexMap::const_iterator itr = maNameIndexMap.find(aSelectedName);
+    if (itr == maNameIndexMap.end())
+        // This should never happen!
+        return aSelectedName;
+
+    tools::Long nDim = itr->second;
+    bool bIsDataLayout = false;
+    return mrDPObj.GetDimName(nDim, bIsDataLayout);
+}
+
+IMPL_LINK_NOARG(ScDPShowDetailDlg, DblClickHdl, weld::TreeView&, bool)
+{
+    m_xDialog->response(RET_OK);
+    return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/scendlg.cxx b/sc/source/ui/dbgui/scendlg.cxx
new file mode 100644
index 000000000..543914e14
--- /dev/null
+++ b/sc/source/ui/dbgui/scendlg.cxx
@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <comphelper/string.hxx>
+#include <svx/colorbox.hxx>
+#include <unotools/useroptions.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <unotools/localedatawrapper.hxx>
+
+#include <global.hxx>
+#include <globstr.hrc>
+#include <scresid.hxx>
+#include <tabvwsh.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <scendlg.hxx>
+
+ScNewScenarioDlg::ScNewScenarioDlg(weld::Window* pParent, const OUString& rName, bool bEdit, bool bSheetProtected)
+    : GenericDialogController(pParent, "modules/scalc/ui/scenariodialog.ui", "ScenarioDialog")
+    , aDefScenarioName(rName)
+    , bIsEdit(bEdit)
+    , m_xEdName(m_xBuilder->weld_entry("name"))
+    , m_xEdComment(m_xBuilder->weld_text_view("comment"))
+    , m_xCbShowFrame(m_xBuilder->weld_check_button("showframe"))
+    , m_xLbColor(new ColorListBox(m_xBuilder->weld_menu_button("bordercolor"), [this] { return m_xDialog.get(); }))
+    , m_xCbTwoWay(m_xBuilder->weld_check_button("copyback"))
+    , m_xCbCopyAll(m_xBuilder->weld_check_button("copysheet"))
+    , m_xCbProtect(m_xBuilder->weld_check_button("preventchanges"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xAltTitle(m_xBuilder->weld_label("alttitle"))
+    , m_xCreatedFt(m_xBuilder->weld_label("createdft"))
+    , m_xOnFt(m_xBuilder->weld_label("onft"))
+{
+    m_xEdComment->set_size_request(m_xEdComment->get_approximate_digit_width() * 60,
+                                   m_xEdComment->get_height_rows(6));
+
+    if (bIsEdit)
+        m_xDialog->set_title(m_xAltTitle->get_label());
+
+    SvtUserOptions aUserOpt;
+
+    OUString sCreatedBy(m_xCreatedFt->get_label());
+    OUString sOn(m_xOnFt->get_label());
+
+    OUString aComment(sCreatedBy + " " + aUserOpt.GetFirstName() + " " +aUserOpt.GetLastName()
+              + ", " + sOn + " " + ScGlobal::getLocaleData().getDate(Date(Date::SYSTEM))
+              + ", " + ScGlobal::getLocaleData().getTime(tools::Time(tools::Time::SYSTEM)));
+
+    m_xEdComment->set_text(aComment);
+    m_xEdName->set_text(rName);
+    m_xBtnOk->connect_clicked(LINK(this, ScNewScenarioDlg, OkHdl));
+    m_xCbShowFrame->connect_toggled(LINK(this, ScNewScenarioDlg, EnableHdl));
+
+    m_xLbColor->SelectEntry( COL_LIGHTGRAY );
+    m_xCbShowFrame->set_active(true);
+    m_xCbTwoWay->set_active(true);
+    m_xCbCopyAll->set_active(false);
+    m_xCbProtect->set_active(true);
+
+    if (bIsEdit)
+        m_xCbCopyAll->set_active(false);
+    // If the Sheet is protected then we disable the Scenario Protect input
+    // and default it to true above. Note we are in 'Add' mode here as: if
+    // Sheet && scenario protection are true, then we cannot edit this dialog.
+    if (bSheetProtected)
+        m_xCbProtect->set_active(false);
+}
+
+ScNewScenarioDlg::~ScNewScenarioDlg()
+{
+}
+
+void ScNewScenarioDlg::GetScenarioData( OUString& rName, OUString& rComment,
+                                        Color& rColor, ScScenarioFlags& rFlags ) const
+{
+    rComment = m_xEdComment->get_text();
+    rName    = m_xEdName->get_text();
+
+    if (rName.isEmpty())
+        rName = aDefScenarioName;
+
+    rColor = m_xLbColor->GetSelectEntryColor();
+    ScScenarioFlags nBits = ScScenarioFlags::NONE;
+    if (m_xCbShowFrame->get_active())
+        nBits |= ScScenarioFlags::ShowFrame;
+    if (m_xCbTwoWay->get_active())
+        nBits |= ScScenarioFlags::TwoWay;
+    if (m_xCbCopyAll->get_active())
+        nBits |= ScScenarioFlags::CopyAll;
+    if (m_xCbProtect->get_active())
+        nBits |= ScScenarioFlags::Protected;
+    rFlags = nBits;
+}
+
+void ScNewScenarioDlg::SetScenarioData(const OUString& rName, const OUString& rComment,
+                                        const Color& rColor, ScScenarioFlags nFlags)
+{
+    m_xEdComment->set_text(rComment);
+    m_xEdName->set_text(rName);
+    m_xLbColor->SelectEntry(rColor);
+
+    m_xCbShowFrame->set_active( (nFlags & ScScenarioFlags::ShowFrame) != ScScenarioFlags::NONE );
+    EnableHdl(*m_xCbShowFrame);
+    m_xCbTwoWay->set_active( (nFlags & ScScenarioFlags::TwoWay)    != ScScenarioFlags::NONE );
+    //  not CopyAll
+    m_xCbProtect->set_active( (nFlags & ScScenarioFlags::Protected) != ScScenarioFlags::NONE );
+}
+
+IMPL_LINK_NOARG(ScNewScenarioDlg, OkHdl, weld::Button&, void)
+{
+    OUString      aName = comphelper::string::strip(m_xEdName->get_text(), ' ');
+    ScDocument& rDoc    = static_cast<ScTabViewShell*>(SfxViewShell::Current())->GetViewData().GetDocument();
+
+    m_xEdName->set_text(aName);
+
+    if ( !ScDocument::ValidTabName( aName ) )
+    {
+        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                      VclMessageType::Info, VclButtonsType::Ok,
+                                                      ScResId(STR_INVALIDTABNAME)));
+        xInfoBox->run();
+        m_xEdName->grab_focus();
+    }
+    else if ( !bIsEdit && !rDoc.ValidNewTabName( aName ) )
+    {
+        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                      VclMessageType::Info, VclButtonsType::Ok,
+                                                      ScResId(STR_NEWTABNAMENOTUNIQUE)));
+        xInfoBox->run();
+        m_xEdName->grab_focus();
+    }
+    else
+        m_xDialog->response(RET_OK);
+
+    //! when editing, test whether another table has the name!
+}
+
+IMPL_LINK(ScNewScenarioDlg, EnableHdl, weld::Toggleable&, rBox, void)
+{
+    if (&rBox == m_xCbShowFrame.get())
+        m_xLbColor->set_sensitive(m_xCbShowFrame->get_active());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/scuiasciiopt.cxx b/sc/source/ui/dbgui/scuiasciiopt.cxx
new file mode 100644
index 000000000..126689d7b
--- /dev/null
+++ b/sc/source/ui/dbgui/scuiasciiopt.cxx
@@ -0,0 +1,943 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <svx/txencbox.hxx>
+
+#include <global.hxx>
+#include <scresid.hxx>
+#include <impex.hxx>
+#include <scuiasciiopt.hxx>
+#include <strings.hrc>
+#include <strings.hxx>
+#include <csvtablebox.hxx>
+#include <osl/thread.h>
+#include <unotools/transliterationwrapper.hxx>
+
+#include <optutil.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <miscuno.hxx>
+#include <osl/diagnose.h>
+#include <vcl/svapp.hxx>
+#include <comphelper/lok.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <unicode/ucsdet.h>
+
+//! TODO make dynamic
+const SCSIZE ASCIIDLG_MAXROWS                = MAXROWCOUNT;
+
+// Maximum number of source lines to concatenate while generating the preview
+// for one logical line. This may result in a wrong preview if the actual
+// number of embedded line feeds is greater, but a number too high would take
+// too much time (loop excessively if unlimited and large data) if none of the
+// selected separators are actually used in data but a field at start of line
+// is quoted.
+constexpr sal_uInt32 kMaxEmbeddedLinefeeds = 500;
+
+using namespace com::sun::star::uno;
+
+namespace {
+
+// Defines - CSV Import Preserve Options
+// For usage of index order see lcl_CreatePropertiesNames() below.
+enum CSVImportOptionsIndex
+{
+    CSVIO_MergeDelimiters = 0,
+    CSVIO_Separators,
+    CSVIO_TextSeparators,
+    CSVIO_FixedWidth,
+    CSVIO_RemoveSpace,
+    CSVIO_EvaluateFormulas,
+    // Settings for *all* dialog invocations above.
+    // Settings not for SC_TEXTTOCOLUMNS below.
+    CSVIO_FromRow,
+    CSVIO_Text2ColSkipEmptyCells = CSVIO_FromRow,
+    CSVIO_CharSet,
+    CSVIO_QuotedAsText,
+    CSVIO_DetectSpecialNum,
+    CSVIO_Language,
+    // Plus one not for SC_IMPORTFILE.
+    CSVIO_PasteSkipEmptyCells
+};
+
+}
+
+// Config items for all three paths are defined in
+// officecfg/registry/schema/org/openoffice/Office/Calc.xcs
+// If not, options are neither loaded nor saved.
+const ::std::vector<OUString> CSVImportOptionNames =
+{
+    "MergeDelimiters",
+    "Separators",
+    "TextSeparators",
+    "FixedWidth",
+    "RemoveSpace",
+    "EvaluateFormulas",
+    "FromRow",
+    "CharSet",
+    "QuotedFieldAsText",
+    "DetectSpecialNumbers",
+    "Language",
+    "SkipEmptyCells"
+};
+constexpr OUStringLiteral aSep_Path =           u"Office.Calc/Dialogs/CSVImport";
+constexpr OUStringLiteral aSep_Path_Clpbrd =    u"Office.Calc/Dialogs/ClipboardTextImport";
+constexpr OUStringLiteral aSep_Path_Text2Col =  u"Office.Calc/Dialogs/TextToColumnsImport";
+
+namespace {
+CSVImportOptionsIndex getSkipEmptyCellsIndex( ScImportAsciiCall eCall )
+{
+    return eCall == SC_TEXTTOCOLUMNS ? CSVIO_Text2ColSkipEmptyCells : CSVIO_PasteSkipEmptyCells;
+}
+}
+
+static void lcl_FillCombo(weld::ComboBox& rCombo, std::u16string_view rList, sal_Unicode cSelect)
+{
+    OUString aStr;
+    if (!rList.empty())
+    {
+        sal_Int32 nIdx {0};
+        do
+        {
+            const OUString sEntry {o3tl::getToken(rList, 0, '\t', nIdx)};
+            rCombo.append_text(sEntry);
+            if (nIdx>0 && static_cast<sal_Unicode>(o3tl::toInt32(o3tl::getToken(rList, 0, '\t', nIdx))) == cSelect)
+                aStr = sEntry;
+        }
+        while (nIdx>0);
+    }
+
+    if ( cSelect )
+    {
+        if (aStr.isEmpty())
+            aStr = OUString(cSelect);         // Ascii
+
+        rCombo.set_entry_text(aStr);
+    }
+}
+
+static sal_Unicode lcl_CharFromCombo(const weld::ComboBox& rCombo, std::u16string_view rList)
+{
+    sal_Unicode c = 0;
+    OUString aStr = rCombo.get_active_text();
+    if ( !aStr.isEmpty() && !rList.empty() )
+    {
+        sal_Int32 nIdx {0};
+        OUString sToken {o3tl::getToken(rList, 0, '\t', nIdx)};
+        while (nIdx>0)
+        {
+            if ( ScGlobal::GetTransliteration().isEqual( aStr, sToken ) )
+            {
+                sal_Int32 nTmpIdx {nIdx};
+                c = static_cast<sal_Unicode>(o3tl::toInt32(o3tl::getToken(rList, 0, '\t', nTmpIdx)));
+            }
+            // Skip to next token at even position
+            sToken = o3tl::getToken(rList, 1, '\t', nIdx);
+        }
+        if (!c)
+        {
+            sal_Unicode cFirst = aStr[0];
+            // #i24235# first try the first character of the string directly
+            if( (aStr.getLength() == 1) || (cFirst < '0') || (cFirst > '9') )
+                c = cFirst;
+            else    // keep old behaviour for compatibility (i.e. "39" -> "'")
+                c = static_cast<sal_Unicode>(aStr.toInt32());       // Ascii
+        }
+    }
+    return c;
+}
+
+static void lcl_CreatePropertiesNames ( OUString& rSepPath, Sequence<OUString>& rNames, ScImportAsciiCall eCall )
+{
+    sal_Int32 nProperties = 0;
+
+    switch(eCall)
+    {
+        case SC_IMPORTFILE:
+            rSepPath = aSep_Path;
+            nProperties = 11;
+            break;
+        case SC_PASTETEXT:
+            rSepPath = aSep_Path_Clpbrd;
+            nProperties = 12;
+            break;
+        case SC_TEXTTOCOLUMNS:
+        default:
+            rSepPath = aSep_Path_Text2Col;
+            nProperties = 7;
+            break;
+    }
+    rNames.realloc( nProperties );
+    OUString* pNames = rNames.getArray();
+    pNames[ CSVIO_MergeDelimiters ] =   CSVImportOptionNames[ CSVIO_MergeDelimiters ];
+    pNames[ CSVIO_Separators ] =        CSVImportOptionNames[ CSVIO_Separators ];
+    pNames[ CSVIO_TextSeparators ] =    CSVImportOptionNames[ CSVIO_TextSeparators ];
+    pNames[ CSVIO_FixedWidth ] =        CSVImportOptionNames[ CSVIO_FixedWidth ];
+    pNames[ CSVIO_RemoveSpace ] =       CSVImportOptionNames[ CSVIO_RemoveSpace ];
+    pNames[ CSVIO_EvaluateFormulas ] =  CSVImportOptionNames[ CSVIO_EvaluateFormulas ];
+    if (eCall != SC_TEXTTOCOLUMNS)
+    {
+        pNames[ CSVIO_FromRow ] =       CSVImportOptionNames[ CSVIO_FromRow ];
+        pNames[ CSVIO_CharSet ] =       CSVImportOptionNames[ CSVIO_CharSet ];
+        pNames[ CSVIO_QuotedAsText ] =  CSVImportOptionNames[ CSVIO_QuotedAsText ];
+        pNames[ CSVIO_DetectSpecialNum ] = CSVImportOptionNames[ CSVIO_DetectSpecialNum ];
+        pNames[ CSVIO_Language ] =      CSVImportOptionNames[ CSVIO_Language ];
+    }
+    if (eCall != SC_IMPORTFILE)
+    {
+        const sal_Int32 nSkipEmptyCells = getSkipEmptyCellsIndex(eCall);
+        assert( nSkipEmptyCells < rNames.getLength());
+        pNames[ nSkipEmptyCells ] = CSVImportOptionNames[ CSVIO_PasteSkipEmptyCells ];
+    }
+}
+
+static void lcl_LoadSeparators( OUString& rFieldSeparators, OUString& rTextSeparators,
+                             bool& rMergeDelimiters, bool& rQuotedAsText, bool& rDetectSpecialNum,
+                             bool& rFixedWidth, sal_Int32& rFromRow, sal_Int32& rCharSet,
+                             sal_Int32& rLanguage, bool& rSkipEmptyCells, bool& rRemoveSpace,
+                             bool& rEvaluateFormulas, ScImportAsciiCall eCall )
+{
+    Sequence<Any>aValues;
+    const Any *pProperties;
+    Sequence<OUString> aNames;
+    OUString aSepPath;
+    lcl_CreatePropertiesNames ( aSepPath, aNames, eCall);
+    ScLinkConfigItem aItem( aSepPath );
+    aValues = aItem.GetProperties( aNames );
+    pProperties = aValues.getConstArray();
+
+    if( pProperties[ CSVIO_MergeDelimiters ].hasValue() )
+        rMergeDelimiters = ScUnoHelpFunctions::GetBoolFromAny( pProperties[ CSVIO_MergeDelimiters ] );
+
+    if( pProperties[ CSVIO_RemoveSpace ].hasValue() )
+        rRemoveSpace = ScUnoHelpFunctions::GetBoolFromAny( pProperties[ CSVIO_RemoveSpace ] );
+
+    if( pProperties[ CSVIO_Separators ].hasValue() )
+        pProperties[ CSVIO_Separators ] >>= rFieldSeparators;
+
+    if( pProperties[ CSVIO_TextSeparators ].hasValue() )
+        pProperties[ CSVIO_TextSeparators ] >>= rTextSeparators;
+
+    if( pProperties[ CSVIO_FixedWidth ].hasValue() )
+        rFixedWidth = ScUnoHelpFunctions::GetBoolFromAny( pProperties[ CSVIO_FixedWidth ] );
+
+    if( pProperties[ CSVIO_EvaluateFormulas ].hasValue() )
+        rEvaluateFormulas = ScUnoHelpFunctions::GetBoolFromAny( pProperties[ CSVIO_EvaluateFormulas ] );
+
+    if (eCall != SC_TEXTTOCOLUMNS)
+    {
+        if( pProperties[ CSVIO_FromRow ].hasValue() )
+            pProperties[ CSVIO_FromRow ] >>= rFromRow;
+
+        if( pProperties[ CSVIO_CharSet ].hasValue() )
+            pProperties[ CSVIO_CharSet ] >>= rCharSet;
+
+        if ( pProperties[ CSVIO_QuotedAsText ].hasValue() )
+            pProperties[ CSVIO_QuotedAsText ] >>= rQuotedAsText;
+
+        if ( pProperties[ CSVIO_DetectSpecialNum ].hasValue() )
+            pProperties[ CSVIO_DetectSpecialNum ] >>= rDetectSpecialNum;
+
+        if ( pProperties[ CSVIO_Language ].hasValue() )
+            pProperties[ CSVIO_Language ] >>= rLanguage;
+    }
+    if (eCall != SC_IMPORTFILE)
+    {
+        const sal_Int32 nSkipEmptyCells = getSkipEmptyCellsIndex(eCall);
+        assert( nSkipEmptyCells < aValues.getLength());
+        if ( pProperties[nSkipEmptyCells].hasValue() )
+            rSkipEmptyCells = ScUnoHelpFunctions::GetBoolFromAny( pProperties[nSkipEmptyCells] );
+    }
+}
+
+static void lcl_SaveSeparators(
+    const OUString& sFieldSeparators, const OUString& sTextSeparators, bool bMergeDelimiters, bool bQuotedAsText,
+    bool bDetectSpecialNum, bool bFixedWidth, sal_Int32 nFromRow,
+    sal_Int32 nCharSet, sal_Int32 nLanguage, bool bSkipEmptyCells, bool bRemoveSpace, bool bEvaluateFormulas,
+    ScImportAsciiCall eCall )
+{
+    Sequence<Any> aValues;
+    Any *pProperties;
+    Sequence<OUString> aNames;
+    OUString aSepPath;
+    lcl_CreatePropertiesNames ( aSepPath, aNames, eCall );
+    ScLinkConfigItem aItem( aSepPath );
+    aValues = aItem.GetProperties( aNames );
+    pProperties = aValues.getArray();
+
+    pProperties[ CSVIO_MergeDelimiters ] <<= bMergeDelimiters;
+    pProperties[ CSVIO_RemoveSpace ] <<= bRemoveSpace;
+    pProperties[ CSVIO_Separators ] <<= sFieldSeparators;
+    pProperties[ CSVIO_TextSeparators ] <<= sTextSeparators;
+    pProperties[ CSVIO_FixedWidth ] <<= bFixedWidth;
+    pProperties[ CSVIO_EvaluateFormulas ] <<= bEvaluateFormulas;
+    if (eCall != SC_TEXTTOCOLUMNS)
+    {
+        pProperties[ CSVIO_FromRow ] <<= nFromRow;
+        pProperties[ CSVIO_CharSet ] <<= nCharSet;
+        pProperties[ CSVIO_QuotedAsText ] <<= bQuotedAsText;
+        pProperties[ CSVIO_DetectSpecialNum ] <<= bDetectSpecialNum;
+        pProperties[ CSVIO_Language ] <<= nLanguage;
+    }
+    if (eCall != SC_IMPORTFILE)
+    {
+        const sal_Int32 nSkipEmptyCells = getSkipEmptyCellsIndex(eCall);
+        assert( nSkipEmptyCells < aValues.getLength());
+        pProperties[ nSkipEmptyCells ] <<= bSkipEmptyCells;
+    }
+
+    aItem.PutProperties(aNames, aValues);
+}
+
+ScImportAsciiDlg::ScImportAsciiDlg(weld::Window* pParent, const OUString& aDatName,
+                                   SvStream* pInStream, ScImportAsciiCall eCall)
+    : GenericDialogController(pParent, "modules/scalc/ui/textimportcsv.ui", "TextImportCsvDialog")
+    , mpDatStream(pInStream)
+    , mnStreamPos(pInStream ? pInStream->Tell() : 0)
+    , mnRowPosCount(0)
+    , mcTextSep(ScAsciiOptions::cDefaultTextSep)
+    , meCall(eCall)
+    , mbDetectSep(eCall != SC_TEXTTOCOLUMNS)
+    , mxFtCharSet(m_xBuilder->weld_label("textcharset"))
+    , mxLbCharSet(new SvxTextEncodingBox(m_xBuilder->weld_combo_box("charset")))
+    , mxFtCustomLang(m_xBuilder->weld_label("textlanguage"))
+    , mxLbCustomLang(new SvxLanguageBox(m_xBuilder->weld_combo_box("language")))
+    , mxFtRow(m_xBuilder->weld_label("textfromrow"))
+    , mxNfRow(m_xBuilder->weld_spin_button("fromrow"))
+    , mxRbFixed(m_xBuilder->weld_radio_button("tofixedwidth"))
+    , mxRbSeparated(m_xBuilder->weld_radio_button("toseparatedby"))
+    , mxCkbTab(m_xBuilder->weld_check_button("tab"))
+    , mxCkbSemicolon(m_xBuilder->weld_check_button("semicolon"))
+    , mxCkbComma(m_xBuilder->weld_check_button("comma"))
+    , mxCkbRemoveSpace(m_xBuilder->weld_check_button("removespace"))
+    , mxCkbSpace(m_xBuilder->weld_check_button("space"))
+    , mxCkbOther(m_xBuilder->weld_check_button("other"))
+    , mxEdOther(m_xBuilder->weld_entry("inputother"))
+    , mxCkbAsOnce(m_xBuilder->weld_check_button("mergedelimiters"))
+    , mxFtTextSep(m_xBuilder->weld_label("texttextdelimiter"))
+    , mxCbTextSep(m_xBuilder->weld_combo_box("textdelimiter"))
+    , mxCkbQuotedAsText(m_xBuilder->weld_check_button("quotedfieldastext"))
+    , mxCkbDetectNumber(m_xBuilder->weld_check_button("detectspecialnumbers"))
+    , mxCkbEvaluateFormulas(m_xBuilder->weld_check_button("evaluateformulas"))
+    , mxCkbSkipEmptyCells(m_xBuilder->weld_check_button("skipemptycells"))
+    , mxFtType(m_xBuilder->weld_label("textcolumntype"))
+    , mxLbType(m_xBuilder->weld_combo_box("columntype"))
+    , mxAltTitle(m_xBuilder->weld_label("textalttitle"))
+    , mxTableBox(new ScCsvTableBox(*m_xBuilder))
+{
+    OUString aName = m_xDialog->get_title();
+    switch (meCall)
+    {
+        case SC_TEXTTOCOLUMNS:
+            m_xDialog->set_title(mxAltTitle->get_label());
+            break;
+        case SC_IMPORTFILE:
+            if (!comphelper::LibreOfficeKit::isActive())
+            {
+                aName += " - [" + aDatName + "]";
+                m_xDialog->set_title(aName);
+            }
+            break;
+        default:
+            break;
+    }
+
+    // To be able to prefill the correct values based on the file extension
+    bool bIsTSV = (aDatName.endsWithIgnoreAsciiCase(".tsv") || aDatName.endsWithIgnoreAsciiCase(".tab"));
+
+    // Default options are set in officecfg/registry/schema/org/openoffice/Office/Calc.xcs
+    OUString sFieldSeparators(",;\t");
+    OUString sTextSeparators(mcTextSep);
+    bool bMergeDelimiters = false;
+    bool bFixedWidth = false;
+    bool bQuotedFieldAsText = false;
+    bool bDetectSpecialNum = true;
+    bool bEvaluateFormulas = (meCall != SC_IMPORTFILE);
+    bool bSkipEmptyCells = true;
+    bool bRemoveSpace = false;
+    sal_Int32 nFromRow = 1;
+    sal_Int32 nCharSet = -1;
+    sal_Int32 nLanguage = 0;
+    lcl_LoadSeparators (sFieldSeparators, sTextSeparators, bMergeDelimiters,
+                         bQuotedFieldAsText, bDetectSpecialNum, bFixedWidth, nFromRow,
+                         nCharSet, nLanguage, bSkipEmptyCells, bRemoveSpace, bEvaluateFormulas, meCall);
+    // load from saved settings
+    maFieldSeparators = sFieldSeparators;
+
+    if( bMergeDelimiters && !bIsTSV )
+        mxCkbAsOnce->set_active(true);
+    if (bQuotedFieldAsText)
+        mxCkbQuotedAsText->set_active(true);
+    if (bRemoveSpace)
+        mxCkbRemoveSpace->set_active(true);
+    if (bDetectSpecialNum)
+        mxCkbDetectNumber->set_active(true);
+    if (bEvaluateFormulas)
+        mxCkbEvaluateFormulas->set_active(true);
+    if (bSkipEmptyCells)
+        mxCkbSkipEmptyCells->set_active(true);
+    if (bFixedWidth && !bIsTSV)
+        mxRbFixed->set_active(true);
+    if (nFromRow != 1)
+        mxNfRow->set_value(nFromRow);
+
+    // Clipboard is always Unicode, else detect.
+    rtl_TextEncoding ePreselectUnicode = (meCall == SC_IMPORTFILE ?
+            RTL_TEXTENCODING_DONTKNOW : RTL_TEXTENCODING_UNICODE);
+    // Sniff for Unicode / not
+    if( ePreselectUnicode == RTL_TEXTENCODING_DONTKNOW && mpDatStream )
+    {
+        mpDatStream->Seek( 0 );
+        constexpr size_t buffsize = 4096;
+        sal_Int8 bytes[buffsize] = { 0 };
+        sal_Int32 nRead = mpDatStream->ReadBytes( bytes, buffsize );
+        mpDatStream->Seek( 0 );
+
+        if ( nRead > 0 )
+        {
+            UErrorCode uerr = U_ZERO_ERROR;
+            UCharsetDetector* ucd = ucsdet_open( &uerr );
+            ucsdet_setText( ucd, reinterpret_cast<const char*>(bytes), nRead, &uerr );
+
+            if ( const UCharsetMatch* match = ucsdet_detect(ucd, &uerr) )
+            {
+                const char* pEncodingName = ucsdet_getName( match, &uerr );
+
+                if ( U_SUCCESS(uerr) && !strcmp("UTF-8", pEncodingName) )
+                {
+                    ePreselectUnicode = RTL_TEXTENCODING_UTF8; // UTF-8
+                    mpDatStream->StartReadingUnicodeText( RTL_TEXTENCODING_UTF8 );
+                }
+                else if ( U_SUCCESS(uerr) && !strcmp("UTF-16LE", pEncodingName) )
+                {
+                    ePreselectUnicode = RTL_TEXTENCODING_UNICODE; // UTF-16LE
+                    mpDatStream->SetEndian( SvStreamEndian::LITTLE );
+                    mpDatStream->StartReadingUnicodeText( RTL_TEXTENCODING_UNICODE );
+                }
+                else if ( U_SUCCESS(uerr) && !strcmp("UTF-16BE", pEncodingName) )
+                {
+                    ePreselectUnicode = RTL_TEXTENCODING_UNICODE; // UTF-16BE
+                    mpDatStream->SetEndian( SvStreamEndian::BIG );
+                    mpDatStream->StartReadingUnicodeText( RTL_TEXTENCODING_UNICODE );
+                }
+                else // other
+                    mpDatStream->StartReadingUnicodeText( RTL_TEXTENCODING_DONTKNOW );
+            }
+
+            ucsdet_close( ucd );
+        }
+
+        mnStreamPos = mpDatStream->Tell();
+    }
+
+    if (bIsTSV)
+        SetSeparators('\t');
+    else
+    {
+        // Some MS-Excel convention is the first line containing the field
+        // separator as "sep=|" (without quotes and any field separator
+        // character). The second possibility seems to be it is present *with*
+        // quotes so it shows up as cell content *including* the separator and
+        // can be preserved during round trips. Check for an exact match of
+        // any such and set separator.
+        /* TODO: it is debatable whether the unquoted form should rather be
+         * treated special to actually include the separator in the field data.
+         * Currently it does not. */
+        sal_Unicode cSep = 0;
+        OUString aLine;
+        // Try to read one more character, if more than 7 it can't be an exact
+        // match of any.
+        mpDatStream->ReadUniOrByteStringLine( aLine, mpDatStream->GetStreamCharSet(), 8);
+        mpDatStream->Seek(mnStreamPos);
+        if (aLine.getLength() == 8)
+            ;   // nothing
+        else if (aLine.getLength() == 5 && aLine.startsWithIgnoreAsciiCase("sep="))
+            cSep = aLine[4];
+        else if (aLine.getLength() == 7 && aLine[6] == '"' && aLine.startsWithIgnoreAsciiCase("\"sep="))
+            cSep = aLine[5];
+
+        // Set Separators in the dialog from maFieldSeparators (empty are not
+        // set) or an optionally defined by file content field separator.
+        SetSeparators(cSep);
+    }
+
+    // Get Separators from the dialog (empty are set from default)
+    maFieldSeparators = GetSeparators();
+
+    mxNfRow->connect_value_changed( LINK( this, ScImportAsciiDlg, FirstRowHdl ) );
+
+    // *** Separator characters ***
+    lcl_FillCombo( *mxCbTextSep, SCSTR_TEXTSEP, mcTextSep );
+    mxCbTextSep->set_entry_text(sTextSeparators);
+    // tdf#69207 - use selected text delimiter to parse the provided data
+    mcTextSep = lcl_CharFromCombo(*mxCbTextSep, SCSTR_TEXTSEP);
+
+    Link<weld::Toggleable&,void> aSeparatorClickHdl =LINK( this, ScImportAsciiDlg, SeparatorClickHdl );
+    mxCbTextSep->connect_changed( LINK( this, ScImportAsciiDlg, SeparatorComboBoxHdl ) );
+    mxCkbTab->connect_toggled( aSeparatorClickHdl );
+    mxCkbSemicolon->connect_toggled( aSeparatorClickHdl );
+    mxCkbComma->connect_toggled( aSeparatorClickHdl );
+    mxCkbAsOnce->connect_toggled( aSeparatorClickHdl );
+    mxCkbQuotedAsText->connect_toggled( aSeparatorClickHdl );
+    mxCkbDetectNumber->connect_toggled( aSeparatorClickHdl );
+    mxCkbEvaluateFormulas->connect_toggled( aSeparatorClickHdl );
+    mxCkbSkipEmptyCells->connect_toggled( aSeparatorClickHdl );
+    mxCkbSpace->connect_toggled( aSeparatorClickHdl );
+    mxCkbRemoveSpace->connect_toggled( aSeparatorClickHdl );
+    mxCkbOther->connect_toggled( aSeparatorClickHdl );
+    mxEdOther->connect_changed(LINK(this, ScImportAsciiDlg, SeparatorEditHdl));
+
+    // *** text encoding ListBox ***
+    // all encodings allowed, including Unicode, but subsets are excluded
+    mxLbCharSet->FillFromTextEncodingTable( true );
+    // Insert one "SYSTEM" entry for compatibility in AsciiOptions and system
+    // independent document linkage.
+    mxLbCharSet->InsertTextEncoding( RTL_TEXTENCODING_DONTKNOW, ScResId( SCSTR_CHARSET_USER ) );
+    if ( ePreselectUnicode == RTL_TEXTENCODING_DONTKNOW )
+    {
+        rtl_TextEncoding eSystemEncoding = osl_getThreadTextEncoding();
+        // Prefer UTF-8, as UTF-16 would have already been detected from the stream.
+        // This gives a better chance that the file is going to be opened correctly.
+        if ( ( eSystemEncoding == RTL_TEXTENCODING_UNICODE ) && mpDatStream )
+            eSystemEncoding = RTL_TEXTENCODING_UTF8;
+        mxLbCharSet->SelectTextEncoding( eSystemEncoding );
+    }
+    else
+    {
+        mxLbCharSet->SelectTextEncoding( ePreselectUnicode );
+    }
+
+    if (nCharSet >= 0 && ePreselectUnicode == RTL_TEXTENCODING_DONTKNOW)
+        mxLbCharSet->set_active(nCharSet);
+
+    SetSelectedCharSet();
+    mxLbCharSet->connect_changed( LINK( this, ScImportAsciiDlg, CharSetHdl ) );
+
+    mxLbCustomLang->SetLanguageList(
+        SvxLanguageListFlags::ALL | SvxLanguageListFlags::ONLY_KNOWN, false, false);
+    mxLbCustomLang->InsertLanguage(LANGUAGE_SYSTEM);
+    mxLbCustomLang->set_active_id(static_cast<LanguageType>(nLanguage));
+
+    // *** column type ListBox ***
+    OUString aColumnUser( ScResId( SCSTR_COLUMN_USER ) );
+    for (sal_Int32 nIdx {0}; nIdx>=0; )
+    {
+        mxLbType->append_text(aColumnUser.getToken(0, ';', nIdx));
+    }
+
+    mxLbType->connect_changed( LINK( this, ScImportAsciiDlg, LbColTypeHdl ) );
+    mxFtType->set_sensitive(false);
+    mxLbType->set_sensitive(false);
+
+    // *** table box preview ***
+    mxTableBox->Init();
+    mxTableBox->SetUpdateTextHdl( LINK( this, ScImportAsciiDlg, UpdateTextHdl ) );
+    mxTableBox->InitTypes( *mxLbType );
+    mxTableBox->SetColTypeHdl( LINK( this, ScImportAsciiDlg, ColTypeHdl ) );
+
+    mxRbSeparated->connect_toggled( LINK( this, ScImportAsciiDlg, RbSepFixHdl ) );
+    mxRbFixed->connect_toggled( LINK( this, ScImportAsciiDlg, RbSepFixHdl ) );
+
+    SetupSeparatorCtrls();
+    RbSepFix();
+
+    UpdateVertical();
+
+    mxTableBox->GetGrid().Execute( CSVCMD_NEWCELLTEXTS );
+
+    if (meCall == SC_TEXTTOCOLUMNS)
+    {
+        mxFtCharSet->set_sensitive(false);
+        mxLbCharSet->set_sensitive(false);
+        mxFtCustomLang->set_sensitive(false);
+        mxLbCustomLang->set_active_id(LANGUAGE_SYSTEM);
+        mxLbCustomLang->set_sensitive(false);
+        mxFtRow->set_sensitive(false);
+        mxNfRow->set_sensitive(false);
+
+        // Quoted field as text option is not used for text-to-columns mode.
+        mxCkbQuotedAsText->set_active(false);
+        mxCkbQuotedAsText->set_sensitive(false);
+
+        // Always detect special numbers for text-to-columns mode.
+        mxCkbDetectNumber->set_active(true);
+        mxCkbDetectNumber->set_sensitive(false);
+    }
+    if (meCall == SC_IMPORTFILE)
+    {
+        //Empty cells in imported file are empty
+        mxCkbSkipEmptyCells->set_active(false);
+        mxCkbSkipEmptyCells->hide();
+    }
+    m_xDialog->SetInstallLOKNotifierHdl(LINK(this, ScImportAsciiDlg, InstallLOKNotifierHdl));
+}
+
+IMPL_STATIC_LINK_NOARG(ScImportAsciiDlg, InstallLOKNotifierHdl, void*, vcl::ILibreOfficeKitNotifier*)
+{
+    return GetpApp();
+}
+
+ScImportAsciiDlg::~ScImportAsciiDlg()
+{
+}
+
+bool ScImportAsciiDlg::GetLine( sal_uLong nLine, OUString &rText, sal_Unicode& rcDetectSep )
+{
+    if (nLine >= ASCIIDLG_MAXROWS || !mpDatStream)
+        return false;
+
+    bool bRet = true;
+    bool bFixed = mxRbFixed->get_active();
+
+    if (!mpRowPosArray)
+        mpRowPosArray.reset( new sal_uLong[ASCIIDLG_MAXROWS + 2] );
+
+    if (!mnRowPosCount) // complete re-fresh
+    {
+        memset( mpRowPosArray.get(), 0, sizeof(mpRowPosArray[0]) * (ASCIIDLG_MAXROWS+2));
+
+        Seek(0);
+        mpDatStream->StartReadingUnicodeText( mpDatStream->GetStreamCharSet() );
+
+        mnStreamPos = mpDatStream->Tell();
+        mpRowPosArray[mnRowPosCount] = mnStreamPos;
+    }
+
+    if (nLine >= mnRowPosCount)
+    {
+        // need to work out some more line information
+        do
+        {
+            if (!Seek(mpRowPosArray[mnRowPosCount]) || !mpDatStream->good())
+            {
+                bRet = false;
+                break;
+            }
+            rText = ReadCsvLine(*mpDatStream, !bFixed, maFieldSeparators,
+                    mcTextSep, rcDetectSep, kMaxEmbeddedLinefeeds);
+            mnStreamPos = mpDatStream->Tell();
+            mpRowPosArray[++mnRowPosCount] = mnStreamPos;
+        } while (nLine >= mnRowPosCount && mpDatStream->good());
+        if (mpDatStream->eof() &&
+                mnStreamPos == mpRowPosArray[mnRowPosCount-1])
+        {
+            // the very end, not even an empty line read
+            bRet = false;
+            --mnRowPosCount;
+        }
+    }
+    else
+    {
+        Seek( mpRowPosArray[nLine]);
+        rText = ReadCsvLine(*mpDatStream, !bFixed, maFieldSeparators, mcTextSep, rcDetectSep, kMaxEmbeddedLinefeeds);
+        mnStreamPos = mpDatStream->Tell();
+    }
+
+    //  If the file content isn't unicode, ReadUniStringLine
+    //  may try to seek beyond the file's end and cause a CANTSEEK error
+    //  (depending on the stream type). The error code has to be cleared,
+    //  or further read operations (including non-unicode) will fail.
+    if ( mpDatStream->GetError() == ERRCODE_IO_CANTSEEK )
+        mpDatStream->ResetError();
+
+    ScImportExport::EmbeddedNullTreatment( rText);
+
+    return bRet;
+}
+
+void ScImportAsciiDlg::GetOptions( ScAsciiOptions& rOpt )
+{
+    rOpt.SetCharSet( meCharSet );
+    rOpt.SetCharSetSystem( mbCharSetSystem );
+    rOpt.SetLanguage(mxLbCustomLang->get_active_id());
+    rOpt.SetFixedLen( mxRbFixed->get_active() );
+    rOpt.SetStartRow( mxNfRow->get_value() );
+    mxTableBox->FillColumnData( rOpt );
+    if( mxRbSeparated->get_active() )
+    {
+        rOpt.SetFieldSeps( GetSeparators() );
+        rOpt.SetMergeSeps( mxCkbAsOnce->get_active() );
+        rOpt.SetRemoveSpace( mxCkbRemoveSpace->get_active() );
+        rOpt.SetTextSep( lcl_CharFromCombo( *mxCbTextSep, SCSTR_TEXTSEP ) );
+    }
+
+    rOpt.SetQuotedAsText(mxCkbQuotedAsText->get_active());
+    rOpt.SetDetectSpecialNumber(mxCkbDetectNumber->get_active());
+    rOpt.SetEvaluateFormulas(mxCkbEvaluateFormulas->get_active());
+    rOpt.SetSkipEmptyCells(mxCkbSkipEmptyCells->get_active());
+}
+
+void ScImportAsciiDlg::SaveParameters()
+{
+    lcl_SaveSeparators( maFieldSeparators, mxCbTextSep->get_active_text(), mxCkbAsOnce->get_active(),
+                     mxCkbQuotedAsText->get_active(), mxCkbDetectNumber->get_active(),
+                     mxRbFixed->get_active(),
+                     mxNfRow->get_value(),
+                     mxLbCharSet->get_active(),
+                     static_cast<sal_uInt16>(mxLbCustomLang->get_active_id()),
+                     mxCkbSkipEmptyCells->get_active(), mxCkbRemoveSpace->get_active(),
+                     mxCkbEvaluateFormulas->get_active(), meCall );
+}
+
+void ScImportAsciiDlg::SetSeparators( sal_Unicode cSep )
+{
+    if (cSep)
+    {
+        // Exclusively set a separator, maFieldSeparators needs not be
+        // modified, it's obtained by GetSeparators() after this call.
+        constexpr sal_Unicode aSeps[] = { '\t', ';', ',', ' ' };
+        for (const sal_Unicode c : aSeps)
+        {
+            const bool bSet = (c == cSep);
+            switch (c)
+            {
+                case '\t':  mxCkbTab->set_active(bSet);        break;
+                case ';':   mxCkbSemicolon->set_active(bSet);  break;
+                case ',':   mxCkbComma->set_active(bSet);      break;
+                case ' ':   mxCkbSpace->set_active(bSet);      break;
+            }
+            if (bSet)
+                cSep = 0;
+        }
+        if (cSep)
+        {
+            mxCkbOther->set_active(true);
+            mxEdOther->set_text(OUStringChar(cSep));
+        }
+    }
+    else
+    {
+        for (sal_Int32 i = 0; i < maFieldSeparators.getLength(); ++i)
+        {
+            switch (maFieldSeparators[i])
+            {
+                case '\t':  mxCkbTab->set_active(true);        break;
+                case ';':   mxCkbSemicolon->set_active(true);  break;
+                case ',':   mxCkbComma->set_active(true);      break;
+                case ' ':   mxCkbSpace->set_active(true);      break;
+                default:
+                            mxCkbOther->set_active(true);
+                            mxEdOther->set_text(mxEdOther->get_text() + OUStringChar(maFieldSeparators[i]));
+            }
+        }
+    }
+}
+
+void ScImportAsciiDlg::SetSelectedCharSet()
+{
+    meCharSet = mxLbCharSet->GetSelectTextEncoding();
+    mbCharSetSystem = (meCharSet == RTL_TEXTENCODING_DONTKNOW);
+    if( mbCharSetSystem )
+        meCharSet = osl_getThreadTextEncoding();
+}
+
+OUString ScImportAsciiDlg::GetSeparators() const
+{
+    OUString aSepChars;
+    if( mxCkbTab->get_active() )
+        aSepChars += "\t";
+    if( mxCkbSemicolon->get_active() )
+        aSepChars += ";";
+    if( mxCkbComma->get_active() )
+        aSepChars += ",";
+    if( mxCkbSpace->get_active() )
+        aSepChars += " ";
+    if( mxCkbOther->get_active() )
+        aSepChars += mxEdOther->get_text();
+    return aSepChars;
+}
+
+void ScImportAsciiDlg::SetupSeparatorCtrls()
+{
+    bool bEnable = mxRbSeparated->get_active();
+    mxCkbTab->set_sensitive( bEnable );
+    mxCkbSemicolon->set_sensitive( bEnable );
+    mxCkbComma->set_sensitive( bEnable );
+    mxCkbSpace->set_sensitive( bEnable );
+    mxCkbRemoveSpace->set_sensitive( bEnable );
+    mxCkbOther->set_sensitive( bEnable );
+    mxEdOther->set_sensitive( bEnable );
+    mxCkbAsOnce->set_sensitive( bEnable );
+    mxFtTextSep->set_sensitive( bEnable );
+    mxCbTextSep->set_sensitive( bEnable );
+}
+
+void ScImportAsciiDlg::UpdateVertical()
+{
+    mnRowPosCount = 0;
+    if (mpDatStream)
+        mpDatStream->SetStreamCharSet(meCharSet);
+}
+
+void ScImportAsciiDlg::RbSepFix()
+{
+    weld::WaitObject aWaitObj(m_xDialog.get());
+    if( mxRbFixed->get_active() )
+        mxTableBox->SetFixedWidthMode();
+    else
+        mxTableBox->SetSeparatorsMode();
+    SetupSeparatorCtrls();
+}
+
+IMPL_LINK(ScImportAsciiDlg, RbSepFixHdl, weld::Toggleable&, rButton, void)
+{
+    if (!rButton.get_active())
+        return;
+    RbSepFix();
+}
+
+IMPL_LINK(ScImportAsciiDlg, SeparatorClickHdl, weld::Toggleable&, rCtrl, void)
+{
+    SeparatorHdl(&rCtrl);
+}
+
+IMPL_LINK( ScImportAsciiDlg, SeparatorComboBoxHdl, weld::ComboBox&, rCtrl, void )
+{
+    SeparatorHdl(&rCtrl);
+}
+
+IMPL_LINK( ScImportAsciiDlg, SeparatorEditHdl, weld::Entry&, rEdit, void )
+{
+    SeparatorHdl(&rEdit);
+}
+
+void ScImportAsciiDlg::SeparatorHdl(const weld::Widget* pCtrl)
+{
+    OSL_ENSURE( pCtrl, "ScImportAsciiDlg::SeparatorHdl - missing sender" );
+    OSL_ENSURE( !mxRbFixed->get_active(), "ScImportAsciiDlg::SeparatorHdl - not allowed in fixed width" );
+
+    /*  #i41550# First update state of the controls. The GetSeparators()
+        function needs final state of the check boxes. */
+    if (pCtrl == mxCkbOther.get() && mxCkbOther->get_active())
+        mxEdOther->grab_focus();
+    else if (pCtrl == mxEdOther.get())
+        mxCkbOther->set_active(!mxEdOther->get_text().isEmpty());
+
+    OUString aOldFldSeps( maFieldSeparators);
+    maFieldSeparators = GetSeparators();
+    sal_Unicode cOldSep = mcTextSep;
+    mcTextSep = lcl_CharFromCombo( *mxCbTextSep, SCSTR_TEXTSEP );
+    // Any separator changed may result in completely different lines due to
+    // embedded line breaks.
+    if (cOldSep != mcTextSep || aOldFldSeps != maFieldSeparators)
+        UpdateVertical();
+
+    mxTableBox->GetGrid().Execute( CSVCMD_NEWCELLTEXTS );
+}
+
+IMPL_LINK_NOARG(ScImportAsciiDlg, CharSetHdl, weld::ComboBox&, void)
+{
+    if (mxLbCharSet->get_active() != -1)
+    {
+        weld::WaitObject aWaitObj(m_xDialog.get());
+        rtl_TextEncoding eOldCharSet = meCharSet;
+        SetSelectedCharSet();
+        // switching char-set invalidates 8bit -> String conversions
+        if (eOldCharSet != meCharSet)
+            UpdateVertical();
+
+        mxTableBox->GetGrid().Execute( CSVCMD_NEWCELLTEXTS );
+    }
+}
+
+IMPL_LINK(ScImportAsciiDlg, FirstRowHdl, weld::SpinButton&, rNumField, void)
+{
+    mxTableBox->GetGrid().Execute( CSVCMD_SETFIRSTIMPORTLINE, rNumField.get_value() - 1);
+}
+
+IMPL_LINK(ScImportAsciiDlg, LbColTypeHdl, weld::ComboBox&, rListBox, void)
+{
+    if (&rListBox == mxLbType.get())
+        mxTableBox->GetGrid().Execute(CSVCMD_SETCOLUMNTYPE, rListBox.get_active());
+}
+
+IMPL_LINK_NOARG(ScImportAsciiDlg, UpdateTextHdl, ScCsvTableBox&, void)
+{
+    // Checking the separator can only be done once for the very first time
+    // when the dialog wasn't already presented to the user.
+    // As a side effect this has the benefit that the check is only done on the
+    // first set of visible lines.
+    mbDetectSep = (mbDetectSep && !mxRbFixed->get_active()
+                && (!mxCkbTab->get_active() || !mxCkbSemicolon->get_active()
+                    || !mxCkbComma->get_active() || !mxCkbSpace->get_active()));
+    sal_Unicode cDetectSep = (mbDetectSep ? 0 : 0xffff);
+
+    sal_Int32 nBaseLine = mxTableBox->GetGrid().GetFirstVisLine();
+    sal_Int32 nRead = mxTableBox->GetGrid().GetVisLineCount();
+    // If mnRowPosCount==0, this is an initializing call, read ahead for row
+    // count and resulting scroll bar size and position to be able to scroll at
+    // all. When adding lines, read only the amount of next lines to be
+    // displayed.
+    if (!mnRowPosCount || nRead > CSV_PREVIEW_LINES)
+        nRead = CSV_PREVIEW_LINES;
+
+    sal_Int32 i;
+    for (i = 0; i < nRead; i++)
+    {
+        if (!GetLine( nBaseLine + i, maPreviewLine[i], cDetectSep))
+            break;
+    }
+    for (; i < CSV_PREVIEW_LINES; i++)
+        maPreviewLine[i].clear();
+
+    if (mbDetectSep)
+    {
+        mbDetectSep = false;
+        if (cDetectSep)
+        {
+            // Expect separator to be appended by now so all subsequent
+            // GetLine()/ReadCsvLine() actually used it.
+            assert(maFieldSeparators.endsWith(OUStringChar(cDetectSep)));
+            // Preselect separator in UI.
+            switch (cDetectSep)
+            {
+                case '\t':  mxCkbTab->set_active(true);         break;
+                case ';':   mxCkbSemicolon->set_active(true);   break;
+                case ',':   mxCkbComma->set_active(true);       break;
+                case ' ':   mxCkbSpace->set_active(true);       break;
+            }
+        }
+    }
+
+    mxTableBox->GetGrid().Execute( CSVCMD_SETLINECOUNT, mnRowPosCount);
+    bool bMergeSep = mxCkbAsOnce->get_active();
+    bool bRemoveSpace = mxCkbRemoveSpace->get_active();
+    mxTableBox->SetUniStrings( maPreviewLine, maFieldSeparators, mcTextSep, bMergeSep, bRemoveSpace );
+}
+
+IMPL_LINK( ScImportAsciiDlg, ColTypeHdl, ScCsvTableBox&, rTableBox, void )
+{
+    sal_Int32 nType = rTableBox.GetSelColumnType();
+    sal_Int32 nTypeCount = mxLbType->get_count();
+    bool bEmpty = (nType == CSV_TYPE_MULTI);
+    bool bEnable = ((0 <= nType) && (nType < nTypeCount)) || bEmpty;
+
+    mxFtType->set_sensitive( bEnable );
+    mxLbType->set_sensitive( bEnable );
+
+    if (bEmpty)
+        mxLbType->set_active(-1);
+    else if (bEnable)
+        mxLbType->set_active(nType);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/scuiimoptdlg.cxx b/sc/source/ui/dbgui/scuiimoptdlg.cxx
new file mode 100644
index 000000000..e04f0b672
--- /dev/null
+++ b/sc/source/ui/dbgui/scuiimoptdlg.cxx
@@ -0,0 +1,340 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <scuiimoptdlg.hxx>
+#include <scresid.hxx>
+#include <strings.hrc>
+#include <strings.hxx>
+#include <officecfg/Office/Calc.hxx>
+#include <osl/thread.h>
+#include <rtl/tencinfo.h>
+#include <imoptdlg.hxx>
+#include <svx/txencbox.hxx>
+#include <o3tl/string_view.hxx>
+
+// ScDelimiterTable
+
+class ScDelimiterTable
+{
+public:
+    explicit ScDelimiterTable( const OUString& rDelTab )
+            :   theDelTab ( rDelTab ),
+                nDelIdx   ( 0 )
+            {}
+
+    sal_uInt16  GetCode( std::u16string_view rDelimiter ) const;
+    OUString  GetDelimiter( sal_Unicode nCode ) const;
+
+    OUString  FirstDel()  { nDelIdx = 0; return theDelTab.getToken( 0, cSep, nDelIdx ); }
+    OUString  NextDel()   { return theDelTab.getToken( 1, cSep, nDelIdx ); }
+
+private:
+    const OUString      theDelTab;
+    static constexpr sal_Unicode cSep {'\t'};
+    sal_Int32           nDelIdx;
+};
+
+sal_uInt16 ScDelimiterTable::GetCode( std::u16string_view rDel ) const
+{
+    if (!theDelTab.isEmpty())
+    {
+        sal_Int32 nIdx {0};
+
+        // Check even tokens: start from 0 and then skip 1 token at each iteration
+        if (rDel != o3tl::getToken(theDelTab, 0, cSep, nIdx ))
+            while (nIdx>0 && rDel != o3tl::getToken(theDelTab, 1, cSep, nIdx ));
+
+        if (nIdx>0)
+            return static_cast<sal_Unicode>(o3tl::toInt32(o3tl::getToken(theDelTab, 0, cSep, nIdx )));
+    }
+
+    return 0;
+}
+
+OUString ScDelimiterTable::GetDelimiter( sal_Unicode nCode ) const
+{
+    if (!theDelTab.isEmpty())
+    {
+        sal_Int32 nIdx {0};
+        // Check odd tokens: start from 1 and then skip 1 token at each iteration
+        do
+        {
+            sal_Int32 nPrevIdx {nIdx};
+            if (nCode == static_cast<sal_Unicode>(o3tl::toInt32(o3tl::getToken(theDelTab, 1, cSep, nIdx ))))
+                return theDelTab.getToken( 0, cSep, nPrevIdx );
+        }
+        while (nIdx>0);
+    }
+
+    return OUString();
+}
+
+void ScImportOptionsDlg::FillFromTextEncodingTable(bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags)
+{
+    if (m_bIsAsciiImport)
+        m_xLbCharset->FillFromTextEncodingTable(bExcludeImportSubsets, nExcludeInfoFlags);
+    else
+        m_xTvCharset->FillFromTextEncodingTable(bExcludeImportSubsets, nExcludeInfoFlags);
+}
+
+void ScImportOptionsDlg::FillFromDbTextEncodingMap(bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags)
+{
+    if (m_bIsAsciiImport)
+        m_xLbCharset->FillFromDbTextEncodingMap(bExcludeImportSubsets, nExcludeInfoFlags);
+    else
+        m_xTvCharset->FillFromDbTextEncodingMap(bExcludeImportSubsets, nExcludeInfoFlags);
+}
+
+// ScImportOptionsDlg
+ScImportOptionsDlg::ScImportOptionsDlg(weld::Window* pParent, bool bAscii,
+                                       const ScImportOptions*  pOptions,
+                                       const OUString* pStrTitle,
+                                       bool bMultiByte, bool bOnlyDbtoolsEncodings,
+                                       bool bImport)
+    : GenericDialogController(pParent, "modules/scalc/ui/imoptdialog.ui", "ImOptDialog")
+    , m_bIsAsciiImport(bAscii)
+    , m_xFieldFrame(m_xBuilder->weld_frame("fieldframe"))
+    , m_xFtCharset(m_xBuilder->weld_label("charsetft"))
+    , m_xEncGrid(m_xBuilder->weld_widget("grid2"))
+    , m_xFtFieldSep(m_xBuilder->weld_label("fieldft"))
+    , m_xEdFieldSep(m_xBuilder->weld_combo_box("field"))
+    , m_xFtTextSep(m_xBuilder->weld_label("textft"))
+    , m_xEdTextSep(m_xBuilder->weld_combo_box("text"))
+    , m_xCbShown(m_xBuilder->weld_check_button("asshown"))
+    , m_xCbFormulas(m_xBuilder->weld_check_button("formulas"))
+    , m_xCbQuoteAll(m_xBuilder->weld_check_button("quoteall"))
+    , m_xCbFixed(m_xBuilder->weld_check_button("fixedwidth"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xLbCharset(new SvxTextEncodingBox(m_xBuilder->weld_combo_box("charsetdropdown")))
+    , m_xTvCharset(new SvxTextEncodingTreeView(m_xBuilder->weld_tree_view("charsetlist")))
+{
+    if (bAscii)
+    {
+        m_xDialog->set_help_id(m_xDialog->get_help_id() + "?config=NonTextImport");
+        m_xLbCharset->show();
+        m_xTvCharset->hide();
+    }
+    else
+    {
+        m_xTvCharset->set_size_request(-1, m_xTvCharset->get_height_rows(6));
+        m_xEncGrid->set_vexpand(true);
+        m_xLbCharset->hide();
+        m_xTvCharset->show();
+    }
+
+    OUString sFieldSep(SCSTR_FIELDSEP);
+    sFieldSep = sFieldSep.replaceFirst( "%TAB",   ScResId(SCSTR_FIELDSEP_TAB) );
+    sFieldSep = sFieldSep.replaceFirst( "%SPACE", ScResId(SCSTR_FIELDSEP_SPACE) );
+
+    // not possible in the Ctor initializer (MSC cannot do that):
+    pFieldSepTab.reset( new ScDelimiterTable(sFieldSep) );
+    pTextSepTab.reset( new ScDelimiterTable(SCSTR_TEXTSEP) );
+
+    OUString aStr = pFieldSepTab->FirstDel();
+
+    while (!aStr.isEmpty())
+    {
+        m_xEdFieldSep->append_text(aStr);
+        aStr = pFieldSepTab->NextDel();
+    }
+
+    aStr = pTextSepTab->FirstDel();
+
+    while (!aStr.isEmpty())
+    {
+        m_xEdTextSep->append_text(aStr);
+        aStr = pTextSepTab->NextDel();
+    }
+
+    m_xEdFieldSep->set_active(0);
+    m_xEdTextSep->set_active(0);
+
+    if ( bOnlyDbtoolsEncodings )
+    {
+        // Even dBase export allows multibyte now
+        if ( bMultiByte )
+            FillFromDbTextEncodingMap( bImport );
+        else
+            FillFromDbTextEncodingMap( bImport, RTL_TEXTENCODING_INFO_MULTIBYTE );
+    }
+    else if ( !bAscii )
+    {   //!TODO: Unicode would need work in each filter
+        if ( bMultiByte )
+            FillFromTextEncodingTable( bImport, RTL_TEXTENCODING_INFO_UNICODE );
+        else
+            FillFromTextEncodingTable( bImport, RTL_TEXTENCODING_INFO_UNICODE |
+                RTL_TEXTENCODING_INFO_MULTIBYTE );
+    }
+    else
+    {
+        if ( pOptions )
+        {
+            sal_Unicode nCode = pOptions->nFieldSepCode;
+            aStr  = pFieldSepTab->GetDelimiter( nCode );
+
+            if ( aStr.isEmpty() )
+                m_xEdFieldSep->set_entry_text(OUString(nCode));
+            else
+                m_xEdFieldSep->set_entry_text(aStr);
+
+            nCode = pOptions->nTextSepCode;
+            aStr  = pTextSepTab->GetDelimiter( nCode );
+
+            if ( aStr.isEmpty() )
+                m_xEdTextSep->set_entry_text(OUString(nCode));
+            else
+                m_xEdTextSep->set_entry_text(aStr);
+        }
+        // all encodings allowed, even Unicode
+        FillFromTextEncodingTable( bImport );
+    }
+
+    if( bAscii )
+    {
+        sal_Int32 nCharSet = officecfg::Office::Calc::Dialogs::CSVExport::CharSet::get();
+        OUString strFieldSeparator = officecfg::Office::Calc::Dialogs::CSVExport::FieldSeparator::get();
+        OUString strTextSeparator = officecfg::Office::Calc::Dialogs::CSVExport::TextSeparator::get();
+        bool bSaveTrueCellContent = officecfg::Office::Calc::Dialogs::CSVExport::SaveTrueCellContent::get();
+        bool bSaveCellFormulas = officecfg::Office::Calc::Dialogs::CSVExport::SaveCellFormulas::get();
+        bool bQuoteAllTextCells = officecfg::Office::Calc::Dialogs::CSVExport::QuoteAllTextCells::get();
+        bool bFixedWidth = officecfg::Office::Calc::Dialogs::CSVExport::FixedWidth::get();
+
+        m_xCbFixed->show();
+        m_xCbFixed->connect_toggled(LINK(this, ScImportOptionsDlg, FixedWidthHdl));
+        m_xCbFixed->set_active( bFixedWidth );
+        FixedWidthHdl(*m_xCbFixed);
+        m_xCbShown->show();
+        m_xCbShown->set_active( bSaveTrueCellContent );
+        m_xCbQuoteAll->show();
+        m_xCbQuoteAll->set_active( bQuoteAllTextCells );
+        m_xCbFormulas->show();
+        // default option for "save formulas" no longer taken from view shell but from persisted dialog settings
+        m_xCbFormulas->set_active( bSaveCellFormulas );
+        // if no charset, text separator or field separator exist, keep the values from dialog initialization
+        if (strFieldSeparator.getLength() > 0)
+            m_xEdFieldSep->set_entry_text(strFieldSeparator);
+        if (strTextSeparator.getLength() > 0)
+            m_xEdTextSep->set_entry_text(strTextSeparator);
+        if (nCharSet < 0 || nCharSet == RTL_TEXTENCODING_DONTKNOW )
+            m_xLbCharset->SelectTextEncoding(pOptions ? pOptions->eCharSet : osl_getThreadTextEncoding());
+        else
+            m_xLbCharset->SelectTextEncoding(nCharSet);
+    }
+    else
+    {
+        m_xFieldFrame->set_label(m_xFtCharset->get_label());
+        m_xFtFieldSep->hide();
+        m_xFtTextSep->hide();
+        m_xFtCharset->hide();
+        m_xEdFieldSep->hide();
+        m_xEdTextSep->hide();
+        m_xCbFixed->hide();
+        m_xCbShown->hide();
+        m_xCbQuoteAll->hide();
+        m_xCbFormulas->hide();
+        m_xTvCharset->grab_focus();
+        m_xTvCharset->connect_row_activated(LINK(this, ScImportOptionsDlg, DoubleClickHdl));
+        m_xTvCharset->SelectTextEncoding(pOptions ? pOptions->eCharSet : osl_getThreadTextEncoding());
+    }
+
+    // optional title:
+    if (pStrTitle)
+        m_xDialog->set_title(*pStrTitle);
+}
+
+ScImportOptionsDlg::~ScImportOptionsDlg()
+{
+}
+
+void ScImportOptionsDlg::GetImportOptions( ScImportOptions& rOptions ) const
+{
+    auto nEncoding = m_bIsAsciiImport ? m_xLbCharset->GetSelectTextEncoding() : m_xTvCharset->GetSelectTextEncoding();
+    rOptions.SetTextEncoding(nEncoding);
+
+    if (m_xCbFixed->get_visible())
+    {
+        rOptions.nFieldSepCode = GetCodeFromCombo( *m_xEdFieldSep );
+        rOptions.nTextSepCode  = GetCodeFromCombo( *m_xEdTextSep );
+        rOptions.bFixedWidth = m_xCbFixed->get_active();
+        rOptions.bSaveAsShown = m_xCbShown->get_active();
+        rOptions.bQuoteAllText = m_xCbQuoteAll->get_active();
+        rOptions.bSaveFormulas = m_xCbFormulas->get_active();
+    }
+}
+
+sal_uInt16 ScImportOptionsDlg::GetCodeFromCombo(const weld::ComboBox& rEd) const
+{
+    ScDelimiterTable* pTab;
+    OUString  aStr( rEd.get_active_text() );
+    sal_uInt16  nCode;
+
+    if (&rEd == m_xEdTextSep.get())
+        pTab = pTextSepTab.get();
+    else
+        pTab = pFieldSepTab.get();
+
+    if ( aStr.isEmpty() )
+    {
+        nCode = 0;          // no separator
+    }
+    else
+    {
+        nCode = pTab->GetCode( aStr );
+
+        if ( nCode == 0 )
+            nCode = static_cast<sal_uInt16>(aStr[0]);
+    }
+
+    return nCode;
+}
+
+IMPL_LINK_NOARG(ScImportOptionsDlg, FixedWidthHdl, weld::Toggleable&, void)
+{
+    bool bEnable = !m_xCbFixed->get_active();
+    m_xFtFieldSep->set_sensitive( bEnable );
+    m_xEdFieldSep->set_sensitive( bEnable );
+    m_xFtTextSep->set_sensitive( bEnable );
+    m_xEdTextSep->set_sensitive( bEnable );
+    m_xCbShown->set_sensitive( bEnable );
+    m_xCbQuoteAll->set_sensitive( bEnable );
+}
+
+IMPL_LINK_NOARG(ScImportOptionsDlg, DoubleClickHdl, weld::TreeView&, bool)
+{
+    m_xDialog->response(RET_OK);
+    return true;
+}
+
+void ScImportOptionsDlg::SaveImportOptions() const
+{
+    std::shared_ptr < comphelper::ConfigurationChanges > batch(comphelper::ConfigurationChanges::create());
+    auto nEncoding = m_bIsAsciiImport ? m_xLbCharset->GetSelectTextEncoding() : m_xTvCharset->GetSelectTextEncoding();
+    officecfg::Office::Calc::Dialogs::CSVExport::CharSet::set(nEncoding, batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::FieldSeparator::set(m_xEdFieldSep->get_active_text(), batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::TextSeparator::set(m_xEdTextSep->get_active_text(), batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::FixedWidth::set(m_xCbFixed->get_active(), batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::SaveCellFormulas::set(m_xCbFormulas->get_active(), batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::SaveTrueCellContent::set(m_xCbShown->get_active(), batch);
+    officecfg::Office::Calc::Dialogs::CSVExport::QuoteAllTextCells::set(m_xCbQuoteAll->get_active(), batch);
+    batch->commit();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/sfiltdlg.cxx b/sc/source/ui/dbgui/sfiltdlg.cxx
new file mode 100644
index 000000000..3aeb31923
--- /dev/null
+++ b/sc/source/ui/dbgui/sfiltdlg.cxx
@@ -0,0 +1,435 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sfx2/dispatch.hxx>
+
+#include <uiitems.hxx>
+#include <rangenam.hxx>
+#include <reffact.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <docsh.hxx>
+#include <scresid.hxx>
+
+#include <foptmgr.hxx>
+
+#include <globstr.hrc>
+#include <strings.hrc>
+
+#include <filtdlg.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+// DEFINE --------------------------------------------------------------------
+
+namespace
+{
+    void ERRORBOX(weld::Window* pParent, TranslateId rid)
+    {
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent,
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  ScResId(rid)));
+        xBox->run();
+    }
+}
+
+
+ScSpecialFilterDlg::ScSpecialFilterDlg( SfxBindings* pB, SfxChildWindow* pCW, weld::Window* pParent,
+                                        const SfxItemSet&   rArgSet )
+
+    : ScAnyRefDlgController(pB, pCW, pParent, "modules/scalc/ui/advancedfilterdialog.ui", "AdvancedFilterDialog")
+    , aStrUndefined   ( ScResId(SCSTR_UNDEFINED) )
+    , nWhichQuery     ( rArgSet.GetPool()->GetWhich( SID_QUERY ) )
+    , theQueryData    ( static_cast<const ScQueryItem&>(
+                           rArgSet.Get( nWhichQuery )).GetQueryData() )
+    , pViewData(nullptr)
+    , pDoc(nullptr)
+    , bRefInputMode(false)
+    , m_pRefInputEdit(nullptr)
+    , m_xLbFilterArea(m_xBuilder->weld_combo_box("lbfilterarea"))
+    , m_xEdFilterArea(new formula::RefEdit(m_xBuilder->weld_entry("edfilterarea")))
+    , m_xRbFilterArea(new formula::RefButton(m_xBuilder->weld_button("rbfilterarea")))
+    , m_xExpander(m_xBuilder->weld_expander("more"))
+    , m_xBtnCase(m_xBuilder->weld_check_button("case"))
+    , m_xBtnRegExp(m_xBuilder->weld_check_button("regexp"))
+    , m_xBtnHeader(m_xBuilder->weld_check_button("header"))
+    , m_xBtnUnique(m_xBuilder->weld_check_button("unique"))
+    , m_xBtnCopyResult(m_xBuilder->weld_check_button("copyresult"))
+    , m_xLbCopyArea(m_xBuilder->weld_combo_box("lbcopyarea"))
+    , m_xEdCopyArea(new formula::RefEdit(m_xBuilder->weld_entry("edcopyarea")))
+    , m_xRbCopyArea(new formula::RefButton(m_xBuilder->weld_button("rbcopyarea")))
+    , m_xBtnDestPers(m_xBuilder->weld_check_button("destpers"))
+    , m_xFtDbAreaLabel(m_xBuilder->weld_label("dbarealabel"))
+    , m_xFtDbArea(m_xBuilder->weld_label("dbarea"))
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xBtnCancel(m_xBuilder->weld_button("cancel"))
+    , m_xFilterFrame(m_xBuilder->weld_frame("filterframe"))
+    , m_xFilterLabel(m_xFilterFrame->weld_label_widget())
+{
+    m_xEdFilterArea->SetReferences(this, m_xFilterLabel.get());
+    m_xRbFilterArea->SetReferences(this, m_xEdFilterArea.get());
+    m_xEdCopyArea->SetReferences(this, m_xFtDbAreaLabel.get());
+    m_xRbCopyArea->SetReferences(this, m_xEdCopyArea.get());
+
+    Init( rArgSet );
+
+    Link<formula::RefEdit&, void> aLinkEdit = LINK(this, ScSpecialFilterDlg, RefInputEditHdl);
+    Link<formula::RefButton&, void> aLinkButton = LINK(this, ScSpecialFilterDlg, RefInputButtonHdl);
+    m_xEdCopyArea->SetGetFocusHdl(aLinkEdit);
+    m_xRbCopyArea->SetGetFocusHdl(aLinkButton);
+    m_xEdFilterArea->SetGetFocusHdl(aLinkEdit);
+    m_xRbFilterArea->SetGetFocusHdl(aLinkButton);
+    m_xEdCopyArea->SetLoseFocusHdl(aLinkEdit);
+    m_xRbCopyArea->SetLoseFocusHdl(aLinkButton);
+    m_xEdFilterArea->SetLoseFocusHdl(aLinkEdit);
+    m_xRbFilterArea->SetLoseFocusHdl(aLinkButton);
+
+    m_xEdFilterArea->GrabFocus();
+}
+
+ScSpecialFilterDlg::~ScSpecialFilterDlg()
+{
+    pOptionsMgr.reset();
+
+    pOutItem.reset();
+}
+
+void ScSpecialFilterDlg::Init( const SfxItemSet& rArgSet )
+{
+    const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(
+                                    rArgSet.Get( nWhichQuery ));
+
+    m_xBtnOk->connect_clicked( LINK( this, ScSpecialFilterDlg, EndDlgHdl ) );
+    m_xBtnCancel->connect_clicked( LINK( this, ScSpecialFilterDlg, EndDlgHdl ) );
+    m_xLbFilterArea->connect_changed( LINK( this, ScSpecialFilterDlg, FilterAreaSelHdl ) );
+    m_xEdFilterArea->SetModifyHdl  ( LINK( this, ScSpecialFilterDlg, FilterAreaModHdl ) );
+
+    pViewData   = rQueryItem.GetViewData();
+    pDoc        = pViewData ? &pViewData->GetDocument() : nullptr;
+
+    m_xEdFilterArea->SetText( OUString() );      // may be overwritten below
+
+    if ( pViewData && pDoc )
+    {
+        if(pDoc->GetChangeTrack()!=nullptr) m_xBtnCopyResult->set_sensitive(false);
+
+        ScRangeName* pRangeNames = pDoc->GetRangeName();
+        m_xLbFilterArea->clear();
+        m_xLbFilterArea->append_text(aStrUndefined);
+
+        for (const auto& rEntry : *pRangeNames)
+        {
+            if (!rEntry.second->HasType(ScRangeData::Type::Criteria))
+                continue;
+
+            OUString aSymbol = rEntry.second->GetSymbol();
+            m_xLbFilterArea->append(aSymbol, rEntry.second->GetName());
+        }
+
+        //  is there a stored source range?
+
+        ScRange aAdvSource;
+        if (rQueryItem.GetAdvancedQuerySource(aAdvSource))
+        {
+            OUString aRefStr(aAdvSource.Format(*pDoc, ScRefFlags::RANGE_ABS_3D, pDoc->GetAddressConvention()));
+            m_xEdFilterArea->SetRefString( aRefStr );
+        }
+    }
+
+    m_xLbFilterArea->set_active( 0 );
+
+    // let options be initialized:
+
+    pOptionsMgr.reset( new ScFilterOptionsMgr(
+                            pViewData,
+                            theQueryData,
+                            m_xBtnCase.get(),
+                            m_xBtnRegExp.get(),
+                            m_xBtnHeader.get(),
+                            m_xBtnUnique.get(),
+                            m_xBtnCopyResult.get(),
+                            m_xBtnDestPers.get(),
+                            m_xLbCopyArea.get(),
+                            m_xEdCopyArea.get(),
+                            m_xRbCopyArea.get(),
+                            m_xFtDbAreaLabel.get(),
+                            m_xFtDbArea.get(),
+                            aStrUndefined ) );
+
+    //  special filter always needs column headers
+    m_xBtnHeader->set_active(true);
+    m_xBtnHeader->set_sensitive(false);
+
+    // turn on modal mode
+    // SetDispatcherLock( true );
+    //@BugID 54702 enable/disable in base class only
+    //SFX_APPWINDOW->Disable(false);        //! general method in ScAnyRefDlg
+}
+
+void ScSpecialFilterDlg::Close()
+{
+    if (pViewData)
+        pViewData->GetDocShell()->CancelAutoDBRange();
+
+    DoClose( ScSpecialFilterDlgWrapper::GetChildWindowId() );
+}
+
+// Transfer of a table area selected with the mouse, which is then displayed
+// as a new selection in the reference edit.
+
+void ScSpecialFilterDlg::SetReference( const ScRange& rRef, ScDocument& rDocP )
+{
+    if ( !(bRefInputMode && m_pRefInputEdit) )       // only possible if in the reference edit mode
+        return;
+
+    if ( rRef.aStart != rRef.aEnd )
+        RefInputStart( m_pRefInputEdit );
+
+    OUString aRefStr;
+    const formula::FormulaGrammar::AddressConvention eConv = rDocP.GetAddressConvention();
+
+    if (m_pRefInputEdit == m_xEdCopyArea.get())
+        aRefStr = rRef.aStart.Format(ScRefFlags::ADDR_ABS_3D, &rDocP, eConv);
+    else if (m_pRefInputEdit == m_xEdFilterArea.get())
+        aRefStr = rRef.Format(rDocP, ScRefFlags::RANGE_ABS_3D, eConv);
+
+    m_pRefInputEdit->SetRefString( aRefStr );
+}
+
+void ScSpecialFilterDlg::SetActive()
+{
+    if ( bRefInputMode )
+    {
+        if (m_pRefInputEdit == m_xEdCopyArea.get())
+        {
+            m_xEdCopyArea->GrabFocus();
+            m_xEdCopyArea->GetModifyHdl().Call( *m_xEdCopyArea );
+        }
+        else if (m_pRefInputEdit == m_xEdFilterArea.get())
+        {
+            m_xEdFilterArea->GrabFocus();
+            FilterAreaModHdl( *m_xEdFilterArea );
+        }
+    }
+    else
+        m_xDialog->grab_focus();
+
+    RefInputDone();
+}
+
+ScQueryItem* ScSpecialFilterDlg::GetOutputItem( const ScQueryParam& rParam,
+                                                const ScRange& rSource )
+{
+    pOutItem.reset(new ScQueryItem( nWhichQuery, &rParam ));
+    pOutItem->SetAdvancedQuerySource( &rSource );
+    return pOutItem.get();
+}
+
+bool ScSpecialFilterDlg::IsRefInputMode() const
+{
+    return bRefInputMode;
+}
+
+// Handler:
+
+IMPL_LINK(ScSpecialFilterDlg, EndDlgHdl, weld::Button&, rBtn, void)
+{
+    OSL_ENSURE( pDoc && pViewData, "Document or ViewData not found. :-/" );
+
+    if (&rBtn == m_xBtnOk.get() && pDoc && pViewData)
+    {
+        OUString          theCopyStr( m_xEdCopyArea->GetText() );
+        OUString          theAreaStr( m_xEdFilterArea->GetText() );
+        ScQueryParam    theOutParam( theQueryData );
+        ScAddress       theAdrCopy;
+        bool            bEditInputOk    = true;
+        bool            bQueryOk        = false;
+        ScRange         theFilterArea;
+        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
+
+        if ( m_xBtnCopyResult->get_active() )
+        {
+            sal_Int32 nColonPos = theCopyStr.indexOf( ':' );
+
+            if ( -1 != nColonPos )
+                theCopyStr = theCopyStr.copy( 0, nColonPos );
+
+            ScRefFlags nResult = theAdrCopy.Parse( theCopyStr, *pDoc, eConv );
+
+            if ( (nResult & ScRefFlags::VALID) == ScRefFlags::ZERO )
+            {
+                if (!m_xExpander->get_expanded())
+                    m_xExpander->set_expanded(true);
+
+                ERRORBOX(m_xDialog.get(), STR_INVALID_TABREF);
+                m_xEdCopyArea->GrabFocus();
+                bEditInputOk = false;
+            }
+        }
+
+        if ( bEditInputOk )
+        {
+            ScRefFlags nResult = ScRange().Parse( theAreaStr, *pDoc, eConv );
+
+            if ( (nResult & ScRefFlags::VALID) == ScRefFlags::ZERO )
+            {
+                ERRORBOX(m_xDialog.get(), STR_INVALID_TABREF);
+                m_xEdFilterArea->GrabFocus();
+                bEditInputOk = false;
+            }
+        }
+
+        if ( bEditInputOk )
+        {
+            /*
+             * All edit fields contain valid areas. Now try to create
+             * a ScQueryParam from the filter area:
+             */
+
+            ScRefFlags  nResult = theFilterArea.Parse( theAreaStr, *pDoc, eConv );
+
+            if ( (nResult & ScRefFlags::VALID) == ScRefFlags::VALID )
+            {
+                ScAddress& rStart = theFilterArea.aStart;
+                ScAddress& rEnd   = theFilterArea.aEnd;
+
+                if ( m_xBtnCopyResult->get_active() )
+                {
+                    theOutParam.bInplace    = false;
+                    theOutParam.nDestTab    = theAdrCopy.Tab();
+                    theOutParam.nDestCol    = theAdrCopy.Col();
+                    theOutParam.nDestRow    = theAdrCopy.Row();
+                }
+                else
+                {
+                    theOutParam.bInplace    = true;
+                    theOutParam.nDestTab    = 0;
+                    theOutParam.nDestCol    = 0;
+                    theOutParam.nDestRow    = 0;
+                }
+
+                theOutParam.bHasHeader = m_xBtnHeader->get_active();
+                theOutParam.bByRow     = true;
+                theOutParam.bCaseSens  = m_xBtnCase->get_active();
+                theOutParam.eSearchType = m_xBtnRegExp->get_active() ? utl::SearchParam::SearchType::Regexp :
+                    utl::SearchParam::SearchType::Normal;
+                theOutParam.bDuplicate = !m_xBtnUnique->get_active();
+                theOutParam.bDestPers  = m_xBtnDestPers->get_active();
+
+                bQueryOk = pDoc->CreateQueryParam(ScRange(rStart,rEnd), theOutParam);
+            }
+        }
+
+        if ( bQueryOk )
+        {
+            SetDispatcherLock( false );
+            SwitchToDocument();
+            GetBindings().GetDispatcher()->ExecuteList(FID_FILTER_OK,
+                    SfxCallMode::SLOT | SfxCallMode::RECORD,
+                    { GetOutputItem(theOutParam, theFilterArea) });
+            response(RET_OK);
+        }
+        else
+        {
+            ERRORBOX(m_xDialog.get(), STR_INVALID_QUERYAREA);
+            m_xEdFilterArea->GrabFocus();
+        }
+    }
+    else if (&rBtn == m_xBtnCancel.get())
+    {
+        response(RET_CANCEL);
+    }
+}
+
+IMPL_LINK_NOARG(ScSpecialFilterDlg, RefInputEditHdl, formula::RefEdit&, void)
+{
+    RefInputHdl();
+}
+
+IMPL_LINK_NOARG(ScSpecialFilterDlg, RefInputButtonHdl, formula::RefButton&, void)
+{
+    RefInputHdl();
+}
+
+void ScSpecialFilterDlg::RefInputHdl()
+{
+    if (!m_xDialog->has_toplevel_focus())
+        return;
+
+    if( m_xEdCopyArea->GetWidget()->has_focus() || m_xRbCopyArea->GetWidget()->has_focus() )
+    {
+        m_pRefInputEdit = m_xEdCopyArea.get();
+        bRefInputMode = true;
+    }
+    else if( m_xEdFilterArea->GetWidget()->has_focus() || m_xRbFilterArea->GetWidget()->has_focus() )
+    {
+        m_pRefInputEdit = m_xEdFilterArea.get();
+        bRefInputMode = true;
+    }
+    else if( bRefInputMode )
+    {
+        m_pRefInputEdit = nullptr;
+        bRefInputMode = false;
+    }
+}
+
+IMPL_LINK(ScSpecialFilterDlg, FilterAreaSelHdl, weld::ComboBox&, rLb, void)
+{
+    if (&rLb == m_xLbFilterArea.get())
+    {
+        OUString  aString;
+        const sal_Int32 nSelPos = m_xLbFilterArea->get_active();
+
+        if ( nSelPos > 0 )
+            aString = m_xLbFilterArea->get_id(nSelPos);
+
+        m_xEdFilterArea->SetText( aString );
+    }
+}
+
+IMPL_LINK( ScSpecialFilterDlg, FilterAreaModHdl, formula::RefEdit&, rEd, void )
+{
+    if (&rEd != m_xEdFilterArea.get())
+        return;
+
+    if ( pDoc && pViewData )
+    {
+        OUString  theCurAreaStr = rEd.GetText();
+        ScRefFlags  nResult = ScRange().Parse( theCurAreaStr, *pDoc );
+
+        if ( (nResult & ScRefFlags::VALID) == ScRefFlags::VALID )
+        {
+            const sal_Int32 nCount  = m_xLbFilterArea->get_count();
+            for (sal_Int32 i = 1; i < nCount; ++i)
+            {
+                OUString aStr = m_xLbFilterArea->get_id(i);
+                if (theCurAreaStr == aStr)
+                {
+                    m_xLbFilterArea->set_active( i );
+                    return;
+                }
+            }
+            m_xLbFilterArea->set_active( 0 );
+        }
+    }
+    else
+        m_xLbFilterArea->set_active( 0 );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/sortdlg.cxx b/sc/source/ui/dbgui/sortdlg.cxx
new file mode 100644
index 000000000..22af2230b
--- /dev/null
+++ b/sc/source/ui/dbgui/sortdlg.cxx
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <scui_def.hxx>
+#include <tpsort.hxx>
+#include <sortdlg.hxx>
+
+ScSortDlg::ScSortDlg(weld::Window* pParent, const SfxItemSet* pArgSet)
+    : SfxTabDialogController(pParent, "modules/scalc/ui/sortdialog.ui", "SortDialog", pArgSet)
+{
+    AddTabPage("criteria", ScTabPageSortFields::Create, nullptr);
+    AddTabPage("options", ScTabPageSortOptions::Create, nullptr);
+}
+
+ScSortWarningDlg::ScSortWarningDlg(weld::Window* pParent,
+    std::u16string_view rExtendText, std::u16string_view rCurrentText)
+    : GenericDialogController(pParent, "modules/scalc/ui/sortwarning.ui", "SortWarning")
+    , m_xFtText(m_xBuilder->weld_label("sorttext"))
+    , m_xBtnExtSort(m_xBuilder->weld_button("extend"))
+    , m_xBtnCurSort(m_xBuilder->weld_button("current"))
+{
+    OUString sTextName = m_xFtText->get_label();
+    sTextName = sTextName.replaceFirst("%1", rExtendText);
+    sTextName = sTextName.replaceFirst("%2", rCurrentText);
+    m_xFtText->set_label(sTextName);
+
+    m_xBtnExtSort->connect_clicked( LINK( this, ScSortWarningDlg, BtnHdl ) );
+    m_xBtnCurSort->connect_clicked( LINK( this, ScSortWarningDlg, BtnHdl ) );
+}
+
+ScSortWarningDlg::~ScSortWarningDlg()
+{
+}
+
+IMPL_LINK(ScSortWarningDlg, BtnHdl, weld::Button&, rBtn, void)
+{
+    if (&rBtn == m_xBtnExtSort.get())
+    {
+        m_xDialog->response(BTN_EXTEND_RANGE);
+    }
+    else if(&rBtn == m_xBtnCurSort.get())
+    {
+        m_xDialog->response(BTN_CURRENT_SELECTION);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/sortkeydlg.cxx b/sc/source/ui/dbgui/sortkeydlg.cxx
new file mode 100644
index 000000000..599280735
--- /dev/null
+++ b/sc/source/ui/dbgui/sortkeydlg.cxx
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <memory>
+#include <sortkeydlg.hxx>
+#include <vcl/svapp.hxx>
+
+#include <scresid.hxx>
+#include <strings.hrc>
+
+ScSortKeyItem::ScSortKeyItem(weld::Container* pParent)
+    : m_xBuilder(Application::CreateBuilder(pParent, "modules/scalc/ui/sortkey.ui"))
+    , m_xFrame(m_xBuilder->weld_frame("SortKeyFrame"))
+    , m_xLbSort(m_xBuilder->weld_combo_box("sortlb"))
+    , m_xBtnUp(m_xBuilder->weld_radio_button("up"))
+    , m_xBtnDown(m_xBuilder->weld_radio_button("down"))
+    , m_xLabel(m_xBuilder->weld_label("lbColRow"))
+    , m_pParent(pParent)
+{
+    // tdf#136155 let the other elements in the dialog determine the width of the
+    // combobox
+    m_xLbSort->set_size_request(m_xLbSort->get_approximate_digit_width() * 12, -1);
+    // keep the UI static when switching the labels
+    const sal_Int32 nChars = std::max( ScResId(SCSTR_COLUMN).getLength(), ScResId(SCSTR_ROW).getLength() ) + 2; // +2 to avoid cut-off labels on kf5/gen
+    m_xLabel->set_size_request( m_xLabel->get_approximate_digit_width() * nChars, -1);
+}
+
+ScSortKeyItem::~ScSortKeyItem()
+{
+    m_pParent->move(m_xFrame.get(), nullptr);
+}
+
+void ScSortKeyItem::DisableField()
+{
+    m_xFrame->set_sensitive(false);
+}
+
+void ScSortKeyItem::EnableField()
+{
+    m_xFrame->set_sensitive(true);
+}
+
+ScSortKeyWindow::ScSortKeyWindow(weld::Container* pBox)
+    : m_pBox(pBox)
+{
+}
+
+ScSortKeyWindow::~ScSortKeyWindow()
+{
+}
+
+void ScSortKeyWindow::AddSortKey( sal_uInt16 nItemNumber )
+{
+    ScSortKeyItem* pSortKeyItem = new ScSortKeyItem(m_pBox);
+
+    // Set Sort key number
+    OUString aLine = pSortKeyItem->m_xFrame->get_label() +
+                     OUString::number( nItemNumber );
+    pSortKeyItem->m_xFrame->set_label(aLine);
+
+    // for ui-testing. Distinguish the sort keys
+    if ( m_aSortKeyItems.size() > 0 )
+    {
+        pSortKeyItem->m_xLbSort->set_buildable_name(
+            pSortKeyItem->m_xLbSort->get_buildable_name() + OString::number(m_aSortKeyItems.size() + 1));
+    }
+
+    m_aSortKeyItems.push_back(std::unique_ptr<ScSortKeyItem>(pSortKeyItem));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/subtdlg.cxx b/sc/source/ui/dbgui/subtdlg.cxx
new file mode 100644
index 000000000..924716a6f
--- /dev/null
+++ b/sc/source/ui/dbgui/subtdlg.cxx
@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <tpsubt.hxx>
+#include <subtdlg.hxx>
+#include <scui_def.hxx>
+
+ScSubTotalDlg::ScSubTotalDlg(weld::Window* pParent, const SfxItemSet& rArgSet)
+    : SfxTabDialogController(pParent, "modules/scalc/ui/subtotaldialog.ui", "SubTotalDialog", &rArgSet)
+    , m_xBtnRemove(m_xBuilder->weld_button("remove"))
+{
+    AddTabPage("1stgroup",  ScTpSubTotalGroup1::Create, nullptr);
+    AddTabPage("2ndgroup",  ScTpSubTotalGroup2::Create, nullptr);
+    AddTabPage("3rdgroup",  ScTpSubTotalGroup3::Create, nullptr);
+    AddTabPage("options", ScTpSubTotalOptions::Create, nullptr);
+    m_xBtnRemove->connect_clicked( LINK( this, ScSubTotalDlg, RemoveHdl ) );
+}
+
+ScSubTotalDlg::~ScSubTotalDlg()
+{
+}
+
+IMPL_LINK_NOARG(ScSubTotalDlg, RemoveHdl, weld::Button&, void)
+{
+    m_xDialog->response(SCRET_REMOVE);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/textimportoptions.cxx b/sc/source/ui/dbgui/textimportoptions.cxx
new file mode 100644
index 000000000..99ddc425d
--- /dev/null
+++ b/sc/source/ui/dbgui/textimportoptions.cxx
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <textimportoptions.hxx>
+#include <svx/langbox.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <i18nlangtag/languagetag.hxx>
+
+ScTextImportOptionsDlg::ScTextImportOptionsDlg(weld::Window* pParent)
+    : GenericDialogController(pParent, "modules/scalc/ui/textimportoptions.ui", "TextImportOptionsDialog")
+    , m_xBtnOk(m_xBuilder->weld_button("ok"))
+    , m_xRbAutomatic(m_xBuilder->weld_radio_button("automatic"))
+    , m_xRbCustom(m_xBuilder->weld_radio_button("custom"))
+    , m_xBtnConvertDate(m_xBuilder->weld_check_button("convertdata"))
+    , m_xBtnKeepAsking(m_xBuilder->weld_check_button("keepasking"))
+    , m_xLbCustomLang(new SvxLanguageBox(m_xBuilder->weld_combo_box("lang")))
+{
+    init();
+}
+
+ScTextImportOptionsDlg::~ScTextImportOptionsDlg()
+{
+}
+
+LanguageType ScTextImportOptionsDlg::getLanguageType() const
+{
+    if (m_xRbAutomatic->get_active())
+        return LANGUAGE_SYSTEM;
+
+    return m_xLbCustomLang->get_active_id();
+}
+
+bool ScTextImportOptionsDlg::isDateConversionSet() const
+{
+    return m_xBtnConvertDate->get_active();
+}
+
+bool ScTextImportOptionsDlg::isKeepAskingSet() const
+{
+    return m_xBtnKeepAsking->get_active();
+}
+
+void ScTextImportOptionsDlg::init()
+{
+    m_xBtnOk->connect_clicked(LINK(this, ScTextImportOptionsDlg, OKHdl));
+    Link<weld::Toggleable&,void> aLink = LINK(this, ScTextImportOptionsDlg, RadioHdl);
+    m_xRbAutomatic->connect_toggled(aLink);
+    m_xRbCustom->connect_toggled(aLink);
+
+    m_xRbAutomatic->set_active(true);
+
+    m_xLbCustomLang->SetLanguageList(
+        SvxLanguageListFlags::ALL | SvxLanguageListFlags::ONLY_KNOWN, false);
+
+    LanguageType eLang = Application::GetSettings().GetLanguageTag().getLanguageType();
+    m_xLbCustomLang->set_active_id(eLang);
+    m_xLbCustomLang->set_sensitive(false);
+}
+
+IMPL_LINK_NOARG(ScTextImportOptionsDlg, OKHdl, weld::Button&, void)
+{
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK(ScTextImportOptionsDlg, RadioHdl, weld::Toggleable&, rBtn, void)
+{
+    if (&rBtn == m_xRbAutomatic.get())
+    {
+        m_xLbCustomLang->set_sensitive(false);
+    }
+    else if (&rBtn == m_xRbCustom.get())
+    {
+        m_xLbCustomLang->set_sensitive(true);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/tpsort.cxx b/sc/source/ui/dbgui/tpsort.cxx
new file mode 100644
index 000000000..35a24e633
--- /dev/null
+++ b/sc/source/ui/dbgui/tpsort.cxx
@@ -0,0 +1,855 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <svtools/collatorres.hxx>
+#include <unotools/collatorwrapper.hxx>
+#include <comphelper/processfactory.hxx>
+#include <osl/diagnose.h>
+
+#include <scitems.hxx>
+#include <uiitems.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <global.hxx>
+#include <dbdata.hxx>
+#include <userlist.hxx>
+#include <rangeutl.hxx>
+#include <scresid.hxx>
+#include <sc.hrc>
+#include <strings.hrc>
+#include <globstr.hrc>
+
+#include <sortkeydlg.hxx>
+
+#include <sortdlg.hxx>
+
+#include <tpsort.hxx>
+
+using namespace com::sun::star;
+
+/*
+ * Since the settings on the second Tab Page (Options) effects
+ * the first Tab Page, there must be a way for it to communicate with the
+ * other Page.
+ *
+ * At the moment this problem is solved through using two data members of the
+ * Tab Pages. If a page is enabled / disabled, it compares this data member
+ * with its own state (-> Activate() / Deactivate()).
+ *
+ * In the meantime the class SfxTabPage offers the following method:
+ *
+ * virtual sal_Bool HasExchangeSupport() const; -> return sal_True;
+ * virtual void ActivatePage(const SfxItemSet &);
+ * virtual int  DeactivatePage(SfxItemSet * = 0);
+ *
+ * This still needs to be changed!
+ */
+
+// Sort Criteria Tab page
+
+ScTabPageSortFields::ScTabPageSortFields(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet)
+    : SfxTabPage(pPage, pController, "modules/scalc/ui/sortcriteriapage.ui", "SortCriteriaPage", &rArgSet)
+    ,
+
+        m_aIdle("ScTabPageSortFields Scroll To End Idle"),
+        aStrUndefined   ( ScResId( SCSTR_UNDEFINED ) ),
+        aStrColumn      ( ScResId( SCSTR_COLUMN ) ),
+        aStrRow         ( ScResId( SCSTR_ROW ) ),
+        aStrRowLabel    ( ScResId( SCSTR_ROW_LABEL ) ),
+        aStrColLabel    ( ScResId( SCSTR_COL_LABEL ) ),
+
+        nWhichSort      ( rArgSet.GetPool()->GetWhich( SID_SORT ) ),
+        pViewData       ( nullptr ),
+        aSortData       ( rArgSet.Get( nWhichSort ).GetSortData() ),
+        nFieldCount     ( 0 ),
+        // show actual size of the sorting keys without limiting them to the default size
+        nSortKeyCount(std::max(aSortData.GetSortKeyCount(), static_cast<sal_uInt16>(DEFSORT)))
+
+    , m_xTop(m_xBuilder->weld_container("TopWindow"))
+    , m_xBtnHeader(m_xBuilder->weld_check_button("cbHeader"))
+    , m_xBtnTopDown(m_xBuilder->weld_radio_button("rbTopDown"))
+    , m_xBtnLeftRight(m_xBuilder->weld_radio_button("rbLeftRight"))
+    , m_xScrolledWindow(m_xBuilder->weld_scrolled_window("SortCriteriaPage"))
+    , m_xBox(m_xBuilder->weld_container("SortKeyWindow"))
+    , m_aSortWin(m_xBox.get())
+{
+    // tdf#147722 set some nominal small default height so the height adapts
+    // to all the other contents and the natural height of this widget isn't
+    // an input into the overall size
+    m_xScrolledWindow->set_size_request(-1, 42);
+
+    Init();
+
+    m_aIdle.SetInvokeHandler(LINK(this, ScTabPageSortFields, ScrollToEndHdl));
+
+    SetExchangeSupport();
+}
+
+ScTabPageSortFields::~ScTabPageSortFields()
+{
+    m_aSortWin.m_aSortKeyItems.clear();
+    m_xBox.reset();
+    m_xScrolledWindow.reset();
+}
+
+void ScTabPageSortFields::Init()
+{
+    // Check whether the field that is passed on is a database field:
+    ScDocument* pDoc = pViewData ? &pViewData->GetDocument() : nullptr;
+    if ( pDoc )
+    {
+        ScDBCollection* pDBColl = pDoc->GetDBCollection();
+        const SCTAB     nCurTab = pViewData->GetTabNo();
+        if ( pDBColl )
+        {
+            ScDBData* pDBData
+                    = pDBColl->GetDBAtArea( nCurTab,
+                                            aSortData.nCol1, aSortData.nRow1,
+                                            aSortData.nCol2, aSortData.nRow2 );
+            if ( pDBData )
+            {
+                m_xBtnHeader->set_active(pDBData->HasHeader());
+            }
+        }
+    }
+    m_xBtnHeader->set_label(aStrColLabel);
+
+    Link<weld::Toggleable&,void> aLink = LINK(this, ScTabPageSortFields, SortDirHdl );
+    m_xBtnTopDown->connect_toggled( aLink );
+    m_xBtnLeftRight->connect_toggled( aLink );
+    m_xBtnHeader->connect_toggled( aLink );
+
+    const ScSortItem& rSortItem = GetItemSet().Get( nWhichSort );
+
+    pViewData = rSortItem.GetViewData();
+    OSL_ENSURE( pViewData, "ViewData not found!" );
+
+    nFieldArr.push_back( 0 );
+
+    // Create three sort key dialogs by default
+    for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+    {
+        AddSortKey(i+1);
+        m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->connect_changed(LINK(this, ScTabPageSortFields, SelectHdl));
+    }
+}
+
+std::unique_ptr<SfxTabPage> ScTabPageSortFields::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* pArgSet)
+{
+    return std::make_unique<ScTabPageSortFields>(pPage, pController, *pArgSet);
+}
+
+void ScTabPageSortFields::Reset( const SfxItemSet* /* rArgSet */ )
+{
+    m_xBtnHeader->set_active( aSortData.bHasHeader );
+    m_xBtnTopDown->set_active( aSortData.bByRow );
+    m_xBtnLeftRight->set_active( !aSortData.bByRow );
+
+    if (m_aSortWin.m_aSortKeyItems[0]->m_xLbSort->get_count() == 0)
+        FillFieldLists(0);
+
+    // ListBox selection:
+    if (!aSortData.maKeyState.empty() && aSortData.maKeyState[0].bDoSort)
+    {
+        // Make sure that the all sort keys are reset
+        for ( sal_uInt16 i=nSortKeyCount; i<aSortData.GetSortKeyCount(); i++ )
+        {
+            AddSortKey(i+1);
+            m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->connect_changed( LINK( this,
+                                 ScTabPageSortFields, SelectHdl ) );
+        }
+        nSortKeyCount = aSortData.GetSortKeyCount();
+        FillFieldLists(0);
+
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+        {
+            if (aSortData.maKeyState[i].bDoSort )
+            {
+                m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->set_active( GetFieldSelPos(
+                                    aSortData.maKeyState[i].nField ) );
+                (aSortData.maKeyState[i].bAscending)
+                    ? m_aSortWin.m_aSortKeyItems[i]->m_xBtnUp->set_active(true)
+                    : m_aSortWin.m_aSortKeyItems[i]->m_xBtnDown->set_active(true);
+            }
+            else
+            {
+                m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->set_active(0); // Select none
+                m_aSortWin.m_aSortKeyItems[i]->m_xBtnUp->set_active(true);
+            }
+        }
+
+        // Enable or disable field depending on preceding Listbox selection
+        m_aSortWin.m_aSortKeyItems[0]->EnableField();
+        for ( sal_uInt16 i=1; i<nSortKeyCount; i++ )
+            if ( m_aSortWin.m_aSortKeyItems[i - 1]->m_xLbSort->get_active() == 0 )
+                m_aSortWin.m_aSortKeyItems[i]->DisableField();
+            else
+                m_aSortWin.m_aSortKeyItems[i]->EnableField();
+    }
+    else
+    {
+        SCCOL  nCol = pViewData->GetCurX();
+
+        if( nCol < aSortData.nCol1 )
+            nCol = aSortData.nCol1;
+        else if( nCol > aSortData.nCol2 )
+            nCol = aSortData.nCol2;
+
+        sal_uInt16  nSort1Pos = nCol - aSortData.nCol1+1;
+
+        m_aSortWin.m_aSortKeyItems[0]->m_xLbSort->set_active(nSort1Pos);
+        for ( sal_uInt16 i=1; i<nSortKeyCount; i++ )
+            m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->set_active(0);
+
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+            m_aSortWin.m_aSortKeyItems[i]->m_xBtnUp->set_active(true);
+
+        m_aSortWin.m_aSortKeyItems[0]->EnableField();
+        m_aSortWin.m_aSortKeyItems[1]->EnableField();
+        for ( sal_uInt16 i=2; i<nSortKeyCount; i++ )
+            m_aSortWin.m_aSortKeyItems[i]->DisableField();
+    }
+
+    // Make sure that there is always a last undefined sort key
+    if (m_aSortWin.m_aSortKeyItems[nSortKeyCount - 1]->m_xLbSort->get_active() > 0)
+        SetLastSortKey( nSortKeyCount );
+}
+
+bool ScTabPageSortFields::FillItemSet( SfxItemSet* rArgSet )
+{
+    ScSortParam aNewSortData = aSortData;
+
+    const SfxItemSet* pExample = GetDialogExampleSet();
+    if (pExample)
+    {
+        if (const ScSortItem* pItem = pExample->GetItemIfSet(nWhichSort))
+        {
+            ScSortParam aTempData = pItem->GetSortData();
+            aTempData.maKeyState = aNewSortData.maKeyState;
+            aNewSortData = aTempData;
+        }
+    }
+    aNewSortData.bByRow        = m_xBtnTopDown->get_active();
+    aNewSortData.bHasHeader    = m_xBtnHeader->get_active();
+
+    std::vector<sal_Int32>  nSortPos;
+
+    for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+    {
+        nSortPos.push_back(m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->get_active());
+        if (nSortPos[i] == -1) nSortPos[i] = 0;
+    }
+
+    if( nSortKeyCount >= aNewSortData.GetSortKeyCount() )
+        aNewSortData.maKeyState.resize(nSortKeyCount);
+
+    if ( nSortPos[0] > 0 )
+    {
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+        {
+            aNewSortData.maKeyState[i].bDoSort = (nSortPos[i] > 0);
+            aNewSortData.maKeyState[i].nField = nFieldArr[nSortPos[i]];
+            aNewSortData.maKeyState[i].bAscending = m_aSortWin.m_aSortKeyItems[i]->m_xBtnUp->get_active();
+        }
+    }
+    else
+    {
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+            aNewSortData.maKeyState[i].bDoSort = false;
+    }
+
+    rArgSet->Put( ScSortItem( SCITEM_SORTDATA, nullptr, &aNewSortData ) );
+
+    return true;
+}
+
+// for data exchange without dialogue detour:
+void ScTabPageSortFields::ActivatePage( const SfxItemSet& rSet )
+{
+    // Refresh local copy with shared data
+    aSortData = rSet.Get( SCITEM_SORTDATA ).GetSortData();
+
+    m_xBtnHeader->set_active( aSortData.bHasHeader );
+    m_xBtnTopDown->set_active( aSortData.bByRow );
+    m_xBtnLeftRight->set_active( !aSortData.bByRow );
+}
+
+DeactivateRC ScTabPageSortFields::DeactivatePage( SfxItemSet* pSetP )
+{
+    if ( pSetP )
+        FillItemSet( pSetP );
+
+    return DeactivateRC::LeavePage;
+}
+
+void ScTabPageSortFields::FillFieldLists( sal_uInt16 nStartField )
+{
+    if ( !pViewData )
+        return;
+
+    ScDocument& rDoc = pViewData->GetDocument();
+
+    for (sal_uInt16 j = nStartField; j < nSortKeyCount; ++j)
+    {
+        m_aSortWin.m_aSortKeyItems[j]->m_xLabel->set_label(aSortData.bByRow ? aStrColumn : aStrRow);
+        m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->clear();
+        m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->freeze();
+        m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->append_text(aStrUndefined);
+    }
+
+    SCCOL   nFirstSortCol   = aSortData.nCol1;
+    SCROW   nFirstSortRow   = aSortData.nRow1;
+    SCTAB   nTab        = pViewData->GetTabNo();
+    sal_uInt16  i           = 1;
+    nFieldArr.clear();
+    nFieldArr.push_back(0);
+
+    if ( aSortData.bByRow )
+    {
+        OUString  aFieldName;
+        SCCOL   nMaxCol = rDoc.ClampToAllocatedColumns(nTab, aSortData.nCol2);
+        SCCOL   col;
+
+        for ( col=nFirstSortCol; col<=nMaxCol && i<SC_MAXFIELDS(rDoc.GetSheetLimits()); col++ )
+        {
+            aFieldName = rDoc.GetString(col, nFirstSortRow, nTab);
+            if ( !aSortData.bHasHeader || aFieldName.isEmpty() )
+                aFieldName = ScColToAlpha( col );
+            nFieldArr.push_back( col );
+
+            for ( sal_uInt16 j=nStartField; j<nSortKeyCount; j++ )
+                m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->insert_text(i, aFieldName);
+
+            i++;
+        }
+    }
+    else
+    {
+        OUString  aFieldName;
+        SCROW   nMaxRow = aSortData.nRow2;
+        SCROW   row;
+
+        for ( row=nFirstSortRow; row<=nMaxRow && i<SC_MAXFIELDS(rDoc.GetSheetLimits()); row++ )
+        {
+            aFieldName = rDoc.GetString(nFirstSortCol, row, nTab);
+            if ( !aSortData.bHasHeader || aFieldName.isEmpty() )
+                aFieldName = OUString::number( row+1);
+            nFieldArr.push_back( row );
+
+            for ( sal_uInt16 j=nStartField; j<nSortKeyCount; j++ )
+                m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->insert_text(i, aFieldName);
+
+            i++;
+        }
+    }
+
+    for (sal_uInt16 j=nStartField; j < nSortKeyCount; ++j)
+    {
+        m_aSortWin.m_aSortKeyItems[j]->m_xLbSort->thaw();
+    }
+
+    nFieldCount = i;
+}
+
+sal_uInt16 ScTabPageSortFields::GetFieldSelPos( SCCOLROW nField )
+{
+    sal_uInt16  nFieldPos   = 0;
+    bool    bFound      = false;
+
+    for ( sal_uInt16 n=1; n<nFieldCount && !bFound; n++ )
+    {
+        if ( nFieldArr[n] == nField )
+        {
+            nFieldPos = n;
+            bFound = true;
+        }
+    }
+
+    return nFieldPos;
+}
+
+void ScTabPageSortFields::SetLastSortKey( sal_uInt16 nItem )
+{
+    // Extend local SortParam copy
+    const ScSortKeyState atempKeyState = { 0, false, true };
+    aSortData.maKeyState.push_back( atempKeyState );
+
+    // Add Sort Key Item
+    ++nSortKeyCount;
+    AddSortKey( nSortKeyCount );
+    m_aSortWin.m_aSortKeyItems[nItem]->m_xLbSort->connect_changed(
+                     LINK( this, ScTabPageSortFields, SelectHdl ) );
+
+    FillFieldLists( nItem );
+
+    // Set Status
+    m_aSortWin.m_aSortKeyItems[nItem]->m_xBtnUp->set_active(true);
+    m_aSortWin.m_aSortKeyItems[nItem]->m_xLbSort->set_active(0);
+}
+
+// Handler:
+
+IMPL_LINK_NOARG(ScTabPageSortFields, SortDirHdl, weld::Toggleable&, void)
+{
+    if ( (m_xBtnTopDown->get_active() != aSortData.bByRow) || (m_xBtnHeader->get_active() != aSortData.bHasHeader))
+    {
+        if (m_xBtnTopDown->get_active())
+            m_xBtnHeader->set_label(aStrColLabel);
+        else
+            m_xBtnHeader->set_label(aStrRowLabel);
+
+        aSortData.bByRow     = m_xBtnTopDown->get_active();
+        aSortData.bHasHeader = m_xBtnHeader->get_active();
+
+        // remember selection
+        std::vector<sal_uInt16> nCurSel;
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+            nCurSel.push_back( m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->get_active() );
+
+        FillFieldLists(0);
+
+        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+            m_aSortWin.m_aSortKeyItems[i]->m_xLbSort->set_active(nCurSel[i]);
+    }
+}
+
+IMPL_LINK( ScTabPageSortFields, SelectHdl, weld::ComboBox&, rLb, void )
+{
+    OUString aSelEntry = rLb.get_active_text();
+    ScSortKeyItems::iterator pIter;
+
+    // If last listbox is enabled add one item
+    if (m_aSortWin.m_aSortKeyItems.back()->m_xLbSort.get() == &rLb)
+    {
+        if ( aSelEntry != aStrUndefined )
+        {
+            SetLastSortKey( nSortKeyCount );
+            return;
+        }
+    }
+
+    // Find selected listbox
+    pIter = std::find_if(m_aSortWin.m_aSortKeyItems.begin(), m_aSortWin.m_aSortKeyItems.end(),
+        [&rLb](const ScSortKeyItems::value_type& rItem) { return rItem->m_xLbSort.get() == &rLb; });
+
+    if (pIter == m_aSortWin.m_aSortKeyItems.end())
+        return;
+
+    // If not selecting the last Listbox, modify the succeeding ones
+    ++pIter;
+    if ( std::distance(m_aSortWin.m_aSortKeyItems.begin(), pIter) >= nSortKeyCount )
+        return;
+
+    if ( aSelEntry == aStrUndefined )
+    {
+        for ( ; pIter != m_aSortWin.m_aSortKeyItems.end(); ++pIter )
+        {
+            (*pIter)->m_xLbSort->set_active(0);
+
+            (*pIter)->DisableField();
+        }
+    }
+    else
+    {
+        (*pIter)->EnableField();
+    }
+}
+
+IMPL_LINK_NOARG(ScTabPageSortFields, ScrollToEndHdl, Timer*, void)
+{
+    m_xScrolledWindow->vadjustment_set_value(m_xScrolledWindow->vadjustment_get_upper());
+}
+
+void ScTabPageSortFields::AddSortKey( sal_uInt16 nItem )
+{
+    m_aSortWin.AddSortKey(nItem);
+    m_aIdle.Start();
+}
+
+// Sort option Tab Page:
+
+ScTabPageSortOptions::ScTabPageSortOptions(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet)
+    : SfxTabPage(pPage, pController, "modules/scalc/ui/sortoptionspage.ui", "SortOptionsPage", &rArgSet)
+    , aStrUndefined(ScResId(SCSTR_UNDEFINED))
+    , nWhichSort(rArgSet.GetPool()->GetWhich(SID_SORT))
+    , aSortData(rArgSet.Get(nWhichSort).GetSortData())
+    , pViewData(nullptr)
+    , pDoc(nullptr)
+    , m_xBtnCase(m_xBuilder->weld_check_button("case"))
+    , m_xBtnFormats(m_xBuilder->weld_check_button("formats"))
+    , m_xBtnNaturalSort(m_xBuilder->weld_check_button("naturalsort"))
+    , m_xBtnCopyResult(m_xBuilder->weld_check_button("copyresult"))
+    , m_xLbOutPos(m_xBuilder->weld_combo_box("outarealb"))
+    , m_xEdOutPos(m_xBuilder->weld_entry("outareaed"))
+    , m_xBtnSortUser(m_xBuilder->weld_check_button("sortuser"))
+    , m_xLbSortUser(m_xBuilder->weld_combo_box("sortuserlb"))
+    , m_xLbLanguage(new SvxLanguageBox(m_xBuilder->weld_combo_box("language")))
+    , m_xFtAlgorithm(m_xBuilder->weld_label("algorithmft"))
+    , m_xLbAlgorithm(m_xBuilder->weld_combo_box("algorithmlb"))
+    , m_xBtnIncComments(m_xBuilder->weld_check_button("includenotes"))
+    , m_xBtnIncImages(m_xBuilder->weld_check_button("includeimages"))
+{
+    m_xLbSortUser->set_size_request(m_xLbSortUser->get_approximate_digit_width() * 50, -1);
+    m_xLbSortUser->set_accessible_description(ScResId(STR_A11Y_DESC_SORTUSER));
+    Init();
+    SetExchangeSupport();
+}
+
+void ScTabPageSortOptions::Init()
+{
+    //  CollatorResource has user-visible names for sort algorithms
+    m_xColRes.reset(new CollatorResource);
+
+    //! use CollatorWrapper from document?
+    m_xColWrap.reset(new CollatorWrapper(comphelper::getProcessComponentContext()));
+
+    const ScSortItem& rSortItem = GetItemSet().Get( nWhichSort );
+
+    m_xLbOutPos->connect_changed( LINK( this, ScTabPageSortOptions, SelOutPosHdl ) );
+    m_xBtnCopyResult->connect_toggled( LINK( this, ScTabPageSortOptions, EnableHdl ) );
+    m_xBtnSortUser->connect_toggled( LINK( this, ScTabPageSortOptions, EnableHdl ) );
+    m_xLbLanguage->connect_changed( LINK( this, ScTabPageSortOptions, FillAlgorHdl ) );
+
+    pViewData = rSortItem.GetViewData();
+    pDoc      = pViewData ? &pViewData->GetDocument() : nullptr;
+
+    OSL_ENSURE( pViewData, "ViewData not found! :-/" );
+
+    if ( pViewData && pDoc )
+    {
+        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
+
+        m_xLbOutPos->clear();
+        m_xLbOutPos->append_text(aStrUndefined);
+        m_xLbOutPos->set_sensitive(false);
+
+        ScAreaNameIterator aIter( *pDoc );
+        OUString aName;
+        ScRange aRange;
+        while ( aIter.Next( aName, aRange ) )
+        {
+            OUString aRefStr(aRange.aStart.Format(ScRefFlags::ADDR_ABS_3D, pDoc, eConv));
+            m_xLbOutPos->append(aRefStr, aName);
+        }
+
+        m_xLbOutPos->set_active(0);
+        m_xEdOutPos->set_text(OUString());
+    }
+
+    FillUserSortListBox();
+
+    //  get available languages
+
+    m_xLbLanguage->SetLanguageList( SvxLanguageListFlags::ALL | SvxLanguageListFlags::ONLY_KNOWN, false );
+    m_xLbLanguage->InsertLanguage( LANGUAGE_SYSTEM );
+}
+
+std::unique_ptr<SfxTabPage> ScTabPageSortOptions::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rArgSet)
+{
+    return std::make_unique<ScTabPageSortOptions>(pPage, pController, *rArgSet);
+}
+
+void ScTabPageSortOptions::Reset( const SfxItemSet* /* rArgSet */ )
+{
+    if ( aSortData.bUserDef )
+    {
+        m_xBtnSortUser->set_active(true);
+        m_xLbSortUser->set_sensitive(true);
+        m_xLbSortUser->set_active(aSortData.nUserIndex);
+    }
+    else
+    {
+        m_xBtnSortUser->set_active(false);
+        m_xLbSortUser->set_sensitive(false);
+        m_xLbSortUser->set_active(0);
+    }
+
+    m_xBtnCase->set_active( aSortData.bCaseSens );
+    m_xBtnFormats->set_active( aSortData.aDataAreaExtras.mbCellFormats );
+    m_xBtnNaturalSort->set_active( aSortData.bNaturalSort );
+    m_xBtnIncComments->set_active( aSortData.aDataAreaExtras.mbCellNotes );
+    m_xBtnIncImages->set_active( aSortData.aDataAreaExtras.mbCellDrawObjects );
+
+    LanguageType eLang = LanguageTag::convertToLanguageType( aSortData.aCollatorLocale, false);
+    if ( eLang == LANGUAGE_DONTKNOW )
+        eLang = LANGUAGE_SYSTEM;
+    m_xLbLanguage->set_active_id(eLang);
+    FillAlgor();               // get algorithms, select default
+    if ( !aSortData.aCollatorAlgorithm.isEmpty() )
+        m_xLbAlgorithm->set_active_text(m_xColRes->GetTranslation(aSortData.aCollatorAlgorithm));
+
+    if ( pDoc && !aSortData.bInplace )
+    {
+        ScRefFlags nFormat = (aSortData.nDestTab != pViewData->GetTabNo())
+                            ? ScRefFlags::RANGE_ABS_3D
+                            : ScRefFlags::RANGE_ABS;
+
+        theOutPos.Set( aSortData.nDestCol,
+                       aSortData.nDestRow,
+                       aSortData.nDestTab );
+
+        OUString aStr(theOutPos.Format(nFormat, pDoc, pDoc->GetAddressConvention()));
+        m_xBtnCopyResult->set_active(true);
+        m_xLbOutPos->set_sensitive(true);
+        m_xEdOutPos->set_sensitive(true);
+        m_xEdOutPos->set_text( aStr );
+        EdOutPosModHdl();
+        m_xEdOutPos->grab_focus();
+        m_xEdOutPos->select_region(0, -1);
+    }
+    else
+    {
+        m_xBtnCopyResult->set_active( false );
+        m_xLbOutPos->set_sensitive(false);
+        m_xEdOutPos->set_sensitive(false);
+        m_xEdOutPos->set_text( OUString() );
+    }
+}
+
+bool ScTabPageSortOptions::FillItemSet( SfxItemSet* rArgSet )
+{
+    // Create local copy of ScParam
+    ScSortParam aNewSortData = aSortData;
+
+    const SfxItemSet* pExample = GetDialogExampleSet();
+    if (pExample)
+    {
+        if (const ScSortItem* pSortItem = pExample->GetItemIfSet(nWhichSort))
+            aNewSortData = pSortItem->GetSortData();
+    }
+    aNewSortData.bCaseSens       = m_xBtnCase->get_active();
+    aNewSortData.bNaturalSort    = m_xBtnNaturalSort->get_active();
+    aNewSortData.aDataAreaExtras.mbCellNotes = m_xBtnIncComments->get_active();
+    aNewSortData.aDataAreaExtras.mbCellDrawObjects = m_xBtnIncImages->get_active();
+    aNewSortData.aDataAreaExtras.mbCellFormats = m_xBtnFormats->get_active();
+    aNewSortData.bInplace        = !m_xBtnCopyResult->get_active();
+    aNewSortData.nDestCol        = theOutPos.Col();
+    aNewSortData.nDestRow        = theOutPos.Row();
+    aNewSortData.nDestTab        = theOutPos.Tab();
+    aNewSortData.bUserDef        = m_xBtnSortUser->get_active();
+    aNewSortData.nUserIndex      = (m_xBtnSortUser->get_active())
+                                   ? m_xLbSortUser->get_active()
+                                   : 0;
+
+    // get locale
+    LanguageType eLang = m_xLbLanguage->get_active_id();
+    aNewSortData.aCollatorLocale = LanguageTag::convertToLocale( eLang, false);
+
+    // get algorithm
+    OUString sAlg;
+    if ( eLang != LANGUAGE_SYSTEM )
+    {
+        uno::Sequence<OUString> aAlgos = m_xColWrap->listCollatorAlgorithms(
+                aNewSortData.aCollatorLocale );
+        const int nSel = m_xLbAlgorithm->get_active();
+        if ( nSel < aAlgos.getLength() )
+            sAlg = aAlgos[nSel];
+    }
+    aNewSortData.aCollatorAlgorithm = sAlg;
+
+    rArgSet->Put( ScSortItem( SCITEM_SORTDATA, &aNewSortData ) );
+
+    return true;
+}
+
+// for data exchange without dialogue detour:
+void ScTabPageSortOptions::ActivatePage( const SfxItemSet& rSet )
+{
+    // Refresh local copy with shared data
+    aSortData = rSet.Get( SCITEM_SORTDATA ).GetSortData();
+    ScSortDlg* pDlg = static_cast<ScSortDlg*>(GetDialogController());
+    if (!pDlg)
+        return;
+}
+
+DeactivateRC ScTabPageSortOptions::DeactivatePage( SfxItemSet* pSetP )
+{
+    bool bPosInputOk = true;
+
+    if ( m_xBtnCopyResult->get_active() )
+    {
+        OUString    thePosStr = m_xEdOutPos->get_text();
+        ScAddress   thePos;
+        sal_Int32   nColonPos = thePosStr.indexOf( ':' );
+
+        if ( -1 != nColonPos )
+            thePosStr = thePosStr.copy( 0, nColonPos );
+
+        if ( pViewData )
+        {
+            //  visible table is default for input without table
+            //  must be changed to GetRefTabNo when sorting has RefInput!
+            thePos.SetTab( pViewData->GetTabNo() );
+        }
+
+        ScRefFlags nResult = thePos.Parse( thePosStr, *pDoc, pDoc->GetAddressConvention() );
+
+        bPosInputOk = (nResult & ScRefFlags::VALID) == ScRefFlags::VALID;
+
+        if ( !bPosInputOk )
+        {
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrameWeld(),
+                                                      VclMessageType::Warning, VclButtonsType::Ok,
+                                                      ScResId(STR_INVALID_TABREF)));
+            xBox->run();
+            m_xEdOutPos->grab_focus();
+            m_xEdOutPos->select_region(0, -1);
+            theOutPos.Set(0,0,0);
+        }
+        else
+        {
+            m_xEdOutPos->set_text(thePosStr);
+            theOutPos = thePos;
+        }
+    }
+
+    if ( pSetP && bPosInputOk )
+        FillItemSet( pSetP );
+
+    return bPosInputOk ? DeactivateRC::LeavePage : DeactivateRC::KeepPage;
+}
+
+void ScTabPageSortOptions::FillUserSortListBox()
+{
+    ScUserList* pUserLists = ScGlobal::GetUserList();
+
+    m_xLbSortUser->clear();
+    if ( pUserLists )
+    {
+        size_t nCount = pUserLists->size();
+        for (size_t i=0; i<nCount; ++i)
+            m_xLbSortUser->append_text((*pUserLists)[i].GetString());
+    }
+}
+
+// Handler:
+
+IMPL_LINK( ScTabPageSortOptions, EnableHdl, weld::Toggleable&, rButton, void )
+{
+    if (&rButton == m_xBtnCopyResult.get())
+    {
+        if (rButton.get_active())
+        {
+            m_xLbOutPos->set_sensitive(true);
+            m_xEdOutPos->set_sensitive(true);
+            m_xEdOutPos->grab_focus();
+        }
+        else
+        {
+            m_xLbOutPos->set_sensitive(false);
+            m_xEdOutPos->set_sensitive(false);
+        }
+    }
+    else if (&rButton == m_xBtnSortUser.get())
+    {
+        if (rButton.get_active())
+        {
+            m_xLbSortUser->set_sensitive(true);
+            m_xLbSortUser->grab_focus();
+        }
+        else
+            m_xLbSortUser->set_sensitive(false);
+    }
+}
+
+IMPL_LINK(ScTabPageSortOptions, SelOutPosHdl, weld::ComboBox&, rLb, void)
+{
+    if (&rLb == m_xLbOutPos.get())
+    {
+        OUString  aString;
+        const int nSelPos = m_xLbOutPos->get_active();
+
+        if (nSelPos > 0)
+            aString = m_xLbOutPos->get_id(nSelPos);
+
+        m_xEdOutPos->set_text(aString);
+    }
+}
+
+void ScTabPageSortOptions::EdOutPosModHdl()
+{
+    OUString  theCurPosStr = m_xEdOutPos->get_text();
+    ScRefFlags  nResult = ScAddress().Parse( theCurPosStr, *pDoc, pDoc->GetAddressConvention() );
+
+    if ( (nResult & ScRefFlags::VALID) != ScRefFlags::VALID )
+        return;
+
+    bool    bFound  = false;
+    sal_Int32 i = 0;
+    const int nCount = m_xLbOutPos->get_count();
+
+    for ( i=2; i<nCount && !bFound; i++ )
+    {
+        OUString aStr = m_xLbOutPos->get_id(i);
+        bFound = (theCurPosStr == aStr);
+    }
+
+    if ( bFound )
+        m_xLbOutPos->set_active(--i);
+    else
+        m_xLbOutPos->set_active(0);
+}
+
+void ScTabPageSortOptions::FillAlgor()
+{
+    tools::Long nCount = 0;
+
+    m_xLbAlgorithm->freeze();
+    m_xLbAlgorithm->clear();
+
+    LanguageType eLang = m_xLbLanguage->get_active_id();
+    if ( eLang == LANGUAGE_SYSTEM )
+    {
+        //  for LANGUAGE_SYSTEM no algorithm can be selected because
+        //  it wouldn't necessarily exist for other languages
+        //  -> leave list box empty if LANGUAGE_SYSTEM is selected
+        m_xFtAlgorithm->set_sensitive( false );           // nothing to select
+        m_xLbAlgorithm->set_sensitive( false );           // nothing to select
+    }
+    else
+    {
+        lang::Locale aLocale( LanguageTag::convertToLocale( eLang ));
+        const uno::Sequence<OUString> aAlgos = m_xColWrap->listCollatorAlgorithms( aLocale );
+
+        nCount = aAlgos.getLength();
+        for (const OUString& sAlg : aAlgos)
+        {
+            OUString sUser = m_xColRes->GetTranslation( sAlg );
+            m_xLbAlgorithm->append_text(sUser);
+        }
+    }
+
+    m_xLbAlgorithm->thaw();
+
+    m_xLbAlgorithm->set_active(nCount ? 0 : -1);    // first entry is default
+    m_xFtAlgorithm->set_sensitive(nCount > 1);      // enable only if there is a choice
+    m_xLbAlgorithm->set_sensitive(nCount > 1);      // enable only if there is a choice
+}
+
+IMPL_LINK_NOARG(ScTabPageSortOptions, FillAlgorHdl, weld::ComboBox&, void)
+{
+    FillAlgor();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/tpsubt.cxx b/sc/source/ui/dbgui/tpsubt.cxx
new file mode 100644
index 000000000..01431c815
--- /dev/null
+++ b/sc/source/ui/dbgui/tpsubt.cxx
@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#undef SC_DLLIMPLEMENTATION
+
+#include <scitems.hxx>
+#include <uiitems.hxx>
+#include <global.hxx>
+#include <userlist.hxx>
+#include <viewdata.hxx>
+#include <document.hxx>
+#include <scresid.hxx>
+#include <sc.hrc>
+#include <strings.hrc>
+#include <subtotals.hrc>
+
+#include <tpsubt.hxx>
+#include <tpsort.hxx>
+#include <memory>
+
+#include <osl/diagnose.h>
+
+// Subtotals group tabpage:
+
+ScTpSubTotalGroup::ScTpSubTotalGroup(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet, const sal_uInt16& rTabNumber)
+    : SfxTabPage(pPage, pController, "modules/scalc/ui/subtotalgrppage.ui", "SubTotalGrpPage", &rArgSet)
+    , aStrNone(ScResId(SCSTR_NONE))
+    , aStrColumn(ScResId(SCSTR_COLUMN_LETTER))
+    , pViewData(nullptr)
+    , pDoc(nullptr)
+    , nWhichSubTotals(rArgSet.GetPool()->GetWhich(SID_SUBTOTALS))
+    , rSubTotalData(rArgSet.Get(nWhichSubTotals).GetSubTotalData())
+    , nFieldCount(0)
+    , mxLbGroup(m_xBuilder->weld_combo_box("group_by"))
+    , mxLbColumns(m_xBuilder->weld_tree_view("columns"))
+    , mxLbFunctions(m_xBuilder->weld_tree_view("functions"))
+    , mxLbSelectAllColumns(m_xBuilder->weld_check_button("select_all_columns_button"))
+{
+    for (size_t i = 0; i < SAL_N_ELEMENTS(SCSTR_SUBTOTALS); ++i)
+        mxLbFunctions->append_text(ScResId(SCSTR_SUBTOTALS[i]));
+
+    auto nHeight = mxLbColumns->get_height_rows(14);
+    mxLbColumns->set_size_request(-1, nHeight);
+    mxLbFunctions->set_size_request(-1, nHeight);
+
+    mxLbColumns->enable_toggle_buttons(weld::ColumnToggleType::Check);
+
+    Init();
+
+    // UI tests
+    mxLbGroup->set_buildable_name(mxLbGroup->get_buildable_name() + OString::number(rTabNumber));
+    mxLbColumns->set_buildable_name(mxLbColumns->get_buildable_name() + OString::number(rTabNumber));
+}
+
+ScTpSubTotalGroup::~ScTpSubTotalGroup()
+{
+}
+
+void ScTpSubTotalGroup::Init()
+{
+    const ScSubTotalItem& rSubTotalItem = GetItemSet().Get( nWhichSubTotals );
+
+    pViewData = rSubTotalItem.GetViewData();
+    assert(pViewData && "CreateScSubTotalDlg aArgSet must contain a ScSubTotalItem with ViewData set");
+    pDoc = &pViewData->GetDocument();
+    assert(pDoc && "Document not found :-(");
+
+    mxLbGroup->connect_changed( LINK( this, ScTpSubTotalGroup, SelectListBoxHdl ) );
+    mxLbColumns->connect_changed( LINK( this, ScTpSubTotalGroup, SelectTreeListBoxHdl ) );
+    mxLbColumns->connect_toggled( LINK( this, ScTpSubTotalGroup, CheckHdl ) );
+    mxLbFunctions->connect_changed( LINK( this, ScTpSubTotalGroup, SelectTreeListBoxHdl) );
+    mxLbSelectAllColumns->connect_toggled( LINK( this, ScTpSubTotalGroup, CheckBoxHdl ) );
+
+    mnFieldArr.resize(SC_MAXFIELDS(pDoc->GetSheetLimits()));
+    mnFieldArr[0] = 0;
+    FillListBoxes();
+}
+
+namespace
+{
+    int GetCheckedEntryCount(weld::TreeView& rTreeView)
+    {
+        int nRet = 0;
+
+        rTreeView.all_foreach([&](const weld::TreeIter& rEntry) {
+            if ( rTreeView.get_toggle(rEntry) == TRISTATE_TRUE )
+                ++nRet;
+            return false;
+        });
+
+        return nRet;
+    }
+}
+
+bool ScTpSubTotalGroup::DoReset( sal_uInt16             nGroupNo,
+                                 const SfxItemSet&  rArgSet  )
+{
+    sal_uInt16 nGroupIdx = 0;
+
+    OSL_ENSURE( (nGroupNo<=3) && (nGroupNo>0), "Invalid group" );
+
+    if ( (nGroupNo > 3) || (nGroupNo == 0) )
+        return false;
+    else
+        nGroupIdx = nGroupNo-1;
+
+    // first we have to clear the listboxes...
+    for (int nLbEntry = 0, nCount = mxLbColumns->n_children(); nLbEntry < nCount; ++nLbEntry)
+    {
+        mxLbColumns->set_toggle(nLbEntry, TRISTATE_FALSE);
+        mxLbColumns->set_id(nLbEntry, "0");
+    }
+    mxLbFunctions->select(0);
+
+    const ScSubTotalParam & theSubTotalData( rArgSet.Get( nWhichSubTotals ).GetSubTotalData() );
+
+    if ( theSubTotalData.bGroupActive[nGroupIdx] )
+    {
+        SCCOL           nField      = theSubTotalData.nField[nGroupIdx];
+        SCCOL           nSubTotals  = theSubTotalData.nSubTotals[nGroupIdx];
+        SCCOL*          pSubTotals  = theSubTotalData.pSubTotals[nGroupIdx].get();
+        ScSubTotalFunc* pFunctions  = theSubTotalData.pFunctions[nGroupIdx].get();
+
+        mxLbGroup->set_active( GetFieldSelPos( nField )+1 );
+
+        sal_uInt16 nFirstChecked = 0;
+        for ( sal_uInt16 i=0; i<nSubTotals; i++ )
+        {
+            sal_uInt16  nCheckPos = GetFieldSelPos( pSubTotals[i] );
+
+            mxLbColumns->set_toggle(nCheckPos, TRISTATE_TRUE);
+            mxLbColumns->set_id(nCheckPos, OUString::number(FuncToLbPos(pFunctions[i])));
+
+            if (i == 0 || nCheckPos < nFirstChecked)
+                nFirstChecked = nCheckPos;
+        }
+        // Select the first checked field from the top.
+        mxLbColumns->select(nFirstChecked);
+    }
+    else
+    {
+        mxLbGroup->set_active( (nGroupNo == 1) ? 1 : 0 );
+        mxLbColumns->select( 0 );
+        mxLbFunctions->select( 0 );
+    }
+
+    if ( mxLbColumns->n_children() == GetCheckedEntryCount(*mxLbColumns) )
+        mxLbSelectAllColumns->set_active( true );
+    else
+        mxLbSelectAllColumns->set_active( false );
+
+    return true;
+}
+
+bool ScTpSubTotalGroup::DoFillItemSet( sal_uInt16       nGroupNo,
+                                       SfxItemSet&  rArgSet  )
+{
+    sal_uInt16 nGroupIdx = 0;
+
+    OSL_ENSURE( (nGroupNo<=3) && (nGroupNo>0), "Invalid group" );
+    OSL_ENSURE(    (mxLbGroup->get_count() > 0)
+                && (mxLbColumns->n_children() > 0)
+                && (mxLbFunctions->n_children() > 0),
+                "Non-initialized Lists" );
+
+    if (  (nGroupNo > 3) || (nGroupNo == 0)
+        || (mxLbGroup->get_count() == 0)
+        || (mxLbColumns->n_children() == 0)
+        || (mxLbFunctions->n_children() == 0)
+       )
+        return false;
+    else
+        nGroupIdx = nGroupNo-1;
+
+    ScSubTotalParam theSubTotalData;            // read out, if already partly filled
+    const SfxItemSet* pExample = GetDialogExampleSet();
+    if (pExample)
+    {
+        if (const ScSubTotalItem* pItem = pExample->GetItemIfSet(nWhichSubTotals))
+            theSubTotalData = pItem->GetSubTotalData();
+    }
+
+    std::unique_ptr<ScSubTotalFunc[]> pFunctions;
+    std::unique_ptr<SCCOL[]>          pSubTotals;
+    const sal_Int32 nGroup      = mxLbGroup->get_active();
+    const sal_Int32 nEntryCount = mxLbColumns->n_children();
+    const sal_Int32 nCheckCount = GetCheckedEntryCount(*mxLbColumns);
+
+    theSubTotalData.nCol1                   = rSubTotalData.nCol1;
+    theSubTotalData.nRow1                   = rSubTotalData.nRow1;
+    theSubTotalData.nCol2                   = rSubTotalData.nCol2;
+    theSubTotalData.nRow2                   = rSubTotalData.nRow2;
+    theSubTotalData.bGroupActive[nGroupIdx] = (nGroup != 0);
+    theSubTotalData.nField[nGroupIdx]       = (nGroup != 0)
+                                                ? mnFieldArr[nGroup-1]
+                                                : static_cast<SCCOL>(0);
+
+    if ( nEntryCount>0 && nCheckCount>0 && nGroup!=0 )
+    {
+        sal_uInt16 nFunction    = 0;
+
+        pSubTotals.reset(new SCCOL          [nCheckCount]);
+        pFunctions.reset(new ScSubTotalFunc [nCheckCount]);
+
+        for ( sal_Int32 i=0, nCheck=0; i<nEntryCount; i++ )
+        {
+            if (mxLbColumns->get_toggle(i) == TRISTATE_TRUE)
+            {
+                OSL_ENSURE( nCheck <= nCheckCount,
+                            "Range error :-(" );
+                nFunction = mxLbColumns->get_id(i).toUInt32();
+                pSubTotals[nCheck] = mnFieldArr[i];
+                pFunctions[nCheck] = LbPosToFunc( nFunction );
+                nCheck++;
+            }
+        }
+        theSubTotalData.SetSubTotals( nGroupNo,      // group number
+                                      pSubTotals.get(),
+                                      pFunctions.get(),
+                                      nCheckCount ); // number of array elements
+
+    }
+
+    rArgSet.Put( ScSubTotalItem( SCITEM_SUBTDATA, nullptr, &theSubTotalData ) );
+
+    return true;
+}
+
+void ScTpSubTotalGroup::FillListBoxes()
+{
+    assert(pViewData && pDoc && "CreateScSubTotalDlg aArgSet must contain a ScSubTotalItem with ViewData set");
+
+    SCCOL   nFirstCol   = rSubTotalData.nCol1;
+    SCROW   nFirstRow   = rSubTotalData.nRow1;
+    SCTAB   nTab        = pViewData->GetTabNo();
+    SCCOL   nMaxCol     = rSubTotalData.nCol2;
+    SCCOL   col;
+    OUString  aFieldName;
+
+    mxLbGroup->clear();
+    mxLbColumns->clear();
+    mxLbGroup->insert_text(0, aStrNone );
+
+    mxLbColumns->freeze();
+    sal_uInt16 i=0;
+    for ( col=nFirstCol; col<=nMaxCol && i<SC_MAXFIELDS(pDoc->GetSheetLimits()); col++ )
+    {
+        aFieldName = pDoc->GetString(col, nFirstRow, nTab);
+        if ( aFieldName.isEmpty() )
+        {
+            aFieldName = ScGlobal::ReplaceOrAppend( aStrColumn, u"%1", ScColToAlpha( col ));
+        }
+        mnFieldArr[i] = col;
+        mxLbGroup->insert_text(i+1, aFieldName);
+        mxLbColumns->insert(i);
+        mxLbColumns->set_toggle(i, TRISTATE_FALSE);
+        mxLbColumns->set_text(i, aFieldName, 0);
+        mxLbColumns->set_id(i, "0");
+        i++;
+    }
+    mxLbColumns->thaw();
+
+    // subsequent initialization of the constant:
+    nFieldCount = i;
+}
+
+sal_uInt16 ScTpSubTotalGroup::GetFieldSelPos( SCCOL nField )
+{
+    sal_uInt16  nFieldPos   = 0;
+    bool    bFound      = false;
+
+    for ( sal_uInt16 n=0; n<nFieldCount && !bFound; n++ )
+    {
+        if ( mnFieldArr[n] == nField )
+        {
+            nFieldPos = n;
+            bFound = true;
+        }
+    }
+
+    return nFieldPos;
+}
+
+ScSubTotalFunc ScTpSubTotalGroup::LbPosToFunc( sal_uInt16 nPos )
+{
+    switch ( nPos )
+    {
+//      case  0:    return SUBTOTAL_FUNC_NONE;
+        case  2:    return SUBTOTAL_FUNC_AVE;
+        case  6:    return SUBTOTAL_FUNC_CNT;
+        case  1:    return SUBTOTAL_FUNC_CNT2;
+        case  3:    return SUBTOTAL_FUNC_MAX;
+        case  4:    return SUBTOTAL_FUNC_MIN;
+        case  5:    return SUBTOTAL_FUNC_PROD;
+        case  7:    return SUBTOTAL_FUNC_STD;
+        case  8:    return SUBTOTAL_FUNC_STDP;
+        case  0:    return SUBTOTAL_FUNC_SUM;
+        case  9:    return SUBTOTAL_FUNC_VAR;
+        case 10:    return SUBTOTAL_FUNC_VARP;
+        default:
+            OSL_FAIL( "ScTpSubTotalGroup::LbPosToFunc" );
+            return SUBTOTAL_FUNC_NONE;
+    }
+}
+
+sal_uInt16 ScTpSubTotalGroup::FuncToLbPos( ScSubTotalFunc eFunc )
+{
+    switch ( eFunc )
+    {
+//      case SUBTOTAL_FUNC_NONE:    return 0;
+        case SUBTOTAL_FUNC_AVE:     return 2;
+        case SUBTOTAL_FUNC_CNT:     return 6;
+        case SUBTOTAL_FUNC_CNT2:    return 1;
+        case SUBTOTAL_FUNC_MAX:     return 3;
+        case SUBTOTAL_FUNC_MIN:     return 4;
+        case SUBTOTAL_FUNC_PROD:    return 5;
+        case SUBTOTAL_FUNC_STD:     return 7;
+        case SUBTOTAL_FUNC_STDP:    return 8;
+        case SUBTOTAL_FUNC_SUM:     return 0;
+        case SUBTOTAL_FUNC_VAR:     return 9;
+        case SUBTOTAL_FUNC_VARP:    return 10;
+        default:
+            OSL_FAIL( "ScTpSubTotalGroup::FuncToLbPos" );
+            return 0;
+    }
+}
+
+// Handler:
+
+IMPL_LINK(ScTpSubTotalGroup, SelectTreeListBoxHdl, weld::TreeView&, rLb, void)
+{
+    SelectHdl(&rLb);
+
+    if ( mxLbColumns->n_children() == GetCheckedEntryCount(*mxLbColumns) )
+        mxLbSelectAllColumns->set_active( true );
+    else
+        mxLbSelectAllColumns->set_active( false );
+}
+
+IMPL_LINK(ScTpSubTotalGroup, SelectListBoxHdl, weld::ComboBox&, rLb, void)
+{
+    SelectHdl(&rLb);
+}
+
+void ScTpSubTotalGroup::SelectHdl(const weld::Widget *pLb)
+{
+    const sal_Int32 nColumn = mxLbColumns->get_selected_index();
+    if (nColumn == -1)
+        return;
+
+    const sal_Int32 nFunction   = mxLbFunctions->get_selected_index();
+    sal_uInt16      nOldFunction  = mxLbColumns->get_id(nColumn).toUInt32();
+
+    if ( pLb == mxLbColumns.get() )
+    {
+        mxLbFunctions->select(nOldFunction);
+    }
+    else if ( pLb == mxLbFunctions.get() )
+    {
+        mxLbColumns->set_id(nColumn, OUString::number(nFunction));
+        mxLbColumns->set_toggle(nColumn, TRISTATE_TRUE);
+    }
+}
+
+IMPL_LINK( ScTpSubTotalGroup, CheckHdl, const weld::TreeView::iter_col&, rRowCol, void )
+{
+    mxLbColumns->select(rRowCol.first);
+    SelectHdl(mxLbColumns.get());
+
+    if ( mxLbColumns->n_children() == GetCheckedEntryCount(*mxLbColumns) )
+        mxLbSelectAllColumns->set_active( true );
+    else
+        mxLbSelectAllColumns->set_active( false );
+}
+
+// Derived Group TabPages:
+
+std::unique_ptr<SfxTabPage> ScTpSubTotalGroup1::Create( weld::Container* pPage, weld::DialogController* pController,
+                                                 const SfxItemSet*  rArgSet )
+{
+    return std::make_unique<ScTpSubTotalGroup1>( pPage, pController, *rArgSet );
+}
+
+std::unique_ptr<SfxTabPage> ScTpSubTotalGroup2::Create( weld::Container* pPage, weld::DialogController* pController,
+                                       const SfxItemSet*    rArgSet )
+{
+    return std::make_unique<ScTpSubTotalGroup2>( pPage, pController, *rArgSet );
+}
+
+std::unique_ptr<SfxTabPage> ScTpSubTotalGroup3::Create( weld::Container* pPage, weld::DialogController* pController,
+                                       const SfxItemSet*    rArgSet )
+{
+    return std::make_unique<ScTpSubTotalGroup3>( pPage, pController, *rArgSet );
+}
+
+ScTpSubTotalGroup1::ScTpSubTotalGroup1( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet ) :
+    ScTpSubTotalGroup( pPage, pController, rArgSet, 1 )
+{}
+
+ScTpSubTotalGroup2::ScTpSubTotalGroup2( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet ) :
+    ScTpSubTotalGroup( pPage, pController, rArgSet, 2 )
+{}
+
+ScTpSubTotalGroup3::ScTpSubTotalGroup3( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet ) :
+    ScTpSubTotalGroup( pPage, pController, rArgSet, 3 )
+{}
+
+#define RESET(i) (ScTpSubTotalGroup::DoReset( (i), *rArgSet ))
+void ScTpSubTotalGroup1::Reset( const SfxItemSet* rArgSet ) { RESET(1); }
+void ScTpSubTotalGroup2::Reset( const SfxItemSet* rArgSet ) { RESET(2); }
+void ScTpSubTotalGroup3::Reset( const SfxItemSet* rArgSet ) { RESET(3); }
+#undef RESET
+
+#define FILLSET(i) (ScTpSubTotalGroup::DoFillItemSet( (i), *rArgSet ))
+bool ScTpSubTotalGroup1::FillItemSet( SfxItemSet* rArgSet ) { return FILLSET(1); }
+bool ScTpSubTotalGroup2::FillItemSet( SfxItemSet* rArgSet ) { return FILLSET(2); }
+bool ScTpSubTotalGroup3::FillItemSet( SfxItemSet* rArgSet ) { return FILLSET(3); }
+#undef FILL
+
+// options tab page:
+
+ScTpSubTotalOptions::ScTpSubTotalOptions(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet)
+
+        :   SfxTabPage      ( pPage, pController,
+                              "modules/scalc/ui/subtotaloptionspage.ui", "SubTotalOptionsPage",
+                              &rArgSet ),
+            pViewData       ( nullptr ),
+            pDoc            ( nullptr ),
+            nWhichSubTotals ( rArgSet.GetPool()->GetWhich( SID_SUBTOTALS ) ),
+            rSubTotalData   ( rArgSet.Get( nWhichSubTotals ).GetSubTotalData() )
+    , m_xBtnPagebreak(m_xBuilder->weld_check_button("pagebreak"))
+    , m_xBtnCase(m_xBuilder->weld_check_button("case"))
+    , m_xBtnSort(m_xBuilder->weld_check_button("sort"))
+    , m_xFlSort(m_xBuilder->weld_label("label2"))
+    , m_xBtnAscending(m_xBuilder->weld_radio_button("ascending"))
+    , m_xBtnDescending(m_xBuilder->weld_radio_button("descending"))
+    , m_xBtnFormats(m_xBuilder->weld_check_button("formats"))
+    , m_xBtnUserDef(m_xBuilder->weld_check_button("btnuserdef"))
+    , m_xLbUserDef(m_xBuilder->weld_combo_box("lbuserdef"))
+{
+    m_xLbUserDef->set_accessible_description(ScResId(STR_A11Y_DESC_USERDEF));
+    m_xBtnUserDef->set_accessible_description(ScResId(STR_A11Y_DESC_USERDEF));
+    Init();
+}
+
+ScTpSubTotalOptions::~ScTpSubTotalOptions()
+{
+}
+
+void ScTpSubTotalOptions::Init()
+{
+    const ScSubTotalItem& rSubTotalItem = GetItemSet().Get( nWhichSubTotals );
+
+    pViewData   = rSubTotalItem.GetViewData();
+    assert(pViewData && "CreateScSubTotalDlg aArgSet must contain a ScSubTotalItem with ViewData set");
+    pDoc = &pViewData->GetDocument();
+    assert(pDoc && "Document not found!");
+
+    m_xBtnSort->connect_toggled( LINK( this, ScTpSubTotalOptions, CheckHdl ) );
+    m_xBtnUserDef->connect_toggled( LINK( this, ScTpSubTotalOptions, CheckHdl ) );
+
+    FillUserSortListBox();
+}
+
+std::unique_ptr<SfxTabPage> ScTpSubTotalOptions::Create(weld::Container* pPage, weld::DialogController* pController,
+                                               const SfxItemSet* rArgSet)
+{
+    return std::make_unique<ScTpSubTotalOptions>(pPage, pController, *rArgSet);
+}
+
+void ScTpSubTotalOptions::Reset( const SfxItemSet* /* rArgSet */ )
+{
+    m_xBtnPagebreak->set_active( rSubTotalData.bPagebreak );
+    m_xBtnCase->set_active( rSubTotalData.bCaseSens );
+    m_xBtnFormats->set_active( rSubTotalData.bIncludePattern );
+    m_xBtnSort->set_active( rSubTotalData.bDoSort );
+    m_xBtnAscending->set_active( rSubTotalData.bAscending );
+    m_xBtnDescending->set_active( !rSubTotalData.bAscending );
+
+    if ( rSubTotalData.bUserDef )
+    {
+        m_xBtnUserDef->set_active(true);
+        m_xLbUserDef->set_sensitive(true);
+        m_xLbUserDef->set_active(rSubTotalData.nUserIndex);
+    }
+    else
+    {
+        m_xBtnUserDef->set_active( false );
+        m_xLbUserDef->set_sensitive(false);
+        m_xLbUserDef->set_active(0);
+    }
+
+    CheckHdl(*m_xBtnSort);
+}
+
+bool ScTpSubTotalOptions::FillItemSet( SfxItemSet* rArgSet )
+{
+    ScSubTotalParam theSubTotalData;            // read out, if already partly filled
+    const SfxItemSet* pExample = GetDialogExampleSet();
+    if (pExample)
+    {
+        if (const ScSubTotalItem* pItem = pExample->GetItemIfSet(nWhichSubTotals))
+            theSubTotalData = pItem->GetSubTotalData();
+    }
+
+    theSubTotalData.bPagebreak      = m_xBtnPagebreak->get_active();
+    theSubTotalData.bReplace        = true;
+    theSubTotalData.bCaseSens       = m_xBtnCase->get_active();
+    theSubTotalData.bIncludePattern = m_xBtnFormats->get_active();
+    theSubTotalData.bDoSort         = m_xBtnSort->get_active();
+    theSubTotalData.bAscending      = m_xBtnAscending->get_active();
+    theSubTotalData.bUserDef        = m_xBtnUserDef->get_active();
+    theSubTotalData.nUserIndex      = (m_xBtnUserDef->get_active())
+                                    ? m_xLbUserDef->get_active()
+                                    : 0;
+
+    rArgSet->Put( ScSubTotalItem( nWhichSubTotals, nullptr, &theSubTotalData ) );
+
+    return true;
+}
+
+void ScTpSubTotalOptions::FillUserSortListBox()
+{
+    ScUserList* pUserLists = ScGlobal::GetUserList();
+
+    m_xLbUserDef->freeze();
+    m_xLbUserDef->clear();
+    if ( pUserLists )
+    {
+        size_t nCount = pUserLists->size();
+        for ( size_t i=0; i<nCount; ++i )
+            m_xLbUserDef->append_text((*pUserLists)[i].GetString() );
+    }
+    m_xLbUserDef->thaw();
+}
+
+// Handler:
+
+IMPL_LINK(ScTpSubTotalOptions, CheckHdl, weld::Toggleable&, rBox, void)
+{
+    if (&rBox == m_xBtnSort.get())
+    {
+        if ( m_xBtnSort->get_active() )
+        {
+            m_xFlSort->set_sensitive(true);
+            m_xBtnFormats->set_sensitive(true);
+            m_xBtnUserDef->set_sensitive(true);
+            m_xBtnAscending->set_sensitive(true);
+            m_xBtnDescending->set_sensitive(true);
+
+            if ( m_xBtnUserDef->get_active() )
+                m_xLbUserDef->set_sensitive(true);
+        }
+        else
+        {
+            m_xFlSort->set_sensitive(false);
+            m_xBtnFormats->set_sensitive(false);
+            m_xBtnUserDef->set_sensitive(false);
+            m_xBtnAscending->set_sensitive(false);
+            m_xBtnDescending->set_sensitive(false);
+            m_xLbUserDef->set_sensitive(false);
+        }
+    }
+    else if (&rBox == m_xBtnUserDef.get())
+    {
+        if ( m_xBtnUserDef->get_active() )
+        {
+            m_xLbUserDef->set_sensitive(true);
+            m_xLbUserDef->grab_focus();
+        }
+        else
+            m_xLbUserDef->set_sensitive(false);
+    }
+}
+
+IMPL_LINK(ScTpSubTotalGroup, CheckBoxHdl, weld::Toggleable&, rBox, void)
+{
+    if (&rBox != mxLbSelectAllColumns.get())
+        return;
+
+    bool bChecked = mxLbSelectAllColumns->get_active();
+
+    mxLbColumns->all_foreach([&](const weld::TreeIter& rEntry) {
+        if ( bChecked )
+            mxLbColumns->set_toggle(rEntry, TRISTATE_TRUE);
+        else
+            mxLbColumns->set_toggle(rEntry, TRISTATE_FALSE);
+
+        return false;
+    });
+}
+
+ScTpSubTotalGroup1::~ScTpSubTotalGroup1()
+{
+}
+
+ScTpSubTotalGroup2::~ScTpSubTotalGroup2()
+{
+}
+
+ScTpSubTotalGroup3::~ScTpSubTotalGroup3()
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dbgui/validate.cxx b/sc/source/ui/dbgui/validate.cxx
new file mode 100644
index 000000000..d194fdc10
--- /dev/null
+++ b/sc/source/ui/dbgui/validate.cxx
@@ -0,0 +1,927 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifdef SC_DLLIMPLEMENTATION
+#undef SC_DLLIMPLEMENTATION
+#endif
+
+#include <com/sun/star/sheet/TableValidationVisibility.hpp>
+#include <comphelper/string.hxx>
+#include <svl/stritem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <sfx2/app.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <scresid.hxx>
+#include <strings.hrc>
+
+#include <stringutil.hxx>
+#include <validat.hxx>
+#include <validate.hxx>
+#include <compiler.hxx>
+#include <formula/opcode.hxx>
+
+// cell range picker
+#include <tabvwsh.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/childwin.hxx>
+#include <reffact.hxx>
+#include <comphelper/lok.hxx>
+
+
+#define IS_MOBILE (comphelper::LibreOfficeKit::isActive() && SfxViewShell::Current() && SfxViewShell::Current()->isLOKMobilePhone())
+
+/*  Position indexes for "Allow" list box.
+    They do not map directly to ScValidationMode and can safely be modified to
+    change the order of the list box entries. */
+#define SC_VALIDDLG_ALLOW_ANY       0
+#define SC_VALIDDLG_ALLOW_WHOLE     1
+#define SC_VALIDDLG_ALLOW_DECIMAL   2
+#define SC_VALIDDLG_ALLOW_DATE      3
+#define SC_VALIDDLG_ALLOW_TIME      4
+#define SC_VALIDDLG_ALLOW_RANGE     5
+#define SC_VALIDDLG_ALLOW_LIST      6
+#define SC_VALIDDLG_ALLOW_TEXTLEN   7
+#define SC_VALIDDLG_ALLOW_CUSTOM    8
+
+/*  Position indexes for "Data" list box.
+    They do not map directly to ScConditionMode and can safely be modified to
+    change the order of the list box entries. */
+#define SC_VALIDDLG_DATA_EQUAL        0
+#define SC_VALIDDLG_DATA_LESS         1
+#define SC_VALIDDLG_DATA_GREATER      2
+#define SC_VALIDDLG_DATA_EQLESS       3
+#define SC_VALIDDLG_DATA_EQGREATER    4
+#define SC_VALIDDLG_DATA_NOTEQUAL     5
+#define SC_VALIDDLG_DATA_VALIDRANGE   6
+#define SC_VALIDDLG_DATA_INVALIDRANGE 7
+#define SC_VALIDDLG_DATA_DIRECT       8
+
+namespace ValidListType = css::sheet::TableValidationVisibility;
+
+const WhichRangesContainer ScTPValidationValue::pValueRanges(svl::Items<
+    FID_VALID_LISTTYPE, FID_VALID_LISTTYPE,
+    FID_VALID_MODE, FID_VALID_ERRTEXT
+>);
+
+ScValidationDlg::ScValidationDlg(weld::Window* pParent, const SfxItemSet* pArgSet,
+    ScTabViewShell *pTabViewSh)
+    : ScValidationDlgBase(pParent,
+        "modules/scalc/ui/validationdialog.ui", "ValidationDialog", pArgSet, nullptr)
+    , m_pTabVwSh(pTabViewSh)
+    , m_sValuePageId("criteria")
+    , m_bOwnRefHdlr(false)
+    , m_bRefInputting(false)
+    , m_xHBox(m_xBuilder->weld_container("refinputbox"))
+{
+    AddTabPage(m_sValuePageId, ScTPValidationValue::Create, nullptr);
+    AddTabPage("inputhelp", ScTPValidationHelp::Create, nullptr);
+    AddTabPage("erroralert", ScTPValidationError::Create, nullptr);
+
+    if (IS_MOBILE)
+    {
+        m_xBuilder->weld_button("cancel")->hide();
+        m_xBuilder->weld_button("help")->hide();
+    }
+}
+
+void ScValidationDlg::EndDialog(int nResponse)
+{
+    // tdf#137215 ensure original modality of true is restored before dialog loop ends
+    if (m_bOwnRefHdlr)
+        RemoveRefDlg(true);
+    ScValidationDlgBase::EndDialog(nResponse);
+}
+
+ScValidationDlg::~ScValidationDlg()
+{
+    if (m_bOwnRefHdlr)
+        RemoveRefDlg(false);
+}
+
+void ScTPValidationValue::SetReferenceHdl( const ScRange&rRange , const ScDocument& rDoc )
+{
+    if ( rRange.aStart != rRange.aEnd )
+        if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
+            if( m_pRefEdit )
+                pValidationDlg->RefInputStart( m_pRefEdit );
+
+    if ( m_pRefEdit )
+    {
+        OUString aStr(rRange.Format(rDoc, ScRefFlags::RANGE_ABS_3D, rDoc.GetAddressConvention()));
+        m_pRefEdit->SetRefString( aStr );
+    }
+}
+
+void ScTPValidationValue:: SetActiveHdl()
+{
+    if ( m_pRefEdit ) m_pRefEdit->GrabFocus();
+
+    if ( ScValidationDlg *pValidationDlg = GetValidationDlg() )
+        if( m_pRefEdit )
+        {
+            pValidationDlg->RefInputDone();
+        }
+}
+
+void ScTPValidationValue::RefInputStartPreHdl( formula::RefEdit* pEdit, const formula::RefButton* pButton )
+{
+    ScValidationDlg *pValidationDlg = GetValidationDlg();
+    if (!pValidationDlg)
+        return;
+
+    weld::Container* pNewParent = pValidationDlg->get_refinput_shrink_parent();
+    if (pEdit == m_pRefEdit && pNewParent != m_pRefEditParent)
+    {
+        m_xRefGrid->move(m_pRefEdit->GetWidget(), pNewParent);
+        m_pRefEditParent = pNewParent;
+    }
+
+    if (pNewParent != m_pBtnRefParent)
+    {
+        // if Edit SetParent but button not, the tab order will be
+        // incorrect, so move button anyway, and restore
+        // parent later in order to restore the tab order. But
+        // hide it if it's moved but unwanted.
+        m_xRefGrid->move(m_xBtnRef->GetWidget(), pNewParent);
+        m_xBtnRef->GetWidget()->set_visible(pButton == m_xBtnRef.get());
+        m_pBtnRefParent = pNewParent;
+    }
+
+    pNewParent->show();
+}
+
+void ScTPValidationValue::RefInputDonePostHdl()
+{
+    if (ScValidationDlg *pValidationDlg = GetValidationDlg())
+    {
+        weld::Container* pOldParent = pValidationDlg->get_refinput_shrink_parent();
+
+        if (m_pRefEdit && m_pRefEditParent != m_xRefGrid.get())
+        {
+            pOldParent->move(m_pRefEdit->GetWidget(), m_xRefGrid.get());
+            m_pRefEditParent = m_xRefGrid.get();
+        }
+
+        if (m_pBtnRefParent != m_xRefGrid.get())
+        {
+            pOldParent->move(m_xBtnRef->GetWidget(), m_xRefGrid.get());
+            m_xBtnRef->GetWidget()->show();
+            m_pBtnRefParent = m_xRefGrid.get();
+        }
+
+        pOldParent->hide();
+        ScViewData& rViewData = pValidationDlg->GetTabViewShell()->GetViewData();
+        SCTAB nCurTab = rViewData.GetTabNo();
+        SCTAB nRefTab = rViewData.GetRefTabNo();
+        // If RefInput switched to a different sheet from the data sheet,
+        // switch back: fdo#53920
+        if ( nCurTab != nRefTab )
+        {
+             rViewData.GetViewShell()->SetTabNo( nRefTab );
+        }
+    }
+
+    if (m_pRefEdit && !m_pRefEdit->GetWidget()->has_focus())
+        m_pRefEdit->GrabFocus();
+}
+
+namespace {
+
+/** Converts the passed ScValidationMode to the position in the list box. */
+sal_uInt16 lclGetPosFromValMode( ScValidationMode eValMode )
+{
+    sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
+    switch( eValMode )
+    {
+        case SC_VALID_ANY:      nLbPos = SC_VALIDDLG_ALLOW_ANY;     break;
+        case SC_VALID_WHOLE:    nLbPos = SC_VALIDDLG_ALLOW_WHOLE;   break;
+        case SC_VALID_DECIMAL:  nLbPos = SC_VALIDDLG_ALLOW_DECIMAL; break;
+        case SC_VALID_DATE:     nLbPos = SC_VALIDDLG_ALLOW_DATE;    break;
+        case SC_VALID_TIME:     nLbPos = SC_VALIDDLG_ALLOW_TIME;    break;
+        case SC_VALID_TEXTLEN:  nLbPos = SC_VALIDDLG_ALLOW_TEXTLEN; break;
+        case SC_VALID_LIST:     nLbPos = SC_VALIDDLG_ALLOW_RANGE;   break;
+        case SC_VALID_CUSTOM:   nLbPos = SC_VALIDDLG_ALLOW_CUSTOM;  break;
+        default:    OSL_FAIL( "lclGetPosFromValMode - unknown validity mode" );
+    }
+    return nLbPos;
+}
+
+/** Converts the passed list box position to an ScValidationMode. */
+ScValidationMode lclGetValModeFromPos( sal_uInt16 nLbPos )
+{
+    ScValidationMode eValMode = SC_VALID_ANY;
+    switch( nLbPos )
+    {
+        case SC_VALIDDLG_ALLOW_ANY:     eValMode = SC_VALID_ANY;        break;
+        case SC_VALIDDLG_ALLOW_WHOLE:   eValMode = SC_VALID_WHOLE;      break;
+        case SC_VALIDDLG_ALLOW_DECIMAL: eValMode = SC_VALID_DECIMAL;    break;
+        case SC_VALIDDLG_ALLOW_DATE:    eValMode = SC_VALID_DATE;       break;
+        case SC_VALIDDLG_ALLOW_TIME:    eValMode = SC_VALID_TIME;       break;
+        case SC_VALIDDLG_ALLOW_RANGE:   eValMode = SC_VALID_LIST;       break;
+        case SC_VALIDDLG_ALLOW_LIST:    eValMode = SC_VALID_LIST;       break;
+        case SC_VALIDDLG_ALLOW_TEXTLEN: eValMode = SC_VALID_TEXTLEN;    break;
+        case SC_VALIDDLG_ALLOW_CUSTOM:  eValMode = SC_VALID_CUSTOM;     break;
+        default:    OSL_FAIL( "lclGetValModeFromPos - invalid list box position" );
+    }
+    return eValMode;
+}
+
+/** Converts the passed ScConditionMode to the position in the list box. */
+sal_uInt16 lclGetPosFromCondMode( ScConditionMode eCondMode )
+{
+    sal_uInt16 nLbPos = SC_VALIDDLG_DATA_EQUAL;
+    switch( eCondMode )
+    {
+        case ScConditionMode::NONE:          // may occur in old XML files after Excel import
+        case ScConditionMode::Equal:         nLbPos = SC_VALIDDLG_DATA_EQUAL;        break;
+        case ScConditionMode::Less:          nLbPos = SC_VALIDDLG_DATA_LESS;         break;
+        case ScConditionMode::Greater:       nLbPos = SC_VALIDDLG_DATA_GREATER;      break;
+        case ScConditionMode::EqLess:        nLbPos = SC_VALIDDLG_DATA_EQLESS;       break;
+        case ScConditionMode::EqGreater:     nLbPos = SC_VALIDDLG_DATA_EQGREATER;    break;
+        case ScConditionMode::NotEqual:      nLbPos = SC_VALIDDLG_DATA_NOTEQUAL;     break;
+        case ScConditionMode::Between:       nLbPos = SC_VALIDDLG_DATA_VALIDRANGE;      break;
+        case ScConditionMode::NotBetween:    nLbPos = SC_VALIDDLG_DATA_INVALIDRANGE;   break;
+        case ScConditionMode::Direct:        nLbPos = SC_VALIDDLG_DATA_DIRECT;         break;
+        default:    OSL_FAIL( "lclGetPosFromCondMode - unknown condition mode" );
+    }
+    return nLbPos;
+}
+
+/** Converts the passed list box position to an ScConditionMode. */
+ScConditionMode lclGetCondModeFromPos( sal_uInt16 nLbPos )
+{
+    ScConditionMode eCondMode = ScConditionMode::Equal;
+    switch( nLbPos )
+    {
+        case SC_VALIDDLG_DATA_EQUAL:        eCondMode = ScConditionMode::Equal;      break;
+        case SC_VALIDDLG_DATA_LESS:         eCondMode = ScConditionMode::Less;       break;
+        case SC_VALIDDLG_DATA_GREATER:      eCondMode = ScConditionMode::Greater;    break;
+        case SC_VALIDDLG_DATA_EQLESS:       eCondMode = ScConditionMode::EqLess;     break;
+        case SC_VALIDDLG_DATA_EQGREATER:    eCondMode = ScConditionMode::EqGreater;  break;
+        case SC_VALIDDLG_DATA_NOTEQUAL:     eCondMode = ScConditionMode::NotEqual;   break;
+        case SC_VALIDDLG_DATA_VALIDRANGE:      eCondMode = ScConditionMode::Between;    break;
+        case SC_VALIDDLG_DATA_INVALIDRANGE:   eCondMode = ScConditionMode::NotBetween; break;
+        case SC_VALIDDLG_DATA_DIRECT:         eCondMode = ScConditionMode::Direct;   break;
+        default:    OSL_FAIL( "lclGetCondModeFromPos - invalid list box position" );
+    }
+    return eCondMode;
+}
+
+/** Converts line feed separated string to a formula with strings separated by semicolons.
+    @descr  Keeps all empty strings.
+    Example: abc\ndef\n\nghi -> "abc";"def";"";"ghi".
+    @param rFmlaStr  (out-param) The converted formula string. */
+void lclGetFormulaFromStringList( OUString& rFmlaStr, std::u16string_view rStringList, sal_Unicode cFmlaSep )
+{
+    rFmlaStr.clear();
+    if (!rStringList.empty())
+    {
+        sal_Int32 nIdx {0};
+        do
+        {
+            OUString aToken {o3tl::getToken(rStringList, 0, '\n', nIdx )};
+            ScGlobal::AddQuotes( aToken, '"' );
+            rFmlaStr = ScGlobal::addToken(rFmlaStr, aToken, cFmlaSep);
+        }
+        while (nIdx>0);
+    }
+    if( rFmlaStr.isEmpty() )
+        rFmlaStr = "\"\"";
+}
+
+/** Converts formula with strings separated by semicolons to line feed separated string.
+    @descr  Keeps all empty strings. Ignores all empty tokens (multiple semicolons).
+    Example: "abc";;;"def";"";"ghi" -> abc\ndef\n\nghi.
+    @param rStringList  (out-param) The converted line feed separated string list.
+    @return  true = Conversion successful. */
+bool lclGetStringListFromFormula( OUString& rStringList, const OUString& rFmlaStr, sal_Unicode cFmlaSep )
+{
+    static const OUStringLiteral aQuotes( u"\"\"" );
+
+    rStringList.clear();
+    bool bIsStringList = !rFmlaStr.isEmpty();
+    bool bTokenAdded = false;
+
+    for ( sal_Int32 nStringIx = 0; bIsStringList && nStringIx>=0; )
+    {
+        OUString aToken( ScStringUtil::GetQuotedToken(rFmlaStr, 0, aQuotes, cFmlaSep, nStringIx ) );
+        aToken = comphelper::string::strip(aToken, ' ');
+        if( !aToken.isEmpty() )      // ignore empty tokens, i.e. "a";;"b"
+        {
+            bIsStringList = ScGlobal::IsQuoted( aToken, '"' );
+            if( bIsStringList )
+            {
+                ScGlobal::EraseQuotes( aToken, '"' );
+                rStringList = ScGlobal::addToken(rStringList, aToken, '\n', 1, bTokenAdded);
+                bTokenAdded = true;
+            }
+        }
+    }
+
+    return bIsStringList;
+}
+
+} // namespace
+
+ScTPValidationValue::ScTPValidationValue(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet)
+    : SfxTabPage(pPage, pController, "modules/scalc/ui/validationcriteriapage.ui",
+                 "ValidationCriteriaPage", &rArgSet)
+    , maStrMin(ScResId(SCSTR_VALID_MINIMUM))
+    , maStrMax(ScResId(SCSTR_VALID_MAXIMUM))
+    , maStrValue(ScResId(SCSTR_VALID_VALUE))
+    , maStrFormula(ScResId(SCSTR_VALID_FORMULA))
+    , maStrRange(ScResId(SCSTR_VALID_RANGE))
+    , maStrList(ScResId(SCSTR_VALID_LIST))
+    , m_pRefEdit(nullptr)
+    , m_xLbAllow(m_xBuilder->weld_combo_box("allow"))
+    , m_xCbAllow(m_xBuilder->weld_check_button("allowempty"))
+    , m_xCbShow(m_xBuilder->weld_check_button("showlist"))
+    , m_xCbSort(m_xBuilder->weld_check_button("sortascend"))
+    , m_xFtValue(m_xBuilder->weld_label("valueft"))
+    , m_xLbValue(m_xBuilder->weld_combo_box("data"))
+    , m_xFtMin(m_xBuilder->weld_label("minft"))
+    , m_xMinGrid(m_xBuilder->weld_widget("mingrid"))
+    , m_xEdMin(new formula::RefEdit(m_xBuilder->weld_entry("min")))
+    , m_xEdList(m_xBuilder->weld_text_view("minlist"))
+    , m_xFtMax(m_xBuilder->weld_label("maxft"))
+    , m_xEdMax(new formula::RefEdit(m_xBuilder->weld_entry("max")))
+    , m_xFtHint(m_xBuilder->weld_label("hintft"))
+    , m_xBtnRef(new formula::RefButton(m_xBuilder->weld_button("validref")))
+    , m_xRefGrid(m_xBuilder->weld_container("refgrid"))
+    , m_pRefEditParent(m_xRefGrid.get())
+    , m_pBtnRefParent(m_xRefGrid.get())
+{
+    m_xEdMin->SetReferences(nullptr, m_xFtMin.get());
+
+    Size aSize(m_xEdList->get_approximate_digit_width() * 40,
+               m_xEdList->get_height_rows(10));
+    m_xEdList->set_size_request(aSize.Width(), aSize.Height());
+    m_xEdMax->SetReferences(nullptr, m_xFtMax.get());
+
+    m_xBtnRef->SetClickHdl(LINK(this, ScTPValidationValue, ClickHdl));
+
+    //lock in the max size initial config
+    aSize = m_xContainer->get_preferred_size();
+    m_xContainer->set_size_request(aSize.Width(), aSize.Height());
+
+    Init();
+
+    // list separator in formulas
+    OUString aListSep = ::ScCompiler::GetNativeSymbol( ocSep );
+    OSL_ENSURE( aListSep.getLength() == 1, "ScTPValidationValue::ScTPValidationValue - list separator error" );
+    mcFmlaSep = aListSep.getLength() ? aListSep[0] : ';';
+    m_xBtnRef->GetWidget()->hide(); // cell range picker
+}
+
+ScTPValidationValue::~ScTPValidationValue()
+{
+    m_xEdMin.reset();
+    m_xEdMax.reset();
+    m_xBtnRef.reset();
+}
+
+void ScTPValidationValue::Init()
+{
+    m_xLbAllow->connect_changed( LINK( this, ScTPValidationValue, SelectHdl ) );
+    m_xLbValue->connect_changed( LINK( this, ScTPValidationValue, SelectHdl ) );
+    m_xCbShow->connect_toggled( LINK( this, ScTPValidationValue, CheckHdl ) );
+
+    // cell range picker
+    m_xEdMin->SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
+    m_xEdMin->SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillEditFocusHdl ) );
+    m_xEdMax->SetGetFocusHdl( LINK( this, ScTPValidationValue, EditSetFocusHdl ) );
+    m_xEdMax->SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillEditFocusHdl ) );
+    m_xBtnRef->SetLoseFocusHdl( LINK( this, ScTPValidationValue, KillButtonFocusHdl ) );
+
+    m_xLbAllow->set_active( SC_VALIDDLG_ALLOW_ANY );
+    m_xLbValue->set_active( SC_VALIDDLG_DATA_EQUAL );
+
+    SelectHdl( *m_xLbAllow );
+    CheckHdl( *m_xCbShow );
+}
+
+std::unique_ptr<SfxTabPage> ScTPValidationValue::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rArgSet)
+{
+    return std::make_unique<ScTPValidationValue>(pPage, pController, *rArgSet);
+}
+
+void ScTPValidationValue::Reset( const SfxItemSet* rArgSet )
+{
+    sal_uInt16 nLbPos = SC_VALIDDLG_ALLOW_ANY;
+    if( const SfxUInt16Item* pItem = rArgSet->GetItemIfSet( FID_VALID_MODE ) )
+        nLbPos = lclGetPosFromValMode( static_cast< ScValidationMode >( pItem->GetValue() ) );
+    m_xLbAllow->set_active( nLbPos );
+
+    nLbPos = SC_VALIDDLG_DATA_EQUAL;
+    if( const SfxUInt16Item* pItem = rArgSet->GetItemIfSet( FID_VALID_CONDMODE ) )
+        nLbPos = lclGetPosFromCondMode( static_cast< ScConditionMode >( pItem->GetValue() ) );
+    m_xLbValue->set_active( nLbPos );
+
+    // *** check boxes ***
+    bool bCheck = true;
+    if( const SfxBoolItem* pItem = rArgSet->GetItemIfSet( FID_VALID_BLANK ) )
+        bCheck = pItem->GetValue();
+    m_xCbAllow->set_active( bCheck );
+
+    sal_Int32 nListType = ValidListType::UNSORTED;
+    if( const SfxInt16Item* pItem = rArgSet->GetItemIfSet( FID_VALID_LISTTYPE ) )
+        nListType = pItem->GetValue();
+    m_xCbShow->set_active( nListType != ValidListType::INVISIBLE );
+    m_xCbSort->set_active( nListType == ValidListType::SORTEDASCENDING );
+
+    // *** formulas ***
+    OUString aFmlaStr;
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_VALUE1 ) )
+        aFmlaStr = pItem->GetValue();
+    SetFirstFormula( aFmlaStr );
+
+    aFmlaStr.clear();
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_VALUE2 ) )
+        aFmlaStr = pItem->GetValue();
+    SetSecondFormula( aFmlaStr );
+
+    SelectHdl( *m_xLbAllow );
+    CheckHdl( *m_xCbShow );
+}
+
+bool ScTPValidationValue::FillItemSet( SfxItemSet* rArgSet )
+{
+    sal_Int16 nListType = m_xCbShow->get_active() ?
+        (m_xCbSort->get_active() ? ValidListType::SORTEDASCENDING : ValidListType::UNSORTED) :
+        ValidListType::INVISIBLE;
+
+    const sal_Int32 nLbPos = m_xLbAllow->get_active();
+    bool bCustom = (nLbPos == SC_VALIDDLG_ALLOW_CUSTOM);
+    ScConditionMode eCondMode = bCustom ?
+            ScConditionMode::Direct : lclGetCondModeFromPos( m_xLbValue->get_active() );
+
+    rArgSet->Put( SfxUInt16Item( FID_VALID_MODE, sal::static_int_cast<sal_uInt16>(
+                    lclGetValModeFromPos( nLbPos ) ) ) );
+    rArgSet->Put( SfxUInt16Item( FID_VALID_CONDMODE, sal::static_int_cast<sal_uInt16>( eCondMode ) ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_VALUE1, GetFirstFormula() ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_VALUE2, GetSecondFormula() ) );
+    rArgSet->Put( SfxBoolItem( FID_VALID_BLANK, m_xCbAllow->get_active() ) );
+    rArgSet->Put( SfxInt16Item( FID_VALID_LISTTYPE, nListType ) );
+    return true;
+}
+
+OUString ScTPValidationValue::GetFirstFormula() const
+{
+    OUString aFmlaStr;
+    if( m_xLbAllow->get_active() == SC_VALIDDLG_ALLOW_LIST )
+        lclGetFormulaFromStringList( aFmlaStr, m_xEdList->get_text(), mcFmlaSep );
+    else
+        aFmlaStr = m_xEdMin->GetText();
+    return aFmlaStr;
+}
+
+OUString ScTPValidationValue::GetSecondFormula() const
+{
+    return m_xEdMax->GetText();
+}
+
+void ScTPValidationValue::SetFirstFormula( const OUString& rFmlaStr )
+{
+    // try if formula is a string list, validation mode must already be set
+    OUString aStringList;
+    if( (m_xLbAllow->get_active() == SC_VALIDDLG_ALLOW_RANGE) &&
+        lclGetStringListFromFormula( aStringList, rFmlaStr, mcFmlaSep ) )
+    {
+        m_xEdList->set_text( aStringList );
+        m_xEdMin->SetText( OUString() );
+        // change validation mode to string list
+        m_xLbAllow->set_active( SC_VALIDDLG_ALLOW_LIST );
+    }
+    else
+    {
+        m_xEdMin->SetText( rFmlaStr );
+        m_xEdList->set_text( OUString() );
+    }
+}
+
+void ScTPValidationValue::SetSecondFormula( const OUString& rFmlaStr )
+{
+    m_xEdMax->SetText( rFmlaStr );
+}
+
+ScValidationDlg * ScTPValidationValue::GetValidationDlg()
+{
+    return dynamic_cast<ScValidationDlg*>(GetDialogController());
+}
+
+void ScTPValidationValue::SetupRefDlg()
+{
+    ScValidationDlg *pValidationDlg = GetValidationDlg();
+    if( !pValidationDlg )
+        return;
+
+    if( !pValidationDlg->SetupRefDlg() )
+        return;
+
+    pValidationDlg->SetHandler( this );
+    pValidationDlg->SetSetRefHdl( static_cast<ScRefHandlerHelper::PFUNCSETREFHDLTYPE>( &ScTPValidationValue::SetReferenceHdl ) );
+    pValidationDlg->SetSetActHdl( static_cast<ScRefHandlerHelper::PCOMMONHDLTYPE>( &ScTPValidationValue::SetActiveHdl ) );
+    pValidationDlg->SetRefInputStartPreHdl( static_cast<ScRefHandlerHelper::PINPUTSTARTDLTYPE>( &ScTPValidationValue::RefInputStartPreHdl ) );
+    pValidationDlg->SetRefInputDonePostHdl( static_cast<ScRefHandlerHelper::PCOMMONHDLTYPE>( &ScTPValidationValue::RefInputDonePostHdl ) );
+
+    weld::Label* pLabel = nullptr;
+
+    if (m_xEdMax->GetWidget()->get_visible())
+    {
+        m_pRefEdit = m_xEdMax.get();
+        pLabel = m_xFtMax.get();
+    }
+    else if (m_xEdMin->GetWidget()->get_visible())
+    {
+        m_pRefEdit = m_xEdMin.get();
+        pLabel = m_xFtMin.get();
+    }
+
+    if (m_pRefEdit && !m_pRefEdit->GetWidget()->has_focus())
+        m_pRefEdit->GrabFocus();
+
+    if( m_pRefEdit )
+        m_pRefEdit->SetReferences( pValidationDlg, pLabel );
+
+    m_xBtnRef->SetReferences( pValidationDlg, m_pRefEdit );
+}
+
+void ScTPValidationValue::RemoveRefDlg(bool bRestoreModal)
+{
+    ScValidationDlg *pValidationDlg = GetValidationDlg();
+    if( !pValidationDlg )
+        return;
+
+    if( !pValidationDlg->RemoveRefDlg(bRestoreModal) )
+        return;
+
+    pValidationDlg->SetHandler( nullptr );
+    pValidationDlg->SetSetRefHdl( nullptr );
+    pValidationDlg->SetSetActHdl( nullptr );
+    pValidationDlg->SetRefInputStartPreHdl( nullptr );
+    pValidationDlg->SetRefInputDonePostHdl( nullptr );
+
+    if( m_pRefEdit )
+        m_pRefEdit->SetReferences( nullptr, nullptr );
+    m_pRefEdit = nullptr;
+
+    m_xBtnRef->SetReferences( nullptr, nullptr );
+}
+
+IMPL_LINK_NOARG(ScTPValidationValue, EditSetFocusHdl, formula::RefEdit&, void)
+{
+    const sal_Int32 nPos = m_xLbAllow->get_active();
+
+    if ( nPos == SC_VALIDDLG_ALLOW_RANGE )
+    {
+        SetupRefDlg();
+    }
+}
+
+IMPL_LINK( ScTPValidationValue, KillEditFocusHdl, formula::RefEdit&, rWnd, void )
+{
+    if (&rWnd != m_pRefEdit)
+        return;
+    if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
+    {
+        if (pValidationDlg->IsChildFocus() && !pValidationDlg->IsRefInputting())
+        {
+            if( ( !m_pRefEdit || !m_pRefEdit->GetWidget()->has_focus()) && !m_xBtnRef->GetWidget()->has_focus() )
+            {
+                RemoveRefDlg(true);
+            }
+        }
+    }
+}
+
+IMPL_LINK( ScTPValidationValue, KillButtonFocusHdl, formula::RefButton&, rWnd, void )
+{
+    if( &rWnd != m_xBtnRef.get())
+        return;
+    if( ScValidationDlg *pValidationDlg = GetValidationDlg() )
+        if (pValidationDlg->IsChildFocus() && !pValidationDlg->IsRefInputting())
+            if( ( !m_pRefEdit || !m_pRefEdit->GetWidget()->has_focus()) && !m_xBtnRef->GetWidget()->has_focus() )
+            {
+                RemoveRefDlg(true);
+            }
+}
+
+IMPL_LINK_NOARG(ScTPValidationValue, SelectHdl, weld::ComboBox&, void)
+{
+    const sal_Int32 nLbPos = m_xLbAllow->get_active();
+    bool bEnable = (nLbPos != SC_VALIDDLG_ALLOW_ANY);
+    bool bRange = (nLbPos == SC_VALIDDLG_ALLOW_RANGE);
+    bool bList = (nLbPos == SC_VALIDDLG_ALLOW_LIST);
+    bool bCustom = (nLbPos == SC_VALIDDLG_ALLOW_CUSTOM);
+
+    m_xCbAllow->set_sensitive( bEnable );   // Empty cell
+    m_xFtValue->set_sensitive( bEnable );
+    m_xLbValue->set_sensitive( bEnable );
+    m_xFtMin->set_sensitive( bEnable );
+    m_xEdMin->GetWidget()->set_sensitive( bEnable );
+    m_xEdList->set_sensitive( bEnable );
+    m_xFtMax->set_sensitive( bEnable );
+    m_xEdMax->GetWidget()->set_sensitive( bEnable );
+
+    bool bShowMax = false;
+
+    if( bRange )
+        m_xFtMin->set_label( maStrRange );
+    else if( bList )
+        m_xFtMin->set_label( maStrList );
+    else if( bCustom )
+        m_xFtMin->set_label( maStrFormula );
+    else
+    {
+        switch( m_xLbValue->get_active() )
+        {
+            case SC_VALIDDLG_DATA_EQUAL:
+            case SC_VALIDDLG_DATA_NOTEQUAL:     m_xFtMin->set_label( maStrValue );  break;
+
+            case SC_VALIDDLG_DATA_LESS:
+            case SC_VALIDDLG_DATA_EQLESS:       m_xFtMin->set_label( maStrMax );    break;
+
+            case SC_VALIDDLG_DATA_VALIDRANGE:
+            case SC_VALIDDLG_DATA_INVALIDRANGE:   bShowMax = true;
+                [[fallthrough]];
+            case SC_VALIDDLG_DATA_GREATER:
+            case SC_VALIDDLG_DATA_EQGREATER:    m_xFtMin->set_label( maStrMin );    break;
+
+            default:
+                OSL_FAIL( "ScTPValidationValue::SelectHdl - unknown condition mode" );
+        }
+    }
+
+    m_xCbShow->set_visible( bRange || bList );
+    m_xCbSort->set_visible( bRange || bList );
+    m_xFtValue->set_visible( !bRange && !bList && !bCustom);
+    m_xLbValue->set_visible( !bRange && !bList && !bCustom );
+    m_xEdMin->GetWidget()->set_visible( !bList );
+    m_xEdList->set_visible( bList );
+    m_xMinGrid->set_vexpand( bList );
+    m_xFtMax->set_visible( bShowMax );
+    m_xEdMax->GetWidget()->set_visible( bShowMax );
+    m_xFtHint->set_visible( bRange );
+    m_xBtnRef->GetWidget()->set_visible( bRange );  // cell range picker
+}
+
+IMPL_LINK_NOARG(ScTPValidationValue, CheckHdl, weld::Toggleable&, void)
+{
+    m_xCbSort->set_sensitive( m_xCbShow->get_active() );
+}
+
+// Input Help Page
+
+ScTPValidationHelp::ScTPValidationHelp(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rArgSet)
+    : SfxTabPage(pPage, pController, IS_MOBILE ? OUString("modules/scalc/ui/validationhelptabpage-mobile.ui")
+            : OUString("modules/scalc/ui/validationhelptabpage.ui"), "ValidationHelpTabPage", &rArgSet)
+    , m_xTsbHelp(m_xBuilder->weld_check_button("tsbhelp"))
+    , m_xEdtTitle(m_xBuilder->weld_entry("title"))
+    , m_xEdInputHelp(m_xBuilder->weld_text_view("inputhelp"))
+{
+    m_xEdInputHelp->set_size_request(m_xEdInputHelp->get_approximate_digit_width() * 40, m_xEdInputHelp->get_height_rows(13));
+}
+
+ScTPValidationHelp::~ScTPValidationHelp()
+{
+}
+
+std::unique_ptr<SfxTabPage> ScTPValidationHelp::Create(weld::Container* pPage, weld::DialogController* pController,
+                                              const SfxItemSet* rArgSet)
+{
+    return std::make_unique<ScTPValidationHelp>(pPage, pController, *rArgSet);
+}
+
+void ScTPValidationHelp::Reset( const SfxItemSet* rArgSet )
+{
+    if ( const SfxBoolItem* pItem = rArgSet->GetItemIfSet( FID_VALID_SHOWHELP ) )
+        m_xTsbHelp->set_state( pItem->GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE );
+    else
+        m_xTsbHelp->set_state( TRISTATE_FALSE );
+
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_HELPTITLE ) )
+        m_xEdtTitle->set_text( pItem->GetValue() );
+    else
+        m_xEdtTitle->set_text( OUString() );
+
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_HELPTEXT ) )
+        m_xEdInputHelp->set_text( pItem->GetValue() );
+    else
+        m_xEdInputHelp->set_text( OUString() );
+}
+
+bool ScTPValidationHelp::FillItemSet( SfxItemSet* rArgSet )
+{
+    rArgSet->Put( SfxBoolItem( FID_VALID_SHOWHELP, m_xTsbHelp->get_state() == TRISTATE_TRUE ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_HELPTITLE, m_xEdtTitle->get_text() ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_HELPTEXT, m_xEdInputHelp->get_text() ) );
+
+    return true;
+}
+
+// Error Alert Page
+
+ScTPValidationError::ScTPValidationError(weld::Container* pPage, weld::DialogController* pController,
+                                         const SfxItemSet& rArgSet)
+
+    :   SfxTabPage      ( pPage, pController,
+                          IS_MOBILE ? OUString("modules/scalc/ui/erroralerttabpage-mobile.ui")
+                                : OUString("modules/scalc/ui/erroralerttabpage.ui"), "ErrorAlertTabPage",
+                          &rArgSet )
+    , m_xTsbShow(m_xBuilder->weld_check_button("tsbshow"))
+    , m_xLbAction(m_xBuilder->weld_combo_box("actionCB"))
+    , m_xBtnSearch(m_xBuilder->weld_button("browseBtn"))
+    , m_xEdtTitle(m_xBuilder->weld_entry("erroralert_title"))
+    , m_xFtError(m_xBuilder->weld_label("errormsg_label"))
+    , m_xEdError(m_xBuilder->weld_text_view("errorMsg"))
+{
+    m_xEdError->set_size_request(m_xEdError->get_approximate_digit_width() * 40, m_xEdError->get_height_rows(12));
+    Init();
+}
+
+ScTPValidationError::~ScTPValidationError()
+{
+}
+
+void ScTPValidationError::Init()
+{
+    m_xLbAction->connect_changed(LINK(this, ScTPValidationError, SelectActionHdl));
+    m_xBtnSearch->connect_clicked(LINK( this, ScTPValidationError, ClickSearchHdl));
+
+    m_xLbAction->set_active(0);
+
+    SelectActionHdl(*m_xLbAction);
+}
+
+std::unique_ptr<SfxTabPage> ScTPValidationError::Create(weld::Container* pPage, weld::DialogController* pController,
+                                               const SfxItemSet* rArgSet)
+{
+    return std::make_unique<ScTPValidationError>(pPage, pController, *rArgSet);
+}
+
+void ScTPValidationError::Reset( const SfxItemSet* rArgSet )
+{
+    if ( const SfxBoolItem* pItem = rArgSet->GetItemIfSet( FID_VALID_SHOWERR ) )
+        m_xTsbShow->set_state( pItem->GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE );
+    else
+        m_xTsbShow->set_state( TRISTATE_TRUE );   // check by default
+
+    if ( const SfxUInt16Item* pItem = rArgSet->GetItemIfSet( FID_VALID_ERRSTYLE ) )
+        m_xLbAction->set_active( pItem->GetValue() );
+    else
+        m_xLbAction->set_active( 0 );
+
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_ERRTITLE ) )
+        m_xEdtTitle->set_text( pItem->GetValue() );
+    else
+        m_xEdtTitle->set_text( OUString() );
+
+    if ( const SfxStringItem* pItem = rArgSet->GetItemIfSet( FID_VALID_ERRTEXT ) )
+        m_xEdError->set_text( pItem->GetValue() );
+    else
+        m_xEdError->set_text( OUString() );
+
+    SelectActionHdl(*m_xLbAction);
+}
+
+bool ScTPValidationError::FillItemSet( SfxItemSet* rArgSet )
+{
+    rArgSet->Put( SfxBoolItem( FID_VALID_SHOWERR, m_xTsbShow->get_state() == TRISTATE_TRUE ) );
+    rArgSet->Put( SfxUInt16Item( FID_VALID_ERRSTYLE, m_xLbAction->get_active() ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_ERRTITLE, m_xEdtTitle->get_text() ) );
+    rArgSet->Put( SfxStringItem( FID_VALID_ERRTEXT, m_xEdError->get_text() ) );
+
+    return true;
+}
+
+IMPL_LINK_NOARG(ScTPValidationError, SelectActionHdl, weld::ComboBox&, void)
+{
+    ScValidErrorStyle eStyle = static_cast<ScValidErrorStyle>(m_xLbAction->get_active());
+    bool bMacro = ( eStyle == SC_VALERR_MACRO );
+
+    m_xBtnSearch->set_sensitive( bMacro );
+    m_xFtError->set_sensitive( !bMacro );
+    m_xEdError->set_sensitive( !bMacro );
+}
+
+IMPL_LINK_NOARG(ScTPValidationError, ClickSearchHdl, weld::Button&, void)
+{
+    // Use static SfxApplication method to bring up selector dialog for
+    // choosing a script
+    OUString aScriptURL = SfxApplication::ChooseScript(GetFrameWeld());
+
+    if ( !aScriptURL.isEmpty() )
+    {
+        m_xEdtTitle->set_text( aScriptURL );
+    }
+}
+
+bool ScValidationDlg::EnterRefStatus()
+{
+    ScTabViewShell *pTabViewShell = GetTabViewShell();
+
+    if( !pTabViewShell ) return false;
+
+    sal_uInt16 nId  = SLOTID;
+    SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
+    SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
+
+    if (pWnd && pWnd->GetController().get() != this) pWnd = nullptr;
+
+    SC_MOD()->SetRefDialog( nId, pWnd == nullptr );
+
+    return true;
+}
+
+bool ScValidationDlg::LeaveRefStatus()
+{
+    ScTabViewShell *pTabViewShell = GetTabViewShell();
+
+    if( !pTabViewShell ) return false;
+
+    sal_uInt16 nId  = SLOTID;
+    SfxViewFrame* pViewFrm = pTabViewShell->GetViewFrame();
+    if ( pViewFrm->GetChildWindow( nId ) )
+    {
+        DoClose( nId );
+    }
+    return true;
+}
+
+bool ScValidationDlg::SetupRefDlg()
+{
+    if ( m_bOwnRefHdlr ) return false;
+    if( EnterRefMode() )
+    {
+        SetModal( false );
+        m_bOwnRefHdlr = true;
+        return EnterRefStatus();
+    }
+
+    return false;
+}
+
+bool ScValidationDlg::RemoveRefDlg( bool bRestoreModal /* = true */ )
+{
+    bool bVisLock = false;
+    bool bFreeWindowLock = false;
+
+    ScTabViewShell *pTabVwSh = GetTabViewShell();
+
+    if( !pTabVwSh ) return false;
+
+    if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
+    {
+        bVisLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( true );
+        bFreeWindowLock = static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( true );
+    }
+
+    if ( !m_bOwnRefHdlr ) return false;
+    if( LeaveRefStatus() && LeaveRefMode() )
+    {
+        m_bOwnRefHdlr = false;
+
+        if( bRestoreModal )
+        {
+            SetModal( true );
+        }
+    }
+
+    if ( SfxChildWindow* pWnd = pTabVwSh->GetViewFrame()->GetChildWindow( SID_VALIDITY_REFERENCE ) )
+    {
+        static_cast<ScValidityRefChildWin*>(pWnd)->LockVisible( bVisLock );
+        static_cast<ScValidityRefChildWin*>(pWnd)->LockFreeWindow( bFreeWindowLock );
+    }
+
+    return true;
+}
+
+IMPL_LINK_NOARG(ScTPValidationValue, ClickHdl, formula::RefButton&, void)
+{
+    SetupRefDlg();
+}
+
+bool ScValidationDlg::IsChildFocus() const
+{
+    return m_xDialog->has_toplevel_focus();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */