Version 7.5.1.1, tag libreoffice-7.5.1.1

[LibreOffice.git] / sc / source / filter / inc / xestyle.hxx

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

#pragma once

#include <map>
#include <svl/zforlist.hxx>
#include <svl/nfkeytab.hxx>
#include <editeng/svxfont.hxx>
#include "xerecord.hxx"
#include "xlstyle.hxx"
#include "xeroot.hxx"
#include <fonthelper.hxx>
#include <memory>
#include <utility>
#include <vector>

/* ============================================================================
- Buffers for style records (PALETTE, FONT, FORMAT, XF, STYLE).
============================================================================ */

const sal_uInt16 EXC_ID_FONTLIST    = 0x8031;   /// For internal use only.
const sal_uInt16 EXC_ID_FORMATLIST  = 0x801E;   /// For internal use only.
const sal_uInt16 EXC_ID_XFLIST      = 0x8043;   /// For internal use only.
const sal_uInt16 EXC_ID_DXFS        = 0x9999;   /// For internal use only. TODO:moggi: find a better/correct value

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

/** Different types of colors in a document. */
enum XclExpColorType
{
    EXC_COLOR_CELLTEXT,         /// Text in a cell.
    EXC_COLOR_CELLBORDER,       /// Border of a cell.
    EXC_COLOR_CELLAREA,         /// Background area of a cell.
    EXC_COLOR_CHARTTEXT,        /// Text color in a chart.
    EXC_COLOR_CHARTLINE,        /// Line in a chart.
    EXC_COLOR_CHARTAREA,        /// Area in a chart.
    EXC_COLOR_CTRLTEXT,         /// Text color in a form control.
    EXC_COLOR_GRID,              /// Spreadsheet grid color.
    EXC_COLOR_TABBG             /// Spreadsheet tab bg color.
};

class XclExpPaletteImpl;

/** Stores all used colors in the document.

    Supports color reduction to the maximum count of the current BIFF version.
    An instance of this class collects all colors in the conversion phase of
    the export, using the InsertColor() function. It returns a unique
    identifier for each passed color.

    After the entire document is converted, the Finalize() function will reduce
    the palette to the  number of colors supported by the current BIFF version.

    Then, in the streaming phase, the functions GetColorIndex() and
    GetMixedColors() return the real Excel palette index for all color
    identifiers.
 */
class XclExpPalette : public XclDefaultPalette, public XclExpRecord
{
public:
    explicit            XclExpPalette( const XclExpRoot& rRoot );
    virtual             ~XclExpPalette() override;

    /** 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 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;

    /** Saves the PALETTE record, if it differs from the default palette. */
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    /** Writes the contents of the PALETTE record. */
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    typedef std::shared_ptr< XclExpPaletteImpl > XclExpPaletteImplRef;
    XclExpPaletteImplRef mxImpl;
};

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

const size_t EXC_FONTLIST_NOTFOUND = static_cast< size_t >( -1 );

/** Helper functions for font export. */
namespace XclExpFontHelper
{
    /** Returns the script type of the first font item found in the item set and its parents. */
    sal_Int16    GetFirstUsedScript(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet );

    /** Returns a VCL font object filled from the passed item set. */
    vcl::Font    GetFontFromItemSet(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript );

    /**
     * Get a dxf related font object from the item set.
     * Only items that are explicitly set in the item set
     * are also set in the returned object.
     */
    ScDxfFont GetDxfFontFromItemSet(const XclExpRoot& rRoot, const SfxItemSet& rSet);

    /** Returns true, if at least one font related item is set in the passed item set.
        @param bDeep  true = Searches in parent item sets too. */
    bool         CheckItems(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript,
                            bool bDeep );
}

/** Stores all data of an Excel font and provides export of FONT records. */
class XclExpFont : public XclExpRecord, protected XclExpRoot
{
public:
    explicit            XclExpFont( const XclExpRoot& rRoot,
                            const XclFontData& rFontData, XclExpColorType eColorType );

    /** Returns read-only access to font data. */
    const XclFontData& GetFontData() const { return maData; }
    /** Returns the font color identifier. */
    sal_uInt32   GetFontColorId() const { return mnColorId; }
    /** Compares this font with the passed font data.
        @param nHash  The hash value calculated from the font data. */
    virtual bool        Equals( const XclFontData& rFontData, sal_uInt32 nHash ) const;

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    /** Writes the contents of the FONT record. */
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclFontData         maData;         /// All font attributes.
    sal_uInt32          mnColorId;      /// Unique color ID for text color.
    sal_uInt32          mnHash;         /// Hash value for fast comparison.
};

