/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <sal/config.h>

#include <cstddef>

#include <dlg_ObjectProperties.hxx>

#include "tp_AxisLabel.hxx"

#include "tp_DataLabel.hxx"

#include "tp_LegendPosition.hxx"

#include "tp_PointGeometry.hxx"

#include "tp_Scale.hxx"

#include "tp_AxisPositions.hxx"

#include "tp_ErrorBars.hxx"

#include "tp_Trendline.hxx"

#include "tp_SeriesToAxis.hxx"

#include "tp_TitleRotation.hxx"

#include "tp_PolarOptions.hxx"

#include "tp_DataPointOption.hxx"

#include "tp_DataTable.hxx"

#include "tp_ChartColorPalette.hxx"

#include <ViewElementListProvider.hxx>

#include <ChartType.hxx>

#include <ChartTypeHelper.hxx>

#include <ObjectNameProvider.hxx>

#include <DataSeries.hxx>

#include <DiagramHelper.hxx>

#include <Diagram.hxx>

#include <NumberFormatterWrapper.hxx>

#include <Axis.hxx>

#include <AxisHelper.hxx>

#include <ExplicitCategoriesProvider.hxx>

#include <ChartModel.hxx>

#include <CommonConverters.hxx>

#include <RegressionCalculationHelper.hxx>

#include <BaseCoordinateSystem.hxx>

#include <com/sun/star/chart2/AxisType.hpp>

#include <svl/intitem.hxx>

#include <svl/ctloptions.hxx>

#include <svx/svxids.hrc>

#include <svx/drawitem.hxx>

#include <svx/ofaitem.hxx>

#include <svx/svxgraphicitem.hxx>

#include <svx/dialogs.hrc>

#include <editeng/flstitem.hxx>

#include <svx/flagsdef.hxx>

#include <svx/numinf.hxx>

#include <svl/cjkoptions.hxx>

#include <utility>

#include <comphelper/diagnose_ex.hxx>

#include <vcl/tabs.hrc>

namespace chart

{

using namespace ::com::sun::star;

using namespace ::com::sun::star::chart2;

using ::com::sun::star::uno::Reference;

using ::com::sun::star::uno::Sequence;

using ::com::sun::star::uno::Exception;

using ::com::sun::star::beans::XPropertySet;

ObjectPropertiesDialogParameter::ObjectPropertiesDialogParameter( OUString aObjectCID )

        : m_aObjectCID(std::move( aObjectCID ))

        , m_eObjectType( ObjectIdentifier::getObjectType( m_aObjectCID ) )

        , m_bAffectsMultipleObjects(false)

        , m_bHasGeometryProperties(false)

        , m_bHasStatisticProperties(false)

        , m_bProvidesSecondaryYAxis(false)

        , m_bProvidesOverlapAndGapWidth(false)

        , m_bProvidesBarConnectors(false)

        , m_bHasAreaProperties(false)

        , m_bHasSymbolProperties(false)

        , m_bHasNumberProperties(false)

        , m_bProvidesStartingAngle(false)

        , m_bProvidesMissingValueTreatments(false)

        , m_bIsPieChartDataPoint(false)

        , m_bHasScaleProperties(false)

        , m_bCanAxisLabelsBeStaggered(false)

        , m_bSupportingAxisPositioning(false)

        , m_bShowAxisOrigin(false)

        , m_bIsCrossingAxisIsCategoryAxis(false)

        , m_bSupportingCategoryPositioning(false)

        , m_bComplexCategoriesAxis( false )

        , m_nNbPoints( 0 )

{

    std::u16string_view aParticleID = ObjectIdentifier::getParticleID( m_aObjectCID );

    m_bAffectsMultipleObjects = (aParticleID == u"ALLELEMENTS");

}

ObjectPropertiesDialogParameter::~ObjectPropertiesDialogParameter()

{

}

void ObjectPropertiesDialogParameter::init( const rtl::Reference<::chart::ChartModel>& xChartModel )

{

    m_xChartDocument = xChartModel;

    rtl::Reference< Diagram > xDiagram = xChartModel->getFirstChartDiagram();

    rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( m_aObjectCID, xChartModel );

    rtl::Reference< ChartType > xChartType = xChartModel->getChartTypeOfSeries( xSeries );

    sal_Int32 nDimensionCount = 0;

    if (xDiagram)

        nDimensionCount = xDiagram->getDimension();

    bool bHasSeriesProperties = (m_eObjectType==OBJECTTYPE_DATA_SERIES);

    bool bHasDataPointproperties = (m_eObjectType==OBJECTTYPE_DATA_POINT);

    if( bHasSeriesProperties || bHasDataPointproperties )

    {

        m_bHasGeometryProperties = xChartType->isSupportingGeometryProperties(nDimensionCount );

        m_bHasAreaProperties     = xChartType->isSupportingAreaProperties(nDimensionCount);

        m_bHasSymbolProperties   = xChartType->isSupportingSymbolProperties(nDimensionCount);

        m_bIsPieChartDataPoint   = bHasDataPointproperties && xChartType->isSupportingStartingAngle();

        if( bHasSeriesProperties )

        {

            m_bHasStatisticProperties =  xChartType->isSupportingStatisticProperties(nDimensionCount);

            m_bProvidesSecondaryYAxis =  xChartType->isSupportingSecondaryAxis(nDimensionCount);

            m_bProvidesOverlapAndGapWidth =  xChartType->isSupportingOverlapAndGapWidthProperties(nDimensionCount);

            m_bProvidesBarConnectors =  xChartType->isSupportingBarConnectors(nDimensionCount);

            m_bProvidesStartingAngle = xChartType->isSupportingStartingAngle();

            m_bProvidesMissingValueTreatments = ChartTypeHelper::getSupportedMissingValueTreatments( xChartType )

                                            .hasElements();

        }

    }

    if( m_eObjectType == OBJECTTYPE_DATA_ERRORS_X ||

        m_eObjectType == OBJECTTYPE_DATA_ERRORS_Y ||

        m_eObjectType == OBJECTTYPE_DATA_ERRORS_Z)

        m_bHasStatisticProperties = true;

    if( m_eObjectType == OBJECTTYPE_AXIS )

    {

        //show scale properties only for a single axis not for multiselection

        m_bHasScaleProperties = !m_bAffectsMultipleObjects;

        if( m_bHasScaleProperties )

        {

            rtl::Reference< Axis > xAxis = ObjectIdentifier::getAxisForCID( m_aObjectCID, xChartModel );

            if( xAxis.is() )

            {

                //no scale page for series axis

                ScaleData aData( xAxis->getScaleData() );

                if( aData.AxisType == chart2::AxisType::SERIES )

                    m_bHasScaleProperties = false;

                if( aData.AxisType != chart2::AxisType::SERIES )

                    m_bHasNumberProperties = true;

                //is the crossing main axis a category axes?:

                rtl::Reference< BaseCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( xAxis, xDiagram ) );

                rtl::Reference< Axis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( xAxis, xCooSys ) );

                if( xCrossingMainAxis.is() )

                {

                    ScaleData aScale( xCrossingMainAxis->getScaleData() );

                    m_bIsCrossingAxisIsCategoryAxis = ( aScale.AxisType == chart2::AxisType::CATEGORY  );

                    if( m_bIsCrossingAxisIsCategoryAxis )

                    {

                        if (xChartModel)

                            m_aCategories = DiagramHelper::getExplicitSimpleCategories( *xChartModel );

                    }

                }

                sal_Int32 nCooSysIndex=0;

                sal_Int32 nDimensionIndex=0;

                sal_Int32 nAxisIndex=0;

                if( AxisHelper::getIndicesForAxis( xAxis, xDiagram, nCooSysIndex, nDimensionIndex, nAxisIndex ) )

                {

                    xChartType = AxisHelper::getFirstChartTypeWithSeriesAttachedToAxisIndex( xDiagram, nAxisIndex );

                    //show positioning controls only if they make sense

                    m_bSupportingAxisPositioning = xChartType.is() ? xChartType->isSupportingAxisPositioning(nDimensionCount, nDimensionIndex) : true;

                    //show axis origin only for secondary y axis

                    if( nDimensionIndex==1 && nAxisIndex==1 && xChartType.is() && xChartType->isSupportingBaseValue())

                        m_bShowAxisOrigin = true;

                    if ( nDimensionIndex == 0 && ( aData.AxisType == chart2::AxisType::CATEGORY || aData.AxisType == chart2::AxisType::DATE ) )

                    {

                        if (xChartModel)

                        {

                            ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, *xChartModel );

                            m_bComplexCategoriesAxis = aExplicitCategoriesProvider.hasComplexCategories();

                        }

                        if (!m_bComplexCategoriesAxis)

                            m_bSupportingCategoryPositioning = xChartType.is() && xChartType->isSupportingCategoryPositioning(nDimensionCount);

                    }

                }

            }

        }

        //no staggering of labels for 3D axis

        m_bCanAxisLabelsBeStaggered = nDimensionCount==2;

    }

    if( m_eObjectType == OBJECTTYPE_DATA_CURVE )

    {

        const std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > & aDataSeqs( xSeries->getDataSequences2());

        Sequence< double > aXValues, aYValues;

        bool bXValuesFound = false, bYValuesFound = false;

        m_nNbPoints = 0;

        for( std::size_t i=0;

             ! (bXValuesFound && bYValuesFound) && i<aDataSeqs.size();

             ++i )

        {

            try

            {

                Reference< data::XDataSequence > xSeq( aDataSeqs[i]->getValues());

                Reference< XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW );

                OUString aRole;

                if( xProp->getPropertyValue( u"Role"_ustr ) >>= aRole )

                {

                    if( !bXValuesFound && aRole == "values-x" )

                    {

                        aXValues = DataSequenceToDoubleSequence( xSeq );

                        bXValuesFound = true;

                    }

                    else if( !bYValuesFound && aRole == "values-y" )

                    {

                        aYValues = DataSequenceToDoubleSequence( xSeq );

                        bYValuesFound = true;

                    }

                }

            }

            catch( const Exception & )

            {

                DBG_UNHANDLED_EXCEPTION("chart2");

            }

        }

        if( !bXValuesFound && bYValuesFound )

        {

            // initialize with 1, 2, ...

            //first category (index 0) matches with real number 1.0

            aXValues.realloc( aYValues.getLength() );

            auto pXValues = aXValues.getArray();

            for( sal_Int32 i=0; i<aXValues.getLength(); ++i )

                pXValues[i] = i+1;

            bXValuesFound = true;

        }

        if( bXValuesFound && bYValuesFound &&

            aXValues.hasElements() &&

            aYValues.hasElements() )

        {

            RegressionCalculationHelper::tDoubleVectorPair aValues(

                RegressionCalculationHelper::cleanup( aXValues, aYValues, RegressionCalculationHelper::isValid()));

            m_nNbPoints = aValues.second.size();

        }

    }

     //create gui name for this object

    if( !m_bAffectsMultipleObjects && m_eObjectType == OBJECTTYPE_AXIS )

    {

        m_aLocalizedName = ObjectNameProvider::getAxisName( m_aObjectCID, xChartModel );

    }

    else if( !m_bAffectsMultipleObjects && ( m_eObjectType == OBJECTTYPE_GRID || m_eObjectType == OBJECTTYPE_SUBGRID ) )

    {

        m_aLocalizedName = ObjectNameProvider::getGridName( m_aObjectCID, xChartModel );

    }

    else if( !m_bAffectsMultipleObjects && m_eObjectType == OBJECTTYPE_TITLE )

    {

        m_aLocalizedName = ObjectNameProvider::getTitleName( m_aObjectCID, xChartModel );

    }

    else

    {

        switch( m_eObjectType )

        {

            case OBJECTTYPE_DATA_POINT:

            case OBJECTTYPE_DATA_LABEL:

            case OBJECTTYPE_DATA_LABELS:

            case OBJECTTYPE_DATA_ERRORS_X:

            case OBJECTTYPE_DATA_ERRORS_Y:

            case OBJECTTYPE_DATA_ERRORS_Z:

            case OBJECTTYPE_DATA_AVERAGE_LINE:

            case OBJECTTYPE_DATA_CURVE:

            case OBJECTTYPE_DATA_CURVE_EQUATION:

                if( m_bAffectsMultipleObjects )

                    m_aLocalizedName = ObjectNameProvider::getName_ObjectForAllSeries( m_eObjectType );

                else

                    m_aLocalizedName = ObjectNameProvider::getName_ObjectForSeries( m_eObjectType, m_aObjectCID, m_xChartDocument );

                break;

            default:

                m_aLocalizedName = ObjectNameProvider::getName(m_eObjectType,m_bAffectsMultipleObjects);

                break;

        }

    }

}

