/* -*- 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 <DataTableView.hxx>

#include <VSeriesPlotter.hxx>

#include <ShapeFactory.hxx>

#include <ExplicitCategoriesProvider.hxx>

#include <ChartModel.hxx>

#include <ObjectIdentifier.hxx>

#include <svx/svdotable.hxx>

#include <com/sun/star/table/BorderLine.hpp>

#include <com/sun/star/table/BorderLine2.hpp>

#include <com/sun/star/table/TableBorder.hpp>

#include <com/sun/star/table/BorderLineStyle.hpp>

#include <com/sun/star/text/XTextRange.hpp>

#include <com/sun/star/text/XText.hpp>

#include <com/sun/star/style/ParagraphAdjust.hpp>

#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>

#include <com/sun/star/drawing/TextVerticalAdjust.hpp>

#include <com/sun/star/drawing/LineDash.hpp>

#include <com/sun/star/drawing/LineStyle.hpp>

#include <com/sun/star/drawing/FillStyle.hpp>

#include <com/sun/star/util/XBroadcaster.hpp>

#include <com/sun/star/container/XNameContainer.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <o3tl/unit_conversion.hxx>

using namespace css;

namespace chart

{

namespace

{

void setTopCell(const uno::Reference<beans::XPropertySet>& xPropertySet)

{

    xPropertySet->setPropertyValue(u"FillColor"_ustr, uno::Any(Color(0xFFFFFF)));

    xPropertySet->setPropertyValue(u"TextVerticalAdjust"_ustr,

                                   uno::Any(drawing::TextVerticalAdjust_TOP));

    xPropertySet->setPropertyValue(u"ParaAdjust"_ustr, uno::Any(style::ParagraphAdjust_CENTER));

    table::BorderLine2 aBorderLine;

    aBorderLine.LineWidth = 0;

    aBorderLine.Color = 0x000000;

    xPropertySet->setPropertyValue(u"TopBorder"_ustr, uno::Any(aBorderLine));

    xPropertySet->setPropertyValue(u"LeftBorder"_ustr, uno::Any(aBorderLine));

}

void copyProperty(const uno::Reference<beans::XPropertySet>& xOut,

                  const uno::Reference<beans::XPropertySet>& xIn, OUString const& sPropertyName)

{

    xOut->setPropertyValue(sPropertyName, xIn->getPropertyValue(sPropertyName));

}

uno::Reference<text::XTextRange> getFirstParagraph(uno::Reference<text::XText> const& xText)

{

    uno::Reference<text::XTextRange> xParagraph;

    uno::Reference<container::XEnumerationAccess> xEnumAccess(xText, uno::UNO_QUERY);

    if (!xEnumAccess.is())

        return xParagraph;

    uno::Reference<container::XEnumeration> xEnumeration(xEnumAccess->createEnumeration());

    xParagraph.set(xEnumeration->nextElement(), uno::UNO_QUERY);

    return xParagraph;

}

uno::Reference<beans::XPropertySet>

getFirstParagraphProperties(uno::Reference<text::XText> const& xText)

{

    uno::Reference<beans::XPropertySet> xPropertySet;

    auto xParagraph = getFirstParagraph(xText);

    if (!xParagraph.is())

        return xPropertySet;

    xPropertySet.set(xParagraph, uno::UNO_QUERY);

    return xPropertySet;

}

} // end anonymous namespace

DataTableView::DataTableView(

    rtl::Reference<::chart::ChartModel> const& xChartModel,

    rtl::Reference<DataTable> const& rDataTableModel,

    css::uno::Reference<css::uno::XComponentContext> const& rComponentContext,

    bool bAlignAxisValuesWithColumns)

    : m_xChartModel(xChartModel)

    , m_xDataTableModel(rDataTableModel)

    , m_xComponentContext(rComponentContext)

    , m_bAlignAxisValuesWithColumns(bAlignAxisValuesWithColumns)

{

    m_aLineProperties.initFromPropertySet(uno::Reference<beans::XPropertySet>(m_xDataTableModel));

}

void DataTableView::setCellCharAndParagraphProperties(

    const uno::Reference<beans::XPropertySet>& xPropertySet)

{

    uno::Reference<beans::XPropertySet> xDataTableProperties(m_xDataTableModel);

    copyProperty(xPropertySet, xDataTableProperties, u"CharColor"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontFamily"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontFamilyAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontFamilyComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontCharSet"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontCharSetAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontCharSetComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontName"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontNameAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontNameComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontPitch"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontPitchAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontPitchComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontStyleName"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontStyleNameAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharFontStyleNameComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharHeight"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharHeightAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharHeightComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharKerning"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharLocale"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharLocaleAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharLocaleComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharPosture"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharPostureAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharPostureComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharRelief"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharShadowed"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharStrikeout"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharUnderline"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharUnderlineColor"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharUnderlineHasColor"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharOverline"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharOverlineColor"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharOverlineHasColor"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharWeight"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharWeightAsian"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharWeightComplex"_ustr);

    copyProperty(xPropertySet, xDataTableProperties, u"CharWordMode"_ustr);

    drawing::FillStyle eFillStyle = drawing::FillStyle_NONE;

    xDataTableProperties->getPropertyValue(u"FillStyle"_ustr) >>= eFillStyle;

    if (eFillStyle == drawing::FillStyle_SOLID)

    {

        sal_Int32 aColor = 0;

        if (xDataTableProperties->getPropertyValue(u"FillColor"_ustr) >>= aColor)

            xPropertySet->setPropertyValue(u"CharBackColor"_ustr, uno::Any(aColor));

    }

    xPropertySet->setPropertyValue(u"ParaAdjust"_ustr, uno::Any(style::ParagraphAdjust_CENTER));

}

void DataTableView::setCellProperties(const css::uno::Reference<beans::XPropertySet>& xPropertySet,

                                      bool bLeft, bool bTop, bool bRight, bool bBottom)

{

    xPropertySet->setPropertyValue(u"FillColor"_ustr, uno::Any(Color(0xFFFFFF)));

    float fFontHeight = 0.0;

    m_xDataTableModel->getPropertyValue(u"CharHeight"_ustr) >>= fFontHeight;

    fFontHeight = o3tl::convert(fFontHeight, o3tl::Length::pt, o3tl::Length::mm100);

    sal_Int32 nXDistance = std::round(fFontHeight * 0.18f);

    sal_Int32 nYDistance = std::round(fFontHeight * 0.30f);

    xPropertySet->setPropertyValue(u"TextLeftDistance"_ustr, uno::Any(nXDistance));

    xPropertySet->setPropertyValue(u"TextRightDistance"_ustr, uno::Any(nXDistance));

    xPropertySet->setPropertyValue(u"TextUpperDistance"_ustr, uno::Any(nYDistance));

    xPropertySet->setPropertyValue(u"TextLowerDistance"_ustr, uno::Any(nYDistance));

    xPropertySet->setPropertyValue(u"TextVerticalAdjust"_ustr,

                                   uno::Any(drawing::TextVerticalAdjust_TOP));

    drawing::LineStyle eStyle = drawing::LineStyle_NONE;

    m_aLineProperties.LineStyle >>= eStyle;

    if (eStyle != drawing::LineStyle_NONE)

    {

        table::BorderLine2 aBorderLine;

        sal_Int32 nWidth = 0;

        m_aLineProperties.Width >>= nWidth;

        aBorderLine.LineWidth = o3tl::convert(nWidth, o3tl::Length::mm100, o3tl::Length::twip);

        sal_Int32 nColor = 0;

        m_aLineProperties.Color >>= nColor;

        aBorderLine.Color = nColor;

        aBorderLine.LineStyle = table::BorderLineStyle::SOLID;

        if (eStyle == drawing::LineStyle_DASH)

        {

            OUString aDashName;

            m_aLineProperties.DashName >>= aDashName;

            if (!aDashName.isEmpty() && m_xChartModel.is())

            {

                uno::Reference<container::XNameContainer> xDashTable(

                    m_xChartModel->createInstance(u"com.sun.star.drawing.DashTable"_ustr),

                    uno::UNO_QUERY);

                if (xDashTable.is() && xDashTable->hasByName(aDashName))

                {

                    drawing::LineDash aLineDash;

                    xDashTable->getByName(aDashName) >>= aLineDash;

                    if (aLineDash.Dots == 0 && aLineDash.Dashes == 0)

                        aBorderLine.LineStyle = table::BorderLineStyle::SOLID;

                    else if (aLineDash.Dots == 1 && aLineDash.Dashes == 0)

                        aBorderLine.LineStyle = table::BorderLineStyle::DOTTED;

                    else if (aLineDash.Dots == 0 && aLineDash.Dashes == 1)

                        aBorderLine.LineStyle = table::BorderLineStyle::DASHED;

                    else if (aLineDash.Dots == 1 && aLineDash.Dashes == 1)

                        aBorderLine.LineStyle = table::BorderLineStyle::DASH_DOT;

                    else if (aLineDash.Dots == 2 && aLineDash.Dashes == 1)

                        aBorderLine.LineStyle = table::BorderLineStyle::DASH_DOT_DOT;

                    else

                        aBorderLine.LineStyle = table::BorderLineStyle::DASHED;

                }

            }

        }

        if (bLeft)

            xPropertySet->setPropertyValue(u"LeftBorder"_ustr, uno::Any(aBorderLine));

        if (bTop)

            xPropertySet->setPropertyValue(u"TopBorder"_ustr, uno::Any(aBorderLine));

        if (bRight)

            xPropertySet->setPropertyValue(u"RightBorder"_ustr, uno::Any(aBorderLine));

        if (bBottom)

            xPropertySet->setPropertyValue(u"BottomBorder"_ustr, uno::Any(aBorderLine));

    }

}

void DataTableView::createShapes(basegfx::B2DVector const& rStart, basegfx::B2DVector const& rEnd,

                                 sal_Int32 nAxisStepWidth)

{

    if (!m_xTarget.is())

        return;

    // Remove shapes first before we add the new ones

    ShapeFactory::removeSubShapes(m_xTarget);

    auto sParticle = ObjectIdentifier::createParticleForDataTable(m_xChartModel);

    auto sCID = ObjectIdentifier::createClassifiedIdentifierForParticle(sParticle);

    m_xTableShape = ShapeFactory::createTable(m_xTarget, sCID);

    // calculate the table size

    auto rDelta = rEnd - rStart;

    sal_Int32 nTableSize = basegfx::fround(rDelta.getX());

    m_xTableShape->setSize({ nTableSize, 0 });

    try

    {

        m_xTableShape->getPropertyValue(u"Model"_ustr) >>= m_xTable;

    }

    catch (const uno::Exception&)

    {

        return;

    }

    if (!m_xTable.is())

        return;

    uno::Reference<util::XBroadcaster> xBroadcaster(m_xTable, uno::UNO_QUERY);

    if (!xBroadcaster.is())

        return;

    xBroadcaster->lockBroadcasts();

    auto* pTableObject = static_cast<sdr::table::SdrTableObj*>(m_xTableShape->GetSdrObject());

    // get the data table properties from the model

    bool bHBorder = false;

    bool bVBorder = false;

    bool bOutline = false;

    bool bKeys = false;

    std::vector<ViewLegendSymbol> aSymbols;

    m_xDataTableModel->getPropertyValue(u"HBorder"_ustr) >>= bHBorder;

    m_xDataTableModel->getPropertyValue(u"VBorder"_ustr) >>= bVBorder;

    m_xDataTableModel->getPropertyValue(u"Outline"_ustr) >>= bOutline;

    m_xDataTableModel->getPropertyValue(u"Keys"_ustr) >>= bKeys;

    // set the data table row and column size

    sal_Int32 nColumnCount = m_aXValues.size();

    uno::Reference<table::XTableColumns> xTableColumns = m_xTable->getColumns();

    xTableColumns->insertByIndex(0, nColumnCount);

    sal_Int32 nRowCount = m_aDataSeriesNames.size();

    uno::Reference<table::XTableRows> xTableRows = m_xTable->getRows();

    xTableRows->insertByIndex(0, nRowCount);

    sal_Int32 nColumnWidth = 0.0;

    // If we don't align, we have to calculate the column width ourselves,

    // otherwise the column width is taken from the x-axis width

    if (m_bAlignAxisValuesWithColumns)

        nColumnWidth = nAxisStepWidth;

    else

        nColumnWidth = double(nTableSize) / nColumnCount;

    // Setup empty top-left cell

    {

        uno::Reference<table::XCell> xCell = m_xTable->getCellByPosition(0, 0);

        uno::Reference<beans::XPropertySet> xPropertySet(xCell, uno::UNO_QUERY);

        if (xPropertySet.is())

        {

            setTopCell(xPropertySet);

        }

    }

    sal_Int32 nColumn;

    sal_Int32 nRow;

    // COLUMN HEADER

    nColumn = 1;

    for (auto const& rString : m_aXValues)

    {

        uno::Reference<table::XCell> xCell = m_xTable->getCellByPosition(nColumn, 0);

        uno::Reference<beans::XPropertySet> xPropertySet(xCell, uno::UNO_QUERY);

        uno::Reference<text::XTextRange> xCellTextRange(xCell, uno::UNO_QUERY);

        if (xCellTextRange.is())

        {

            auto xText = xCellTextRange->getText();

            xText->insertString(xText->getStart(), rString, false);

            auto xTextPropertySet = getFirstParagraphProperties(xText);

            if (xTextPropertySet)

            {

                bool bLeft = (bOutline && nColumn == 1)

                             || (bVBorder && nColumn > 1 && nColumn < nColumnCount);

                bool bRight = (bOutline && nColumn == nColumnCount)

                              || (bVBorder && nColumn > 1 && nColumn < nColumnCount);

                setCellCharAndParagraphProperties(xTextPropertySet);

                setCellProperties(xPropertySet, bLeft, bOutline, bRight, bOutline);

            }

        }

        nColumn++;

    }

    // ROW HEADER

    // Prepare keys (symbols)

    sal_Int32 nMaxSymbolWidth = 0;

    constexpr const sal_Int32 constSymbolMargin = 100; // 1mm

    if (bKeys)

    {

        float fFontHeight = 0.0;

        m_xDataTableModel->getPropertyValue(u"CharHeight"_ustr) >>= fFontHeight;

        fFontHeight = o3tl::convert(fFontHeight, o3tl::Length::pt, o3tl::Length::mm100);

        sal_Int32 nSymbolHeight = sal_Int32(fFontHeight * 0.6);

        sal_Int32 nSymbolWidth = nSymbolHeight;

        for (VSeriesPlotter* pSeriesPlotter : m_pSeriesPlotterList)

        {

            if (pSeriesPlotter)

            {

                awt::Size aCurrentRatio = pSeriesPlotter->getPreferredLegendKeyAspectRatio();

                sal_Int32 nCurrentWidth = aCurrentRatio.Width;

                if (aCurrentRatio.Height > 0)

                    nCurrentWidth = nSymbolHeight * aCurrentRatio.Width / aCurrentRatio.Height;

                nSymbolWidth = std::max(nSymbolWidth, nCurrentWidth);

            }

        }

        nMaxSymbolWidth = nSymbolWidth;

        for (VSeriesPlotter* pSeriesPlotter : m_pSeriesPlotterList)

        {

            if (pSeriesPlotter)

            {

                awt::Size aSize(nSymbolWidth, nSymbolHeight);

                std::vector<ViewLegendSymbol> aNewEntries

                    = pSeriesPlotter->createSymbols(aSize, m_xTarget, m_xComponentContext);

                for (auto const& rSymbol : aNewEntries)

                    aSymbols.push_back(rSymbol);

            }

        }

    }

    nRow = 1;

    for (auto const& rSeriesName : m_aDataSeriesNames)

    {

        uno::Reference<table::XCell> xCell = m_xTable->getCellByPosition(0, nRow);

        uno::Reference<beans::XPropertySet> xCellPropertySet(xCell, uno::UNO_QUERY);

        uno::Reference<text::XTextRange> xCellTextRange(xCell, uno::UNO_QUERY);

        if (xCellTextRange.is())

        {

            bool bTop = (bOutline && nRow == 1) || (bHBorder && nRow > 1 && nRow < nRowCount);

            bool bBottom

                = (bOutline && nRow == nRowCount) || (bHBorder && nRow > 1 && nRow < nRowCount);

            auto xText = xCellTextRange->getText();

            xText->insertString(xText->getStart(), rSeriesName, false);

            auto xTextPropertySet = getFirstParagraphProperties(xText);

            if (xTextPropertySet)

            {

                setCellCharAndParagraphProperties(xTextPropertySet);

                setCellProperties(xCellPropertySet, bOutline, bTop, bOutline, bBottom);

                xCellPropertySet->setPropertyValue(u"ParaAdjust"_ustr,

                                                   uno::Any(style::ParagraphAdjust_LEFT));

                if (bKeys)

                {

                    xCellPropertySet->setPropertyValue(

                        u"ParaLeftMargin"_ustr,

                        uno::Any(nMaxSymbolWidth + sal_Int32(2 * constSymbolMargin)));

                }

            }

        }

        nRow++;

    }

    // TABLE

    nRow = 1;

    const sal_Int32 nTableModelRowCount = m_xTable->getRowCount();

    const sal_Int32 nTableModelColCount = m_xTable->getColumnCount();

    // tdf#153182 the broken bounds are most likely because we don't know if the

    // data-table has header rows and columns. Most likely it does not.

    bool bBrokenBounds = false;

    for (auto const& rSeries : m_pDataSeriesValues)

    {

        nColumn = 1;

        for (auto const& rValue : rSeries)

        {

            if (nRow >= nTableModelRowCount || nColumn >= nTableModelColCount)

            {

                bBrokenBounds = true;

                SAL_WARN("chart2", "exceeding bounds of table model?");

                break;

            }

            uno::Reference<table::XCell> xCell = m_xTable->getCellByPosition(nColumn, nRow);

            uno::Reference<beans::XPropertySet> xCellPropertySet(xCell, uno::UNO_QUERY);

            uno::Reference<text::XTextRange> xCellTextRange(xCell, uno::UNO_QUERY);

            if (xCellTextRange.is())

            {

                auto xText = xCellTextRange->getText();

                xText->insertString(xText->getStart(), rValue, false);

                auto xTextPropertySet = getFirstParagraphProperties(xText);

                if (xTextPropertySet.is())

                {

                    bool bLeft = false;

                    bool bTop = false;

                    bool bRight = false;

                    bool bBottom = false;

                    if (nColumn > 1 && bVBorder)

                        bLeft = true;

                    if (nRow > 1 && bHBorder)

                        bTop = true;

                    if (nRow == nRowCount && bOutline)

                        bBottom = true;

                    if (nColumn == nColumnCount && bOutline)

                        bRight = true;

                    setCellCharAndParagraphProperties(xTextPropertySet);

                    setCellProperties(xCellPropertySet, bLeft, bTop, bRight, bBottom);

                }

            }

            nColumn++;

        }

        if (bBrokenBounds)

            break;

        nRow++;

    }

    // force recalculation of column widths in the table shape

    xBroadcaster->unlockBroadcasts();

    pTableObject->DistributeColumns(0, nColumnCount, true, true);

    xBroadcaster->lockBroadcasts();

    // reposition the data table

    changePosition(basegfx::fround(rStart.getX()), basegfx::fround(rStart.getY()));

    sal_Int32 nTableX = m_xTableShape->getPosition().X;

    sal_Int32 nTableY = m_xTableShape->getPosition().Y;

    uno::Reference<beans::XPropertySet> xPropertySet(xTableColumns->getByIndex(0), uno::UNO_QUERY);

    for (sal_Int32 i = 1; i < xTableColumns->getCount(); ++i)

    {

        xPropertySet.set(xTableColumns->getByIndex(i), uno::UNO_QUERY);

        xPropertySet->setPropertyValue(u"Width"_ustr, uno::Any(nColumnWidth));

    }

    // force recalculation of row heights in the table shape

    xBroadcaster->unlockBroadcasts();

    pTableObject->DistributeRows(0, nRowCount, true, true);

    if (bKeys)

    {

        sal_Int32 nTotalHeight = 0;

        for (sal_Int32 i = 0; i < xTableRows->getCount(); i++)

        {

            sal_Int32 nSymbolIndex = i - 1;

            if (nSymbolIndex < sal_Int32(aSymbols.size()))

            {

                xPropertySet.set(xTableRows->getByIndex(i), uno::UNO_QUERY);

                sal_Int32 nHeight = 0;

                xPropertySet->getPropertyValue(u"Height"_ustr) >>= nHeight;

                if (i > 0)

                {

                    auto& rSymbol = aSymbols[nSymbolIndex].xSymbol;

                    sal_Int32 nSymbolHeight = rSymbol->getSize().Height;

                    sal_Int32 nSymbolY

                        = basegfx::fround(double(nHeight) / 2.0 - double(nSymbolHeight) / 2.0);

                    rSymbol->setPosition(

                        { nTableX + constSymbolMargin, nTableY + nTotalHeight + nSymbolY });

                }

                nTotalHeight += nHeight;

            }

        }

    }

}

void DataTableView::changePosition(sal_Int32 x, sal_Int32 y)

{

    if (!m_xTable.is())

        return;

    uno::Reference<table::XTableColumns> xTableColumns = m_xTable->getColumns();

    uno::Reference<beans::XPropertySet> xPropertySet(xTableColumns->getByIndex(0), uno::UNO_QUERY);

    sal_Int32 nWidth = 0;

    xPropertySet->getPropertyValue(u"Width"_ustr) >>= nWidth;

    m_xTarget->setPosition({ x - nWidth, y });

}

void DataTableView::initializeShapes(const rtl::Reference<SvxShapeGroupAnyD>& xTarget)

{

    m_xTarget = xTarget;

}

void DataTableView::initializeValues(

    std::vector<std::unique_ptr<VSeriesPlotter>>& rSeriesPlotterList)

{

    for (auto& rSeriesPlotter : rSeriesPlotterList)

    {

        m_pSeriesPlotterList.push_back(rSeriesPlotter.get());

        for (auto const& rCategory :

             rSeriesPlotter->getExplicitCategoriesProvider()->getSimpleCategories())

        {

            m_aXValues.push_back(rCategory);

        }

        for (auto const& rString : rSeriesPlotter->getAllSeriesNames())

        {

            m_aDataSeriesNames.push_back(rString);

        }

        for (VDataSeries* pSeries : rSeriesPlotter->getAllSeries())

        {

            auto& rValues = m_pDataSeriesValues.emplace_back();

            for (int i = 0; i < pSeries->getTotalPointCount(); i++)

            {

                double nValue = pSeries->getYValue(i);

                rValues.push_back(rSeriesPlotter->getLabelTextForValue(*pSeries, i, nValue, false));

            }

        }

    }

}

} //namespace chart

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */