    /* -*- 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 "vbaformat.hxx"
    #include <ooo/vba/excel/XStyle.hpp>
    #include <ooo/vba/excel/XlVAlign.hpp>
    #include <ooo/vba/excel/XlHAlign.hpp>
    #include <ooo/vba/excel/XlOrientation.hpp>
    #include <ooo/vba/excel/Constants.hpp>
    #include <ooo/vba/excel/XRange.hpp>
    #include <com/sun/star/table/CellVertJustify2.hpp>
    #include <com/sun/star/table/CellHoriJustify.hpp>
    #include <com/sun/star/table/CellOrientation.hpp>
    #include <com/sun/star/table/XCellRange.hpp>
    #include <com/sun/star/text/WritingMode.hpp>
    #include <com/sun/star/util/CellProtection.hpp>

    #include <basic/sberrors.hxx>
    #include <rtl/math.hxx>

    #include "excelvbahelper.hxx"
    #include "vbaborders.hxx"
    #include "vbapalette.hxx"
    #include "vbafont.hxx"
    #include "vbainterior.hxx"

    #include <unonames.hxx>
    #include <cellsuno.hxx>
    #include <scitems.hxx>
    #include <attrib.hxx>

    using namespace ::ooo::vba;
    using namespace ::com::sun::star;

    #define FORMATSTRING "FormatString"
    #define LOCALE "Locale"

    template< typename... Ifc >
    ScVbaFormat< Ifc... >::ScVbaFormat( const uno::Reference< XHelperInterface >& xParent,
                                        const uno::Reference< uno::XComponentContext > & xContext,
                                        const uno::Reference< beans::XPropertySet >& _xPropertySet,
                                        const uno::Reference< frame::XModel >& xModel,
                                        bool bCheckAmbiguoity )
        : ScVbaFormat_BASE( xParent, xContext ),
          m_aDefaultLocale( "en", "US", OUString() ),
          mxPropertySet( _xPropertySet ),
          mxModel( xModel ),
          mbCheckAmbiguoity( bCheckAmbiguoity ),
          mbAddIndent( false )
    {
        try
        {
            if ( !mxModel.is() )
                DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, "XModel Interface could not be retrieved" );
            // mxServiceInfo is unused,
            // mxNumberFormatsSupplier is initialized when needed in initializeNumberFormats.
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setVerticalAlignment( const uno::Any& _oAlignment)
    {
        try
        {
            uno::Any aVal;
            sal_Int32 nAlignment = 0;
            if ( !(_oAlignment >>= nAlignment ))
                throw uno::RuntimeException();
            switch (nAlignment)
            {
                case excel::XlVAlign::xlVAlignBottom :
                    aVal <<= table::CellVertJustify2::BOTTOM;
                    break;
                case excel::XlVAlign::xlVAlignCenter :
                    aVal <<= table::CellVertJustify2::CENTER;
                    break;
                case excel::XlVAlign::xlVAlignDistributed:
                case excel::XlVAlign::xlVAlignJustify:
                    aVal <<= table::CellVertJustify2::STANDARD;
                    break;

                case excel::XlVAlign::xlVAlignTop:
                    aVal <<= table::CellVertJustify2::TOP;
                    break;
                default:
                    aVal <<= table::CellVertJustify2::STANDARD;
                    break;
            }
            mxPropertySet->setPropertyValue( SC_UNONAME_CELLVJUS, aVal );
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getVerticalAlignment(  )
    {
        uno::Any aResult = aNULL();
        try
        {
            if (!isAmbiguous( SC_UNONAME_CELLVJUS ) )
            {
                sal_Int32 aAPIAlignment = table::CellVertJustify2::STANDARD;
                mxPropertySet->getPropertyValue( SC_UNONAME_CELLVJUS ) >>= aAPIAlignment;
                switch( aAPIAlignment )
                {
                    case table::CellVertJustify2::BOTTOM:
                        aResult <<= excel::XlVAlign::xlVAlignBottom;
                        break;
                    case table::CellVertJustify2::CENTER:
                        aResult <<= excel::XlVAlign::xlVAlignCenter;
                        break;
                    case table::CellVertJustify2::STANDARD:
                        aResult <<= excel::XlVAlign::xlVAlignBottom;
                        break;
                    case table::CellVertJustify2::TOP:
                        aResult <<= excel::XlVAlign::xlVAlignTop;
                        break;
                    default:
                        break;
                }
            }
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return aResult;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setHorizontalAlignment( const uno::Any& HorizontalAlignment )
    {
        try
        {
            uno::Any aVal;
            sal_Int32 nAlignment = 0;
            if ( !( HorizontalAlignment >>= nAlignment ) )
                throw uno::RuntimeException();
            switch ( nAlignment )
            {
                case excel::XlHAlign::xlHAlignJustify:
                    aVal <<= table::CellHoriJustify_BLOCK;
                    break;
                case excel::XlHAlign::xlHAlignCenter:
                    aVal <<= table::CellHoriJustify_CENTER;
                    break;
                case excel::XlHAlign::xlHAlignDistributed:
                    aVal <<= table::CellHoriJustify_BLOCK;
                    break;
                case excel::XlHAlign::xlHAlignLeft:
                    aVal <<= table::CellHoriJustify_LEFT;
                    break;
                case excel::XlHAlign::xlHAlignRight:
                    aVal <<= table::CellHoriJustify_RIGHT;
                    break;
            }
            // #FIXME what about the default case above?
            // shouldn't need the test below
            if ( aVal.hasValue() )
                mxPropertySet->setPropertyValue( SC_UNONAME_CELLHJUS, aVal );
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }

    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getHorizontalAlignment(  )
    {
        uno::Any NRetAlignment = aNULL();
        try
        {
            OUString sHoriJust( SC_UNONAME_CELLHJUS );
            if (!isAmbiguous(sHoriJust))
            {
                table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_BLOCK;

                if ( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment )
                {
                    switch( aAPIAlignment )
                    {
                        case table::CellHoriJustify_BLOCK:
                            NRetAlignment <<= excel::XlHAlign::xlHAlignJustify;
                            break;
                        case table::CellHoriJustify_CENTER:
                            NRetAlignment <<= excel::XlHAlign::xlHAlignCenter;
                            break;
                        case table::CellHoriJustify_LEFT:
                            NRetAlignment <<= excel::XlHAlign::xlHAlignLeft;
                            break;
                        case table::CellHoriJustify_RIGHT:
                            NRetAlignment <<= excel::XlHAlign::xlHAlignRight;
                            break;
                         default: // handle those other cases with a NULL return
                            break;
                    }
                }
            }
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
        return NRetAlignment;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setOrientation( const uno::Any& _aOrientation )
    {
        try
        {
            sal_Int32 nOrientation = 0;
            if ( !( _aOrientation >>= nOrientation ) )
                throw uno::RuntimeException();
            uno::Any aVal;
            switch( nOrientation )
            {
                case excel::XlOrientation::xlDownward:
                    aVal <<= table::CellOrientation_TOPBOTTOM;
                    break;
                case excel::XlOrientation::xlHorizontal:
                    aVal <<= table::CellOrientation_STANDARD;
                    mxPropertySet->setPropertyValue( SC_UNONAME_ROTANG, uno::makeAny( sal_Int32(0) ) );
                    break;
                case excel::XlOrientation::xlUpward:
                    aVal <<= table::CellOrientation_BOTTOMTOP;
                    break;
                case excel::XlOrientation::xlVertical:
                    aVal <<= table::CellOrientation_STACKED;
                    break;
            }
            // #FIXME what about the default case above?
            // shouldn't need the test below
            if ( aVal.hasValue() )
                mxPropertySet->setPropertyValue( SC_UNONAME_CELLORI, aVal );

        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }
    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getOrientation(  )
    {
        uno::Any NRetOrientation = aNULL();
        try
        {
            if (!isAmbiguous(SC_UNONAME_CELLORI))
            {
                table::CellOrientation aOrientation = table::CellOrientation_STANDARD;
                if ( !(  mxPropertySet->getPropertyValue( SC_UNONAME_CELLORI ) >>= aOrientation ) )
                    throw uno::RuntimeException();

                switch(aOrientation)
                {
                    case table::CellOrientation_STANDARD:
                        NRetOrientation <<= excel::XlOrientation::xlHorizontal;
                        break;
                    case table::CellOrientation_BOTTOMTOP:
                        NRetOrientation <<= excel::XlOrientation::xlUpward;
                        break;
                    case table::CellOrientation_TOPBOTTOM:
                        NRetOrientation <<= excel::XlOrientation::xlDownward;
                        break;
                    case table::CellOrientation_STACKED:
                        NRetOrientation <<= excel::XlOrientation::xlVertical;
                        break;
                    default:
                        NRetOrientation <<= excel::XlOrientation::xlHorizontal;
                }
            }
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return NRetOrientation;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setWrapText( const uno::Any& _aWrapText )
    {
        try
        {
            mxPropertySet->setPropertyValue( SC_UNONAME_WRAP, _aWrapText);
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getWrapText(  )
    {
        uno::Any aWrap = aNULL();
        try
        {
            OUString aPropName( SC_UNONAME_WRAP );
            if (!isAmbiguous( aPropName ))
            {
                aWrap = mxPropertySet->getPropertyValue(aPropName);
            }
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
        return aWrap;
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::Borders( const uno::Any& Index )
    {
        ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
        uno::Reference< XCollection > xColl =  new ScVbaBorders( thisHelperIface(), ScVbaFormat_BASE::mxContext, uno::Reference< table::XCellRange >( mxPropertySet, uno::UNO_QUERY_THROW ), aPalette );

        if ( Index.hasValue() )
        {
            return xColl->Item( Index, uno::Any() );
        }
        return uno::makeAny( xColl );
    }

    template< typename... Ifc >
    uno::Reference< excel::XFont > SAL_CALL
    ScVbaFormat< Ifc... >::Font(  )
    {
        ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
        return new ScVbaFont( thisHelperIface(), ScVbaFormat_BASE::mxContext, aPalette, mxPropertySet );
    }

    template< typename... Ifc >
    uno::Reference< excel::XInterior > SAL_CALL
    ScVbaFormat< Ifc... >::Interior(  )
    {
        return new ScVbaInterior( thisHelperIface(), ScVbaFormat_BASE::mxContext, mxPropertySet );
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getNumberFormatLocal(  )
    {
        uno::Any aRet = uno::makeAny( OUString() );
        try
        {
            OUString sPropName( SC_UNO_DP_NUMBERFO );
            if (!isAmbiguous( sPropName ))
            {

                initializeNumberFormats();

                sal_Int32 nFormat = 0;
                if ( ! (mxPropertySet->getPropertyValue( sPropName ) >>= nFormat ) )
                    throw uno::RuntimeException();

                OUString sFormat;
                xNumberFormats->getByKey(nFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
                aRet <<= sFormat.toAsciiLowerCase();

            }
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return aRet;

    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setNumberFormatLocal( const uno::Any& _oLocalFormatString )
    {
        try
        {
            OUString sLocalFormatString;
            sal_Int32 nFormat = -1;
            OUString sNumFormat( SC_UNO_DP_NUMBERFO );
            if ( !(_oLocalFormatString >>= sLocalFormatString )
            || !( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat ) )
                throw uno::RuntimeException();

            sLocalFormatString = sLocalFormatString.toAsciiUpperCase();
            initializeNumberFormats();
            lang::Locale aRangeLocale;
            xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
            sal_Int32 nNewFormat = xNumberFormats->queryKey(sLocalFormatString, aRangeLocale, true);

            if (nNewFormat == -1)
                nNewFormat = xNumberFormats->addNew(sLocalFormatString, aRangeLocale);
            mxPropertySet->setPropertyValue(sNumFormat, uno::makeAny( nNewFormat ));
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setNumberFormat( const uno::Any& _oFormatString )
    {
        try
        {
            OUString sFormatString;
            if ( !( _oFormatString >>= sFormatString ) )
                throw uno::RuntimeException();

            sFormatString = sFormatString.toAsciiUpperCase();

            lang::Locale aDefaultLocale = m_aDefaultLocale;
            initializeNumberFormats();
            sal_Int32 nFormat = xNumberFormats->queryKey(sFormatString, aDefaultLocale, true);

            if (nFormat == -1)
                nFormat = xNumberFormats->addNew(sFormatString, aDefaultLocale);

            lang::Locale aRangeLocale;
            xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
            sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, aRangeLocale);
            mxPropertySet->setPropertyValue( SC_UNO_DP_NUMBERFO, uno::makeAny( nNewFormat));
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }

    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setIndentLevel( const uno::Any& _aLevel )
    {
        try
        {
            sal_Int32 nLevel = 0;
            if ( !(_aLevel >>= nLevel ) )
                throw uno::RuntimeException();
            table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_STANDARD;

            OUString sHoriJust( SC_UNONAME_CELLHJUS );
            if ( !( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment ) )
                throw uno::RuntimeException();
            if (aAPIAlignment == table::CellHoriJustify_STANDARD)
                mxPropertySet->setPropertyValue( sHoriJust, uno::makeAny( table::CellHoriJustify_LEFT) ) ;
            mxPropertySet->setPropertyValue( SC_UNONAME_PINDENT, uno::makeAny( sal_Int16(nLevel * 352.8) ) );
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getIndentLevel(  )
    {
        uno::Any NRetIndentLevel = aNULL();
        try
        {
            OUString sParaIndent( SC_UNONAME_PINDENT );
            if (!isAmbiguous(sParaIndent))
            {
                sal_Int16 IndentLevel = 0;
                if ( mxPropertySet->getPropertyValue(sParaIndent) >>= IndentLevel )
                    NRetIndentLevel <<= sal_Int32( rtl::math::round(static_cast<double>( IndentLevel ) / 352.8));
                else
                    NRetIndentLevel <<= sal_Int32(0);
            }
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return NRetIndentLevel;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setLocked( const uno::Any& _aLocked )
    {
        try
        {
            bool bIsLocked = false;
            if ( !( _aLocked >>= bIsLocked ) )
                throw uno::RuntimeException();
            util::CellProtection aCellProtection;
            OUString sCellProt( SC_UNONAME_CELLPRO );
            mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
            aCellProtection.IsLocked = bIsLocked;
            mxPropertySet->setPropertyValue(sCellProt, uno::makeAny( aCellProtection ) );
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setFormulaHidden( const uno::Any& FormulaHidden )
    {
        try
        {
            bool bIsFormulaHidden = false;
            FormulaHidden >>= bIsFormulaHidden;
            util::CellProtection aCellProtection;
            OUString sCellProt( SC_UNONAME_CELLPRO );
            mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
            aCellProtection.IsFormulaHidden = bIsFormulaHidden;
            mxPropertySet->setPropertyValue(sCellProt,uno::makeAny(aCellProtection));
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception( ERRCODE_BASIC_METHOD_FAILED, OUString() );
        }
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getLocked(  )
    {
        uno::Any aCellProtection = aNULL();
        try
        {
            OUString sCellProt( SC_UNONAME_CELLPRO );

            if (!isAmbiguous(sCellProt))
            {
                SfxItemSet* pDataSet = getCurrentDataSet();
                if ( pDataSet )
                {
                    const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
                    SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
                    if(eState != SfxItemState::DONTCARE)
                        aCellProtection <<= rProtAttr.GetProtection();
                }
                else // fallback to propertyset
                {
                    util::CellProtection cellProtection;
                    mxPropertySet->getPropertyValue(sCellProt) >>= cellProtection;
                    aCellProtection <<= cellProtection.IsLocked;
                }
            }
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return aCellProtection;
    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getFormulaHidden(  )
    {
        uno::Any aBoolRet = aNULL();
        try
        {
            OUString sCellProt( SC_UNONAME_CELLPRO );
            if (!isAmbiguous(sCellProt))
            {
                SfxItemSet* pDataSet = getCurrentDataSet();
                if ( pDataSet )
                {
                    const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
                    SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
                    if(eState != SfxItemState::DONTCARE)
                        aBoolRet <<= rProtAttr.GetHideFormula();
                }
                else
                {
                    util::CellProtection aCellProtection;
                    mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
                    aBoolRet <<= aCellProtection.IsFormulaHidden;
                }
            }
        }
        catch (const uno::Exception&)
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return aBoolRet;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setShrinkToFit( const uno::Any& ShrinkToFit )
    {
        try
        {
            mxPropertySet->setPropertyValue( SC_UNONAME_SHRINK_TO_FIT, ShrinkToFit);
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, OUString() );
        }

    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getShrinkToFit(  )
    {
        uno::Any aRet = aNULL();
        try
        {
            OUString sShrinkToFit( SC_UNONAME_SHRINK_TO_FIT );
            if (!isAmbiguous(sShrinkToFit))
                aRet = mxPropertySet->getPropertyValue(sShrinkToFit);
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, OUString());
        }
        return aRet;
    }

    template< typename... Ifc >
    void SAL_CALL
    ScVbaFormat< Ifc... >::setReadingOrder( const uno::Any& ReadingOrder )
    {
        try
        {
            sal_Int32 nReadingOrder = 0;
            if ( !(ReadingOrder >>= nReadingOrder ))
                throw uno::RuntimeException();
            uno::Any aVal = aNULL();
            switch(nReadingOrder)
            {
                case excel::Constants::xlLTR:
                    aVal <<= sal_Int16(text::WritingMode_LR_TB);
                    break;
                case excel::Constants::xlRTL:
                    aVal <<= sal_Int16(text::WritingMode_RL_TB);
                    break;
                case excel::Constants::xlContext:
                    // TODO implement xlContext
                    // Reading order has to depend on the language of the first letter
                    // written.
                    aVal <<= sal_Int16(text::WritingMode_LR_TB);
                    break;
                default:
                    DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
            }
            mxPropertySet->setPropertyValue( SC_UNONAME_WRITING, aVal );
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }

    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getReadingOrder(  )
    {
        uno::Any NRetReadingOrder = aNULL();
        try
        {
            OUString sWritingMode( SC_UNONAME_WRITING );
            if (!isAmbiguous(sWritingMode))
            {
                text::WritingMode aWritingMode = text::WritingMode_LR_TB;
                if ( ( mxPropertySet->getPropertyValue(sWritingMode) ) >>= aWritingMode )
                switch (aWritingMode){
                    case text::WritingMode_LR_TB:
                        NRetReadingOrder <<= excel::Constants::xlLTR;
                        break;
                    case text::WritingMode_RL_TB:
                        NRetReadingOrder <<= excel::Constants::xlRTL;
                        break;
                    default:
                        NRetReadingOrder <<= excel::Constants::xlRTL;
                }
            }
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, OUString());
        }
        return NRetReadingOrder;

    }

    template< typename... Ifc >
    uno::Any SAL_CALL
    ScVbaFormat< Ifc... >::getNumberFormat(  )
    {
        uno::Any aFormat = aNULL();
        try
        {
            sal_Int32 nFormat = -1;
            OUString sNumFormat( SC_UNO_DP_NUMBERFO );
            if (!isAmbiguous(sNumFormat) &&
                ( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat) )
            {
                initializeNumberFormats();

                sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, m_aDefaultLocale );
                OUString sFormat;
                xNumberFormats->getByKey(nNewFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
                aFormat <<= sFormat;
            }
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return aFormat;
    }

    template< typename... Ifc >
    bool
    ScVbaFormat< Ifc... >::isAmbiguous(const OUString& _sPropertyName)
    {
        bool bResult = false;
        try
        {
            if (mbCheckAmbiguoity)
                bResult = ( getXPropertyState()->getPropertyState(_sPropertyName) == beans::PropertyState_AMBIGUOUS_VALUE );
        }
        catch (const uno::Exception& )
        {
            DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, OUString());
        }
        return bResult;
    }

    template< typename... Ifc >
    void
    ScVbaFormat< Ifc... >::initializeNumberFormats()
    {
        if ( !xNumberFormats.is() )
        {
            mxNumberFormatsSupplier.set( mxModel, uno::UNO_QUERY_THROW );
            xNumberFormats = mxNumberFormatsSupplier->getNumberFormats();
            xNumberFormatTypes.set( xNumberFormats, uno::UNO_QUERY ); // _THROW?
        }
    }

    template< typename... Ifc >
    uno::Reference< beans::XPropertyState > const &
    ScVbaFormat< Ifc... >::getXPropertyState()
    {
        if ( !xPropertyState.is() )
            xPropertyState.set( mxPropertySet, uno::UNO_QUERY_THROW );
        return xPropertyState;
    }

    template< typename... Ifc >
    ScCellRangesBase*
    ScVbaFormat< Ifc... >::getCellRangesBase()
    {
        return ScCellRangesBase::getImplementation( mxPropertySet );
    }

    template< typename... Ifc >
    SfxItemSet*
    ScVbaFormat< Ifc... >::getCurrentDataSet()
    {
        SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
        if ( !pDataSet )
            throw uno::RuntimeException("Can't access Itemset for XPropertySet" );
        return pDataSet;
    }

    template class ScVbaFormat< excel::XStyle >;
    template class ScVbaFormat< excel::XRange >;

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

↑ V1019 Compound assignment expression is used inside condition.

↑ V1019 Compound assignment expression is used inside condition.