const sal_uInt16 nNoArrowNoShadowDlg    = 1101;

void SchAttribTabDlg::setSymbolInformation( SfxItemSet&& rSymbolShapeProperties,

                std::optional<Graphic> oAutoSymbolGraphic )

{

    m_oSymbolShapeProperties.emplace(std::move(rSymbolShapeProperties));

    m_oAutoSymbolGraphic = std::move(oAutoSymbolGraphic);

}

void SchAttribTabDlg::SetAxisMinorStepWidthForErrorBarDecimals( double fMinorStepWidth )

{

    m_fAxisMinorStepWidthForErrorBarDecimals = fMinorStepWidth;

}

SchAttribTabDlg::SchAttribTabDlg(weld::Window* pParent,

                                 const SfxItemSet* pAttr,

                                 const ObjectPropertiesDialogParameter& rDialogParameter,

                                 const ViewElementListProvider* pViewElementListProvider,

                                 const uno::Reference< util::XNumberFormatsSupplier >& xNumberFormatsSupplier)

    : SfxTabDialogController(pParent, u"modules/schart/ui/attributedialog.ui"_ustr, u"AttributeDialog"_ustr, pAttr)

    , m_rParameter(rDialogParameter)

    , m_pViewElementListProvider( pViewElementListProvider )

    , m_pNumberFormatter(nullptr)

    , m_fAxisMinorStepWidthForErrorBarDecimals(0.1)

    , m_bOKPressed(false)

