sc/Library_sc.mk | 2
sc/inc/SparklineAttributes.hxx | 145 ++++++++++++
sc/inc/SparklineGroup.hxx | 118 ----------
sc/qa/unit/SparklineImportExportTest.cxx | 124 +++++-----
sc/source/filter/excel/export/SparklineExt.cxx | 94 ++++----
sc/source/filter/inc/export/SparklineExt.hxx | 6
sc/source/filter/oox/SparklineFragment.cxx | 80 +++----
sc/source/ui/dialogs/SparklineDialog.cxx | 70 +++---
sc/source/ui/sparklines/SparklineAttributes.cxx | 273 ++++++++++++++++++++++++
sc/source/ui/sparklines/SparklineGroup.cxx | 25 ++
sc/source/ui/view/output.cxx | 79 +++---
11 files changed, 684 insertions(+), 332 deletions(-)
New commits:
commit 03ae32de9474dedb209b79f6866fa64e9e51c49e
Author: Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Tue Mar 22 15:12:55 2022 +0900
Commit: Tomaž Vajngerl <qui...@gmail.com>
CommitDate: Tue Apr 12 05:01:52 2022 +0200
sc: split attrs out of SparklineGroup into a COW class
The attributes can be independent of the actual SparklineGroup,
so they can be shared through multiple SparklineGroups and with
the attributes being COW, they can be safely changed without the
fear that it will impact a different SparklineGroup insstance.
Change-Id: I274b1243d014288ea34a213326ef765ceff86a58
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/132502
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <qui...@gmail.com>
(cherry picked from commit 634399594cfd1672caaf412ed4bc945f12aa4913)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/132832
Tested-by: Tomaž Vajngerl <qui...@gmail.com>
diff --git a/sc/Library_sc.mk b/sc/Library_sc.mk
index 5e4da178dacf..f523ee899254 100644
--- a/sc/Library_sc.mk
+++ b/sc/Library_sc.mk
@@ -510,7 +510,9 @@ $(eval $(call gb_Library_add_exception_objects,sc,\
sc/source/ui/sidebar/NumberFormatControl \
sc/source/ui/sidebar/NumberFormatPropertyPanel \
sc/source/ui/sidebar/ScPanelFactory \
+ sc/source/ui/sparklines/SparklineAttributes \
sc/source/ui/sparklines/SparklineData \
+ sc/source/ui/sparklines/SparklineGroup \
sc/source/ui/StatisticsDialogs/AnalysisOfVarianceDialog \
sc/source/ui/StatisticsDialogs/CorrelationDialog \
sc/source/ui/StatisticsDialogs/CovarianceDialog \
diff --git a/sc/inc/SparklineAttributes.hxx b/sc/inc/SparklineAttributes.hxx
new file mode 100644
index 000000000000..e89e15bc1a1b
--- /dev/null
+++ b/sc/inc/SparklineAttributes.hxx
@@ -0,0 +1,145 @@
+/* -*- 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/.
+ *
+ */
+
+#pragma once
+
+#include "scdllapi.h"
+#include <sal/types.h>
+#include <tools/color.hxx>
+#include <optional>
+#include <o3tl/cow_wrapper.hxx>
+
+namespace sc
+{
+/** Supported sparkline types */
+enum class SparklineType
+{
+ Line,
+ Column,
+ Stacked
+};
+
+/** The method of calculating the axis min or max value */
+enum class AxisType
+{
+ Individual, // calculate the min/max of a sparkline
+ Group, // calculate the min or max of the whole sparkline group
+ Custom // user defined
+};
+
+/** Determines how to display the empty cells */
+enum class DisplayEmptyCellsAs
+{
+ Span,
+ Gap,
+ Zero // empty cell equals zero
+};
+
+/** Common properties for a group of sparklines */
+class SC_DLLPUBLIC SparklineAttributes
+{
+private:
+ class Implementation;
+ o3tl::cow_wrapper<Implementation> m_aImplementation;
+
+public:
+ SparklineAttributes();
+ ~SparklineAttributes();
+ SparklineAttributes(const SparklineAttributes& rOther);
+ SparklineAttributes(SparklineAttributes&& rOther);
+ SparklineAttributes& operator=(const SparklineAttributes& rOther);
+ SparklineAttributes& operator=(SparklineAttributes&& rOther);
+
+ bool operator==(const SparklineAttributes& rOther) const;
+ bool operator!=(const SparklineAttributes& rOther) const
+ {
+ return !(SparklineAttributes::operator==(rOther));
+ }
+
+ Color getColorSeries() const;
+ void setColorSeries(Color aColorSeries);
+
+ Color getColorNegative() const;
+ void setColorNegative(Color aColorSeries);
+
+ Color getColorAxis() const;
+ void setColorAxis(Color aColorSeries);
+
+ Color getColorMarkers() const;
+ void setColorMarkers(Color aColorSeries);
+
+ Color getColorFirst() const;
+ void setColorFirst(Color aColorSeries);
+
+ Color getColorLast() const;
+ void setColorLast(Color aColorSeries);
+
+ Color getColorHigh() const;
+ void setColorHigh(Color aColorSeries);
+
+ Color getColorLow() const;
+ void setColorLow(Color aColorSeries);
+
+ AxisType getMinAxisType() const;
+ void setMinAxisType(AxisType eAxisType);
+
+ AxisType getMaxAxisType() const;
+ void setMaxAxisType(AxisType eAxisType);
+
+ /** Line weigth or width in points */
+ double getLineWeight() const;
+ void setLineWeight(double nWeight);
+
+ SparklineType getType() const;
+ void setType(SparklineType eType);
+
+ bool isDateAxis() const;
+ void setDateAxis(bool bValue);
+
+ DisplayEmptyCellsAs getDisplayEmptyCellsAs() const;
+ void setDisplayEmptyCellsAs(DisplayEmptyCellsAs eValue);
+
+ bool isMarkers() const;
+ void setMarkers(bool bValue);
+
+ bool isHigh() const;
+ void setHigh(bool bValue);
+
+ bool isLow() const;
+ void setLow(bool bValue);
+
+ bool isFirst() const;
+ void setFirst(bool bValue);
+
+ bool isLast() const;
+ void setLast(bool bValue);
+
+ bool isNegative() const;
+ void setNegative(bool bValue);
+
+ bool shouldDisplayXAxis() const;
+ void setDisplayXAxis(bool bValue);
+
+ bool shouldDisplayHidden() const;
+ void setDisplayHidden(bool bValue);
+
+ bool isRightToLeft() const;
+ void setRightToLeft(bool bValue);
+
+ std::optional<double> getManualMax() const;
+ void setManualMax(std::optional<double> aValue);
+
+ std::optional<double> getManualMin() const;
+ void setManualMin(std::optional<double> aValue);
+};
+
+} // end sc
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/inc/SparklineGroup.hxx b/sc/inc/SparklineGroup.hxx
index 9f00985e9f61..9e2fd89ff9cf 100644
--- a/sc/inc/SparklineGroup.hxx
+++ b/sc/inc/SparklineGroup.hxx
@@ -11,129 +11,25 @@
#pragma once
#include "scdllapi.h"
+#include "SparklineAttributes.hxx"
#include <tools/color.hxx>
#include <optional>
namespace sc
{
-/** Supported sparkline types */
-enum class SparklineType
-{
- Line,
- Column,
- Stacked
-};
-
-/** The method of calculating the axis min or max value */
-enum class AxisType
-{
- Individual, // calculate the min/max of a sparkline
- Group, // calculate the min or max of the whole sparkline group
- Custom // user defined
-};
-
-/** Determines how to display the empty cells */
-enum class DisplayEmptyCellAs
-{
- Span,
- Gap,
- Zero // empty cell equals zero
-};
-
/** Common properties for a group of sparklines */
class SC_DLLPUBLIC SparklineGroup
{
-public:
- Color m_aColorSeries;
- Color m_aColorNegative;
- Color m_aColorAxis;
- Color m_aColorMarkers;
- Color m_aColorFirst;
- Color m_aColorLast;
- Color m_aColorHigh;
- Color m_aColorLow;
-
- AxisType m_eMinAxisType;
- AxisType m_eMaxAxisType;
-
- double m_fLineWeight; // In pt
-
- SparklineType m_eType;
+private:
+ SparklineAttributes m_aAttributes;
- bool m_bDateAxis;
-
- DisplayEmptyCellAs m_eDisplayEmptyCellsAs;
-
- bool m_bMarkers;
- bool m_bHigh;
- bool m_bLow;
- bool m_bFirst;
- bool m_bLast;
- bool m_bNegative;
- bool m_bDisplayXAxis;
- bool m_bDisplayHidden;
- bool m_bRightToLeft;
+public:
+ SparklineAttributes& getAttributes() { return m_aAttributes; }
- std::optional<double> m_aManualMax; // if m_sMinAxisType is "custom"
- std::optional<double> m_aManualMin; // if m_sMaxAxisType is "custom"
OUString m_sUID;
- SparklineGroup()
- : m_aColorSeries(COL_BLUE)
- , m_aColorNegative(COL_RED)
- , m_aColorAxis(COL_RED)
- , m_aColorMarkers(COL_RED)
- , m_aColorFirst(COL_RED)
- , m_aColorLast(COL_RED)
- , m_aColorHigh(COL_RED)
- , m_aColorLow(COL_RED)
- , m_eMinAxisType(AxisType::Individual)
- , m_eMaxAxisType(AxisType::Individual)
- , m_fLineWeight(0.75)
- , m_eType(SparklineType::Line)
- , m_bDateAxis(false)
- , m_eDisplayEmptyCellsAs(DisplayEmptyCellAs::Zero)
- , m_bMarkers(false)
- , m_bHigh(false)
- , m_bLow(false)
- , m_bFirst(false)
- , m_bLast(false)
- , m_bNegative(false)
- , m_bDisplayXAxis(false)
- , m_bDisplayHidden(false)
- , m_bRightToLeft(false)
- {
- }
-
- SparklineGroup(SparklineGroup const& pOtherSparkline)
- : m_aColorSeries(pOtherSparkline.m_aColorSeries)
- , m_aColorNegative(pOtherSparkline.m_aColorNegative)
- , m_aColorAxis(pOtherSparkline.m_aColorAxis)
- , m_aColorMarkers(pOtherSparkline.m_aColorMarkers)
- , m_aColorFirst(pOtherSparkline.m_aColorFirst)
- , m_aColorLast(pOtherSparkline.m_aColorLast)
- , m_aColorHigh(pOtherSparkline.m_aColorHigh)
- , m_aColorLow(pOtherSparkline.m_aColorLow)
- , m_eMinAxisType(pOtherSparkline.m_eMinAxisType)
- , m_eMaxAxisType(pOtherSparkline.m_eMaxAxisType)
- , m_fLineWeight(pOtherSparkline.m_fLineWeight)
- , m_eType(pOtherSparkline.m_eType)
- , m_bDateAxis(pOtherSparkline.m_bDateAxis)
- , m_eDisplayEmptyCellsAs(pOtherSparkline.m_eDisplayEmptyCellsAs)
- , m_bMarkers(pOtherSparkline.m_bMarkers)
- , m_bHigh(pOtherSparkline.m_bHigh)
- , m_bLow(pOtherSparkline.m_bLow)
- , m_bFirst(pOtherSparkline.m_bFirst)
- , m_bLast(pOtherSparkline.m_bLast)
- , m_bNegative(pOtherSparkline.m_bNegative)
- , m_bDisplayXAxis(pOtherSparkline.m_bDisplayXAxis)
- , m_bDisplayHidden(pOtherSparkline.m_bDisplayHidden)
- , m_bRightToLeft(pOtherSparkline.m_bRightToLeft)
- , m_aManualMax(pOtherSparkline.m_aManualMax)
- , m_aManualMin(pOtherSparkline.m_aManualMin)
- , m_sUID(pOtherSparkline.m_sUID)
- {
- }
+ SparklineGroup();
+ SparklineGroup(SparklineGroup const& pOtherSparkline);
SparklineGroup& operator=(const SparklineGroup&) = delete;
};
diff --git a/sc/qa/unit/SparklineImportExportTest.cxx
b/sc/qa/unit/SparklineImportExportTest.cxx
index 25af95c8770e..8f36cf2f9adf 100644
--- a/sc/qa/unit/SparklineImportExportTest.cxx
+++ b/sc/qa/unit/SparklineImportExportTest.cxx
@@ -59,88 +59,88 @@ void checkSparklines(ScDocument& rDocument)
{
auto pSparkline = rDocument.GetSparkline(ScAddress(0, 1, 0)); // A2
CPPUNIT_ASSERT(pSparkline);
- auto pSparklineGroup = pSparkline->getSparklineGroup();
- CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line,
pSparklineGroup->m_eType);
-
- CPPUNIT_ASSERT_EQUAL(Color(0x376092), pSparklineGroup->m_aColorSeries);
- CPPUNIT_ASSERT_EQUAL(Color(0x00b050),
pSparklineGroup->m_aColorNegative);
- CPPUNIT_ASSERT_EQUAL(Color(0x000000), pSparklineGroup->m_aColorAxis);
- CPPUNIT_ASSERT_EQUAL(Color(0x000000),
pSparklineGroup->m_aColorMarkers);
- CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), pSparklineGroup->m_aColorFirst);
- CPPUNIT_ASSERT_EQUAL(Color(0xff0000), pSparklineGroup->m_aColorLast);
- CPPUNIT_ASSERT_EQUAL(Color(0x92d050), pSparklineGroup->m_aColorHigh);
- CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), pSparklineGroup->m_aColorLow);
-
- CPPUNIT_ASSERT_EQUAL(1.0, pSparklineGroup->m_fLineWeight);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bDateAxis);
- CPPUNIT_ASSERT_EQUAL(sc::DisplayEmptyCellAs::Gap,
pSparklineGroup->m_eDisplayEmptyCellsAs);
-
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bMarkers);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bHigh);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bLow);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bFirst);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bLast);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bNegative);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bDisplayXAxis);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bDisplayHidden);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bRightToLeft);
-
- CPPUNIT_ASSERT_EQUAL(false, bool(pSparklineGroup->m_aManualMax));
- CPPUNIT_ASSERT_EQUAL(false, bool(pSparklineGroup->m_aManualMin));
+ auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes();
+ CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line, rAttributes.getType());
+
+ CPPUNIT_ASSERT_EQUAL(Color(0x376092), rAttributes.getColorSeries());
+ CPPUNIT_ASSERT_EQUAL(Color(0x00b050), rAttributes.getColorNegative());
+ CPPUNIT_ASSERT_EQUAL(Color(0x000000), rAttributes.getColorAxis());
+ CPPUNIT_ASSERT_EQUAL(Color(0x000000), rAttributes.getColorMarkers());
+ CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), rAttributes.getColorFirst());
+ CPPUNIT_ASSERT_EQUAL(Color(0xff0000), rAttributes.getColorLast());
+ CPPUNIT_ASSERT_EQUAL(Color(0x92d050), rAttributes.getColorHigh());
+ CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), rAttributes.getColorLow());
+
+ CPPUNIT_ASSERT_EQUAL(1.0, rAttributes.getLineWeight());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.isDateAxis());
+ CPPUNIT_ASSERT_EQUAL(sc::DisplayEmptyCellsAs::Gap,
rAttributes.getDisplayEmptyCellsAs());
+
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isMarkers());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isHigh());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isLow());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isFirst());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isLast());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isNegative());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.shouldDisplayXAxis());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.shouldDisplayHidden());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.isRightToLeft());
+
+ CPPUNIT_ASSERT_EQUAL(false, bool(rAttributes.getManualMax()));
+ CPPUNIT_ASSERT_EQUAL(false, bool(rAttributes.getManualMin()));
}
// Sparkline at Sheet1:A3
{
auto pSparkline = rDocument.GetSparkline(ScAddress(0, 2, 0)); // A3
CPPUNIT_ASSERT(pSparkline);
- auto pSparklineGroup = pSparkline->getSparklineGroup();
- CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column,
pSparklineGroup->m_eType);
-
- CPPUNIT_ASSERT_EQUAL(Color(0x376092), pSparklineGroup->m_aColorSeries);
- CPPUNIT_ASSERT_EQUAL(Color(0xff0000),
pSparklineGroup->m_aColorNegative);
- CPPUNIT_ASSERT_EQUAL(Color(0x000000), pSparklineGroup->m_aColorAxis);
- CPPUNIT_ASSERT_EQUAL(Color(0xd00000),
pSparklineGroup->m_aColorMarkers);
- CPPUNIT_ASSERT_EQUAL(Color(0x92d050), pSparklineGroup->m_aColorFirst);
- CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), pSparklineGroup->m_aColorLast);
- CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), pSparklineGroup->m_aColorHigh);
- CPPUNIT_ASSERT_EQUAL(Color(0xffc000), pSparklineGroup->m_aColorLow);
-
- CPPUNIT_ASSERT_EQUAL(0.75, pSparklineGroup->m_fLineWeight);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bDateAxis);
- CPPUNIT_ASSERT_EQUAL(sc::DisplayEmptyCellAs::Gap,
pSparklineGroup->m_eDisplayEmptyCellsAs);
-
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bMarkers);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bHigh);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bLow);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bFirst);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bLast);
- CPPUNIT_ASSERT_EQUAL(true, pSparklineGroup->m_bNegative);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bDisplayXAxis);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bDisplayHidden);
- CPPUNIT_ASSERT_EQUAL(false, pSparklineGroup->m_bRightToLeft);
-
- CPPUNIT_ASSERT_EQUAL(false, bool(pSparklineGroup->m_aManualMax));
- CPPUNIT_ASSERT_EQUAL(false, bool(pSparklineGroup->m_aManualMin));
+ auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes();
+ CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column, rAttributes.getType());
+
+ CPPUNIT_ASSERT_EQUAL(Color(0x376092), rAttributes.getColorSeries());
+ CPPUNIT_ASSERT_EQUAL(Color(0xff0000), rAttributes.getColorNegative());
+ CPPUNIT_ASSERT_EQUAL(Color(0x000000), rAttributes.getColorAxis());
+ CPPUNIT_ASSERT_EQUAL(Color(0xd00000), rAttributes.getColorMarkers());
+ CPPUNIT_ASSERT_EQUAL(Color(0x92d050), rAttributes.getColorFirst());
+ CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), rAttributes.getColorLast());
+ CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), rAttributes.getColorHigh());
+ CPPUNIT_ASSERT_EQUAL(Color(0xffc000), rAttributes.getColorLow());
+
+ CPPUNIT_ASSERT_EQUAL(0.75, rAttributes.getLineWeight());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.isDateAxis());
+ CPPUNIT_ASSERT_EQUAL(sc::DisplayEmptyCellsAs::Gap,
rAttributes.getDisplayEmptyCellsAs());
+
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.isMarkers());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isHigh());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isLow());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isFirst());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isLast());
+ CPPUNIT_ASSERT_EQUAL(true, rAttributes.isNegative());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.shouldDisplayXAxis());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.shouldDisplayHidden());
+ CPPUNIT_ASSERT_EQUAL(false, rAttributes.isRightToLeft());
+
+ CPPUNIT_ASSERT_EQUAL(false, bool(rAttributes.getManualMax()));
+ CPPUNIT_ASSERT_EQUAL(false, bool(rAttributes.getManualMin()));
}
// Sparkline at Sheet2:B1
{
auto pSparkline = rDocument.GetSparkline(ScAddress(1, 0, 1)); //B1
CPPUNIT_ASSERT(pSparkline);
- auto pSparklineGroup = pSparkline->getSparklineGroup();
- CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column,
pSparklineGroup->m_eType);
+ auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes();
+ CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column, rAttributes.getType());
}
// Sparkline at Sheet2:B2
{
auto pSparkline = rDocument.GetSparkline(ScAddress(1, 1, 1)); //B2
CPPUNIT_ASSERT(pSparkline);
- auto pSparklineGroup = pSparkline->getSparklineGroup();
- CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line,
pSparklineGroup->m_eType);
+ auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes();
+ CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line, rAttributes.getType());
}
// Sparkline at Sheet2:B2
{
auto pSparkline = rDocument.GetSparkline(ScAddress(1, 1, 1)); //B2
CPPUNIT_ASSERT(pSparkline);
- auto pSparklineGroup = pSparkline->getSparklineGroup();
- CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line,
pSparklineGroup->m_eType);
+ auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes();
+ CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Line, rAttributes.getType());
}
// Sparkline doesn't exists at A4
{
diff --git a/sc/source/filter/excel/export/SparklineExt.cxx
b/sc/source/filter/excel/export/SparklineExt.cxx
index 9f41d9197b6a..1a82dbec46da 100644
--- a/sc/source/filter/excel/export/SparklineExt.cxx
+++ b/sc/source/filter/excel/export/SparklineExt.cxx
@@ -62,121 +62,121 @@ void SparklineExt::SaveXml(XclExpXmlStream& rStream)
void SparklineExt::addSparklineGroupAttributes(
rtl::Reference<sax_fastparser::FastAttributeList>& pAttrList,
- sc::SparklineGroup& rSparklineGroup)
+ sc::SparklineAttributes& rAttributes)
{
- if (rSparklineGroup.m_fLineWeight != 0.75)
- pAttrList->add(XML_lineWeight,
OString::number(rSparklineGroup.m_fLineWeight));
+ if (rAttributes.getLineWeight() != 0.75)
+ pAttrList->add(XML_lineWeight,
OString::number(rAttributes.getLineWeight()));
- if (rSparklineGroup.m_eType != sc::SparklineType::Line)
+ if (rAttributes.getType() != sc::SparklineType::Line)
{
- if (rSparklineGroup.m_eType == sc::SparklineType::Column)
+ if (rAttributes.getType() == sc::SparklineType::Column)
pAttrList->add(XML_type, "column");
- else if (rSparklineGroup.m_eType == sc::SparklineType::Stacked)
+ else if (rAttributes.getType() == sc::SparklineType::Stacked)
pAttrList->add(XML_type, "stacked");
}
- if (rSparklineGroup.m_bDateAxis)
+ if (rAttributes.isDateAxis())
pAttrList->add(XML_dateAxis, "1");
- if (rSparklineGroup.m_eDisplayEmptyCellsAs != sc::DisplayEmptyCellAs::Zero)
+ if (rAttributes.getDisplayEmptyCellsAs() != sc::DisplayEmptyCellsAs::Zero)
{
- if (rSparklineGroup.m_eDisplayEmptyCellsAs ==
sc::DisplayEmptyCellAs::Gap)
+ if (rAttributes.getDisplayEmptyCellsAs() ==
sc::DisplayEmptyCellsAs::Gap)
pAttrList->add(XML_displayEmptyCellsAs, "gap");
- else if (rSparklineGroup.m_eDisplayEmptyCellsAs ==
sc::DisplayEmptyCellAs::Span)
+ else if (rAttributes.getDisplayEmptyCellsAs() ==
sc::DisplayEmptyCellsAs::Span)
pAttrList->add(XML_displayEmptyCellsAs, "span");
}
- if (rSparklineGroup.m_bMarkers)
+ if (rAttributes.isMarkers())
pAttrList->add(XML_markers, "1");
- if (rSparklineGroup.m_bHigh)
+ if (rAttributes.isHigh())
pAttrList->add(XML_high, "1");
- if (rSparklineGroup.m_bLow)
+ if (rAttributes.isLow())
pAttrList->add(XML_low, "1");
- if (rSparklineGroup.m_bFirst)
+ if (rAttributes.isFirst())
pAttrList->add(XML_first, "1");
- if (rSparklineGroup.m_bLast)
+ if (rAttributes.isLast())
pAttrList->add(XML_last, "1");
- if (rSparklineGroup.m_bNegative)
+ if (rAttributes.isNegative())
pAttrList->add(XML_negative, "1");
- if (rSparklineGroup.m_bDisplayXAxis)
+ if (rAttributes.shouldDisplayXAxis())
pAttrList->add(XML_displayXAxis, "1");
- if (rSparklineGroup.m_bDisplayHidden)
+ if (rAttributes.shouldDisplayHidden())
pAttrList->add(XML_displayHidden, "1");
- if (rSparklineGroup.m_eMinAxisType != sc::AxisType::Individual)
+ if (rAttributes.getMinAxisType() != sc::AxisType::Individual)
{
- if (rSparklineGroup.m_eMinAxisType == sc::AxisType::Group)
+ if (rAttributes.getMinAxisType() == sc::AxisType::Group)
pAttrList->add(XML_minAxisType, "group");
- else if (rSparklineGroup.m_eMinAxisType == sc::AxisType::Custom)
+ else if (rAttributes.getMinAxisType() == sc::AxisType::Custom)
pAttrList->add(XML_minAxisType, "custom");
}
- if (rSparklineGroup.m_eMaxAxisType != sc::AxisType::Individual)
+ if (rAttributes.getMaxAxisType() != sc::AxisType::Individual)
{
- if (rSparklineGroup.m_eMaxAxisType == sc::AxisType::Group)
+ if (rAttributes.getMaxAxisType() == sc::AxisType::Group)
pAttrList->add(XML_maxAxisType, "group");
- else if (rSparklineGroup.m_eMaxAxisType == sc::AxisType::Custom)
+ else if (rAttributes.getMaxAxisType() == sc::AxisType::Custom)
pAttrList->add(XML_maxAxisType, "custom");
}
- if (rSparklineGroup.m_bRightToLeft)
+ if (rAttributes.isRightToLeft())
pAttrList->add(XML_rightToLeft, "1");
- if (rSparklineGroup.m_aManualMax && rSparklineGroup.m_eMaxAxisType ==
sc::AxisType::Custom)
- pAttrList->add(XML_manualMax,
OString::number(*rSparklineGroup.m_aManualMax));
+ if (rAttributes.getManualMax() && rAttributes.getMaxAxisType() ==
sc::AxisType::Custom)
+ pAttrList->add(XML_manualMax,
OString::number(*rAttributes.getManualMax()));
- if (rSparklineGroup.m_aManualMin && rSparklineGroup.m_eMinAxisType ==
sc::AxisType::Custom)
- pAttrList->add(XML_manualMin,
OString::number(*rSparklineGroup.m_aManualMin));
+ if (rAttributes.getManualMin() && rAttributes.getMinAxisType() ==
sc::AxisType::Custom)
+ pAttrList->add(XML_manualMin,
OString::number(*rAttributes.getManualMin()));
}
void SparklineExt::addSparklineGroupColors(XclExpXmlStream& rStream,
- sc::SparklineGroup& rSparklineGroup)
+ sc::SparklineAttributes&
rAttributes)
{
sax_fastparser::FSHelperPtr& rWorksheet = rStream.GetCurrentStream();
rWorksheet->singleElementNS(XML_x14, XML_colorSeries, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorSeries));
+
XclXmlUtils::ToOString(rAttributes.getColorSeries()));
- if (rSparklineGroup.m_aColorSeries != COL_TRANSPARENT)
+ if (rAttributes.getColorNegative() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorNegative, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorNegative));
+
XclXmlUtils::ToOString(rAttributes.getColorNegative()));
}
- if (rSparklineGroup.m_aColorAxis != COL_TRANSPARENT)
+ if (rAttributes.getColorAxis() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorAxis, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorAxis));
+
XclXmlUtils::ToOString(rAttributes.getColorAxis()));
}
- if (rSparklineGroup.m_aColorMarkers != COL_TRANSPARENT)
+ if (rAttributes.getColorMarkers() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorMarkers, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorMarkers));
+
XclXmlUtils::ToOString(rAttributes.getColorMarkers()));
}
- if (rSparklineGroup.m_aColorFirst != COL_TRANSPARENT)
+ if (rAttributes.getColorFirst() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorFirst, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorFirst));
+
XclXmlUtils::ToOString(rAttributes.getColorFirst()));
}
- if (rSparklineGroup.m_aColorLast != COL_TRANSPARENT)
+ if (rAttributes.getColorLast() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorLast, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorLast));
+
XclXmlUtils::ToOString(rAttributes.getColorLast()));
}
- if (rSparklineGroup.m_aColorHigh != COL_TRANSPARENT)
+ if (rAttributes.getColorHigh() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorHigh, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorHigh));
+
XclXmlUtils::ToOString(rAttributes.getColorHigh()));
}
- if (rSparklineGroup.m_aColorLow != COL_TRANSPARENT)
+ if (rAttributes.getColorLow() != COL_TRANSPARENT)
{
rWorksheet->singleElementNS(XML_x14, XML_colorLow, XML_rgb,
-
XclXmlUtils::ToOString(rSparklineGroup.m_aColorLow));
+
XclXmlUtils::ToOString(rAttributes.getColorLow()));
}
}
@@ -187,11 +187,11 @@ void SparklineExt::addSparklineGroup(XclExpXmlStream&
rStream, sc::SparklineGrou
// Sparkline Group Attributes
auto pAttrList = sax_fastparser::FastSerializerHelper::createAttrList();
- addSparklineGroupAttributes(pAttrList, rSparklineGroup);
+ addSparklineGroupAttributes(pAttrList, rSparklineGroup.getAttributes());
rWorksheet->startElementNS(XML_x14, XML_sparklineGroup, pAttrList);
- addSparklineGroupColors(rStream, rSparklineGroup);
+ addSparklineGroupColors(rStream, rSparklineGroup.getAttributes());
// Sparklines
diff --git a/sc/source/filter/inc/export/SparklineExt.hxx
b/sc/source/filter/inc/export/SparklineExt.hxx
index aa649d89e772..9843e910e252 100644
--- a/sc/source/filter/inc/export/SparklineExt.hxx
+++ b/sc/source/filter/inc/export/SparklineExt.hxx
@@ -14,6 +14,7 @@
#include <map>
#include <rangelst.hxx>
#include <Sparkline.hxx>
+#include <SparklineAttributes.hxx>
#include <sax/fastattribs.hxx>
@@ -34,11 +35,12 @@ public:
void SaveXml(XclExpXmlStream& rStream) override;
void addSparklineGroup(XclExpXmlStream& rStream, sc::SparklineGroup&
rSparklineGroup,
std::vector<std::shared_ptr<sc::Sparkline>> const&
rSparklines);
+
static void
addSparklineGroupAttributes(rtl::Reference<sax_fastparser::FastAttributeList>&
pAttrList,
- sc::SparklineGroup& rSparklineGroup);
+ sc::SparklineAttributes& rSparklineAttributes);
static void addSparklineGroupColors(XclExpXmlStream& rStream,
- sc::SparklineGroup& rSparklineGroup);
+ sc::SparklineAttributes&
rSparklineAttributes);
XclExpExtType GetType() override { return XclExpExtSparklineType; }
};
diff --git a/sc/source/filter/oox/SparklineFragment.cxx
b/sc/source/filter/oox/SparklineFragment.cxx
index ce398169972e..451b7b2a70e1 100644
--- a/sc/source/filter/oox/SparklineFragment.cxx
+++ b/sc/source/filter/oox/SparklineFragment.cxx
@@ -56,34 +56,34 @@ namespace
return ::Color();
}
-void addColorsToSparklineGroup(sc::SparklineGroup& rSparklineGroup, sal_Int32
nElement,
- const AttributeList& rAttribs, ThemeBuffer&
rThemeBuffer)
+void addColorsToSparklineAttributes(sc::SparklineAttributes& rAttributes,
sal_Int32 nElement,
+ const AttributeList& rAttribs,
ThemeBuffer& rThemeBuffer)
{
switch (nElement)
{
case XLS14_TOKEN(colorSeries):
- rSparklineGroup.m_aColorSeries = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorSeries(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorNegative):
- rSparklineGroup.m_aColorNegative = getColor(rAttribs,
rThemeBuffer);
+ rAttributes.setColorNegative(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorAxis):
- rSparklineGroup.m_aColorAxis = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorAxis(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorMarkers):
- rSparklineGroup.m_aColorMarkers = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorMarkers(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorFirst):
- rSparklineGroup.m_aColorFirst = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorFirst(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorLast):
- rSparklineGroup.m_aColorLast = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorLast(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorHigh):
- rSparklineGroup.m_aColorHigh = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorHigh(getColor(rAttribs, rThemeBuffer));
break;
case XLS14_TOKEN(colorLow):
- rSparklineGroup.m_aColorLow = getColor(rAttribs, rThemeBuffer);
+ rAttributes.setColorLow(getColor(rAttribs, rThemeBuffer));
break;
default:
break;
@@ -99,13 +99,13 @@ sc::SparklineType parseSparklineType(std::u16string_view
rString)
return sc::SparklineType::Line;
}
-sc::DisplayEmptyCellAs parseDisplayEmptyCellAs(std::u16string_view rString)
+sc::DisplayEmptyCellsAs parseDisplayEmptyCellsAs(std::u16string_view rString)
{
if (rString == u"span")
- return sc::DisplayEmptyCellAs::Span;
+ return sc::DisplayEmptyCellsAs::Span;
else if (rString == u"gap")
- return sc::DisplayEmptyCellAs::Gap;
- return sc::DisplayEmptyCellAs::Zero;
+ return sc::DisplayEmptyCellsAs::Gap;
+ return sc::DisplayEmptyCellsAs::Zero;
}
sc::AxisType parseAxisType(std::u16string_view rString)
@@ -117,45 +117,43 @@ sc::AxisType parseAxisType(std::u16string_view rString)
return sc::AxisType::Individual;
}
-void addAttributesToSparklineGroup(sc::SparklineGroup& rSparklineGroup,
- const AttributeList& rAttribs)
+void addAttributesToSparklineAttributes(sc::SparklineAttributes&
rSparklineAttributes,
+ const AttributeList& rAttribs)
{
auto oManualMax = rAttribs.getDouble(XML_manualMax);
auto oManualMin = rAttribs.getDouble(XML_manualMin);
- rSparklineGroup.m_fLineWeight = rAttribs.getDouble(XML_lineWeight, 0.75);
+ rSparklineAttributes.setLineWeight(rAttribs.getDouble(XML_lineWeight,
0.75));
OUString sType = rAttribs.getString(XML_type, "line");
- rSparklineGroup.m_eType = parseSparklineType(sType);
+ rSparklineAttributes.setType(parseSparklineType(sType));
- rSparklineGroup.m_bDateAxis = rAttribs.getBool(XML_dateAxis, false);
+ rSparklineAttributes.setDateAxis(rAttribs.getBool(XML_dateAxis, false));
OUString sDisplayEmptyCellsAs =
rAttribs.getString(XML_displayEmptyCellsAs, "zero");
- rSparklineGroup.m_eDisplayEmptyCellsAs =
parseDisplayEmptyCellAs(sDisplayEmptyCellsAs);
+
rSparklineAttributes.setDisplayEmptyCellsAs(parseDisplayEmptyCellsAs(sDisplayEmptyCellsAs));
- rSparklineGroup.m_bMarkers = rAttribs.getBool(XML_markers, false);
- rSparklineGroup.m_bHigh = rAttribs.getBool(XML_high, false);
- rSparklineGroup.m_bLow = rAttribs.getBool(XML_low, false);
- rSparklineGroup.m_bFirst = rAttribs.getBool(XML_first, false);
- rSparklineGroup.m_bLast = rAttribs.getBool(XML_last, false);
- rSparklineGroup.m_bNegative = rAttribs.getBool(XML_negative, false);
- rSparklineGroup.m_bDisplayXAxis = rAttribs.getBool(XML_displayXAxis,
false);
- rSparklineGroup.m_bDisplayHidden = rAttribs.getBool(XML_displayHidden,
false);
+ rSparklineAttributes.setMarkers(rAttribs.getBool(XML_markers, false));
+ rSparklineAttributes.setHigh(rAttribs.getBool(XML_high, false));
+ rSparklineAttributes.setLow(rAttribs.getBool(XML_low, false));
+ rSparklineAttributes.setFirst(rAttribs.getBool(XML_first, false));
+ rSparklineAttributes.setLast(rAttribs.getBool(XML_last, false));
+ rSparklineAttributes.setNegative(rAttribs.getBool(XML_negative, false));
+ rSparklineAttributes.setDisplayXAxis(rAttribs.getBool(XML_displayXAxis,
false));
+ rSparklineAttributes.setDisplayHidden(rAttribs.getBool(XML_displayHidden,
false));
OUString sMinAxisType = rAttribs.getString(XML_minAxisType, "individual");
- rSparklineGroup.m_eMinAxisType = parseAxisType(sMinAxisType);
+ rSparklineAttributes.setMinAxisType(parseAxisType(sMinAxisType));
OUString sMaxAxisType = rAttribs.getString(XML_maxAxisType, "individual");
- rSparklineGroup.m_eMaxAxisType = parseAxisType(sMaxAxisType);
+ rSparklineAttributes.setMaxAxisType(parseAxisType(sMaxAxisType));
- rSparklineGroup.m_bRightToLeft = rAttribs.getBool(XML_rightToLeft, false);
+ rSparklineAttributes.setRightToLeft(rAttribs.getBool(XML_rightToLeft,
false));
- rSparklineGroup.m_sUID = rAttribs.getString(XML_uid, OUString());
-
- if (rSparklineGroup.m_eMaxAxisType == sc::AxisType::Custom)
- rSparklineGroup.m_aManualMax = oManualMax.get();
- if (rSparklineGroup.m_eMinAxisType == sc::AxisType::Custom)
- rSparklineGroup.m_aManualMin = oManualMin.get();
+ if (rSparklineAttributes.getMaxAxisType() == sc::AxisType::Custom)
+ rSparklineAttributes.setManualMax(oManualMax.get());
+ if (rSparklineAttributes.getMinAxisType() == sc::AxisType::Custom)
+ rSparklineAttributes.setManualMin(oManualMin.get());
}
} // end anonymous namespace
@@ -173,7 +171,9 @@ ContextHandlerRef
SparklineGroupsContext::onCreateContext(sal_Int32 nElement,
case XLS14_TOKEN(sparklineGroup):
{
auto& rLastGroup = m_aSparklineGroups.emplace_back();
- addAttributesToSparklineGroup(*rLastGroup.getSparklineGroup(),
rAttribs);
+ auto& rSparklineAttributes =
rLastGroup.getSparklineGroup()->getAttributes();
+ addAttributesToSparklineAttributes(rSparklineAttributes, rAttribs);
+ rLastGroup.getSparklineGroup()->m_sUID =
rAttribs.getString(XML_uid, OUString());
return this;
}
case XLS14_TOKEN(colorSeries):
@@ -186,8 +186,8 @@ ContextHandlerRef
SparklineGroupsContext::onCreateContext(sal_Int32 nElement,
case XLS14_TOKEN(colorLow):
{
auto& rLastGroup = m_aSparklineGroups.back();
- addColorsToSparklineGroup(*rLastGroup.getSparklineGroup(),
nElement, rAttribs,
- getTheme());
+ auto& rSparklineAttributes =
rLastGroup.getSparklineGroup()->getAttributes();
+ addColorsToSparklineAttributes(rSparklineAttributes, nElement,
rAttribs, getTheme());
return this;
}
case XLS14_TOKEN(sparklines):
diff --git a/sc/source/ui/dialogs/SparklineDialog.cxx
b/sc/source/ui/dialogs/SparklineDialog.cxx
index 103582c25a6e..b285108bca6d 100644
--- a/sc/source/ui/dialogs/SparklineDialog.cxx
+++ b/sc/source/ui/dialogs/SparklineDialog.cxx
@@ -113,7 +113,9 @@ SparklineDialog::~SparklineDialog() {}
void SparklineDialog::setupValues(std::shared_ptr<sc::SparklineGroup> const&
pSparklineGroup)
{
- switch (pSparklineGroup->m_eType)
+ auto& rAttribute = pSparklineGroup->getAttributes();
+
+ switch (rAttribute.getType())
{
case sc::SparklineType::Line:
mxRadioLine->set_active(true);
@@ -126,20 +128,20 @@ void
SparklineDialog::setupValues(std::shared_ptr<sc::SparklineGroup> const& pSp
break;
}
- mxColorSeries->SelectEntry(pSparklineGroup->m_aColorSeries);
- mxColorNegative->SelectEntry(pSparklineGroup->m_aColorNegative);
- mxColorMarker->SelectEntry(pSparklineGroup->m_aColorMarkers);
- mxColorHigh->SelectEntry(pSparklineGroup->m_aColorHigh);
- mxColorLow->SelectEntry(pSparklineGroup->m_aColorLow);
- mxColorFirst->SelectEntry(pSparklineGroup->m_aColorFirst);
- mxColorLast->SelectEntry(pSparklineGroup->m_aColorLast);
-
- mxCheckButtonNegative->set_active(pSparklineGroup->m_bNegative);
- mxCheckButtonMarker->set_active(pSparklineGroup->m_bMarkers);
- mxCheckButtonHigh->set_active(pSparklineGroup->m_bHigh);
- mxCheckButtonLow->set_active(pSparklineGroup->m_bLow);
- mxCheckButtonFirst->set_active(pSparklineGroup->m_bFirst);
- mxCheckButtonLast->set_active(pSparklineGroup->m_bLast);
+ mxColorSeries->SelectEntry(rAttribute.getColorSeries());
+ mxColorNegative->SelectEntry(rAttribute.getColorNegative());
+ mxColorMarker->SelectEntry(rAttribute.getColorMarkers());
+ mxColorHigh->SelectEntry(rAttribute.getColorHigh());
+ mxColorLow->SelectEntry(rAttribute.getColorLow());
+ mxColorFirst->SelectEntry(rAttribute.getColorFirst());
+ mxColorLast->SelectEntry(rAttribute.getColorLast());
+
+ mxCheckButtonNegative->set_active(rAttribute.isNegative());
+ mxCheckButtonMarker->set_active(rAttribute.isMarkers());
+ mxCheckButtonHigh->set_active(rAttribute.isHigh());
+ mxCheckButtonLow->set_active(rAttribute.isLow());
+ mxCheckButtonFirst->set_active(rAttribute.isFirst());
+ mxCheckButtonLast->set_active(rAttribute.isLast());
}
void SparklineDialog::Close() {
DoClose(sc::SparklineDialogWrapper::GetChildWindowId()); }
@@ -289,28 +291,32 @@ IMPL_LINK(SparklineDialog, ButtonClicked, weld::Button&,
rButton, void)
IMPL_LINK(SparklineDialog, ToggleHandler, weld::Toggleable&, rToggle, void)
{
+ auto& rAttribute = mpLocalSparklineGroup->getAttributes();
+
if (mxCheckButtonNegative.get() == &rToggle)
- mpLocalSparklineGroup->m_bNegative =
mxCheckButtonNegative->get_active();
+ rAttribute.setNegative(mxCheckButtonNegative->get_active());
if (mxCheckButtonMarker.get() == &rToggle)
- mpLocalSparklineGroup->m_bMarkers = mxCheckButtonMarker->get_active();
+ rAttribute.setMarkers(mxCheckButtonMarker->get_active());
if (mxCheckButtonHigh.get() == &rToggle)
- mpLocalSparklineGroup->m_bHigh = mxCheckButtonHigh->get_active();
+ rAttribute.setHigh(mxCheckButtonHigh->get_active());
if (mxCheckButtonLow.get() == &rToggle)
- mpLocalSparklineGroup->m_bLow = mxCheckButtonLow->get_active();
+ rAttribute.setLow(mxCheckButtonLow->get_active());
if (mxCheckButtonFirst.get() == &rToggle)
- mpLocalSparklineGroup->m_bFirst = mxCheckButtonFirst->get_active();
+ rAttribute.setFirst(mxCheckButtonFirst->get_active());
if (mxCheckButtonLast.get() == &rToggle)
- mpLocalSparklineGroup->m_bLast = mxCheckButtonLast->get_active();
+ rAttribute.setLast(mxCheckButtonLast->get_active());
}
IMPL_LINK_NOARG(SparklineDialog, SelectSparklineType, weld::Toggleable&, void)
{
+ auto& rAttribute = mpLocalSparklineGroup->getAttributes();
+
if (mxRadioLine->get_active())
- mpLocalSparklineGroup->m_eType = sc::SparklineType::Line;
+ rAttribute.setType(sc::SparklineType::Line);
else if (mxRadioColumn->get_active())
- mpLocalSparklineGroup->m_eType = sc::SparklineType::Column;
+ rAttribute.setType(sc::SparklineType::Column);
else if (mxRadioStacked->get_active())
- mpLocalSparklineGroup->m_eType = sc::SparklineType::Stacked;
+ rAttribute.setType(sc::SparklineType::Stacked);
}
bool SparklineDialog::checkValidInputOutput()
@@ -335,13 +341,15 @@ bool SparklineDialog::checkValidInputOutput()
void SparklineDialog::perform()
{
- mpLocalSparklineGroup->m_aColorSeries =
mxColorSeries->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorNegative =
mxColorNegative->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorMarkers =
mxColorMarker->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorHigh = mxColorHigh->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorLow = mxColorLow->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorFirst = mxColorFirst->GetSelectEntryColor();
- mpLocalSparklineGroup->m_aColorLast = mxColorLast->GetSelectEntryColor();
+ auto& rAttribute = mpLocalSparklineGroup->getAttributes();
+
+ rAttribute.setColorSeries(mxColorSeries->GetSelectEntryColor());
+ rAttribute.setColorNegative(mxColorNegative->GetSelectEntryColor());
+ rAttribute.setColorMarkers(mxColorMarker->GetSelectEntryColor());
+ rAttribute.setColorHigh(mxColorHigh->GetSelectEntryColor());
+ rAttribute.setColorLow(mxColorLow->GetSelectEntryColor());
+ rAttribute.setColorFirst(mxColorFirst->GetSelectEntryColor());
+ rAttribute.setColorLast(mxColorLast->GetSelectEntryColor());
auto& rDocFunc = mrViewData.GetDocShell()->GetDocFunc();
diff --git a/sc/source/ui/sparklines/SparklineAttributes.cxx
b/sc/source/ui/sparklines/SparklineAttributes.cxx
new file mode 100644
index 000000000000..1203b9f67eb0
--- /dev/null
+++ b/sc/source/ui/sparklines/SparklineAttributes.cxx
@@ -0,0 +1,273 @@
+/* -*- 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 <SparklineAttributes.hxx>
+
+namespace sc
+{
+class SparklineAttributes::Implementation
+{
+public:
+ Color m_aColorSeries;
+ Color m_aColorNegative;
+ Color m_aColorAxis;
+ Color m_aColorMarkers;
+ Color m_aColorFirst;
+ Color m_aColorLast;
+ Color m_aColorHigh;
+ Color m_aColorLow;
+
+ AxisType m_eMinAxisType;
+ AxisType m_eMaxAxisType;
+
+ double m_fLineWeight; // In pt
+
+ SparklineType m_eType;
+
+ bool m_bDateAxis;
+
+ DisplayEmptyCellsAs m_eDisplayEmptyCellsAs; // span, gap, zero
+
+ bool m_bMarkers;
+ bool m_bHigh;
+ bool m_bLow;
+ bool m_bFirst;
+ bool m_bLast;
+ bool m_bNegative;
+ bool m_bDisplayXAxis;
+ bool m_bDisplayHidden;
+ bool m_bRightToLeft;
+
+ std::optional<double> m_aManualMax;
+ std::optional<double> m_aManualMin;
+
+ Implementation()
+ : m_aColorSeries(COL_BLUE)
+ , m_aColorNegative(COL_RED)
+ , m_aColorAxis(COL_RED)
+ , m_aColorMarkers(COL_RED)
+ , m_aColorFirst(COL_RED)
+ , m_aColorLast(COL_RED)
+ , m_aColorHigh(COL_RED)
+ , m_aColorLow(COL_RED)
+ , m_eMinAxisType(AxisType::Individual)
+ , m_eMaxAxisType(AxisType::Individual)
+ , m_fLineWeight(0.75)
+ , m_eType(SparklineType::Line)
+ , m_bDateAxis(false)
+ , m_eDisplayEmptyCellsAs(DisplayEmptyCellsAs::Zero)
+ , m_bMarkers(false)
+ , m_bHigh(false)
+ , m_bLow(false)
+ , m_bFirst(false)
+ , m_bLast(false)
+ , m_bNegative(false)
+ , m_bDisplayXAxis(false)
+ , m_bDisplayHidden(false)
+ , m_bRightToLeft(false)
+ {
+ }
+
+ Implementation(Implementation const& pOther)
+ : m_aColorSeries(pOther.m_aColorSeries)
+ , m_aColorNegative(pOther.m_aColorNegative)
+ , m_aColorAxis(pOther.m_aColorAxis)
+ , m_aColorMarkers(pOther.m_aColorMarkers)
+ , m_aColorFirst(pOther.m_aColorFirst)
+ , m_aColorLast(pOther.m_aColorLast)
+ , m_aColorHigh(pOther.m_aColorHigh)
+ , m_aColorLow(pOther.m_aColorLow)
+ , m_eMinAxisType(pOther.m_eMinAxisType)
+ , m_eMaxAxisType(pOther.m_eMaxAxisType)
+ , m_fLineWeight(pOther.m_fLineWeight)
+ , m_eType(pOther.m_eType)
+ , m_bDateAxis(pOther.m_bDateAxis)
+ , m_eDisplayEmptyCellsAs(pOther.m_eDisplayEmptyCellsAs)
+ , m_bMarkers(pOther.m_bMarkers)
+ , m_bHigh(pOther.m_bHigh)
+ , m_bLow(pOther.m_bLow)
+ , m_bFirst(pOther.m_bFirst)
+ , m_bLast(pOther.m_bLast)
+ , m_bNegative(pOther.m_bNegative)
+ , m_bDisplayXAxis(pOther.m_bDisplayXAxis)
+ , m_bDisplayHidden(pOther.m_bDisplayHidden)
+ , m_bRightToLeft(pOther.m_bRightToLeft)
+ , m_aManualMax(pOther.m_aManualMax)
+ , m_aManualMin(pOther.m_aManualMin)
+ {
+ }
+
+ bool operator==(const Implementation& rImpl) const
+ {
+ return (m_aColorSeries == rImpl.m_aColorSeries)
+ && (m_aColorNegative == rImpl.m_aColorNegative)
+ && (m_aColorAxis == rImpl.m_aColorAxis) && (m_aColorMarkers ==
rImpl.m_aColorMarkers)
+ && (m_aColorFirst == rImpl.m_aColorFirst) && (m_aColorLast ==
rImpl.m_aColorLast)
+ && (m_aColorHigh == rImpl.m_aColorHigh) && (m_aColorLow ==
rImpl.m_aColorLow)
+ && (m_eMinAxisType == rImpl.m_eMinAxisType)
+ && (m_eMaxAxisType == rImpl.m_eMaxAxisType) && (m_fLineWeight
== rImpl.m_fLineWeight)
+ && (m_eType == rImpl.m_eType) && (m_bDateAxis ==
rImpl.m_bDateAxis)
+ && (m_eDisplayEmptyCellsAs == rImpl.m_eDisplayEmptyCellsAs)
+ && (m_bMarkers == rImpl.m_bMarkers) && (m_bHigh ==
rImpl.m_bHigh)
+ && (m_bLow == rImpl.m_bLow) && (m_bFirst == rImpl.m_bFirst)
+ && (m_bLast == rImpl.m_bLast) && (m_bNegative ==
rImpl.m_bNegative)
+ && (m_bDisplayXAxis == rImpl.m_bDisplayXAxis)
+ && (m_bDisplayHidden == rImpl.m_bDisplayHidden)
+ && (m_bRightToLeft == rImpl.m_bRightToLeft) && (m_aManualMax ==
rImpl.m_aManualMax)
+ && (m_aManualMin == rImpl.m_aManualMin);
+ }
+};
+
+SparklineAttributes::SparklineAttributes() = default;
+
+SparklineAttributes::~SparklineAttributes() = default;
+
+SparklineAttributes::SparklineAttributes(SparklineAttributes const&) = default;
+
+SparklineAttributes::SparklineAttributes(SparklineAttributes&&) = default;
+
+SparklineAttributes& SparklineAttributes::operator=(SparklineAttributes
const&) = default;
+
+SparklineAttributes& SparklineAttributes::operator=(SparklineAttributes&&) =
default;
+
+bool SparklineAttributes::operator==(SparklineAttributes const& rOther) const
+{
+ return m_aImplementation == rOther.m_aImplementation;
+}
+
+Color SparklineAttributes::getColorSeries() const { return
m_aImplementation->m_aColorSeries; }
+
+void SparklineAttributes::setColorSeries(Color aColor)
+{
+ m_aImplementation->m_aColorSeries = aColor;
+}
+
+Color SparklineAttributes::getColorNegative() const { return
m_aImplementation->m_aColorNegative; }
+
+void SparklineAttributes::setColorNegative(Color aColor)
+{
+ m_aImplementation->m_aColorNegative = aColor;
+}
+
+Color SparklineAttributes::getColorAxis() const { return
m_aImplementation->m_aColorAxis; }
+
+void SparklineAttributes::setColorAxis(Color aColor) {
m_aImplementation->m_aColorAxis = aColor; }
+
+Color SparklineAttributes::getColorMarkers() const { return
m_aImplementation->m_aColorMarkers; }
+void SparklineAttributes::setColorMarkers(Color aColor)
+{
+ m_aImplementation->m_aColorMarkers = aColor;
+}
+
+Color SparklineAttributes::getColorFirst() const { return
m_aImplementation->m_aColorFirst; }
+void SparklineAttributes::setColorFirst(Color aColor) {
m_aImplementation->m_aColorFirst = aColor; }
+
+Color SparklineAttributes::getColorLast() const { return
m_aImplementation->m_aColorLast; }
+void SparklineAttributes::setColorLast(Color aColor) {
m_aImplementation->m_aColorLast = aColor; }
+
+Color SparklineAttributes::getColorHigh() const { return
m_aImplementation->m_aColorHigh; }
+void SparklineAttributes::setColorHigh(Color aColor) {
m_aImplementation->m_aColorHigh = aColor; }
+
+Color SparklineAttributes::getColorLow() const { return
m_aImplementation->m_aColorLow; }
+void SparklineAttributes::setColorLow(Color aColor) {
m_aImplementation->m_aColorLow = aColor; }
+
+AxisType SparklineAttributes::getMinAxisType() const { return
m_aImplementation->m_eMinAxisType; }
+void SparklineAttributes::setMinAxisType(AxisType eAxisType)
+{
+ m_aImplementation->m_eMinAxisType = eAxisType;
+}
+
+AxisType SparklineAttributes::getMaxAxisType() const { return
m_aImplementation->m_eMaxAxisType; }
+void SparklineAttributes::setMaxAxisType(AxisType eAxisType)
+{
+ m_aImplementation->m_eMaxAxisType = eAxisType;
+}
+
+double SparklineAttributes::getLineWeight() const { return
m_aImplementation->m_fLineWeight; }
+void SparklineAttributes::setLineWeight(double nWeight)
+{
+ m_aImplementation->m_fLineWeight = nWeight;
+}
+
+SparklineType SparklineAttributes::getType() const { return
m_aImplementation->m_eType; }
+void SparklineAttributes::setType(SparklineType eType) {
m_aImplementation->m_eType = eType; }
+
+bool SparklineAttributes::isDateAxis() const { return
m_aImplementation->m_bDateAxis; }
+void SparklineAttributes::setDateAxis(bool bValue) {
m_aImplementation->m_bDateAxis = bValue; }
+
+DisplayEmptyCellsAs SparklineAttributes::getDisplayEmptyCellsAs() const
+{
+ return m_aImplementation->m_eDisplayEmptyCellsAs;
+}
+void SparklineAttributes::setDisplayEmptyCellsAs(DisplayEmptyCellsAs eValue)
+{
+ m_aImplementation->m_eDisplayEmptyCellsAs = eValue;
+}
+
+bool SparklineAttributes::isMarkers() const { return
m_aImplementation->m_bMarkers; }
+void SparklineAttributes::setMarkers(bool bValue) {
m_aImplementation->m_bMarkers = bValue; }
+
+bool SparklineAttributes::isHigh() const { return m_aImplementation->m_bHigh; }
+void SparklineAttributes::setHigh(bool bValue) { m_aImplementation->m_bHigh =
bValue; }
+
+bool SparklineAttributes::isLow() const { return m_aImplementation->m_bLow; }
+void SparklineAttributes::setLow(bool bValue) { m_aImplementation->m_bLow =
bValue; }
+
+bool SparklineAttributes::isFirst() const { return
m_aImplementation->m_bFirst; }
+void SparklineAttributes::setFirst(bool bValue) { m_aImplementation->m_bFirst
= bValue; }
+
+bool SparklineAttributes::isLast() const { return m_aImplementation->m_bLast; }
+void SparklineAttributes::setLast(bool bValue) { m_aImplementation->m_bLast =
bValue; }
+
+bool SparklineAttributes::isNegative() const { return
m_aImplementation->m_bNegative; }
+void SparklineAttributes::setNegative(bool bValue) {
m_aImplementation->m_bNegative = bValue; }
+
+bool SparklineAttributes::shouldDisplayXAxis() const { return
m_aImplementation->m_bDisplayXAxis; }
+void SparklineAttributes::setDisplayXAxis(bool bValue)
+{
+ m_aImplementation->m_bDisplayXAxis = bValue;
+}
+
+bool SparklineAttributes::shouldDisplayHidden() const
+{
+ return m_aImplementation->m_bDisplayHidden;
+}
+void SparklineAttributes::setDisplayHidden(bool bValue)
+{
+ m_aImplementation->m_bDisplayHidden = bValue;
+}
+
+bool SparklineAttributes::isRightToLeft() const { return
m_aImplementation->m_bRightToLeft; }
+void SparklineAttributes::setRightToLeft(bool bValue)
+{
+ m_aImplementation->m_bRightToLeft = bValue;
+}
+
+std::optional<double> SparklineAttributes::getManualMax() const
+{
+ return m_aImplementation->m_aManualMax;
+}
+void SparklineAttributes::setManualMax(std::optional<double> aValue)
+{
+ m_aImplementation->m_aManualMax = aValue;
+}
+
+std::optional<double> SparklineAttributes::getManualMin() const
+{
+ return m_aImplementation->m_aManualMin;
+}
+void SparklineAttributes::setManualMin(std::optional<double> aValue)
+{
+ m_aImplementation->m_aManualMin = aValue;
+}
+
+} // end sc
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/sparklines/SparklineGroup.cxx
b/sc/source/ui/sparklines/SparklineGroup.cxx
new file mode 100644
index 000000000000..55f52ff4665f
--- /dev/null
+++ b/sc/source/ui/sparklines/SparklineGroup.cxx
@@ -0,0 +1,25 @@
+/* -*- 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 <SparklineGroup.hxx>
+
+namespace sc
+{
+SparklineGroup::SparklineGroup() {}
+
+SparklineGroup::SparklineGroup(SparklineGroup const& pOtherSparkline)
+ : m_aAttributes(pOtherSparkline.m_aAttributes)
+ , m_sUID(pOtherSparkline.m_sUID)
+{
+}
+
+} // end sc
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/view/output.cxx b/sc/source/ui/view/output.cxx
index 1e6a6c018f29..0cd3d91cda7f 100644
--- a/sc/source/ui/view/output.cxx
+++ b/sc/source/ui/view/output.cxx
@@ -2323,8 +2323,8 @@ void createMarker(std::vector<SparklineMarker> &
rMarkers, double x, double y, C
/** Draw a line chart into the rectangle bounds */
void drawLine(vcl::RenderContext& rRenderContext, tools::Rectangle const &
rRectangle,
- std::vector<double> const & rValues, double nMin, double nMax,
- std::shared_ptr<sc::SparklineGroup> const & pSparklineGroup)
+ std::vector<double> const& rValues, double nMin, double nMax,
+ sc::SparklineAttributes const& rAttributes)
{
basegfx::B2DPolygon aPolygon;
double numebrOfSteps = rValues.size() - 1;
@@ -2343,25 +2343,25 @@ void drawLine(vcl::RenderContext& rRenderContext,
tools::Rectangle const & rRect
aPolygon.append({ x, y } );
- if (pSparklineGroup->m_bFirst && nValueIndex == 0)
+ if (rAttributes.isFirst() && nValueIndex == 0)
{
- createMarker(aMarkers, x, y, pSparklineGroup->m_aColorFirst);
+ createMarker(aMarkers, x, y, rAttributes.getColorFirst());
}
- else if (pSparklineGroup->m_bLast && nValueIndex == (nValuesSize - 1))
+ else if (rAttributes.isLast() && nValueIndex == (nValuesSize - 1))
{
- createMarker(aMarkers, x, y, pSparklineGroup->m_aColorLast);
+ createMarker(aMarkers, x, y, rAttributes.getColorLast());
}
- else if (pSparklineGroup->m_bHigh && nValue == nMax)
+ else if (rAttributes.isHigh() && nValue == nMax)
{
- createMarker(aMarkers, x, y, pSparklineGroup->m_aColorHigh);
+ createMarker(aMarkers, x, y, rAttributes.getColorHigh());
}
- else if (pSparklineGroup->m_bLow && nValue == nMin)
+ else if (rAttributes.isLow() && nValue == nMin)
{
- createMarker(aMarkers, x, y, pSparklineGroup->m_aColorLow);
+ createMarker(aMarkers, x, y, rAttributes.getColorLow());
}
- else if (pSparklineGroup->m_bNegative && nValue < 0.0)
+ else if (rAttributes.isNegative() && nValue < 0.0)
{
- createMarker(aMarkers, x, y, pSparklineGroup->m_aColorNegative);
+ createMarker(aMarkers, x, y, rAttributes.getColorNegative());
}
xStep++;
@@ -2372,7 +2372,7 @@ void drawLine(vcl::RenderContext& rRenderContext,
tools::Rectangle const & rRect
aMatrix.translate(rRectangle.Left(), rRectangle.Top());
aPolygon.transform(aMatrix);
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorSeries);
+ rRenderContext.SetLineColor(rAttributes.getColorSeries());
rRenderContext.DrawPolyLine(aPolygon);
for (auto const & rMarker : aMarkers)
@@ -2385,45 +2385,45 @@ void drawLine(vcl::RenderContext& rRenderContext,
tools::Rectangle const & rRect
}
}
-void setFillAndLineColor(vcl::RenderContext& rRenderContext,
std::shared_ptr<sc::SparklineGroup> const & pSparklineGroup,
+void setFillAndLineColor(vcl::RenderContext& rRenderContext,
sc::SparklineAttributes const& rAttributes,
double nValue, sal_Int64 nValueIndex, sal_Int64
nValuesSize, double nMin, double nMax)
{
- if (pSparklineGroup->m_bFirst && nValueIndex == 0)
+ if (rAttributes.isFirst() && nValueIndex == 0)
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorFirst);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorFirst);
+ rRenderContext.SetLineColor(rAttributes.getColorFirst());
+ rRenderContext.SetFillColor(rAttributes.getColorFirst());
}
- else if (pSparklineGroup->m_bLast && nValueIndex == (nValuesSize - 1))
+ else if (rAttributes.isLast() && nValueIndex == (nValuesSize - 1))
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorLast);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorLast);
+ rRenderContext.SetLineColor(rAttributes.getColorLast());
+ rRenderContext.SetFillColor(rAttributes.getColorLast());
}
- else if (pSparklineGroup->m_bHigh && nValue == nMax)
+ else if (rAttributes.isHigh() && nValue == nMax)
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorHigh);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorHigh);
+ rRenderContext.SetLineColor(rAttributes.getColorHigh());
+ rRenderContext.SetFillColor(rAttributes.getColorHigh());
}
- else if (pSparklineGroup->m_bLow && nValue == nMin)
+ else if (rAttributes.isLow() && nValue == nMin)
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorLow);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorLow);
+ rRenderContext.SetLineColor(rAttributes.getColorLow());
+ rRenderContext.SetFillColor(rAttributes.getColorLow());
}
- else if (pSparklineGroup->m_bNegative && nValue < 0.0)
+ else if (rAttributes.isNegative() && nValue < 0.0)
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorNegative);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorNegative);
+ rRenderContext.SetLineColor(rAttributes.getColorNegative());
+ rRenderContext.SetFillColor(rAttributes.getColorNegative());
}
else
{
- rRenderContext.SetLineColor(pSparklineGroup->m_aColorSeries);
- rRenderContext.SetFillColor(pSparklineGroup->m_aColorSeries);
+ rRenderContext.SetLineColor(rAttributes.getColorSeries());
+ rRenderContext.SetFillColor(rAttributes.getColorSeries());
}
}
/** Draw a column chart into the rectangle bounds */
void drawColumn(vcl::RenderContext& rRenderContext, tools::Rectangle const &
rRectangle,
std::vector<double> const & rValues, double nMin, double nMax,
- std::shared_ptr<sc::SparklineGroup> const & pSparklineGroup)
+ sc::SparklineAttributes const & rAttributes)
{
basegfx::B2DPolygon aPolygon;
@@ -2447,7 +2447,7 @@ void drawColumn(vcl::RenderContext& rRenderContext,
tools::Rectangle const & rRe
{
if (nValue != 0.0)
{
- setFillAndLineColor(rRenderContext, pSparklineGroup, nValue,
nValueIndex, sal_Int64(rValues.size()), nMax, nMin);
+ setFillAndLineColor(rRenderContext, rAttributes, nValue,
nValueIndex, sal_Int64(rValues.size()), nMax, nMin);
double nP = (nValue - nMin) / nDelta;
double x = rRectangle.GetWidth() * (xStep / numberOfSteps);
@@ -2475,6 +2475,7 @@ void drawSparkline(std::shared_ptr<sc::Sparkline> const&
pSparkline, vcl::Render
return;
auto pSparklineGroup = pSparkline->getSparklineGroup();
+ auto const& rAttributes = pSparklineGroup->getAttributes();
rRenderContext.SetAntialiasing(AntialiasingFlags::Enable);
@@ -2516,11 +2517,11 @@ void drawSparkline(std::shared_ptr<sc::Sparkline>
const& pSparkline, vcl::Render
}
}
- if (pSparklineGroup->m_eType == sc::SparklineType::Column)
+ if (rAttributes.getType() == sc::SparklineType::Column)
{
- drawColumn(rRenderContext, rRectangle, aValues, nMin, nMax,
pSparklineGroup);
+ drawColumn(rRenderContext, rRectangle, aValues, nMin, nMax,
pSparklineGroup->getAttributes());
}
- else if (pSparklineGroup->m_eType == sc::SparklineType::Stacked)
+ else if (rAttributes.getType() == sc::SparklineType::Stacked)
{
// transform the data to 1, -1
for (auto & rValue : aValues)
@@ -2528,11 +2529,11 @@ void drawSparkline(std::shared_ptr<sc::Sparkline>
const& pSparkline, vcl::Render
if (rValue != 0.0)
rValue = rValue > 0.0 ? 1.0 : -1.0;
}
- drawColumn(rRenderContext, rRectangle, aValues, -1, 1,
pSparklineGroup);
+ drawColumn(rRenderContext, rRectangle, aValues, -1, 1,
pSparklineGroup->getAttributes());
}
- else if (pSparklineGroup->m_eType == sc::SparklineType::Line)
+ else if (rAttributes.getType() == sc::SparklineType::Line)
{
- drawLine(rRenderContext, rRectangle, aValues, nMin, nMax,
pSparklineGroup);
+ drawLine(rRenderContext, rRectangle, aValues, nMin, nMax,
pSparklineGroup->getAttributes());
}
}
} // end anonymous namespace