class XclExpDxfFont : public XclExpRecordBase, protected XclExpRoot
{
public:
    XclExpDxfFont(const XclExpRoot& rRoot, const SfxItemSet& rItemSet);

    virtual void SaveXml(XclExpXmlStream& rStrm) override;
private:

    ScDxfFont maDxfData;
};

/** Used as placeholder for font index 4, which is not used in Excel. */
class XclExpBlindFont : public XclExpFont
{
public:
    explicit            XclExpBlindFont( const XclExpRoot& rRoot );

    /** Returns always false to never find this font while searching the font list. */
    virtual bool        Equals( const XclFontData& rFontData, sal_uInt32 nHash ) const override;

    /** Skips writing this record. */
    virtual void        Save( XclExpStream& rStrm ) override;
};

class ScPatternAttr;

/** Stores the data of all fonts used in the document. */
class XclExpFontBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpFontBuffer( const XclExpRoot& rRoot );

    /** Returns the specified font from font list. */
    const XclExpFont*   GetFont( sal_uInt16 nXclFont ) const;
    /** Returns the application font data of this file, needed e.g. for column width. */
    const XclFontData&  GetAppFontData() const;

    /** Inserts a new font with the passed font data into the buffer if not present.
        @param bAppFont  true = Sets the application font; false = Inserts a new font.
        @return  The resulting Excel font index. */
    sal_uInt16          Insert( const XclFontData& rFontData,
                            XclExpColorType eColorType, bool bAppFont = false );
    /** Inserts the SvxFont into the buffer if not present, e.g. where escapements are used.
        @return  The resulting Excel font index. */
    sal_uInt16          Insert( const SvxFont& rFont,
                            XclExpColorType eColorType );
    /** Inserts the font contained in the passed item set into the buffer, if not present.
        @param nScript  The script type of the font properties to be used.
        @param bAppFont  true = Sets the application font; false = Inserts a new font.
        @return  The resulting Excel font index. */
    sal_uInt16          Insert( const SfxItemSet& rItemSet, sal_Int16 nScript,
                            XclExpColorType eColorType, bool bAppFont );

    /** Writes all FONT records contained in this buffer. */
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    /** Initializes the default fonts for the current BIFF version. */
    void                InitDefaultFonts();
    /** Tries to find the passed font and returns the current list index. */
    size_t              Find( const XclFontData& rFontData );

private:
    typedef XclExpRecordList< XclExpFont >  XclExpFontList;
    typedef XclExpFontList::RecordRefType   XclExpFontRef;

    XclExpFontList      maFontList;     /// List of all FONT records.
    size_t              mnXclMaxSize;   /// Maximum number of fonts.
};

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

/** Stores a core number format index with corresponding Excel format index. */
struct XclExpNumFmt
{
    sal_uInt32          mnScNumFmt;     /// Core index of the number format.
    sal_uInt16          mnXclNumFmt;    /// Resulting Excel format index.
    OUString            maNumFmtString; /// format string

    explicit     XclExpNumFmt( sal_uInt32 nScNumFmt, sal_uInt16 nXclNumFmt, OUString aFrmt ) :
                            mnScNumFmt( nScNumFmt ), mnXclNumFmt( nXclNumFmt ), maNumFmtString(std::move( aFrmt )) {}

    void SaveXml( XclExpXmlStream& rStrm );
};

typedef ::std::unique_ptr< SvNumberFormatter >    SvNumberFormatterPtr;

/** Stores all number formats used in the document. */
class XclExpNumFmtBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpNumFmtBuffer( const XclExpRoot& rRoot );
    virtual             ~XclExpNumFmtBuffer() override;

    /** Returns the core index of the current standard number format. */
    sal_uInt32   GetStandardFormat() const { return mnStdFmt; }

    /** Inserts a number format into the format buffer.
        @param nScNumFmt  The core index of the number format.
        @return  The resulting Excel format index. */
    sal_uInt16          Insert( sal_uInt32 nScNumFmt );

    /** Writes all FORMAT records contained in this buffer. */
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

    OUString            GetFormatCode ( sal_uInt32 nScNumFmt );