{

    NumberFormatterWrapper aNumberFormatterWrapper( xNumberFormatsSupplier );

    m_pNumberFormatter = aNumberFormatterWrapper.getSvNumberFormatter();

    m_xDialog->set_title(rDialogParameter.getLocalizedName());

    ObjectType eType = rDialogParameter.getObjectType();

    switch (eType)

    {

        case OBJECTTYPE_TITLE:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                       RID_M + RID_TAB_AREA.sIconName);

            AddTabPage(u"transparent"_ustr, TabResId(RID_TAB_TRANSPARENCE.aLabel), RID_SVXPAGE_TRANSPARENCE,

                       RID_M + RID_TAB_TRANSPARENCE.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            AddTabPage(u"alignment"_ustr, TabResId(RID_TAB_ALIGNMENT.aLabel), SchAlignmentTabPage::Create,

                       RID_M + RID_TAB_ALIGNMENT.sIconName);

            if( SvtCJKOptions::IsAsianTypographyEnabled() )

                AddTabPage(u"asian"_ustr, TabResId(RID_TAB_ASIANTYPO.aLabel), RID_SVXPAGE_PARA_ASIAN,

                           RID_M + RID_TAB_ASIANTYPO.sIconName);

            break;

        case OBJECTTYPE_LEGEND:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                       RID_M + RID_TAB_AREA.sIconName);

            AddTabPage(u"transparent"_ustr, TabResId(RID_TAB_TRANSPARENCE.aLabel), RID_SVXPAGE_TRANSPARENCE,

                       RID_M + RID_TAB_TRANSPARENCE.sIconName);

            AddTabPage(u"colorpalette"_ustr, TabResId(RID_TAB_COLORPALETTE.aLabel), ChartColorPaletteTabPage::Create,

                       RID_M + RID_TAB_COLORPALETTE.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            AddTabPage(u"legendpos"_ustr, TabResId(RID_TAB_CHART_LEGENDPOS.aLabel), SchLegendPosTabPage::Create,

                       RID_M + RID_TAB_CHART_LEGENDPOS.sIconName);

            if (SvtCJKOptions::IsAsianTypographyEnabled())

                AddTabPage(u"asian"_ustr, TabResId(RID_TAB_ASIANTYPO.aLabel), RID_SVXPAGE_PARA_ASIAN,

                           RID_M + RID_TAB_ASIANTYPO.sIconName);

            break;

        case OBJECTTYPE_DATA_SERIES:

        case OBJECTTYPE_DATA_POINT:

            if (m_rParameter.ProvidesSecondaryYAxis() || m_rParameter.ProvidesOverlapAndGapWidth() || m_rParameter.ProvidesMissingValueTreatments())

                AddTabPage(u"options"_ustr, TabResId(RID_TAB_CHART_OPTIONS.aLabel), SchOptionTabPage::Create,

                           RID_M + RID_TAB_CHART_OPTIONS.sIconName);

            if (m_rParameter.ProvidesStartingAngle())

                AddTabPage(u"polaroptions"_ustr, TabResId(RID_TAB_CHART_OPTIONS.aLabel), PolarOptionsTabPage::Create,

                           RID_M + RID_TAB_CHART_OPTIONS.sIconName);

            if (m_rParameter.IsPieChartDataPoint())

                AddTabPage(u"datapointoption"_ustr, TabResId(RID_TAB_CHART_OPTIONS.aLabel), DataPointOptionTabPage::Create,

                           RID_M + RID_TAB_CHART_OPTIONS.sIconName);

            if (m_rParameter.HasGeometryProperties())

                AddTabPage(u"layout"_ustr, TabResId(RID_TAB_CHART_LAYOUT.aLabel), SchLayoutTabPage::Create,

                           RID_M + RID_TAB_CHART_LAYOUT.sIconName);

            if (m_rParameter.HasAreaProperties())

            {

                AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                           RID_M + RID_TAB_AREA.sIconName);

                AddTabPage(u"transparent"_ustr, TabResId(RID_TAB_TRANSPARENCE.aLabel), RID_SVXPAGE_TRANSPARENCE,

                           RID_M + RID_TAB_TRANSPARENCE.sIconName);

                AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                        RID_M + RID_TAB_BORDER.sIconName);

            }

            else

                AddTabPage(u"border"_ustr, TabResId(RID_TAB_LINE.aLabel), RID_SVXPAGE_LINE,

                           RID_M + RID_TAB_LINE.sIconName);

            AddTabPage(u"colorpalette"_ustr, TabResId(RID_TAB_COLORPALETTE.aLabel), ChartColorPaletteTabPage::Create,

                       RID_M + RID_TAB_COLORPALETTE.sIconName);

            break;

        case OBJECTTYPE_DATA_LABEL:

        case OBJECTTYPE_DATA_LABELS:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"datalabels"_ustr, TabResId(RID_TAB_CHART_DATALABEL.aLabel), DataLabelsTabPage::Create,

                       RID_M + RID_TAB_CHART_DATALABEL.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            if( SvtCJKOptions::IsAsianTypographyEnabled() )

                AddTabPage(u"asian"_ustr, TabResId(RID_TAB_ASIANTYPO.aLabel), RID_SVXPAGE_PARA_ASIAN,

                           RID_M + RID_TAB_ASIANTYPO.sIconName);

            break;

        case OBJECTTYPE_AXIS:

        {

            if (m_rParameter.HasScaleProperties())

            {

                AddTabPage(u"scale"_ustr, TabResId(RID_TAB_CHART_SCALE.aLabel), ScaleTabPage::Create,

                           RID_M + RID_TAB_CHART_SCALE.sIconName);

                //no positioning page for z axes so far as the tickmarks are not shown so far

                AddTabPage(u"axispos"_ustr, TabResId(RID_TAB_CHART_POSITIONING.aLabel), AxisPositionsTabPage::Create,

                           RID_M + RID_TAB_CHART_POSITIONING.sIconName);

            }

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"axislabel"_ustr, TabResId(RID_TAB_CHART_AXISLABEL.aLabel), SchAxisLabelTabPage::Create,

                       RID_M + RID_TAB_CHART_AXISLABEL.sIconName);

            if (m_rParameter.HasNumberProperties())

                AddTabPage(u"numberformat"_ustr, TabResId(RID_TAB_NUMBERS.aLabel), RID_SVXPAGE_NUMBERFORMAT,

                           RID_M + RID_TAB_NUMBERS.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            if( SvtCJKOptions::IsAsianTypographyEnabled() )

                AddTabPage(u"asian"_ustr, TabResId(RID_TAB_ASIANTYPO.aLabel), RID_SVXPAGE_PARA_ASIAN,

                           RID_M + RID_TAB_ASIANTYPO.sIconName);

            break;

        }

        case OBJECTTYPE_DATA_ERRORS_X:

            AddTabPage(u"xerrorbar"_ustr, TabResId(RID_TAB_CHART_ERROR_X.aLabel), ErrorBarsTabPage::Create,

                       RID_M  + RID_TAB_CHART_ERROR_X.sIconName);

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_LINE.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_LINE.sIconName);

            break;

        case OBJECTTYPE_DATA_ERRORS_Y:

            AddTabPage(u"yerrorbar"_ustr, TabResId(RID_TAB_CHART_ERROR_Y.aLabel), ErrorBarsTabPage::Create,

                       RID_M  + RID_TAB_CHART_ERROR_Y.sIconName);

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_LINE.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_LINE.sIconName);

            break;

        case OBJECTTYPE_DATA_ERRORS_Z:

            break;

        case OBJECTTYPE_GRID:

        case OBJECTTYPE_SUBGRID:

        case OBJECTTYPE_DATA_AVERAGE_LINE:

        case OBJECTTYPE_DATA_STOCK_RANGE:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_LINE.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_LINE.sIconName);

            break;

        case OBJECTTYPE_DATA_CURVE:

            AddTabPage(u"trendline"_ustr, TabResId(RID_TAB_CHART_TREND.aLabel), TrendlineTabPage::Create,

                       RID_M + RID_TAB_CHART_TREND.sIconName);

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_LINE.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_LINE.sIconName);

            break;

        case OBJECTTYPE_DATA_STOCK_LOSS:

        case OBJECTTYPE_DATA_STOCK_GAIN:

        case OBJECTTYPE_PAGE:

        case OBJECTTYPE_DIAGRAM_FLOOR:

        case OBJECTTYPE_DIAGRAM_WALL:

        case OBJECTTYPE_DIAGRAM:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                       RID_M + RID_TAB_AREA.sIconName);

            AddTabPage(u"transparent"_ustr, TabResId(RID_TAB_TRANSPARENCE.aLabel), RID_SVXPAGE_TRANSPARENCE,

                       RID_M + RID_TAB_TRANSPARENCE.sIconName);

            if (eType != OBJECTTYPE_DATA_STOCK_LOSS && eType != OBJECTTYPE_DATA_STOCK_GAIN)

                AddTabPage(u"colorpalette"_ustr, TabResId(RID_TAB_COLORPALETTE.aLabel), ChartColorPaletteTabPage::Create,

                           RID_M + RID_TAB_COLORPALETTE.sIconName);

            break;

        case OBJECTTYPE_LEGEND_ENTRY:

        case OBJECTTYPE_AXIS_UNITLABEL:

        case OBJECTTYPE_UNKNOWN:

            // nothing

            break;

        case OBJECTTYPE_DATA_TABLE:

            AddTabPage(u"datatable"_ustr, TabResId(RID_TAB_CHART_TABLE.aLabel), DataTableTabPage::Create,

                       RID_M + RID_TAB_CHART_TABLE.sIconName);

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                       RID_M + RID_TAB_AREA.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            break;

        case OBJECTTYPE_DATA_CURVE_EQUATION:

            AddTabPage(u"border"_ustr, TabResId(RID_TAB_BORDER.aLabel), RID_SVXPAGE_LINE,

                       RID_M + RID_TAB_BORDER.sIconName);

            AddTabPage(u"area"_ustr, TabResId(RID_TAB_AREA.aLabel), RID_SVXPAGE_AREA,

                       RID_M + RID_TAB_AREA.sIconName);

            AddTabPage(u"transparent"_ustr, TabResId(RID_TAB_TRANSPARENCE.aLabel), RID_SVXPAGE_TRANSPARENCE,

                       RID_M + RID_TAB_TRANSPARENCE.sIconName);

            AddTabPage(u"fontname"_ustr, TabResId(RID_TAB_FONT.aLabel), RID_SVXPAGE_CHAR_NAME,

                       RID_M + RID_TAB_FONT.sIconName);

            AddTabPage(u"effects"_ustr, TabResId(RID_TAB_FONTEFFECTS.aLabel), RID_SVXPAGE_CHAR_EFFECTS,

                       RID_M + RID_TAB_FONTEFFECTS.sIconName);

            AddTabPage(u"numberformat"_ustr, TabResId(RID_TAB_NUMBERS.aLabel), RID_SVXPAGE_NUMBERFORMAT,

                           RID_M + RID_TAB_NUMBERS.sIconName);

            if (SvtCTLOptions::IsCTLFontEnabled())

            {

                /*  When rotation is supported for equation text boxes, use

                    SchAlignmentTabPage::Create here. The special

                    SchAlignmentTabPage::CreateWithoutRotation can be deleted. */

                AddTabPage(u"alignment"_ustr, TabResId(RID_TAB_ALIGNMENT.aLabel), SchAlignmentTabPage::CreateWithoutRotation,

                           RID_M + RID_TAB_ALIGNMENT.sIconName);

            }

            break;

        default:

            break;

    }

    // used to find out if user left the dialog with OK. When OK is pressed but

    // no changes were done, Cancel is returned by the SfxTabDialog. See method

    // DialogWasClosedWithOK.

    GetOKButton().connect_clicked(LINK(this, SchAttribTabDlg, OKPressed));

}

