xistyle.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 <tools/solar.h>
#include <vector>
#include <memory>
#include <rangelst.hxx>
#include "xlstyle.hxx"
#include "xiroot.hxx"

class ScPatternAttr;

struct XclRange;
struct ScAttrEntry;
enum class SvxBoxItemLine;

/* ============================================================================
- Buffers for style records (PALETTE, FONT, FORMAT, XF)
    and a container for XF indexes for every used cell in a sheet.
============================================================================ */

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

class XclImpPalette : public XclDefaultPalette
{
public:
    explicit            XclImpPalette( const XclImpRoot& rRoot );

    void                Initialize();

    Color           GetColor( sal_uInt16 nXclIndex ) const;

    void                ReadPalette( XclImpStream& rStrm );

private:
    void ExportPalette();
    typedef ::std::vector< Color > ColorVec;
    ColorVec                      maColorTable;       
    const XclImpRoot&             mrRoot;
};

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

class XclImpFont : protected XclImpRoot
{
public:
    explicit            XclImpFont( const XclImpRoot& rRoot );

    explicit            XclImpFont( const XclImpRoot& rRoot, const XclFontData& rFontData );

    void                SetAllUsedFlags( bool bUsed );
    void                SetFontData( const XclFontData& rFontData, bool bHasCharSet );

    const XclFontData& GetFontData() const { return maData; }
    bool         HasCharSet() const { return mbHasCharSet; }
    bool         HasEscapement() const { return maData.mnEscapem != EXC_FONTESC_NONE; }
    rtl_TextEncoding    GetFontEncoding() const;

    bool         HasAsianChars() const { return mbHasAsian; }

    void                ReadFont( XclImpStream& rStrm );
    void                ReadEfont( XclImpStream& rStrm );
    void                ReadCFFontBlock( XclImpStream& rStrm );

    void                FillToItemSet( SfxItemSet& rItemSet, XclFontItemType eType,
                            bool bSkipPoolDefs = false ) const;
    void                WriteFontProperties( ScfPropertySet& rPropSet,
                            XclFontPropSetType eType, const Color* pFontColor = nullptr ) const;

private:
    void                ReadFontData2( XclImpStream& rStrm );
    void                ReadFontData5( XclImpStream& rStrm );

    void                ReadFontColor( XclImpStream& rStrm );

    void                ReadFontName2( XclImpStream& rStrm );
    void                ReadFontName8( XclImpStream& rStrm );

    void                GuessScriptType();

private:
    XclFontData         maData;         
    bool                mbHasCharSet;   
    bool                mbHasWstrn;     
    bool                mbHasAsian;     
    bool                mbHasCmplx;     
    bool                mbFontNameUsed; 
    bool                mbHeightUsed;   
    bool                mbColorUsed;    
    bool                mbWeightUsed;   
    bool                mbEscapemUsed;  
    bool                mbUnderlUsed;   
    bool                mbItalicUsed;   
    bool                mbStrikeUsed;   
    bool                mbOutlineUsed;  
    bool                mbShadowUsed;   
};

class XclImpFontBuffer : protected XclImpRoot
{
public:
    XclImpFontBuffer(const XclImpFontBuffer&) = delete;
    const XclImpFontBuffer& operator=(const XclImpFontBuffer&) = delete;

    explicit            XclImpFontBuffer( const XclImpRoot& rRoot );

    void                Initialize();

    const XclImpFont*   GetFont( sal_uInt16 nFontIndex ) const;
    const XclFontData& GetAppFontData() const { return maAppFont; }

    void                ReadFont( XclImpStream& rStrm );
    void                ReadEfont( XclImpStream& rStrm );

    void                FillToItemSet( SfxItemSet& rItemSet, XclFontItemType eType,
                            sal_uInt16 nFontIdx, bool bSkipPoolDefs = false ) const;
    void                WriteFontProperties(
                            ScfPropertySet& rPropSet, XclFontPropSetType eType,
                            sal_uInt16 nFontIdx, const Color* pFontColor = nullptr ) const;
    void                WriteDefaultCtrlFontProperties( ScfPropertySet& rPropSet ) const;

private:
    void                UpdateAppFont( const XclFontData& rFontData, bool bHasCharSet );

private:
    std::vector< XclImpFont > maFontList; 
    XclFontData         maAppFont;              
    XclImpFont          maFont4;                
    XclImpFont          maCtrlFont;             
};

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

class XclImpNumFmtBuffer : public XclNumFmtBuffer, protected XclImpRoot
{
public:
    explicit            XclImpNumFmtBuffer( const XclImpRoot& rRoot );

    void                Initialize();

    void                ReadFormat( XclImpStream& rStrm );

    sal_uInt16          ReadCFFormat( XclImpStream& rStrm, bool bIFmt );

    void                CreateScFormats();

    sal_uInt32          GetScFormat( sal_uInt16 nXclNumFmt ) const;

    void                FillToItemSet(
                            SfxItemSet& rItemSet, sal_uInt16 nXclNumFmt,
                            bool bSkipPoolDefs = false ) const;
    void                FillScFmtToItemSet(
                            SfxItemSet& rItemSet, sal_uInt32 nScNumFmt,
                            bool bSkipPoolDefs = false ) const;

private:
    typedef ::std::map< sal_uInt16, sal_uLong > XclImpIndexMap;

    XclImpIndexMap      maIndexMap;     
    sal_uInt16          mnNextXclIdx;   
};

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

struct XclImpCellProt : public XclCellProt
{
    void                FillFromXF2( sal_uInt8 nNumFmt );
    void                FillFromXF3( sal_uInt16 nProt );

    void                FillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs = false ) const;
};

struct XclImpCellAlign : public XclCellAlign
{
    void                FillFromXF2( sal_uInt8 nFlags );
    void                FillFromXF3( sal_uInt16 nAlign );
    void                FillFromXF4( sal_uInt16 nAlign );
    void                FillFromXF5( sal_uInt16 nAlign );
    void                FillFromXF8( sal_uInt16 nAlign, sal_uInt16 nMiscAttrib );
    void                FillFromCF( sal_uInt16 nAlign, sal_uInt16 nMiscAttrib );

    void                FillToItemSet( SfxItemSet& rItemSet, const XclImpFont* pFont, bool bSkipPoolDefs = false ) const;
};

struct XclImpCellBorder : public XclCellBorder
{
    bool                mbLeftUsed;     
    bool                mbRightUsed;    
    bool                mbTopUsed;      
    bool                mbBottomUsed;   
    bool                mbDiagUsed;     

    explicit            XclImpCellBorder();

    void                SetUsedFlags( bool bOuterUsed, bool bDiagUsed );

    void                FillFromXF2( sal_uInt8 nFlags );
    void                FillFromXF3( sal_uInt32 nBorder );
    void                FillFromXF5( sal_uInt32 nBorder, sal_uInt32 nArea );
    void                FillFromXF8( sal_uInt32 nBorder1, sal_uInt32 nBorder2 );

    void                FillFromCF8( sal_uInt16 nLineStyle, sal_uInt32 nLineColor, sal_uInt32 nFlags );

    bool                HasAnyOuterBorder() const;

    void                FillToItemSet(
                            SfxItemSet& rItemSet,
                            const XclImpPalette& rPalette,
                            bool bSkipPoolDefs = false ) const;
};

struct XclImpCellArea : public XclCellArea
{
    bool                mbForeUsed;     
    bool                mbBackUsed;     
    bool                mbPattUsed;     

    explicit            XclImpCellArea();

    void                SetUsedFlags( bool bUsed );

    void                FillFromXF2( sal_uInt8 nFlags );
    void                FillFromXF3( sal_uInt16 nArea );
    void                FillFromXF5( sal_uInt32 nArea );
    void                FillFromXF8( sal_uInt32 nBorder2, sal_uInt16 nArea );

    void                FillFromCF8( sal_uInt16 nPattern, sal_uInt16 nColor, sal_uInt32 nFlags );

    void                FillToItemSet(
                            SfxItemSet& rItemSet,
                            const XclImpPalette& rPalette,
                            bool bSkipPoolDefs = false ) const;
};

class XclImpXFIndex
{
public:
    explicit     XclImpXFIndex( sal_uInt16 nXFIndex, bool bBoolCell = false ) :
                            mnXFIndex( nXFIndex ), mbBoolCell( bBoolCell ) {}

    sal_uInt16   GetXFIndex() const { return mnXFIndex; }
    bool         IsBoolCell() const { return mbBoolCell; }

private:
    sal_uInt16          mnXFIndex;      
    bool                mbBoolCell;     
};

inline bool operator==( const XclImpXFIndex& rLeft, const XclImpXFIndex& rRight )
{ return (rLeft.GetXFIndex() == rRight.GetXFIndex()) && (rLeft.IsBoolCell() == rRight.IsBoolCell()); }

inline bool operator!=( const XclImpXFIndex& rLeft, const XclImpXFIndex& rRight )
{ return !(rLeft == rRight); }

class XclImpXF : public XclXFBase, protected XclImpRoot
{
public:
    XclImpXF(const XclImpXF&) = delete;
    const XclImpXF& operator=(const XclImpXF&) = delete;

    explicit            XclImpXF( const XclImpRoot& rRoot );
    virtual             ~XclImpXF() override;

    void                ReadXF( XclImpStream& rStrm );

    sal_uInt8    GetHorAlign() const { return maAlignment.mnHorAlign; }
    sal_uInt16   GetFontIndex() const { return mnXclFont; }

    const ScPatternAttr& CreatePattern( bool bSkipPoolDefs = false );

    void                ApplyPatternToAttrVector(
                            ::std::vector<ScAttrEntry>& rAttrs, SCROW nRow1, SCROW nRow2,
                            sal_uInt32 nForceScNumFmt);

    void                ApplyPattern(
                            SCCOL nScCol1, SCROW nScRow1,
                            SCCOL nScCol2, SCROW nScRow2,
                            SCTAB nScTab );

    static void         ApplyPatternForBiff2CellFormat(
                            const XclImpRoot& rRoot, const ScAddress& rScPos,
                            sal_uInt8 nFlags1, sal_uInt8 nFlags2, sal_uInt8 nFlags3 );

private:
    void                ReadXF2( XclImpStream& rStrm );
    void                ReadXF3( XclImpStream& rStrm );
    void                ReadXF4( XclImpStream& rStrm );
    void                ReadXF5( XclImpStream& rStrm );
    void                ReadXF8( XclImpStream& rStrm );

    void                SetUsedFlags( sal_uInt8 nUsedFlags );

private:
    typedef ::std::unique_ptr< ScPatternAttr > ScPatternAttrPtr;

    ScPatternAttrPtr    mpPattern;          
    ScStyleSheet*       mpStyleSheet;       

    XclImpCellProt      maProtection;       
    XclImpCellAlign     maAlignment;        
    XclImpCellBorder    maBorder;           
    XclImpCellArea      maArea;             
    sal_uInt16          mnXclNumFmt;        
    sal_uInt16          mnXclFont;          
};

class XclImpStyle : protected XclImpRoot
{
public:
    explicit            XclImpStyle( const XclImpRoot& rRoot );

    void                ReadStyle( XclImpStream& rStrm );

    const OUString& GetName() const { return maName; }
    sal_uInt16   GetXfId() const { return mnXfId; }
    bool         IsBuiltin() const { return mbBuiltin && (mnBuiltinId != EXC_STYLE_USERDEF); }
    sal_uInt8    GetBuiltinId() const { return mnBuiltinId; }
    sal_uInt8    GetLevel() const { return mnLevel; }

    ScStyleSheet*       CreateStyleSheet();
    void                CreateUserStyle( const OUString& rFinalName );

private:
    OUString            maName;             
    sal_uInt16          mnXfId;             
    sal_uInt8           mnBuiltinId;        
    sal_uInt8           mnLevel;            
    bool                mbBuiltin;          
    bool                mbCustom;           
    bool                mbHidden;           

    OUString            maFinalName;        
    ScStyleSheet*       mpStyleSheet;       
};

class XclImpXFBuffer : protected XclImpRoot
{
public:
    XclImpXFBuffer(const XclImpXFBuffer&) = delete;
    const XclImpXFBuffer& operator=(const XclImpXFBuffer&) = delete;

    explicit            XclImpXFBuffer( const XclImpRoot& rRoot );

    void                Initialize();

    void                ReadXF( XclImpStream& rStrm );
    void                ReadStyle( XclImpStream& rStrm );

    XclImpXF*    GetXF( sal_uInt16 nXFIndex )
                            { return (nXFIndex >= maXFList.size()) ? nullptr : maXFList.at(nXFIndex).get(); }

    const XclImpXF*    GetXF( sal_uInt16 nXFIndex ) const
                            { return (nXFIndex >= maXFList.size()) ? nullptr : maXFList.at(nXFIndex).get(); }

    sal_uInt16          GetFontIndex( sal_uInt16 nXFIndex ) const;
    const XclImpFont*   GetFont( sal_uInt16 nXFIndex ) const;

    void                CreateUserStyles();
    ScStyleSheet*       CreateStyleSheet( sal_uInt16 nXFIndex );

private:
    typedef std::vector< std::unique_ptr<XclImpStyle> >        XclImpStyleList;
    typedef ::std::map< sal_uInt16, XclImpStyle* >  XclImpStyleMap;

    std::vector< std::unique_ptr<XclImpXF> > maXFList; 
    XclImpStyleList     maBuiltinStyles;    
    XclImpStyleList     maUserStyles;       
    XclImpStyleMap      maStylesByXf;       
};

// Buffer for XF indexes in cells =============================================

class XclImpXFRange
{
public:
    SCROW               mnScRow1;       
    SCROW               mnScRow2;       
    XclImpXFIndex       maXFIndex;      

    inline explicit     XclImpXFRange( SCROW nScRow, const XclImpXFIndex& rXFIndex );
    inline explicit     XclImpXFRange( SCROW nFirstScRow, SCROW nLastScRow, const XclImpXFIndex& rXFIndex );

    inline bool         Contains( SCROW nScRow ) const;

    bool                Expand( SCROW nScRow, const XclImpXFIndex& rXFIndex );
    bool                Expand( const XclImpXFRange& rNextRange );
};

inline XclImpXFRange::XclImpXFRange( SCROW nScRow, const XclImpXFIndex& rXFIndex ) :
    mnScRow1( nScRow ),
    mnScRow2( nScRow ),
    maXFIndex( rXFIndex )
{
}

inline XclImpXFRange::XclImpXFRange( SCROW nFirstScRow, SCROW nLastScRow, const XclImpXFIndex& rXFIndex ) :
    mnScRow1( nFirstScRow ),
    mnScRow2( nLastScRow ),
    maXFIndex( rXFIndex )
{
}

inline bool XclImpXFRange::Contains( SCROW nScRow ) const
{
    return (mnScRow1 <= nScRow) && (nScRow <= mnScRow2);
}

class XclImpXFRangeColumn
{
public:
    XclImpXFRangeColumn(const XclImpXFRangeColumn&) = delete;
    const XclImpXFRangeColumn& operator=(const XclImpXFRangeColumn&) = delete;

    typedef std::vector< std::unique_ptr<XclImpXFRange> > IndexList;

    explicit     XclImpXFRangeColumn() {}

    IndexList::iterator begin() { return maIndexList.begin(); }
    IndexList::iterator end() { return maIndexList.end(); }

    void                SetDefaultXF( const XclImpXFIndex& rXFIndex );

    void                SetXF( SCROW nScRow, const XclImpXFIndex& rXFIndex );

private:
    void                Find(
                            XclImpXFRange*& rpPrevRange,
                            XclImpXFRange*& rpNextRange,
                            sal_uLong& rnNextIndex,
                            SCROW nScRow );

    void                TryConcatPrev( sal_uLong nIndex );

    void                Insert(XclImpXFRange* pXFRange, sal_uLong nIndex);

private:
    IndexList maIndexList;    
};

class XclImpXFRangeBuffer : protected XclImpRoot
{
public:
    XclImpXFRangeBuffer(const XclImpXFRangeBuffer&) = delete;
    const XclImpXFRangeBuffer& operator=(const XclImpXFRangeBuffer&) = delete;

    explicit            XclImpXFRangeBuffer( const XclImpRoot& rRoot );
    virtual             ~XclImpXFRangeBuffer() override;

    void                Initialize();

    void                SetXF( const ScAddress& rScPos, sal_uInt16 nXFIndex );
    void                SetBlankXF( const ScAddress& rScPos, sal_uInt16 nXFIndex );
    void                SetBoolXF( const ScAddress& rScPos, sal_uInt16 nXFIndex );
    void                SetRowDefXF( SCROW nScRow, sal_uInt16 nXFIndex );
    void                SetColumnDefXF( SCCOL nScCol, sal_uInt16 nXFIndex );

    void                SetHyperlink( const XclRange& rXclRange, const OUString& rUrl );

    void                SetMerge( SCCOL nScCol1, SCROW nScRow1, SCCOL nScCol2, SCROW nScRow2 );

    void                Finalize();

private:
    enum XclImpXFInsertMode
    {
        xlXFModeCell,               
        xlXFModeBoolCell,           
        xlXFModeBlank,              
        xlXFModeRow                 
    };

private:
    void                SetXF( const ScAddress& rScPos, sal_uInt16 nXFIndex, XclImpXFInsertMode eMode );

    void                SetBorderLine( const ScRange& rRange, SCTAB nScTab, SvxBoxItemLine nLine );

private:

    std::vector< std::shared_ptr< XclImpXFRangeColumn > >
                        maColumns;        
    std::vector< std::pair< XclRange, OUString > >
                        maHyperlinks;     
    ScRangeList         maMergeList;      
};

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