/* -*- 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 <sal/config.h>

#include <algorithm>

#include <memory>

#include <condformatuno.hxx>

#include <document.hxx>

#include <conditio.hxx>

#include <colorscale.hxx>

#include <docsh.hxx>

#include <compiler.hxx>

#include <tokenarray.hxx>

#include <cellsuno.hxx>

#include <convuno.hxx>

#include <o3tl/safeint.hxx>

#include <utility>

#include <vcl/svapp.hxx>

#include <rtl/ustring.hxx>

#include <sal/log.hxx>

#include <com/sun/star/sheet/DataBarAxis.hpp>

#include <com/sun/star/sheet/IconSetType.hpp>

#include <com/sun/star/sheet/ConditionFormatOperator.hpp>

#include <com/sun/star/sheet/DataBarEntryType.hpp>

#include <com/sun/star/sheet/ColorScaleEntryType.hpp>

#include <com/sun/star/sheet/IconSetFormatEntry.hpp>

#include <com/sun/star/sheet/ConditionEntryType.hpp>

#include <com/sun/star/sheet/DateType.hpp>

namespace {

enum CondFormatProperties

{

    ID,

    CondFormat_Range

};

std::span<const SfxItemPropertyMapEntry> getCondFormatPropset()

{

    static const SfxItemPropertyMapEntry aCondFormatPropertyMap_Impl[] =

    {

        {u"ID"_ustr, ID, cppu::UnoType<sal_Int32>::get(), 0, 0},

        {u"Range"_ustr, CondFormat_Range, cppu::UnoType<sheet::XSheetCellRanges>::get(), 0, 0},

    };

    return aCondFormatPropertyMap_Impl;

}

enum ConditionEntryProperties

{

    StyleName,

    Formula1,

    Formula2,

    Operator

};

std::span<const SfxItemPropertyMapEntry> getConditionEntryrPropSet()

{

    static const SfxItemPropertyMapEntry aConditionEntryPropertyMap_Impl[] =

    {

        {u"StyleName"_ustr, StyleName, cppu::UnoType<OUString>::get(), 0, 0},

        {u"Formula1"_ustr, Formula1, cppu::UnoType<OUString>::get(), 0, 0},

        {u"Formula2"_ustr, Formula2, cppu::UnoType<OUString>::get(), 0, 0},

        {u"Operator"_ustr, Operator, cppu::UnoType<decltype(sheet::ConditionFormatOperator::EQUAL)>::get(), 0, 0 },

    };

    return aConditionEntryPropertyMap_Impl;

}

struct ConditionEntryApiMap

{

    ScConditionMode eMode;

    sal_Int32 nApiMode;

};

ConditionEntryApiMap const aConditionEntryMap[] =

{

    {ScConditionMode::Equal, sheet::ConditionFormatOperator::EQUAL},

    {ScConditionMode::Less, sheet::ConditionFormatOperator::LESS},

    {ScConditionMode::Greater, sheet::ConditionFormatOperator::GREATER},

    {ScConditionMode::EqLess, sheet::ConditionFormatOperator::LESS_EQUAL},

    {ScConditionMode::EqGreater, sheet::ConditionFormatOperator::GREATER_EQUAL},

    {ScConditionMode::NotEqual, sheet::ConditionFormatOperator::NOT_EQUAL},

    {ScConditionMode::Between, sheet::ConditionFormatOperator::BETWEEN},

    {ScConditionMode::NotBetween, sheet::ConditionFormatOperator::NOT_BETWEEN},

    {ScConditionMode::Duplicate, sheet::ConditionFormatOperator::DUPLICATE},

    {ScConditionMode::NotDuplicate, sheet::ConditionFormatOperator::UNIQUE},

    {ScConditionMode::Direct, sheet::ConditionFormatOperator::EXPRESSION},

    {ScConditionMode::Top10, sheet::ConditionFormatOperator::TOP_N_ELEMENTS},

    {ScConditionMode::Bottom10, sheet::ConditionFormatOperator::BOTTOM_N_ELEMENTS},

    {ScConditionMode::TopPercent, sheet::ConditionFormatOperator::TOP_N_PERCENT},

    {ScConditionMode::BottomPercent, sheet::ConditionFormatOperator::BOTTOM_N_PERCENT},

    {ScConditionMode::AboveAverage, sheet::ConditionFormatOperator::ABOVE_AVERAGE},

    {ScConditionMode::BelowAverage, sheet::ConditionFormatOperator::BELOW_AVERAGE},

    {ScConditionMode::AboveEqualAverage, sheet::ConditionFormatOperator::ABOVE_EQUAL_AVERAGE},

    {ScConditionMode::BelowEqualAverage, sheet::ConditionFormatOperator::BELOW_EQUAL_AVERAGE},

    {ScConditionMode::Error, sheet::ConditionFormatOperator::ERROR},

    {ScConditionMode::NoError, sheet::ConditionFormatOperator::NO_ERROR},

    {ScConditionMode::BeginsWith, sheet::ConditionFormatOperator::BEGINS_WITH},

    {ScConditionMode::EndsWith, sheet::ConditionFormatOperator::ENDS_WITH},

    {ScConditionMode::ContainsText, sheet::ConditionFormatOperator::CONTAINS},

    {ScConditionMode::NotContainsText, sheet::ConditionFormatOperator::NOT_CONTAINS},

    {ScConditionMode::NONE, sheet::ConditionFormatOperator::EQUAL},

};

enum ColorScaleProperties

{

    ColorScaleEntries

};

std::span<const SfxItemPropertyMapEntry> getColorScalePropSet()

{

    static const SfxItemPropertyMapEntry aColorScalePropertyMap_Impl[] =

    {

        {u"ColorScaleEntries"_ustr, ColorScaleEntries, cppu::UnoType<uno::Sequence< sheet::XColorScaleEntry >>::get(), 0, 0 },

    };

    return aColorScalePropertyMap_Impl;

}

struct ColorScaleEntryTypeApiMap

{

    ScColorScaleEntryType eType;

    sal_Int32 nApiType;

};

ColorScaleEntryTypeApiMap const aColorScaleEntryTypeMap[] =

{

    { COLORSCALE_MIN, sheet::ColorScaleEntryType::COLORSCALE_MIN },

    { COLORSCALE_MAX, sheet::ColorScaleEntryType::COLORSCALE_MAX },

    { COLORSCALE_VALUE, sheet::ColorScaleEntryType::COLORSCALE_VALUE },

    { COLORSCALE_FORMULA, sheet::ColorScaleEntryType::COLORSCALE_FORMULA },

    { COLORSCALE_PERCENT, sheet::ColorScaleEntryType::COLORSCALE_PERCENT },

    { COLORSCALE_PERCENTILE, sheet::ColorScaleEntryType::COLORSCALE_PERCENTILE }

};

enum DataBarProperties

{

    AxisPosition,

    UseGradient,

    UseNegativeColor,

    DataBar_ShowValue,

    DataBar_Color,

    AxisColor,

    NegativeColor,

    DataBarEntries,

    MinimumLength,

    MaximumLength

};

std::span<const SfxItemPropertyMapEntry> getDataBarPropSet()

{

    static const SfxItemPropertyMapEntry aDataBarPropertyMap_Impl[] =

    {

        {u"AxisPosition"_ustr, AxisPosition, cppu::UnoType<decltype(sheet::DataBarAxis::AXIS_AUTOMATIC)>::get(), 0, 0 },

        {u"UseGradient"_ustr, UseGradient, cppu::UnoType<bool>::get(), 0, 0 },

        {u"UseNegativeColor"_ustr, UseNegativeColor, cppu::UnoType<bool>::get(), 0, 0 },

        {u"ShowValue"_ustr, DataBar_ShowValue, cppu::UnoType<bool>::get(), 0, 0 },

        {u"Color"_ustr, DataBar_Color, cppu::UnoType<sal_Int32>::get(), 0, 0},

        {u"AxisColor"_ustr, AxisColor, cppu::UnoType<sal_Int32>::get(), 0, 0},

        {u"NegativeColor"_ustr, NegativeColor, cppu::UnoType<sal_Int32>::get(), 0, 0},

        {u"DataBarEntries"_ustr, DataBarEntries, cppu::UnoType<uno::Sequence< sheet::XDataBarEntry >>::get(), 0, 0 },

        {u"MinimumLength"_ustr, MinimumLength, cppu::UnoType<double>::get(), 0, 0 },

        {u"MaximumLength"_ustr, MaximumLength, cppu::UnoType<double>::get(), 0, 0 },

    };

    return aDataBarPropertyMap_Impl;

}

struct DataBarAxisApiMap

{

    databar::ScAxisPosition ePos;

    sal_Int32 nApiPos;

};

DataBarAxisApiMap const aDataBarAxisMap[] =

{

    { databar::NONE, sheet::DataBarAxis::AXIS_NONE },

    { databar::AUTOMATIC, sheet::DataBarAxis::AXIS_AUTOMATIC },

    { databar::MIDDLE, sheet::DataBarAxis::AXIS_MIDDLE }

};

struct DataBarEntryTypeApiMap

{

    ScColorScaleEntryType eType;

    sal_Int32 nApiType;

};

DataBarEntryTypeApiMap const aDataBarEntryTypeMap[] =

{

    { COLORSCALE_AUTO, sheet::DataBarEntryType::DATABAR_AUTO },

    { COLORSCALE_MIN, sheet::DataBarEntryType::DATABAR_MIN },

    { COLORSCALE_MAX, sheet::DataBarEntryType::DATABAR_MAX },

    { COLORSCALE_VALUE, sheet::DataBarEntryType::DATABAR_VALUE },

    { COLORSCALE_FORMULA, sheet::DataBarEntryType::DATABAR_FORMULA },

    { COLORSCALE_PERCENT, sheet::DataBarEntryType::DATABAR_PERCENT },

    { COLORSCALE_PERCENTILE, sheet::DataBarEntryType::DATABAR_PERCENTILE }

};

enum IconSetProperties

{

    Icons,

    Reverse,

    ShowValue,

    IconSetEntries

};

std::span<const SfxItemPropertyMapEntry> getIconSetPropSet()

{

    static const SfxItemPropertyMapEntry aIconSetPropertyMap_Impl[] =

    {

        {u"Icons"_ustr, Icons, cppu::UnoType<decltype(sheet::IconSetType::ICONSET_3SYMBOLS)>::get(), 0, 0 },

        {u"Reverse"_ustr, Reverse, cppu::UnoType<bool>::get(), 0, 0 },

        {u"ShowValue"_ustr, ShowValue, cppu::UnoType<bool>::get(), 0, 0 },

        {u"IconSetEntries"_ustr, IconSetEntries, cppu::UnoType<uno::Sequence< sheet::XIconSetEntry >>::get(), 0, 0 },

    };

    return aIconSetPropertyMap_Impl;

}

struct IconSetTypeApiMap

{

    ScIconSetType eType;

    sal_Int32 nApiType;

};

const IconSetTypeApiMap aIconSetApiMap[] =

{

    { IconSet_3Arrows, sheet::IconSetType::ICONSET_3ARROWS },

    { IconSet_3ArrowsGray, sheet::IconSetType::ICONSET_3ARROWS_GRAY },

    { IconSet_3Flags, sheet::IconSetType::ICONSET_3FLAGS },

    { IconSet_3TrafficLights1, sheet::IconSetType::ICONSET_3TRAFFICLIGHTS1 },

    { IconSet_3TrafficLights2, sheet::IconSetType::ICONSET_3TRAFFICLIGHTS2 },

    { IconSet_3Signs, sheet::IconSetType::ICONSET_3SIGNS },

    { IconSet_3Symbols, sheet::IconSetType::ICONSET_3SYMBOLS },

    { IconSet_3Symbols2, sheet::IconSetType::ICONSET_3SYMBOLS2 },

    { IconSet_3Smilies, sheet::IconSetType::ICONSET_3SMILIES },

    { IconSet_3ColorSmilies, sheet::IconSetType::ICONSET_3COLOR_SIMILIES },

    { IconSet_4Arrows, sheet::IconSetType::ICONSET_4ARROWS },

    { IconSet_4ArrowsGray, sheet::IconSetType::ICONSET_4ARROWS_GRAY },

    { IconSet_4Rating, sheet::IconSetType::ICONSET_4RATING },

    { IconSet_4RedToBlack, sheet::IconSetType::ICONSET_4RED_TO_BLACK },

    { IconSet_4TrafficLights, sheet::IconSetType::ICONSET_4TRAFFICLIGHTS },

    { IconSet_5Arrows, sheet::IconSetType::ICONSET_5ARROWS },

    { IconSet_5ArrowsGray, sheet::IconSetType::ICONSET_4ARROWS_GRAY },

    { IconSet_5Ratings, sheet::IconSetType::ICONSET_5RATINGS },

    { IconSet_5Quarters, sheet::IconSetType::ICONSET_5QUARTERS },

};

struct IconSetEntryTypeApiMap

{

    ScColorScaleEntryType eType;

    sal_Int32 nApiType;

};

IconSetEntryTypeApiMap const aIconSetEntryTypeMap[] =

{

    { COLORSCALE_MIN, sheet::IconSetFormatEntry::ICONSET_MIN },

    { COLORSCALE_VALUE, sheet::IconSetFormatEntry::ICONSET_VALUE },

    { COLORSCALE_FORMULA, sheet::IconSetFormatEntry::ICONSET_FORMULA },

    { COLORSCALE_PERCENT, sheet::IconSetFormatEntry::ICONSET_PERCENT },

    { COLORSCALE_PERCENTILE, sheet::IconSetFormatEntry::ICONSET_PERCENTILE }

};

enum DateProperties

{

    Date_StyleName,

    DateType

};

std::span<const SfxItemPropertyMapEntry> getCondDatePropSet()

{

    static const SfxItemPropertyMapEntry aCondDatePropertyMap_Impl[] =

    {

        {u"StyleName"_ustr, StyleName, cppu::UnoType<OUString>::get(), 0, 0},

        {u"DateType"_ustr, Icons, cppu::UnoType<decltype(sheet::DateType::TODAY)>::get(), 0, 0 },

    };

    return aCondDatePropertyMap_Impl;

}

struct DateTypeApiMap

{

    condformat::ScCondFormatDateType eType;

    sal_Int32 nApiType;

};

DateTypeApiMap const aDateTypeApiMap[] =

{

    { condformat::TODAY, sheet::DateType::TODAY },

    { condformat::YESTERDAY, sheet::DateType::YESTERDAY },

    { condformat::TOMORROW, sheet::DateType::TOMORROW },

    { condformat::LAST7DAYS, sheet::DateType::LAST7DAYS },

    { condformat::THISWEEK, sheet::DateType::THISWEEK },

    { condformat::LASTWEEK, sheet::DateType::LASTWEEK },

    { condformat::NEXTWEEK, sheet::DateType::NEXTWEEK },

    { condformat::THISMONTH, sheet::DateType::THISMONTH },

    { condformat::LASTMONTH, sheet::DateType::LASTMONTH },

    { condformat::NEXTMONTH, sheet::DateType::NEXTMONTH },

    { condformat::THISYEAR, sheet::DateType::THISYEAR },

    { condformat::LASTYEAR, sheet::DateType::LASTYEAR },

    { condformat::NEXTYEAR, sheet::DateType::NEXTYEAR }

};

}

ScCondFormatsObj::ScCondFormatsObj(ScDocShell* pDocShell, SCTAB nTab):

    mnTab(nTab),

    mpDocShell(pDocShell)

{

    pDocShell->GetDocument().AddUnoObject(*this);

}

ScCondFormatsObj::~ScCondFormatsObj()

{

    SolarMutexGuard aGuard;

    if (mpDocShell)

        mpDocShell->GetDocument().RemoveUnoObject(*this);

}

void ScCondFormatsObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)

{

    if ( rHint.GetId() == SfxHintId::Dying )

    {

        mpDocShell = nullptr;

    }

}

sal_Int32 ScCondFormatsObj::createByRange(const uno::Reference< sheet::XSheetCellRanges >& xRanges)

{

    SolarMutexGuard aGuard;

    if (!mpDocShell)

        throw lang::IllegalArgumentException();

    if (!xRanges.is())

        throw lang::IllegalArgumentException();

    const uno::Sequence<table::CellRangeAddress> aRanges =

        xRanges->getRangeAddresses();

    ScRangeList aCoreRange;

    for (const auto& rRange : aRanges)

    {

        ScRange aRange;

        ScUnoConversion::FillScRange(aRange, rRange);

        aCoreRange.Join(aRange);

    }

    if (aCoreRange.empty())

        throw lang::IllegalArgumentException();

    SCTAB nTab = aCoreRange[0].aStart.Tab();

    auto pNewFormat = std::make_unique<ScConditionalFormat>(0, mpDocShell->GetDocument());

    pNewFormat->SetRange(aCoreRange);

    ScDocument& rDoc = mpDocShell->GetDocument();

    sal_Int32 nIndex = rDoc.AddCondFormat(std::move(pNewFormat), nTab);

    rDoc.AddCondFormatData(aCoreRange, nTab, nIndex);

    return nIndex;

}

void ScCondFormatsObj::removeByID(const sal_Int32 nID)

{

    SolarMutexGuard aGuard;

    ScConditionalFormatList* pFormatList = getCoreObject();

    pFormatList->erase(nID);

}

uno::Sequence<uno::Reference<sheet::XConditionalFormat> > ScCondFormatsObj::getConditionalFormats()

{

    SolarMutexGuard aGuard;

    ScConditionalFormatList* pFormatList = getCoreObject();

    size_t n = pFormatList->size();

    uno::Sequence<uno::Reference<sheet::XConditionalFormat> > aCondFormats(n);

    std::transform(pFormatList->begin(), pFormatList->end(), aCondFormats.getArray(),

                   [this](const auto& rFormat)

                   { return uno::Reference(new ScCondFormatObj(mpDocShell, this, rFormat->GetKey())); });

    return aCondFormats;

}

sal_Int32 ScCondFormatsObj::getLength()

{

    SolarMutexGuard aGuard;

    ScConditionalFormatList* pFormatList = getCoreObject();

    return pFormatList->size();

}

ScConditionalFormatList* ScCondFormatsObj::getCoreObject()

{

    if (!mpDocShell)

        throw uno::RuntimeException();

    ScConditionalFormatList* pList = mpDocShell->GetDocument().GetCondFormList(mnTab);

    if (!pList)

        throw uno::RuntimeException();

    return pList;

}

namespace {

uno::Reference<beans::XPropertySet> createConditionEntry(const ScFormatEntry* pEntry,

        rtl::Reference<ScCondFormatObj> const & xParent)

{

    switch (pEntry->GetType())

    {

        case ScFormatEntry::Type::Condition:

        case ScFormatEntry::Type::ExtCondition:

            return new ScConditionEntryObj(xParent,

                    static_cast<const ScCondFormatEntry*>(pEntry));

        break;

        case ScFormatEntry::Type::Colorscale:

            return new ScColorScaleFormatObj(xParent,

                    static_cast<const ScColorScaleFormat*>(pEntry));

        break;

        case ScFormatEntry::Type::Databar:

            return new ScDataBarFormatObj(xParent,

                    static_cast<const ScDataBarFormat*>(pEntry));

        break;

        case ScFormatEntry::Type::Iconset:

            return new ScIconSetFormatObj(xParent,

                    static_cast<const ScIconSetFormat*>(pEntry));

        break;

        case ScFormatEntry::Type::Date:

            return new ScCondDateFormatObj(xParent,

                    static_cast<const ScCondDateFormatEntry*>(pEntry));

        break;

        default:

        break;

    }

    return uno::Reference<beans::XPropertySet>();

}

}

ScCondFormatObj::ScCondFormatObj(ScDocShell* pDocShell, rtl::Reference<ScCondFormatsObj> xCondFormats,

        sal_Int32 nKey):

    mxCondFormatList(std::move(xCondFormats)),

    mpDocShell(pDocShell),

    maPropSet(getCondFormatPropset()),

    mnKey(nKey)

{

}

ScCondFormatObj::~ScCondFormatObj()

{

}

ScConditionalFormat* ScCondFormatObj::getCoreObject()

{

    ScConditionalFormatList* pList = mxCondFormatList->getCoreObject();

    ScConditionalFormat* pFormat = pList->GetFormat(mnKey);

    if (!pFormat)

        throw uno::RuntimeException();

    return pFormat;

}

ScDocShell* ScCondFormatObj::getDocShell()

{

    return mpDocShell;

}

namespace

{

ScColorScaleFormat* createColorScaleFormat(ScDocument& rDoc, size_t nEntries)

{

    ScColorScaleFormat* pNewEntry = new ScColorScaleFormat(rDoc);

    for (size_t i = 0; i < nEntries; ++i)

        pNewEntry->AddEntry(new ScColorScaleEntry);

    pNewEntry->EnsureSize();

    return pNewEntry;

}

}

void ScCondFormatObj::createEntry(const sal_Int32 nType, const sal_Int32 nPos)

{

    SolarMutexGuard aGuard;

    ScConditionalFormat* pFormat = getCoreObject();

    if (nPos > sal_Int32(pFormat->size()))

        throw lang::IllegalArgumentException();

    ScFormatEntry* pNewEntry = nullptr;

    ScDocument& rDoc = mpDocShell->GetDocument();

    switch (nType)

    {

        case sheet::ConditionEntryType::CONDITION:

            pNewEntry = new ScCondFormatEntry(ScConditionMode::Equal, u""_ustr, u""_ustr,

                    rDoc, pFormat->GetRange().GetTopLeftCorner(), u""_ustr);

        break;

        case sheet::ConditionEntryType::COLORSCALE:

            pNewEntry = createColorScaleFormat(rDoc, 0);

        break;

        case sheet::ConditionEntryType::COLORSCALE2:

            pNewEntry = createColorScaleFormat(rDoc, 2);

        break;

        case sheet::ConditionEntryType::COLORSCALE3:

            pNewEntry = createColorScaleFormat(rDoc, 3);

        break;

        case sheet::ConditionEntryType::DATABAR:

            pNewEntry = new ScDataBarFormat(rDoc);

            static_cast<ScDataBarFormat*>(pNewEntry)->EnsureSize();

        break;

        case sheet::ConditionEntryType::ICONSET:

            pNewEntry = new ScIconSetFormat(rDoc);

            static_cast<ScIconSetFormat*>(pNewEntry)->EnsureSize();

        break;

        case sheet::ConditionEntryType::DATE:

            pNewEntry = new ScCondDateFormatEntry(rDoc);

        break;

        default:

            SAL_WARN("sc", "unknown conditional format type");

            throw lang::IllegalArgumentException();

    }

    pFormat->AddEntry(pNewEntry);

}

void ScCondFormatObj::removeByIndex(const sal_Int32 nIndex)

{

    SolarMutexGuard aGuard;

    if (getCoreObject()->size() >= o3tl::make_unsigned(nIndex))

        throw lang::IllegalArgumentException();

    getCoreObject()->RemoveEntry(nIndex);

}

uno::Type ScCondFormatObj::getElementType()

{

    return cppu::UnoType<beans::XPropertySet>::get();

}

sal_Bool ScCondFormatObj::hasElements()

{

    SolarMutexGuard aGuard;

    ScConditionalFormat* pFormat = getCoreObject();

    return !pFormat->IsEmpty();

}

sal_Int32 ScCondFormatObj::getCount()

{

    SolarMutexGuard aGuard;

    ScConditionalFormat* pFormat = getCoreObject();

    return pFormat->size();

}

uno::Any ScCondFormatObj::getByIndex(sal_Int32 nIndex)

{

    SolarMutexGuard aGuard;

    if (getCoreObject()->size() <= o3tl::make_unsigned(nIndex))

        throw lang::IllegalArgumentException();

    const ScFormatEntry* pEntry = getCoreObject()->GetEntry(nIndex);

    uno::Reference<beans::XPropertySet> xCondEntry =

        createConditionEntry(pEntry, this);

    return uno::Any(xCondEntry);

}

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCondFormatObj::getPropertySetInfo()

{

    SolarMutexGuard aGuard;

    static uno::Reference<beans::XPropertySetInfo> aRef(

        new SfxItemPropertySetInfo( maPropSet.getPropertyMap()));

    return aRef;

}

void SAL_CALL ScCondFormatObj::setPropertyValue(

                        const OUString& aPropertyName, const uno::Any& aValue )

{

    SolarMutexGuard aGuard;

    const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class

    const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );

    if ( !pEntry )

        throw beans::UnknownPropertyException(aPropertyName);

    switch(pEntry->nWID)

    {

        case ID:

            throw lang::IllegalArgumentException();

        break;

        case CondFormat_Range:

        {

            uno::Reference<sheet::XSheetCellRanges> xRange;

            if (aValue >>= xRange)

            {

                ScConditionalFormat* pFormat = getCoreObject();

                const uno::Sequence<table::CellRangeAddress> aRanges =

                    xRange->getRangeAddresses();

                ScRangeList aTargetRange;

                for (const auto& rRange : aRanges)

                {

                    ScRange aRange;

                    ScUnoConversion::FillScRange(aRange, rRange);

                    aTargetRange.Join(aRange);

                }

                pFormat->SetRange(aTargetRange);

            }

        }

        break;

        default:

            SAL_WARN("sc", "unknown property");

    }

}

uno::Any SAL_CALL ScCondFormatObj::getPropertyValue( const OUString& aPropertyName )

{

    SolarMutexGuard aGuard;

    const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class

    const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );

    if ( !pEntry )

        throw beans::UnknownPropertyException(aPropertyName);

    uno::Any aAny;

    switch(pEntry->nWID)

    {

        case ID:

            aAny <<= sal_Int32(getCoreObject()->GetKey());

        break;

        case CondFormat_Range:

        {

            const ScRangeList& rRange = getCoreObject()->GetRange();

            uno::Reference<sheet::XSheetCellRanges> xRange;

            xRange.set(new ScCellRangesObj(mpDocShell, rRange));

            aAny <<= xRange;

        }

        break;

        default:

            SAL_WARN("sc", "unknown property");

    }

    return aAny;

}

void SAL_CALL ScCondFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,

                            const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScCondFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,

                            const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScCondFormatObj::addVetoableChangeListener( const OUString&,

                            const uno::Reference<beans::XVetoableChangeListener>&)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScCondFormatObj::removeVetoableChangeListener( const OUString&,

                            const uno::Reference<beans::XVetoableChangeListener>&)

{

    SAL_WARN("sc", "not implemented");

}

namespace {

bool isObjectStillAlive(const ScConditionalFormat* pFormat, const ScFormatEntry* pEntry)

{

    for(size_t i = 0, n= pFormat->size(); i < n; ++i)

    {

        if (pFormat->GetEntry(i) == pEntry)

            return true;

    }

    return false;

}

}

ScConditionEntryObj::ScConditionEntryObj(rtl::Reference<ScCondFormatObj> const & xParent,

        const ScCondFormatEntry* pFormat):

    mpDocShell(xParent->getDocShell()),

    mxParent(xParent),

    maPropSet(getConditionEntryrPropSet()),

    mpFormat(pFormat)

{

}

ScConditionEntryObj::~ScConditionEntryObj()

{

}

ScCondFormatEntry* ScConditionEntryObj::getCoreObject()

{

    ScConditionalFormat* pFormat = mxParent->getCoreObject();

    if (isObjectStillAlive(pFormat, mpFormat))

        return const_cast<ScCondFormatEntry*>(mpFormat);

    throw lang::IllegalArgumentException();

}

sal_Int32 ScConditionEntryObj::getType()

{

    return sheet::ConditionEntryType::CONDITION;

}

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScConditionEntryObj::getPropertySetInfo()

{

    static uno::Reference<beans::XPropertySetInfo> aRef(

        new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));

    return aRef;

}

void SAL_CALL ScConditionEntryObj::setPropertyValue(

                        const OUString& aPropertyName, const uno::Any& aValue )

{

    SolarMutexGuard aGuard;

    const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class

    const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );

    if ( !pEntry )

        throw beans::UnknownPropertyException(aPropertyName);

    switch(pEntry->nWID)

    {

        case StyleName:

        {

            OUString aStyleName;

            if ((aValue >>= aStyleName) && !aStyleName.isEmpty())

                getCoreObject()->UpdateStyleName(aStyleName);

        }

        break;

        case Formula1:

        {

            OUString aFormula;

            if ((aValue >>= aFormula) && !aFormula.isEmpty())

            {

                ScCompiler aComp(mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());

                aComp.SetGrammar(mpDocShell->GetDocument().GetGrammar());

                std::unique_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));

                getCoreObject()->SetFormula1(*pArr);

            }

        }

        break;

        case Formula2:

        {

            OUString aFormula;

            if ((aValue >>= aFormula) && !aFormula.isEmpty())

            {

                ScCompiler aComp(mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());

                aComp.SetGrammar(mpDocShell->GetDocument().GetGrammar());

                std::unique_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));

                getCoreObject()->SetFormula2(*pArr);

            }

        }

        break;

        case Operator:

        {

            sal_Int32 nVal;

            if (aValue >>= nVal)

            {

                for (ConditionEntryApiMap const & rEntry : aConditionEntryMap)

                {

                    if (rEntry.nApiMode == nVal)

                    {

                        getCoreObject()->SetOperation(rEntry.eMode);

                        break;

                    }

                }

            }

        }

        break;

        default:

            SAL_WARN("sc", "unsupported property");

    }

}

uno::Any SAL_CALL ScConditionEntryObj::getPropertyValue( const OUString& aPropertyName )

{

    SolarMutexGuard aGuard;

    const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class

    const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );

    if ( !pEntry )

        throw beans::UnknownPropertyException(aPropertyName);

    uno::Any aAny;

    switch(pEntry->nWID)

    {

        case StyleName:

            aAny <<= getCoreObject()->GetStyle();

        break;

        case Formula1:

        {

            ScAddress aCursor = getCoreObject()->GetSrcPos();

            OUString aFormula = getCoreObject()->GetExpression(aCursor, 0);

            aAny <<= aFormula;

        }

        break;

        case Formula2:

        {

            ScAddress aCursor = getCoreObject()->GetSrcPos();

            OUString aFormula = getCoreObject()->GetExpression(aCursor, 1);

            aAny <<= aFormula;

        }

        break;

        case Operator:

        {

            ScConditionMode eMode = getCoreObject()->GetOperation();

            for (ConditionEntryApiMap const & rEntry : aConditionEntryMap)

            {

                if (rEntry.eMode == eMode)

                {

                    aAny <<= rEntry.nApiMode;

                    break;

                }

            }

        }

        break;

        default:

            SAL_WARN("sc", "unsupported property");

    }

    return aAny;

}

void SAL_CALL ScConditionEntryObj::addPropertyChangeListener( const OUString& /* aPropertyName */,

                            const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScConditionEntryObj::removePropertyChangeListener( const OUString& /* aPropertyName */,

                            const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScConditionEntryObj::addVetoableChangeListener( const OUString&,

                            const uno::Reference<beans::XVetoableChangeListener>&)

{

    SAL_WARN("sc", "not implemented");

}

void SAL_CALL ScConditionEntryObj::removeVetoableChangeListener( const OUString&,

                            const uno::Reference<beans::XVetoableChangeListener>&)

{

    SAL_WARN("sc", "not implemented");

}

ScColorScaleFormatObj::ScColorScaleFormatObj(rtl::Reference<ScCondFormatObj> xParent,

        const ScColorScaleFormat* pFormat):

    mxParent(std::move(xParent)),

    maPropSet(getColorScalePropSet()),

    mpFormat(pFormat)

{

}

ScColorScaleFormatObj::~ScColorScaleFormatObj()

{

}

ScColorScaleFormat* ScColorScaleFormatObj::getCoreObject()

{

    ScConditionalFormat* pFormat = mxParent->getCoreObject();

    if (isObjectStillAlive(pFormat, mpFormat))

        return const_cast<ScColorScaleFormat*>(mpFormat);

    throw lang::IllegalArgumentException();

}

sal_Int32 ScColorScaleFormatObj::getType()

{

    switch (getCoreObject()->size())

    {

        case 2:

            return sheet::ConditionEntryType::COLORSCALE2;

        case 3:

            return sheet::ConditionEntryType::COLORSCALE3;

        default:

            return sheet::ConditionEntryType::COLORSCALE;

    }

}

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScColorScaleFormatObj::getPropertySetInfo()

{

    static uno::Reference<beans::XPropertySetInfo> aRef(

        new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));

    return aRef;

}