private:
    /** Writes the FORMAT record with index nXclIx and format string rFormatStr. */
    void                WriteFormatRecord( XclExpStream& rStrm, sal_uInt16 nXclNumFmt, const OUString& rFormatStr );
    /** Writes the FORMAT record represented by rFormat. */
    void                WriteFormatRecord( XclExpStream& rStrm, const XclExpNumFmt& rFormat );

private:
    typedef ::std::vector< XclExpNumFmt >           XclExpNumFmtVec;

    SvNumberFormatterPtr mxFormatter;   /// Special number formatter for conversion.
    XclExpNumFmtVec     maFormatMap;    /// Maps core formats to Excel indexes.
    std::unique_ptr<NfKeywordTable>   mpKeywordTable; /// Replacement table.
    sal_uInt32          mnStdFmt;       /// Key for standard number format.
    sal_uInt16          mnXclOffset;    /// Offset to first user defined format.
};

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

/** Extends the XclCellProt struct for export.
    @descr  Provides functions to fill from item sets and to fill to Excel record data. */
struct XclExpCellProt : public XclCellProt
{
    /** Fills the protection attributes from the passed item set.
        @return  true = At least one protection item is set. */
    bool                FillFromItemSet( const SfxItemSet& rItemSet, bool bStyle = false );

    /** Fills the data to the passed fields of a BIFF3-BIFF8 XF record. */
    void                FillToXF3( sal_uInt16& rnProt ) const;

    void                SaveXml( XclExpXmlStream& rStrm ) const;
};

/** Extends the XclCellAlign struct for export.
    @descr  Provides functions to fill from item sets and to fill to Excel record data. */
struct XclExpCellAlign : public XclCellAlign
{
    /** Fills the alignment attributes from the passed item set.
        @descr  Fills only the attributes exported in the passed BIFF version.
        @param bForceLineBreak  true = Set line break flag unconditionally.
        @return  true = At least one alignment item is set. */
    bool                FillFromItemSet(const XclRoot& rRoot, const SfxItemSet& rItemSet,
                            bool bForceLineBreak, XclBiff eBiff, bool bStyle = false );

    /** Fills the data to the passed fields of a BIFF5/BIFF7 XF record. */
    void                FillToXF5( sal_uInt16& rnAlign ) const;
    /** Fills the data to the passed fields of a BIFF8 XF record. */
    void                FillToXF8( sal_uInt16& rnAlign, sal_uInt16& rnMiscAttrib ) const;

    void                SaveXml( XclExpXmlStream& rStrm ) const;
};

/** Extends the XclCellBorder struct for export.
    @descr  Provides functions to fill from item sets and to fill to Excel record data. */
struct XclExpCellBorder : public XclCellBorder
{
    sal_uInt32          mnLeftColorId;      /// Color ID for left line.
    sal_uInt32          mnRightColorId;     /// Color ID for right line.
    sal_uInt32          mnTopColorId;       /// Color ID for top line.
    sal_uInt32          mnBottomColorId;    /// Color ID for bottom line.
    sal_uInt32          mnDiagColorId;      /// Color ID for diagonal line(s).

    explicit            XclExpCellBorder();

    /** Fills the border attributes from the passed item set.
        @descr  Fills only the attributes exported in the passed BIFF version.
        @return  true = At least one border item is set. */
    bool                FillFromItemSet( const SfxItemSet& rItemSet,
                            XclExpPalette& rPalette, XclBiff eBiff, bool bStyle = false );
    /** Fills the mn***Color base members from the mn***ColorId members. */
    void                SetFinalColors( const XclExpPalette& rPalette );

    /** Fills the data to the passed fields of a BIFF5/BIFF7 XF record. */
    void                FillToXF5( sal_uInt32& rnBorder, sal_uInt32& rnArea ) const;
    /** Fills the data to the passed fields of a BIFF8 XF record. */
    void                FillToXF8( sal_uInt32& rnBorder1, sal_uInt32& rnBorder2 ) const;

    /** Fills the data to the passed fields of a BIFF8 CF (conditional format) record. */
    void                FillToCF8( sal_uInt16& rnLine, sal_uInt32& rnColor ) const;

