stylesbuffer.hxx

Go to the documentation of this file.

/* -*- 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 <memory>
#include <com/sun/star/awt/FontDescriptor.hpp>
#include <com/sun/star/table/CellHoriJustify.hpp>
#include <com/sun/star/table/CellOrientation.hpp>
#include <com/sun/star/table/BorderLine2.hpp>
#include <com/sun/star/util/CellProtection.hpp>
#include <oox/drawingml/color.hxx>
#include <oox/helper/graphichelper.hxx>
#include <oox/helper/refmap.hxx>
#include <oox/helper/refvector.hxx>
#include "numberformatsbuffer.hxx"
#include <editeng/svxenum.hxx>
#include <editeng/frmdir.hxx>
#include <docmodel/color/ComplexColor.hxx>
#include <attarray.hxx>
#include <vector>
 
class ScPatternCache;
 
namespace oox { class SequenceInputStream; }
 
namespace oox { class PropertySet;
                class PropertyMap;
                class AttributeList; }
 
namespace oox::xls {
 
const sal_Int32 OOX_COLOR_WINDOWTEXT3       = 24;       
const sal_Int32 OOX_COLOR_WINDOWBACK3       = 25;       
const sal_Int32 OOX_COLOR_WINDOWTEXT        = 64;       
const sal_Int32 OOX_COLOR_WINDOWBACK        = 65;       
const sal_Int32 OOX_COLOR_BUTTONBACK        = 67;       
const sal_Int32 OOX_COLOR_CHWINDOWTEXT      = 77;       
const sal_Int32 OOX_COLOR_CHWINDOWBACK      = 78;       
const sal_Int32 OOX_COLOR_CHBORDERAUTO      = 79;       
const sal_Int32 OOX_COLOR_NOTEBACK          = 80;       
const sal_Int32 OOX_COLOR_NOTETEXT          = 81;       
const sal_Int32 OOX_COLOR_FONTAUTO          = 0x7FFF;   
 
const sal_Int16 API_LINE_NONE               = 0;
const sal_Int16 API_LINE_HAIR               = 1;
const sal_Int16 API_LINE_THIN               = 15;
const sal_Int16 API_LINE_MEDIUM             = 35;
const sal_Int16 API_LINE_THICK              = 50;
 
const sal_Int16 API_ESCAPE_NONE             = 0;        
const sal_Int16 API_ESCAPE_SUPERSCRIPT      = 101;      
const sal_Int16 API_ESCAPE_SUBSCRIPT        = -101;     
 
const sal_Int8 API_ESCAPEHEIGHT_NONE        = 100;      
const sal_Int8 API_ESCAPEHEIGHT_DEFAULT     = 58;       
 
class ExcelGraphicHelper : public GraphicHelper, public WorkbookHelper
{
public:
    explicit            ExcelGraphicHelper( const WorkbookHelper& rHelper );
 
    virtual ::Color     getSchemeColor( sal_Int32 nToken ) const override;
    virtual ::Color     getPaletteColor( sal_Int32 nPaletteIdx ) const override;
};
 
class Color : public ::oox::drawingml::Color
{
public:
    void                setAuto();
    void                setRgb( ::Color nRgbValue, double fTint = 0.0 );
    void                setTheme( sal_Int32 nThemeIdx, double fTint = 0.0 );
    void                setIndexed( sal_Int32 nPaletteIdx, double fTint = 0.0 );
 
    void                importColor( const AttributeList& rAttribs );
 
    void                importColor( SequenceInputStream& rStrm );
    void                importColorId( SequenceInputStream& rStrm );
 
    bool         isAuto() const { return isPlaceHolder(); }
};
 
SequenceInputStream& operator>>( SequenceInputStream& rStrm, Color& orColor );
 
class ColorPalette : public WorkbookHelper
{
public:
    explicit            ColorPalette( const WorkbookHelper& rHelper );
 
    void                importPaletteColor( const AttributeList& rAttribs );
    void                importPaletteColor( SequenceInputStream& rStrm );
 
    ::Color             getColor( sal_Int32 nPaletteIdx ) const;
 
private:
    void                appendColor( ::Color nRGBValue );
 
private:
    ::std::vector< ::Color > maColors;    
    size_t              mnAppendIndex;      
};
 
struct FontModel
{
    OUString     maName;             
    Color               maColor;            
    sal_Int32           mnScheme;           
    sal_Int32           mnFamily;           
    sal_Int32           mnCharSet;          
    double              mfHeight;           
    sal_Int32           mnUnderline;        
    sal_Int32           mnEscapement;       
    bool                mbBold;             
    bool                mbItalic;           
    bool                mbStrikeout;        
    bool                mbOutline;          
    bool                mbShadow;           
 
    explicit            FontModel();
 
    void                setBiff12Scheme( sal_uInt8 nScheme );
    void                setBiffHeight( sal_uInt16 nHeight );
    void                setBiffWeight( sal_uInt16 nWeight );
    void                setBiffUnderline( sal_uInt16 nUnderline );
    void                setBiffEscapement( sal_uInt16 nEscapement );
};
 
struct ApiFontUsedFlags
{
    bool                mbNameUsed;         
    bool                mbColorUsed;        
    bool                mbSchemeUsed;       
    bool                mbHeightUsed;       
    bool                mbUnderlineUsed;    
    bool                mbEscapementUsed;   
    bool                mbWeightUsed;       
    bool                mbPostureUsed;      
    bool                mbStrikeoutUsed;    
    bool                mbOutlineUsed;      
    bool                mbShadowUsed;       
 
    explicit            ApiFontUsedFlags( bool bAllUsed );
};
 
struct ApiScriptFontName
{
    OUString     maName;             
    sal_Int16           mnFamily;           
    sal_Int16           mnTextEnc;          
 
    explicit            ApiScriptFontName();
};
 
struct ApiFontData
{
    ApiScriptFontName        maLatinFont;        
    ApiScriptFontName        maAsianFont;        
    ApiScriptFontName        maCmplxFont;        
    css::awt::FontDescriptor maDesc;             
    ::Color                  mnColor;            
    model::ComplexColor      maComplexColor;     
    sal_Int16                mnEscapement;       
    sal_Int8                 mnEscapeHeight;     
    bool                     mbOutline;          
    bool                     mbShadow;           
 
    explicit            ApiFontData();
};
 
class Font : public WorkbookHelper
{
public:
    explicit            Font( const WorkbookHelper& rHelper, bool bDxf );
    explicit            Font( const WorkbookHelper& rHelper, FontModel aModel );
 
    void                importAttribs( sal_Int32 nElement, const AttributeList& rAttribs );
 
    void                importFont( SequenceInputStream& rStrm );
    void                importDxfName( SequenceInputStream& rStrm );
    void                importDxfColor( SequenceInputStream& rStrm );
    void                importDxfScheme( SequenceInputStream& rStrm );
    void                importDxfHeight( SequenceInputStream& rStrm );
    void                importDxfWeight( SequenceInputStream& rStrm );
    void                importDxfUnderline( SequenceInputStream& rStrm );
    void                importDxfEscapement( SequenceInputStream& rStrm );
    void                importDxfFlag( sal_Int32 nElement, SequenceInputStream& rStrm );
 
    const FontModel& getModel() const { return maModel; }
 
    void                finalizeImport();
 
    const css::awt::FontDescriptor& getFontDescriptor() const { return maApiData.maDesc;}
    bool                needsRichTextFormat() const;
 
    void                fillToItemSet( SfxItemSet& rItemSet, bool bEditEngineText, bool bSkipPoolDefs = false ) const;
    void                writeToPropertyMap(
                            PropertyMap& rPropMap ) const;
    void                writeToPropertySet(
                            PropertySet& rPropSet ) const;
 
private:
    FontModel           maModel;
    ApiFontData         maApiData;
    ApiFontUsedFlags    maUsedFlags;
    bool                mbDxf;
};
 
typedef std::shared_ptr< Font > FontRef;
 
struct AlignmentModel
{
    sal_Int32           mnHorAlign;         
    sal_Int32           mnVerAlign;         
    sal_Int32           mnTextDir;          
    sal_Int32           mnRotation;         
    sal_Int32           mnIndent;           
    bool                mbWrapText;         
    bool                mbShrink;           
    bool                mbJustLastLine;     
 
    explicit            AlignmentModel();
 
    void                setBiffHorAlign( sal_uInt8 nHorAlign );
    void                setBiffVerAlign( sal_uInt8 nVerAlign );
};
 
struct ApiAlignmentData
{
    css::table::CellHoriJustify  meHorJustify;       
    sal_Int32                    mnHorJustifyMethod;
    sal_Int32                    mnVerJustify;       
    sal_Int32                    mnVerJustifyMethod;
    css::table::CellOrientation  meOrientation;      
    Degree100                    mnRotation;         
    sal_Int16                    mnWritingMode;      
    sal_Int16                    mnIndent;           
    bool                         mbWrapText;         
    bool                         mbShrink;           
 
    explicit            ApiAlignmentData();
};
 
bool operator==( const ApiAlignmentData& rLeft, const ApiAlignmentData& rRight );
 
class Alignment : public WorkbookHelper
{
public:
    explicit            Alignment( const WorkbookHelper& rHelper );
 
    void                importAlignment( const AttributeList& rAttribs );
 
    void                setBiff12Data( sal_uInt32 nFlags );
 
    void                finalizeImport();
 
    const AlignmentModel& getModel() const { return maModel; }
    const ApiAlignmentData& getApiData() const { return maApiData; }
 
    void                fillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs = false ) const;
 
private:
    ::SvxCellHorJustify GetScHorAlign() const;
    ::SvxCellVerJustify GetScVerAlign() const;
    ::SvxFrameDirection GetScFrameDir() const;
    AlignmentModel      maModel;            
    ApiAlignmentData    maApiData;          
};
 
struct ProtectionModel
{
    bool                mbLocked;           
    bool                mbHidden;           
 
    explicit            ProtectionModel();
};
 
struct ApiProtectionData
{
    typedef css::util::CellProtection ApiCellProtection;
 
    ApiCellProtection   maCellProt;
 
    explicit            ApiProtectionData();
};
 
bool operator==( const ApiProtectionData& rLeft, const ApiProtectionData& rRight );
 
class Protection : public WorkbookHelper
{
public:
    explicit            Protection( const WorkbookHelper& rHelper );
 
    void                importProtection( const AttributeList& rAttribs );
 
    void                setBiff12Data( sal_uInt32 nFlags );
 
    void                finalizeImport();
 
    const ApiProtectionData& getApiData() const { return maApiData; }
 
    void                fillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs = false ) const;
private:
    ProtectionModel     maModel;            
    ApiProtectionData   maApiData;          
};
 
struct BorderLineModel
{
    Color               maColor;            
    sal_Int32           mnStyle;            
    bool                mbUsed;             
 
    explicit            BorderLineModel( bool bDxf );
 
    void                setBiffStyle( sal_Int32 nLineStyle );
};
 
struct BorderModel
{
    BorderLineModel     maLeft;             
    BorderLineModel     maRight;            
    BorderLineModel     maTop;              
    BorderLineModel     maBottom;           
    BorderLineModel     maDiagonal;         
    bool                mbDiagTLtoBR;       
    bool                mbDiagBLtoTR;       
 
    explicit            BorderModel( bool bDxf );
};
 
struct ApiBorderData
{
    typedef css::table::BorderLine2     ApiBorderLine;
 
    ApiBorderLine       maLeft;             
    ApiBorderLine       maRight;            
    ApiBorderLine       maTop;              
    ApiBorderLine       maBottom;           
    model::ComplexColor maComplexColorLeft;
    model::ComplexColor maComplexColorRight;
    model::ComplexColor maComplexColorTop;
    model::ComplexColor maComplexColorBottom;
    ApiBorderLine       maTLtoBR;           
    ApiBorderLine       maBLtoTR;           
    bool                mbBorderUsed;       
    bool                mbDiagUsed;         
 
    explicit            ApiBorderData();
 
    bool                hasAnyOuterBorder() const;
};
 
class Border : public WorkbookHelper
{
public:
    explicit            Border( const WorkbookHelper& rHelper, bool bDxf );
 
    void                importBorder( const AttributeList& rAttribs );
    void                importStyle( sal_Int32 nElement, const AttributeList& rAttribs );
    void                importColor( sal_Int32 nElement, const AttributeList& rAttribs );
 
    void                importBorder( SequenceInputStream& rStrm );
    void                importDxfBorder( sal_Int32 nElement, SequenceInputStream& rStrm );
 
    void                finalizeImport( bool bRTL );
 
    const ApiBorderData& getApiData() const { return maApiData; }
 
    void fillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs = false ) const;
 
private:
    BorderLineModel*    getBorderLine( sal_Int32 nElement );
 
    bool                convertBorderLine(
                            css::table::BorderLine2& rBorderLine,
                            const BorderLineModel& rModel );
 
private:
    BorderModel         maModel;
    ApiBorderData       maApiData;
    bool                mbDxf;
};
 
typedef std::shared_ptr< Border > BorderRef;
 
struct PatternFillModel
{
    Color               maPatternColor;     
    Color               maFilterPatternColor; 
    Color               maFillColor;        
    sal_Int32           mnPattern;          
    bool                mbPattColorUsed;    
    bool                mbFillColorUsed;    
    bool                mbPatternUsed;      
 
    explicit            PatternFillModel( bool bDxf );
 
    void                setBiffPattern( sal_Int32 nPattern );
};
 
struct GradientFillModel
{
    typedef ::std::map< double, Color > ColorMap;
 
    sal_Int32           mnType;             
    double              mfAngle;            
    double              mfLeft;             
    double              mfRight;            
    double              mfTop;              
    double              mfBottom;           
    ColorMap            maColors;           
 
    explicit            GradientFillModel();
 
    void                readGradient( SequenceInputStream& rStrm );
    void                readGradientStop( SequenceInputStream& rStrm, bool bDxf );
};
 
struct ApiSolidFillData
{
    ::Color             mnColor;            
    model::ComplexColor maComplexColor;
    ::Color             mnFilterColor;        
    bool                mbTransparent;      
    bool                mbUsed;             
 
    explicit            ApiSolidFillData();
};
 
class Fill : public WorkbookHelper
{
public:
    explicit            Fill( const WorkbookHelper& rHelper, bool bDxf );
 
    void                importPatternFill( const AttributeList& rAttribs );
    void                importFgColor( const AttributeList& rAttribs );
    void                importBgColor( const AttributeList& rAttribs );
    void                importGradientFill( const AttributeList& rAttribs );
    void                importColor( const AttributeList& rAttribs, double fPosition );
 
    void                importFill( SequenceInputStream& rStrm );
    void                importDxfPattern( SequenceInputStream& rStrm );
    void                importDxfFgColor( SequenceInputStream& rStrm );
    void                importDxfBgColor( SequenceInputStream& rStrm );
    void                importDxfGradient( SequenceInputStream& rStrm );
    void                importDxfStop( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
    void                fillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs = false ) const;
 
private:
    typedef std::shared_ptr< PatternFillModel >   PatternModelRef;
    typedef std::shared_ptr< GradientFillModel >  GradientModelRef;
 
    PatternModelRef     mxPatternModel;
    GradientModelRef    mxGradientModel;
    ApiSolidFillData    maApiData;
    bool                mbDxf;
};
 
typedef std::shared_ptr< Fill > FillRef;
 
struct XfModel
{
    sal_Int32           mnStyleXfId;        
    sal_Int32           mnFontId;           
    sal_Int32           mnNumFmtId;         
    sal_Int32           mnBorderId;         
    sal_Int32           mnFillId;           
    bool                mbCellXf;           
    bool                mbFontUsed;         
    bool                mbNumFmtUsed;       
    bool                mbAlignUsed;        
    bool                mbProtUsed;         
    bool                mbBorderUsed;       
    bool                mbAreaUsed;         
 
    explicit            XfModel();
};
 
bool operator==( const XfModel& rXfModel1,  const XfModel& rXfModel2 );
 
class Xf : public WorkbookHelper
{
    friend bool operator==( const Xf& rXf1,  const Xf& rXf2 );
public:
    struct AttrList
    {
        std::vector<ScAttrEntry> maAttrs;
        bool mbLatinNumFmtOnly;
        const ScPatternAttr* mpDefPattern;
 
        AttrList(const ScPatternAttr* pDefPatternAttr);
    };
 
    explicit            Xf( const WorkbookHelper& rHelper );
 
    void                importXf( const AttributeList& rAttribs, bool bCellXf );
    void                importAlignment( const AttributeList& rAttribs );
    void                importProtection( const AttributeList& rAttribs );
 
    void                importXf( SequenceInputStream& rStrm, bool bCellXf );
 
    void                finalizeImport();
 
    bool         isCellXf() const { return maModel.mbCellXf; }
 
    FontRef             getFont() const;
    const Alignment& getAlignment() const { return maAlignment; }
 
    void applyPatternToAttrList(
        AttrList& rAttrs, SCROW nRow1, SCROW nRow2, sal_Int32 nXfId,
        sal_Int32 nForceScNumFmt, ScPatternCache& rCache );
 
    void writeToDoc( ScDocumentImport& rDoc, const ScRange& rRange );
 
    const ::ScPatternAttr& createPattern( bool bSkipPoolDefs = false );
 
private:
    typedef ::std::unique_ptr< ::ScPatternAttr > ScPatternAttrPtr;
 
    ScPatternAttrPtr    mpPattern;          
    sal_uInt32          mnScNumFmt;         
 
    XfModel             maModel;            
    Alignment           maAlignment;        
    Protection          maProtection;       
    sal_Int32           meRotationRef;      
    ::ScStyleSheet*       mpStyleSheet;       
};
 
bool operator==( const Xf& rXf1,  const Xf& rXf2 );
 
typedef std::shared_ptr< Xf > XfRef;
 
class Dxf : public WorkbookHelper
{
public:
    explicit            Dxf( const WorkbookHelper& rHelper );
 
    FontRef const &     createFont( bool bAlwaysNew = true );
    BorderRef const &   createBorder( bool bAlwaysNew = true );
    FillRef const &     createFill( bool bAlwaysNew = true );
 
    void                importNumFmt( const AttributeList& rAttribs );
 
    void                importDxf( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
    void fillToItemSet( SfxItemSet& rSet ) const;
 
private:
    FontRef             mxFont;             
    NumberFormatRef     mxNumFmt;           
    std::shared_ptr< Alignment >
                        mxAlignment;        
    std::shared_ptr< Protection >
                        mxProtection;       
    BorderRef           mxBorder;           
    FillRef             mxFill;             
};
 
typedef std::shared_ptr< Dxf > DxfRef;
 
struct CellStyleModel
{
    OUString     maName;             
    sal_Int32           mnXfId;             
    sal_Int32           mnBuiltinId;        
    sal_Int32           mnLevel;            
    bool                mbBuiltin;          
    bool                mbCustom;           
    bool                mbHidden;           
 
    explicit            CellStyleModel();
 
    bool                isBuiltin() const;
    bool                isDefaultStyle() const;
};
 
class CellStyle : public WorkbookHelper
{
public:
    explicit            CellStyle( const WorkbookHelper& rHelper );
 
    void                importCellStyle( const AttributeList& rAttribs );
    void                importCellStyle( SequenceInputStream& rStrm );
 
    void                createCellStyle();
    void                finalizeImport( const OUString& rFinalName );
 
    const CellStyleModel& getModel() const { return maModel; }
    const OUString& getFinalStyleName() const { return maFinalName; }
    ::ScStyleSheet* getStyleSheet() { return mpStyleSheet; }
private:
    CellStyleModel      maModel;
    OUString     maFinalName;        
    bool                mbCreated;          
    ::ScStyleSheet*     mpStyleSheet;       
 
};
 
typedef std::shared_ptr< CellStyle > CellStyleRef;
 
class CellStyleBuffer : public WorkbookHelper
{
public:
    explicit            CellStyleBuffer( const WorkbookHelper& rHelper );
 
    CellStyleRef        importCellStyle( const AttributeList& rAttribs );
    CellStyleRef        importCellStyle( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
    sal_Int32           getDefaultXfId() const;
    OUString     getDefaultStyleName() const;
    OUString     createCellStyle( sal_Int32 nXfId ) const;
    ::ScStyleSheet*     getCellStyleSheet( sal_Int32 nXfId ) const;
 
private:
    void                insertCellStyle( CellStyleRef const & xCellStyle );
    static OUString     createCellStyle( const CellStyleRef& rxCellStyle );
    static ::ScStyleSheet* getCellStyleSheet( const CellStyleRef& rxCellStyle );
 
private:
    typedef RefVector< CellStyle >          CellStyleVector;
    typedef RefMap< sal_Int32, CellStyle >  CellStyleXfIdMap;
 
    CellStyleVector     maBuiltinStyles;    
    CellStyleVector     maUserStyles;       
    CellStyleXfIdMap    maStylesByXf;       
    CellStyleRef        mxDefStyle;         
};
 
struct AutoFormatModel
{
    sal_Int32           mnAutoFormatId;     
    bool                mbApplyNumFmt;      
    bool                mbApplyFont;        
    bool                mbApplyAlignment;   
    bool                mbApplyBorder;      
    bool                mbApplyFill;        
    bool                mbApplyProtection;  
 
    explicit            AutoFormatModel();
};
 
class StylesBuffer : public WorkbookHelper
{
public:
    explicit            StylesBuffer( const WorkbookHelper& rHelper );
 
    FontRef             createFont();
    NumberFormatRef     createNumFmt( sal_Int32 nNumFmtId, std::u16string_view aFmtCode );
    sal_Int32           nextFreeNumFmtId();
    BorderRef           createBorder();
    FillRef             createFill();
    XfRef               createCellXf();
    XfRef               createStyleXf();
    DxfRef              createDxf();
    DxfRef              createExtDxf();
 
    void                importPaletteColor( const AttributeList& rAttribs );
    NumberFormatRef     importNumFmt( const AttributeList& rAttribs );
    CellStyleRef        importCellStyle( const AttributeList& rAttribs );
 
    void                importPaletteColor( SequenceInputStream& rStrm );
    void                importNumFmt( SequenceInputStream& rStrm );
    void                importCellStyle( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
    ::Color             getPaletteColor( sal_Int32 nIndex ) const;
    FontRef             getFont( sal_Int32 nFontId ) const;
    BorderRef           getBorder( sal_Int32 nBorderId ) const;
    XfRef               getCellXf( sal_Int32 nXfId ) const;
    XfRef               getStyleXf( sal_Int32 nXfId ) const;
 
    FontRef             getFontFromCellXf( sal_Int32 nXfId ) const;
    FontRef             getDefaultFont() const;
    const FontModel&    getDefaultFontModel() const;
 
    static bool         equalBorders( sal_Int32 nBorderId1, sal_Int32 nBorderId2 );
    static bool         equalFills( sal_Int32 nFillId1, sal_Int32 nFillId2 );
 
    OUString     getDefaultStyleName() const;
    OUString     createCellStyle( sal_Int32 nXfId ) const;
    ::ScStyleSheet*     getCellStyleSheet( sal_Int32 nXfId ) const;
    OUString     createDxfStyle( sal_Int32 nDxfId ) const;
    OUString     createExtDxfStyle( sal_Int32 nDxfId ) const;
 
    void                writeFontToItemSet( SfxItemSet& rItemSet, sal_Int32 nFontId, bool bSkipPoolDefs ) const;
    sal_uInt32          writeNumFmtToItemSet( SfxItemSet& rItemSet, sal_uInt32 nNumFmtId, bool bSkipPoolDefs ) const;
    void                writeBorderToItemSet( SfxItemSet& rItemSet, sal_Int32 nBorderId, bool bSkipPoolDefs ) const;
    void                writeFillToItemSet( SfxItemSet& rItemSet, sal_Int32 nFillId, bool bSkipPoolDefs ) const;
 
    void                writeCellXfToDoc( ScDocumentImport& rDoc, const ScRange& rRange, sal_Int32 nXfId ) const;
    const RefVector< Dxf >& getExtDxfs() const { return maExtDxfs; }
 
private:
    typedef RefVector< Font >                           FontVector;
    typedef RefVector< Border >                         BorderVector;
    typedef RefVector< Fill >                           FillVector;
    typedef RefVector< Xf >                             XfVector;
    typedef RefVector< Dxf >                            DxfVector;
    typedef ::std::map< sal_Int32, OUString >    DxfStyleMap;
 
    ColorPalette        maPalette;          
    FontVector          maFonts;            
    NumberFormatsBuffer maNumFmts;          
    BorderVector        maBorders;          
    FillVector          maFills;            
    XfVector            maCellXfs;          
    XfVector            maStyleXfs;         
    CellStyleBuffer     maCellStyles;       
    DxfVector           maDxfs;             
    DxfVector           maExtDxfs;          
    mutable DxfStyleMap maDxfStyles;        
};
 
} // namespace oox::xls
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */