    /* -*- 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 <memory>
    #include <xestyle.hxx>

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <set>
    #include <com/sun/star/i18n/ScriptType.hpp>
    #include <comphelper/processfactory.hxx>
    #include <rtl/tencinfo.h>
    #include <vcl/font.hxx>
    #include <svl/zformat.hxx>
    #include <svl/itempool.hxx>
    #include <svl/languageoptions.hxx>
    #include <sfx2/printer.hxx>
    #include <scitems.hxx>
    #include <svx/algitem.hxx>
    #include <editeng/boxitem.hxx>
    #include <editeng/lineitem.hxx>
    #include <svx/rotmodit.hxx>
    #include <editeng/colritem.hxx>
    #include <editeng/brushitem.hxx>
    #include <editeng/frmdiritem.hxx>
    #include <editeng/fontitem.hxx>
    #include <editeng/eeitem.hxx>
    #include <editeng/escapementitem.hxx>
    #include <editeng/justifyitem.hxx>
    #include <editeng/langitem.hxx>
    #include <document.hxx>
    #include <stlpool.hxx>
    #include <stlsheet.hxx>
    #include <patattr.hxx>
    #include <attrib.hxx>
    #include <globstr.hrc>
    #include <scresid.hxx>
    #include <xestring.hxx>
    #include <conditio.hxx>

    #include <oox/export/utils.hxx>
    #include <oox/token/tokens.hxx>
    #include <oox/token/namespaces.hxx>
    #include <oox/token/relationship.hxx>
    #include <o3tl/make_unique.hxx>

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

    // PALETTE record - color information =========================================

    namespace {

    sal_uInt32 lclGetWeighting( XclExpColorType eType )
    {
        switch( eType )
        {
            case EXC_COLOR_CHARTLINE:   return 1;
            case EXC_COLOR_CELLBORDER:
            case EXC_COLOR_CHARTAREA:   return 2;
            case EXC_COLOR_CELLTEXT:
            case EXC_COLOR_CHARTTEXT:
            case EXC_COLOR_CTRLTEXT:    return 10;
            case EXC_COLOR_TABBG:
            case EXC_COLOR_CELLAREA:    return 20;
            case EXC_COLOR_GRID:        return 50;
            default:    OSL_FAIL( "lclGetWeighting - unknown color type" );
        }
        return 1;
    }

    sal_Int32 lclGetColorDistance( const Color& rColor1, const Color& rColor2 )
    {
        sal_Int32 nDist = rColor1.GetRed() - rColor2.GetRed();
        nDist *= nDist * 77;
        sal_Int32 nDummy = rColor1.GetGreen() - rColor2.GetGreen();
        nDist += nDummy * nDummy * 151;
        nDummy = rColor1.GetBlue() - rColor2.GetBlue();
        nDist += nDummy * nDummy * 28;
        return nDist;
    }

    sal_uInt8 lclGetMergedColorComp( sal_uInt8 nComp1, sal_uInt32 nWeight1, sal_uInt8 nComp2, sal_uInt32 nWeight2 )
    {
        sal_uInt8 nComp1Dist = ::std::min< sal_uInt8 >( nComp1, 0xFF - nComp1 );
        sal_uInt8 nComp2Dist = ::std::min< sal_uInt8 >( nComp2, 0xFF - nComp2 );
        if( nComp1Dist != nComp2Dist )
        {
            /*  #i36945# One of the passed RGB components is nearer at the limits (0x00 or 0xFF).
                Increase its weighting to prevent fading of the colors during reduction. */
            const sal_uInt8& rnCompNearer = (nComp1Dist < nComp2Dist) ? nComp1 : nComp2;
            sal_uInt32& rnWeight = (nComp1Dist < nComp2Dist) ? nWeight1 : nWeight2;
            rnWeight *= ((rnCompNearer - 0x80L) * (rnCompNearer - 0x7FL) / 0x1000L + 1);
        }
        sal_uInt32 nWSum = nWeight1 + nWeight2;
        return static_cast< sal_uInt8 >( (nComp1 * nWeight1 + nComp2 * nWeight2 + nWSum / 2) / nWSum );
    }

    void lclSetMixedColor( Color& rDest, const Color& rSrc1, const Color& rSrc2 )
    {
        rDest.SetRed( static_cast< sal_uInt8 >( (static_cast< sal_uInt16 >( rSrc1.GetRed() ) + rSrc2.GetRed()) / 2 ) );
        rDest.SetGreen( static_cast< sal_uInt8 >( (static_cast< sal_uInt16 >( rSrc1.GetGreen() ) + rSrc2.GetGreen()) / 2 ) );
        rDest.SetBlue( static_cast< sal_uInt8 >( (static_cast< sal_uInt16 >( rSrc1.GetBlue() ) + rSrc2.GetBlue()) / 2 ) );
    }

    } // namespace

    // additional classes for color reduction -------------------------------------

    namespace {

    /** Represents an entry in a color list.

        The color stores a weighting value, which increases the more the color is
        used in the document. Heavy-weighted colors will change less than others on
        color reduction.
     */
    class XclListColor
    {
    private:
        Color               maColor;        /// The color value of this palette entry.
        sal_uInt32          mnColorId;      /// Unique color ID for color reduction.
        sal_uInt32          mnWeight;       /// Weighting for color reduction.
        bool                mbBaseColor;    /// true = Handle as base color, (don't remove/merge).

    public:
        explicit            XclListColor( const Color& rColor, sal_uInt32 nColorId );

        /** Returns the RGB color value of the color. */
        const Color& GetColor() const { return maColor; }
        /** Returns the unique ID of the color. */
        sal_uInt32   GetColorId() const { return mnColorId; }
        /** Returns the current weighting of the color. */
        sal_uInt32   GetWeighting() const { return mnWeight; }
        /** Returns true, if this color is a base color, i.e. it will not be removed or merged. */
        bool         IsBaseColor() const { return mbBaseColor; }

        /** Adds the passed weighting to this color. */
        void         AddWeighting( sal_uInt32 nWeight ) { mnWeight += nWeight; }
        /** Merges this color with rColor, regarding weighting settings. */
        void                Merge( const XclListColor& rColor );
    };

    XclListColor::XclListColor( const Color& rColor, sal_uInt32 nColorId ) :
        maColor( rColor ),
        mnColorId( nColorId ),
        mnWeight( 0 )
    {
        mbBaseColor =
            ((rColor.GetRed()   == 0x00) || (rColor.GetRed()   == 0xFF)) &&
            ((rColor.GetGreen() == 0x00) || (rColor.GetGreen() == 0xFF)) &&
            ((rColor.GetBlue()  == 0x00) || (rColor.GetBlue()  == 0xFF));
    }

    void XclListColor::Merge( const XclListColor& rColor )
    {
        sal_uInt32 nWeight2 = rColor.GetWeighting();
        // do not change RGB value of base colors
        if( !mbBaseColor )
        {
            maColor.SetRed(   lclGetMergedColorComp( maColor.GetRed(),   mnWeight, rColor.maColor.GetRed(),   nWeight2 ) );
            maColor.SetGreen( lclGetMergedColorComp( maColor.GetGreen(), mnWeight, rColor.maColor.GetGreen(), nWeight2 ) );
            maColor.SetBlue(  lclGetMergedColorComp( maColor.GetBlue(),  mnWeight, rColor.maColor.GetBlue(),  nWeight2 ) );
        }
        AddWeighting( nWeight2 );
    }

    /** Data for each inserted original color, represented by a color ID. */
    struct XclColorIdData
    {
        Color               maColor;        /// The original inserted color.
        sal_uInt32          mnIndex;        /// Maps current color ID to color list or export color vector.
        /** Sets the contents of this struct. */
        void         Set( const Color& rColor, sal_uInt32 nIndex ) { maColor = rColor; mnIndex = nIndex; }
    };

    /** A color that will be written to the Excel file. */
    struct XclPaletteColor
    {
        Color               maColor;        /// Resulting color to export.
        bool                mbUsed;         /// true = Entry is used in the document.

        explicit     XclPaletteColor( const Color& rColor ) : maColor( rColor ), mbUsed( false ) {}
        void         SetColor( const Color& rColor ) { maColor = rColor; mbUsed = true; }
    };

    /** Maps a color list index to a palette index.
        @descr  Used to remap the color ID data vector from list indexes to palette indexes. */
    struct XclRemap
    {
        sal_uInt32          mnPalIndex;     /// Index to palette.
        bool                mbProcessed;    /// true = List color already processed.

        explicit     XclRemap() : mnPalIndex( 0 ), mbProcessed( false ) {}
        void         SetIndex( sal_uInt32 nPalIndex )
                                { mnPalIndex = nPalIndex; mbProcessed = true; }
    };

    /** Stores the nearest palette color index of a list color. */
    struct XclNearest
    {
        sal_uInt32          mnPalIndex;     /// Index to nearest palette color.
        sal_Int32           mnDist;         /// Distance to palette color.

        explicit     XclNearest() : mnPalIndex( 0 ), mnDist( 0 ) {}
    };

    } // namespace

    class XclExpPaletteImpl
    {
    public:
        explicit            XclExpPaletteImpl( const XclDefaultPalette& rDefPal );

        /** Inserts the color into the list and updates weighting.
            @param nAutoDefault  The Excel palette index for automatic color.
            @return  A unique ID for this color. */
        sal_uInt32          InsertColor( const Color& rColor, XclExpColorType eType, sal_uInt16 nAutoDefault = 0 );
        /** Returns the color ID representing a fixed Excel palette index (i.e. for auto colors). */
        static sal_uInt32   GetColorIdFromIndex( sal_uInt16 nIndex );

        /** Reduces the color list to the maximum count of the current BIFF version. */
        void                Finalize();

        /** Returns the Excel palette index of the color with passed color ID. */
        sal_uInt16          GetColorIndex( sal_uInt32 nColorId ) const;

        /** Returns a foreground and background color for the two passed color IDs.
            @descr  If rnXclPattern contains a solid pattern, this function tries to find
            the two best fitting colors and a mix pattern (25%, 50% or 75%) for nForeColorId.
            This will result in a better approximation to the passed foreground color. */
        void                GetMixedColors(
                                sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt8& rnXclPattern,
                                sal_uInt32 nForeColorId, sal_uInt32 nBackColorId ) const;

        /** Returns the RGB color for a (non-zero-based) Excel palette entry.
            @return  The color from current or default palette or COL_AUTO, if nothing else found. */
        Color               GetColor( sal_uInt16 nXclIndex ) const;

        /** Returns true, if all colors of the palette are equal to default palette colors. */
        bool                IsDefaultPalette() const;
        /** Writes the color list (contents of the palette record) to the passed stream. */
        void                WriteBody( XclExpStream& rStrm );
        void                SaveXml( XclExpXmlStream& rStrm );

    private:
        /** Returns the Excel index of a 0-based color index. */
        static sal_uInt16 GetXclIndex( sal_uInt32 nIndex )
                                { return static_cast< sal_uInt16 >( nIndex + EXC_COLOR_USEROFFSET ); }

        /** Returns the original inserted color represented by the color ID nColorId. */
        const Color&        GetOriginalColor( sal_uInt32 nColorId ) const;

        /** Searches for rColor, returns the ordered insertion index for rColor in rnIndex. */
        XclListColor*       SearchListEntry( const Color& rColor, sal_uInt32& rnIndex );
        /** Creates and inserts a new color list entry at the specified list position. */
        XclListColor*       CreateListEntry( const Color& rColor, sal_uInt32 nIndex );

        /** Raw and fast reduction of the palette. */
        void                RawReducePalette( sal_uInt32 nPass );
        /** Reduction of one color using advanced color merging based on color weighting. */
        void                ReduceLeastUsedColor();

        /** Finds the least used color and returns its current list index. */
        sal_uInt32          GetLeastUsedListColor() const;
        /** Returns the list index of the color nearest to rColor.
            @param nIgnore  List index of a color which will be ignored.
            @return  The list index of the found color. */
        sal_uInt32          GetNearestListColor( const Color& rColor, sal_uInt32 nIgnore ) const;
        /** Returns the list index of the color nearest to the color with list index nIndex. */
        sal_uInt32          GetNearestListColor( sal_uInt32 nIndex ) const;

        /** Returns in rnIndex the palette index of the color nearest to rColor.
            Searches for default colors only (colors never replaced).
            @return  The distance from passed color to found color. */
        sal_Int32           GetNearestPaletteColor(
                                sal_uInt32& rnIndex,
                                const Color& rColor ) const;
        /** Returns in rnFirst and rnSecond the palette indexes of the two colors nearest to rColor.
            @return  The minimum distance from passed color to found colors. */
        sal_Int32           GetNearPaletteColors(
                                sal_uInt32& rnFirst, sal_uInt32& rnSecond,
                                const Color& rColor ) const;

    private:
        typedef std::vector< std::unique_ptr<XclListColor> >     XclListColorList;
        typedef std::shared_ptr< XclListColorList > XclListColorListRef;
        typedef ::std::vector< XclColorIdData >       XclColorIdDataVec;
        typedef ::std::vector< XclPaletteColor >      XclPaletteColorVec;

        const XclDefaultPalette& mrDefPal;      /// The default palette for the current BIFF version.
        XclListColorListRef mxColorList;        /// Working color list.
        XclColorIdDataVec   maColorIdDataVec;   /// Data of all CIDs.
        XclPaletteColorVec  maPalette;          /// Contains resulting colors to export.
        sal_uInt32          mnLastIdx;          /// Last insertion index for search opt.
    };

    const sal_uInt32 EXC_PAL_INDEXBASE          = 0xFFFF0000;
    const sal_uInt32 EXC_PAL_MAXRAWSIZE         = 1024;

    XclExpPaletteImpl::XclExpPaletteImpl( const XclDefaultPalette& rDefPal ) :
        mrDefPal( rDefPal ),
        mxColorList( new XclListColorList ),
        mnLastIdx( 0 )
    {
        // initialize maPalette with default colors
        sal_uInt16 nCount = static_cast< sal_uInt16 >( mrDefPal.GetColorCount() );
        maPalette.reserve( nCount );
        for( sal_uInt16 nIdx = 0; nIdx < nCount; ++nIdx )
            maPalette.emplace_back( mrDefPal.GetDefColor( GetXclIndex( nIdx ) ) );

        InsertColor( COL_BLACK, EXC_COLOR_CELLTEXT );
    }

    sal_uInt32 XclExpPaletteImpl::InsertColor( const Color& rColor, XclExpColorType eType, sal_uInt16 nAutoDefault )
    {
        if( rColor == COL_AUTO )
            return GetColorIdFromIndex( nAutoDefault );

        sal_uInt32 nFoundIdx = 0;
        XclListColor* pEntry = SearchListEntry( rColor, nFoundIdx );
        if( !pEntry || (pEntry->GetColor() != rColor) )
            pEntry = CreateListEntry( rColor, nFoundIdx );
        pEntry->AddWeighting( lclGetWeighting( eType ) );

        return pEntry->GetColorId();
    }

    sal_uInt32 XclExpPaletteImpl::GetColorIdFromIndex( sal_uInt16 nIndex )
    {
        return EXC_PAL_INDEXBASE | nIndex;
    }

    void XclExpPaletteImpl::Finalize()
    {
    // --- build initial color ID data vector (maColorIdDataVec) ---

        sal_uInt32 nCount = mxColorList->size();
        maColorIdDataVec.resize( nCount );
        for( sal_uInt32 nIdx = 0; nIdx < nCount; ++nIdx )
        {
            const XclListColor& listColor = *mxColorList->at( nIdx ).get();
            maColorIdDataVec[ listColor.GetColorId() ].Set( listColor.GetColor(), nIdx );
        }

    // --- loop as long as current color count does not fit into palette of current BIFF ---

        // phase 1: raw reduction (performance reasons, #i36945#)
        sal_uInt32 nPass = 0;
        while( mxColorList->size() > EXC_PAL_MAXRAWSIZE )
            RawReducePalette( nPass++ );

        // phase 2: precise reduction using advanced color merging based on color weighting
        while( mxColorList->size() > mrDefPal.GetColorCount() )
            ReduceLeastUsedColor();

    // --- use default palette and replace colors with nearest used colors ---

        nCount = mxColorList->size();
        std::vector< XclRemap > aRemapVec( nCount );
        std::vector< XclNearest > aNearestVec( nCount );

        // in each run: search the best fitting color and replace a default color with it
        for( sal_uInt32 nRun = 0; nRun < nCount; ++nRun )
        {
            sal_uInt32 nIndex;
            // find nearest unused default color for each unprocessed list color
            for( nIndex = 0; nIndex < nCount; ++nIndex )
                aNearestVec[ nIndex ].mnDist = aRemapVec[ nIndex ].mbProcessed ? SAL_MAX_INT32 :
                    GetNearestPaletteColor( aNearestVec[ nIndex ].mnPalIndex, mxColorList->at( nIndex )->GetColor() );
            // find the list color which is nearest to a default color
            sal_uInt32 nFound = 0;
            for( nIndex = 1; nIndex < nCount; ++nIndex )
                if( aNearestVec[ nIndex ].mnDist < aNearestVec[ nFound ].mnDist )
                    nFound = nIndex;
            // replace default color with list color
            sal_uInt32 nNearest = aNearestVec[ nFound ].mnPalIndex;
            OSL_ENSURE( nNearest < maPalette.size(), "XclExpPaletteImpl::Finalize - algorithm error" );
            maPalette[ nNearest ].SetColor( mxColorList->at( nFound )->GetColor() );
            aRemapVec[ nFound ].SetIndex( nNearest );
        }

        // remap color ID data map (maColorIdDataVec) from list indexes to palette indexes
        for( XclColorIdDataVec::iterator aIt = maColorIdDataVec.begin(), aEnd = maColorIdDataVec.end(); aIt != aEnd; ++aIt )
            aIt->mnIndex = aRemapVec[ aIt->mnIndex ].mnPalIndex;
    }

    sal_uInt16 XclExpPaletteImpl::GetColorIndex( sal_uInt32 nColorId ) const
    {
        sal_uInt16 nRet = 0;
        if( nColorId >= EXC_PAL_INDEXBASE )
            nRet = static_cast< sal_uInt16 >( nColorId & ~EXC_PAL_INDEXBASE );
        else if( nColorId < maColorIdDataVec.size() )
            nRet = GetXclIndex( maColorIdDataVec[ nColorId ].mnIndex );
        return nRet;
    }

    void XclExpPaletteImpl::GetMixedColors(
            sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt8& rnXclPattern,
            sal_uInt32 nForeColorId, sal_uInt32 nBackColorId ) const
    {
        rnXclForeIx = GetColorIndex( nForeColorId );
        rnXclBackIx = GetColorIndex( nBackColorId );
        if( (rnXclPattern != EXC_PATT_SOLID) || (nForeColorId >= maColorIdDataVec.size()) )
            return;

        // now we have solid pattern, and a defined foreground (background doesn't care for solid pattern)

        sal_uInt32 nIndex1, nIndex2;
        Color aForeColor( GetOriginalColor( nForeColorId ) );
        sal_Int32 nFirstDist = GetNearPaletteColors( nIndex1, nIndex2, aForeColor );
        if( (nIndex1 >= maPalette.size()) || (nIndex2 >= maPalette.size()) )
            return;

        Color aColorArr[ 5 ];
        aColorArr[ 0 ] = maPalette[ nIndex1 ].maColor;
        aColorArr[ 4 ] = maPalette[ nIndex2 ].maColor;
        lclSetMixedColor( aColorArr[ 2 ], aColorArr[ 0 ], aColorArr[ 4 ] );
        lclSetMixedColor( aColorArr[ 1 ], aColorArr[ 0 ], aColorArr[ 2 ] );
        lclSetMixedColor( aColorArr[ 3 ], aColorArr[ 2 ], aColorArr[ 4 ] );

        sal_Int32 nMinDist = nFirstDist;
        sal_uInt32 nMinIndex = 0;
        for( sal_uInt32 nCnt = 1; nCnt < 4; ++nCnt )
        {
            sal_Int32 nDist = lclGetColorDistance( aForeColor, aColorArr[ nCnt ] );
            if( nDist < nMinDist )
            {
                nMinDist = nDist;
                nMinIndex = nCnt;
            }
        }
        rnXclForeIx = GetXclIndex( nIndex1 );
        rnXclBackIx = GetXclIndex( nIndex2 );
        if( nMinDist < nFirstDist )
        {
            switch( nMinIndex )
            {
                case 1: rnXclPattern = EXC_PATT_75_PERC;    break;
                case 2: rnXclPattern = EXC_PATT_50_PERC;    break;
                case 3: rnXclPattern = EXC_PATT_25_PERC;    break;
            }
        }
    }

    Color XclExpPaletteImpl::GetColor( sal_uInt16 nXclIndex ) const
    {
        if( nXclIndex >= EXC_COLOR_USEROFFSET )
        {
            sal_uInt32 nIdx = nXclIndex - EXC_COLOR_USEROFFSET;
            if( nIdx < maPalette.size() )
                return maPalette[ nIdx ].maColor;
        }
        return mrDefPal.GetDefColor( nXclIndex );
    }

    bool XclExpPaletteImpl::IsDefaultPalette() const
    {
        bool bDefault = true;
        for( sal_uInt32 nIdx = 0, nSize = static_cast< sal_uInt32 >( maPalette.size() ); bDefault && (nIdx < nSize); ++nIdx )
            bDefault = maPalette[ nIdx ].maColor == mrDefPal.GetDefColor( GetXclIndex( nIdx ) );
        return bDefault;
    }

    void XclExpPaletteImpl::WriteBody( XclExpStream& rStrm )
    {
        rStrm << static_cast< sal_uInt16 >( maPalette.size() );
        for( XclPaletteColorVec::const_iterator aIt = maPalette.begin(), aEnd = maPalette.end(); aIt != aEnd; ++aIt )
            rStrm << aIt->maColor;
    }

    void XclExpPaletteImpl::SaveXml( XclExpXmlStream& rStrm )
    {
        if( maPalette.empty() )
            return;

        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_colors, FSEND );
        rStyleSheet->startElement( XML_indexedColors, FSEND );
        for( XclPaletteColorVec::const_iterator aIt = maPalette.begin(), aEnd = maPalette.end(); aIt != aEnd; ++aIt )
            rStyleSheet->singleElement( XML_rgbColor,
                    XML_rgb,    XclXmlUtils::ToOString( aIt->maColor ).getStr(),
                    FSEND );
        rStyleSheet->endElement( XML_indexedColors );
        rStyleSheet->endElement( XML_colors );
    }

    const Color& XclExpPaletteImpl::GetOriginalColor( sal_uInt32 nColorId ) const
    {
        if( nColorId < maColorIdDataVec.size() )
            return maColorIdDataVec[ nColorId ].maColor;
        return maPalette[ 0 ].maColor;
    }

    XclListColor* XclExpPaletteImpl::SearchListEntry( const Color& rColor, sal_uInt32& rnIndex )
    {
        rnIndex = 0;

        if (mxColorList->empty())
            return nullptr;

        XclListColor* pEntry = nullptr;

        // search optimization for equal-colored objects occurring repeatedly
        if (mnLastIdx < mxColorList->size())
        {
            pEntry = (*mxColorList)[mnLastIdx].get();
            if( pEntry->GetColor() == rColor )
            {
                rnIndex = mnLastIdx;
                return pEntry;
            }
        }

        // binary search for color
        sal_uInt32 nBegIdx = 0;
        sal_uInt32 nEndIdx = mxColorList->size();
        bool bFound = false;
        while( !bFound && (nBegIdx < nEndIdx) )
        {
            rnIndex = (nBegIdx + nEndIdx) / 2;
            pEntry = (*mxColorList)[rnIndex].get();
            bFound = pEntry->GetColor() == rColor;
            if( !bFound )
            {
                if( pEntry->GetColor() < rColor )
                    nBegIdx = rnIndex + 1;
                else
                    nEndIdx = rnIndex;
            }
        }

        // not found - use end of range as new insertion position
        if( !bFound )
            rnIndex = nEndIdx;

        mnLastIdx = rnIndex;
        return pEntry;
    }

    XclListColor* XclExpPaletteImpl::CreateListEntry( const Color& rColor, sal_uInt32 nIndex )
    {
        XclListColor* pEntry = new XclListColor( rColor, mxColorList->size() );
        mxColorList->insert(mxColorList->begin() + nIndex, std::unique_ptr<XclListColor>(pEntry));
        return pEntry;
    }

    void XclExpPaletteImpl::RawReducePalette( sal_uInt32 nPass )
    {
        /*  Fast palette reduction - in each call of this function one RGB component
            of each color is reduced to a lower number of distinct values.
            Pass 0: Blue is reduced to 128 distinct values.
            Pass 1: Red is reduced to 128 distinct values.
            Pass 2: Green is reduced to 128 distinct values.
            Pass 3: Blue is reduced to 64 distinct values.
            Pass 4: Red is reduced to 64 distinct values.
            Pass 5: Green is reduced to 64 distinct values.
            And so on...
         */

        XclListColorListRef xOldList = mxColorList;
        mxColorList.reset( new XclListColorList );

        // maps old list indexes to new list indexes, used to update maColorIdDataVec
        ScfUInt32Vec aListIndexMap;
        aListIndexMap.reserve( xOldList->size() );

        // preparations
        sal_uInt8 nR, nG, nB;
        sal_uInt8& rnComp = ((nPass % 3 == 0) ? nB : ((nPass % 3 == 1) ? nR : nG));
        nPass /= 3;
        OSL_ENSURE( nPass < 7, "XclExpPaletteImpl::RawReducePalette - reduction not terminated" );

        static const sal_uInt8 spnFactor2[] = { 0x81, 0x82, 0x84, 0x88, 0x92, 0xAA, 0xFF };
        sal_uInt8 nFactor1 = static_cast< sal_uInt8 >( 0x02 << nPass );
        sal_uInt8 nFactor2 = spnFactor2[ nPass ];
        sal_uInt8 nFactor3 = static_cast< sal_uInt8 >( 0x40 >> nPass );

        // process each color in the old color list
        for(std::unique_ptr<XclListColor> & pOldColor : *xOldList)
        {
            // get the old list entry
            const XclListColor* pOldEntry = pOldColor.get();
            nR = pOldEntry->GetColor().GetRed();
            nG = pOldEntry->GetColor().GetGreen();
            nB = pOldEntry->GetColor().GetBlue();

            /*  Calculate the new RGB component (rnComp points to one of nR, nG, nB).
                Using integer arithmetic with its rounding errors, the results of
                this calculation are always exactly in the range 0x00 to 0xFF
                (simply cutting the lower bits would darken the colors slightly). */
            sal_uInt32 nNewComp = rnComp;
            nNewComp /= nFactor1;
            nNewComp *= nFactor2;
            nNewComp /= nFactor3;
            rnComp = static_cast< sal_uInt8 >( nNewComp );
            Color aNewColor( nR, nG, nB );

            // find or insert the new color
            sal_uInt32 nFoundIdx = 0;
            XclListColor* pNewEntry = SearchListEntry( aNewColor, nFoundIdx );
            if( !pNewEntry || (pNewEntry->GetColor() != aNewColor) )
                pNewEntry = CreateListEntry( aNewColor, nFoundIdx );
            pNewEntry->AddWeighting( pOldEntry->GetWeighting() );
            aListIndexMap.push_back( nFoundIdx );
        }

        // update color ID data map (maps color IDs to color list indexes), replace old by new list indexes
        for( XclColorIdDataVec::iterator aIt = maColorIdDataVec.begin(), aEnd = maColorIdDataVec.end(); aIt != aEnd; ++aIt )
            aIt->mnIndex = aListIndexMap[ aIt->mnIndex ];
    }

    void XclExpPaletteImpl::ReduceLeastUsedColor()
    {
        // find a list color to remove
        sal_uInt32 nRemove = GetLeastUsedListColor();
        // find its nearest neighbor
        sal_uInt32 nKeep = GetNearestListColor( nRemove );

        // merge both colors to one color, remove one color from list
        XclListColor* pKeepEntry = mxColorList->at(nKeep).get();
        XclListColor* pRemoveEntry = mxColorList->at(nRemove).get();
        if( pKeepEntry && pRemoveEntry )
        {
            // merge both colors (if pKeepEntry is a base color, it will not change)
            pKeepEntry->Merge( *pRemoveEntry );
            // remove the less used color, adjust nKeep index if kept color follows removed color
            XclListColorList::iterator itr = mxColorList->begin();
            ::std::advance(itr, nRemove);
            mxColorList->erase(itr);
            if( nKeep > nRemove ) --nKeep;

            // recalculate color ID data map (maps color IDs to color list indexes)
            for( XclColorIdDataVec::iterator aIt = maColorIdDataVec.begin(), aEnd = maColorIdDataVec.end(); aIt != aEnd; ++aIt )
            {
                if( aIt->mnIndex > nRemove )
                    --aIt->mnIndex;
                else if( aIt->mnIndex == nRemove )
                    aIt->mnIndex = nKeep;
            }
        }
    }

    sal_uInt32 XclExpPaletteImpl::GetLeastUsedListColor() const
    {
        sal_uInt32 nFound = 0;
        sal_uInt32 nMinW = SAL_MAX_UINT32;

        for( sal_uInt32 nIdx = 0, nCount = mxColorList->size(); nIdx < nCount; ++nIdx )
        {
            XclListColor& rEntry = *mxColorList->at( nIdx ).get();
            // ignore the base colors
            if( !rEntry.IsBaseColor() && (rEntry.GetWeighting() < nMinW) )
            {
                nFound = nIdx;
                nMinW = rEntry.GetWeighting();
            }
        }
        return nFound;
    }

    sal_uInt32 XclExpPaletteImpl::GetNearestListColor( const Color& rColor, sal_uInt32 nIgnore ) const
    {
        sal_uInt32 nFound = 0;
        sal_Int32 nMinD = SAL_MAX_INT32;

        for( sal_uInt32 nIdx = 0, nCount = mxColorList->size(); nIdx < nCount; ++nIdx )
        {
            if( nIdx != nIgnore )
            {
                if( XclListColor* pEntry = mxColorList->at(nIdx).get() )
                {
                    sal_Int32 nDist = lclGetColorDistance( rColor, pEntry->GetColor() );
                    if( nDist < nMinD )
                    {
                        nFound = nIdx;
                        nMinD = nDist;
                    }
                }
            }
        }
        return nFound;
    }

    sal_uInt32 XclExpPaletteImpl::GetNearestListColor( sal_uInt32 nIndex ) const
    {
        if (nIndex >= mxColorList->size())
            return 0;
        XclListColor* pEntry = mxColorList->at(nIndex).get();
        return GetNearestListColor( pEntry->GetColor(), nIndex );
    }

    sal_Int32 XclExpPaletteImpl::GetNearestPaletteColor(
            sal_uInt32& rnIndex, const Color& rColor ) const
    {
        rnIndex = 0;
        sal_Int32 nDist = SAL_MAX_INT32;

        for( XclPaletteColorVec::const_iterator aIt = maPalette.begin(), aEnd = maPalette.end();
                aIt != aEnd; ++aIt )
        {
            if( !aIt->mbUsed )
            {
                sal_Int32 nCurrDist = lclGetColorDistance( rColor, aIt->maColor );
                if( nCurrDist < nDist )
                {
                    rnIndex = aIt - maPalette.begin();
                    nDist = nCurrDist;
                }
            }
        }
        return nDist;
    }

    sal_Int32 XclExpPaletteImpl::GetNearPaletteColors(
            sal_uInt32& rnFirst, sal_uInt32& rnSecond, const Color& rColor ) const
    {
        rnFirst = rnSecond = 0;
        sal_Int32 nDist1 = SAL_MAX_INT32;
        sal_Int32 nDist2 = SAL_MAX_INT32;

        for( XclPaletteColorVec::const_iterator aIt = maPalette.begin(), aEnd = maPalette.end();
                aIt != aEnd; ++aIt )
        {
            sal_Int32 nCurrDist = lclGetColorDistance( rColor, aIt->maColor );
            if( nCurrDist < nDist1 )
            {
                rnSecond = rnFirst;
                nDist2 = nDist1;
                rnFirst = aIt - maPalette.begin();
                nDist1 = nCurrDist;
            }
            else if( nCurrDist < nDist2 )
            {
                rnSecond = aIt - maPalette.begin();
                nDist2 = nCurrDist;
            }
        }
        return nDist1;
    }

    XclExpPalette::XclExpPalette( const XclExpRoot& rRoot ) :
        XclDefaultPalette( rRoot ),
        XclExpRecord( EXC_ID_PALETTE )
    {
        mxImpl.reset( new XclExpPaletteImpl( *this ) );
        SetRecSize( GetColorCount() * 4 + 2 );
    }

    XclExpPalette::~XclExpPalette()
    {
    }

    sal_uInt32 XclExpPalette::InsertColor( const Color& rColor, XclExpColorType eType, sal_uInt16 nAutoDefault )
    {
        return mxImpl->InsertColor( rColor, eType, nAutoDefault );
    }

    sal_uInt32 XclExpPalette::GetColorIdFromIndex( sal_uInt16 nIndex )
    {
        return XclExpPaletteImpl::GetColorIdFromIndex( nIndex );
    }

    void XclExpPalette::Finalize()
    {
        mxImpl->Finalize();
    }

    sal_uInt16 XclExpPalette::GetColorIndex( sal_uInt32 nColorId ) const
    {
        return mxImpl->GetColorIndex( nColorId );
    }

    void XclExpPalette::GetMixedColors(
            sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt8& rnXclPattern,
            sal_uInt32 nForeColorId, sal_uInt32 nBackColorId ) const
    {
        return mxImpl->GetMixedColors( rnXclForeIx, rnXclBackIx, rnXclPattern, nForeColorId, nBackColorId );
    }

    Color XclExpPalette::GetColor( sal_uInt16 nXclIndex ) const
    {
        return mxImpl->GetColor( nXclIndex );
    }

    void XclExpPalette::Save( XclExpStream& rStrm )
    {
        if( !mxImpl->IsDefaultPalette() )
            XclExpRecord::Save( rStrm );
    }

    void XclExpPalette::SaveXml( XclExpXmlStream& rStrm )
    {
        if( !mxImpl->IsDefaultPalette() )
            mxImpl->SaveXml( rStrm );
    }

    void XclExpPalette::WriteBody( XclExpStream& rStrm )
    {
        mxImpl->WriteBody( rStrm );
    }

    // FONT record - font information =============================================

    namespace {

    typedef ::std::pair< sal_uInt16, sal_Int16 > WhichAndScript;

    sal_Int16 lclCheckFontItems( const SfxItemSet& rItemSet,
            const WhichAndScript& rWAS1, const WhichAndScript& rWAS2, const WhichAndScript& rWAS3 )
    {
        if( ScfTools::CheckItem( rItemSet, rWAS1.first, false ) ) return rWAS1.second;
        if( ScfTools::CheckItem( rItemSet, rWAS2.first, false ) ) return rWAS2.second;
        if( ScfTools::CheckItem( rItemSet, rWAS3.first, false ) ) return rWAS3.second;
        return 0;
    };

    } // namespace

    sal_Int16 XclExpFontHelper::GetFirstUsedScript( const XclExpRoot& rRoot, const SfxItemSet& rItemSet )
    {
        namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;

        /*  #i17050# #i107170# We need to determine which font items are set in the
            item set, and which script type we should prefer according to the
            current language settings. */

        static const WhichAndScript WAS_LATIN( ATTR_FONT, css::i18n::ScriptType::LATIN );
        static const WhichAndScript WAS_ASIAN( ATTR_CJK_FONT, css::i18n::ScriptType::ASIAN );
        static const WhichAndScript WAS_CMPLX( ATTR_CTL_FONT, css::i18n::ScriptType::COMPLEX );

        /*  do not let a font from a parent style override an explicit
            cell font. */

        sal_Int16 nDefScript = rRoot.GetDefApiScript();
        sal_Int16 nScript = 0;
        const SfxItemSet* pCurrSet = &rItemSet;

        while( (nScript == 0) && pCurrSet )
        {
            switch( nDefScript )
            {
                case ApiScriptType::LATIN:
                    nScript = lclCheckFontItems( *pCurrSet, WAS_LATIN, WAS_CMPLX, WAS_ASIAN );
                break;
                case ApiScriptType::ASIAN:
                    nScript = lclCheckFontItems( *pCurrSet, WAS_ASIAN, WAS_CMPLX, WAS_LATIN );
                break;
                case ApiScriptType::COMPLEX:
                    nScript = lclCheckFontItems( *pCurrSet, WAS_CMPLX, WAS_ASIAN, WAS_LATIN );
                break;
                default:
                    OSL_FAIL( "XclExpFontHelper::GetFirstUsedScript - unknown script type" );
                    nScript = ApiScriptType::LATIN;
            };
            pCurrSet = pCurrSet->GetParent();
        }

        if (nScript == 0)
            nScript = nDefScript;

        if (nScript == 0)
        {
            OSL_FAIL( "XclExpFontHelper::GetFirstUsedScript - unknown script type" );
            nScript = ApiScriptType::LATIN;
        }

        return nScript;
    }

    vcl::Font XclExpFontHelper::GetFontFromItemSet( const XclExpRoot& rRoot, const SfxItemSet& rItemSet, sal_Int16 nScript )
    {
        // if WEAK is passed, guess script type from existing items in the item set
        if( nScript == css::i18n::ScriptType::WEAK )
            nScript = GetFirstUsedScript( rRoot, rItemSet );

        // convert to core script type constants
        SvtScriptType nScScript = SvtLanguageOptions::FromI18NToSvtScriptType(nScript);

        // fill the font object
        vcl::Font aFont;
        ScPatternAttr::GetFont( aFont, rItemSet, SC_AUTOCOL_RAW, nullptr, nullptr, nullptr, nScScript );
        return aFont;
    }

    ScDxfFont XclExpFontHelper::GetDxfFontFromItemSet(const XclExpRoot& rRoot, const SfxItemSet& rItemSet)
    {
        sal_Int16 nScript = GetFirstUsedScript(rRoot, rItemSet);

        // convert to core script type constants
        SvtScriptType nScScript = SvtLanguageOptions::FromI18NToSvtScriptType(nScript);
        return ScPatternAttr::GetDxfFont(rItemSet, nScScript);
    }

    bool XclExpFontHelper::CheckItems( const XclExpRoot& rRoot, const SfxItemSet& rItemSet, sal_Int16 nScript, bool bDeep )
    {
        static const sal_uInt16 pnCommonIds[] = {
            ATTR_FONT_UNDERLINE, ATTR_FONT_CROSSEDOUT, ATTR_FONT_CONTOUR,
            ATTR_FONT_SHADOWED, ATTR_FONT_COLOR, ATTR_FONT_LANGUAGE, 0 };
        static const sal_uInt16 pnLatinIds[] = {
            ATTR_FONT, ATTR_FONT_HEIGHT, ATTR_FONT_WEIGHT, ATTR_FONT_POSTURE, 0 };
        static const sal_uInt16 pnAsianIds[] = {
            ATTR_CJK_FONT, ATTR_CJK_FONT_HEIGHT, ATTR_CJK_FONT_WEIGHT, ATTR_CJK_FONT_POSTURE, 0 };
        static const sal_uInt16 pnComplexIds[] = {
            ATTR_CTL_FONT, ATTR_CTL_FONT_HEIGHT, ATTR_CTL_FONT_WEIGHT, ATTR_CTL_FONT_POSTURE, 0 };

        bool bUsed = ScfTools::CheckItems( rItemSet, pnCommonIds, bDeep );
        if( !bUsed )
        {
            namespace ApiScriptType = css::i18n::ScriptType;
            // if WEAK is passed, guess script type from existing items in the item set
            if( nScript == ApiScriptType::WEAK )
                nScript = GetFirstUsedScript( rRoot, rItemSet );
            // check the correct items
            switch( nScript )
            {
                case ApiScriptType::LATIN:      bUsed = ScfTools::CheckItems( rItemSet, pnLatinIds, bDeep );    break;
                case ApiScriptType::ASIAN:      bUsed = ScfTools::CheckItems( rItemSet, pnAsianIds, bDeep );    break;
                case ApiScriptType::COMPLEX:    bUsed = ScfTools::CheckItems( rItemSet, pnComplexIds, bDeep );  break;
                default:    OSL_FAIL( "XclExpFontHelper::CheckItems - unknown script type" );
            }
        }
        return bUsed;
    }

    namespace {

    sal_uInt32 lclCalcHash( const XclFontData& rFontData )
    {
        sal_uInt32 nHash = rFontData.maName.getLength();
        nHash += sal_uInt32(rFontData.maColor) * 2;
        nHash += rFontData.mnWeight * 3;
        nHash += rFontData.mnCharSet * 5;
        nHash += rFontData.mnFamily * 7;
        nHash += rFontData.mnHeight * 11;
        nHash += rFontData.mnUnderline * 13;
        nHash += rFontData.mnEscapem * 17;
        if( rFontData.mbItalic ) nHash += 19;
        if( rFontData.mbStrikeout ) nHash += 23;
        if( rFontData.mbOutline ) nHash += 29;
        if( rFontData.mbShadow ) nHash += 31;
        return nHash;
    }

    } // namespace

    XclExpFont::XclExpFont( const XclExpRoot& rRoot,
            const XclFontData& rFontData, XclExpColorType eColorType ) :
        XclExpRecord( EXC_ID2_FONT, 14 ),
        XclExpRoot( rRoot ),
        maData( rFontData )
    {
        // insert font color into palette
        mnColorId = rRoot.GetPalette().InsertColor( rFontData.maColor, eColorType, EXC_COLOR_FONTAUTO );
        // hash value for faster comparison
        mnHash = lclCalcHash( maData );
        // record size
        sal_Int32 nStrLen = maData.maName.getLength();
        SetRecSize( ((GetBiff() == EXC_BIFF8) ? (nStrLen * 2 + 1) : nStrLen) + 15 );
    }

    bool XclExpFont::Equals( const XclFontData& rFontData, sal_uInt32 nHash ) const
    {
        return (mnHash == nHash) && (maData == rFontData);
    }

    void XclExpFont::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_font, FSEND );
        XclXmlUtils::WriteFontData( rStyleSheet, maData, XML_name );
        // OOXTODO: XML_scheme; //scheme/@val values: "major", "minor", "none"
        rStyleSheet->endElement( XML_font );
    }

    // private --------------------------------------------------------------------

    void XclExpFont::WriteBody( XclExpStream& rStrm )
    {
        sal_uInt16 nAttr = EXC_FONTATTR_NONE;
        ::set_flag( nAttr, EXC_FONTATTR_ITALIC, maData.mbItalic );
        if( maData.mnUnderline > 0 )
            ::set_flag( nAttr, EXC_FONTATTR_UNDERLINE, true );
        ::set_flag( nAttr, EXC_FONTATTR_STRIKEOUT, maData.mbStrikeout );
        ::set_flag( nAttr, EXC_FONTATTR_OUTLINE, maData.mbOutline );
        ::set_flag( nAttr, EXC_FONTATTR_SHADOW, maData.mbShadow );

        OSL_ENSURE( maData.maName.getLength() < 256, "XclExpFont::WriteBody - font name too long" );
        XclExpString aFontName;
        if( GetBiff() <= EXC_BIFF5 )
            aFontName.AssignByte( maData.maName, GetTextEncoding(), XclStrFlags::EightBitLength );
        else
            aFontName.Assign( maData.maName, XclStrFlags::ForceUnicode | XclStrFlags::EightBitLength );

        rStrm   << maData.mnHeight
                << nAttr
                << GetPalette().GetColorIndex( mnColorId )
                << maData.mnWeight
                << maData.mnEscapem
                << maData.mnUnderline
                << maData.mnFamily
                << maData.mnCharSet
                << sal_uInt8( 0 )
                << aFontName;
    }

    XclExpDxfFont::XclExpDxfFont(const XclExpRoot& rRoot,
            const SfxItemSet& rItemSet):
        XclExpRoot(rRoot)
    {
        maDxfData = XclExpFontHelper::GetDxfFontFromItemSet(rRoot, rItemSet);
    }

    namespace {

    const char* getUnderlineOOXValue(FontLineStyle eUnderline)
    {
        switch (eUnderline)
        {
            case LINESTYLE_NONE:
            case LINESTYLE_DONTKNOW:
                return "none";
            case LINESTYLE_DOUBLE:
            case LINESTYLE_DOUBLEWAVE:
                return "double";
            default:
                return "single";
        }
    }

    const char* getFontFamilyOOXValue(FontFamily eValue)
    {
        switch (eValue)
        {
            case FAMILY_DONTKNOW:
                return "0";
            break;
            case FAMILY_SWISS:
            case FAMILY_SYSTEM:
                return "2";
            case FAMILY_ROMAN:
                return "1";
            case FAMILY_SCRIPT:
                return "4";
            case FAMILY_MODERN:
                return "3";
            case FAMILY_DECORATIVE:
                return "5";
            default:
                return "0";
        }
    }

    }

    void XclExpDxfFont::SaveXml(XclExpXmlStream& rStrm)
    {
        if (maDxfData.isEmpty())
            return;

        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement(XML_font, FSEND);

        if (maDxfData.pFontAttr)
        {
            OUString aFontName = (*maDxfData.pFontAttr)->GetFamilyName();

            aFontName = XclTools::GetXclFontName(aFontName);
            if (!aFontName.isEmpty())
            {
                rStyleSheet->singleElement(XML_name,
                        XML_val, XclXmlUtils::ToOString(aFontName).getStr(),
                        FSEND);
            }

            rtl_TextEncoding eTextEnc = (*maDxfData.pFontAttr)->GetCharSet();
            sal_uInt8 nExcelCharSet = rtl_getBestWindowsCharsetFromTextEncoding(eTextEnc);
            if (nExcelCharSet)
            {
                rStyleSheet->singleElement(XML_charset,
                        XML_val, OString::number(nExcelCharSet).getStr(),
                        FSEND);
            }

            FontFamily eFamily = (*maDxfData.pFontAttr)->GetFamily();
            const char* pVal = getFontFamilyOOXValue(eFamily);
            if (pVal)
            {
                rStyleSheet->singleElement(XML_family,
                        XML_val, pVal,
                        FSEND);
            }
        }

        if (maDxfData.eWeight)
        {
            rStyleSheet->singleElement(XML_b,
                    XML_val, ToPsz10(maDxfData.eWeight.get() != WEIGHT_NORMAL),
                    FSEND);
        }

        if (maDxfData.eItalic)
        {
            bool bItalic = (maDxfData.eItalic.get() == ITALIC_OBLIQUE) || (maDxfData.eItalic.get() == ITALIC_NORMAL);
            rStyleSheet->singleElement(XML_i,
                    XML_val, ToPsz10(bItalic),
                    FSEND);
        }

        if (maDxfData.eStrike)
        {
            bool bStrikeout =
                (maDxfData.eStrike.get() == STRIKEOUT_SINGLE) || (maDxfData.eStrike.get() == STRIKEOUT_DOUBLE) ||
                (maDxfData.eStrike.get() == STRIKEOUT_BOLD)   || (maDxfData.eStrike.get() == STRIKEOUT_SLASH)  ||
                (maDxfData.eStrike.get() == STRIKEOUT_X);

            rStyleSheet->singleElement(XML_strike,
                    XML_val, ToPsz10(bStrikeout),
                    FSEND);
        }

        if (maDxfData.bOutline)
        {
            rStyleSheet->singleElement(XML_outline,
                    XML_val, ToPsz10(maDxfData.bOutline.get()),
                    FSEND);
        }

        if (maDxfData.bShadow)
        {
            rStyleSheet->singleElement(XML_shadow,
                    XML_val, ToPsz10(maDxfData.bShadow.get()),
                    FSEND);
        }

        if (maDxfData.aColor)
        {
            rStyleSheet->singleElement(XML_color,
                    XML_rgb, XclXmlUtils::ToOString(maDxfData.aColor.get()).getStr(),
                    FSEND);
        }

        if (maDxfData.nFontHeight)
        {
            rStyleSheet->singleElement(XML_sz,
                    XML_val, OString::number(*maDxfData.nFontHeight/20).getStr(),
                    FSEND);
        }

        if (maDxfData.eUnder)
        {
            const char* pVal = getUnderlineOOXValue(maDxfData.eUnder.get());
            rStyleSheet->singleElement(XML_u,
                    XML_val, pVal,
                    FSEND);
        }

        rStyleSheet->endElement(XML_font);
    }

    XclExpBlindFont::XclExpBlindFont( const XclExpRoot& rRoot ) :
        XclExpFont( rRoot, XclFontData(), EXC_COLOR_CELLTEXT )
    {
    }

    bool XclExpBlindFont::Equals( const XclFontData& /*rFontData*/, sal_uInt32 /*nHash*/ ) const
    {
        return false;
    }

    void XclExpBlindFont::Save( XclExpStream& /*rStrm*/ )
    {
        // do nothing
    }

    XclExpFontBuffer::XclExpFontBuffer( const XclExpRoot& rRoot ) :
        XclExpRoot( rRoot ),
        mnXclMaxSize( 0 )
    {
        switch( GetBiff() )
        {
            case EXC_BIFF4: mnXclMaxSize = EXC_FONT_MAXCOUNT4;  break;
            case EXC_BIFF5: mnXclMaxSize = EXC_FONT_MAXCOUNT5;  break;
            case EXC_BIFF8: mnXclMaxSize = EXC_FONT_MAXCOUNT8;  break;
            default:        DBG_ERROR_BIFF();
        }
        InitDefaultFonts();
    }

    const XclExpFont* XclExpFontBuffer::GetFont( sal_uInt16 nXclFont ) const
    {
        return maFontList.GetRecord( nXclFont ).get();
    }

    const XclFontData& XclExpFontBuffer::GetAppFontData() const
    {
        return maFontList.GetRecord( EXC_FONT_APP )->GetFontData(); // exists always
    }

    sal_uInt16 XclExpFontBuffer::Insert(
            const XclFontData& rFontData, XclExpColorType eColorType, bool bAppFont )
    {
        if( bAppFont )
        {
            XclExpFontRef xFont( new XclExpFont( GetRoot(), rFontData, eColorType ) );
            maFontList.ReplaceRecord( xFont, EXC_FONT_APP );
            // set width of '0' character for column width export
            SetCharWidth( xFont->GetFontData() );
            return EXC_FONT_APP;
        }

        size_t nPos = Find( rFontData );
        if( nPos == EXC_FONTLIST_NOTFOUND )
        {
            // not found in buffer - create new font
            size_t nSize = maFontList.GetSize();
            if( nSize < mnXclMaxSize )
            {
                // possible to insert
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), rFontData, eColorType ) );
                nPos = nSize;       // old size is last position now
            }
            else
            {
                // buffer is full - ignore new font, use default font
                nPos = EXC_FONT_APP;
            }
        }
        return static_cast< sal_uInt16 >( nPos );
    }

    sal_uInt16 XclExpFontBuffer::Insert(
            const SvxFont& rFont, XclExpColorType eColorType )
    {
        return Insert( XclFontData( rFont ), eColorType );
    }

    sal_uInt16 XclExpFontBuffer::Insert( const SfxItemSet& rItemSet,
            sal_Int16 nScript, XclExpColorType eColorType, bool bAppFont )
    {
        // #i17050# script type now provided by caller
        vcl::Font aFont = XclExpFontHelper::GetFontFromItemSet( GetRoot(), rItemSet, nScript );
        return Insert( XclFontData( aFont ), eColorType, bAppFont );
    }

    void XclExpFontBuffer::Save( XclExpStream& rStrm )
    {
        maFontList.Save( rStrm );
    }

    void XclExpFontBuffer::SaveXml( XclExpXmlStream& rStrm )
    {
        if( maFontList.IsEmpty() )
            return;

        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_fonts,
                XML_count,  OString::number(  maFontList.GetSize() ).getStr(),
                FSEND );

        maFontList.SaveXml( rStrm );

        rStyleSheet->endElement( XML_fonts );
    }

    // private --------------------------------------------------------------------

    void XclExpFontBuffer::InitDefaultFonts()
    {
        XclFontData aFontData;
        aFontData.maName = "Arial";
        aFontData.SetScFamily( FAMILY_DONTKNOW );
        aFontData.SetFontEncoding( ScfTools::GetSystemTextEncoding() );
        aFontData.SetScHeight( 200 );   // 200 twips = 10 pt
        aFontData.SetScWeight( WEIGHT_NORMAL );

        switch( GetBiff() )
        {
            case EXC_BIFF5:
            {
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
                aFontData.SetScWeight( WEIGHT_BOLD );
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
                aFontData.SetScWeight( WEIGHT_NORMAL );
                aFontData.SetScPosture( ITALIC_NORMAL );
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
                aFontData.SetScWeight( WEIGHT_BOLD );
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
                // the blind font with index 4
                maFontList.AppendNewRecord( new XclExpBlindFont( GetRoot() ) );
                // already add the first user defined font (Excel does it too)
                aFontData.SetScWeight( WEIGHT_NORMAL );
                aFontData.SetScPosture( ITALIC_NONE );
                maFontList.AppendNewRecord( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
            }
            break;
            case EXC_BIFF8:
            {
                XclExpFontRef xFont( new XclExpFont( GetRoot(), aFontData, EXC_COLOR_CELLTEXT ) );
                maFontList.AppendRecord( xFont );
                maFontList.AppendRecord( xFont );
                maFontList.AppendRecord( xFont );
                maFontList.AppendRecord( xFont );
                if( GetOutput() == EXC_OUTPUT_BINARY )
                    // the blind font with index 4
                    maFontList.AppendNewRecord( new XclExpBlindFont( GetRoot() ) );
            }
            break;
            default:
                DBG_ERROR_BIFF();
        }
    }

    size_t XclExpFontBuffer::Find( const XclFontData& rFontData )
    {
        sal_uInt32 nHash = lclCalcHash( rFontData );
        for( size_t nPos = 0, nSize = maFontList.GetSize(); nPos < nSize; ++nPos )
            if( maFontList.GetRecord( nPos )->Equals( rFontData, nHash ) )
                return nPos;
        return EXC_FONTLIST_NOTFOUND;
    }

    // FORMAT record - number formats =============================================

    /** Predicate for search algorithm. */
    struct XclExpNumFmtPred
    {
        sal_uInt32   mnScNumFmt;
        explicit     XclExpNumFmtPred( sal_uInt32 nScNumFmt ) : mnScNumFmt( nScNumFmt ) {}
        bool         operator()( const XclExpNumFmt& rFormat ) const
                                { return rFormat.mnScNumFmt == mnScNumFmt; }
    };

    void XclExpNumFmt::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->singleElement( XML_numFmt,
                XML_numFmtId,   OString::number( mnXclNumFmt ).getStr(),
                XML_formatCode, OUStringToOString(maNumFmtString, RTL_TEXTENCODING_UTF8).getStr(),
                FSEND );
    }

    XclExpNumFmtBuffer::XclExpNumFmtBuffer( const XclExpRoot& rRoot ) :
        XclExpRoot( rRoot ),
        /*  Compiler needs a hint, this doesn't work: new NfKeywordTable;
            cannot convert from 'class String *' to 'class String (*)[54]'
            The effective result here is class String (*)[54*1] */
        mxFormatter( new SvNumberFormatter( comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US ) ),
        mpKeywordTable( new NfKeywordTable ),
        mnStdFmt( GetFormatter().GetStandardIndex( ScGlobal::eLnge ) )
    {
        switch( GetBiff() )
        {
            case EXC_BIFF5: mnXclOffset = EXC_FORMAT_OFFSET5;   break;
            case EXC_BIFF8: mnXclOffset = EXC_FORMAT_OFFSET8;   break;
            default:        mnXclOffset = 0; DBG_ERROR_BIFF();
        }

        mxFormatter->FillKeywordTableForExcel( *mpKeywordTable );
    }

    XclExpNumFmtBuffer::~XclExpNumFmtBuffer()
    {
    }

    sal_uInt16 XclExpNumFmtBuffer::Insert( sal_uInt32 nScNumFmt )
    {
        XclExpNumFmtVec::const_iterator aIt =
            ::std::find_if( maFormatMap.begin(), maFormatMap.end(), XclExpNumFmtPred( nScNumFmt ) );
        if( aIt != maFormatMap.end() )
            return aIt->mnXclNumFmt;

        size_t nSize = maFormatMap.size();
        if( nSize < static_cast< size_t >( 0xFFFF - mnXclOffset ) )
        {
            sal_uInt16 nXclNumFmt = static_cast< sal_uInt16 >( nSize + mnXclOffset );
            maFormatMap.emplace_back( nScNumFmt, nXclNumFmt, GetFormatCode( nScNumFmt ) );
            return nXclNumFmt;
        }

        return 0;
    }

    void XclExpNumFmtBuffer::Save( XclExpStream& rStrm )
    {
        for( XclExpNumFmtVec::const_iterator aIt = maFormatMap.begin(), aEnd = maFormatMap.end(); aIt != aEnd; ++aIt )
            WriteFormatRecord( rStrm, *aIt );
    }

    void XclExpNumFmtBuffer::SaveXml( XclExpXmlStream& rStrm )
    {
        if( maFormatMap.empty() )
            return;

        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_numFmts,
                XML_count,  OString::number(  maFormatMap.size() ).getStr(),
                FSEND );
        for( XclExpNumFmtVec::iterator aIt = maFormatMap.begin(), aEnd = maFormatMap.end(); aIt != aEnd; ++aIt )
        {
            aIt->SaveXml( rStrm );
        }
        rStyleSheet->endElement( XML_numFmts );
    }

    void XclExpNumFmtBuffer::WriteFormatRecord( XclExpStream& rStrm, sal_uInt16 nXclNumFmt, const OUString& rFormatStr )
    {
        XclExpString aExpStr;
        if( GetBiff() <= EXC_BIFF5 )
            aExpStr.AssignByte( rFormatStr, GetTextEncoding(), XclStrFlags::EightBitLength );
        else
            aExpStr.Assign( rFormatStr );

        rStrm.StartRecord( EXC_ID4_FORMAT, 2 + aExpStr.GetSize() );
        rStrm << nXclNumFmt << aExpStr;
        rStrm.EndRecord();
    }

    void XclExpNumFmtBuffer::WriteFormatRecord( XclExpStream& rStrm, const XclExpNumFmt& rFormat )
    {
        WriteFormatRecord( rStrm, rFormat.mnXclNumFmt, GetFormatCode( rFormat.mnScNumFmt ) );
    }

    namespace {

    OUString GetNumberFormatCode(const XclRoot& rRoot, const sal_uInt32 nScNumFmt, SvNumberFormatter* pFormatter, const NfKeywordTable* pKeywordTable)
    {
        return rRoot.GetFormatter().GetFormatStringForExcel( nScNumFmt, *pKeywordTable, *pFormatter);
    }

    }

    OUString XclExpNumFmtBuffer::GetFormatCode( sal_uInt32 nScNumFmt )
    {
        return GetNumberFormatCode( *this, nScNumFmt, mxFormatter.get(), mpKeywordTable.get() );
    }

    // XF, STYLE record - Cell formatting =========================================

    bool XclExpCellProt::FillFromItemSet( const SfxItemSet& rItemSet, bool bStyle )
    {
        const ScProtectionAttr& rProtItem = rItemSet.Get( ATTR_PROTECTION );
        mbLocked = rProtItem.GetProtection();
        mbHidden = rProtItem.GetHideFormula() || rProtItem.GetHideCell();
        return ScfTools::CheckItem( rItemSet, ATTR_PROTECTION, bStyle );
    }

    void XclExpCellProt::FillToXF3( sal_uInt16& rnProt ) const
    {
        ::set_flag( rnProt, EXC_XF_LOCKED, mbLocked );
        ::set_flag( rnProt, EXC_XF_HIDDEN, mbHidden );
    }

    void XclExpCellProt::SaveXml( XclExpXmlStream& rStrm ) const
    {
        rStrm.GetCurrentStream()->singleElement( XML_protection,
                XML_locked,     ToPsz( mbLocked ),
                XML_hidden,     ToPsz( mbHidden ),
                FSEND );
    }

    bool XclExpCellAlign::FillFromItemSet(
            const SfxItemSet& rItemSet, bool bForceLineBreak, XclBiff eBiff, bool bStyle )
    {
        bool bUsed = false;
        SvxCellHorJustify eHorAlign = rItemSet.Get( ATTR_HOR_JUSTIFY ).GetValue();
        SvxCellVerJustify eVerAlign = rItemSet.Get( ATTR_VER_JUSTIFY ).GetValue();

        switch( eBiff )
        {
            case EXC_BIFF8: // attributes new in BIFF8
            {
                // text indent
                long nTmpIndent = rItemSet.Get( ATTR_INDENT ).GetValue();
                (nTmpIndent += 100) /= 200; // 1 Excel unit == 10 pt == 200 twips
                mnIndent = limit_cast< sal_uInt8 >( nTmpIndent, 0, 15 );
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_INDENT, bStyle );

                // shrink to fit
                mbShrink = rItemSet.Get( ATTR_SHRINKTOFIT ).GetValue();
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_SHRINKTOFIT, bStyle );

                // CTL text direction
                SetScFrameDir( rItemSet.Get( ATTR_WRITINGDIR ).GetValue() );
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_WRITINGDIR, bStyle );

                SAL_FALLTHROUGH;
            }

            case EXC_BIFF5: // attributes new in BIFF5
            case EXC_BIFF4: // attributes new in BIFF4
            {
                // vertical alignment
                SetScVerAlign( eVerAlign );
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_VER_JUSTIFY, bStyle );

                // stacked/rotation
                bool bStacked = rItemSet.Get( ATTR_STACKED ).GetValue();
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_STACKED, bStyle );
                if( bStacked )
                {
                    mnRotation = EXC_ROT_STACKED;
                }
                else
                {
                    // rotation
                    sal_Int32 nScRot = rItemSet.Get( ATTR_ROTATE_VALUE ).GetValue();
                    mnRotation = XclTools::GetXclRotation( nScRot );
                    bUsed |= ScfTools::CheckItem( rItemSet, ATTR_ROTATE_VALUE, bStyle );
                }
                mnOrient = XclTools::GetXclOrientFromRot( mnRotation );

                SAL_FALLTHROUGH;
            }

            case EXC_BIFF3: // attributes new in BIFF3
            {
                // text wrap
                mbLineBreak = bForceLineBreak || rItemSet.Get( ATTR_LINEBREAK ).GetValue();
                bUsed |= bForceLineBreak || ScfTools::CheckItem( rItemSet, ATTR_LINEBREAK, bStyle );

                SAL_FALLTHROUGH;
            }

            case EXC_BIFF2: // attributes new in BIFF2
            {
                // horizontal alignment
                SetScHorAlign( eHorAlign );
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_HOR_JUSTIFY, bStyle );
            }

            break;
            default:    DBG_ERROR_BIFF();
        }

        if (eBiff == EXC_BIFF8)
        {
            // Adjust for distributed alignments.
            if (eHorAlign == SvxCellHorJustify::Block)
            {
                SvxCellJustifyMethod eHorJustMethod =
                    rItemSet.GetItem<SvxJustifyMethodItem>(ATTR_HOR_JUSTIFY_METHOD)->GetValue();
                if (eHorJustMethod == SvxCellJustifyMethod::Distribute)
                    mnHorAlign = EXC_XF_HOR_DISTRIB;
            }

            if (eVerAlign == SvxCellVerJustify::Block)
            {
                SvxCellJustifyMethod eVerJustMethod =
                    rItemSet.GetItem<SvxJustifyMethodItem>(ATTR_VER_JUSTIFY_METHOD)->GetValue();
                if (eVerJustMethod == SvxCellJustifyMethod::Distribute)
                    mnVerAlign = EXC_XF_VER_DISTRIB;
            }
        }

        return bUsed;
    }

    void XclExpCellAlign::FillToXF5( sal_uInt16& rnAlign ) const
    {
        ::insert_value( rnAlign, mnHorAlign, 0, 3 );
        ::set_flag( rnAlign, EXC_XF_LINEBREAK, mbLineBreak );
        ::insert_value( rnAlign, mnVerAlign, 4, 3 );
        ::insert_value( rnAlign, mnOrient, 8, 2 );
    }

    void XclExpCellAlign::FillToXF8( sal_uInt16& rnAlign, sal_uInt16& rnMiscAttrib ) const
    {
        ::insert_value( rnAlign, mnHorAlign, 0, 3 );
        ::set_flag( rnAlign, EXC_XF_LINEBREAK, mbLineBreak );
        ::insert_value( rnAlign, mnVerAlign, 4, 3 );
        ::insert_value( rnAlign, mnRotation, 8, 8 );
        ::insert_value( rnMiscAttrib, mnIndent, 0, 4 );
        ::set_flag( rnMiscAttrib, EXC_XF8_SHRINK, mbShrink );
        ::insert_value( rnMiscAttrib, mnTextDir, 6, 2 );
    }

    static const char* ToHorizontalAlignment( sal_uInt8 nHorAlign )
    {
        switch( nHorAlign )
        {
            case EXC_XF_HOR_GENERAL:    return "general";
            case EXC_XF_HOR_LEFT:       return "left";
            case EXC_XF_HOR_CENTER:     return "center";
            case EXC_XF_HOR_RIGHT:      return "right";
            case EXC_XF_HOR_FILL:       return "fill";
            case EXC_XF_HOR_JUSTIFY:    return "justify";
            case EXC_XF_HOR_CENTER_AS:  return "centerContinuous";
            case EXC_XF_HOR_DISTRIB:    return "distributed";
        }
        return "*unknown*";
    }

    static const char* ToVerticalAlignment( sal_uInt8 nVerAlign )
    {
        switch( nVerAlign )
        {
            case EXC_XF_VER_TOP:        return "top";
            case EXC_XF_VER_CENTER:     return "center";
            case EXC_XF_VER_BOTTOM:     return "bottom";
            case EXC_XF_VER_JUSTIFY:    return "justify";
            case EXC_XF_VER_DISTRIB:    return "distributed";
        }
        return "*unknown*";
    }

    void XclExpCellAlign::SaveXml( XclExpXmlStream& rStrm ) const
    {
        rStrm.GetCurrentStream()->singleElement( XML_alignment,
                XML_horizontal,         ToHorizontalAlignment( mnHorAlign ),
                XML_vertical,           ToVerticalAlignment( mnVerAlign ),
                XML_textRotation,       OString::number(  mnRotation ).getStr(),
                XML_wrapText,           ToPsz( mbLineBreak ),
                XML_indent,             OString::number(  mnIndent ).getStr(),
                // OOXTODO: XML_relativeIndent,     mnIndent?
                // OOXTODO: XML_justifyLastLine,
                XML_shrinkToFit,        ToPsz( mbShrink ),
                XML_readingOrder, mnTextDir == EXC_XF_TEXTDIR_CONTEXT ? nullptr : OString::number(  mnTextDir ).getStr(),
                FSEND );
    }

    namespace {

    void lclGetBorderLine(
            sal_uInt8& rnXclLine, sal_uInt32& rnColorId,
            const ::editeng::SvxBorderLine* pLine, XclExpPalette& rPalette, XclBiff eBiff )
    {
        // Document: sc/qa/unit/data/README.cellborders

        enum CalcLineIndex{Idx_None, Idx_Solid, Idx_Dotted, Idx_Dashed, Idx_FineDashed, Idx_DashDot, Idx_DashDotDot, Idx_DoubleThin, Idx_Last};
        enum ExcelWidthIndex{Width_Hair, Width_Thin, Width_Medium, Width_Thick, Width_Last};
        static sal_uInt8 Map_LineLO_toMS[Idx_Last][Width_Last] =
        {
        //    0,05  -  0,74                  0,75  -  1,49                   1,50  -  2,49                 2,50  -  9,00          Width Range [pt]
        //   EXC_BORDER_HAIR                EXC_BORDER_THIN                EXC_BORDER_MEDIUM              EXC_BORDER_THICK        MS Width
            {EXC_LINE_NONE                , EXC_LINE_NONE                , EXC_LINE_NONE                , EXC_LINE_NONE                }, //  0    BorderLineStyle::NONE
            {EXC_LINE_HAIR                , EXC_LINE_THIN                , EXC_LINE_MEDIUM              , EXC_LINE_THICK               }, //  1    BorderLineStyle::SOLID
            {EXC_LINE_DOTTED              , EXC_LINE_DOTTED              , EXC_LINE_MEDIUM_SLANT_DASHDOT, EXC_LINE_MEDIUM_SLANT_DASHDOT}, //  2    BorderLineStyle::DOTTED
            {EXC_LINE_DOTTED              , EXC_LINE_DASHED              , EXC_LINE_MEDIUM_DASHED       , EXC_LINE_MEDIUM_DASHED       }, //  3    BorderLineStyle::DASHED
            {EXC_LINE_DASHED              , EXC_LINE_DASHED              , EXC_LINE_MEDIUM_SLANT_DASHDOT, EXC_LINE_MEDIUM_SLANT_DASHDOT}, //  4    BorderLineStyle::FINE_DASHED
            {EXC_LINE_DASHED              , EXC_LINE_THIN_DASHDOT        , EXC_LINE_MEDIUM_DASHDOT      , EXC_LINE_MEDIUM_DASHDOT      }, //  5    BorderLineStyle::DASH_DOT
            {EXC_LINE_DASHED              , EXC_LINE_THIN_DASHDOTDOT     , EXC_LINE_MEDIUM_DASHDOTDOT   , EXC_LINE_MEDIUM_DASHDOTDOT   }, //  6    BorderLineStyle::DASH_DOT_DOT
            {EXC_LINE_DOUBLE              , EXC_LINE_DOUBLE              , EXC_LINE_DOUBLE              , EXC_LINE_DOUBLE              }  //  7    BorderLineStyle::DOUBLE_THIN
        };                                                                                                                                // Line  Name

        rnXclLine = EXC_LINE_NONE;
        if( pLine )
        {
            sal_uInt16 nOuterWidth = pLine->GetOutWidth();
            ExcelWidthIndex nOuterWidthIndx;
            CalcLineIndex  nStyleIndex;

            switch (pLine->GetBorderLineStyle())
            {
                case SvxBorderLineStyle::NONE:
                    nStyleIndex = Idx_None;
                    break;
                case SvxBorderLineStyle::SOLID:
                    nStyleIndex = Idx_Solid;
                    break;
                case SvxBorderLineStyle::DOTTED:
                    nStyleIndex = Idx_Dotted;
                    break;
                case SvxBorderLineStyle::DASHED:
                    nStyleIndex = Idx_Dashed;
                    break;
                case SvxBorderLineStyle::FINE_DASHED:
                    nStyleIndex = Idx_FineDashed;
                    break;
                case SvxBorderLineStyle::DASH_DOT:
                    nStyleIndex = Idx_DashDot;
                    break;
                case SvxBorderLineStyle::DASH_DOT_DOT:
                    nStyleIndex = Idx_DashDotDot;
                    break;
                case SvxBorderLineStyle::DOUBLE_THIN:
                    // the "nOuterWidth" is not right for this line type
                    // but at the moment width it not important for that
                    // the right function is nOuterWidth = (sal_uInt16) pLine->GetWidth();
                    nStyleIndex = Idx_DoubleThin;
                    break;
                default:
                    nStyleIndex = Idx_Solid;
            }

            if( nOuterWidth >= EXC_BORDER_THICK )
                nOuterWidthIndx = Width_Thick;
            else if( nOuterWidth >= EXC_BORDER_MEDIUM )
                nOuterWidthIndx = Width_Medium;
            else if( nOuterWidth >= EXC_BORDER_THIN )
                nOuterWidthIndx = Width_Thin;
            else if ( nOuterWidth >= EXC_BORDER_HAIR )
                nOuterWidthIndx = Width_Hair;
            else
                nOuterWidthIndx = Width_Thin;

            rnXclLine = Map_LineLO_toMS[nStyleIndex][nOuterWidthIndx];
        }

        if( (eBiff == EXC_BIFF2) && (rnXclLine != EXC_LINE_NONE) )
            rnXclLine = EXC_LINE_THIN;

        rnColorId = (pLine && (rnXclLine != EXC_LINE_NONE)) ?
            rPalette.InsertColor( pLine->GetColor(), EXC_COLOR_CELLBORDER ) :
            XclExpPalette::GetColorIdFromIndex( 0 );
    }

    } // namespace

    XclExpCellBorder::XclExpCellBorder() :
        mnLeftColorId(   XclExpPalette::GetColorIdFromIndex( mnLeftColor ) ),
        mnRightColorId(  XclExpPalette::GetColorIdFromIndex( mnRightColor ) ),
        mnTopColorId(    XclExpPalette::GetColorIdFromIndex( mnTopColor ) ),
        mnBottomColorId( XclExpPalette::GetColorIdFromIndex( mnBottomColor ) ),
        mnDiagColorId(   XclExpPalette::GetColorIdFromIndex( mnDiagColor ) )
    {
    }

    bool XclExpCellBorder::FillFromItemSet(
            const SfxItemSet& rItemSet, XclExpPalette& rPalette, XclBiff eBiff, bool bStyle )
    {
        bool bUsed = false;

        switch( eBiff )
        {
            case EXC_BIFF8: // attributes new in BIFF8
            {
                const SvxLineItem& rTLBRItem = rItemSet.Get( ATTR_BORDER_TLBR );
                sal_uInt8 nTLBRLine;
                sal_uInt32 nTLBRColorId;
                lclGetBorderLine( nTLBRLine, nTLBRColorId, rTLBRItem.GetLine(), rPalette, eBiff );
                mbDiagTLtoBR = (nTLBRLine != EXC_LINE_NONE);

                const SvxLineItem& rBLTRItem = rItemSet.Get( ATTR_BORDER_BLTR );
                sal_uInt8 nBLTRLine;
                sal_uInt32 nBLTRColorId;
                lclGetBorderLine( nBLTRLine, nBLTRColorId, rBLTRItem.GetLine(), rPalette, eBiff );
                mbDiagBLtoTR = (nBLTRLine != EXC_LINE_NONE);

                if( ::ScHasPriority( rTLBRItem.GetLine(), rBLTRItem.GetLine() ) )
                {
                    mnDiagLine = nTLBRLine;
                    mnDiagColorId = nTLBRColorId;
                }
                else
                {
                    mnDiagLine = nBLTRLine;
                    mnDiagColorId = nBLTRColorId;
                }

                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_BORDER_TLBR, bStyle ) ||
                         ScfTools::CheckItem( rItemSet, ATTR_BORDER_BLTR, bStyle );

                SAL_FALLTHROUGH;
            }

            case EXC_BIFF5:
            case EXC_BIFF4:
            case EXC_BIFF3:
            case EXC_BIFF2:
            {
                const SvxBoxItem& rBoxItem = rItemSet.Get( ATTR_BORDER );
                lclGetBorderLine( mnLeftLine,   mnLeftColorId,   rBoxItem.GetLeft(),   rPalette, eBiff );
                lclGetBorderLine( mnRightLine,  mnRightColorId,  rBoxItem.GetRight(),  rPalette, eBiff );
                lclGetBorderLine( mnTopLine,    mnTopColorId,    rBoxItem.GetTop(),    rPalette, eBiff );
                lclGetBorderLine( mnBottomLine, mnBottomColorId, rBoxItem.GetBottom(), rPalette, eBiff );
                bUsed |= ScfTools::CheckItem( rItemSet, ATTR_BORDER, bStyle );
            }

            break;
            default:    DBG_ERROR_BIFF();
        }

        return bUsed;
    }

    void XclExpCellBorder::SetFinalColors( const XclExpPalette& rPalette )
    {
        mnLeftColor   = rPalette.GetColorIndex( mnLeftColorId );
        mnRightColor  = rPalette.GetColorIndex( mnRightColorId );
        mnTopColor    = rPalette.GetColorIndex( mnTopColorId );
        mnBottomColor = rPalette.GetColorIndex( mnBottomColorId );
        mnDiagColor   = rPalette.GetColorIndex( mnDiagColorId );
    }

    void XclExpCellBorder::FillToXF5( sal_uInt32& rnBorder, sal_uInt32& rnArea ) const
    {
        ::insert_value( rnBorder, mnTopLine,      0, 3 );
        ::insert_value( rnBorder, mnLeftLine,     3, 3 );
        ::insert_value( rnArea,   mnBottomLine,  22, 3 );
        ::insert_value( rnBorder, mnRightLine,    6, 3 );
        ::insert_value( rnBorder, mnTopColor,     9, 7 );
        ::insert_value( rnBorder, mnLeftColor,   16, 7 );
        ::insert_value( rnArea,   mnBottomColor, 25, 7 );
        ::insert_value( rnBorder, mnRightColor,  23, 7 );
    }

    void XclExpCellBorder::FillToXF8( sal_uInt32& rnBorder1, sal_uInt32& rnBorder2 ) const
    {
        ::insert_value( rnBorder1, mnLeftLine,     0, 4 );
        ::insert_value( rnBorder1, mnRightLine,    4, 4 );
        ::insert_value( rnBorder1, mnTopLine,      8, 4 );
        ::insert_value( rnBorder1, mnBottomLine,  12, 4 );
        ::insert_value( rnBorder1, mnLeftColor,   16, 7 );
        ::insert_value( rnBorder1, mnRightColor,  23, 7 );
        ::insert_value( rnBorder2, mnTopColor,     0, 7 );
        ::insert_value( rnBorder2, mnBottomColor,  7, 7 );
        ::insert_value( rnBorder2, mnDiagColor,   14, 7 );
        ::insert_value( rnBorder2, mnDiagLine,    21, 4 );
        ::set_flag( rnBorder1, EXC_XF_DIAGONAL_TL_TO_BR, mbDiagTLtoBR );
        ::set_flag( rnBorder1, EXC_XF_DIAGONAL_BL_TO_TR, mbDiagBLtoTR );
    }

    void XclExpCellBorder::FillToCF8( sal_uInt16& rnLine, sal_uInt32& rnColor ) const
    {
        ::insert_value( rnLine,  mnLeftLine,     0, 4 );
        ::insert_value( rnLine,  mnRightLine,    4, 4 );
        ::insert_value( rnLine,  mnTopLine,      8, 4 );
        ::insert_value( rnLine,  mnBottomLine,  12, 4 );
        ::insert_value( rnColor, mnLeftColor,    0, 7 );
        ::insert_value( rnColor, mnRightColor,   7, 7 );
        ::insert_value( rnColor, mnTopColor,    16, 7 );
        ::insert_value( rnColor, mnBottomColor, 23, 7 );
    }

    static const char* ToLineStyle( sal_uInt8 nLineStyle )
    {
        switch( nLineStyle )
        {
            case EXC_LINE_NONE:              return "none";
            case EXC_LINE_THIN:              return "thin";
            case EXC_LINE_MEDIUM:            return "medium";
            case EXC_LINE_THICK:             return "thick";
            case EXC_LINE_DOUBLE:            return "double";
            case EXC_LINE_HAIR:              return "hair";
            case EXC_LINE_DOTTED:            return "dotted";
            case EXC_LINE_DASHED:            return "dashed";
            case EXC_LINE_MEDIUM_DASHED:     return "mediumDashed";
            case EXC_LINE_THIN_DASHDOT:      return "dashDot";
            case EXC_LINE_THIN_DASHDOTDOT:   return "dashDotDot";
            case EXC_LINE_MEDIUM_DASHDOT:    return "mediumDashDot";
            case EXC_LINE_MEDIUM_DASHDOTDOT: return "mediumDashDotDot";
            case EXC_LINE_MEDIUM_SLANT_DASHDOT: return "slantDashDot";
        }
        return "*unknown*";
    }

    static void lcl_WriteBorder( XclExpXmlStream& rStrm, sal_Int32 nElement, sal_uInt8 nLineStyle, const Color& rColor )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        if( nLineStyle == EXC_LINE_NONE )
            rStyleSheet->singleElement( nElement, FSEND );
        else if( rColor == Color( 0, 0, 0, 0 ) )
            rStyleSheet->singleElement( nElement,
                    XML_style,  ToLineStyle( nLineStyle ),
                    FSEND );
        else
        {
            rStyleSheet->startElement( nElement,
                    XML_style,  ToLineStyle( nLineStyle ),
                    FSEND );
            rStyleSheet->singleElement( XML_color,
                    XML_rgb,    XclXmlUtils::ToOString( rColor ).getStr(),
                    FSEND );
            rStyleSheet->endElement( nElement );
        }
    }

    void XclExpCellBorder::SaveXml( XclExpXmlStream& rStrm ) const
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();

        XclExpPalette& rPalette = rStrm.GetRoot().GetPalette();

        rStyleSheet->startElement( XML_border,
                XML_diagonalUp,     ToPsz( mbDiagBLtoTR ),
                XML_diagonalDown,   ToPsz( mbDiagTLtoBR ),
                // OOXTODO: XML_outline,
                FSEND );
        lcl_WriteBorder( rStrm, XML_left,       mnLeftLine,     rPalette.GetColor( mnLeftColor ) );
        lcl_WriteBorder( rStrm, XML_right,      mnRightLine,    rPalette.GetColor( mnRightColor ) );
        lcl_WriteBorder( rStrm, XML_top,        mnTopLine,      rPalette.GetColor( mnTopColor ) );
        lcl_WriteBorder( rStrm, XML_bottom,     mnBottomLine,   rPalette.GetColor( mnBottomColor ) );
        lcl_WriteBorder( rStrm, XML_diagonal,   mnDiagLine,     rPalette.GetColor( mnDiagColor ) );
        // OOXTODO: XML_vertical, XML_horizontal
        rStyleSheet->endElement( XML_border );
    }

    XclExpCellArea::XclExpCellArea() :
        mnForeColorId( XclExpPalette::GetColorIdFromIndex( mnForeColor ) ),
        mnBackColorId( XclExpPalette::GetColorIdFromIndex( mnBackColor ) )
    {
    }

    bool XclExpCellArea::FillFromItemSet( const SfxItemSet& rItemSet, XclExpPalette& rPalette, bool bStyle )
    {
        const SvxBrushItem& rBrushItem = rItemSet.Get( ATTR_BACKGROUND );
        if( rBrushItem.GetColor().GetTransparency() )
        {
            mnPattern = EXC_PATT_NONE;
            mnForeColorId = XclExpPalette::GetColorIdFromIndex( EXC_COLOR_WINDOWTEXT );
            mnBackColorId = XclExpPalette::GetColorIdFromIndex( EXC_COLOR_WINDOWBACK );
        }
        else
        {
            mnPattern = EXC_PATT_SOLID;
            mnForeColorId = rPalette.InsertColor( rBrushItem.GetColor(), EXC_COLOR_CELLAREA );
            mnBackColorId = XclExpPalette::GetColorIdFromIndex( EXC_COLOR_WINDOWTEXT );
        }
        return ScfTools::CheckItem( rItemSet, ATTR_BACKGROUND, bStyle );
    }

    void XclExpCellArea::SetFinalColors( const XclExpPalette& rPalette )
    {
        rPalette.GetMixedColors( mnForeColor, mnBackColor, mnPattern, mnForeColorId, mnBackColorId );
    }

    void XclExpCellArea::FillToXF5( sal_uInt32& rnArea ) const
    {
        ::insert_value( rnArea, mnPattern,   16, 6 );
        ::insert_value( rnArea, mnForeColor,  0, 7 );
        ::insert_value( rnArea, mnBackColor,  7, 7 );
    }

    void XclExpCellArea::FillToXF8( sal_uInt32& rnBorder2, sal_uInt16& rnArea ) const
    {
        ::insert_value( rnBorder2, mnPattern,   26, 6 );
        ::insert_value( rnArea,    mnForeColor,  0, 7 );
        ::insert_value( rnArea,    mnBackColor,  7, 7 );
    }

    void XclExpCellArea::FillToCF8( sal_uInt16& rnPattern, sal_uInt16& rnColor ) const
    {
        XclCellArea aTmp( *this );
        if( !aTmp.IsTransparent() && (aTmp.mnBackColor == EXC_COLOR_WINDOWTEXT) )
            aTmp.mnBackColor = 0;
        if( aTmp.mnPattern == EXC_PATT_SOLID )
            ::std::swap( aTmp.mnForeColor, aTmp.mnBackColor );
        ::insert_value( rnColor,   aTmp.mnForeColor,  0, 7 );
        ::insert_value( rnColor,   aTmp.mnBackColor,  7, 7 );
        ::insert_value( rnPattern, aTmp.mnPattern,   10, 6 );
    }

    static const char* ToPatternType( sal_uInt8 nPattern )
    {
        switch( nPattern )
        {
            case EXC_PATT_NONE:         return "none";
            case EXC_PATT_SOLID:        return "solid";
            case EXC_PATT_50_PERC:      return "mediumGray";
            case EXC_PATT_75_PERC:      return "darkGray";
            case EXC_PATT_25_PERC:      return "lightGray";
            case EXC_PATT_12_5_PERC:    return "gray125";
            case EXC_PATT_6_25_PERC:    return "gray0625";
        }
        return "*unknown*";
    }

    void XclExpCellArea::SaveXml( XclExpXmlStream& rStrm ) const
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_fill,
                FSEND );

        // OOXTODO: XML_gradientFill

        XclExpPalette& rPalette = rStrm.GetRoot().GetPalette();

        if( mnPattern == EXC_PATT_NONE || ( mnForeColor == 0 && mnBackColor == 0 ) )
            rStyleSheet->singleElement( XML_patternFill,
                    XML_patternType,    ToPatternType( mnPattern ),
                    FSEND );
        else
        {
            rStyleSheet->startElement( XML_patternFill,
                    XML_patternType,    ToPatternType( mnPattern ),
                    FSEND );
            rStyleSheet->singleElement( XML_fgColor,
                    XML_rgb,    XclXmlUtils::ToOString( rPalette.GetColor( mnForeColor ) ).getStr(),
                    FSEND );
            rStyleSheet->singleElement( XML_bgColor,
                    XML_rgb,    XclXmlUtils::ToOString( rPalette.GetColor( mnBackColor ) ).getStr(),
                    FSEND );
            rStyleSheet->endElement( XML_patternFill );
        }

        rStyleSheet->endElement( XML_fill );
    }

    bool XclExpColor::FillFromItemSet( const SfxItemSet& rItemSet )
    {
        if( !ScfTools::CheckItem( rItemSet, ATTR_BACKGROUND, true ) )
            return false;

        const SvxBrushItem& rBrushItem = rItemSet.Get( ATTR_BACKGROUND );
        maColor = rBrushItem.GetColor();

        return true;
    }

    void XclExpColor::SaveXml( XclExpXmlStream& rStrm ) const
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_fill,
                FSEND );
        rStyleSheet->startElement( XML_patternFill,
                FSEND );
        rStyleSheet->singleElement( XML_bgColor,
                XML_rgb, XclXmlUtils::ToOString(maColor).getStr(),
                FSEND );

        rStyleSheet->endElement( XML_patternFill );
        rStyleSheet->endElement( XML_fill );
    }

    XclExpXFId::XclExpXFId() :
        mnXFId( XclExpXFBuffer::GetDefCellXFId() ),
        mnXFIndex( EXC_XF_DEFAULTCELL )
    {
    }

    XclExpXFId::XclExpXFId( sal_uInt32 nXFId ) :
        mnXFId( nXFId ),
        mnXFIndex( EXC_XF_DEFAULTCELL )
    {
    }

    void XclExpXFId::ConvertXFIndex( const XclExpRoot& rRoot )
    {
        mnXFIndex = rRoot.GetXFBuffer().GetXFIndex( mnXFId );
    }

    XclExpXF::XclExpXF(
            const XclExpRoot& rRoot, const ScPatternAttr& rPattern, sal_Int16 nScript,
            sal_uInt32 nForceScNumFmt, sal_uInt16 nForceXclFont, bool bForceLineBreak ) :
        XclXFBase( true ),
        XclExpRoot( rRoot )
    {
        mnParentXFId = GetXFBuffer().InsertStyle( rPattern.GetStyleSheet() );
        Init( rPattern.GetItemSet(), nScript, nForceScNumFmt, nForceXclFont, bForceLineBreak, false );
    }

    XclExpXF::XclExpXF( const XclExpRoot& rRoot, const SfxStyleSheetBase& rStyleSheet ) :
        XclXFBase( false ),
        XclExpRoot( rRoot ),
        mnParentXFId( XclExpXFBuffer::GetXFIdFromIndex( EXC_XF_STYLEPARENT ) )
    {
        bool bDefStyle = (rStyleSheet.GetName() == ScResId( STR_STYLENAME_STANDARD ));
        sal_Int16 nScript = bDefStyle ? GetDefApiScript() : css::i18n::ScriptType::WEAK;
        Init( const_cast< SfxStyleSheetBase& >( rStyleSheet ).GetItemSet(), nScript,
            NUMBERFORMAT_ENTRY_NOT_FOUND, EXC_FONT_NOTFOUND, false, bDefStyle );
    }

    XclExpXF::XclExpXF( const XclExpRoot& rRoot, bool bCellXF ) :
        XclXFBase( bCellXF ),
        XclExpRoot( rRoot ),
        mnParentXFId( XclExpXFBuffer::GetXFIdFromIndex( EXC_XF_STYLEPARENT ) )
    {
        InitDefault();
    }

    bool XclExpXF::Equals( const ScPatternAttr& rPattern,
            sal_uInt32 nForceScNumFmt, sal_uInt16 nForceXclFont, bool bForceLineBreak ) const
    {
        return IsCellXF() && (mpItemSet == &rPattern.GetItemSet()) &&
            (!bForceLineBreak || maAlignment.mbLineBreak) &&
            ((nForceScNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND) || (mnScNumFmt == nForceScNumFmt)) &&
            ((nForceXclFont == EXC_FONT_NOTFOUND) || (mnXclFont == nForceXclFont));
    }

    bool XclExpXF::Equals( const SfxStyleSheetBase& rStyleSheet ) const
    {
        return IsStyleXF() && (mpItemSet == &const_cast< SfxStyleSheetBase& >( rStyleSheet ).GetItemSet());
    }

    void XclExpXF::SetFinalColors()
    {
        maBorder.SetFinalColors( GetPalette() );
        maArea.SetFinalColors( GetPalette() );
    }

    bool XclExpXF::Equals( const XclExpXF& rCmpXF ) const
    {
        return XclXFBase::Equals( rCmpXF ) &&
            (maProtection == rCmpXF.maProtection) && (maAlignment  == rCmpXF.maAlignment) &&
            (maBorder     == rCmpXF.maBorder)     && (maArea       == rCmpXF.maArea)      &&
            (mnXclFont    == rCmpXF.mnXclFont)    && (mnXclNumFmt  == rCmpXF.mnXclNumFmt) &&
            (mnParentXFId == rCmpXF.mnParentXFId);
    }

    void XclExpXF::InitDefault()
    {
        SetRecHeader( EXC_ID5_XF, (GetBiff() == EXC_BIFF8) ? 20 : 16 );
        mpItemSet = nullptr;
        mnScNumFmt = NUMBERFORMAT_ENTRY_NOT_FOUND;
        mnXclFont = mnXclNumFmt = 0;
        SetXmlIds(0, 0);
    }

    void XclExpXF::Init( const SfxItemSet& rItemSet, sal_Int16 nScript,
            sal_uInt32 nForceScNumFmt, sal_uInt16 nForceXclFont, bool bForceLineBreak, bool bDefStyle )
    {
        InitDefault();
        mpItemSet = &rItemSet;

        // cell protection
        mbProtUsed = maProtection.FillFromItemSet( rItemSet, IsStyleXF() );

        // font
        if( nForceXclFont == EXC_FONT_NOTFOUND )
        {
            mnXclFont = GetFontBuffer().Insert( rItemSet, nScript, EXC_COLOR_CELLTEXT, bDefStyle );
            mbFontUsed = XclExpFontHelper::CheckItems( GetRoot(), rItemSet, nScript, IsStyleXF() );
        }
        else
        {
            mnXclFont = nForceXclFont;
            mbFontUsed = true;
        }

        // number format
        if (nForceScNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND)
            mnXclNumFmt = nForceScNumFmt;
        else
        {
            // Built-in formats of dedicated languages may be attributed using the
            // system language (or even other?) format with a language attribute,
            // obtain the "real" format key.
            mnScNumFmt = rItemSet.Get( ATTR_VALUE_FORMAT ).GetValue();
            LanguageType nLang = rItemSet.Get( ATTR_LANGUAGE_FORMAT).GetLanguage();
            if (mnScNumFmt >= SV_COUNTRY_LANGUAGE_OFFSET || nLang != LANGUAGE_SYSTEM)
                mnScNumFmt = GetFormatter().GetFormatForLanguageIfBuiltIn( mnScNumFmt, nLang);
        }
        mnXclNumFmt = GetNumFmtBuffer().Insert( mnScNumFmt );
        mbFmtUsed = ScfTools::CheckItem( rItemSet, ATTR_VALUE_FORMAT, IsStyleXF() );

        // alignment
        mbAlignUsed = maAlignment.FillFromItemSet( rItemSet, bForceLineBreak, GetBiff(), IsStyleXF() );

        // cell border
        mbBorderUsed = maBorder.FillFromItemSet( rItemSet, GetPalette(), GetBiff(), IsStyleXF() );

        // background area
        mbAreaUsed = maArea.FillFromItemSet( rItemSet, GetPalette(), IsStyleXF() );

        // set all b***Used flags to true in "Default"/"Normal" style
        if( bDefStyle )
            SetAllUsedFlags( true );
    }

    sal_uInt8 XclExpXF::GetUsedFlags() const
    {
        sal_uInt8 nUsedFlags = 0;
        /*  In cell XFs a set bit means a used attribute, in style XFs a cleared bit.
            "mbCellXF == mb***Used" evaluates to correct value in cell and style XFs. */
        ::set_flag( nUsedFlags, EXC_XF_DIFF_PROT,   mbCellXF == mbProtUsed );
        ::set_flag( nUsedFlags, EXC_XF_DIFF_FONT,   mbCellXF == mbFontUsed );
        ::set_flag( nUsedFlags, EXC_XF_DIFF_VALFMT, mbCellXF == mbFmtUsed );
        ::set_flag( nUsedFlags, EXC_XF_DIFF_ALIGN,  mbCellXF == mbAlignUsed );
        ::set_flag( nUsedFlags, EXC_XF_DIFF_BORDER, mbCellXF == mbBorderUsed );
        ::set_flag( nUsedFlags, EXC_XF_DIFF_AREA,   mbCellXF == mbAreaUsed );
        return nUsedFlags;
    }

    void XclExpXF::WriteBody5( XclExpStream& rStrm )
    {
        sal_uInt16 nTypeProt = 0, nAlign = 0;
        sal_uInt32 nArea = 0, nBorder = 0;

        ::set_flag( nTypeProt, EXC_XF_STYLE, IsStyleXF() );
        ::insert_value( nTypeProt, mnParent, 4, 12 );
        ::insert_value( nAlign, GetUsedFlags(), 10, 6 );

        maProtection.FillToXF3( nTypeProt );
        maAlignment.FillToXF5( nAlign );
        maBorder.FillToXF5( nBorder, nArea );
        maArea.FillToXF5( nArea );

        rStrm << mnXclFont << mnXclNumFmt << nTypeProt << nAlign << nArea << nBorder;
    }

    void XclExpXF::WriteBody8( XclExpStream& rStrm )
    {
        sal_uInt16 nTypeProt = 0, nAlign = 0, nMiscAttrib = 0, nArea = 0;
        sal_uInt32 nBorder1 = 0, nBorder2 = 0;

        ::set_flag( nTypeProt, EXC_XF_STYLE, IsStyleXF() );
        ::insert_value( nTypeProt, mnParent, 4, 12 );
        ::insert_value( nMiscAttrib, GetUsedFlags(), 10, 6 );

        maProtection.FillToXF3( nTypeProt );
        maAlignment.FillToXF8( nAlign, nMiscAttrib );
        maBorder.FillToXF8( nBorder1, nBorder2 );
        maArea.FillToXF8( nBorder2, nArea );

        rStrm << mnXclFont << mnXclNumFmt << nTypeProt << nAlign << nMiscAttrib << nBorder1 << nBorder2 << nArea;
    }

    void XclExpXF::WriteBody( XclExpStream& rStrm )
    {
        XclExpXFId aParentId( mnParentXFId );
        aParentId.ConvertXFIndex( GetRoot() );
        mnParent = aParentId.mnXFIndex;
        switch( GetBiff() )
        {
            case EXC_BIFF5: WriteBody5( rStrm );    break;
            case EXC_BIFF8: WriteBody8( rStrm );    break;
            default:        DBG_ERROR_BIFF();
        }
    }

    void XclExpXF::SetXmlIds( sal_uInt32 nBorderId, sal_uInt32 nFillId )
    {
        mnBorderId = nBorderId;
        mnFillId   = nFillId;
    }

    void XclExpXF::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();

        sal_Int32 nXfId = 0;
        const XclExpXF* pStyleXF = nullptr;
        if( IsCellXF() )
        {
            sal_uInt16 nXFIndex = rStrm.GetRoot().GetXFBuffer().GetXFIndex( mnParentXFId );
            nXfId = rStrm.GetRoot().GetXFBuffer().GetXmlStyleIndex( nXFIndex );
            pStyleXF = rStrm.GetRoot().GetXFBuffer().GetXFById( mnParentXFId );
        }

        rStyleSheet->startElement( XML_xf,
                XML_numFmtId,           OString::number(  mnXclNumFmt ).getStr(),
                XML_fontId,             OString::number(  mnXclFont ).getStr(),
                XML_fillId,             OString::number(  mnFillId ).getStr(),
                XML_borderId,           OString::number(  mnBorderId ).getStr(),
                XML_xfId,               IsStyleXF() ? nullptr : OString::number( nXfId ).getStr(),
                // OOXTODO: XML_quotePrefix,
                // OOXTODO: XML_pivotButton,
                // OOXTODO: XML_applyNumberFormat,  ;
                XML_applyFont,          ToPsz( mbFontUsed ),
                // OOXTODO: XML_applyFill,
                XML_applyBorder,        ToPsz( mbBorderUsed ),
                XML_applyAlignment,     ToPsz( mbAlignUsed ),
                XML_applyProtection,    ToPsz( mbProtUsed ),
                FSEND );
        if( mbAlignUsed )
            maAlignment.SaveXml( rStrm );
        else if ( pStyleXF )
            pStyleXF->GetAlignmentData().SaveXml( rStrm );
        if( mbProtUsed )
            maProtection.SaveXml( rStrm );
        else if ( pStyleXF )
            pStyleXF->GetProtectionData().SaveXml( rStrm );

        // OOXTODO: XML_extLst
        rStyleSheet->endElement( XML_xf );
    }

    XclExpDefaultXF::XclExpDefaultXF( const XclExpRoot& rRoot, bool bCellXF ) :
        XclExpXF( rRoot, bCellXF )
    {
    }

    void XclExpDefaultXF::SetFont( sal_uInt16 nXclFont )
    {
        mnXclFont = nXclFont;
        mbFontUsed = true;
    }

    void XclExpDefaultXF::SetNumFmt( sal_uInt16 nXclNumFmt )
    {
        mnXclNumFmt = nXclNumFmt;
        mbFmtUsed = true;
    }

    XclExpStyle::XclExpStyle( sal_uInt32 nXFId, const OUString& rStyleName ) :
        XclExpRecord( EXC_ID_STYLE, 4 ),
        maName( rStyleName ),
        maXFId( nXFId ),
        mnStyleId( EXC_STYLE_USERDEF ),
        mnLevel( EXC_STYLE_NOLEVEL )
    {
        OSL_ENSURE( !maName.isEmpty(), "XclExpStyle::XclExpStyle - empty style name" );
    #if OSL_DEBUG_LEVEL > 0
        sal_uInt8 nStyleId, nLevel; // do not use members for debug tests
        OSL_ENSURE( !XclTools::GetBuiltInStyleId( nStyleId, nLevel, maName ),
            "XclExpStyle::XclExpStyle - this is a built-in style" );
    #endif
    }

    XclExpStyle::XclExpStyle( sal_uInt32 nXFId, sal_uInt8 nStyleId, sal_uInt8 nLevel ) :
        XclExpRecord( EXC_ID_STYLE, 4 ),
        maXFId( nXFId ),
        mnStyleId( nStyleId ),
        mnLevel( nLevel )
    {
    }

    void XclExpStyle::WriteBody( XclExpStream& rStrm )
    {
        maXFId.ConvertXFIndex( rStrm.GetRoot() );
        ::set_flag( maXFId.mnXFIndex, EXC_STYLE_BUILTIN, IsBuiltIn() );
        rStrm << maXFId.mnXFIndex;

        if( IsBuiltIn() )
        {
            rStrm << mnStyleId << mnLevel;
        }
        else
        {
            XclExpString aNameEx;
            if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
                aNameEx.Assign( maName );
            else
                aNameEx.AssignByte( maName, rStrm.GetRoot().GetTextEncoding(), XclStrFlags::EightBitLength );
            rStrm << aNameEx;
        }
    }

    static const char* lcl_StyleNameFromId( sal_Int32 nStyleId )
    {
        switch( nStyleId )
        {
            case 0:     return "Normal";
            case 3:     return "Comma";
            case 4:     return "Currency";
            case 5:     return "Percent";
            case 6:     return "Comma [0]";
            case 7:     return "Currency [0]";
        }
        return "*unknown*";
    }

    void XclExpStyle::SaveXml( XclExpXmlStream& rStrm )
    {
        constexpr sal_Int32 CELL_STYLE_MAX_BUILTIN_ID = 54;
        OString sName;
        OString sBuiltinId;
        const char* pBuiltinId = nullptr;
        if( IsBuiltIn() )
        {
            sName = OString( lcl_StyleNameFromId( mnStyleId ) );
            sBuiltinId = OString::number( std::min( static_cast<sal_Int32>( CELL_STYLE_MAX_BUILTIN_ID - 1 ), static_cast <sal_Int32>( mnStyleId ) ) );
            pBuiltinId = sBuiltinId.getStr();
        }
        else
            sName = XclXmlUtils::ToOString( maName );

        // get the index in sortedlist associated with the mnXId
        sal_Int32 nXFId = rStrm.GetRoot().GetXFBuffer().GetXFIndex( maXFId.mnXFId );
        // get the style index associated with index into sortedlist
        nXFId = rStrm.GetRoot().GetXFBuffer().GetXmlStyleIndex( nXFId );
        rStrm.GetCurrentStream()->singleElement( XML_cellStyle,
                XML_name,           sName.getStr(),
                XML_xfId,           OString::number( nXFId ).getStr(),
    // builtinId of 54 or above is invalid according to OpenXML SDK validator.
                XML_builtinId, pBuiltinId,
                // OOXTODO: XML_iLevel,
                // OOXTODO: XML_hidden,
                // XML_customBuiltin,  ToPsz( ! IsBuiltIn() ),
                FSEND );
        // OOXTODO: XML_extLst
    }

    namespace {

    const sal_uInt32 EXC_XFLIST_INDEXBASE   = 0xFFFE0000;
    /** Maximum count of XF records to store in the XF list (performance). */
    const sal_uInt32 EXC_XFLIST_HARDLIMIT   = 256 * 1024;

    bool lclIsBuiltInStyle( const OUString& rStyleName )
    {
        return
            XclTools::IsBuiltInStyleName( rStyleName ) ||
            XclTools::IsCondFormatStyleName( rStyleName );
    }

    } // namespace

    XclExpXFBuffer::XclExpBuiltInInfo::XclExpBuiltInInfo() :
        mnStyleId( EXC_STYLE_USERDEF ),
        mnLevel( EXC_STYLE_NOLEVEL ),
        mbPredefined( true ),
        mbHasStyleRec( false )
    {
    }

    /** Predicate for search algorithm. */
    struct XclExpBorderPred
    {
        const XclExpCellBorder&
                            mrBorder;
        explicit     XclExpBorderPred( const XclExpCellBorder& rBorder ) : mrBorder( rBorder ) {}
        bool                operator()( const XclExpCellBorder& rBorder ) const;
    };

    bool XclExpBorderPred::operator()( const XclExpCellBorder& rBorder ) const
    {
        return
            mrBorder.mnLeftColor     == rBorder.mnLeftColor &&
            mrBorder.mnRightColor    == rBorder.mnRightColor &&
            mrBorder.mnTopColor      == rBorder.mnTopColor &&
            mrBorder.mnBottomColor   == rBorder.mnBottomColor &&
            mrBorder.mnDiagColor     == rBorder.mnDiagColor &&
            mrBorder.mnLeftLine      == rBorder.mnLeftLine &&
            mrBorder.mnRightLine     == rBorder.mnRightLine &&
            mrBorder.mnTopLine       == rBorder.mnTopLine &&
            mrBorder.mnBottomLine    == rBorder.mnBottomLine &&
            mrBorder.mnDiagLine      == rBorder.mnDiagLine &&
            mrBorder.mbDiagTLtoBR    == rBorder.mbDiagTLtoBR &&
            mrBorder.mbDiagBLtoTR    == rBorder.mbDiagBLtoTR &&
            mrBorder.mnLeftColorId   == rBorder.mnLeftColorId &&
            mrBorder.mnRightColorId  == rBorder.mnRightColorId &&
            mrBorder.mnTopColorId    == rBorder.mnTopColorId &&
            mrBorder.mnBottomColorId == rBorder.mnBottomColorId &&
            mrBorder.mnDiagColorId   == rBorder.mnDiagColorId;
    }

    struct XclExpFillPred
    {
        const XclExpCellArea&
                            mrFill;
        explicit     XclExpFillPred( const XclExpCellArea& rFill ) : mrFill( rFill ) {}
        bool                operator()( const XclExpCellArea& rFill ) const;
    };

    bool XclExpFillPred::operator()( const XclExpCellArea& rFill ) const
    {
        return
            mrFill.mnForeColor      == rFill.mnForeColor &&
            mrFill.mnBackColor      == rFill.mnBackColor &&
            mrFill.mnPattern        == rFill.mnPattern &&
            mrFill.mnForeColorId    == rFill.mnForeColorId &&
            mrFill.mnBackColorId    == rFill.mnBackColorId;
    }

    XclExpXFBuffer::XclExpXFBuffer( const XclExpRoot& rRoot ) :
        XclExpRoot( rRoot )
    {
    }

    void XclExpXFBuffer::Initialize()
    {
        InsertDefaultRecords();
        InsertUserStyles();
    }

    sal_uInt32 XclExpXFBuffer::Insert( const ScPatternAttr* pPattern, sal_Int16 nScript )
    {
        return InsertCellXF( pPattern, nScript, NUMBERFORMAT_ENTRY_NOT_FOUND, EXC_FONT_NOTFOUND, false );
    }

    sal_uInt32 XclExpXFBuffer::InsertWithFont( const ScPatternAttr* pPattern, sal_Int16 nScript,
            sal_uInt16 nForceXclFont, bool bForceLineBreak )
    {
        return InsertCellXF( pPattern, nScript, NUMBERFORMAT_ENTRY_NOT_FOUND, nForceXclFont, bForceLineBreak );
    }

    sal_uInt32 XclExpXFBuffer::InsertWithNumFmt( const ScPatternAttr* pPattern, sal_Int16 nScript, sal_uInt32 nForceScNumFmt, bool bForceLineBreak )
    {
        return InsertCellXF( pPattern, nScript, nForceScNumFmt, EXC_FONT_NOTFOUND, bForceLineBreak );
    }

    sal_uInt32 XclExpXFBuffer::InsertStyle( const SfxStyleSheetBase* pStyleSheet )
    {
        return pStyleSheet ? InsertStyleXF( *pStyleSheet ) : GetXFIdFromIndex( EXC_XF_DEFAULTSTYLE );
    }

    sal_uInt32 XclExpXFBuffer::GetXFIdFromIndex( sal_uInt16 nXFIndex )
    {
        return EXC_XFLIST_INDEXBASE | nXFIndex;
    }

    sal_uInt32 XclExpXFBuffer::GetDefCellXFId()
    {
        return GetXFIdFromIndex( EXC_XF_DEFAULTCELL );
    }

    const XclExpXF* XclExpXFBuffer::GetXFById( sal_uInt32 nXFId ) const
    {
        return maXFList.GetRecord( nXFId ).get();
    }

    void XclExpXFBuffer::Finalize()
    {
        for( size_t nPos = 0, nSize = maXFList.GetSize(); nPos < nSize; ++nPos )
            maXFList.GetRecord( nPos )->SetFinalColors();

        sal_uInt32 nTotalCount = static_cast< sal_uInt32 >( maXFList.GetSize() );
        sal_uInt32 nId;
        maXFIndexVec.resize( nTotalCount, EXC_XF_DEFAULTCELL );
        maStyleIndexes.resize( nTotalCount, EXC_XF_DEFAULTCELL );
        maCellIndexes.resize( nTotalCount, EXC_XF_DEFAULTCELL );

        XclExpBuiltInMap::const_iterator aBuiltInEnd = maBuiltInMap.end();
        /*  nMaxBuiltInXFId used to decide faster whether an XF record is
            user-defined. If the current XF ID is greater than this value,
            maBuiltInMap doesn't need to be searched. */
        sal_uInt32 nMaxBuiltInXFId = maBuiltInMap.empty() ? 0 : maBuiltInMap.rbegin()->first;

        // *** map all built-in XF records (cell and style) *** -------------------

        // do not change XF order -> std::map<> iterates elements in ascending order
        for( XclExpBuiltInMap::const_iterator aIt = maBuiltInMap.begin(); aIt != aBuiltInEnd; ++aIt )
            AppendXFIndex( aIt->first );

        // *** insert all user-defined style XF records, without reduce *** -------

        sal_uInt32 nStyleXFCount = 0;       // counts up to EXC_XF_MAXSTYLECOUNT limit

        for( nId = 0; nId < nTotalCount; ++nId )
        {
            XclExpXFRef xXF = maXFList.GetRecord( nId );
            if( xXF->IsStyleXF() && ((nId > nMaxBuiltInXFId) || (maBuiltInMap.find( nId ) == aBuiltInEnd)) )
            {
                if( nStyleXFCount < EXC_XF_MAXSTYLECOUNT )
                {
                    // maximum count of styles not reached
                    AppendXFIndex( nId );
                    ++nStyleXFCount;
                }
                else
                {
                    /*  Maximum count of styles reached - do not append more
                        pointers to XFs; use default style XF instead; do not break
                        the loop to initialize all maXFIndexVec elements. */
                    maXFIndexVec[ nId ] = EXC_XF_DEFAULTSTYLE;
                }
            }
        }

        // *** insert all cell XF records *** -------------------------------------

        // start position to search for equal inserted XF records
        size_t nSearchStart = maSortedXFList.GetSize();

        // break the loop if XF limit reached - maXFIndexVec is already initialized with default index
        XclExpXFRef xDefCellXF = maXFList.GetRecord( EXC_XF_DEFAULTCELL );
        for( nId = 0; (nId < nTotalCount) && (maSortedXFList.GetSize() < EXC_XF_MAXCOUNT); ++nId )
        {
            XclExpXFRef xXF = maXFList.GetRecord( nId );
            if( xXF->IsCellXF() && ((nId > nMaxBuiltInXFId) || (maBuiltInMap.find( nId ) == aBuiltInEnd)) )
            {
                // try to find an XF record equal to *xXF, which is already inserted
                sal_uInt16 nFoundIndex = EXC_XF_NOTFOUND;

                // first try if it is equal to the default cell XF
                if( xDefCellXF->Equals( *xXF ) )
                {
                    nFoundIndex = EXC_XF_DEFAULTCELL;
                }
                else for( size_t nSearchPos = nSearchStart, nSearchEnd = maSortedXFList.GetSize();
                            (nSearchPos < nSearchEnd) && (nFoundIndex == EXC_XF_NOTFOUND); ++nSearchPos )
                {
                    if( maSortedXFList.GetRecord( nSearchPos )->Equals( *xXF ) )
                        nFoundIndex = static_cast< sal_uInt16 >( nSearchPos );
                }

                if( nFoundIndex != EXC_XF_NOTFOUND )
                    // equal XF already in the list, use its resulting XF index
                    maXFIndexVec[ nId ] = nFoundIndex;
                else
                    AppendXFIndex( nId );
            }
        }

        sal_uInt16 nXmlStyleIndex   = 0;
        sal_uInt16 nXmlCellIndex    = 0;

        size_t nXFCount = maSortedXFList.GetSize();
        for( size_t i = 0; i < nXFCount; ++i )
        {
            XclExpXFList::RecordRefType xXF = maSortedXFList.GetRecord( i );
            if( xXF->IsStyleXF() )
                maStyleIndexes[ i ] = nXmlStyleIndex++;
            else
                maCellIndexes[ i ] = nXmlCellIndex++;
        }
    }

    sal_uInt16 XclExpXFBuffer::GetXFIndex( sal_uInt32 nXFId ) const
    {
        sal_uInt16 nXFIndex = EXC_XF_DEFAULTSTYLE;
        if( nXFId >= EXC_XFLIST_INDEXBASE )
            nXFIndex = static_cast< sal_uInt16 >( nXFId & ~EXC_XFLIST_INDEXBASE );
        else if( nXFId < maXFIndexVec.size() )
            nXFIndex = maXFIndexVec[ nXFId ];
        return nXFIndex;
    }

    sal_Int32 XclExpXFBuffer::GetXmlStyleIndex( sal_uInt32 nXFIndex ) const
    {
        OSL_ENSURE( nXFIndex < maStyleIndexes.size(), "XclExpXFBuffer::GetXmlStyleIndex - invalid index!" );
        if( nXFIndex > maStyleIndexes.size() )
            return 0;   // should be caught/debugged via above assert; return "valid" index.
        return maStyleIndexes[ nXFIndex ];
    }

    sal_Int32 XclExpXFBuffer::GetXmlCellIndex( sal_uInt32 nXFIndex ) const
    {
        OSL_ENSURE( nXFIndex < maCellIndexes.size(), "XclExpXFBuffer::GetXmlStyleIndex - invalid index!" );
        if( nXFIndex > maCellIndexes.size() )
            return 0;   // should be caught/debugged via above assert; return "valid" index.
        return maCellIndexes[ nXFIndex ];
    }

    void XclExpXFBuffer::Save( XclExpStream& rStrm )
    {
        // save all XF records contained in the maSortedXFList vector (sorted by XF index)
        maSortedXFList.Save( rStrm );
        // save all STYLE records
        maStyleList.Save( rStrm );
    }

    static void lcl_GetCellCounts( const XclExpRecordList< XclExpXF >& rXFList, sal_Int32& rCells, sal_Int32& rStyles )
    {
        rCells  = 0;
        rStyles = 0;
        size_t nXFCount = rXFList.GetSize();
        for( size_t i = 0; i < nXFCount; ++i )
        {
            XclExpRecordList< XclExpXF >::RecordRefType xXF = rXFList.GetRecord( i );
            if( xXF->IsCellXF() )
                ++rCells;
            else if( xXF->IsStyleXF() )
                ++rStyles;
        }
    }

    void XclExpXFBuffer::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();

        rStyleSheet->startElement( XML_fills,
                XML_count,  OString::number(  maFills.size() ).getStr(),
                FSEND );
        for( XclExpFillList::iterator aIt = maFills.begin(), aEnd = maFills.end();
                aIt != aEnd; ++aIt )
        {
            aIt->SaveXml( rStrm );
        }
        rStyleSheet->endElement( XML_fills );

        rStyleSheet->startElement( XML_borders,
                XML_count,  OString::number(  maBorders.size() ).getStr(),
                FSEND );
        for( XclExpBorderList::iterator aIt = maBorders.begin(), aEnd = maBorders.end();
                aIt != aEnd; ++aIt )
        {
            aIt->SaveXml( rStrm );
        }
        rStyleSheet->endElement( XML_borders );

        // save all XF records contained in the maSortedXFList vector (sorted by XF index)
        sal_Int32 nCells, nStyles;
        lcl_GetCellCounts( maSortedXFList, nCells, nStyles );

        if( nStyles > 0 )
        {
            rStyleSheet->startElement( XML_cellStyleXfs,
                    XML_count,  OString::number( nStyles ).getStr(),
                    FSEND );
            size_t nXFCount = maSortedXFList.GetSize();
            for( size_t i = 0; i < nXFCount; ++i )
            {
                XclExpXFList::RecordRefType xXF = maSortedXFList.GetRecord( i );
                if( ! xXF->IsStyleXF() )
                    continue;
                SaveXFXml( rStrm, *xXF );
            }
            rStyleSheet->endElement( XML_cellStyleXfs );
        }

        if( nCells > 0 )
        {
            rStyleSheet->startElement( XML_cellXfs,
                    XML_count,  OString::number( nCells ).getStr(),
                    FSEND );
            size_t nXFCount = maSortedXFList.GetSize();
            for( size_t i = 0; i < nXFCount; ++i )
            {
                XclExpXFList::RecordRefType xXF = maSortedXFList.GetRecord( i );
                if( ! xXF->IsCellXF() )
                    continue;
                SaveXFXml( rStrm, *xXF );
            }
            rStyleSheet->endElement( XML_cellXfs );
        }

        // save all STYLE records
        rStyleSheet->startElement( XML_cellStyles,
                XML_count,  OString::number(  maStyleList.GetSize() ).getStr(),
                FSEND );
        maStyleList.SaveXml( rStrm );
        rStyleSheet->endElement( XML_cellStyles );
    }

    void XclExpXFBuffer::SaveXFXml( XclExpXmlStream& rStrm, XclExpXF& rXF )
    {
        XclExpBorderList::iterator aBorderPos =
            std::find_if( maBorders.begin(), maBorders.end(), XclExpBorderPred( rXF.GetBorderData() ) );
        OSL_ENSURE( aBorderPos != maBorders.end(), "XclExpXFBuffer::SaveXml - Invalid @borderId!" );
        XclExpFillList::iterator aFillPos =
            std::find_if( maFills.begin(), maFills.end(), XclExpFillPred( rXF.GetAreaData() ) );
        OSL_ENSURE( aFillPos != maFills.end(), "XclExpXFBuffer::SaveXml - Invalid @fillId!" );

        sal_Int32 nBorderId = 0, nFillId = 0;
        if( aBorderPos != maBorders.end() )
            nBorderId = std::distance( maBorders.begin(), aBorderPos );
        if( aFillPos != maFills.end() )
            nFillId = std::distance( maFills.begin(), aFillPos );

        rXF.SetXmlIds( nBorderId, nFillId );
        rXF.SaveXml( rStrm );
    }

    sal_uInt32 XclExpXFBuffer::FindXF( const ScPatternAttr& rPattern,
            sal_uInt32 nForceScNumFmt, sal_uInt16 nForceXclFont, bool bForceLineBreak ) const
    {
        for( size_t nPos = 0, nSize = maXFList.GetSize(); nPos < nSize; ++nPos )
            if( maXFList.GetRecord( nPos )->Equals( rPattern, nForceScNumFmt, nForceXclFont, bForceLineBreak ) )
                return static_cast< sal_uInt32 >( nPos );
        return EXC_XFID_NOTFOUND;
    }

    sal_uInt32 XclExpXFBuffer::FindXF( const SfxStyleSheetBase& rStyleSheet ) const
    {
        for( size_t nPos = 0, nSize = maXFList.GetSize(); nPos < nSize; ++nPos )
            if( maXFList.GetRecord( nPos )->Equals( rStyleSheet ) )
                return static_cast< sal_uInt32 >( nPos );
        return EXC_XFID_NOTFOUND;
    }

    sal_uInt32 XclExpXFBuffer::FindBuiltInXF( sal_uInt8 nStyleId, sal_uInt8 nLevel ) const
    {
        for( XclExpBuiltInMap::const_iterator aIt = maBuiltInMap.begin(), aEnd = maBuiltInMap.end(); aIt != aEnd; ++aIt )
            if( (aIt->second.mnStyleId == nStyleId) && (aIt->second.mnLevel == nLevel) )
                return aIt->first;
        return EXC_XFID_NOTFOUND;
    }

    sal_uInt32 XclExpXFBuffer::InsertCellXF( const ScPatternAttr* pPattern, sal_Int16 nScript,
            sal_uInt32 nForceScNumFmt, sal_uInt16 nForceXclFont, bool bForceLineBreak )
    {
        const ScPatternAttr* pDefPattern = GetDoc().GetDefPattern();
        if( !pPattern )
            pPattern = pDefPattern;

        // special handling for default cell formatting
        if( (pPattern == pDefPattern) && !bForceLineBreak &&
            (nForceScNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND) &&
            (nForceXclFont == EXC_FONT_NOTFOUND) )
        {
            // Is it the first try to insert the default cell format?
            bool& rbPredefined = maBuiltInMap[ EXC_XF_DEFAULTCELL ].mbPredefined;
            if( rbPredefined )
            {
                // replace default cell pattern
                XclExpXFRef xNewXF( new XclExpXF( GetRoot(), *pPattern, nScript ) );
                maXFList.ReplaceRecord( xNewXF, EXC_XF_DEFAULTCELL );
                rbPredefined = false;
            }
            return GetDefCellXFId();
        }

        sal_uInt32 nXFId = FindXF( *pPattern, nForceScNumFmt, nForceXclFont, bForceLineBreak );
        if( nXFId == EXC_XFID_NOTFOUND )
        {
            // not found - insert new cell XF
            if( maXFList.GetSize() < EXC_XFLIST_HARDLIMIT )
            {
                maXFList.AppendNewRecord( new XclExpXF(
                    GetRoot(), *pPattern, nScript, nForceScNumFmt, nForceXclFont, bForceLineBreak ) );
                // do not set nXFId before the AppendNewRecord() call - it may insert 2 XFs (style+cell)
                nXFId = static_cast< sal_uInt32 >( maXFList.GetSize() - 1 );
            }
            else
            {
                // list full - fall back to default cell XF
                nXFId = GetDefCellXFId();
            }
        }
        return nXFId;
    }

    sal_uInt32 XclExpXFBuffer::InsertStyleXF( const SfxStyleSheetBase& rStyleSheet )
    {
        // *** try, if it is a built-in style - create new XF or replace existing predefined XF ***

        sal_uInt8 nStyleId, nLevel;
        if( XclTools::GetBuiltInStyleId( nStyleId, nLevel, rStyleSheet.GetName() ) )
        {
            // try to find the built-in XF record (if already created in InsertDefaultRecords())
            sal_uInt32 nXFId = FindBuiltInXF( nStyleId, nLevel );
            if( nXFId == EXC_XFID_NOTFOUND )
            {
                // built-in style XF not yet created - do it now
                XclExpXFRef xXF( new XclExpXF( GetRoot(), rStyleSheet ) );
                nXFId = AppendBuiltInXFWithStyle( xXF, nStyleId, nLevel );
                // this new XF record is not predefined
                maBuiltInMap[ nXFId ].mbPredefined = false;
            }
            else
            {
                OSL_ENSURE( maXFList.HasRecord( nXFId ), "XclExpXFBuffer::InsertStyleXF - built-in XF not found" );
                // XF record still predefined? -> Replace with real XF
                bool& rbPredefined = maBuiltInMap[ nXFId ].mbPredefined;
                if( rbPredefined )
                {
                    // replace predefined built-in style (ReplaceRecord() deletes old record)
                    maXFList.ReplaceRecord( std::make_shared<XclExpXF>( GetRoot(), rStyleSheet ), nXFId );
                    rbPredefined = false;
                }
            }

            // STYLE already inserted? (may be not, i.e. for RowLevel/ColLevel or Hyperlink styles)
            bool& rbHasStyleRec = maBuiltInMap[ nXFId ].mbHasStyleRec;
            if( !rbHasStyleRec )
            {
                maStyleList.AppendNewRecord( new XclExpStyle( nXFId, nStyleId, nLevel ) );
                rbHasStyleRec = true;
            }

            return nXFId;
        }

        // *** try to find the XF record of a user-defined style ***

        sal_uInt32 nXFId = FindXF( rStyleSheet );
        if( nXFId == EXC_XFID_NOTFOUND )
        {
            // not found - insert new style XF and STYLE
            nXFId = static_cast< sal_uInt32 >( maXFList.GetSize() );
            if( nXFId < EXC_XFLIST_HARDLIMIT )
            {
                maXFList.AppendNewRecord( new XclExpXF( GetRoot(), rStyleSheet ) );
                // create the STYLE record
                if( !rStyleSheet.GetName().isEmpty() )
                    maStyleList.AppendNewRecord( new XclExpStyle( nXFId, rStyleSheet.GetName() ) );
            }
            else
                // list full - fall back to default style XF
                nXFId = GetXFIdFromIndex( EXC_XF_DEFAULTSTYLE );
        }
        return nXFId;
    }

    void XclExpXFBuffer::InsertUserStyles()
    {
        SfxStyleSheetIterator aStyleIter( GetDoc().GetStyleSheetPool(), SfxStyleFamily::Para );
        for( SfxStyleSheetBase* pStyleSheet = aStyleIter.First(); pStyleSheet; pStyleSheet = aStyleIter.Next() )
            if( pStyleSheet->IsUserDefined() && !lclIsBuiltInStyle( pStyleSheet->GetName() ) )
                InsertStyleXF( *pStyleSheet );
    }

    sal_uInt32 XclExpXFBuffer::AppendBuiltInXF( XclExpXFRef const & xXF, sal_uInt8 nStyleId, sal_uInt8 nLevel )
    {
        sal_uInt32 nXFId = static_cast< sal_uInt32 >( maXFList.GetSize() );
        maXFList.AppendRecord( xXF );
        XclExpBuiltInInfo& rInfo = maBuiltInMap[ nXFId ];
        rInfo.mnStyleId = nStyleId;
        rInfo.mnLevel = nLevel;
        rInfo.mbPredefined = true;
        return nXFId;
    }

    sal_uInt32 XclExpXFBuffer::AppendBuiltInXFWithStyle( XclExpXFRef const & xXF, sal_uInt8 nStyleId, sal_uInt8 nLevel )
    {
        sal_uInt32 nXFId = AppendBuiltInXF( xXF, nStyleId, nLevel );
        maStyleList.AppendNewRecord( new XclExpStyle( nXFId, nStyleId, nLevel ) );
        maBuiltInMap[ nXFId ].mbHasStyleRec = true;  // mark existing STYLE record
        return nXFId;
    }

    static XclExpCellArea lcl_GetPatternFill_None()
    {
        XclExpCellArea aFill;
        aFill.mnPattern = EXC_PATT_NONE;
        return aFill;
    }

    static XclExpCellArea lcl_GetPatternFill_Gray125()
    {
        XclExpCellArea aFill;
        aFill.mnPattern     = EXC_PATT_12_5_PERC;
        aFill.mnForeColor   = 0;
        aFill.mnBackColor   = 0;
        return aFill;
    }

    void XclExpXFBuffer::InsertDefaultRecords()
    {
        maFills.push_back( lcl_GetPatternFill_None() );
        maFills.push_back( lcl_GetPatternFill_Gray125() );

        // index 0: default style
        if( SfxStyleSheetBase* pDefStyleSheet = GetStyleSheetPool().Find( ScResId( STR_STYLENAME_STANDARD ), SfxStyleFamily::Para ) )
        {
            XclExpXFRef xDefStyle( new XclExpXF( GetRoot(), *pDefStyleSheet ) );
            sal_uInt32 nXFId = AppendBuiltInXFWithStyle( xDefStyle, EXC_STYLE_NORMAL );
            // mark this XF as not predefined, prevents overwriting
            maBuiltInMap[ nXFId ].mbPredefined = false;
        }
        else
        {
            OSL_FAIL( "XclExpXFBuffer::InsertDefaultRecords - default style not found" );
            XclExpXFRef xDefStyle( new XclExpDefaultXF( GetRoot(), false ) );
            xDefStyle->SetAllUsedFlags( true );
            AppendBuiltInXFWithStyle( xDefStyle, EXC_STYLE_NORMAL );
        }

        // index 1-14: RowLevel and ColLevel styles (without STYLE records)
        XclExpDefaultXF aLevelStyle( GetRoot(), false );
        // RowLevel_1, ColLevel_1
        aLevelStyle.SetFont( 1 );
        AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_ROWLEVEL, 0 );
        AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_COLLEVEL, 0 );
        // RowLevel_2, ColLevel_2
        aLevelStyle.SetFont( 2 );
        AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_ROWLEVEL, 1 );
        AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_COLLEVEL, 1 );
        // RowLevel_3, ColLevel_3 ... RowLevel_7, ColLevel_7
        aLevelStyle.SetFont( 0 );
        for( sal_uInt8 nLevel = 2; nLevel < EXC_STYLE_LEVELCOUNT; ++nLevel )
        {
            AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_ROWLEVEL, nLevel );
            AppendBuiltInXF( XclExpXFRef( new XclExpDefaultXF( aLevelStyle ) ), EXC_STYLE_COLLEVEL, nLevel );
        }

        // index 15: default hard cell format, placeholder to be able to add more built-in styles
        maXFList.AppendNewRecord( new XclExpDefaultXF( GetRoot(), true ) );
        maBuiltInMap[ EXC_XF_DEFAULTCELL ].mbPredefined = true;

        // index 16-20: other built-in styles
        XclExpDefaultXF aFormatStyle( GetRoot(), false );
        aFormatStyle.SetFont( 1 );
        aFormatStyle.SetNumFmt( 43 );
        AppendBuiltInXFWithStyle( XclExpXFRef( new XclExpDefaultXF( aFormatStyle ) ), EXC_STYLE_COMMA );
        aFormatStyle.SetNumFmt( 41 );
        AppendBuiltInXFWithStyle( XclExpXFRef( new XclExpDefaultXF( aFormatStyle ) ), EXC_STYLE_COMMA_0 );
        aFormatStyle.SetNumFmt( 44 );
        AppendBuiltInXFWithStyle( XclExpXFRef( new XclExpDefaultXF( aFormatStyle ) ), EXC_STYLE_CURRENCY );
        aFormatStyle.SetNumFmt( 42 );
        AppendBuiltInXFWithStyle( XclExpXFRef( new XclExpDefaultXF( aFormatStyle ) ), EXC_STYLE_CURRENCY_0 );
        aFormatStyle.SetNumFmt( 9 );
        AppendBuiltInXFWithStyle( XclExpXFRef( new XclExpDefaultXF( aFormatStyle ) ), EXC_STYLE_PERCENT );

        // other built-in style XF records (i.e. Hyperlink styles) are created on demand

        /*  Insert the real default hard cell format -> 0 is document default pattern.
            Do it here (and not already above) to really have all built-in styles. */
        Insert( nullptr, GetDefApiScript() );
    }

    void XclExpXFBuffer::AppendXFIndex( sal_uInt32 nXFId )
    {
        OSL_ENSURE( nXFId < maXFIndexVec.size(), "XclExpXFBuffer::AppendXFIndex - XF ID out of range" );
        maXFIndexVec[ nXFId ] = static_cast< sal_uInt16 >( maSortedXFList.GetSize() );
        XclExpXFRef xXF = maXFList.GetRecord( nXFId );
        AddBorderAndFill( *xXF );
        maSortedXFList.AppendRecord( xXF );
        OSL_ENSURE( maXFList.HasRecord( nXFId ), "XclExpXFBuffer::AppendXFIndex - XF not found" );
    }

    void XclExpXFBuffer::AddBorderAndFill( const XclExpXF& rXF )
    {
        if( std::none_of( maBorders.begin(), maBorders.end(), XclExpBorderPred( rXF.GetBorderData() ) ) )
        {
            maBorders.push_back( rXF.GetBorderData() );
        }

        if( std::none_of( maFills.begin(), maFills.end(), XclExpFillPred( rXF.GetAreaData() ) ) )
        {
            maFills.push_back( rXF.GetAreaData() );
        }
    }

    XclExpDxfs::XclExpDxfs( const XclExpRoot& rRoot )
        : XclExpRoot( rRoot ),
        mpKeywordTable( new NfKeywordTable )
    {
        // Special number formatter for conversion.
        SvNumberFormatterPtr xFormatter(new SvNumberFormatter( comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US ));
        xFormatter->FillKeywordTableForExcel( *mpKeywordTable );

        SCTAB nTables = rRoot.GetDoc().GetTableCount();
        sal_Int32 nIndex = 0;
        for(SCTAB nTab = 0; nTab < nTables; ++nTab)
        {
            ScConditionalFormatList* pList = rRoot.GetDoc().GetCondFormList(nTab);
            if (pList)
            {
                for (ScConditionalFormatList::const_iterator itr = pList->begin();
                        itr != pList->end(); ++itr)
                {
                    size_t nEntryCount = (*itr)->size();
                    for (size_t nFormatEntry = 0; nFormatEntry < nEntryCount; ++nFormatEntry)
                    {
                        const ScFormatEntry* pFormatEntry = (*itr)->GetEntry(nFormatEntry);
                        if (!pFormatEntry || (pFormatEntry->GetType() != ScFormatEntry::Type::Condition &&
                                    pFormatEntry->GetType() != ScFormatEntry::Type::Date))
                            continue;

                        OUString aStyleName;
                        if(pFormatEntry->GetType() == ScFormatEntry::Type::Condition)
                        {
                            const ScCondFormatEntry* pEntry = static_cast<const ScCondFormatEntry*>(pFormatEntry);
                            aStyleName= pEntry->GetStyle();
                        }
                        else
                        {
                            const ScCondDateFormatEntry* pEntry = static_cast<const ScCondDateFormatEntry*>(pFormatEntry);
                            aStyleName = pEntry->GetStyleName();
                        }

                        if (maStyleNameToDxfId.find(aStyleName) == maStyleNameToDxfId.end())
                        {
                            maStyleNameToDxfId.insert(std::pair<OUString, sal_Int32>(aStyleName, nIndex));

                            SfxStyleSheetBase* pStyle = rRoot.GetDoc().GetStyleSheetPool()->Find(aStyleName);
                            if(!pStyle)
                                continue;

                            SfxItemSet& rSet = pStyle->GetItemSet();

                            std::unique_ptr<XclExpCellBorder> pBorder(new XclExpCellBorder);
                            if (!pBorder->FillFromItemSet( rSet, GetPalette(), GetBiff()) )
                            {
                                pBorder.reset();
                            }

                            std::unique_ptr<XclExpCellAlign> pAlign(new XclExpCellAlign);
                            if (!pAlign->FillFromItemSet( rSet, false, GetBiff()))
                            {
                                pAlign.reset();
                            }

                            std::unique_ptr<XclExpCellProt> pCellProt(new XclExpCellProt);
                            if (!pCellProt->FillFromItemSet( rSet ))
                            {
                                pCellProt.reset();
                            }

                            std::unique_ptr<XclExpColor> pColor(new XclExpColor);
                            if(!pColor->FillFromItemSet( rSet ))
                            {
                                pColor.reset();
                            }

                            std::unique_ptr<XclExpDxfFont> pFont(new XclExpDxfFont(rRoot, rSet));

                            std::unique_ptr<XclExpNumFmt> pNumFormat;
                            const SfxPoolItem *pPoolItem = nullptr;
                            if( rSet.GetItemState( ATTR_VALUE_FORMAT, true, &pPoolItem ) == SfxItemState::SET )
                            {
                                sal_uInt32 nScNumFmt = static_cast< const SfxUInt32Item* >(pPoolItem)->GetValue();
                                sal_Int32 nXclNumFmt = GetRoot().GetNumFmtBuffer().Insert(nScNumFmt);
                                pNumFormat.reset(new XclExpNumFmt( nScNumFmt, nXclNumFmt, GetNumberFormatCode( *this, nScNumFmt, xFormatter.get(), mpKeywordTable.get() )));
                            }

                            maDxf.push_back(o3tl::make_unique<XclExpDxf>( rRoot, std::move(pAlign), std::move(pBorder),
                                    std::move(pFont), std::move(pNumFormat), std::move(pCellProt), std::move(pColor) ));
                            ++nIndex;
                        }

                    }
                }
            }
        }
    }

    sal_Int32 XclExpDxfs::GetDxfId( const OUString& rStyleName )
    {
        std::map<OUString, sal_Int32>::iterator itr = maStyleNameToDxfId.find(rStyleName);
        if(itr!= maStyleNameToDxfId.end())
            return itr->second;
        return -1;
    }

    void XclExpDxfs::SaveXml( XclExpXmlStream& rStrm )
    {
        if(maDxf.empty())
            return;

        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_dxfs,
                XML_count, OString::number(maDxf.size()).getStr(),
                FSEND );

        for ( DxfContainer::iterator itr = maDxf.begin(); itr != maDxf.end(); ++itr )
        {
            (*itr)->SaveXml( rStrm );
        }

        rStyleSheet->endElement( XML_dxfs );
    }

    XclExpDxf::XclExpDxf( const XclExpRoot& rRoot, std::unique_ptr<XclExpCellAlign> pAlign, std::unique_ptr<XclExpCellBorder> pBorder,
                std::unique_ptr<XclExpDxfFont> pFont, std::unique_ptr<XclExpNumFmt> pNumberFmt, std::unique_ptr<XclExpCellProt> pProt,
                std::unique_ptr<XclExpColor> pColor)
        : XclExpRoot( rRoot ),
        mpAlign(std::move(pAlign)),
        mpBorder(std::move(pBorder)),
        mpFont(std::move(pFont)),
        mpNumberFmt(std::move(pNumberFmt)),
        mpProt(std::move(pProt)),
        mpColor(std::move(pColor))
    {
    }

    XclExpDxf::~XclExpDxf()
    {
    }

    void XclExpDxf::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr& rStyleSheet = rStrm.GetCurrentStream();
        rStyleSheet->startElement( XML_dxf, FSEND );

        if (mpFont)
            mpFont->SaveXml(rStrm);
        if (mpNumberFmt)
            mpNumberFmt->SaveXml(rStrm);
        if (mpColor)
            mpColor->SaveXml(rStrm);
        if (mpAlign)
            mpAlign->SaveXml(rStrm);
        if (mpBorder)
            mpBorder->SaveXml(rStrm);
        if (mpProt)
            mpProt->SaveXml(rStrm);
        rStyleSheet->endElement( XML_dxf );
    }

    XclExpXmlStyleSheet::XclExpXmlStyleSheet( const XclExpRoot& rRoot )
        : XclExpRoot( rRoot )
    {
    }

    void XclExpXmlStyleSheet::SaveXml( XclExpXmlStream& rStrm )
    {
        sax_fastparser::FSHelperPtr aStyleSheet = rStrm.CreateOutputStream(
                "xl/styles.xml",
                "styles.xml",
                rStrm.GetCurrentStream()->getOutputStream(),
                "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
                rtl::OUStringToOString(oox::getRelationship(Relationship::STYLES), RTL_TEXTENCODING_UTF8).getStr());
        rStrm.PushStream( aStyleSheet );

        aStyleSheet->startElement( XML_styleSheet,
                XML_xmlns, XclXmlUtils::ToOString(rStrm.getNamespaceURL(OOX_NS(xls))).getStr(),
                FSEND );

        CreateRecord( EXC_ID_FORMATLIST )->SaveXml( rStrm );
        CreateRecord( EXC_ID_FONTLIST )->SaveXml( rStrm );
        CreateRecord( EXC_ID_XFLIST )->SaveXml( rStrm );
        CreateRecord( EXC_ID_DXFS )->SaveXml( rStrm );
        CreateRecord( EXC_ID_PALETTE )->SaveXml( rStrm );

        aStyleSheet->endElement( XML_styleSheet );

        rStrm.PopStream();
    }

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

↑ V557 Array overrun is possible. The 'nXFIndex' index is pointing beyond array bound.

↑ V557 Array overrun is possible. The 'nXFIndex' index is pointing beyond array bound.

↑ V547 Expression 'pVal' is always true.