    void                SaveXml( XclExpXmlStream& rStrm ) const;
};

/** Extends the XclCellArea struct for export.
    @descr  Provides functions to fill from item sets and to fill to Excel record data. */
struct XclExpCellArea : public XclCellArea
{
    sal_uInt32          mnForeColorId;  /// Foreground color ID.
    sal_uInt32          mnBackColorId;  /// Background color ID.
    Color maForeColor; // Actual foreground color
    Color maBackColor; // Actual background color

    explicit            XclExpCellArea();
    explicit            XclExpCellArea(Color aForeColor, Color aBackColor);

    /** Fills the area attributes from the passed item set.
        @return  true = At least one area item is set. */
    bool                FillFromItemSet(
                            const SfxItemSet& rItemSet, XclExpPalette& rPalette,
                            bool bStyle );
    /** Fills the mn***Color base members from the mn***ColorId members. */
    void                SetFinalColors( const XclExpPalette& rPalette );

    /** Fills the data to the passed fields of a BIFF5/BIFF7 XF record. */
    void                FillToXF5( sal_uInt32& rnArea ) const;
    /** Fills the data to the passed fields of a BIFF8 XF record. */
    void                FillToXF8( sal_uInt32& rnBorder2, sal_uInt16& rnArea ) const;

    /** Fills the data to the passed fields of a BIFF8 CF (conditional format) record. */
    void                FillToCF8( sal_uInt16& rnPattern, sal_uInt16& rnColor ) const;

    void                SaveXml( XclExpXmlStream& rStrm ) const;
};

struct XclExpColor
{
    Color maColor;

    bool FillFromItemSet( const SfxItemSet& rItemSet );

    void SaveXml( XclExpXmlStream& rStrm ) const;
};

/** A combination of unique XF identifier with real Excel XF index. */
struct XclExpXFId
{
    sal_uInt32          mnXFId;         /// Temporary XF identifier.
    sal_uInt16          mnXFIndex;      /// Real Excel XF index.

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

    /** Converts the XF identifier in mnXFId to an Excel XF index and stores it in mnXFIndex. */
    void                ConvertXFIndex( const XclExpRoot& rRoot );
};

class SfxStyleSheetBase;

/** Represents an XF record which contains all formatting data of a cell or cell style. */
class XclExpXF : public XclXFBase, public XclExpRecord, protected XclExpRoot
{
public:
    /** Constructs a cell XF record from the passed Calc cell formatting. */
    explicit            XclExpXF(
                            const XclExpRoot& rRoot,
                            const ScPatternAttr& rPattern,
                            sal_Int16 nScript,
                            sal_uInt32 nScForceNumFmt = NUMBERFORMAT_ENTRY_NOT_FOUND,
                            sal_uInt16 nForceXclFont = EXC_FONT_NOTFOUND,
                            bool bForceLineBreak = false );
    /** Constructs a style XF record from the passed cell style sheet. */
    explicit            XclExpXF(
                            const XclExpRoot& rRoot,
                            const SfxStyleSheetBase& rStyleSheet );

    /** Returns the cell protection settings of this XF. */
    const XclExpCellProt& GetProtectionData() const { return maProtection; }
    /** Returns the alignment settings of this XF. */
    const XclExpCellAlign& GetAlignmentData() const { return maAlignment; }
    /** Returns the cell border settings of this XF. */
    const XclExpCellBorder& GetBorderData() const { return maBorder; }
    /** Returns the cell fill settings of this XF. */
    const XclExpCellArea& GetAreaData() const { return maArea; }

    /** Returns true, if this XF record represents the passed cell formatting.
        @descr  Searches for cell XFs only. */
    bool                Equals(
                            const ScPatternAttr& rPattern,
                            sal_uInt32 nScForceNumFmt,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak ) const;

    /** Returns true, if this XF record represents the passed style.
        @descr  Searches for style XFs only. */
    bool                Equals( const SfxStyleSheetBase& rStyleSheet ) const;

    /** Sets the resulting Excel palette index from all used color IDs (border and area). */
    void                SetFinalColors();

    /** Returns true, if this XF record is completely equal to the passed. */
    bool                Equals( const XclExpXF& rCmpXF ) const;

    void                SetXmlIds( sal_uInt32 nBorderId, sal_uInt32 nFillId );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

    const SfxItemSet*   GetItemSet() const { return mpItemSet; }

    sal_uInt32          GetScNumFmt() const { return mnScNumFmt; }
    sal_uInt16          GetXclFont() const { return mnXclFont; }

protected:
    explicit            XclExpXF( const XclExpRoot& rRoot, bool bCellXF );

protected:  // access for XclExpDefaultXF
    const SfxItemSet*   mpItemSet;          /// Pointer to the item set (we do not own it).

    XclExpCellProt      maProtection;       /// Cell protection flags.
    XclExpCellAlign     maAlignment;        /// All alignment attributes.
    XclExpCellBorder    maBorder;           /// Border line style.
    XclExpCellArea      maArea;             /// Background area style.
    sal_uInt32          mnParentXFId;       /// XF ID of parent XF record.
    sal_uInt32          mnScNumFmt;         /// Calc number format index.
    sal_uInt16          mnXclFont;          /// Excel font index.
    sal_uInt16          mnXclNumFmt;        /// Excel number format index.
    sal_Int32           mnBorderId;         /// OOXML Border Index
    sal_Int32           mnFillId;           /// OOXML Fill Index

private:
    using               XclXFBase::Equals;

    /** Initializes with default values. */
    void                InitDefault();
    /** Fills all members from the passed item set.
        @param bDefStyle  true = This is the "Default"/"Normal" style - needs special handling. */
    void                Init(
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak,
                            bool bDefStyle );

    /** Returns the bits specifying the used attributes.
        @descr  In cell XFs a set bit means a used attribute, in style XF a cleared
        bit means a used attribute. This method regards the cell/style state.
        @return  The mask based on bit 0 (not yet bit-shifted as needed for export). */
    sal_uInt8           GetUsedFlags() const;

    void                WriteBody5( XclExpStream& rStrm );
    void                WriteBody8( XclExpStream& rStrm );

    /** Writes the contents of the XF record. */
    virtual void        WriteBody( XclExpStream& rStrm ) override;
};

/** Represents a default XF record. Supports methods to set attributes directly. */
class XclExpDefaultXF : public XclExpXF
{
public:
    explicit            XclExpDefaultXF( const XclExpRoot& rRoot, bool bCellXF );

    /** Sets the Excel font index. */
    void                SetFont( sal_uInt16 nXclFont );
    /** Sets the Excel number format index. */
    void                SetNumFmt( sal_uInt16 nXclNumFmt );
};

/** Represents a STYLE record containing the data of a cell style.
    @descr  The class is able to store built-in and user-defined styles. */
class XclExpStyle : public XclExpRecord
{
public:
    explicit            XclExpStyle( sal_uInt32 nXFId, OUString aStyleName );
    explicit            XclExpStyle( sal_uInt32 nXFId, sal_uInt8 nStyleId, sal_uInt8 nLevel );

    /** Returns true, if this record represents an Excel built-in style. */
    bool         IsBuiltIn() const { return mnStyleId != EXC_STYLE_USERDEF; }

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    /** Writes the contents of the STYLE record. */
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    OUString            maName;         /// Name of the cell style.
    XclExpXFId          maXFId;         /// XF identifier for style formatting.
    sal_uInt8           mnStyleId;      /// Built-in style identifier.
    sal_uInt8           mnLevel;        /// Outline level for RowLevel and ColLevel styles.
};

/** Stores all XF records (cell formats and cell styles) in the document.

    Stores also the names of user defined cell styles (STYLE records). Supports
    reduction to the maximum count of XF records of the current BIFF version.

    An instance of this class collects all XF records in the conversion phase
    of the export, using the Insert() and InsertStyle() functions. It returns a
    unique identifier for each XF record.

    After the entire document is converted, the Finalize() function will reduce
    the list to the number of XF records supported by the current BIFF version.

    Then, in the streaming phase, the function GetXFIndex() returns the real
    Excel XF index for all XF identifiers.
 */
class XclExpXFBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpXFBuffer( const XclExpRoot& rRoot );

    /** Inserts predefined built-in styles and user-defined styles. */
    void                Initialize();

    /** Finds or creates a cell XF record for the passed item set.
        @return  A unique XF record ID. */
    sal_uInt32          Insert( const ScPatternAttr* pPattern, sal_Int16 nScript );
    /** Finds or creates a cell XF record for the passed item set.
        @param nForceXclFont  The font to be exported. If not equal to EXC_FONT_NOTFOUND,
            this font index will be used unconditionally and the cell font will be ignored.
        @param bForceLineBreak  true = Set line break flag unconditionally.
            This is required for cells that contain multi-line text.
        @return  A unique XF record ID. */
    sal_uInt32          InsertWithFont(
                            const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak );
    /** Finds or creates a cell XF record for the passed item set, with custom number format.
        @param nXFFlags  Additional flags allowing to control the creation of an XF.
        @param nForceScNumFmt  The number format to be exported, e.g. formula
            result type. This format will always overwrite the cell's number format.
        @param bForceLineBreak  true = Set line break flag unconditionally.
            This is required for cells that contain multi-line text.
        @return  A unique XF record ID. */
    sal_uInt32          InsertWithNumFmt(
                            const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            bool bForceLineBreak );
    /** Inserts the passed cell style. Creates a style XF record and a STYLE record.
        @return  A unique XF record ID. */
    sal_uInt32          InsertStyle( const SfxStyleSheetBase* pStyleSheet );
    /** Returns the XF identifier representing a fixed Excel XF index (e.g. for built-in XFs). */
    static sal_uInt32   GetXFIdFromIndex( sal_uInt16 nXFIndex );
    /** Returns the XF identifier representing the default cell XF. */
    static sal_uInt32   GetDefCellXFId();

    /** Returns an XF record by its unique identifier. */
    const XclExpXF*     GetXFById( sal_uInt32 nXFId ) const;

    /** Reduces the XF record list to the maximum allowed number of records. */
    void                Finalize();

    /** Returns the Excel XF index of the XF record with passed XF ID. */
    sal_uInt16          GetXFIndex( sal_uInt32 nXFId ) const;

    sal_Int32           GetXmlStyleIndex( sal_uInt32 nXFId ) const;
    sal_Int32           GetXmlCellIndex( sal_uInt32 nXFId ) const;

    /** Writes all XF records contained in this buffer. */
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    typedef XclExpRecordList< XclExpXF >    XclExpXFList;
    typedef XclExpXFList::RecordRefType     XclExpXFRef;

private:
    /** Returns the XF ID of the cell XF containing the passed format. */
    sal_uInt32          FindXF( const ScPatternAttr& rPattern, sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont, bool bForceLineBreak ) const;
    /** Returns the XF ID of the style XF containing the passed style. */
    sal_uInt32          FindXF( const SfxStyleSheetBase& rStyleSheet ) const;

    /** Returns the XF ID of a built-in style XF, searches by style identifier. */
    sal_uInt32          FindBuiltInXF( sal_uInt8 nStyleId, sal_uInt8 nLevel ) const;

    /** Tries to find the XF record containing the passed format or inserts a new record.
        @return  The XF record ID. */
    sal_uInt32          InsertCellXF( const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont, bool bForceLineBreak );
    /** Inserts the passed cell style. Creates a style XF record and a STYLE record.
        @return  The XF record ID. */
    sal_uInt32          InsertStyleXF( const SfxStyleSheetBase& rStyleSheet );

    /** Inserts an XF and a STYLE record for all user defined style sheets. */
    void                InsertUserStyles();

    /** Inserts a built-in XF record without a STYLE record and returns the XF ID.
        @param bCreateStyleRec  true = Creates the related STYLE record. */
    sal_uInt32          AppendBuiltInXF( XclExpXFRef const & xXF,
                            sal_uInt8 nStyleId, sal_uInt8 nLevel = EXC_STYLE_NOLEVEL );
    /** Inserts a built-in XF and STYLE record and returns the XF ID.
        @param bCreateStyleRec  true = Creates the related STYLE record. */
    sal_uInt32          AppendBuiltInXFWithStyle( XclExpXFRef const & xXF,
                            sal_uInt8 nStyleId, sal_uInt8 nLevel = EXC_STYLE_NOLEVEL );

    /** Inserts all default XF and STYLE records. */
    void                InsertDefaultRecords();

    /** Appends a XF index to the internal ID<->index maps. */
    void                AppendXFIndex( sal_uInt32 nXFId );

    void                AddBorderAndFill( const XclExpXF& rXF );
    void                SaveXFXml( XclExpXmlStream& rStrm, XclExpXF& rXF );

