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

#ifndef INCLUDED_SC_SOURCE_FILTER_INC_XLSTYLE_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_XLSTYLE_HXX

#include <map>
#include <com/sun/star/awt/FontSlant.hpp>
#include <tools/color.hxx>
#include <tools/fontenum.hxx>
#include <editeng/svxenum.hxx>
#include <editeng/frmdir.hxx>
#include <svl/zforlist.hxx>
#include "fapihelper.hxx"

class XclRoot;

// Constants and Enumerations =================================================

// Line styles ----------------------------------------------------------------

const sal_uInt8 EXC_LINE_NONE                 = 0x00;
const sal_uInt8 EXC_LINE_THIN                 = 0x01;
const sal_uInt8 EXC_LINE_MEDIUM               = 0x02;
const sal_uInt8 EXC_LINE_DASHED               = 0x03;
const sal_uInt8 EXC_LINE_DOTTED               = 0x04;
const sal_uInt8 EXC_LINE_THICK                = 0x05;
const sal_uInt8 EXC_LINE_DOUBLE               = 0x06;
const sal_uInt8 EXC_LINE_HAIR                 = 0x07;
const sal_uInt8 EXC_LINE_MEDIUM_DASHED        = 0x08;
const sal_uInt8 EXC_LINE_THIN_DASHDOT         = 0x09;
const sal_uInt8 EXC_LINE_MEDIUM_DASHDOT       = 0x0A;
const sal_uInt8 EXC_LINE_THIN_DASHDOTDOT      = 0x0B;
const sal_uInt8 EXC_LINE_MEDIUM_DASHDOTDOT    = 0x0C;
const sal_uInt8 EXC_LINE_MEDIUM_SLANT_DASHDOT = 0x0D;

// Background patterns --------------------------------------------------------

const sal_uInt8 EXC_PATT_NONE               = 0x00;
const sal_uInt8 EXC_PATT_SOLID              = 0x01;
const sal_uInt8 EXC_PATT_50_PERC            = 0x02;
const sal_uInt8 EXC_PATT_75_PERC            = 0x03;
const sal_uInt8 EXC_PATT_25_PERC            = 0x04;
const sal_uInt8 EXC_PATT_12_5_PERC          = 0x11;
const sal_uInt8 EXC_PATT_6_25_PERC          = 0x12;

// (0x001E, 0x041E) FORMAT ----------------------------------------------------

const sal_uInt16 EXC_ID2_FORMAT             = 0x001E;
const sal_uInt16 EXC_ID4_FORMAT             = 0x041E;

const sal_uInt16 EXC_FORMAT_OFFSET5         = 164;
const sal_uInt16 EXC_FORMAT_OFFSET8         = 164;
const sal_uInt16 EXC_FORMAT_NOTFOUND        = 0xFFFF;

// (0x0031) FONT --------------------------------------------------------------

const sal_uInt16 EXC_ID2_FONT               = 0x0031;
const sal_uInt16 EXC_ID3_FONT               = 0x0231;

const sal_uInt16 EXC_FONT_APP               = 0;        
const sal_uInt16 EXC_FONT_NOTFOUND          = 0xFFFF;

const size_t EXC_FONT_MAXCOUNT4             = 0x00FF;
const size_t EXC_FONT_MAXCOUNT5             = 0x00FF;
const size_t EXC_FONT_MAXCOUNT8             = 0xFFFF;

// families
const sal_uInt8 EXC_FONTFAM_DONTKNOW        = 0x00;
const sal_uInt8 EXC_FONTFAM_ROMAN           = 0x01;
const sal_uInt8 EXC_FONTFAM_SWISS           = 0x02;
const sal_uInt8 EXC_FONTFAM_SYSTEM          = EXC_FONTFAM_SWISS;
const sal_uInt8 EXC_FONTFAM_MODERN          = 0x03;
const sal_uInt8 EXC_FONTFAM_SCRIPT          = 0x04;
const sal_uInt8 EXC_FONTFAM_DECORATIVE      = 0x05;

// charsets
const sal_uInt8 EXC_FONTCSET_ANSI_LATIN     = 0x00;

// attributes
const sal_uInt16 EXC_FONTATTR_NONE          = 0x0000;
const sal_uInt16 EXC_FONTATTR_BOLD          = 0x0001;
const sal_uInt16 EXC_FONTATTR_ITALIC        = 0x0002;
const sal_uInt16 EXC_FONTATTR_UNDERLINE     = 0x0004;
const sal_uInt16 EXC_FONTATTR_STRIKEOUT     = 0x0008;
const sal_uInt16 EXC_FONTATTR_OUTLINE       = 0x0010;
const sal_uInt16 EXC_FONTATTR_SHADOW        = 0x0020;

