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

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

1 files changed, 552 insertions, 0 deletions

diff --git a/sc/source/ui/dialogs/SparklineDialog.cxx b/sc/source/ui/dialogs/SparklineDialog.cxx
new file mode 100644
index 000000000..f27e0eb4a
--- /dev/null
+++ b/sc/source/ui/dialogs/SparklineDialog.cxx
@@ -0,0 +1,552 @@
+/* -*- 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 <SparklineDialog.hxx>
+#include <SparklineData.hxx>
+#include <SparklineGroup.hxx>
+#include <Sparkline.hxx>
+#include <reffact.hxx>
+
+#include <docfunc.hxx>
+
+#include <svx/colorbox.hxx>
+#include <vcl/formatter.hxx>
+
+namespace sc
+{
+SparklineDialog::SparklineDialog(SfxBindings* pBindings, SfxChildWindow* pChildWindow,
+                                 weld::Window* pWindow, ScViewData& rViewData)
+    : ScAnyRefDlgController(pBindings, pChildWindow, pWindow,
+                            u"modules/scalc/ui/sparklinedialog.ui", "SparklineDialog")
+    , mrViewData(rViewData)
+    , mrDocument(rViewData.GetDocument())
+    , mpActiveEdit(nullptr)
+    , mbDialogLostFocus(false)
+    , mxButtonOk(m_xBuilder->weld_button("ok"))
+    , mxButtonCancel(m_xBuilder->weld_button("cancel"))
+    , mxFrameData(m_xBuilder->weld_frame("frmData"))
+    , mxInputRangeLabel(m_xBuilder->weld_label("lbInputRange"))
+    , mxInputRangeEdit(new formula::RefEdit(m_xBuilder->weld_entry("edInputRange")))
+    , mxInputRangeButton(new formula::RefButton(m_xBuilder->weld_button("btnInputRange")))
+    , mxOutputRangeLabel(m_xBuilder->weld_label("lbOutputRange"))
+    , mxOutputRangeEdit(new formula::RefEdit(m_xBuilder->weld_entry("edOutputRange")))
+    , mxOutputRangeButton(new formula::RefButton(m_xBuilder->weld_button("btnOutputRange")))
+    , mxColorSeries(new ColorListBox(m_xBuilder->weld_menu_button("colSeries"),
+                                     [pWindow] { return pWindow; }))
+    , mxColorNegative(new ColorListBox(m_xBuilder->weld_menu_button("colNegative"),
+                                       [pWindow] { return pWindow; }))
+    , mxColorMarker(new ColorListBox(m_xBuilder->weld_menu_button("colMarker"),
+                                     [pWindow] { return pWindow; }))
+    , mxColorHigh(
+          new ColorListBox(m_xBuilder->weld_menu_button("colHigh"), [pWindow] { return pWindow; }))
+    , mxColorLow(
+          new ColorListBox(m_xBuilder->weld_menu_button("colLow"), [pWindow] { return pWindow; }))
+    , mxColorFirst(
+          new ColorListBox(m_xBuilder->weld_menu_button("colFirst"), [pWindow] { return pWindow; }))
+    , mxColorLast(
+          new ColorListBox(m_xBuilder->weld_menu_button("colLast"), [pWindow] { return pWindow; }))
+    , mxCheckButtonNegative(m_xBuilder->weld_check_button("cbNegative"))
+    , mxCheckButtonMarker(m_xBuilder->weld_check_button("cbMarker"))
+    , mxCheckButtonHigh(m_xBuilder->weld_check_button("cbHigh"))
+    , mxCheckButtonLow(m_xBuilder->weld_check_button("cbLow"))
+    , mxCheckButtonFirst(m_xBuilder->weld_check_button("cbFirst"))
+    , mxCheckButtonLast(m_xBuilder->weld_check_button("cbLast"))
+    , mxSpinLineWidth(m_xBuilder->weld_spin_button("seLineWidth"))
+    , mxType(m_xBuilder->weld_combo_box("cbType"))
+    , mxCheckDisplayXAxis(m_xBuilder->weld_check_button("cbDisplayXAxis"))
+    , mxCheckDisplayHidden(m_xBuilder->weld_check_button("cbHidden"))
+    , mxCheckRightToLeft(m_xBuilder->weld_check_button("cbRTL"))
+    , mxDisplayEmptyGap(m_xBuilder->weld_combo_box("cbEmptyCells"))
+    , mxComboMinAxisType(m_xBuilder->weld_combo_box("cbMinAxisType"))
+    , mxComboMaxAxisType(m_xBuilder->weld_combo_box("cbMaxAxisType"))
+    , mxSpinCustomMin(m_xBuilder->weld_formatted_spin_button("seMinAxis"))
+    , mxSpinCustomMax(m_xBuilder->weld_formatted_spin_button("seMaxAxis"))
+    , mbEditMode(false)
+{
+    mxInputRangeEdit->SetReferences(this, mxInputRangeLabel.get());
+    mxInputRangeButton->SetReferences(this, mxInputRangeEdit.get());
+
+    mxOutputRangeEdit->SetReferences(this, mxOutputRangeLabel.get());
+    mxOutputRangeButton->SetReferences(this, mxOutputRangeEdit.get());
+
+    mxButtonCancel->connect_clicked(LINK(this, SparklineDialog, ButtonClicked));
+    mxButtonOk->connect_clicked(LINK(this, SparklineDialog, ButtonClicked));
+    mxButtonOk->set_sensitive(false);
+
+    Link<formula::RefEdit&, void> aEditLink = LINK(this, SparklineDialog, EditFocusHandler);
+    mxInputRangeEdit->SetGetFocusHdl(aEditLink);
+    mxOutputRangeEdit->SetGetFocusHdl(aEditLink);
+    aEditLink = LINK(this, SparklineDialog, LoseEditFocusHandler);
+    mxInputRangeEdit->SetLoseFocusHdl(aEditLink);
+    mxOutputRangeEdit->SetLoseFocusHdl(aEditLink);
+
+    Link<formula::RefButton&, void> aButtonLink = LINK(this, SparklineDialog, ButtonFocusHandler);
+    mxInputRangeButton->SetGetFocusHdl(aButtonLink);
+    mxOutputRangeButton->SetGetFocusHdl(aButtonLink);
+    aButtonLink = LINK(this, SparklineDialog, LoseButtonFocusHandler);
+    mxInputRangeButton->SetLoseFocusHdl(aButtonLink);
+    mxOutputRangeButton->SetLoseFocusHdl(aButtonLink);
+
+    Link<formula::RefEdit&, void> aModifyLink = LINK(this, SparklineDialog, RefInputModifyHandler);
+    mxInputRangeEdit->SetModifyHdl(aModifyLink);
+    mxOutputRangeEdit->SetModifyHdl(aModifyLink);
+
+    mxType->connect_changed(LINK(this, SparklineDialog, SelectSparklineType));
+    mxDisplayEmptyGap->connect_changed(LINK(this, SparklineDialog, SelectSparklineType));
+
+    Link<weld::Toggleable&, void> aLink = LINK(this, SparklineDialog, ToggleHandler);
+    mxCheckButtonNegative->connect_toggled(aLink);
+    mxCheckButtonMarker->connect_toggled(aLink);
+    mxCheckButtonHigh->connect_toggled(aLink);
+    mxCheckButtonLow->connect_toggled(aLink);
+    mxCheckButtonFirst->connect_toggled(aLink);
+    mxCheckButtonLast->connect_toggled(aLink);
+    mxCheckDisplayXAxis->connect_toggled(aLink);
+    mxCheckDisplayHidden->connect_toggled(aLink);
+    mxCheckRightToLeft->connect_toggled(aLink);
+
+    mxSpinLineWidth->connect_value_changed(LINK(this, SparklineDialog, SpinLineWidthChanged));
+
+    mxComboMinAxisType->connect_changed(LINK(this, SparklineDialog, ComboValueChanged));
+    mxComboMaxAxisType->connect_changed(LINK(this, SparklineDialog, ComboValueChanged));
+
+    mxSpinCustomMin->connect_value_changed(LINK(this, SparklineDialog, SpinCustomChanged));
+    Formatter& rSpinCustomMinFormatter = mxSpinCustomMin->GetFormatter();
+    rSpinCustomMinFormatter.ClearMinValue();
+    rSpinCustomMinFormatter.ClearMaxValue();
+    rSpinCustomMinFormatter.UseInputStringForFormatting();
+
+    mxSpinCustomMax->connect_value_changed(LINK(this, SparklineDialog, SpinCustomChanged));
+    Formatter& rSpinCustomMaxFormatter = mxSpinCustomMax->GetFormatter();
+    rSpinCustomMaxFormatter.ClearMinValue();
+    rSpinCustomMaxFormatter.ClearMaxValue();
+    rSpinCustomMaxFormatter.UseInputStringForFormatting();
+
+    setupValues();
+
+    mxOutputRangeEdit->GrabFocus();
+    mxButtonOk->set_sensitive(checkValidInputOutput());
+}
+
+SparklineDialog::~SparklineDialog() = default;
+
+void SparklineDialog::setInputSelection()
+{
+    mrViewData.GetSimpleArea(maInputRange);
+    OUString aString = maInputRange.Format(mrDocument, ScRefFlags::VALID | ScRefFlags::TAB_3D,
+                                           mrDocument.GetAddressConvention());
+    mxInputRangeEdit->SetRefString(aString);
+}
+
+void SparklineDialog::setupValues()
+{
+    ScRange aSelectionRange;
+    mrViewData.GetSimpleArea(aSelectionRange);
+
+    if (mrDocument.HasOneSparklineGroup(aSelectionRange))
+    {
+        if (auto pSparkline = mrDocument.GetSparkline(aSelectionRange.aStart))
+        {
+            mpSparklineGroup = pSparkline->getSparklineGroup();
+            maAttributes = mpSparklineGroup->getAttributes();
+            mxFrameData->set_visible(false);
+            mbEditMode = true;
+        }
+    }
+    else
+    {
+        maInputRange = aSelectionRange;
+    }
+
+    setInputSelection();
+
+    switch (maAttributes.getType())
+    {
+        case sc::SparklineType::Line:
+            mxType->set_active(0);
+            break;
+        case sc::SparklineType::Column:
+            mxType->set_active(1);
+            break;
+        case sc::SparklineType::Stacked:
+            mxType->set_active(2);
+            break;
+    }
+
+    switch (maAttributes.getDisplayEmptyCellsAs())
+    {
+        case sc::DisplayEmptyCellsAs::Gap:
+            mxDisplayEmptyGap->set_active(0);
+            break;
+        case sc::DisplayEmptyCellsAs::Zero:
+            mxDisplayEmptyGap->set_active(1);
+            break;
+        case sc::DisplayEmptyCellsAs::Span:
+            mxDisplayEmptyGap->set_active(2);
+            break;
+    }
+
+    mxColorSeries->SelectEntry(maAttributes.getColorSeries());
+    mxColorNegative->SelectEntry(maAttributes.getColorNegative());
+    mxColorMarker->SelectEntry(maAttributes.getColorMarkers());
+    mxColorHigh->SelectEntry(maAttributes.getColorHigh());
+    mxColorLow->SelectEntry(maAttributes.getColorLow());
+    mxColorFirst->SelectEntry(maAttributes.getColorFirst());
+    mxColorLast->SelectEntry(maAttributes.getColorLast());
+
+    mxCheckButtonNegative->set_active(maAttributes.isNegative());
+    mxCheckButtonMarker->set_active(maAttributes.isMarkers());
+    mxCheckButtonHigh->set_active(maAttributes.isHigh());
+    mxCheckButtonLow->set_active(maAttributes.isLow());
+    mxCheckButtonFirst->set_active(maAttributes.isFirst());
+    mxCheckButtonLast->set_active(maAttributes.isLast());
+
+    mxSpinLineWidth->set_value(sal_Int64(maAttributes.getLineWeight() * 100.0));
+
+    mxCheckDisplayXAxis->set_active(maAttributes.shouldDisplayXAxis());
+    mxCheckDisplayHidden->set_active(maAttributes.shouldDisplayHidden());
+    mxCheckRightToLeft->set_active(maAttributes.isRightToLeft());
+
+    switch (maAttributes.getMinAxisType())
+    {
+        case sc::AxisType::Individual:
+            mxComboMinAxisType->set_active(0);
+            mxSpinCustomMin->GetFormatter().SetValue(0.0);
+            break;
+        case sc::AxisType::Group:
+            mxComboMinAxisType->set_active(1);
+            mxSpinCustomMin->GetFormatter().SetValue(0.0);
+            break;
+        case sc::AxisType::Custom:
+            mxComboMinAxisType->set_active(2);
+            if (maAttributes.getManualMin())
+                mxSpinCustomMin->GetFormatter().SetValue(*maAttributes.getManualMin());
+            break;
+    }
+    ComboValueChanged(*mxComboMinAxisType);
+
+    switch (maAttributes.getMaxAxisType())
+    {
+        case sc::AxisType::Individual:
+            mxComboMaxAxisType->set_active(0);
+            mxSpinCustomMax->GetFormatter().SetValue(0.0);
+            break;
+        case sc::AxisType::Group:
+            mxComboMaxAxisType->set_active(1);
+            mxSpinCustomMax->GetFormatter().SetValue(0.0);
+            break;
+        case sc::AxisType::Custom:
+            mxComboMaxAxisType->set_active(2);
+            if (maAttributes.getManualMax())
+                mxSpinCustomMax->GetFormatter().SetValue(*maAttributes.getManualMax());
+            break;
+    }
+    ComboValueChanged(*mxComboMaxAxisType);
+}
+
+void SparklineDialog::Close() { DoClose(sc::SparklineDialogWrapper::GetChildWindowId()); }
+
+void SparklineDialog::SetActive()
+{
+    if (mbDialogLostFocus)
+    {
+        mbDialogLostFocus = false;
+        if (mpActiveEdit)
+            mpActiveEdit->GrabFocus();
+    }
+    else
+    {
+        m_xDialog->grab_focus();
+    }
+    RefInputDone();
+}
+
+void SparklineDialog::SetReference(const ScRange& rReferenceRange, ScDocument& rDocument)
+{
+    if (mpActiveEdit)
+    {
+        if (rReferenceRange.aStart != rReferenceRange.aEnd)
+            RefInputStart(mpActiveEdit);
+
+        OUString aString;
+        const ScRefFlags eFlags = ScRefFlags::VALID | ScRefFlags::TAB_3D;
+        auto eAddressConvention = rDocument.GetAddressConvention();
+
+        if (mpActiveEdit == mxInputRangeEdit.get())
+        {
+            maInputRange = rReferenceRange;
+            aString = maInputRange.Format(rDocument, eFlags, eAddressConvention);
+            mxInputRangeEdit->SetRefString(aString);
+        }
+        else if (mpActiveEdit == mxOutputRangeEdit.get())
+        {
+            maOutputRange = rReferenceRange;
+            aString = maOutputRange.Format(rDocument, eFlags, eAddressConvention);
+            mxOutputRangeEdit->SetRefString(aString);
+        }
+    }
+
+    mxButtonOk->set_sensitive(checkValidInputOutput());
+}
+
+IMPL_LINK(SparklineDialog, EditFocusHandler, formula::RefEdit&, rEdit, void)
+{
+    auto* pEdit = &rEdit;
+
+    if (mxInputRangeEdit.get() == pEdit)
+        mpActiveEdit = mxInputRangeEdit.get();
+    else if (mxOutputRangeEdit.get() == pEdit)
+        mpActiveEdit = mxOutputRangeEdit.get();
+    else
+        mpActiveEdit = nullptr;
+
+    if (mpActiveEdit)
+        mpActiveEdit->SelectAll();
+}
+
+IMPL_LINK(SparklineDialog, ButtonFocusHandler, formula::RefButton&, rButton, void)
+{
+    auto* pButton = &rButton;
+
+    if (mxInputRangeButton.get() == pButton)
+        mpActiveEdit = mxInputRangeEdit.get();
+    else if (mxOutputRangeButton.get() == pButton)
+        mpActiveEdit = mxOutputRangeEdit.get();
+    else
+        mpActiveEdit = nullptr;
+
+    if (mpActiveEdit)
+        mpActiveEdit->SelectAll();
+}
+
+IMPL_LINK_NOARG(SparklineDialog, LoseEditFocusHandler, formula::RefEdit&, void)
+{
+    mbDialogLostFocus = !m_xDialog->has_toplevel_focus();
+}
+
+IMPL_LINK_NOARG(SparklineDialog, LoseButtonFocusHandler, formula::RefButton&, void)
+{
+    mbDialogLostFocus = !m_xDialog->has_toplevel_focus();
+}
+
+IMPL_LINK_NOARG(SparklineDialog, RefInputModifyHandler, formula::RefEdit&, void)
+{
+    if (mpActiveEdit)
+    {
+        if (mpActiveEdit == mxInputRangeEdit.get())
+        {
+            ScRangeList aRangeList;
+            bool bValid = ParseWithNames(aRangeList, mxInputRangeEdit->GetText(), mrDocument);
+            const ScRange* pRange = (bValid && aRangeList.size() == 1) ? &aRangeList[0] : nullptr;
+            if (pRange)
+            {
+                maInputRange = *pRange;
+                mxInputRangeEdit->StartUpdateData();
+            }
+            else
+            {
+                maInputRange = ScRange(ScAddress::INITIALIZE_INVALID);
+            }
+        }
+        else if (mpActiveEdit == mxOutputRangeEdit.get())
+        {
+            ScRangeList aRangeList;
+            bool bValid = ParseWithNames(aRangeList, mxOutputRangeEdit->GetText(), mrDocument);
+            const ScRange* pRange = (bValid && aRangeList.size() == 1) ? &aRangeList[0] : nullptr;
+            if (pRange)
+            {
+                maOutputRange = *pRange;
+                mxOutputRangeEdit->StartUpdateData();
+            }
+            else
+            {
+                maOutputRange = ScRange(ScAddress::INITIALIZE_INVALID);
+            }
+        }
+    }
+
+    mxButtonOk->set_sensitive(checkValidInputOutput());
+}
+
+IMPL_LINK(SparklineDialog, ButtonClicked, weld::Button&, rButton, void)
+{
+    if (mxButtonOk.get() == &rButton)
+    {
+        perform();
+        response(RET_OK);
+    }
+    else
+    {
+        response(RET_CANCEL);
+    }
+}
+
+IMPL_LINK(SparklineDialog, ToggleHandler, weld::Toggleable&, rToggle, void)
+{
+    if (mxCheckButtonNegative.get() == &rToggle)
+        maAttributes.setNegative(mxCheckButtonNegative->get_active());
+    if (mxCheckButtonMarker.get() == &rToggle)
+        maAttributes.setMarkers(mxCheckButtonMarker->get_active());
+    if (mxCheckButtonHigh.get() == &rToggle)
+        maAttributes.setHigh(mxCheckButtonHigh->get_active());
+    if (mxCheckButtonLow.get() == &rToggle)
+        maAttributes.setLow(mxCheckButtonLow->get_active());
+    if (mxCheckButtonFirst.get() == &rToggle)
+        maAttributes.setFirst(mxCheckButtonFirst->get_active());
+    if (mxCheckButtonLast.get() == &rToggle)
+        maAttributes.setLast(mxCheckButtonLast->get_active());
+    if (mxCheckDisplayXAxis.get() == &rToggle)
+        maAttributes.setDisplayXAxis(mxCheckDisplayXAxis->get_active());
+    if (mxCheckDisplayHidden.get() == &rToggle)
+        maAttributes.setDisplayHidden(mxCheckDisplayHidden->get_active());
+    if (mxCheckRightToLeft.get() == &rToggle)
+        maAttributes.setRightToLeft(mxCheckRightToLeft->get_active());
+}
+
+IMPL_LINK_NOARG(SparklineDialog, SelectSparklineType, weld::ComboBox&, void)
+{
+    switch (mxType->get_active())
+    {
+        case 0:
+            maAttributes.setType(sc::SparklineType::Line);
+            break;
+        case 1:
+            maAttributes.setType(sc::SparklineType::Column);
+            break;
+        case 2:
+            maAttributes.setType(sc::SparklineType::Stacked);
+            break;
+    }
+    switch (mxDisplayEmptyGap->get_active())
+    {
+        case 1:
+            maAttributes.setDisplayEmptyCellsAs(sc::DisplayEmptyCellsAs::Gap);
+            break;
+        case 2:
+            maAttributes.setDisplayEmptyCellsAs(sc::DisplayEmptyCellsAs::Zero);
+            break;
+        case 3:
+            maAttributes.setDisplayEmptyCellsAs(sc::DisplayEmptyCellsAs::Span);
+            break;
+    }
+}
+
+IMPL_LINK_NOARG(SparklineDialog, SpinLineWidthChanged, weld::SpinButton&, void)
+{
+    double value = mxSpinLineWidth->get_value() / 100.0;
+    maAttributes.setLineWeight(value);
+}
+
+IMPL_LINK(SparklineDialog, SpinCustomChanged, weld::FormattedSpinButton&, rFormatted, void)
+{
+    if (mxSpinCustomMin.get() == &rFormatted)
+    {
+        maAttributes.setManualMin(rFormatted.GetFormatter().GetValue());
+    }
+    else if (mxSpinCustomMax.get() == &rFormatted)
+    {
+        maAttributes.setManualMax(rFormatted.GetFormatter().GetValue());
+    }
+}
+
+IMPL_LINK(SparklineDialog, ComboValueChanged, weld::ComboBox&, rComboBox, void)
+{
+    int nActive = rComboBox.get_active();
+
+    if (mxComboMinAxisType.get() == &rComboBox)
+    {
+        switch (nActive)
+        {
+            case 0:
+                maAttributes.setMinAxisType(sc::AxisType::Individual);
+                mxSpinCustomMin->set_sensitive(false);
+                break;
+            case 1:
+                maAttributes.setMinAxisType(sc::AxisType::Group);
+                mxSpinCustomMin->set_sensitive(false);
+                break;
+            case 2:
+                maAttributes.setMinAxisType(sc::AxisType::Custom);
+                mxSpinCustomMin->set_sensitive(true);
+                break;
+            default:
+                break;
+        }
+    }
+    else if (mxComboMaxAxisType.get() == &rComboBox)
+    {
+        switch (nActive)
+        {
+            case 0:
+                maAttributes.setMaxAxisType(sc::AxisType::Individual);
+                mxSpinCustomMax->set_sensitive(false);
+                break;
+            case 1:
+                maAttributes.setMaxAxisType(sc::AxisType::Group);
+                mxSpinCustomMax->set_sensitive(false);
+                break;
+            case 2:
+                maAttributes.setMaxAxisType(sc::AxisType::Custom);
+                mxSpinCustomMax->set_sensitive(true);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+bool SparklineDialog::checkValidInputOutput()
+{
+    if (mbEditMode)
+        return true;
+
+    if (!maInputRange.IsValid() || !maOutputRange.IsValid())
+        return false;
+
+    sc::RangeOrientation eInputOrientation = sc::RangeOrientation::Unknown;
+    if (maOutputRange.aStart.Col() == maOutputRange.aEnd.Col())
+    {
+        sal_Int32 nOutputRowSize = maOutputRange.aEnd.Row() - maOutputRange.aStart.Row();
+        eInputOrientation = sc::calculateOrientation(nOutputRowSize, maInputRange);
+    }
+    else if (maOutputRange.aStart.Row() == maOutputRange.aEnd.Row())
+    {
+        sal_Int32 nOutputColSize = maOutputRange.aEnd.Col() - maOutputRange.aStart.Col();
+        eInputOrientation = sc::calculateOrientation(nOutputColSize, maInputRange);
+    }
+
+    return eInputOrientation != sc::RangeOrientation::Unknown;
+}
+
+void SparklineDialog::perform()
+{
+    maAttributes.setColorSeries(mxColorSeries->GetSelectEntryColor());
+    maAttributes.setColorNegative(mxColorNegative->GetSelectEntryColor());
+    maAttributes.setColorMarkers(mxColorMarker->GetSelectEntryColor());
+    maAttributes.setColorHigh(mxColorHigh->GetSelectEntryColor());
+    maAttributes.setColorLow(mxColorLow->GetSelectEntryColor());
+    maAttributes.setColorFirst(mxColorFirst->GetSelectEntryColor());
+    maAttributes.setColorLast(mxColorLast->GetSelectEntryColor());
+
+    auto& rDocFunc = mrViewData.GetDocShell()->GetDocFunc();
+
+    if (mpSparklineGroup)
+    {
+        rDocFunc.ChangeSparklineGroupAttributes(mpSparklineGroup, maAttributes);
+    }
+    else
+    {
+        auto pNewSparklineGroup = std::make_shared<sc::SparklineGroup>(maAttributes);
+        rDocFunc.InsertSparklines(maInputRange, maOutputRange, pNewSparklineGroup);
+    }
+}
+
+} // end sc
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */