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 <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, const OUString& rFrmt ) :
                            mnScNumFmt( nScNumFmt ), mnXclNumFmt( nXclNumFmt ), maNumFmtString( rFrmt ) {}

    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 );

    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, const OUString& rStyleName );
    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);

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);
    sal_Int32 GetDxfByColor(Color aColor);

    virtual void SaveXml( XclExpXmlStream& rStrm) override;
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: */