private:
    /** Extended info about a built-in XF. */
    struct XclExpBuiltInInfo
    {
        sal_uInt8           mnStyleId;          /// Built-in style identifier.
        sal_uInt8           mnLevel;            /// Level for RowLevel/ColLevel styles.
        bool                mbPredefined;       /// true = XF still predefined.
        bool                mbHasStyleRec;      /// true = STYLE record created.
        explicit            XclExpBuiltInInfo();
    };
    typedef ::std::map< sal_uInt32, XclExpBuiltInInfo > XclExpBuiltInMap;
    typedef ::std::vector< XclExpCellBorder >           XclExpBorderList;
    typedef ::std::vector< XclExpCellArea >             XclExpFillList;

    /** composite key for the find-map, so we can do partial key searching */
    struct FindKey
    {
        bool mbCellXF; // is this a hard cell format, or a cell style
        const SfxItemSet* mpItemSet;
        sal_uInt32 mnScNumFmt;
        sal_uInt16 mnXclFont;

        bool operator<(const FindKey& other) const
        {
            if (mbCellXF != other.mbCellXF)
                return mbCellXF < other.mbCellXF;
            if (mpItemSet != other.mpItemSet)
                return mpItemSet < other.mpItemSet;
            if (mnScNumFmt != other.mnScNumFmt)
                return mnScNumFmt < other.mnScNumFmt;
            return mnXclFont < other.mnXclFont;
        }
    };
    static FindKey ToFindKey(XclExpXF const &);

    XclExpXFList        maXFList;           /// List of all XF records.
    std::map<FindKey, std::vector<sal_uInt32>>
                        maXFFindMap;        /// map of itemset to vector of positions, to speed up find
    XclExpRecordList< XclExpStyle >
                        maStyleList;        /// List of all STYLE records.
    XclExpBuiltInMap    maBuiltInMap;       /// Contained elements describe built-in XFs.
    ScfUInt16Vec        maXFIndexVec;       /// Maps XF IDs to XF indexes.
    ScfUInt16Vec        maStyleIndexes;     /// Maps XF IDs to OOXML Style indexes
    ScfUInt16Vec        maCellIndexes;      /// Maps XF IDs to OOXML Cell indexes
    XclExpXFList        maSortedXFList;     /// List of XF records in XF index order.
    XclExpBorderList    maBorders;          /// List of borders used by XF records
    XclExpFillList      maFills;            /// List of fills used by XF records

};

class XclExpDxf : public XclExpRecordBase, protected XclExpRoot
{
public:
    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);
    XclExpDxf( const XclExpRoot& rRoot, std::unique_ptr<XclExpCellArea> pCellArea);
    virtual ~XclExpDxf() override;

    virtual void SaveXml( XclExpXmlStream& rStrm ) override;
    void SaveXmlExt( XclExpXmlStream& rStrm);
    void SetFinalColors();

private:
    std::unique_ptr<XclExpCellAlign> mpAlign;
    std::unique_ptr<XclExpCellBorder> mpBorder;
    std::unique_ptr<XclExpDxfFont> mpFont;
    std::unique_ptr<XclExpNumFmt> mpNumberFmt;
    std::unique_ptr<XclExpCellProt> mpProt;
    std::unique_ptr<XclExpColor> mpColor;
    std::unique_ptr<XclExpCellArea> mpCellArea;
};

class XclExpDxfs : public XclExpRecordBase, protected XclExpRoot
{
public:
    XclExpDxfs( const XclExpRoot& rRoot );

    sal_Int32 GetDxfId(const OUString& rName) const;
    sal_Int32 GetDxfByColor(Color aColor) const;
    void AddColor(Color aColor);

    virtual void SaveXml( XclExpXmlStream& rStrm) override;
    void Finalize();

private:
    typedef std::vector< std::unique_ptr<XclExpDxf> > DxfContainer;
    std::map<OUString, sal_Int32> maStyleNameToDxfId;
    std::map<Color, sal_Int32> maColorToDxfId;
    DxfContainer maDxf;
    std::unique_ptr<NfKeywordTable>   mpKeywordTable; /// Replacement table.
};

class XclExpXmlStyleSheet : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpXmlStyleSheet( const XclExpRoot& rRoot );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
};

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