SchAttribTabDlg::~SchAttribTabDlg()

{

}

void SchAttribTabDlg::PageCreated(const OUString& rId, SfxTabPage &rPage)

{

    SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool()));

    if (rId == "border")

    {

        aSet.Put (SvxColorListItem(m_pViewElementListProvider->GetColorTable(),SID_COLOR_TABLE));

        aSet.Put (SvxDashListItem(m_pViewElementListProvider->GetDashList(),SID_DASH_LIST));

        aSet.Put (SvxLineEndListItem(m_pViewElementListProvider->GetLineEndList(),SID_LINEEND_LIST));

        aSet.Put (SfxUInt16Item(SID_PAGE_TYPE,0));

        aSet.Put (SfxUInt16Item(SID_DLG_TYPE,nNoArrowNoShadowDlg));

        if (m_rParameter.HasSymbolProperties())

        {

            aSet.Put(OfaPtrItem(SID_OBJECT_LIST,m_pViewElementListProvider->GetSymbolList()));

            if( m_oSymbolShapeProperties )

                aSet.Put(SfxTabDialogItem(SID_ATTR_SET, *m_oSymbolShapeProperties));

            if( m_oAutoSymbolGraphic )

                aSet.Put(SvxGraphicItem(*m_oAutoSymbolGraphic));

        }

        rPage.PageCreated(aSet);

    }

    else if (rId == "area")

    {

        aSet.Put(SvxColorListItem(m_pViewElementListProvider->GetColorTable(),SID_COLOR_TABLE));

        aSet.Put(SvxGradientListItem(m_pViewElementListProvider->GetGradientList(),SID_GRADIENT_LIST));

        aSet.Put(SvxHatchListItem(m_pViewElementListProvider->GetHatchList(),SID_HATCH_LIST));

        aSet.Put(SvxBitmapListItem(m_pViewElementListProvider->GetBitmapList(),SID_BITMAP_LIST));

        aSet.Put(SvxPatternListItem(m_pViewElementListProvider->GetPatternList(),SID_PATTERN_LIST));

        aSet.Put(SfxUInt16Item(SID_PAGE_TYPE,0));

        aSet.Put(SfxUInt16Item(SID_DLG_TYPE,nNoArrowNoShadowDlg));

        rPage.PageCreated(aSet);

    }

    else if (rId == "transparent")

    {

        aSet.Put (SfxUInt16Item(SID_PAGE_TYPE,0));

        aSet.Put (SfxUInt16Item(SID_DLG_TYPE,nNoArrowNoShadowDlg));

        rPage.PageCreated(aSet);

    }

    else if (rId == "fontname")

    {

        aSet.Put (SvxFontListItem(m_pViewElementListProvider->getFontList(), SID_ATTR_CHAR_FONTLIST));

        rPage.PageCreated(aSet);

    }

    else if (rId == "effects")

    {

        aSet.Put (SfxUInt16Item(SID_DISABLE_CTL,DISABLE_CASEMAP));

        rPage.PageCreated(aSet);

    }

    else if (rId == "axislabel")

    {

        bool bShowStaggeringControls = m_rParameter.CanAxisLabelsBeStaggered();

        auto & rLabelPage = static_cast<SchAxisLabelTabPage&>(rPage);

        rLabelPage.ShowStaggeringControls( bShowStaggeringControls );

        rLabelPage.SetComplexCategories(m_rParameter.IsComplexCategoriesAxis());

    }

    else if (rId == "axispos")

    {

        AxisPositionsTabPage* pPage = dynamic_cast< AxisPositionsTabPage* >( &rPage );

        if(pPage)

        {

            pPage->SetNumFormatter( m_pNumberFormatter );

            if (m_rParameter.IsCrossingAxisIsCategoryAxis())

            {

                pPage->SetCrossingAxisIsCategoryAxis(m_rParameter.IsCrossingAxisIsCategoryAxis());

                pPage->SetCategories(m_rParameter.GetCategories());

            }

            pPage->SupportAxisPositioning(m_rParameter.IsSupportingAxisPositioning());

            pPage->SupportCategoryPositioning(m_rParameter.IsSupportingCategoryPositioning());

        }

    }

    else if (rId == "scale")

    {

        ScaleTabPage* pScaleTabPage = dynamic_cast< ScaleTabPage* >( &rPage );

        if(pScaleTabPage)

        {

            pScaleTabPage->SetNumFormatter( m_pNumberFormatter );

            pScaleTabPage->ShowAxisOrigin(m_rParameter.ShowAxisOrigin());

        }

    }

    else if (rId == "datalabels")

    {

        DataLabelsTabPage* pLabelPage = dynamic_cast< DataLabelsTabPage* >( &rPage );

        if( pLabelPage )

            pLabelPage->SetNumberFormatter( m_pNumberFormatter );

    }

    else if (rId == "numberformat")

    {

        aSet.Put (SvxNumberInfoItem( m_pNumberFormatter, SID_ATTR_NUMBERFORMAT_INFO));

        rPage.PageCreated(aSet);

    }

    else if (rId == "xerrorbar")

    {

        ErrorBarsTabPage * pTabPage = dynamic_cast< ErrorBarsTabPage * >( &rPage );

        OSL_ASSERT( pTabPage );

        if( pTabPage )

        {

            pTabPage->SetAxisMinorStepWidthForErrorBarDecimals( m_fAxisMinorStepWidthForErrorBarDecimals );

            pTabPage->SetErrorBarType( ErrorBarResources::ERROR_BAR_X );

            pTabPage->SetChartDocumentForRangeChoosing(m_rParameter.getDocument());

        }

    }

    else if (rId == "yerrorbar")

    {

        ErrorBarsTabPage * pTabPage = dynamic_cast< ErrorBarsTabPage * >( &rPage );

        OSL_ASSERT( pTabPage );

        if( pTabPage )

        {

            pTabPage->SetAxisMinorStepWidthForErrorBarDecimals( m_fAxisMinorStepWidthForErrorBarDecimals );

            pTabPage->SetErrorBarType( ErrorBarResources::ERROR_BAR_Y );

            pTabPage->SetChartDocumentForRangeChoosing(m_rParameter.getDocument());

        }

    }

    else if (rId == "options")

    {

        SchOptionTabPage* pTabPage = dynamic_cast< SchOptionTabPage* >( &rPage );

        if (pTabPage)

            pTabPage->Init(m_rParameter.ProvidesSecondaryYAxis(),

                           m_rParameter.ProvidesOverlapAndGapWidth(),

                           m_rParameter.ProvidesBarConnectors());

    }

    else if (rId == "trendline")

    {

        TrendlineTabPage* pTrendlineTabPage = dynamic_cast< TrendlineTabPage* >( &rPage );

        if(pTrendlineTabPage)

        {

            pTrendlineTabPage->SetNumFormatter( m_pNumberFormatter );

            pTrendlineTabPage->SetNbPoints(m_rParameter.getNbPoints());

        }

    }

    else if (rId == "colorpalette")

    {

        auto* pColorPaletteTabPage = dynamic_cast<ChartColorPaletteTabPage*>( &rPage );

        if (pColorPaletteTabPage)

        {

            pColorPaletteTabPage->init(m_rParameter.getDocument());

        }

    }

}

IMPL_LINK(SchAttribTabDlg, OKPressed, weld::Button&, rButton, void)

{

    m_bOKPressed = true;

    OkHdl(rButton);

}

} //namespace chart

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