// weight
const sal_uInt16 EXC_FONTWGHT_DONTKNOW      = 0;
const sal_uInt16 EXC_FONTWGHT_THIN          = 100;
const sal_uInt16 EXC_FONTWGHT_ULTRALIGHT    = 200;
const sal_uInt16 EXC_FONTWGHT_LIGHT         = 300;
const sal_uInt16 EXC_FONTWGHT_SEMILIGHT     = 350;
const sal_uInt16 EXC_FONTWGHT_NORMAL        = 400;
const sal_uInt16 EXC_FONTWGHT_MEDIUM        = 500;
const sal_uInt16 EXC_FONTWGHT_SEMIBOLD      = 600;
const sal_uInt16 EXC_FONTWGHT_BOLD          = 700;
const sal_uInt16 EXC_FONTWGHT_ULTRABOLD     = 800;
const sal_uInt16 EXC_FONTWGHT_BLACK         = 900;

// underline
const sal_uInt8 EXC_FONTUNDERL_NONE         = 0x00;
const sal_uInt8 EXC_FONTUNDERL_SINGLE       = 0x01;
const sal_uInt8 EXC_FONTUNDERL_DOUBLE       = 0x02;
const sal_uInt8 EXC_FONTUNDERL_SINGLE_ACC   = 0x21;
const sal_uInt8 EXC_FONTUNDERL_DOUBLE_ACC   = 0x22;

// escapement
const sal_uInt16 EXC_FONTESC_NONE           = 0x00;
const sal_uInt16 EXC_FONTESC_SUPER          = 0x01;
const sal_uInt16 EXC_FONTESC_SUB            = 0x02;

// (0x0043, 0x0243, 0x0443, 0x00E0) XF ----------------------------------------

const sal_uInt16 EXC_ID2_XF                 = 0x0043;
const sal_uInt16 EXC_ID3_XF                 = 0x0243;
const sal_uInt16 EXC_ID4_XF                 = 0x0443;
const sal_uInt16 EXC_ID5_XF                 = 0x00E0;

const sal_uInt32 EXC_XF_MAXCOUNT            = 4050;     
const sal_uInt32 EXC_XF_MAXSTYLECOUNT       = 1536;     
const sal_uInt16 EXC_XF_DEFAULTSTYLE        = 0;        
const sal_uInt16 EXC_XF_DEFAULTCELL         = 15;       
const sal_uInt16 EXC_XF_NOTFOUND            = 0xFFFF;   

const sal_uInt32 EXC_XFID_NOTFOUND          = 0xFFFFFFFF;

const sal_uInt16 EXC_XF_LOCKED              = 0x0001;
const sal_uInt16 EXC_XF_HIDDEN              = 0x0002;
const sal_uInt16 EXC_XF_STYLE               = 0x0004;
const sal_uInt16 EXC_XF_STYLEPARENT         = 0x0FFF;   
const sal_uInt16 EXC_XF_LINEBREAK           = 0x0008;   
const sal_uInt16 EXC_XF_SHRINK              = 0x0010;   

const sal_uInt8 EXC_XF_DIFF_VALFMT          = 0x01;
const sal_uInt8 EXC_XF_DIFF_FONT            = 0x02;
const sal_uInt8 EXC_XF_DIFF_ALIGN           = 0x04;
const sal_uInt8 EXC_XF_DIFF_BORDER          = 0x08;
const sal_uInt8 EXC_XF_DIFF_AREA            = 0x10;
const sal_uInt8 EXC_XF_DIFF_PROT            = 0x20;

const sal_uInt8 EXC_XF_HOR_GENERAL          = 0x00;
const sal_uInt8 EXC_XF_HOR_LEFT             = 0x01;
const sal_uInt8 EXC_XF_HOR_CENTER           = 0x02;
const sal_uInt8 EXC_XF_HOR_RIGHT            = 0x03;
const sal_uInt8 EXC_XF_HOR_FILL             = 0x04;
const sal_uInt8 EXC_XF_HOR_JUSTIFY          = 0x05;
const sal_uInt8 EXC_XF_HOR_CENTER_AS        = 0x06;
const sal_uInt8 EXC_XF_HOR_DISTRIB          = 0x07;

const sal_uInt8 EXC_XF_VER_TOP              = 0x00;
const sal_uInt8 EXC_XF_VER_CENTER           = 0x01;
const sal_uInt8 EXC_XF_VER_BOTTOM           = 0x02;
const sal_uInt8 EXC_XF_VER_JUSTIFY          = 0x03;
const sal_uInt8 EXC_XF_VER_DISTRIB          = 0x04;

const sal_uInt8 EXC_XF_TEXTDIR_CONTEXT      = 0x00;
const sal_uInt8 EXC_XF_TEXTDIR_LTR          = 0x01;
const sal_uInt8 EXC_XF_TEXTDIR_RTL          = 0x02;

const sal_uInt8 EXC_XF2_VALFMT_MASK         = 0x3F;
const sal_uInt8 EXC_XF2_LOCKED              = 0x40;
const sal_uInt8 EXC_XF2_HIDDEN              = 0x80;
const sal_uInt8 EXC_XF2_LEFTLINE            = 0x08;
const sal_uInt8 EXC_XF2_RIGHTLINE           = 0x10;
const sal_uInt8 EXC_XF2_TOPLINE             = 0x20;
const sal_uInt8 EXC_XF2_BOTTOMLINE          = 0x40;
const sal_uInt8 EXC_XF2_BACKGROUND          = 0x80;

const sal_uInt16 EXC_XF8_SHRINK             = 0x0010;   
const sal_uInt16 EXC_XF8_MERGE              = 0x0020;

const sal_uInt32 EXC_XF_DIAGONAL_TL_TO_BR   = 0x40000000;   
const sal_uInt32 EXC_XF_DIAGONAL_BL_TO_TR   = 0x80000000;   
const sal_uInt32 EXC_XF_DIAGONAL_BOTH       = 0xC0000000;   

// (0x0045) EFONT -------------------------------------------------------------

const sal_uInt16 EXC_ID_EFONT               = 0x0045;

// (0x0092) PALETTE -----------------------------------------------------------

const sal_uInt16 EXC_ID_PALETTE             = 0x0092;

const sal_uInt16 EXC_COLOR_BIFF2_BLACK      = 0;
const sal_uInt16 EXC_COLOR_BIFF2_WHITE      = 1;

const sal_uInt16 EXC_COLOR_USEROFFSET       = 8;        
const sal_uInt16 EXC_COLOR_WINDOWTEXT3      = 24;       
const sal_uInt16 EXC_COLOR_WINDOWBACK3      = 25;       
const sal_uInt16 EXC_COLOR_WINDOWTEXT       = 64;       
const sal_uInt16 EXC_COLOR_WINDOWBACK       = 65;       
const sal_uInt16 EXC_COLOR_BUTTONBACK       = 67;       
const sal_uInt16 EXC_COLOR_CHWINDOWTEXT     = 77;       
const sal_uInt16 EXC_COLOR_CHWINDOWBACK     = 78;       
const sal_uInt16 EXC_COLOR_CHBORDERAUTO     = 79;       
const sal_uInt16 EXC_COLOR_NOTEBACK         = 80;       
const sal_uInt16 EXC_COLOR_NOTETEXT         = 81;       
const sal_uInt16 EXC_COLOR_FONTAUTO         = 0x7FFF;   

// (0x0293) STYLE -------------------------------------------------------------

const sal_uInt16 EXC_ID_STYLE               = 0x0293;

const sal_uInt16 EXC_STYLE_BUILTIN          = 0x8000;
const sal_uInt16 EXC_STYLE_XFMASK           = 0x0FFF;

const sal_uInt8 EXC_STYLE_NORMAL            = 0x00;         
const sal_uInt8 EXC_STYLE_ROWLEVEL          = 0x01;         
const sal_uInt8 EXC_STYLE_COLLEVEL          = 0x02;         
const sal_uInt8 EXC_STYLE_COMMA             = 0x03;         
const sal_uInt8 EXC_STYLE_CURRENCY          = 0x04;         
const sal_uInt8 EXC_STYLE_PERCENT           = 0x05;         
const sal_uInt8 EXC_STYLE_COMMA_0           = 0x06;         
const sal_uInt8 EXC_STYLE_CURRENCY_0        = 0x07;         
const sal_uInt8 EXC_STYLE_HYPERLINK         = 0x08;         
const sal_uInt8 EXC_STYLE_FOLLOWED_HYPERLINK= 0x09;         
const sal_uInt8 EXC_STYLE_USERDEF           = 0xFF;         

const sal_uInt8 EXC_STYLE_LEVELCOUNT        = 7;            
const sal_uInt8 EXC_STYLE_NOLEVEL           = 0xFF;         

// (0x0892) STYLEEXT ----------------------------------------------------------

const sal_uInt16 EXC_ID_STYLEEXT            = 0x0892;