namespace {

void setColorScaleEntry(ScColorScaleEntry* pEntry, uno::Reference<sheet::XColorScaleEntry> const & xEntry)

{

    ScColorScaleEntryType eType = ScColorScaleEntryType();

    sal_Int32 nApiType = xEntry->getType();

    bool bFound = false;

    for (ColorScaleEntryTypeApiMap const & rEntry : aColorScaleEntryTypeMap)

    {

        if (rEntry.nApiType == nApiType)

        {

            eType = rEntry.eType;

            bFound = true;

            break;

        }

    }

    if (!bFound)

        throw lang::IllegalArgumentException();

    pEntry->SetType(eType);

    pEntry->SetColor(Color(ColorTransparency, xEntry->getColor()));

    switch (eType)

    {

        case COLORSCALE_FORMULA:

            // TODO: Implement

        break;

        default:

        {

            double nVal = xEntry->getFormula().toDouble();

            pEntry->SetValue(nVal);

        }

        break;

    }

}

}

void SAL_CALL ScColorScaleFormatObj::setPropertyValue(

                        const OUString& aPropertyName, const uno::Any& aValue )

{

    SolarMutexGuard aGuard;

    const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class

    const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );

    if ( !pEntry )

        throw beans::UnknownPropertyException(aPropertyName);

    switch(pEntry->nWID)

    {

        case ColorScaleEntries:

        {

            uno::Sequence<uno::Reference<sheet::XColorScaleEntry> > aEntries;

            if (!(aValue >>= aEntries))