From c8d8bf4282cbd04abacfa69ba2cc0fa4300e35e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Toma=C5=BE=20Vajngerl?= Date: Sun, 30 Jul 2023 08:52:44 +0200 Subject: [PATCH] sc: theme color support for sparklines + ODF & OOXML import/export MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This changes Sparkline colors to use complex colors instead and adds Sparkline theme color import and export support for ODF and OOXML. Change-Id: I58edd525d50f95199bd4fe7825afb51aaa7fc091 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/155113 Tested-by: Jenkins Reviewed-by: Tomaž Vajngerl --- include/docmodel/color/ComplexColor.hxx | 7 + include/oox/export/ColorExportUtils.hxx | 48 +- include/xmloff/XMLComplexColorContext.hxx | 45 +- include/xmloff/XMLComplexColorExport.hxx | 11 + include/xmloff/xmltoken.hxx | 14 +- oox/Library_oox.mk | 1 + oox/source/drawingml/color.cxx | 7 +- oox/source/export/ColorExportUtils.cxx | 55 ++ sc/CppunitTest_sc_sparkline_test.mk | 1 + sc/CppunitTest_sc_ucalc_sparkline.mk | 3 + sc/Library_scfilt.mk | 1 + sc/inc/SparklineAttributes.hxx | 35 +- sc/qa/unit/SparklineImportExportTest.cxx | 92 ++- sc/qa/unit/data/fods/Sparklines.fods | 590 ++++++++++++++++++ sc/qa/unit/ucalc_sparkline.cxx | 120 +++- sc/source/filter/excel/export/ExportTools.cxx | 45 ++ .../filter/excel/export/SparklineExt.cxx | 60 +- sc/source/filter/excel/xestyle.cxx | 1 - sc/source/filter/inc/export/ExportTools.hxx | 21 +- sc/source/filter/oox/SparklineFragment.cxx | 35 +- .../filter/xml/SparklineGroupsExport.cxx | 32 +- .../filter/xml/SparklineGroupsExport.hxx | 9 +- .../xml/SparklineGroupsImportContext.cxx | 126 +++- .../xml/SparklineGroupsImportContext.hxx | 19 + sc/source/filter/xml/xmlstyli.cxx | 2 +- sc/source/ui/dialogs/SparklineDialog.cxx | 28 +- sc/source/ui/inc/SparklineRenderer.hxx | 42 +- .../ui/sparklines/SparklineAttributes.cxx | 134 ++-- sc/source/ui/theme/ThemeColorChanger.cxx | 50 ++ .../OpenDocument-v1.3+libreoffice-schema.rng | 87 ++- xmloff/source/core/xmltoken.cxx | 14 +- .../draw/XMLShapePropertySetContext.cxx | 2 +- .../source/style/StylePropertiesContext.cxx | 3 +- xmloff/source/text/XMLComplexColorContext.cxx | 69 +- xmloff/source/text/XMLComplexColorExport.cxx | 35 +- .../source/text/XMLTextPropertySetContext.cxx | 2 +- .../source/text/XMLTextShapeStyleContext.cxx | 2 +- xmloff/source/token/tokens.txt | 14 +- 38 files changed, 1521 insertions(+), 341 deletions(-) create mode 100644 oox/source/export/ColorExportUtils.cxx create mode 100644 sc/qa/unit/data/fods/Sparklines.fods create mode 100644 sc/source/filter/excel/export/ExportTools.cxx diff --git a/include/docmodel/color/ComplexColor.hxx b/include/docmodel/color/ComplexColor.hxx index e9597b15186b..88ff7a42a478 100644 --- a/include/docmodel/color/ComplexColor.hxx +++ b/include/docmodel/color/ComplexColor.hxx @@ -246,6 +246,13 @@ public: o3tl::hash_combine(seed, sal_uInt32(maFinalColor)); return seed; } + + static model::ComplexColor RGB(Color const& rColor) + { + model::ComplexColor aComplexColor; + aComplexColor.setColor(rColor); + return aComplexColor; + } }; } // end of namespace svx diff --git a/include/oox/export/ColorExportUtils.hxx b/include/oox/export/ColorExportUtils.hxx index 63716a10839d..f9dafe260b46 100644 --- a/include/oox/export/ColorExportUtils.hxx +++ b/include/oox/export/ColorExportUtils.hxx @@ -9,47 +9,21 @@ #pragma once -#include +#include -#include +namespace model +{ +class ComplexColor; +} +namespace model +{ +enum class ThemeColorType : sal_Int32; +} namespace oox { -static double convertColorTransformsToTintOrShade(model::ComplexColor const& rComplexColor) -{ - sal_Int16 nLumMod = 10'000; - sal_Int16 nLumOff = 0; - - for (auto const& rTransform : rComplexColor.getTransformations()) - { - if (rTransform.meType == model::TransformationType::LumMod) - nLumMod = rTransform.mnValue; - if (rTransform.meType == model::TransformationType::LumOff) - nLumOff = rTransform.mnValue; - } - - if (nLumMod == 10'000 && nLumOff == 0) - return 0.0; - - double fTint = 0.0; - - if (nLumOff > 0) // tint - fTint = double(nLumOff) / 10'000.0; - else - fTint = -double(10'000 - nLumMod) / 10'000.0; - - return fTint; -} - -static sal_Int32 convertThemeColorTypeToExcelThemeNumber(model::ThemeColorType eType) -{ - if (eType == model::ThemeColorType::Unknown) - return -1; - - constexpr std::array constMap = { 1, 0, 3, 2, 4, 5, 6, 7, 8, 9, 10, 11 }; - - return constMap[sal_Int32(eType)]; -} +OOX_DLLPUBLIC double convertColorTransformsToTintOrShade(model::ComplexColor const& rComplexColor); +OOX_DLLPUBLIC sal_Int32 convertThemeColorTypeToExcelThemeNumber(model::ThemeColorType eType); } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/xmloff/XMLComplexColorContext.hxx b/include/xmloff/XMLComplexColorContext.hxx index cbb785994169..5654cc204206 100644 --- a/include/xmloff/XMLComplexColorContext.hxx +++ b/include/xmloff/XMLComplexColorContext.hxx @@ -10,25 +10,60 @@ #pragma once #include + #include #include -#include +#include +#include -class XMLOFF_DLLPUBLIC XMLComplexColorContext final : public XMLElementPropertyContext +class XMLOFF_DLLPUBLIC XMLComplexColorImport { +private: + model::ComplexColor& mrComplexColor; + +public: + XMLComplexColorImport(model::ComplexColor& rComplexColor); + void fillAttributes(const css::uno::Reference& xAttrList); + bool + handleTransformContext(sal_Int32 nElement, + const css::uno::Reference& xAttrList); +}; + +class XMLOFF_DLLPUBLIC XMLPropertyComplexColorContext final : public XMLElementPropertyContext +{ +private: model::ComplexColor maComplexColor; sal_Int32 mnRootElement; + XMLComplexColorImport maComplexColorImport; + public: - XMLComplexColorContext(SvXMLImport& rImport, sal_Int32 nElement, - const css::uno::Reference& xAttrList, - const XMLPropertyState& rProp, std::vector& rProps); + XMLPropertyComplexColorContext( + SvXMLImport& rImport, sal_Int32 nElement, + const css::uno::Reference& xAttrList, + const XMLPropertyState& rProp, std::vector& rProps); css::uno::Reference SAL_CALL createFastChildContext( sal_Int32 nElement, const css::uno::Reference& AttrList) override; void SAL_CALL endFastElement(sal_Int32 nElement) override; + + model::ComplexColor getComplexColor() { return maComplexColor; } +}; + +class XMLOFF_DLLPUBLIC XMLComplexColorContext final : public SvXMLImportContext +{ +private: + XMLComplexColorImport maComplexColorImport; + +public: + XMLComplexColorContext(SvXMLImport& rImport, model::ComplexColor& rComplexColor, + const css::uno::Reference& xAttrList); + + css::uno::Reference SAL_CALL createFastChildContext( + sal_Int32 nElement, + const css::uno::Reference& AttrList) override; }; /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/xmloff/XMLComplexColorExport.hxx b/include/xmloff/XMLComplexColorExport.hxx index 28911737ff89..51425f52ab55 100644 --- a/include/xmloff/XMLComplexColorExport.hxx +++ b/include/xmloff/XMLComplexColorExport.hxx @@ -11,20 +11,31 @@ #include #include #include +#include namespace com::sun::star::uno { class Any; } +namespace model +{ +class ComplexColor; +} + class SvXMLExport; class XMLOFF_DLLPUBLIC XMLComplexColorExport { SvXMLExport& mrExport; + void doExport(model::ComplexColor const& rComplexColor, sal_uInt16 nPrefix, + const OUString& rLocalName); + public: XMLComplexColorExport(SvXMLExport& rExport); + void exportComplexColor(model::ComplexColor const& rComplexColor, sal_uInt16 nPrefix, + xmloff::token::XMLTokenEnum nToken); void exportXML(const css::uno::Any& rAny, sal_uInt16 nPrefix, const OUString& rLocalName); }; diff --git a/include/xmloff/xmltoken.hxx b/include/xmloff/xmltoken.hxx index 5c929137cad6..1806178b12d6 100644 --- a/include/xmloff/xmltoken.hxx +++ b/include/xmloff/xmltoken.hxx @@ -1800,10 +1800,18 @@ namespace xmloff::token { XML_SOURCE_RANGE_ADDRESS, XML_SOURCE_SERVICE, XML_SPACE_BEFORE, - XML_SPARKLINE_GROUPS, - XML_SPARKLINE_GROUP, - XML_SPARKLINES, XML_SPARKLINE, + XML_SPARKLINES, + XML_SPARKLINE_AXIS_COMPLEX_COLOR, + XML_SPARKLINE_FIRST_COMPLEX_COLOR, + XML_SPARKLINE_GROUP, + XML_SPARKLINE_GROUPS, + XML_SPARKLINE_HIGH_COMPLEX_COLOR, + XML_SPARKLINE_LAST_COMPLEX_COLOR, + XML_SPARKLINE_LOW_COMPLEX_COLOR, + XML_SPARKLINE_MARKERS_COMPLEX_COLOR, + XML_SPARKLINE_NEGATIVE_COMPLEX_COLOR, + XML_SPARKLINE_SERIES_COMPLEX_COLOR, XML_SPAN, XML_SPECULAR, XML_SPECULAR_COLOR, diff --git a/oox/Library_oox.mk b/oox/Library_oox.mk index 3bf2d607918c..e37df6a393b9 100644 --- a/oox/Library_oox.mk +++ b/oox/Library_oox.mk @@ -228,6 +228,7 @@ $(eval $(call gb_Library_add_exception_objects,oox,\ oox/source/dump/oledumper \ oox/source/dump/pptxdumper \ oox/source/export/ColorPropertySet \ + oox/source/export/ColorExportUtils \ oox/source/export/drawingml \ oox/source/export/DMLPresetShapeExport \ oox/source/export/shapes \ diff --git a/oox/source/drawingml/color.cxx b/oox/source/drawingml/color.cxx index 1ed2e57b6242..e582d4e53c77 100644 --- a/oox/source/drawingml/color.cxx +++ b/oox/source/drawingml/color.cxx @@ -825,9 +825,14 @@ model::ComplexColor Color::createComplexColor(const GraphicHelper& /*rGraphicHel auto eTheme = getThemeColorType(); aNewComplexColor.setSchemeColor(eTheme); } + else if (meMode == COLOR_RGB) + { + ::Color aColor(ColorTransparency, lclRgbComponentsToRgb(mnC1, mnC2, mnC3)); + aNewComplexColor = model::ComplexColor::RGB(aColor); + } else { - // TODO + // TODO - Add other options return aNewComplexColor; } diff --git a/oox/source/export/ColorExportUtils.cxx b/oox/source/export/ColorExportUtils.cxx new file mode 100644 index 000000000000..2b9f7baabc53 --- /dev/null +++ b/oox/source/export/ColorExportUtils.cxx @@ -0,0 +1,55 @@ +/* -*- 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 +#include +#include +#include + +namespace oox +{ +double convertColorTransformsToTintOrShade(model::ComplexColor const& rComplexColor) +{ + sal_Int16 nLumMod = 10'000; + sal_Int16 nLumOff = 0; + + for (auto const& rTransform : rComplexColor.getTransformations()) + { + if (rTransform.meType == model::TransformationType::LumMod) + nLumMod = rTransform.mnValue; + if (rTransform.meType == model::TransformationType::LumOff) + nLumOff = rTransform.mnValue; + } + + if (nLumMod == 10'000 && nLumOff == 0) + return 0.0; + + double fTint = 0.0; + + if (nLumOff > 0) // tint + fTint = double(nLumOff) / 10'000.0; + else + fTint = -double(10'000 - nLumMod) / 10'000.0; + + return fTint; +} + +sal_Int32 convertThemeColorTypeToExcelThemeNumber(model::ThemeColorType eType) +{ + if (eType == model::ThemeColorType::Unknown) + return -1; + + static constexpr std::array constThemeColorMapToXmlMap + = { 1, 0, 3, 2, 4, 5, 6, 7, 8, 9, 10, 11 }; + + return constThemeColorMapToXmlMap[sal_Int32(eType)]; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/CppunitTest_sc_sparkline_test.mk b/sc/CppunitTest_sc_sparkline_test.mk index ca678f4829d8..c1f06f65e3d2 100644 --- a/sc/CppunitTest_sc_sparkline_test.mk +++ b/sc/CppunitTest_sc_sparkline_test.mk @@ -28,6 +28,7 @@ $(eval $(call gb_CppunitTest_use_libraries,sc_sparkline_test, \ comphelper \ cppu \ cppuhelper \ + docmodel \ sal \ salhelper \ sax \ diff --git a/sc/CppunitTest_sc_ucalc_sparkline.mk b/sc/CppunitTest_sc_ucalc_sparkline.mk index 99f75e086fc0..24d24b99ee4e 100644 --- a/sc/CppunitTest_sc_ucalc_sparkline.mk +++ b/sc/CppunitTest_sc_ucalc_sparkline.mk @@ -28,12 +28,15 @@ $(eval $(call gb_CppunitTest_use_libraries,sc_ucalc_sparkline, \ comphelper \ cppu \ cppuhelper \ + docmodel \ + editeng \ sal \ salhelper \ sax \ sc \ scqahelper \ sfx \ + svxcore \ subsequenttest \ test \ tl \ diff --git a/sc/Library_scfilt.mk b/sc/Library_scfilt.mk index 5837f1ec3492..7b345b85e0f5 100644 --- a/sc/Library_scfilt.mk +++ b/sc/Library_scfilt.mk @@ -133,6 +133,7 @@ $(eval $(call gb_Library_add_exception_objects,scfilt,\ sc/source/filter/excel/xltracer \ sc/source/filter/excel/xlview \ sc/source/filter/excel/export/SparklineExt \ + sc/source/filter/excel/export/ExportTools \ sc/source/filter/ftools/fapihelper \ sc/source/filter/ftools/fprogressbar \ sc/source/filter/ftools/ftools \ diff --git a/sc/inc/SparklineAttributes.hxx b/sc/inc/SparklineAttributes.hxx index d1baf732ced3..04a6c0abb696 100644 --- a/sc/inc/SparklineAttributes.hxx +++ b/sc/inc/SparklineAttributes.hxx @@ -13,6 +13,7 @@ #include "scdllapi.h" #include #include +#include #include #include @@ -63,29 +64,31 @@ public: return !(SparklineAttributes::operator==(rOther)); } - Color getColorSeries() const; - void setColorSeries(Color aColorSeries); + void resetColors(); - Color getColorNegative() const; - void setColorNegative(Color aColorSeries); + model::ComplexColor getColorSeries() const; + void setColorSeries(model::ComplexColor const& rColorSeries); - Color getColorAxis() const; - void setColorAxis(Color aColorSeries); + model::ComplexColor getColorNegative() const; + void setColorNegative(model::ComplexColor const& rColorSeries); - Color getColorMarkers() const; - void setColorMarkers(Color aColorSeries); + model::ComplexColor getColorAxis() const; + void setColorAxis(model::ComplexColor const& rColorSeries); - Color getColorFirst() const; - void setColorFirst(Color aColorSeries); + model::ComplexColor getColorMarkers() const; + void setColorMarkers(model::ComplexColor const& rColorSeries); - Color getColorLast() const; - void setColorLast(Color aColorSeries); + model::ComplexColor getColorFirst() const; + void setColorFirst(model::ComplexColor const& rColorSeries); - Color getColorHigh() const; - void setColorHigh(Color aColorSeries); + model::ComplexColor getColorLast() const; + void setColorLast(model::ComplexColor const& rColorSeries); - Color getColorLow() const; - void setColorLow(Color aColorSeries); + model::ComplexColor getColorHigh() const; + void setColorHigh(model::ComplexColor const& rColorSeries); + + model::ComplexColor getColorLow() const; + void setColorLow(model::ComplexColor const& rColorSeries); AxisType getMinAxisType() const; void setMinAxisType(AxisType eAxisType); diff --git a/sc/qa/unit/SparklineImportExportTest.cxx b/sc/qa/unit/SparklineImportExportTest.cxx index 46e5bda43377..7462a6df0e11 100644 --- a/sc/qa/unit/SparklineImportExportTest.cxx +++ b/sc/qa/unit/SparklineImportExportTest.cxx @@ -30,12 +30,16 @@ public: void testSparklinesExportODS(); void testSparklinesRoundtripODS(); void testNoSparklinesInDocumentXLSX(); + void testSparklinesRoundtripThemeColorsODS(); + void testSparklinesRoundtripThemeColorsOOXML(); CPPUNIT_TEST_SUITE(SparklineImportExportTest); CPPUNIT_TEST(testSparklinesRoundtripXLSX); CPPUNIT_TEST(testSparklinesExportODS); CPPUNIT_TEST(testSparklinesRoundtripODS); CPPUNIT_TEST(testNoSparklinesInDocumentXLSX); + CPPUNIT_TEST(testSparklinesRoundtripThemeColorsODS); + CPPUNIT_TEST(testSparklinesRoundtripThemeColorsOOXML); CPPUNIT_TEST_SUITE_END(); }; @@ -53,14 +57,14 @@ void checkSparklines(ScDocument& rDocument) 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(COL_BLACK, rAttributes.getColorAxis()); - CPPUNIT_ASSERT_EQUAL(COL_BLACK, 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(Color(0x376092), rAttributes.getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x00b050), rAttributes.getColorNegative().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, rAttributes.getColorAxis().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, rAttributes.getColorMarkers().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), rAttributes.getColorFirst().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0xff0000), rAttributes.getColorLast().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x92d050), rAttributes.getColorHigh().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), rAttributes.getColorLow().getFinalColor()); CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, rAttributes.getLineWeight(), 1E-2); CPPUNIT_ASSERT_EQUAL(false, rAttributes.isDateAxis()); @@ -86,14 +90,14 @@ void checkSparklines(ScDocument& rDocument) 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(COL_BLACK, 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(Color(0x376092), rAttributes.getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0xff0000), rAttributes.getColorNegative().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, rAttributes.getColorAxis().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0xd00000), rAttributes.getColorMarkers().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x92d050), rAttributes.getColorFirst().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x00b0f0), rAttributes.getColorLast().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x7030a0), rAttributes.getColorHigh().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0xffc000), rAttributes.getColorLow().getFinalColor()); CPPUNIT_ASSERT_EQUAL(0.75, rAttributes.getLineWeight()); CPPUNIT_ASSERT_EQUAL(false, rAttributes.isDateAxis()); @@ -223,7 +227,7 @@ void SparklineImportExportTest::testSparklinesRoundtripODS() void SparklineImportExportTest::testNoSparklinesInDocumentXLSX() { // tdf#148835 - // Check no sparkline elements are written when there is none in the document + // Check no sparkline elements are written when there are none in the document // Load the document containing NO sparklines loadFromURL(u"xlsx/empty.xlsx"); @@ -238,6 +242,60 @@ void SparklineImportExportTest::testNoSparklinesInDocumentXLSX() assertXPath(pXmlDoc, "/x:worksheet/x:extLst", 0); } +namespace +{ +void checkSparklineThemeColors(ScDocument& rDocument) +{ + auto pSparkline = rDocument.GetSparkline(ScAddress(0, 1, 0)); // A2 + CPPUNIT_ASSERT(pSparkline); + CPPUNIT_ASSERT_EQUAL(OString("{1C5C5DE0-3C09-4CB3-A3EC-9E763301EC82}"), + pSparkline->getSparklineGroup()->getID().getString()); + + auto& rAttributes = pSparkline->getSparklineGroup()->getAttributes(); + CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column, rAttributes.getType()); + + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent3, + rAttributes.getColorSeries().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent6, + rAttributes.getColorNegative().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ColorType::Unused, rAttributes.getColorAxis().getType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Light1, + rAttributes.getColorMarkers().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent5, + rAttributes.getColorFirst().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent2, + rAttributes.getColorLast().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent1, + rAttributes.getColorHigh().getSchemeType()); + CPPUNIT_ASSERT_EQUAL(model::ThemeColorType::Accent4, rAttributes.getColorLow().getSchemeType()); +} +} // end anonymous namespace + +void SparklineImportExportTest::testSparklinesRoundtripThemeColorsODS() +{ + loadFromURL(u"fods/Sparklines.fods"); + + ScModelObj* pModelObj = comphelper::getFromUnoTunnel(mxComponent); + CPPUNIT_ASSERT(pModelObj); + checkSparklineThemeColors(*pModelObj->GetDocument()); + + saveAndReload("calc8"); + + pModelObj = comphelper::getFromUnoTunnel(mxComponent); + CPPUNIT_ASSERT(pModelObj); + checkSparklineThemeColors(*pModelObj->GetDocument()); +} + +void SparklineImportExportTest::testSparklinesRoundtripThemeColorsOOXML() +{ + loadFromURL(u"fods/Sparklines.fods"); + saveAndReload("Calc Office Open XML"); + + ScModelObj* pModelObj = comphelper::getFromUnoTunnel(mxComponent); + CPPUNIT_ASSERT(pModelObj); + checkSparklineThemeColors(*pModelObj->GetDocument()); +} + CPPUNIT_TEST_SUITE_REGISTRATION(SparklineImportExportTest); CPPUNIT_PLUGIN_IMPLEMENT(); diff --git a/sc/qa/unit/data/fods/Sparklines.fods b/sc/qa/unit/data/fods/Sparklines.fods new file mode 100644 index 000000000000..b952471b5550 --- /dev/null +++ b/sc/qa/unit/data/fods/Sparklines.fods @@ -0,0 +1,590 @@ + + + + quikee2022-02-23T12:01:272023-07-30T09:09:00.836498837LibreOfficeDev/24.2.0.0.alpha0$Linux_X86_64 LibreOffice_project/392723e6d33455e375b469a6eabfc843cc311599PT3M20S116.0300 + + + 0 + 0 + 27824 + 4445 + + + view1 + + + 0 + 1 + 2 + 0 + 0 + 0 + 0 + 0 + 100 + 60 + true + false + false + false + false + + + Sheet1 + 1744 + 0 + 100 + 60 + false + true + true + false + true + -1 + true + 1 + true + true + false + false + false + 1000 + 1000 + 1 + 1 + true + false + false + false + false + + + + + true + true + true + 0 + true + true + false + true + false + -1 + true + true + 0 + false + false + true + true + false + 3 + false + + false + + false + 1000 + 1000 + 1 + 1 + true + false + false + true + true + true + true + 2 + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + - + + + + + - + + + + + - + + + + + : + + + + + + + : + + : + + + + + + + + + - + + + + + + + + + - + + + + + + + + - + + + + + + + + + - + + + + + + + + + + + - + + + + + + + + - + + + + + + + + + + + £ + + + + + + -£ + + + + + + £ + + - + + + + + + + + + + + + + + + + + - + + + + + + + + - + + + + + + + + + + + + + £ + + + + + + -£ + + + + + + £ + + - + + + + + + + + + + + + + + : + + + + + : + + : + + + + + : + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ??? + + + + + Page 1 + + + + + + + + ???(???) + + + 00/00/0000, 00:00:00 + + + + + + Page 1/ 99 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 4 + + + 2 + + + 7 + + + -2 + + + -5 + + + 4 + + + 3 + + + 6 + + + -2 + + + 0 + + + -3 + + + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sc/qa/unit/ucalc_sparkline.cxx b/sc/qa/unit/ucalc_sparkline.cxx index 2d46a81f5807..cb9047267b81 100644 --- a/sc/qa/unit/ucalc_sparkline.cxx +++ b/sc/qa/unit/ucalc_sparkline.cxx @@ -17,6 +17,9 @@ #include #include #include +#include +#include +#include using namespace css; @@ -481,16 +484,16 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testUndoRedoEditSparklineGroup) { sc::SparklineAttributes& rAttibutes = pSparklineGroup->getAttributes(); rAttibutes.setType(sc::SparklineType::Column); - rAttibutes.setColorSeries(COL_YELLOW); - rAttibutes.setColorAxis(COL_GREEN); + rAttibutes.setColorSeries(model::ComplexColor::RGB(COL_YELLOW)); + rAttibutes.setColorAxis(model::ComplexColor::RGB(COL_GREEN)); } m_pDoc->CreateSparkline(ScAddress(0, 6, 0), pSparklineGroup); sc::SparklineAttributes aNewAttributes; aNewAttributes.setType(sc::SparklineType::Stacked); - aNewAttributes.setColorSeries(COL_BLACK); - aNewAttributes.setColorAxis(COL_BLUE); + aNewAttributes.setColorSeries(model::ComplexColor::RGB(COL_BLACK)); + aNewAttributes.setColorAxis(model::ComplexColor::RGB(COL_BLUE)); sc::SparklineAttributes aInitialAttibutes(pSparklineGroup->getAttributes()); @@ -500,8 +503,10 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testUndoRedoEditSparklineGroup) CPPUNIT_ASSERT_EQUAL(false, aNewAttributes == pSparklineGroup->getAttributes()); CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column, pSparklineGroup->getAttributes().getType()); - CPPUNIT_ASSERT_EQUAL(COL_YELLOW, pSparklineGroup->getAttributes().getColorSeries()); - CPPUNIT_ASSERT_EQUAL(COL_GREEN, pSparklineGroup->getAttributes().getColorAxis()); + CPPUNIT_ASSERT_EQUAL(COL_YELLOW, + pSparklineGroup->getAttributes().getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_GREEN, + pSparklineGroup->getAttributes().getColorAxis().getFinalColor()); rDocFunc.ChangeSparklineGroupAttributes(pSparklineGroup, aNewAttributes); @@ -509,8 +514,9 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testUndoRedoEditSparklineGroup) CPPUNIT_ASSERT_EQUAL(true, aNewAttributes == pSparklineGroup->getAttributes()); CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Stacked, pSparklineGroup->getAttributes().getType()); - CPPUNIT_ASSERT_EQUAL(COL_BLACK, pSparklineGroup->getAttributes().getColorSeries()); - CPPUNIT_ASSERT_EQUAL(COL_BLUE, pSparklineGroup->getAttributes().getColorAxis()); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, + pSparklineGroup->getAttributes().getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_BLUE, pSparklineGroup->getAttributes().getColorAxis().getFinalColor()); m_pDoc->GetUndoManager()->Undo(); @@ -518,8 +524,10 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testUndoRedoEditSparklineGroup) CPPUNIT_ASSERT_EQUAL(false, aNewAttributes == pSparklineGroup->getAttributes()); CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Column, pSparklineGroup->getAttributes().getType()); - CPPUNIT_ASSERT_EQUAL(COL_YELLOW, pSparklineGroup->getAttributes().getColorSeries()); - CPPUNIT_ASSERT_EQUAL(COL_GREEN, pSparklineGroup->getAttributes().getColorAxis()); + CPPUNIT_ASSERT_EQUAL(COL_YELLOW, + pSparklineGroup->getAttributes().getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_GREEN, + pSparklineGroup->getAttributes().getColorAxis().getFinalColor()); m_pDoc->GetUndoManager()->Redo(); @@ -527,8 +535,9 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testUndoRedoEditSparklineGroup) CPPUNIT_ASSERT_EQUAL(true, aNewAttributes == pSparklineGroup->getAttributes()); CPPUNIT_ASSERT_EQUAL(sc::SparklineType::Stacked, pSparklineGroup->getAttributes().getType()); - CPPUNIT_ASSERT_EQUAL(COL_BLACK, pSparklineGroup->getAttributes().getColorSeries()); - CPPUNIT_ASSERT_EQUAL(COL_BLUE, pSparklineGroup->getAttributes().getColorAxis()); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, + pSparklineGroup->getAttributes().getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(COL_BLUE, pSparklineGroup->getAttributes().getColorAxis().getFinalColor()); m_pDoc->DeleteTab(0); } @@ -867,6 +876,93 @@ CPPUNIT_TEST_FIXTURE(SparklineTest, testSparklineList) } } +CPPUNIT_TEST_FIXTURE(SparklineTest, testSparklineThemeColorChange) +{ + m_pDoc->InitDrawLayer(); + m_pDoc->InsertTab(0, "Test"); + + // insert test data - A1:A6 + insertTestData(*m_pDoc); + + auto& rDocFunc = m_xDocShell->GetDocFunc(); + + ScDrawLayer* pDrawLayer = m_pDoc->GetDrawLayer(); + CPPUNIT_ASSERT(pDrawLayer); + const SdrPage* pPage(pDrawLayer->GetPage(0)); + CPPUNIT_ASSERT(pPage); + auto const& pTheme = pPage->getSdrPageProperties().GetTheme(); + CPPUNIT_ASSERT(pTheme); + + // Sparkline range + ScRange aDataRange(0, 0, 0, 3, 5, 0); //A1:D6 + ScRange aRange(0, 6, 0, 3, 6, 0); // A7:D7 + + { + auto pSparklineGroup = std::make_shared(); + sc::SparklineAttributes& rAttibutes = pSparklineGroup->getAttributes(); + + model::ComplexColor aSeriesComplexColor; + aSeriesComplexColor.setSchemeColor(model::ThemeColorType::Accent3); + aSeriesComplexColor.setFinalColor(pTheme->getColorSet()->resolveColor(aSeriesComplexColor)); + rAttibutes.setColorSeries(aSeriesComplexColor); + + model::ComplexColor aAxisComplexColor; + aAxisComplexColor.setSchemeColor(model::ThemeColorType::Accent1); + aAxisComplexColor.setFinalColor(pTheme->getColorSet()->resolveColor(aAxisComplexColor)); + rAttibutes.setColorAxis(aAxisComplexColor); + + CPPUNIT_ASSERT(rDocFunc.InsertSparklines(aDataRange, aRange, pSparklineGroup)); + } + + { + CPPUNIT_ASSERT_EQUAL(true, m_pDoc->HasSparkline(ScAddress(0, 6, 0))); // A7 + auto pGroup = m_pDoc->GetSparkline(ScAddress(0, 6, 0))->getSparklineGroup(); + CPPUNIT_ASSERT(pGroup); + sc::SparklineAttributes& rAttibutes = pGroup->getAttributes(); + CPPUNIT_ASSERT_EQUAL(Color(0xa33e03), rAttibutes.getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x18a303), rAttibutes.getColorAxis().getFinalColor()); + } + + { + auto pColorSet = std::make_shared("TestColorScheme"); + pColorSet->add(model::ThemeColorType::Dark1, 0x000000); + pColorSet->add(model::ThemeColorType::Light1, 0x111111); + pColorSet->add(model::ThemeColorType::Dark2, 0x222222); + pColorSet->add(model::ThemeColorType::Light2, 0x333333); + pColorSet->add(model::ThemeColorType::Accent1, 0x444444); + pColorSet->add(model::ThemeColorType::Accent2, 0x555555); + pColorSet->add(model::ThemeColorType::Accent3, 0x666666); + pColorSet->add(model::ThemeColorType::Accent4, 0x777777); + pColorSet->add(model::ThemeColorType::Accent5, 0x888888); + pColorSet->add(model::ThemeColorType::Accent6, 0x999999); + pColorSet->add(model::ThemeColorType::Hyperlink, 0xaaaaaa); + pColorSet->add(model::ThemeColorType::FollowedHyperlink, 0xbbbbbb); + + sc::ThemeColorChanger aChanger(*m_xDocShell); + aChanger.apply(pColorSet); + } + + { + CPPUNIT_ASSERT_EQUAL(true, m_pDoc->HasSparkline(ScAddress(0, 6, 0))); // A7 + auto pGroup = m_pDoc->GetSparkline(ScAddress(0, 6, 0))->getSparklineGroup(); + CPPUNIT_ASSERT(pGroup); + sc::SparklineAttributes& rAttibutes = pGroup->getAttributes(); + CPPUNIT_ASSERT_EQUAL(Color(0x666666), rAttibutes.getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x444444), rAttibutes.getColorAxis().getFinalColor()); + } + + m_pDoc->GetUndoManager()->Undo(); + + { + CPPUNIT_ASSERT_EQUAL(true, m_pDoc->HasSparkline(ScAddress(0, 6, 0))); // A7 + auto pGroup = m_pDoc->GetSparkline(ScAddress(0, 6, 0))->getSparklineGroup(); + CPPUNIT_ASSERT(pGroup); + sc::SparklineAttributes& rAttibutes = pGroup->getAttributes(); + CPPUNIT_ASSERT_EQUAL(Color(0xa33e03), rAttibutes.getColorSeries().getFinalColor()); + CPPUNIT_ASSERT_EQUAL(Color(0x18a303), rAttibutes.getColorAxis().getFinalColor()); + } +} + CPPUNIT_PLUGIN_IMPLEMENT(); /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/filter/excel/export/ExportTools.cxx b/sc/source/filter/excel/export/ExportTools.cxx new file mode 100644 index 000000000000..a132dd148408 --- /dev/null +++ b/sc/source/filter/excel/export/ExportTools.cxx @@ -0,0 +1,45 @@ +/* -*- 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 +#include +#include +#include +#include + +namespace oox::xls +{ +void writeComplexColor(sax_fastparser::FSHelperPtr& pFS, sal_Int32 nElement, + model::ComplexColor const& rComplexColor, Color const& rColor) +{ + if (rComplexColor.isValidSchemeType()) + { + sal_Int32 nTheme + = oox::convertThemeColorTypeToExcelThemeNumber(rComplexColor.getSchemeType()); + double fTintShade = oox::convertColorTransformsToTintOrShade(rComplexColor); + pFS->singleElement(nElement, XML_theme, OString::number(nTheme), XML_tint, + sax_fastparser::UseIf(OString::number(fTintShade), fTintShade != 0.0)); + } + else if (rColor != COL_TRANSPARENT) + { + pFS->singleElement(nElement, XML_rgb, XclXmlUtils::ToOString(rColor)); + } +} + +void writeComplexColor(sax_fastparser::FSHelperPtr& pFS, sal_Int32 nElement, + model::ComplexColor const& rComplexColor) +{ + if (rComplexColor.isValidSchemeType() || rComplexColor.getType() == model::ColorType::RGB) + { + writeComplexColor(pFS, nElement, rComplexColor, rComplexColor.getFinalColor()); + } +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/filter/excel/export/SparklineExt.cxx b/sc/source/filter/excel/export/SparklineExt.cxx index 487698e19ba1..fb5c98148323 100644 --- a/sc/source/filter/excel/export/SparklineExt.cxx +++ b/sc/source/filter/excel/export/SparklineExt.cxx @@ -14,6 +14,7 @@ #include #include #include +#include using namespace oox; @@ -126,50 +127,21 @@ void SparklineExt::addSparklineGroupColors(XclExpXmlStream& rStream, { sax_fastparser::FSHelperPtr& rWorksheet = rStream.GetCurrentStream(); - rWorksheet->singleElementNS(XML_x14, XML_colorSeries, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorSeries())); - - if (rAttributes.getColorNegative() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorNegative, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorNegative())); - } - - if (rAttributes.getColorAxis() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorAxis, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorAxis())); - } - - if (rAttributes.getColorMarkers() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorMarkers, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorMarkers())); - } - - if (rAttributes.getColorFirst() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorFirst, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorFirst())); - } - - if (rAttributes.getColorLast() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorLast, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorLast())); - } - - if (rAttributes.getColorHigh() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorHigh, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorHigh())); - } - - if (rAttributes.getColorLow() != COL_TRANSPARENT) - { - rWorksheet->singleElementNS(XML_x14, XML_colorLow, XML_rgb, - XclXmlUtils::ToOString(rAttributes.getColorLow())); - } + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorSeries), + rAttributes.getColorSeries()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorNegative), + rAttributes.getColorNegative()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorAxis), + rAttributes.getColorAxis()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorMarkers), + rAttributes.getColorMarkers()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorFirst), + rAttributes.getColorFirst()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorLast), + rAttributes.getColorLast()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorHigh), + rAttributes.getColorHigh()); + oox::xls::writeComplexColor(rWorksheet, FSNS(XML_x14, XML_colorLow), rAttributes.getColorLow()); } void SparklineExt::addSparklineGroup(XclExpXmlStream& rStream, sc::SparklineGroup& rSparklineGroup, diff --git a/sc/source/filter/excel/xestyle.cxx b/sc/source/filter/excel/xestyle.cxx index 2937c153fb21..42d3f1944bc7 100644 --- a/sc/source/filter/excel/xestyle.cxx +++ b/sc/source/filter/excel/xestyle.cxx @@ -53,7 +53,6 @@ #include #include -#include #include #include #include diff --git a/sc/source/filter/inc/export/ExportTools.hxx b/sc/source/filter/inc/export/ExportTools.hxx index e5ea27561f39..369728f06e10 100644 --- a/sc/source/filter/inc/export/ExportTools.hxx +++ b/sc/source/filter/inc/export/ExportTools.hxx @@ -11,28 +11,13 @@ #include #include -#include -#include -#include namespace oox::xls { void writeComplexColor(sax_fastparser::FSHelperPtr& pFS, sal_Int32 nElement, - model::ComplexColor const& rComplexColor, Color const& rColor) -{ - if (rComplexColor.isValidSchemeType()) - { - sal_Int32 nTheme - = oox::convertThemeColorTypeToExcelThemeNumber(rComplexColor.getSchemeType()); - double fTintShade = oox::convertColorTransformsToTintOrShade(rComplexColor); - pFS->singleElement(nElement, XML_theme, OString::number(nTheme), XML_tint, - sax_fastparser::UseIf(OString::number(fTintShade), fTintShade != 0.0)); - } - else if (rColor != COL_TRANSPARENT) - { - pFS->singleElement(nElement, XML_rgb, XclXmlUtils::ToOString(rColor)); - } -} + model::ComplexColor const& rComplexColor, Color const& rColor); +void writeComplexColor(sax_fastparser::FSHelperPtr& pFS, sal_Int32 nElement, + model::ComplexColor const& rComplexColor); } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/filter/oox/SparklineFragment.cxx b/sc/source/filter/oox/SparklineFragment.cxx index 38af462c5b3a..afb3f64285ae 100644 --- a/sc/source/filter/oox/SparklineFragment.cxx +++ b/sc/source/filter/oox/SparklineFragment.cxx @@ -17,6 +17,7 @@ #include #include #include +#include using ::oox::core::ContextHandlerRef; @@ -56,34 +57,46 @@ namespace return ::Color(); } +model::ComplexColor fillComplexColor(const AttributeList& rAttribs, ThemeBuffer const& rThemeBuffer, + const GraphicHelper& rGraphicHelper) +{ + XlsColor aColor; + aColor.importColor(rAttribs); + model::ComplexColor aComplexColor = aColor.createComplexColor(rGraphicHelper, -1); + ::Color aFinalColor = getColor(rAttribs, rThemeBuffer); + aComplexColor.setFinalColor(aFinalColor); + return aComplexColor; +} + void addColorsToSparklineAttributes(sc::SparklineAttributes& rAttributes, sal_Int32 nElement, - const AttributeList& rAttribs, ThemeBuffer& rThemeBuffer) + const AttributeList& rAttribs, ThemeBuffer& rThemeBuffer, + const GraphicHelper& rHelper) { switch (nElement) { case XLS14_TOKEN(colorSeries): - rAttributes.setColorSeries(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorSeries(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorNegative): - rAttributes.setColorNegative(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorNegative(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorAxis): - rAttributes.setColorAxis(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorAxis(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorMarkers): - rAttributes.setColorMarkers(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorMarkers(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorFirst): - rAttributes.setColorFirst(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorFirst(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorLast): - rAttributes.setColorLast(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorLast(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorHigh): - rAttributes.setColorHigh(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorHigh(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; case XLS14_TOKEN(colorLow): - rAttributes.setColorLow(getColor(rAttribs, rThemeBuffer)); + rAttributes.setColorLow(fillComplexColor(rAttribs, rThemeBuffer, rHelper)); break; default: break; @@ -172,6 +185,7 @@ ContextHandlerRef SparklineGroupsContext::onCreateContext(sal_Int32 nElement, { auto& rLastGroup = m_aSparklineGroups.emplace_back(); auto& rSparklineAttributes = rLastGroup.getSparklineGroup()->getAttributes(); + rSparklineAttributes.resetColors(); addAttributesToSparklineAttributes(rSparklineAttributes, rAttribs); OUString sGUID = rAttribs.getString(XR2_TOKEN(uid), OUString()); tools::Guid aGuid(OUStringToOString(sGUID, RTL_TEXTENCODING_ASCII_US)); @@ -189,7 +203,8 @@ ContextHandlerRef SparklineGroupsContext::onCreateContext(sal_Int32 nElement, { auto& rLastGroup = m_aSparklineGroups.back(); auto& rSparklineAttributes = rLastGroup.getSparklineGroup()->getAttributes(); - addColorsToSparklineAttributes(rSparklineAttributes, nElement, rAttribs, getTheme()); + addColorsToSparklineAttributes(rSparklineAttributes, nElement, rAttribs, getTheme(), + getBaseFilter().getGraphicHelper()); return this; } case XLS14_TOKEN(sparklines): diff --git a/sc/source/filter/xml/SparklineGroupsExport.cxx b/sc/source/filter/xml/SparklineGroupsExport.cxx index 077d43beab60..fd577e5c6c10 100644 --- a/sc/source/filter/xml/SparklineGroupsExport.cxx +++ b/sc/source/filter/xml/SparklineGroupsExport.cxx @@ -21,6 +21,7 @@ #include #include #include +#include using namespace css; using namespace xmloff::token; @@ -33,14 +34,24 @@ SparklineGroupsExport::SparklineGroupsExport(ScXMLExport& rExport, SCTAB nTable) { } -void SparklineGroupsExport::insertColor(Color aColor, XMLTokenEnum eToken) +void SparklineGroupsExport::insertColor(model::ComplexColor const& rComplexColor, + XMLTokenEnum eToken) { + if (rComplexColor.getType() == model::ColorType::Unused) + return; + OUStringBuffer aStringBuffer; - if (aColor != COL_TRANSPARENT) - { - sax::Converter::convertColor(aStringBuffer, aColor); - m_rExport.AddAttribute(XML_NAMESPACE_CALC_EXT, eToken, aStringBuffer.makeStringAndClear()); - } + sax::Converter::convertColor(aStringBuffer, rComplexColor.getFinalColor()); + m_rExport.AddAttribute(XML_NAMESPACE_CALC_EXT, eToken, aStringBuffer.makeStringAndClear()); +} + +void SparklineGroupsExport::insertComplexColor(model::ComplexColor const& rComplexColor, + XMLTokenEnum eToken) +{ + if (!rComplexColor.isValidSchemeType()) + return; + XMLComplexColorExport aComplexColorExport(m_rExport); + aComplexColorExport.exportComplexColor(rComplexColor, XML_NAMESPACE_CALC_EXT, eToken); } void SparklineGroupsExport::insertBool(bool bValue, XMLTokenEnum eToken) @@ -182,6 +193,15 @@ void SparklineGroupsExport::addSparklineGroup( SvXMLElementExport aElementSparklineGroup(m_rExport, XML_NAMESPACE_CALC_EXT, XML_SPARKLINE_GROUP, true, true); + insertComplexColor(rAttributes.getColorSeries(), XML_SPARKLINE_SERIES_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorNegative(), XML_SPARKLINE_NEGATIVE_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorAxis(), XML_SPARKLINE_AXIS_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorMarkers(), XML_SPARKLINE_MARKERS_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorFirst(), XML_SPARKLINE_FIRST_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorLast(), XML_SPARKLINE_LAST_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorHigh(), XML_SPARKLINE_HIGH_COMPLEX_COLOR); + insertComplexColor(rAttributes.getColorLow(), XML_SPARKLINE_LOW_COMPLEX_COLOR); + SvXMLElementExport aElementSparklines(m_rExport, XML_NAMESPACE_CALC_EXT, XML_SPARKLINES, true, true); diff --git a/sc/source/filter/xml/SparklineGroupsExport.hxx b/sc/source/filter/xml/SparklineGroupsExport.hxx index 9359413735dc..a2ed4a8ef853 100644 --- a/sc/source/filter/xml/SparklineGroupsExport.hxx +++ b/sc/source/filter/xml/SparklineGroupsExport.hxx @@ -19,6 +19,10 @@ #include class ScXMLExport; +namespace model +{ +class ComplexColor; +} namespace sc { @@ -33,7 +37,10 @@ class SparklineGroupsExport std::vector> const& rSparklines); void addSparklineAttributes(Sparkline const& rSparkline); - void insertColor(Color aColor, xmloff::token::XMLTokenEnum eToken); + void insertColor(model::ComplexColor const& rComplexColor, xmloff::token::XMLTokenEnum eToken); + void insertComplexColor(model::ComplexColor const& rComplexColor, + xmloff::token::XMLTokenEnum eToken); + void insertBool(bool bValue, xmloff::token::XMLTokenEnum eToken); public: diff --git a/sc/source/filter/xml/SparklineGroupsImportContext.cxx b/sc/source/filter/xml/SparklineGroupsImportContext.cxx index b1164e3ef993..59c24cdd45a4 100644 --- a/sc/source/filter/xml/SparklineGroupsImportContext.cxx +++ b/sc/source/filter/xml/SparklineGroupsImportContext.cxx @@ -13,6 +13,7 @@ #include #include #include +#include #include #include @@ -181,58 +182,50 @@ void SparklineGroupsImportContext::fillSparklineGroupAttributes( } case XML_ELEMENT(CALC_EXT, XML_COLOR_SERIES): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorSeries(aColor); + maSeriesColor = COL_TRANSPARENT; + sax::Converter::convertColor(maSeriesColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_NEGATIVE): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorNegative(aColor); + maNegativeColor = COL_TRANSPARENT; + sax::Converter::convertColor(maNegativeColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_AXIS): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorAxis(aColor); + maAxisColor = COL_TRANSPARENT; + sax::Converter::convertColor(maAxisColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_MARKERS): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorMarkers(aColor); + maMarkersColor = COL_TRANSPARENT; + sax::Converter::convertColor(maMarkersColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_FIRST): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorFirst(aColor); + maFirstColor = COL_TRANSPARENT; + sax::Converter::convertColor(maFirstColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_LAST): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorLast(aColor); + maLastColor = COL_TRANSPARENT; + sax::Converter::convertColor(maLastColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_HIGH): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorHigh(aColor); + maHighColor = COL_TRANSPARENT; + sax::Converter::convertColor(maHighColor, rIter.toView()); break; } case XML_ELEMENT(CALC_EXT, XML_COLOR_LOW): { - Color aColor; - sax::Converter::convertColor(aColor, rIter.toView()); - rAttributes.setColorLow(aColor); + maLowColor = COL_TRANSPARENT; + sax::Converter::convertColor(maLowColor, rIter.toView()); break; } default: @@ -281,23 +274,72 @@ uno::Reference case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_GROUP): { m_pCurrentSparklineGroup = std::make_shared(); + maAxisComplexColor = model::ComplexColor(); + maFirstComplexColor = model::ComplexColor(); + maLastComplexColor = model::ComplexColor(); + maHighComplexColor = model::ComplexColor(); + maLowComplexColor = model::ComplexColor(); + maSeriesComplexColor = model::ComplexColor(); + maNegativeComplexColor = model::ComplexColor(); + maMarkersComplexColor = model::ComplexColor(); + fillSparklineGroupID(xAttrList); fillSparklineGroupAttributes(xAttrList); pContext = this; - break; } + break; case XML_ELEMENT(CALC_EXT, XML_SPARKLINES): { pContext = this; - break; } + break; case XML_ELEMENT(CALC_EXT, XML_SPARKLINE): { SparklineImportData& rImportData = m_aCurrentSparklineDataList.emplace_back(); fillSparklineAttributes(rImportData, xAttrList); pContext = this; - break; } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_AXIS_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maAxisComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_FIRST_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maFirstComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_LAST_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maLastComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_HIGH_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maHighComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_LOW_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maLowComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_SERIES_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maSeriesComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_NEGATIVE_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maNegativeComplexColor, xAttrList); + } + break; + case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_MARKERS_COMPLEX_COLOR): + { + pContext = new XMLComplexColorContext(GetImport(), maMarkersComplexColor, xAttrList); + } + break; } return pContext; @@ -314,12 +356,42 @@ void SparklineGroupsImportContext::insertSparklines() } } +namespace +{ +model::ComplexColor combineComplexColorAndColor(model::ComplexColor& rComplexColor, Color aColor) +{ + if (rComplexColor.getType() != model::ColorType::Unused) + rComplexColor.setFinalColor(aColor); + else if (aColor != COL_TRANSPARENT) + rComplexColor = model::ComplexColor::RGB(aColor); + return rComplexColor; +} +} // end anonymous namespace + void SAL_CALL SparklineGroupsImportContext::endFastElement(sal_Int32 nElement) { switch (nElement) { case XML_ELEMENT(CALC_EXT, XML_SPARKLINE_GROUP): { + sc::SparklineAttributes& rAttributes = m_pCurrentSparklineGroup->getAttributes(); + { + rAttributes.setColorAxis( + combineComplexColorAndColor(maAxisComplexColor, maAxisColor)); + rAttributes.setColorFirst( + combineComplexColorAndColor(maFirstComplexColor, maFirstColor)); + rAttributes.setColorLast( + combineComplexColorAndColor(maLastComplexColor, maLastColor)); + rAttributes.setColorHigh( + combineComplexColorAndColor(maHighComplexColor, maHighColor)); + rAttributes.setColorLow(combineComplexColorAndColor(maLowComplexColor, maLowColor)); + rAttributes.setColorSeries( + combineComplexColorAndColor(maSeriesComplexColor, maSeriesColor)); + rAttributes.setColorNegative( + combineComplexColorAndColor(maNegativeComplexColor, maNegativeColor)); + rAttributes.setColorMarkers( + combineComplexColorAndColor(maMarkersComplexColor, maMarkersColor)); + } insertSparklines(); m_pCurrentSparklineGroup.reset(); m_aCurrentSparklineDataList.clear(); diff --git a/sc/source/filter/xml/SparklineGroupsImportContext.hxx b/sc/source/filter/xml/SparklineGroupsImportContext.hxx index b8161c96506d..197eca9ca09a 100644 --- a/sc/source/filter/xml/SparklineGroupsImportContext.hxx +++ b/sc/source/filter/xml/SparklineGroupsImportContext.hxx @@ -14,6 +14,7 @@ #include "xmlimprt.hxx" #include #include +#include namespace sax_fastparser { @@ -38,6 +39,24 @@ private: std::shared_ptr m_pCurrentSparklineGroup; std::vector m_aCurrentSparklineDataList; + model::ComplexColor maAxisComplexColor; + model::ComplexColor maFirstComplexColor; + model::ComplexColor maLastComplexColor; + model::ComplexColor maHighComplexColor; + model::ComplexColor maLowComplexColor; + model::ComplexColor maSeriesComplexColor; + model::ComplexColor maNegativeComplexColor; + model::ComplexColor maMarkersComplexColor; + + Color maAxisColor = COL_TRANSPARENT; + Color maFirstColor = COL_TRANSPARENT; + Color maLastColor = COL_TRANSPARENT; + Color maHighColor = COL_TRANSPARENT; + Color maLowColor = COL_TRANSPARENT; + Color maSeriesColor = COL_TRANSPARENT; + Color maNegativeColor = COL_TRANSPARENT; + Color maMarkersColor = COL_TRANSPARENT; + void fillSparklineGroupID(css::uno::Reference const& xAttrList); void fillSparklineGroupAttributes( diff --git a/sc/source/filter/xml/xmlstyli.cxx b/sc/source/filter/xml/xmlstyli.cxx index b938e4e5d174..3d7d86488425 100644 --- a/sc/source/filter/xml/xmlstyli.cxx +++ b/sc/source/filter/xml/xmlstyli.cxx @@ -307,7 +307,7 @@ css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTableCellPropsConte { case CTF_COMPLEX_COLOR: { - return new XMLComplexColorContext(GetImport(), nElement, xAttrList, rProperty, rProperties); + return new XMLPropertyComplexColorContext(GetImport(), nElement, xAttrList, rProperty, rProperties); } break; case CTF_SC_HYPERLINK: diff --git a/sc/source/ui/dialogs/SparklineDialog.cxx b/sc/source/ui/dialogs/SparklineDialog.cxx index f27e0eb4a4a5..2490ae41da2f 100644 --- a/sc/source/ui/dialogs/SparklineDialog.cxx +++ b/sc/source/ui/dialogs/SparklineDialog.cxx @@ -192,13 +192,13 @@ void SparklineDialog::setupValues() 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()); + mxColorSeries->SelectEntry(maAttributes.getColorSeries().getFinalColor()); + mxColorNegative->SelectEntry(maAttributes.getColorNegative().getFinalColor()); + mxColorMarker->SelectEntry(maAttributes.getColorMarkers().getFinalColor()); + mxColorHigh->SelectEntry(maAttributes.getColorHigh().getFinalColor()); + mxColorLow->SelectEntry(maAttributes.getColorLow().getFinalColor()); + mxColorFirst->SelectEntry(maAttributes.getColorFirst().getFinalColor()); + mxColorLast->SelectEntry(maAttributes.getColorLast().getFinalColor()); mxCheckButtonNegative->set_active(maAttributes.isNegative()); mxCheckButtonMarker->set_active(maAttributes.isMarkers()); @@ -526,13 +526,13 @@ bool SparklineDialog::checkValidInputOutput() 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()); + maAttributes.setColorSeries(mxColorSeries->GetSelectedEntry().getComplexColor()); + maAttributes.setColorNegative(mxColorNegative->GetSelectedEntry().getComplexColor()); + maAttributes.setColorMarkers(mxColorMarker->GetSelectedEntry().getComplexColor()); + maAttributes.setColorHigh(mxColorHigh->GetSelectedEntry().getComplexColor()); + maAttributes.setColorLow(mxColorLow->GetSelectedEntry().getComplexColor()); + maAttributes.setColorFirst(mxColorFirst->GetSelectedEntry().getComplexColor()); + maAttributes.setColorLast(mxColorLast->GetSelectedEntry().getComplexColor()); auto& rDocFunc = mrViewData.GetDocShell()->GetDocFunc(); diff --git a/sc/source/ui/inc/SparklineRenderer.hxx b/sc/source/ui/inc/SparklineRenderer.hxx index 616d667ecb48..23d62d6d6ae6 100644 --- a/sc/source/ui/inc/SparklineRenderer.hxx +++ b/sc/source/ui/inc/SparklineRenderer.hxx @@ -296,27 +296,27 @@ private: if (rAttributes.isFirst() && nValueIndex == rSparklineValues.mnFirstIndex) { - createMarker(aMarkers, x, y, rAttributes.getColorFirst()); + createMarker(aMarkers, x, y, rAttributes.getColorFirst().getFinalColor()); } else if (rAttributes.isLast() && nValueIndex == rSparklineValues.mnLastIndex) { - createMarker(aMarkers, x, y, rAttributes.getColorLast()); + createMarker(aMarkers, x, y, rAttributes.getColorLast().getFinalColor()); } else if (rAttributes.isHigh() && nValue == rSparklineValues.mfMaximum) { - createMarker(aMarkers, x, y, rAttributes.getColorHigh()); + createMarker(aMarkers, x, y, rAttributes.getColorHigh().getFinalColor()); } else if (rAttributes.isLow() && nValue == rSparklineValues.mfMinimum) { - createMarker(aMarkers, x, y, rAttributes.getColorLow()); + createMarker(aMarkers, x, y, rAttributes.getColorLow().getFinalColor()); } else if (rAttributes.isNegative() && nValue < 0.0) { - createMarker(aMarkers, x, y, rAttributes.getColorNegative()); + createMarker(aMarkers, x, y, rAttributes.getColorNegative().getFinalColor()); } else if (rAttributes.isMarkers()) { - createMarker(aMarkers, x, y, rAttributes.getColorMarkers()); + createMarker(aMarkers, x, y, rAttributes.getColorMarkers().getFinalColor()); } } @@ -341,12 +341,12 @@ private: aAxisPolygon.append({ x1, y }); aAxisPolygon.append({ x2, y }); - rRenderContext.SetLineColor(rAttributes.getColorAxis()); + rRenderContext.SetLineColor(rAttributes.getColorAxis().getFinalColor()); rRenderContext.DrawPolyLineDirect(aMatrix, aAxisPolygon, 0.2 * mfScaleX); } } - rRenderContext.SetLineColor(rAttributes.getColorSeries()); + rRenderContext.SetLineColor(rAttributes.getColorSeries().getFinalColor()); for (auto& rPolygon : aPolygons) { @@ -371,33 +371,33 @@ private: { if (rAttributes.isFirst() && nValueIndex == rSparklineValues.mnFirstIndex) { - rRenderContext.SetLineColor(rAttributes.getColorFirst()); - rRenderContext.SetFillColor(rAttributes.getColorFirst()); + rRenderContext.SetLineColor(rAttributes.getColorFirst().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorFirst().getFinalColor()); } else if (rAttributes.isLast() && nValueIndex == rSparklineValues.mnLastIndex) { - rRenderContext.SetLineColor(rAttributes.getColorLast()); - rRenderContext.SetFillColor(rAttributes.getColorLast()); + rRenderContext.SetLineColor(rAttributes.getColorLast().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorLast().getFinalColor()); } else if (rAttributes.isHigh() && nValue == rSparklineValues.mfMaximum) { - rRenderContext.SetLineColor(rAttributes.getColorHigh()); - rRenderContext.SetFillColor(rAttributes.getColorHigh()); + rRenderContext.SetLineColor(rAttributes.getColorHigh().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorHigh().getFinalColor()); } else if (rAttributes.isLow() && nValue == rSparklineValues.mfMinimum) { - rRenderContext.SetLineColor(rAttributes.getColorLow()); - rRenderContext.SetFillColor(rAttributes.getColorLow()); + rRenderContext.SetLineColor(rAttributes.getColorLow().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorLow().getFinalColor()); } else if (rAttributes.isNegative() && nValue < 0.0) { - rRenderContext.SetLineColor(rAttributes.getColorNegative()); - rRenderContext.SetFillColor(rAttributes.getColorNegative()); + rRenderContext.SetLineColor(rAttributes.getColorNegative().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorNegative().getFinalColor()); } else { - rRenderContext.SetLineColor(rAttributes.getColorSeries()); - rRenderContext.SetFillColor(rAttributes.getColorSeries()); + rRenderContext.SetLineColor(rAttributes.getColorSeries().getFinalColor()); + rRenderContext.SetFillColor(rAttributes.getColorSeries().getFinalColor()); } } @@ -441,7 +441,7 @@ private: aAxisPolygon.append({ x1, nZeroPosition }); aAxisPolygon.append({ x2, nZeroPosition }); - rRenderContext.SetLineColor(rAttributes.getColorAxis()); + rRenderContext.SetLineColor(rAttributes.getColorAxis().getFinalColor()); rRenderContext.DrawPolyLineDirect(aMatrix, aAxisPolygon, 0.2 * mfScaleX); } } diff --git a/sc/source/ui/sparklines/SparklineAttributes.cxx b/sc/source/ui/sparklines/SparklineAttributes.cxx index 20b8bf6feee6..080c38f5ee64 100644 --- a/sc/source/ui/sparklines/SparklineAttributes.cxx +++ b/sc/source/ui/sparklines/SparklineAttributes.cxx @@ -16,14 +16,14 @@ 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; + model::ComplexColor m_aColorSeries; + model::ComplexColor m_aColorNegative; + model::ComplexColor m_aColorAxis; + model::ComplexColor m_aColorMarkers; + model::ComplexColor m_aColorFirst; + model::ComplexColor m_aColorLast; + model::ComplexColor m_aColorHigh; + model::ComplexColor m_aColorLow; AxisType m_eMinAxisType; AxisType m_eMaxAxisType; @@ -48,19 +48,18 @@ public: std::optional m_aManualMax; std::optional m_aManualMin; - - static constexpr ::Color COL_STANDARD_RED = 0xff0000; - static constexpr ::Color COL_STANDARD_BLUE = 0x2a6099; + static constexpr Color COL_STANDARD_RED = 0xff0000; + static constexpr Color COL_STANDARD_BLUE = 0x2a6099; Implementation() - : m_aColorSeries(COL_STANDARD_BLUE) - , m_aColorNegative(COL_STANDARD_RED) - , m_aColorAxis(COL_STANDARD_RED) - , m_aColorMarkers(COL_STANDARD_RED) - , m_aColorFirst(COL_STANDARD_RED) - , m_aColorLast(COL_STANDARD_RED) - , m_aColorHigh(COL_STANDARD_RED) - , m_aColorLow(COL_STANDARD_RED) + : m_aColorSeries(model::ComplexColor::RGB(COL_STANDARD_BLUE)) + , m_aColorNegative(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorAxis(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorMarkers(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorFirst(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorLast(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorHigh(model::ComplexColor::RGB(COL_STANDARD_RED)) + , m_aColorLow(model::ComplexColor::RGB(COL_STANDARD_RED)) , m_eMinAxisType(AxisType::Individual) , m_eMaxAxisType(AxisType::Individual) , m_fLineWeight(0.75) @@ -146,41 +145,92 @@ 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) +void SparklineAttributes::resetColors() { - m_aImplementation->m_aColorSeries = aColor; + m_aImplementation->m_aColorSeries = model::ComplexColor(); + m_aImplementation->m_aColorNegative = model::ComplexColor(); + m_aImplementation->m_aColorAxis = model::ComplexColor(); + m_aImplementation->m_aColorMarkers = model::ComplexColor(); + m_aImplementation->m_aColorFirst = model::ComplexColor(); + m_aImplementation->m_aColorLast = model::ComplexColor(); + m_aImplementation->m_aColorHigh = model::ComplexColor(); + m_aImplementation->m_aColorLow = model::ComplexColor(); } -Color SparklineAttributes::getColorNegative() const { return m_aImplementation->m_aColorNegative; } - -void SparklineAttributes::setColorNegative(Color aColor) +model::ComplexColor SparklineAttributes::getColorSeries() const { - m_aImplementation->m_aColorNegative = aColor; + return m_aImplementation->m_aColorSeries; } -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) +void SparklineAttributes::setColorSeries(model::ComplexColor const& rColor) { - m_aImplementation->m_aColorMarkers = aColor; + m_aImplementation->m_aColorSeries = rColor; } -Color SparklineAttributes::getColorFirst() const { return m_aImplementation->m_aColorFirst; } -void SparklineAttributes::setColorFirst(Color aColor) { m_aImplementation->m_aColorFirst = aColor; } +model::ComplexColor SparklineAttributes::getColorNegative() const +{ + return m_aImplementation->m_aColorNegative; +} -Color SparklineAttributes::getColorLast() const { return m_aImplementation->m_aColorLast; } -void SparklineAttributes::setColorLast(Color aColor) { m_aImplementation->m_aColorLast = aColor; } +void SparklineAttributes::setColorNegative(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorNegative = rColor; +} -Color SparklineAttributes::getColorHigh() const { return m_aImplementation->m_aColorHigh; } -void SparklineAttributes::setColorHigh(Color aColor) { m_aImplementation->m_aColorHigh = aColor; } +model::ComplexColor SparklineAttributes::getColorAxis() const +{ + return m_aImplementation->m_aColorAxis; +} -Color SparklineAttributes::getColorLow() const { return m_aImplementation->m_aColorLow; } -void SparklineAttributes::setColorLow(Color aColor) { m_aImplementation->m_aColorLow = aColor; } +void SparklineAttributes::setColorAxis(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorAxis = rColor; +} + +model::ComplexColor SparklineAttributes::getColorMarkers() const +{ + return m_aImplementation->m_aColorMarkers; +} +void SparklineAttributes::setColorMarkers(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorMarkers = rColor; +} + +model::ComplexColor SparklineAttributes::getColorFirst() const +{ + return m_aImplementation->m_aColorFirst; +} +void SparklineAttributes::setColorFirst(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorFirst = rColor; +} + +model::ComplexColor SparklineAttributes::getColorLast() const +{ + return m_aImplementation->m_aColorLast; +} +void SparklineAttributes::setColorLast(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorLast = rColor; +} + +model::ComplexColor SparklineAttributes::getColorHigh() const +{ + return m_aImplementation->m_aColorHigh; +} +void SparklineAttributes::setColorHigh(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorHigh = rColor; +} + +model::ComplexColor SparklineAttributes::getColorLow() const +{ + return m_aImplementation->m_aColorLow; +} +void SparklineAttributes::setColorLow(model::ComplexColor const& rColor) +{ + m_aImplementation->m_aColorLow = rColor; +} AxisType SparklineAttributes::getMinAxisType() const { return m_aImplementation->m_eMinAxisType; } void SparklineAttributes::setMinAxisType(AxisType eAxisType) diff --git a/sc/source/ui/theme/ThemeColorChanger.cxx b/sc/source/ui/theme/ThemeColorChanger.cxx index 66683adbd682..be003b539636 100644 --- a/sc/source/ui/theme/ThemeColorChanger.cxx +++ b/sc/source/ui/theme/ThemeColorChanger.cxx @@ -29,9 +29,12 @@ #include #include #include +#include #include #include #include +#include +#include #include @@ -245,6 +248,52 @@ bool changeSheets(ScDocShell& rDocShell, ScDrawLayer* pModel, return bChanged; } +model::ComplexColor modifyComplexColor(model::ComplexColor const& rComplexColor, + std::shared_ptr const& pColorSet) +{ + model::ComplexColor aComplexColor(rComplexColor); + + if (aComplexColor.isValidSchemeType()) + { + Color aColor = pColorSet->getColor(aComplexColor.meSchemeType); + aColor = aComplexColor.applyTransformations(aColor); + aComplexColor.setFinalColor(aColor); + } + return aComplexColor; +} + +void changeSparklines(ScDocShell& rDocShell, std::shared_ptr const& pColorSet) +{ + ScDocument& rDocument = rDocShell.GetDocument(); + auto& rDocFunc = rDocShell.GetDocFunc(); + for (SCTAB nTab = 0; nTab < rDocument.GetTableCount(); ++nTab) + { + auto* pSparklineList = rDocument.GetSparklineList(nTab); + if (pSparklineList && !pSparklineList->getSparklineGroups().empty()) + { + auto const& rSparklineGroups = pSparklineList->getSparklineGroups(); + for (auto const& rSparklineGroup : rSparklineGroups) + { + auto aAttributes = rSparklineGroup->getAttributes(); + + aAttributes.setColorAxis(modifyComplexColor(aAttributes.getColorAxis(), pColorSet)); + aAttributes.setColorSeries( + modifyComplexColor(aAttributes.getColorSeries(), pColorSet)); + aAttributes.setColorNegative( + modifyComplexColor(aAttributes.getColorNegative(), pColorSet)); + aAttributes.setColorMarkers( + modifyComplexColor(aAttributes.getColorMarkers(), pColorSet)); + aAttributes.setColorHigh(modifyComplexColor(aAttributes.getColorHigh(), pColorSet)); + aAttributes.setColorLow(modifyComplexColor(aAttributes.getColorLow(), pColorSet)); + aAttributes.setColorFirst( + modifyComplexColor(aAttributes.getColorFirst(), pColorSet)); + aAttributes.setColorLast(modifyComplexColor(aAttributes.getColorLast(), pColorSet)); + rDocFunc.ChangeSparklineGroupAttributes(rSparklineGroup, aAttributes); + } + } + } +} + void changeTheTheme(ScDocShell& rDocShell, std::shared_ptr const& pColorSet) { ScDocument& rDocument = rDocShell.GetDocument(); @@ -295,6 +344,7 @@ void ThemeColorChanger::apply(std::shared_ptr const& pColorSet) bool bChanged = false; bChanged = changeStyles(m_rDocShell, pColorSet) || bChanged; bChanged = changeSheets(m_rDocShell, rDocument.GetDrawLayer(), pColorSet) || bChanged; + changeSparklines(m_rDocShell, pColorSet); changeTheTheme(m_rDocShell, pColorSet); diff --git a/schema/libreoffice/OpenDocument-v1.3+libreoffice-schema.rng b/schema/libreoffice/OpenDocument-v1.3+libreoffice-schema.rng index 593df76f851e..c9571ac2a77a 100644 --- a/schema/libreoffice/OpenDocument-v1.3+libreoffice-schema.rng +++ b/schema/libreoffice/OpenDocument-v1.3+libreoffice-schema.rng @@ -1714,6 +1714,46 @@ xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -3508,6 +3548,7 @@ xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1. + @@ -3519,6 +3560,7 @@ xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1. + @@ -3532,21 +3574,25 @@ xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1. + + + + + + + + + - - - - + + - - - - + @@ -3567,50 +3613,35 @@ xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1. - - - - + - - - - + - - - - + - - - - + - - - - + diff --git a/xmloff/source/core/xmltoken.cxx b/xmloff/source/core/xmltoken.cxx index 2ecc3ea5ce7b..6564a2b866d7 100644 --- a/xmloff/source/core/xmltoken.cxx +++ b/xmloff/source/core/xmltoken.cxx @@ -1813,10 +1813,18 @@ namespace xmloff::token { TOKEN( "source-range-address", XML_SOURCE_RANGE_ADDRESS ), TOKEN( "source-service", XML_SOURCE_SERVICE ), TOKEN( "space-before", XML_SPACE_BEFORE ), - TOKEN( "sparkline-groups", XML_SPARKLINE_GROUPS ), - TOKEN( "sparkline-group", XML_SPARKLINE_GROUP ), - TOKEN( "sparklines", XML_SPARKLINES ), TOKEN( "sparkline", XML_SPARKLINE ), + TOKEN( "sparklines", XML_SPARKLINES ), + TOKEN( "sparkline-axis-complex-color", XML_SPARKLINE_AXIS_COMPLEX_COLOR), + TOKEN( "sparkline-first-complex-color", XML_SPARKLINE_FIRST_COMPLEX_COLOR), + TOKEN( "sparkline-group", XML_SPARKLINE_GROUP ), + TOKEN( "sparkline-groups", XML_SPARKLINE_GROUPS ), + TOKEN( "sparkline-high-complex-color", XML_SPARKLINE_HIGH_COMPLEX_COLOR), + TOKEN( "sparkline-last-complex-color", XML_SPARKLINE_LAST_COMPLEX_COLOR), + TOKEN( "sparkline-low-complex-color", XML_SPARKLINE_LOW_COMPLEX_COLOR), + TOKEN( "sparkline-markers-complex-color", XML_SPARKLINE_MARKERS_COMPLEX_COLOR), + TOKEN( "sparkline-negative-complex-color", XML_SPARKLINE_NEGATIVE_COMPLEX_COLOR), + TOKEN( "sparkline-series-complex-color", XML_SPARKLINE_SERIES_COMPLEX_COLOR), TOKEN( "span", XML_SPAN ), TOKEN( "specular", XML_SPECULAR ), TOKEN( "specular-color", XML_SPECULAR_COLOR ), diff --git a/xmloff/source/draw/XMLShapePropertySetContext.cxx b/xmloff/source/draw/XMLShapePropertySetContext.cxx index 42cff9db52d8..40287e6516e0 100644 --- a/xmloff/source/draw/XMLShapePropertySetContext.cxx +++ b/xmloff/source/draw/XMLShapePropertySetContext.cxx @@ -84,7 +84,7 @@ css::uno::Reference< css::xml::sax::XFastContextHandler > XMLShapePropertySetCon return new XMLTextColumnsContext(GetImport(), nElement, xAttrList, rProp, rProperties); case CTF_COMPLEX_COLOR: - return new XMLComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); + return new XMLPropertyComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); } return SvXMLPropertySetContext::createFastChildContext( nElement, diff --git a/xmloff/source/style/StylePropertiesContext.cxx b/xmloff/source/style/StylePropertiesContext.cxx index 1bda191485e6..910b7873d54f 100644 --- a/xmloff/source/style/StylePropertiesContext.cxx +++ b/xmloff/source/style/StylePropertiesContext.cxx @@ -35,7 +35,8 @@ StylePropertiesContext::createFastChildContext( { if (nElement == XML_ELEMENT(LO_EXT, XML_CHAR_COMPLEX_COLOR)) { - return new XMLComplexColorContext(GetImport(), nElement, xAttrList, rProperty, rProperties); + return new XMLPropertyComplexColorContext(GetImport(), nElement, xAttrList, rProperty, + rProperties); } return SvXMLPropertySetContext::createFastChildContext(nElement, xAttrList, rProperties, rProperty); diff --git a/xmloff/source/text/XMLComplexColorContext.cxx b/xmloff/source/text/XMLComplexColorContext.cxx index 39b8687cbc51..7b4e299f95e6 100644 --- a/xmloff/source/text/XMLComplexColorContext.cxx +++ b/xmloff/source/text/XMLComplexColorContext.cxx @@ -19,6 +19,7 @@ #include #include #include +#include using namespace css; using namespace xmloff::token; @@ -38,12 +39,13 @@ SvXMLEnumMapEntry const pXML_ThemeColor_Enum[] = { { XML_NONE, -1 }, { XML_FOLLOWED_HYPERLINK, 11 }, { XML_TOKEN_INVALID, 0 } }; -XMLComplexColorContext::XMLComplexColorContext( - SvXMLImport& rImport, sal_Int32 nElement, - const uno::Reference& xAttrList, const XMLPropertyState& rProp, - std::vector& rProps) - : XMLElementPropertyContext(rImport, nElement, rProp, rProps) - , mnRootElement(nElement) +XMLComplexColorImport::XMLComplexColorImport(model::ComplexColor& rComplexColor) + : mrComplexColor(rComplexColor) +{ +} + +void XMLComplexColorImport::fillAttributes( + const uno::Reference& xAttrList) { for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList)) { @@ -54,7 +56,7 @@ XMLComplexColorContext::XMLComplexColorContext( sal_Int16 nValue = -1; if (SvXMLUnitConverter::convertEnum(nValue, aIter.toView(), pXML_ThemeColor_Enum)) { - maComplexColor.setSchemeColor(model::convertToThemeColorType(nValue)); + mrComplexColor.setSchemeColor(model::convertToThemeColorType(nValue)); } break; } @@ -62,7 +64,7 @@ XMLComplexColorContext::XMLComplexColorContext( { const OUString aValue = aIter.toString(); if (aValue == u"theme") - maComplexColor.setType(model::ColorType::Scheme); + mrComplexColor.setType(model::ColorType::Scheme); // TODO - handle other color types break; } @@ -73,8 +75,7 @@ XMLComplexColorContext::XMLComplexColorContext( } } -css::uno::Reference -XMLComplexColorContext::createFastChildContext( +bool XMLComplexColorImport::handleTransformContext( sal_Int32 nElement, const css::uno::Reference& xAttrList) { if (nElement == XML_ELEMENT(LO_EXT, XML_TRANSFORMATION)) @@ -110,24 +111,62 @@ XMLComplexColorContext::createFastChildContext( break; } } - maComplexColor.addTransformation({ eTransformationType, nTransformationValue }); - return this; + mrComplexColor.addTransformation({ eTransformationType, nTransformationValue }); + return true; } XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement); + return false; +} + +XMLPropertyComplexColorContext::XMLPropertyComplexColorContext( + SvXMLImport& rImport, sal_Int32 nElement, + const uno::Reference& xAttrList, const XMLPropertyState& rProp, + std::vector& rProps) + : XMLElementPropertyContext(rImport, nElement, rProp, rProps) + , mnRootElement(nElement) + , maComplexColorImport(maComplexColor) +{ + maComplexColorImport.fillAttributes(xAttrList); +} + +css::uno::Reference +XMLPropertyComplexColorContext::createFastChildContext( + sal_Int32 nElement, const css::uno::Reference& xAttrList) +{ + if (maComplexColorImport.handleTransformContext(nElement, xAttrList)) + return this; return nullptr; } -void XMLComplexColorContext::endFastElement(sal_Int32 nElement) +void XMLPropertyComplexColorContext::endFastElement(sal_Int32 nElement) { if (nElement == mnRootElement) { - if (maComplexColor.getSchemeType() != model::ThemeColorType::Unknown) + if (getComplexColor().getSchemeType() != model::ThemeColorType::Unknown) { - aProp.maValue <<= model::color::createXComplexColor(maComplexColor); + aProp.maValue <<= model::color::createXComplexColor(getComplexColor()); SetInsert(true); } } XMLElementPropertyContext::endFastElement(nElement); } +XMLComplexColorContext::XMLComplexColorContext( + SvXMLImport& rImport, model::ComplexColor& rComplexColor, + const uno::Reference& xAttrList) + : SvXMLImportContext(rImport) + , maComplexColorImport(rComplexColor) +{ + maComplexColorImport.fillAttributes(xAttrList); +} + +css::uno::Reference +XMLComplexColorContext::createFastChildContext( + sal_Int32 nElement, const css::uno::Reference& xAttrList) +{ + if (maComplexColorImport.handleTransformContext(nElement, xAttrList)) + return this; + return nullptr; +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/xmloff/source/text/XMLComplexColorExport.cxx b/xmloff/source/text/XMLComplexColorExport.cxx index 6d950dff3051..4465e0d74585 100644 --- a/xmloff/source/text/XMLComplexColorExport.cxx +++ b/xmloff/source/text/XMLComplexColorExport.cxx @@ -12,7 +12,6 @@ #include #include -#include #include #include #include @@ -34,24 +33,18 @@ constexpr const std::array constThemeColorTypeToToken{ }; } -void XMLComplexColorExport::exportXML(const uno::Any& rAny, sal_uInt16 nPrefix, - const OUString& rLocalName) +void XMLComplexColorExport::doExport(model::ComplexColor const& rComplexColor, sal_uInt16 nPrefix, + const OUString& rLocalName) { - uno::Reference xComplexColor; - rAny >>= xComplexColor; - if (!xComplexColor.is()) + if (rComplexColor.getSchemeType() == model::ThemeColorType::Unknown) return; - model::ComplexColor aComplexColor = model::color::getFromXComplexColor(xComplexColor); - if (aComplexColor.getSchemeType() == model::ThemeColorType::Unknown) - return; - - XMLTokenEnum nToken = constThemeColorTypeToToken[sal_Int16(aComplexColor.getSchemeType())]; + XMLTokenEnum nToken = constThemeColorTypeToToken[sal_Int16(rComplexColor.getSchemeType())]; mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_THEME_TYPE, nToken); mrExport.AddAttribute(XML_NAMESPACE_LO_EXT, XML_COLOR_TYPE, "theme"); SvXMLElementExport aComplexColorElement(mrExport, nPrefix, rLocalName, true, true); - for (auto const& rTransform : aComplexColor.getTransformations()) + for (auto const& rTransform : rComplexColor.getTransformations()) { OUString aType; switch (rTransform.meType) @@ -82,4 +75,22 @@ void XMLComplexColorExport::exportXML(const uno::Any& rAny, sal_uInt16 nPrefix, } } +void XMLComplexColorExport::exportComplexColor(model::ComplexColor const& rComplexColor, + sal_uInt16 nPrefix, XMLTokenEnum nToken) +{ + doExport(rComplexColor, nPrefix, GetXMLToken(nToken)); +} + +void XMLComplexColorExport::exportXML(const uno::Any& rAny, sal_uInt16 nPrefix, + const OUString& rLocalName) +{ + uno::Reference xComplexColor; + rAny >>= xComplexColor; + if (!xComplexColor.is()) + return; + + model::ComplexColor aComplexColor = model::color::getFromXComplexColor(xComplexColor); + doExport(aComplexColor, nPrefix, rLocalName); +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/xmloff/source/text/XMLTextPropertySetContext.cxx b/xmloff/source/text/XMLTextPropertySetContext.cxx index bfe18db611cd..472001287e05 100644 --- a/xmloff/source/text/XMLTextPropertySetContext.cxx +++ b/xmloff/source/text/XMLTextPropertySetContext.cxx @@ -70,7 +70,7 @@ css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTextPropertySetCont break; case CTF_COMPLEX_COLOR: - return new XMLComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); + return new XMLPropertyComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); break; case CTF_DROPCAPFORMAT: diff --git a/xmloff/source/text/XMLTextShapeStyleContext.cxx b/xmloff/source/text/XMLTextShapeStyleContext.cxx index 729a94211e6a..52574c10d650 100644 --- a/xmloff/source/text/XMLTextShapeStyleContext.cxx +++ b/xmloff/source/text/XMLTextShapeStyleContext.cxx @@ -91,7 +91,7 @@ css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTextShapePropertySe break; case CTF_COMPLEX_COLOR: - return new XMLComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); + return new XMLPropertyComplexColorContext(GetImport(), nElement, xAttrList, rProp, rProperties); case CTF_BACKGROUND_URL: DBG_ASSERT( rProp.mnIndex >= 3 && diff --git a/xmloff/source/token/tokens.txt b/xmloff/source/token/tokens.txt index 3dd0ab102f4d..f700d2ac11ad 100644 --- a/xmloff/source/token/tokens.txt +++ b/xmloff/source/token/tokens.txt @@ -1713,10 +1713,18 @@ source-name source-range-address source-service space-before -sparkline-groups -sparkline-group -sparklines sparkline +sparklines +sparkline-axis-complex-color +sparkline-first-complex-color +sparkline-group +sparkline-groups +sparkline-high-complex-color +sparkline-last-complex-color +sparkline-low-complex-color +sparkline-markers-complex-color +sparkline-negative-complex-color +sparkline-series-complex-color span specular specular-color