const sal_uInt8 EXC_STYLEEXT_BUILTIN        = 0x01;
const sal_uInt8 EXC_STYLEEXT_HIDDEN         = 0x02;
const sal_uInt8 EXC_STYLEEXT_CUSTOM         = 0x04;

// Color data =================================================================

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

    sal_uInt32   GetColorCount() const { return mnTableSize - EXC_COLOR_USEROFFSET; }

    Color        GetDefColor( sal_uInt16 nXclIndex ) const;

    bool         IsSystemColor( sal_uInt16 nXclIndex ) const { return nXclIndex >= mnTableSize; }

private:
    const Color*        mpnColorTable;      
    Color               mnWindowText;       
    Color               mnWindowBack;       
    Color               mnFaceColor;        
    Color               mnNoteText;         
    Color               mnNoteBack;         
    sal_uInt32          mnTableSize;        
};

// Font data ==================================================================

namespace vcl { class Font; }
class SvxFont;

struct XclFontData
{
    OUString            maName;         
    OUString            maStyle;        
    Color               maColor;        
    sal_uInt16          mnHeight;       
    sal_uInt16          mnWeight;       
    sal_uInt16          mnEscapem;      
    sal_uInt8           mnFamily;       
    sal_uInt8           mnCharSet;      
    sal_uInt8           mnUnderline;    
    bool                mbItalic;       
    bool                mbStrikeout;    
    bool                mbOutline;      
    bool                mbShadow;       

    explicit            XclFontData();
    explicit            XclFontData( const vcl::Font& rFont );
    explicit            XclFontData( const SvxFont& rFont );

    void                Clear();
    void                FillFromVclFont( const vcl::Font& rFont );
    void                FillFromSvxFont( const SvxFont& rFont );

// *** conversion of VCL/SVX constants *** ------------------------------------

    FontFamily          GetScFamily( rtl_TextEncoding eDefTextEnc ) const;
    rtl_TextEncoding    GetFontEncoding() const;
    FontItalic          GetScPosture() const;
    FontWeight          GetScWeight() const;
    FontLineStyle       GetScUnderline() const;
    SvxEscapement       GetScEscapement() const;
    FontStrikeout       GetScStrikeout() const;

    void                SetScHeight( sal_Int32 nTwips );
    void                SetScFamily( FontFamily eScFamily );
    void                SetFontEncoding( rtl_TextEncoding eFontEnc );
    void                SetScPosture( FontItalic eScPosture );
    void                SetScWeight( FontWeight eScWeight );
    void                SetScUnderline( FontLineStyle eScUnderl );
    void                SetScEscapement( short nScEscapem );
    void                SetScStrikeout( FontStrikeout eScStrikeout );

// *** conversion of API constants *** ----------------------------------------

    float               GetApiHeight() const;
    sal_Int16           GetApiFamily() const;
    sal_Int16           GetApiFontEncoding() const;
    css::awt::FontSlant GetApiPosture() const;
    float               GetApiWeight() const;
    sal_Int16           GetApiUnderline() const;
    sal_Int16           GetApiEscapement() const;
    sal_Int16           GetApiStrikeout() const;

    void                SetApiHeight( float fPoint );
    void                SetApiFamily( sal_Int16 nApiFamily );
    void                SetApiPosture( css::awt::FontSlant eApiPosture );
    void                SetApiWeight( float fApiWeight );
    void                SetApiUnderline( sal_Int16 nApiUnderl );
    void                SetApiEscapement( sal_Int16 nApiEscapem );
    void                SetApiStrikeout( sal_Int16 nApiStrikeout );
};

bool operator==( const XclFontData& rLeft, const XclFontData& rRight );

enum class XclFontItemType
{
    Cell,          
    Editeng,       
    HeaderFooter   
};

enum XclFontPropSetType
{
    EXC_FONTPROPSET_CHART,          
    EXC_FONTPROPSET_CONTROL         
};

class XclFontPropSetHelper
{
public:
    explicit            XclFontPropSetHelper();

    void                ReadFontProperties( XclFontData& rFontData,
                            const ScfPropertySet& rPropSet, XclFontPropSetType eType,
                            sal_Int16 nScript = -1 );

    void                WriteFontProperties(
                            ScfPropertySet& rPropSet, XclFontPropSetType eType,
                            const XclFontData& rFontData,
                            bool bHasWstrn, bool bHasAsian, bool bHasCmplx,
                            const Color* pFontColor );

private:
    ScfPropSetHelper&   GetChartHelper( sal_Int16 nScript );

private:
    ScfPropSetHelper    maHlpChCommon;      
    ScfPropSetHelper    maHlpChWstrn;       
    ScfPropSetHelper    maHlpChAsian;       
    ScfPropSetHelper    maHlpChCmplx;       
    ScfPropSetHelper    maHlpChWstrnNoName; 
    ScfPropSetHelper    maHlpChAsianNoName; 
    ScfPropSetHelper    maHlpChCmplxNoName; 
    ScfPropSetHelper    maHlpChEscapement;  
    ScfPropSetHelper    maHlpControl;       
};

// Number formats =============================================================

struct XclNumFmt
{
    OUString            maFormat;       
    NfIndexTableOffset  meOffset;       
    LanguageType        meLanguage;     
};

class XclNumFmtBuffer
{
public:
    explicit            XclNumFmtBuffer( const XclRoot& rRoot );

    sal_uInt32          GetStdScNumFmt() const { return mnStdScNumFmt; }

protected:
    typedef ::std::map< sal_uInt16, XclNumFmt > XclNumFmtMap;

    void                InitializeImport();

    const XclNumFmtMap& GetFormatMap() const { return maFmtMap; }

    void                InsertFormat( sal_uInt16 nXclNumFmt, const OUString& rFormat );

private:
    void                InsertBuiltinFormats();

    XclNumFmtMap        maFmtMap;       
    const LanguageType  meSysLang;      
    const sal_uInt32    mnStdScNumFmt;  
};

// Cell formatting data (XF) ==================================================

struct XclCellProt
{
    bool                mbLocked;       
    bool                mbHidden;       

    explicit            XclCellProt();
};

bool operator==( const XclCellProt& rLeft, const XclCellProt& rRight );

struct XclCellAlign
{
    sal_uInt8           mnHorAlign;     
    sal_uInt8           mnVerAlign;     
    sal_uInt8           mnOrient;       
    sal_uInt8           mnTextDir;      
    sal_uInt8           mnRotation;     
    sal_uInt8           mnIndent;       
    bool                mbLineBreak;    
    bool                mbShrink;       

    explicit            XclCellAlign();

    SvxCellHorJustify   GetScHorAlign() const;
    SvxCellJustifyMethod GetScHorJustifyMethod() const;
    SvxCellVerJustify   GetScVerAlign() const;
    SvxCellJustifyMethod GetScVerJustifyMethod() const;
    SvxFrameDirection   GetScFrameDir() const;

    void                SetScHorAlign( SvxCellHorJustify eHorJust );
    void                SetScVerAlign( SvxCellVerJustify eVerJust );
    void                SetScFrameDir( SvxFrameDirection eFrameDir );
};

bool operator==( const XclCellAlign& rLeft, const XclCellAlign& rRight );

struct XclCellBorder
{
    sal_uInt16          mnLeftColor;    
    sal_uInt16          mnRightColor;   
    sal_uInt16          mnTopColor;     
    sal_uInt16          mnBottomColor;  
    sal_uInt16          mnDiagColor;    
    sal_uInt8           mnLeftLine;     
    sal_uInt8           mnRightLine;    
    sal_uInt8           mnTopLine;      
    sal_uInt8           mnBottomLine;   
    sal_uInt8           mnDiagLine;     
    bool                mbDiagTLtoBR;   
    bool                mbDiagBLtoTR;   

    explicit            XclCellBorder();
};

bool operator==( const XclCellBorder& rLeft, const XclCellBorder& rRight );

struct XclCellArea
{
    sal_uInt16          mnForeColor;    
    sal_uInt16          mnBackColor;    
    sal_uInt8           mnPattern;      

    explicit            XclCellArea();

    bool                IsTransparent() const;
};

bool operator==( const XclCellArea& rLeft, const XclCellArea& rRight );

class XclXFBase
{
public:
    explicit            XclXFBase( bool bCellXF );
    virtual             ~XclXFBase();

    XclXFBase(XclXFBase const &) = default;
    XclXFBase(XclXFBase &&) = default;
    XclXFBase & operator =(XclXFBase const &) = default;
    XclXFBase & operator =(XclXFBase &&) = default;

    void                SetAllUsedFlags( bool bUsed );
    bool                HasUsedFlags() const;

    bool         IsCellXF() const    { return mbCellXF; }
    bool         IsStyleXF() const   { return !IsCellXF(); }

protected:
    bool                Equals( const XclXFBase& rCmp ) const;

protected:
    sal_uInt16          mnParent;           
    bool                mbCellXF;           
    bool                mbProtUsed;         
    bool                mbFontUsed;         
    bool                mbFmtUsed;          
    bool                mbAlignUsed;        
    bool                mbBorderUsed;       
    bool                mbAreaUsed;         
};

#endif

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