xestyle.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 <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;   
const sal_uInt16 EXC_ID_FORMATLIST  = 0x801E;   
const sal_uInt16 EXC_ID_XFLIST      = 0x8043;   
const sal_uInt16 EXC_ID_DXFS        = 0x9999;   
 
// PALETTE record - color information =========================================
 
enum XclExpColorType
{
    EXC_COLOR_CELLTEXT,         
    EXC_COLOR_CELLBORDER,       
    EXC_COLOR_CELLAREA,         
    EXC_COLOR_CHARTTEXT,        
    EXC_COLOR_CHARTLINE,        
    EXC_COLOR_CHARTAREA,        
    EXC_COLOR_CTRLTEXT,         
    EXC_COLOR_GRID,              
    EXC_COLOR_TABBG             
};
 
class XclExpPaletteImpl;
 
class XclExpPalette : public XclDefaultPalette, public XclExpRecord
{
public:
    explicit            XclExpPalette( const XclExpRoot& rRoot );
    virtual             ~XclExpPalette() override;
 
    sal_uInt32          InsertColor( const Color& rColor, XclExpColorType eType, sal_uInt16 nAutoDefault = 0 );
    static sal_uInt32   GetColorIdFromIndex( sal_uInt16 nIndex );
 
    void                Finalize();
 
    sal_uInt16          GetColorIndex( sal_uInt32 nColorId ) const;
 
    void                GetMixedColors(
                            sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt8& rnXclPattern,
                            sal_uInt32 nForeColorId, sal_uInt32 nBackColorId ) const;
 
    Color               GetColor( sal_uInt16 nXclIndex ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    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 );
 
namespace XclExpFontHelper
{
    sal_Int16    GetFirstUsedScript(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet );
 
    vcl::Font    GetFontFromItemSet(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript );
 
    ScDxfFont GetDxfFontFromItemSet(const XclExpRoot& rRoot, const SfxItemSet& rSet);
 
    bool         CheckItems(
                            const XclExpRoot& rRoot,
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript,
                            bool bDeep );
}
 
class XclExpFont : public XclExpRecord, protected XclExpRoot
{
public:
    explicit            XclExpFont( const XclExpRoot& rRoot,
                            const XclFontData& rFontData, XclExpColorType eColorType );
 
    const XclFontData& GetFontData() const { return maData; }
    sal_uInt32   GetFontColorId() const { return mnColorId; }
    virtual bool        Equals( const XclFontData& rFontData, sal_uInt32 nHash ) const;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclFontData         maData;         
    sal_uInt32          mnColorId;      
    sal_uInt32          mnHash;         
};
 
class XclExpDxfFont : public XclExpRecordBase, protected XclExpRoot
{
public:
    XclExpDxfFont(const XclExpRoot& rRoot, const SfxItemSet& rItemSet);
 
    virtual void SaveXml(XclExpXmlStream& rStrm) override;
private:
 
    ScDxfFont maDxfData;
};
 
class XclExpBlindFont : public XclExpFont
{
public:
    explicit            XclExpBlindFont( const XclExpRoot& rRoot );
 
    virtual bool        Equals( const XclFontData& rFontData, sal_uInt32 nHash ) const override;
 
    virtual void        Save( XclExpStream& rStrm ) override;
};
 
class ScPatternAttr;
 
class XclExpFontBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpFontBuffer( const XclExpRoot& rRoot );
 
    const XclExpFont*   GetFont( sal_uInt16 nXclFont ) const;
    const XclFontData&  GetAppFontData() const;
 
    sal_uInt16          Insert( const XclFontData& rFontData,
                            XclExpColorType eColorType, bool bAppFont = false );
    sal_uInt16          Insert( const SvxFont& rFont,
                            XclExpColorType eColorType );
    sal_uInt16          Insert( const SfxItemSet& rItemSet, sal_Int16 nScript,
                            XclExpColorType eColorType, bool bAppFont );
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    void                InitDefaultFonts();
    size_t              Find( const XclFontData& rFontData );
 
private:
    typedef XclExpRecordList< XclExpFont >  XclExpFontList;
    typedef XclExpFontList::RecordRefType   XclExpFontRef;
 
    XclExpFontList      maFontList;     
    size_t              mnXclMaxSize;   
};
 
// FORMAT record - number formats =============================================
 
struct XclExpNumFmt
{
    sal_uInt32          mnScNumFmt;     
    sal_uInt16          mnXclNumFmt;    
    OUString            maNumFmtString; 
 
    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;
 
class XclExpNumFmtBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpNumFmtBuffer( const XclExpRoot& rRoot );
    virtual             ~XclExpNumFmtBuffer() override;
 
    sal_uInt32   GetStandardFormat() const { return mnStdFmt; }
 
    sal_uInt16          Insert( sal_uInt32 nScNumFmt );
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
    OUString            GetFormatCode ( sal_uInt32 nScNumFmt );
 
private:
    void                WriteFormatRecord( XclExpStream& rStrm, sal_uInt16 nXclNumFmt, const OUString& rFormatStr );
    void                WriteFormatRecord( XclExpStream& rStrm, const XclExpNumFmt& rFormat );
 
private:
    typedef ::std::vector< XclExpNumFmt >           XclExpNumFmtVec;
 
    SvNumberFormatterPtr mxFormatter;   
    XclExpNumFmtVec     maFormatMap;    
    std::unique_ptr<NfKeywordTable>   mpKeywordTable; 
    sal_uInt32          mnStdFmt;       
    sal_uInt16          mnXclOffset;    
};
 
// XF, STYLE record - Cell formatting =========================================
 
struct XclExpCellProt : public XclCellProt
{
    bool                FillFromItemSet( const SfxItemSet& rItemSet, bool bStyle = false );
 
    void                FillToXF3( sal_uInt16& rnProt ) const;
 
    void                SaveXml( XclExpXmlStream& rStrm ) const;
};
 
struct XclExpCellAlign : public XclCellAlign
{
    bool                FillFromItemSet(const XclRoot& rRoot, const SfxItemSet& rItemSet,
                            bool bForceLineBreak, XclBiff eBiff, bool bStyle = false );
 
    void                FillToXF5( sal_uInt16& rnAlign ) const;
    void                FillToXF8( sal_uInt16& rnAlign, sal_uInt16& rnMiscAttrib ) const;
 
    void                SaveXml( XclExpXmlStream& rStrm ) const;
};
 
struct XclExpCellBorder : public XclCellBorder
{
    sal_uInt32          mnLeftColorId;      
    sal_uInt32          mnRightColorId;     
    sal_uInt32          mnTopColorId;       
    sal_uInt32          mnBottomColorId;    
    sal_uInt32          mnDiagColorId;      
 
    explicit            XclExpCellBorder();
 
    bool                FillFromItemSet( const SfxItemSet& rItemSet,
                            XclExpPalette& rPalette, XclBiff eBiff, bool bStyle = false );
    void                SetFinalColors( const XclExpPalette& rPalette );
 
    void                FillToXF5( sal_uInt32& rnBorder, sal_uInt32& rnArea ) const;
    void                FillToXF8( sal_uInt32& rnBorder1, sal_uInt32& rnBorder2 ) const;
 
    void                FillToCF8( sal_uInt16& rnLine, sal_uInt32& rnColor ) const;
 
    void                SaveXml( XclExpXmlStream& rStrm ) const;
};
 
struct XclExpCellArea : public XclCellArea
{
    sal_uInt32          mnForeColorId;  
    sal_uInt32          mnBackColorId;  
    Color maForeColor; // Actual foreground color
    Color maBackColor; // Actual background color
 
    explicit            XclExpCellArea();
    explicit            XclExpCellArea(Color aForeColor, Color aBackColor);
 
    bool                FillFromItemSet(
                            const SfxItemSet& rItemSet, XclExpPalette& rPalette,
                            bool bStyle );
    void                SetFinalColors( const XclExpPalette& rPalette );
 
    void                FillToXF5( sal_uInt32& rnArea ) const;
    void                FillToXF8( sal_uInt32& rnBorder2, sal_uInt16& rnArea ) const;
 
    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;
};
 
struct XclExpXFId
{
    sal_uInt32          mnXFId;         
    sal_uInt16          mnXFIndex;      
 
    explicit            XclExpXFId();
    explicit            XclExpXFId( sal_uInt32 nXFId )
        : mnXFId( nXFId ), mnXFIndex( EXC_XF_DEFAULTCELL ) {}
 
    void                ConvertXFIndex( const XclExpRoot& rRoot );
};
 
class SfxStyleSheetBase;
 
class XclExpXF : public XclXFBase, public XclExpRecord, protected XclExpRoot
{
public:
    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 );
    explicit            XclExpXF(
                            const XclExpRoot& rRoot,
                            const SfxStyleSheetBase& rStyleSheet );
 
    const XclExpCellProt& GetProtectionData() const { return maProtection; }
    const XclExpCellAlign& GetAlignmentData() const { return maAlignment; }
    const XclExpCellBorder& GetBorderData() const { return maBorder; }
    const XclExpCellArea& GetAreaData() const { return maArea; }
 
    bool                Equals(
                            const ScPatternAttr& rPattern,
                            sal_uInt32 nScForceNumFmt,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak ) const;
 
    bool                Equals( const SfxStyleSheetBase& rStyleSheet ) const;
 
    void                SetFinalColors();
 
    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;          
 
    XclExpCellProt      maProtection;       
    XclExpCellAlign     maAlignment;        
    XclExpCellBorder    maBorder;           
    XclExpCellArea      maArea;             
    sal_uInt32          mnParentXFId;       
    sal_uInt32          mnScNumFmt;         
    sal_uInt16          mnXclFont;          
    sal_uInt16          mnXclNumFmt;        
    sal_Int32           mnBorderId;         
    sal_Int32           mnFillId;           
 
private:
    using               XclXFBase::Equals;
 
    void                InitDefault();
    void                Init(
                            const SfxItemSet& rItemSet,
                            sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak,
                            bool bDefStyle );
 
    sal_uInt8           GetUsedFlags() const;
 
    void                WriteBody5( XclExpStream& rStrm );
    void                WriteBody8( XclExpStream& rStrm );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
};
 
class XclExpDefaultXF : public XclExpXF
{
public:
    explicit            XclExpDefaultXF( const XclExpRoot& rRoot, bool bCellXF );
 
    void                SetFont( sal_uInt16 nXclFont );
    void                SetNumFmt( sal_uInt16 nXclNumFmt );
};
 
class XclExpStyle : public XclExpRecord
{
public:
    explicit            XclExpStyle( sal_uInt32 nXFId, OUString aStyleName );
    explicit            XclExpStyle( sal_uInt32 nXFId, sal_uInt8 nStyleId, sal_uInt8 nLevel );
 
    bool         IsBuiltIn() const { return mnStyleId != EXC_STYLE_USERDEF; }
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    OUString            maName;         
    XclExpXFId          maXFId;         
    sal_uInt8           mnStyleId;      
    sal_uInt8           mnLevel;        
};
 
class XclExpXFBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpXFBuffer( const XclExpRoot& rRoot );
 
    void                Initialize();
 
    sal_uInt32          Insert( const ScPatternAttr* pPattern, sal_Int16 nScript );
    sal_uInt32          InsertWithFont(
                            const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt16 nForceXclFont,
                            bool bForceLineBreak );
    sal_uInt32          InsertWithNumFmt(
                            const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            bool bForceLineBreak );
    sal_uInt32          InsertStyle( const SfxStyleSheetBase* pStyleSheet );
    static sal_uInt32   GetXFIdFromIndex( sal_uInt16 nXFIndex );
    static sal_uInt32   GetDefCellXFId();
 
    const XclExpXF*     GetXFById( sal_uInt32 nXFId ) const;
 
    void                Finalize();
 
    sal_uInt16          GetXFIndex( sal_uInt32 nXFId ) const;
 
    sal_Int32           GetXmlStyleIndex( sal_uInt32 nXFId ) const;
    sal_Int32           GetXmlCellIndex( sal_uInt32 nXFId ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    typedef XclExpRecordList< XclExpXF >    XclExpXFList;
    typedef XclExpXFList::RecordRefType     XclExpXFRef;
 
private:
    sal_uInt32          FindXF( const ScPatternAttr& rPattern, sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont, bool bForceLineBreak ) const;
    sal_uInt32          FindXF( const SfxStyleSheetBase& rStyleSheet ) const;
 
    sal_uInt32          FindBuiltInXF( sal_uInt8 nStyleId, sal_uInt8 nLevel ) const;
 
    sal_uInt32          InsertCellXF( const ScPatternAttr* pPattern, sal_Int16 nScript,
                            sal_uInt32 nForceScNumFmt,
                            sal_uInt16 nForceXclFont, bool bForceLineBreak );
    sal_uInt32          InsertStyleXF( const SfxStyleSheetBase& rStyleSheet );
 
    void                InsertUserStyles();
 
    sal_uInt32          AppendBuiltInXF( XclExpXFRef const & xXF,
                            sal_uInt8 nStyleId, sal_uInt8 nLevel = EXC_STYLE_NOLEVEL );
    sal_uInt32          AppendBuiltInXFWithStyle( XclExpXFRef const & xXF,
                            sal_uInt8 nStyleId, sal_uInt8 nLevel = EXC_STYLE_NOLEVEL );
 
    void                InsertDefaultRecords();
 
    void                AppendXFIndex( sal_uInt32 nXFId );
 
    void                AddBorderAndFill( const XclExpXF& rXF );
    void                SaveXFXml( XclExpXmlStream& rStrm, XclExpXF& rXF );
 
private:
    struct XclExpBuiltInInfo
    {
        sal_uInt8           mnStyleId;          
        sal_uInt8           mnLevel;            
        bool                mbPredefined;       
        bool                mbHasStyleRec;      
        explicit            XclExpBuiltInInfo();
    };
    typedef ::std::map< sal_uInt32, XclExpBuiltInInfo > XclExpBuiltInMap;
    typedef ::std::vector< XclExpCellBorder >           XclExpBorderList;
    typedef ::std::vector< XclExpCellArea >             XclExpFillList;
 
    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;           
    std::map<FindKey, std::vector<sal_uInt32>>
                        maXFFindMap;        
    XclExpRecordList< XclExpStyle >
                        maStyleList;        
    XclExpBuiltInMap    maBuiltInMap;       
    ScfUInt16Vec        maXFIndexVec;       
    ScfUInt16Vec        maStyleIndexes;     
    ScfUInt16Vec        maCellIndexes;      
    XclExpXFList        maSortedXFList;     
    XclExpBorderList    maBorders;          
    XclExpFillList      maFills;            
 
};
 
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; 
};
 
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: */