LCOV - code coverage report
Current view: top level - libreoffice/sc/source/filter/excel - xlstyle.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 291 465 62.6 %
Date: 2012-12-27 Functions: 57 72 79.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include "xlstyle.hxx"
      22             : #include <com/sun/star/awt/FontFamily.hpp>
      23             : #include <com/sun/star/awt/FontSlant.hpp>
      24             : #include <com/sun/star/awt/FontUnderline.hpp>
      25             : #include <com/sun/star/i18n/ScriptType.hpp>
      26             : #include <vcl/svapp.hxx>
      27             : #include <vcl/font.hxx>
      28             : #include <sal/macros.h>
      29             : #include <rtl/tencinfo.h>
      30             : #include <toolkit/unohlp.hxx>
      31             : #include <editeng/svxfont.hxx>
      32             : #include "global.hxx"
      33             : #include "xlroot.hxx"
      34             : 
      35             : // Color data =================================================================
      36             : 
      37             : /** Standard EGA colors, bright. */
      38             : #define EXC_PALETTE_EGA_COLORS_LIGHT \
      39             :             0x000000, 0xFFFFFF, 0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF, 0x00FFFF
      40             : /** Standard EGA colors, dark. */
      41             : #define EXC_PALETTE_EGA_COLORS_DARK \
      42             :             0x800000, 0x008000, 0x000080, 0x808000, 0x800080, 0x008080, 0xC0C0C0, 0x808080
      43             : 
      44             : /** Default color table for BIFF2. */
      45             : static const ColorData spnDefColorTable2[] =
      46             : {
      47             : /*  0 */    EXC_PALETTE_EGA_COLORS_LIGHT
      48             : };
      49             : 
      50             : /** Default color table for BIFF3/BIFF4. */
      51             : static const ColorData spnDefColorTable3[] =
      52             : {
      53             : /*  0 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      54             : /*  8 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      55             : /* 16 */    EXC_PALETTE_EGA_COLORS_DARK
      56             : };
      57             : 
      58             : /** Default color table for BIFF5/BIFF7. */
      59             : static const ColorData spnDefColorTable5[] =
      60             : {
      61             : /*  0 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      62             : /*  8 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      63             : /* 16 */    EXC_PALETTE_EGA_COLORS_DARK,
      64             : /* 24 */    0x8080FF, 0x802060, 0xFFFFC0, 0xA0E0E0, 0x600080, 0xFF8080, 0x0080C0, 0xC0C0FF,
      65             : /* 32 */    0x000080, 0xFF00FF, 0xFFFF00, 0x00FFFF, 0x800080, 0x800000, 0x008080, 0x0000FF,
      66             : /* 40 */    0x00CFFF, 0x69FFFF, 0xE0FFE0, 0xFFFF80, 0xA6CAF0, 0xDD9CB3, 0xB38FEE, 0xE3E3E3,
      67             : /* 48 */    0x2A6FF9, 0x3FB8CD, 0x488436, 0x958C41, 0x8E5E42, 0xA0627A, 0x624FAC, 0x969696,
      68             : /* 56 */    0x1D2FBE, 0x286676, 0x004500, 0x453E01, 0x6A2813, 0x85396A, 0x4A3285, 0x424242
      69             : };
      70             : 
      71             : /** Default color table for BIFF8. */
      72             : static const ColorData spnDefColorTable8[] =
      73             : {
      74             : /*  0 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      75             : /*  8 */    EXC_PALETTE_EGA_COLORS_LIGHT,
      76             : /* 16 */    EXC_PALETTE_EGA_COLORS_DARK,
      77             : /* 24 */    0x9999FF, 0x993366, 0xFFFFCC, 0xCCFFFF, 0x660066, 0xFF8080, 0x0066CC, 0xCCCCFF,
      78             : /* 32 */    0x000080, 0xFF00FF, 0xFFFF00, 0x00FFFF, 0x800080, 0x800000, 0x008080, 0x0000FF,
      79             : /* 40 */    0x00CCFF, 0xCCFFFF, 0xCCFFCC, 0xFFFF99, 0x99CCFF, 0xFF99CC, 0xCC99FF, 0xFFCC99,
      80             : /* 48 */    0x3366FF, 0x33CCCC, 0x99CC00, 0xFFCC00, 0xFF9900, 0xFF6600, 0x666699, 0x969696,
      81             : /* 56 */    0x003366, 0x339966, 0x003300, 0x333300, 0x993300, 0x993366, 0x333399, 0x333333
      82             : };
      83             : 
      84             : #undef EXC_PALETTE_EGA_COLORS_LIGHT
      85             : #undef EXC_PALETTE_EGA_COLORS_DARK
      86             : 
      87             : // ----------------------------------------------------------------------------
      88             : 
      89          21 : XclDefaultPalette::XclDefaultPalette( const XclRoot& rRoot ) :
      90             :     mpnColorTable( 0 ),
      91          21 :     mnTableSize( 0 )
      92             : {
      93          21 :     const StyleSettings& rSett = Application::GetSettings().GetStyleSettings();
      94          21 :     mnWindowText = rSett.GetWindowTextColor().GetColor();
      95          21 :     mnWindowBack = rSett.GetWindowColor().GetColor();
      96          21 :     mnFaceColor = rSett.GetFaceColor().GetColor();
      97          21 :     mnNoteText = rSett.GetHelpTextColor().GetColor();
      98          21 :     mnNoteBack = rSett.GetHelpColor().GetColor();
      99             : 
     100             :     // default colors
     101          21 :     switch( rRoot.GetBiff() )
     102             :     {
     103             :         case EXC_BIFF2:
     104           0 :             mpnColorTable = spnDefColorTable2;
     105           0 :             mnTableSize = SAL_N_ELEMENTS( spnDefColorTable2 );
     106           0 :         break;
     107             :         case EXC_BIFF3:
     108             :         case EXC_BIFF4:
     109           0 :             mpnColorTable = spnDefColorTable3;
     110           0 :             mnTableSize = SAL_N_ELEMENTS( spnDefColorTable3 );
     111           0 :         break;
     112             :         case EXC_BIFF5:
     113           0 :             mpnColorTable = spnDefColorTable5;
     114           0 :             mnTableSize = SAL_N_ELEMENTS( spnDefColorTable5 );
     115           0 :         break;
     116             :         case EXC_BIFF8:
     117          21 :             mpnColorTable = spnDefColorTable8;
     118          21 :             mnTableSize = SAL_N_ELEMENTS( spnDefColorTable8 );
     119          21 :         break;
     120             :         default:
     121             :             DBG_ERROR_BIFF();
     122             :     }
     123          21 : }
     124             : 
     125        7057 : ColorData XclDefaultPalette::GetDefColorData( sal_uInt16 nXclIndex ) const
     126             : {
     127             :     ColorData nColor;
     128        7057 :     if( nXclIndex < mnTableSize )
     129        1787 :         nColor = mpnColorTable[ nXclIndex ];
     130        5270 :     else switch( nXclIndex )
     131             :     {
     132             :         case EXC_COLOR_WINDOWTEXT3:
     133             :         case EXC_COLOR_WINDOWTEXT:
     134        4980 :         case EXC_COLOR_CHWINDOWTEXT:    nColor = mnWindowText;  break;
     135             :         case EXC_COLOR_WINDOWBACK3:
     136             :         case EXC_COLOR_WINDOWBACK:
     137         182 :         case EXC_COLOR_CHWINDOWBACK:    nColor = mnWindowBack;  break;
     138           0 :         case EXC_COLOR_BUTTONBACK:      nColor = mnFaceColor;   break;
     139           3 :         case EXC_COLOR_CHBORDERAUTO:    nColor = COL_BLACK;     break;  // TODO: really always black?
     140           0 :         case EXC_COLOR_NOTEBACK:        nColor = mnNoteBack;    break;
     141           0 :         case EXC_COLOR_NOTETEXT:        nColor = mnNoteText;    break;
     142         105 :         case EXC_COLOR_FONTAUTO:        nColor = COL_AUTO;      break;
     143             :         default:
     144             :             OSL_TRACE( "XclDefaultPalette::GetDefColorData - unknown default color index: %d", nXclIndex );
     145           0 :             nColor = COL_AUTO;
     146             :     }
     147        7057 :     return nColor;
     148             : }
     149             : 
     150             : // Font Data ==================================================================
     151             : 
     152             : namespace Awt              = ::com::sun::star::awt;
     153             : namespace AwtFontFamily    = Awt::FontFamily;
     154             : namespace AwtFontUnderline = Awt::FontUnderline;
     155             : namespace AwtFontStrikeout = Awt::FontStrikeout;
     156             : 
     157             : // ----------------------------------------------------------------------------
     158             : 
     159         522 : XclFontData::XclFontData()
     160             : {
     161         522 :     Clear();
     162         522 : }
     163             : 
     164          18 : XclFontData::XclFontData( const Font& rFont )
     165             : {
     166          18 :     Clear();
     167          18 :     FillFromVclFont( rFont );
     168          18 : }
     169             : 
     170           8 : XclFontData::XclFontData( const SvxFont& rFont )
     171             : {
     172           8 :     FillFromSvxFont( rFont );
     173           8 : }
     174             : 
     175         540 : void XclFontData::Clear()
     176             : {
     177         540 :     maName.Erase();
     178         540 :     maStyle.Erase();
     179         540 :     maColor.SetColor( COL_AUTO );
     180         540 :     mnHeight = 0;
     181         540 :     mnWeight = EXC_FONTWGHT_DONTKNOW;
     182         540 :     mnEscapem = EXC_FONTESC_NONE;
     183         540 :     mnFamily = EXC_FONTFAM_SYSTEM;
     184         540 :     mnCharSet = EXC_FONTCSET_ANSI_LATIN;
     185         540 :     mnUnderline = EXC_FONTUNDERL_NONE;
     186         540 :     mbItalic = mbStrikeout = mbOutline = mbShadow = false;
     187         540 : }
     188             : 
     189          34 : void XclFontData::FillFromVclFont( const Font& rFont )
     190             : {
     191          34 :     maName = XclTools::GetXclFontName( rFont.GetName() );   // substitute with MS fonts
     192          34 :     maStyle.Erase();
     193          34 :     maColor = rFont.GetColor();
     194          34 :     SetScUnderline( rFont.GetUnderline() );
     195          34 :     mnEscapem = EXC_FONTESC_NONE;
     196          34 :     SetScHeight( rFont.GetSize().Height() );
     197          34 :     SetScWeight( rFont.GetWeight() );
     198          34 :     SetScFamily( rFont.GetFamily() );
     199          34 :     SetFontEncoding( rFont.GetCharSet() );
     200          34 :     SetScPosture( rFont.GetItalic() );
     201          34 :     SetScStrikeout( rFont.GetStrikeout() );
     202          34 :     mbOutline = rFont.IsOutline();
     203          34 :     mbShadow = rFont.IsShadow();
     204          34 : }
     205             : 
     206           8 : void XclFontData::FillFromSvxFont( const SvxFont& rFont )
     207             : {
     208           8 :     FillFromVclFont( rFont );
     209           8 :     SetScEscapement( rFont.GetEscapement() );
     210           8 : }
     211             : 
     212             : // *** conversion of VCL/SVX constants *** ------------------------------------
     213             : 
     214         999 : FontFamily XclFontData::GetScFamily( rtl_TextEncoding eDefTextEnc ) const
     215             : {
     216             :     FontFamily eScFamily;
     217             :     // ! format differs from Windows documentation: family is in lower nibble, pitch unknown
     218         999 :     switch( mnFamily & 0x0F )
     219             :     {
     220           0 :         case EXC_FONTFAM_ROMAN:         eScFamily = FAMILY_ROMAN;       break;
     221         835 :         case EXC_FONTFAM_SWISS:         eScFamily = FAMILY_SWISS;       break;
     222          93 :         case EXC_FONTFAM_MODERN:        eScFamily = FAMILY_MODERN;      break;
     223           0 :         case EXC_FONTFAM_SCRIPT:        eScFamily = FAMILY_SCRIPT;      break;
     224           0 :         case EXC_FONTFAM_DECORATIVE:    eScFamily = FAMILY_DECORATIVE;  break;
     225             :         default:
     226             :             eScFamily =
     227             :                 ((eDefTextEnc == RTL_TEXTENCODING_APPLE_ROMAN) &&
     228           0 :                 (maName.EqualsIgnoreCaseAscii( "Geneva" ) || maName.EqualsIgnoreCaseAscii( "Chicago" ))) ?
     229          71 :                 FAMILY_SWISS : FAMILY_DONTKNOW;
     230             :     }
     231         999 :     return eScFamily;
     232             : }
     233             : 
     234        1022 : rtl_TextEncoding XclFontData::GetFontEncoding() const
     235             : {
     236             :     // convert Windows character set to text encoding identifier
     237        1022 :     return rtl_getTextEncodingFromWindowsCharset( mnCharSet );
     238             : }
     239             : 
     240         960 : FontItalic XclFontData::GetScPosture() const
     241             : {
     242         960 :     return mbItalic ? ITALIC_NORMAL : ITALIC_NONE;
     243             : }
     244             : 
     245        1547 : FontWeight XclFontData::GetScWeight() const
     246             : {
     247             :     FontWeight eScWeight;
     248             : 
     249        1547 :     if( !mnWeight )             eScWeight = WEIGHT_DONTKNOW;
     250        1547 :     else if( mnWeight < 150 )   eScWeight = WEIGHT_THIN;
     251        1547 :     else if( mnWeight < 250 )   eScWeight = WEIGHT_ULTRALIGHT;
     252        1547 :     else if( mnWeight < 325 )   eScWeight = WEIGHT_LIGHT;
     253        1547 :     else if( mnWeight < 375 )   eScWeight = WEIGHT_SEMILIGHT;
     254        1547 :     else if( mnWeight < 450 )   eScWeight = WEIGHT_NORMAL;
     255         421 :     else if( mnWeight < 550 )   eScWeight = WEIGHT_MEDIUM;
     256         421 :     else if( mnWeight < 650 )   eScWeight = WEIGHT_SEMIBOLD;
     257         421 :     else if( mnWeight < 750 )   eScWeight = WEIGHT_BOLD;
     258           0 :     else if( mnWeight < 850 )   eScWeight = WEIGHT_ULTRABOLD;
     259           0 :     else                        eScWeight = WEIGHT_BLACK;
     260             : 
     261        1547 :     return eScWeight;
     262             : }
     263             : 
     264         972 : FontUnderline XclFontData::GetScUnderline() const
     265             : {
     266         972 :     FontUnderline eScUnderl = UNDERLINE_NONE;
     267         972 :     switch( mnUnderline )
     268             :     {
     269             :         case EXC_FONTUNDERL_SINGLE:
     270           5 :         case EXC_FONTUNDERL_SINGLE_ACC: eScUnderl = UNDERLINE_SINGLE;  break;
     271             :         case EXC_FONTUNDERL_DOUBLE:
     272           0 :         case EXC_FONTUNDERL_DOUBLE_ACC: eScUnderl = UNDERLINE_DOUBLE;  break;
     273             :     }
     274         972 :     return eScUnderl;
     275             : }
     276             : 
     277         313 : SvxEscapement XclFontData::GetScEscapement() const
     278             : {
     279         313 :     SvxEscapement eScEscapem = SVX_ESCAPEMENT_OFF;
     280         313 :     switch( mnEscapem )
     281             :     {
     282           0 :         case EXC_FONTESC_SUPER: eScEscapem = SVX_ESCAPEMENT_SUPERSCRIPT;    break;
     283           0 :         case EXC_FONTESC_SUB:   eScEscapem = SVX_ESCAPEMENT_SUBSCRIPT;      break;
     284             :     }
     285         313 :     return eScEscapem;
     286             : }
     287             : 
     288         960 : FontStrikeout XclFontData::GetScStrikeout() const
     289             : {
     290         960 :     return mbStrikeout ? STRIKEOUT_SINGLE : STRIKEOUT_NONE;
     291             : }
     292             : 
     293          35 : void XclFontData::SetScHeight( sal_Int32 nTwips )
     294             : {
     295          35 :     mnHeight = static_cast< sal_uInt16 >( ::std::min( nTwips, static_cast<sal_Int32>(0x7FFFL) ) );
     296          35 : }
     297             : 
     298          35 : void XclFontData::SetScFamily( FontFamily eScFamily )
     299             : {
     300          35 :     switch( eScFamily )
     301             :     {
     302           1 :         case FAMILY_DONTKNOW:   mnFamily = EXC_FONTFAM_DONTKNOW;    break;
     303           0 :         case FAMILY_DECORATIVE: mnFamily = EXC_FONTFAM_DECORATIVE;  break;
     304           0 :         case FAMILY_MODERN:     mnFamily = EXC_FONTFAM_MODERN;      break;
     305           0 :         case FAMILY_ROMAN:      mnFamily = EXC_FONTFAM_ROMAN;       break;
     306           0 :         case FAMILY_SCRIPT:     mnFamily = EXC_FONTFAM_SCRIPT;      break;
     307          34 :         case FAMILY_SWISS:      mnFamily = EXC_FONTFAM_SWISS;       break;
     308           0 :         case FAMILY_SYSTEM:     mnFamily = EXC_FONTFAM_SYSTEM;      break;
     309             :         default:
     310             :             OSL_FAIL( "XclFontData::SetScFamily - unknown font family" );
     311           0 :             mnFamily = EXC_FONTFAM_DONTKNOW;
     312             :     }
     313          35 : }
     314             : 
     315          35 : void XclFontData::SetFontEncoding( rtl_TextEncoding eFontEnc )
     316             : {
     317             :     // convert text encoding identifier to Windows character set
     318          35 :     mnCharSet = rtl_getBestWindowsCharsetFromTextEncoding( eFontEnc );
     319          35 : }
     320             : 
     321             : 
     322          36 : void XclFontData::SetScPosture( FontItalic eScPosture )
     323             : {
     324          36 :     mbItalic = (eScPosture == ITALIC_OBLIQUE) || (eScPosture == ITALIC_NORMAL);
     325          36 : }
     326             : 
     327          37 : void XclFontData::SetScWeight( FontWeight eScWeight )
     328             : {
     329          37 :     switch( eScWeight )
     330             :     {
     331           0 :         case WEIGHT_DONTKNOW:   mnWeight = EXC_FONTWGHT_DONTKNOW;   break;
     332           0 :         case WEIGHT_THIN:       mnWeight = EXC_FONTWGHT_THIN;       break;
     333           0 :         case WEIGHT_ULTRALIGHT: mnWeight = EXC_FONTWGHT_ULTRALIGHT; break;
     334           0 :         case WEIGHT_LIGHT:      mnWeight = EXC_FONTWGHT_LIGHT;      break;
     335           0 :         case WEIGHT_SEMILIGHT:  mnWeight = EXC_FONTWGHT_SEMILIGHT;  break;
     336          37 :         case WEIGHT_NORMAL:     mnWeight = EXC_FONTWGHT_NORMAL;     break;
     337           0 :         case WEIGHT_MEDIUM:     mnWeight = EXC_FONTWGHT_MEDIUM;     break;
     338           0 :         case WEIGHT_SEMIBOLD:   mnWeight = EXC_FONTWGHT_SEMIBOLD;   break;
     339           0 :         case WEIGHT_BOLD:       mnWeight = EXC_FONTWGHT_BOLD;       break;
     340           0 :         case WEIGHT_ULTRABOLD:  mnWeight = EXC_FONTWGHT_ULTRABOLD;  break;
     341           0 :         case WEIGHT_BLACK:      mnWeight = EXC_FONTWGHT_BLACK;      break;
     342           0 :         default:                mnWeight = EXC_FONTWGHT_NORMAL;
     343             :     }
     344          37 : }
     345             : 
     346          34 : void XclFontData::SetScUnderline( FontUnderline eScUnderl )
     347             : {
     348          34 :     switch( eScUnderl )
     349             :     {
     350             :         case UNDERLINE_NONE:
     351          34 :         case UNDERLINE_DONTKNOW:    mnUnderline = EXC_FONTUNDERL_NONE;      break;
     352             :         case UNDERLINE_DOUBLE:
     353           0 :         case UNDERLINE_DOUBLEWAVE:  mnUnderline = EXC_FONTUNDERL_DOUBLE;    break;
     354           0 :         default:                    mnUnderline = EXC_FONTUNDERL_SINGLE;
     355             :     }
     356          34 : }
     357             : 
     358           8 : void XclFontData::SetScEscapement( short nScEscapem )
     359             : {
     360           8 :     if( nScEscapem > 0 )
     361           0 :         mnEscapem = EXC_FONTESC_SUPER;
     362           8 :     else if( nScEscapem < 0 )
     363           0 :         mnEscapem = EXC_FONTESC_SUB;
     364             :     else
     365           8 :         mnEscapem = EXC_FONTESC_NONE;
     366           8 : }
     367             : 
     368          34 : void XclFontData::SetScStrikeout( FontStrikeout eScStrikeout )
     369             : {
     370             :     mbStrikeout =
     371             :         (eScStrikeout == STRIKEOUT_SINGLE) || (eScStrikeout == STRIKEOUT_DOUBLE) ||
     372             :         (eScStrikeout == STRIKEOUT_BOLD)   || (eScStrikeout == STRIKEOUT_SLASH)  ||
     373          34 :         (eScStrikeout == STRIKEOUT_X);
     374          34 : }
     375             : 
     376             : // *** conversion of API constants *** ----------------------------------------
     377             : 
     378         548 : float XclFontData::GetApiHeight() const
     379             : {
     380         548 :     return static_cast< float >( mnHeight / TWIPS_PER_POINT );
     381             : }
     382             : 
     383           5 : sal_Int16 XclFontData::GetApiFamily() const
     384             : {
     385           5 :     sal_Int16 nApiFamily = AwtFontFamily::DONTKNOW;
     386           5 :     switch( mnFamily )
     387             :     {
     388           0 :         case FAMILY_DECORATIVE: nApiFamily = AwtFontFamily::DECORATIVE; break;
     389           5 :         case FAMILY_MODERN:     nApiFamily = AwtFontFamily::MODERN;     break;
     390           0 :         case FAMILY_ROMAN:      nApiFamily = AwtFontFamily::ROMAN;      break;
     391           0 :         case FAMILY_SCRIPT:     nApiFamily = AwtFontFamily::SCRIPT;     break;
     392           0 :         case FAMILY_SWISS:      nApiFamily = AwtFontFamily::SWISS;      break;
     393           0 :         case FAMILY_SYSTEM:     nApiFamily = AwtFontFamily::SYSTEM;     break;
     394             :     }
     395           5 :     return nApiFamily;
     396             : }
     397             : 
     398           5 : sal_Int16 XclFontData::GetApiFontEncoding() const
     399             : {
     400             :     // API constants are equal to rtl_TextEncoding constants
     401           5 :     return static_cast< sal_Int16 >( GetFontEncoding() );
     402             : }
     403             : 
     404         548 : Awt::FontSlant XclFontData::GetApiPosture() const
     405             : {
     406         548 :     return mbItalic ? Awt::FontSlant_ITALIC : Awt::FontSlant_NONE;
     407             : }
     408             : 
     409         548 : float XclFontData::GetApiWeight() const
     410             : {
     411         548 :     return VCLUnoHelper::ConvertFontWeight( GetScWeight() );
     412             : }
     413             : 
     414         186 : sal_Int16 XclFontData::GetApiUnderline() const
     415             : {
     416         186 :     sal_Int16 nApiUnderl = AwtFontUnderline::NONE;
     417         186 :     switch( mnUnderline )
     418             :     {
     419             :         case EXC_FONTUNDERL_SINGLE:
     420           0 :         case EXC_FONTUNDERL_SINGLE_ACC: nApiUnderl = AwtFontUnderline::SINGLE;  break;
     421             :         case EXC_FONTUNDERL_DOUBLE:
     422           0 :         case EXC_FONTUNDERL_DOUBLE_ACC: nApiUnderl = AwtFontUnderline::DOUBLE;  break;
     423             :     }
     424         186 :     return nApiUnderl;
     425             : }
     426             : 
     427           0 : sal_Int16 XclFontData::GetApiEscapement() const
     428             : {
     429           0 :     sal_Int16 nApiEscapem = 0;
     430           0 :     switch( mnEscapem )
     431             :     {
     432           0 :         case EXC_FONTESC_SUPER: nApiEscapem = 33;   break;
     433           0 :         case EXC_FONTESC_SUB:   nApiEscapem = -33;  break;
     434             :     }
     435           0 :     return nApiEscapem;
     436             : }
     437             : 
     438         186 : sal_Int16 XclFontData::GetApiStrikeout() const
     439             : {
     440         186 :     return mbStrikeout ? AwtFontStrikeout::SINGLE : AwtFontStrikeout::NONE;
     441             : }
     442             : 
     443           0 : void XclFontData::SetApiHeight( float fPoint )
     444             : {
     445           0 :     mnHeight = static_cast< sal_uInt16 >( ::std::min( fPoint * TWIPS_PER_POINT + 0.5, 32767.0 ) );
     446           0 : }
     447             : 
     448           0 : void XclFontData::SetApiFamily( sal_Int16 nApiFamily )
     449             : {
     450           0 :     switch( nApiFamily )
     451             :     {
     452           0 :         case AwtFontFamily::DECORATIVE: mnFamily = FAMILY_DECORATIVE;   break;
     453           0 :         case AwtFontFamily::MODERN:     mnFamily = FAMILY_MODERN;       break;
     454           0 :         case AwtFontFamily::ROMAN:      mnFamily = FAMILY_ROMAN;        break;
     455           0 :         case AwtFontFamily::SCRIPT:     mnFamily = FAMILY_SCRIPT;       break;
     456           0 :         case AwtFontFamily::SWISS:      mnFamily = FAMILY_SWISS;        break;
     457           0 :         case AwtFontFamily::SYSTEM:     mnFamily = FAMILY_SYSTEM;       break;
     458           0 :         default:                        mnFamily = FAMILY_DONTKNOW;
     459             :     }
     460           0 : }
     461             : 
     462           0 : void XclFontData::SetApiPosture( Awt::FontSlant eApiPosture )
     463             : {
     464             :     mbItalic =
     465             :         (eApiPosture == Awt::FontSlant_OBLIQUE) ||
     466             :         (eApiPosture == Awt::FontSlant_ITALIC) ||
     467             :         (eApiPosture == Awt::FontSlant_REVERSE_OBLIQUE) ||
     468           0 :         (eApiPosture == Awt::FontSlant_REVERSE_ITALIC);
     469           0 : }
     470             : 
     471           0 : void XclFontData::SetApiWeight( float fApiWeight )
     472             : {
     473           0 :     SetScWeight( VCLUnoHelper::ConvertFontWeight( fApiWeight ) );
     474           0 : }
     475             : 
     476           0 : void XclFontData::SetApiUnderline( sal_Int16 nApiUnderl )
     477             : {
     478           0 :     switch( nApiUnderl )
     479             :     {
     480             :         case AwtFontUnderline::NONE:
     481           0 :         case AwtFontUnderline::DONTKNOW:    mnUnderline = EXC_FONTUNDERL_NONE;      break;
     482             :         case AwtFontUnderline::DOUBLE:
     483           0 :         case AwtFontUnderline::DOUBLEWAVE:  mnUnderline = EXC_FONTUNDERL_DOUBLE;    break;
     484           0 :         default:                            mnUnderline = EXC_FONTUNDERL_SINGLE;
     485             :     }
     486           0 : }
     487             : 
     488           0 : void XclFontData::SetApiEscapement( sal_Int16 nApiEscapem )
     489             : {
     490           0 :     if( nApiEscapem > 0 )
     491           0 :         mnEscapem = EXC_FONTESC_SUPER;
     492           0 :     else if( nApiEscapem < 0 )
     493           0 :         mnEscapem = EXC_FONTESC_SUB;
     494             :     else
     495           0 :         mnEscapem = EXC_FONTESC_NONE;
     496           0 : }
     497             : 
     498           0 : void XclFontData::SetApiStrikeout( sal_Int16 nApiStrikeout )
     499             : {
     500             :     mbStrikeout =
     501             :         (nApiStrikeout != AwtFontStrikeout::NONE) &&
     502           0 :         (nApiStrikeout != AwtFontStrikeout::DONTKNOW);
     503           0 : }
     504             : 
     505             : // ----------------------------------------------------------------------------
     506             : 
     507          17 : bool operator==( const XclFontData& rLeft, const XclFontData& rRight )
     508             : {
     509             :     return
     510             :         (rLeft.mnHeight    == rRight.mnHeight)    &&
     511             :         (rLeft.mnWeight    == rRight.mnWeight)    &&
     512             :         (rLeft.mnUnderline == rRight.mnUnderline) &&
     513          17 :         (rLeft.maColor     == rRight.maColor)     &&
     514             :         (rLeft.mnEscapem   == rRight.mnEscapem)   &&
     515             :         (rLeft.mnFamily    == rRight.mnFamily)    &&
     516             :         (rLeft.mnCharSet   == rRight.mnCharSet)   &&
     517             :         (rLeft.mbItalic    == rRight.mbItalic)    &&
     518             :         (rLeft.mbStrikeout == rRight.mbStrikeout) &&
     519             :         (rLeft.mbOutline   == rRight.mbOutline)   &&
     520             :         (rLeft.mbShadow    == rRight.mbShadow)    &&
     521          34 :         (rLeft.maName      == rRight.maName);
     522             : }
     523             : 
     524             : // ----------------------------------------------------------------------------
     525             : 
     526             : namespace {
     527             : 
     528             : /** Property names for common font settings. */
     529             : const sal_Char *const sppcPropNamesChCommon[] =
     530             : {
     531             :     "CharUnderline", "CharStrikeout", "CharColor", "CharContoured", "CharShadowed", 0
     532             : };
     533             : /** Property names for Western font settings. */
     534             : const sal_Char *const sppcPropNamesChWstrn[] =
     535             : {
     536             :     "CharFontName", "CharHeight", "CharPosture", "CharWeight", 0
     537             : };
     538             : /** Property names for Asian font settings. */
     539             : const sal_Char *const sppcPropNamesChAsian[] =
     540             : {
     541             :     "CharFontNameAsian", "CharHeightAsian", "CharPostureAsian", "CharWeightAsian", 0
     542             : };
     543             : /** Property names for Complex font settings. */
     544             : const sal_Char *const sppcPropNamesChCmplx[] =
     545             : {
     546             :     "CharFontNameComplex", "CharHeightComplex", "CharPostureComplex", "CharWeightComplex", 0
     547             : };
     548             : /** Property names for escapement. */
     549             : const sal_Char *const sppcPropNamesChEscapement[] =
     550             : {
     551             :     "CharEscapement", "CharEscapementHeight", 0
     552             : };
     553             : const sal_Int8 EXC_API_ESC_HEIGHT           = 58;   /// Default escapement font height.
     554             : 
     555             : /** Property names for Western font settings without font name. */
     556             : const sal_Char *const *const sppcPropNamesChWstrnNoName = sppcPropNamesChWstrn + 1;
     557             : /** Property names for Asian font settings without font name. */
     558             : const sal_Char *const *const sppcPropNamesChAsianNoName = sppcPropNamesChAsian + 1;
     559             : /** Property names for Complex font settings without font name. */
     560             : const sal_Char *const *const sppcPropNamesChCmplxNoName = sppcPropNamesChCmplx + 1;
     561             : 
     562             : /** Property names for font settings in form controls. */
     563             : const sal_Char *const sppcPropNamesControl[] =
     564             : {
     565             :     "FontName", "FontFamily", "FontCharset", "FontHeight", "FontSlant",
     566             :     "FontWeight", "FontUnderline", "FontStrikeout", "TextColor", 0
     567             : };
     568             : 
     569             : /** Inserts all passed API font settings into the font data object. */
     570           0 : void lclSetApiFontSettings( XclFontData& rFontData,
     571             :         const String& rApiFontName, float fApiHeight, float fApiWeight,
     572             :         Awt::FontSlant eApiPosture, sal_Int16 nApiUnderl, sal_Int16 nApiStrikeout )
     573             : {
     574           0 :     rFontData.maName = XclTools::GetXclFontName( rApiFontName );
     575           0 :     rFontData.SetApiHeight( fApiHeight );
     576           0 :     rFontData.SetApiWeight( fApiWeight );
     577           0 :     rFontData.SetApiPosture( eApiPosture );
     578           0 :     rFontData.SetApiUnderline( nApiUnderl );
     579           0 :     rFontData.SetApiStrikeout( nApiStrikeout );
     580           0 : }
     581             : 
     582             : /** Writes script dependent properties to a font property set helper. */
     583         543 : void lclWriteChartFont( ScfPropertySet& rPropSet,
     584             :         ScfPropSetHelper& rHlpName, ScfPropSetHelper& rHlpNoName,
     585             :         const XclFontData& rFontData, bool bHasFontName )
     586             : {
     587             :     // select the font helper
     588         543 :     ScfPropSetHelper& rPropSetHlp = bHasFontName ? rHlpName : rHlpNoName;
     589             :     // initialize the font helper (must be called before writing any properties)
     590         543 :     rPropSetHlp.InitializeWrite();
     591             :     // write font name
     592         543 :     if( bHasFontName )
     593         354 :         rPropSetHlp << rFontData.maName;
     594             :     // write remaining properties
     595         543 :     rPropSetHlp << rFontData.GetApiHeight() << rFontData.GetApiPosture() << rFontData.GetApiWeight();
     596             :     // write properties to property set
     597         543 :     rPropSetHlp.WriteToPropertySet( rPropSet );
     598         543 : }
     599             : 
     600             : } // namespace
     601             : 
     602             : // ----------------------------------------------------------------------------
     603             : 
     604          21 : XclFontPropSetHelper::XclFontPropSetHelper() :
     605             :     maHlpChCommon( sppcPropNamesChCommon ),
     606             :     maHlpChWstrn( sppcPropNamesChWstrn ),
     607             :     maHlpChAsian( sppcPropNamesChAsian ),
     608             :     maHlpChCmplx( sppcPropNamesChCmplx ),
     609             :     maHlpChWstrnNoName( sppcPropNamesChWstrnNoName ),
     610             :     maHlpChAsianNoName( sppcPropNamesChAsianNoName ),
     611             :     maHlpChCmplxNoName( sppcPropNamesChCmplxNoName ),
     612             :     maHlpChEscapement( sppcPropNamesChEscapement ),
     613          21 :     maHlpControl( sppcPropNamesControl )
     614             : {
     615          21 : }
     616             : 
     617           0 : void XclFontPropSetHelper::ReadFontProperties( XclFontData& rFontData,
     618             :         const ScfPropertySet& rPropSet, XclFontPropSetType eType, sal_Int16 nScript )
     619             : {
     620           0 :     switch( eType )
     621             :     {
     622             :         case EXC_FONTPROPSET_CHART:
     623             :         {
     624           0 :             String aApiFontName;
     625             :             float fApiHeight, fApiWeight;
     626           0 :             sal_Int16 nApiUnderl = 0, nApiStrikeout = 0;
     627             :             Awt::FontSlant eApiPosture;
     628             : 
     629             :             // read script type dependent properties
     630           0 :             ScfPropSetHelper& rPropSetHlp = GetChartHelper( nScript );
     631           0 :             rPropSetHlp.ReadFromPropertySet( rPropSet );
     632           0 :             rPropSetHlp >> aApiFontName >> fApiHeight >> eApiPosture >> fApiWeight;
     633             :             // read common properties
     634           0 :             maHlpChCommon.ReadFromPropertySet( rPropSet );
     635           0 :             maHlpChCommon   >> nApiUnderl
     636           0 :                             >> nApiStrikeout
     637           0 :                             >> rFontData.maColor
     638           0 :                             >> rFontData.mbOutline
     639           0 :                             >> rFontData.mbShadow;
     640             : 
     641             :             // convert API property values to Excel settings
     642             :             lclSetApiFontSettings( rFontData, aApiFontName,
     643           0 :                 fApiHeight, fApiWeight, eApiPosture, nApiUnderl, nApiStrikeout );
     644             : 
     645             :             // font escapement
     646           0 :             sal_Int16 nApiEscapement = 0;
     647           0 :             sal_Int8 nApiEscHeight = 0;
     648           0 :             maHlpChEscapement.ReadFromPropertySet( rPropSet );
     649           0 :             maHlpChEscapement.ReadFromPropertySet( rPropSet );
     650           0 :             maHlpChEscapement.ReadFromPropertySet( rPropSet );
     651           0 :             maHlpChEscapement >> nApiEscapement >> nApiEscHeight;
     652           0 :             rFontData.SetApiEscapement( nApiEscapement );
     653             :         }
     654           0 :         break;
     655             : 
     656             :         case EXC_FONTPROPSET_CONTROL:
     657             :         {
     658           0 :             String aApiFontName;
     659             :             float fApiHeight, fApiWeight;
     660             :             sal_Int16 nApiFamily, nApiCharSet, nApiPosture, nApiUnderl, nApiStrikeout;
     661             : 
     662             :             // read font properties
     663           0 :             maHlpControl.ReadFromPropertySet( rPropSet );
     664           0 :             maHlpControl    >> aApiFontName
     665           0 :                             >> nApiFamily
     666           0 :                             >> nApiCharSet
     667           0 :                             >> fApiHeight
     668           0 :                             >> nApiPosture
     669           0 :                             >> fApiWeight
     670           0 :                             >> nApiUnderl
     671           0 :                             >> nApiStrikeout
     672           0 :                             >> rFontData.maColor;
     673             : 
     674             :             // convert API property values to Excel settings
     675           0 :             Awt::FontSlant eApiPosture = static_cast< Awt::FontSlant >( nApiPosture );
     676             :             lclSetApiFontSettings( rFontData, aApiFontName,
     677           0 :                 fApiHeight, fApiWeight, eApiPosture, nApiUnderl, nApiStrikeout );
     678           0 :             rFontData.SetApiFamily( nApiFamily );
     679           0 :             rFontData.SetFontEncoding( nApiCharSet );
     680             :         }
     681           0 :         break;
     682             :     }
     683           0 : }
     684             : 
     685         186 : void XclFontPropSetHelper::WriteFontProperties(
     686             :         ScfPropertySet& rPropSet, XclFontPropSetType eType,
     687             :         const XclFontData& rFontData, bool bHasWstrn, bool bHasAsian, bool bHasCmplx,
     688             :         const Color* pFontColor )
     689             : {
     690         186 :     switch( eType )
     691             :     {
     692             :         case EXC_FONTPROPSET_CHART:
     693             :         {
     694             :             // write common properties
     695         181 :             maHlpChCommon.InitializeWrite();
     696         181 :             const Color& rColor = pFontColor ? *pFontColor : rFontData.maColor;
     697         362 :             maHlpChCommon   << rFontData.GetApiUnderline()
     698         543 :                             << rFontData.GetApiStrikeout()
     699         181 :                             << rColor
     700         362 :                             << rFontData.mbOutline
     701         362 :                             << rFontData.mbShadow;
     702         181 :             maHlpChCommon.WriteToPropertySet( rPropSet );
     703             : 
     704             :             // write script type dependent properties
     705         181 :             lclWriteChartFont( rPropSet, maHlpChWstrn, maHlpChWstrnNoName, rFontData, bHasWstrn );
     706         181 :             lclWriteChartFont( rPropSet, maHlpChAsian, maHlpChAsianNoName, rFontData, bHasAsian );
     707         181 :             lclWriteChartFont( rPropSet, maHlpChCmplx, maHlpChCmplxNoName, rFontData, bHasCmplx );
     708             : 
     709             :             // font escapement
     710         181 :             if( rFontData.GetScEscapement() != SVX_ESCAPEMENT_OFF )
     711             :             {
     712           0 :                 maHlpChEscapement.InitializeWrite();
     713           0 :                 maHlpChEscapement << rFontData.GetApiEscapement() << EXC_API_ESC_HEIGHT;
     714           0 :                 maHlpChEscapement.WriteToPropertySet( rPropSet );
     715             :             }
     716             :         }
     717         181 :         break;
     718             : 
     719             :         case EXC_FONTPROPSET_CONTROL:
     720             :         {
     721           5 :             maHlpControl.InitializeWrite();
     722           5 :             maHlpControl    << rFontData.maName
     723          15 :                             << rFontData.GetApiFamily()
     724          15 :                             << rFontData.GetApiFontEncoding()
     725          15 :                             << static_cast< sal_Int16 >( rFontData.GetApiHeight() + 0.5 )
     726          15 :                             << rFontData.GetApiPosture()
     727          15 :                             << rFontData.GetApiWeight()
     728          15 :                             << rFontData.GetApiUnderline()
     729          15 :                             << rFontData.GetApiStrikeout()
     730          10 :                             << rFontData.maColor;
     731           5 :             maHlpControl.WriteToPropertySet( rPropSet );
     732             :         }
     733           5 :         break;
     734             :     }
     735         186 : }
     736             : 
     737           0 : ScfPropSetHelper& XclFontPropSetHelper::GetChartHelper( sal_Int16 nScript )
     738             : {
     739             :     namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;
     740           0 :     switch( nScript )
     741             :     {
     742           0 :         case ApiScriptType::LATIN:      return maHlpChWstrn;
     743           0 :         case ApiScriptType::ASIAN:      return maHlpChAsian;
     744           0 :         case ApiScriptType::COMPLEX:    return maHlpChCmplx;
     745             :         default:    OSL_FAIL( "XclFontPropSetHelper::GetChartHelper - unknown script type" );
     746             :     }
     747           0 :     return maHlpChWstrn;
     748             : }
     749             : 
     750             : // Number formats =============================================================
     751             : 
     752             : namespace {
     753             : 
     754             : // ----------------------------------------------------------------------------
     755             : 
     756             : /** Special number format index describing a reused format. */
     757             : const NfIndexTableOffset PRV_NF_INDEX_REUSE = NF_INDEX_TABLE_ENTRIES;
     758             : 
     759             : /** German primary language not defined, LANGUAGE_GERMAN belongs to Germany. */
     760             : const LanguageType PRV_LANGUAGE_GERMAN_PRIM = LANGUAGE_GERMAN & LANGUAGE_MASK_PRIMARY;
     761             : /** French primary language not defined, LANGUAGE_FRENCH belongs to France. */
     762             : const LanguageType PRV_LANGUAGE_FRENCH_PRIM = LANGUAGE_FRENCH & LANGUAGE_MASK_PRIMARY;
     763             : /** Parent language identifier for Asian languages (LANGUAGE_CHINESE is a primary only ID). */
     764             : const LanguageType PRV_LANGUAGE_ASIAN_PRIM = LANGUAGE_CHINESE;
     765             : 
     766             : // ----------------------------------------------------------------------------
     767             : 
     768             : /** Stores the number format used in Calc for an Excel built-in number format. */
     769             : struct XclBuiltInFormat
     770             : {
     771             :     sal_uInt16          mnXclNumFmt;    /// Excel built-in index.
     772             :     const sal_Char*     mpFormat;       /// Format string, may be 0 (meOffset used then).
     773             :     NfIndexTableOffset  meOffset;       /// SvNumberFormatter format index, if mpFormat==0.
     774             :     sal_uInt16          mnXclReuseFmt;  /// Use this Excel format, if meOffset==PRV_NF_INDEX_REUSE.
     775             : };
     776             : 
     777             : // ----------------------------------------------------------------------------
     778             : 
     779             : /** Defines a literal Excel built-in number format. */
     780             : #define EXC_NUMFMT_STRING( nXclNumFmt, pcUtf8 ) \
     781             :     { nXclNumFmt, pcUtf8, NF_NUMBER_STANDARD, 0 }
     782             : 
     783             : /** Defines an Excel built-in number format that maps to an own built-in format. */
     784             : #define EXC_NUMFMT_OFFSET( nXclNumFmt, eOffset ) \
     785             :     { nXclNumFmt, 0, eOffset, 0 }
     786             : 
     787             : /** Defines an Excel built-in number format that is the same as the specified. */
     788             : #define EXC_NUMFMT_REUSE( nXclNumFmt, nXclReuse ) \
     789             :     { nXclNumFmt, 0, PRV_NF_INDEX_REUSE, nXclReuse }
     790             : 
     791             : /** Terminates an Excel built-in number format table. */
     792             : #define EXC_NUMFMT_ENDTABLE() \
     793             :     { EXC_FORMAT_NOTFOUND, 0, NF_NUMBER_STANDARD, 0 }
     794             : 
     795             : // ----------------------------------------------------------------------------
     796             : 
     797             : // Currency unit characters
     798             : #define UTF8_BAHT       "\340\270\277"
     799             : #define UTF8_EURO       "\342\202\254"
     800             : #define UTF8_POUND_UK   "\302\243"
     801             : #define UTF8_SHEQEL     "\342\202\252"
     802             : #define UTF8_WON        "\357\277\246"
     803             : #define UTF8_YEN_CS     "\357\277\245"
     804             : #define UTF8_YEN_JP     "\302\245"
     805             : 
     806             : // Japanese/Chinese date/time characters
     807             : #define UTF8_CJ_YEAR    "\345\271\264"
     808             : #define UTF8_CJ_MON     "\346\234\210"
     809             : #define UTF8_CJ_DAY     "\346\227\245"
     810             : #define UTF8_CJ_HOUR    "\346\231\202"
     811             : #define UTF8_CJ_MIN     "\345\210\206"
     812             : #define UTF8_CJ_SEC     "\347\247\222"
     813             : 
     814             : // Chinese Simplified date/time characters
     815             : #define UTF8_CS_HOUR    "\346\227\266"
     816             : 
     817             : // Korean date/time characters
     818             : #define UTF8_KO_YEAR    "\353\205\204"
     819             : #define UTF8_KO_MON     "\354\233\224"
     820             : #define UTF8_KO_DAY     "\354\235\274"
     821             : #define UTF8_KO_HOUR    "\354\213\234"
     822             : #define UTF8_KO_MIN     "\353\266\204"
     823             : #define UTF8_KO_SEC     "\354\264\210"
     824             : 
     825             : // ----------------------------------------------------------------------------
     826             : 
     827             : /** Default number format table. Last parent of all other tables, used for unknown languages. */
     828             : static const XclBuiltInFormat spBuiltInFormats_DONTKNOW[] =
     829             : {
     830             :     EXC_NUMFMT_OFFSET(   0, NF_NUMBER_STANDARD ),       // General
     831             :     EXC_NUMFMT_OFFSET(   1, NF_NUMBER_INT ),            // 0
     832             :     EXC_NUMFMT_OFFSET(   2, NF_NUMBER_DEC2 ),           // 0.00
     833             :     EXC_NUMFMT_OFFSET(   3, NF_NUMBER_1000INT ),        // #,##0
     834             :     EXC_NUMFMT_OFFSET(   4, NF_NUMBER_1000DEC2 ),       // #,##0.00
     835             :     // 5...8 contained in file
     836             :     EXC_NUMFMT_OFFSET(   9, NF_PERCENT_INT ),           // 0%
     837             :     EXC_NUMFMT_OFFSET(  10, NF_PERCENT_DEC2 ),          // 0.00%
     838             :     EXC_NUMFMT_OFFSET(  11, NF_SCIENTIFIC_000E00 ),     // 0.00E+00
     839             :     EXC_NUMFMT_OFFSET(  12, NF_FRACTION_1 ),            // # ?/?
     840             :     EXC_NUMFMT_OFFSET(  13, NF_FRACTION_2 ),            // # ??/??
     841             : 
     842             :     // 14...22 date and time formats
     843             :     EXC_NUMFMT_OFFSET(  14, NF_DATE_SYS_DDMMYYYY ),
     844             :     EXC_NUMFMT_OFFSET(  15, NF_DATE_SYS_DMMMYY ),
     845             :     EXC_NUMFMT_OFFSET(  16, NF_DATE_SYS_DDMMM ),
     846             :     EXC_NUMFMT_OFFSET(  17, NF_DATE_SYS_MMYY ),
     847             :     EXC_NUMFMT_OFFSET(  18, NF_TIME_HHMMAMPM ),
     848             :     EXC_NUMFMT_OFFSET(  19, NF_TIME_HHMMSSAMPM ),
     849             :     EXC_NUMFMT_OFFSET(  20, NF_TIME_HHMM ),
     850             :     EXC_NUMFMT_OFFSET(  21, NF_TIME_HHMMSS ),
     851             :     EXC_NUMFMT_OFFSET(  22, NF_DATETIME_SYSTEM_SHORT_HHMM ),
     852             : 
     853             :     // 23...36 international formats
     854             :     EXC_NUMFMT_REUSE(   23, 0 ),
     855             :     EXC_NUMFMT_REUSE(   24, 0 ),
     856             :     EXC_NUMFMT_REUSE(   25, 0 ),
     857             :     EXC_NUMFMT_REUSE(   26, 0 ),
     858             :     EXC_NUMFMT_REUSE(   27, 14 ),
     859             :     EXC_NUMFMT_REUSE(   28, 14 ),
     860             :     EXC_NUMFMT_REUSE(   29, 14 ),
     861             :     EXC_NUMFMT_REUSE(   30, 14 ),
     862             :     EXC_NUMFMT_REUSE(   31, 14 ),
     863             :     EXC_NUMFMT_REUSE(   32, 21 ),
     864             :     EXC_NUMFMT_REUSE(   33, 21 ),
     865             :     EXC_NUMFMT_REUSE(   34, 21 ),
     866             :     EXC_NUMFMT_REUSE(   35, 21 ),
     867             :     EXC_NUMFMT_REUSE(   36, 14 ),
     868             : 
     869             :     // 37...44 accounting formats
     870             :     // 41...44 contained in file
     871             :     EXC_NUMFMT_STRING(  37, "#,##0;-#,##0" ),
     872             :     EXC_NUMFMT_STRING(  38, "#,##0;[RED]-#,##0" ),
     873             :     EXC_NUMFMT_STRING(  39, "#,##0.00;-#,##0.00" ),
     874             :     EXC_NUMFMT_STRING(  40, "#,##0.00;[RED]-#,##0.00" ),
     875             : 
     876             :     // 45...49 more special formats
     877             :     EXC_NUMFMT_STRING(  45, "mm:ss" ),
     878             :     EXC_NUMFMT_STRING(  46, "[h]:mm:ss" ),
     879             :     EXC_NUMFMT_STRING(  47, "mm:ss.0" ),
     880             :     EXC_NUMFMT_STRING(  48, "##0.0E+0" ),
     881             :     EXC_NUMFMT_OFFSET(  49, NF_TEXT ),
     882             : 
     883             :     // 50...81 international formats
     884             :     EXC_NUMFMT_REUSE(   50, 14 ),
     885             :     EXC_NUMFMT_REUSE(   51, 14 ),
     886             :     EXC_NUMFMT_REUSE(   52, 14 ),
     887             :     EXC_NUMFMT_REUSE(   53, 14 ),
     888             :     EXC_NUMFMT_REUSE(   54, 14 ),
     889             :     EXC_NUMFMT_REUSE(   55, 14 ),
     890             :     EXC_NUMFMT_REUSE(   56, 14 ),
     891             :     EXC_NUMFMT_REUSE(   57, 14 ),
     892             :     EXC_NUMFMT_REUSE(   58, 14 ),
     893             :     EXC_NUMFMT_REUSE(   59, 1 ),
     894             :     EXC_NUMFMT_REUSE(   60, 2 ),
     895             :     EXC_NUMFMT_REUSE(   61, 3 ),
     896             :     EXC_NUMFMT_REUSE(   62, 4 ),
     897             :     EXC_NUMFMT_REUSE(   67, 9 ),
     898             :     EXC_NUMFMT_REUSE(   68, 10 ),
     899             :     EXC_NUMFMT_REUSE(   69, 12 ),
     900             :     EXC_NUMFMT_REUSE(   70, 13 ),
     901             :     EXC_NUMFMT_REUSE(   71, 14 ),
     902             :     EXC_NUMFMT_REUSE(   72, 14 ),
     903             :     EXC_NUMFMT_REUSE(   73, 15 ),
     904             :     EXC_NUMFMT_REUSE(   74, 16 ),
     905             :     EXC_NUMFMT_REUSE(   75, 17 ),
     906             :     EXC_NUMFMT_REUSE(   76, 20 ),
     907             :     EXC_NUMFMT_REUSE(   77, 21 ),
     908             :     EXC_NUMFMT_REUSE(   78, 22 ),
     909             :     EXC_NUMFMT_REUSE(   79, 45 ),
     910             :     EXC_NUMFMT_REUSE(   80, 46 ),
     911             :     EXC_NUMFMT_REUSE(   81, 47 ),
     912             : 
     913             :     // 82...163 not used, must not occur in a file (Excel may crash)
     914             : 
     915             :     EXC_NUMFMT_ENDTABLE()
     916             : };
     917             : 
     918             : // ENGLISH --------------------------------------------------------------------
     919             : 
     920             : /** Base table for English locales. */
     921             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH[] =
     922             : {
     923             :     EXC_NUMFMT_STRING(  15, "DD-MMM-YY" ),
     924             :     EXC_NUMFMT_STRING(  16, "DD-MMM" ),
     925             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
     926             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
     927             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
     928             :     EXC_NUMFMT_STRING(  22, "DD/MM/YYYY hh:mm" ),
     929             :     EXC_NUMFMT_ENDTABLE()
     930             : };
     931             : 
     932             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_UK[] =
     933             : {
     934             :     EXC_NUMFMT_STRING(  63, UTF8_POUND_UK "#,##0;-" UTF8_POUND_UK "#,##0" ),
     935             :     EXC_NUMFMT_STRING(  64, UTF8_POUND_UK "#,##0;[RED]-" UTF8_POUND_UK "#,##0" ),
     936             :     EXC_NUMFMT_STRING(  65, UTF8_POUND_UK "#,##0.00;-" UTF8_POUND_UK "#,##0.00" ),
     937             :     EXC_NUMFMT_STRING(  66, UTF8_POUND_UK "#,##0.00;[RED]-" UTF8_POUND_UK "#,##0.00" ),
     938             :     EXC_NUMFMT_ENDTABLE()
     939             : };
     940             : 
     941             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_EIRE[] =
     942             : {
     943             :     EXC_NUMFMT_STRING(  63, UTF8_EURO "#,##0;-" UTF8_EURO "#,##0" ),
     944             :     EXC_NUMFMT_STRING(  64, UTF8_EURO "#,##0;[RED]-" UTF8_EURO "#,##0" ),
     945             :     EXC_NUMFMT_STRING(  65, UTF8_EURO "#,##0.00;-" UTF8_EURO "#,##0.00" ),
     946             :     EXC_NUMFMT_STRING(  66, UTF8_EURO "#,##0.00;[RED]-" UTF8_EURO "#,##0.00" ),
     947             :     EXC_NUMFMT_ENDTABLE()
     948             : };
     949             : 
     950             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_US[] =
     951             : {
     952             :     EXC_NUMFMT_STRING(  14, "M/D/YYYY" ),
     953             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
     954             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
     955             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
     956             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
     957             :     EXC_NUMFMT_STRING(  22, "M/D/YYYY h:mm" ),
     958             :     EXC_NUMFMT_STRING(  37, "#,##0_);(#,##0)" ),
     959             :     EXC_NUMFMT_STRING(  38, "#,##0_);[RED](#,##0)" ),
     960             :     EXC_NUMFMT_STRING(  39, "#,##0.00_);(#,##0.00)" ),
     961             :     EXC_NUMFMT_STRING(  40, "#,##0.00_);[RED](#,##0.00)" ),
     962             :     EXC_NUMFMT_STRING(  63, "$#,##0_);($#,##0)" ),
     963             :     EXC_NUMFMT_STRING(  64, "$#,##0_);[RED]($#,##0)" ),
     964             :     EXC_NUMFMT_STRING(  65, "$#,##0.00_);($#,##0.00)" ),
     965             :     EXC_NUMFMT_STRING(  66, "$#,##0.00_);[RED]($#,##0.00)" ),
     966             :     EXC_NUMFMT_ENDTABLE()
     967             : };
     968             : 
     969             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_CAN[] =
     970             : {
     971             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
     972             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
     973             :     EXC_NUMFMT_STRING(  22, "DD/MM/YYYY h:mm" ),
     974             :     EXC_NUMFMT_STRING(  63, "$#,##0;-$#,##0" ),
     975             :     EXC_NUMFMT_STRING(  64, "$#,##0;[RED]-$#,##0" ),
     976             :     EXC_NUMFMT_STRING(  65, "$#,##0.00;-$#,##0.00" ),
     977             :     EXC_NUMFMT_STRING(  66, "$#,##0.00;[RED]-$#,##0.00" ),
     978             :     EXC_NUMFMT_ENDTABLE()
     979             : };
     980             : 
     981             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_AUS[] =
     982             : {
     983             :     EXC_NUMFMT_STRING(  14, "D/MM/YYYY" ),
     984             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
     985             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
     986             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
     987             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
     988             :     EXC_NUMFMT_STRING(  22, "D/MM/YYYY h:mm" ),
     989             :     EXC_NUMFMT_STRING(  63, "$#,##0;-$#,##0" ),
     990             :     EXC_NUMFMT_STRING(  64, "$#,##0;[RED]-$#,##0" ),
     991             :     EXC_NUMFMT_STRING(  65, "$#,##0.00;-$#,##0.00" ),
     992             :     EXC_NUMFMT_STRING(  66, "$#,##0.00;[RED]-$#,##0.00" ),
     993             :     EXC_NUMFMT_ENDTABLE()
     994             : };
     995             : 
     996             : static const XclBuiltInFormat spBuiltInFormats_ENGLISH_SAFRICA[] =
     997             : {
     998             :     EXC_NUMFMT_STRING(  14, "YYYY/MM/DD" ),
     999             :     EXC_NUMFMT_OFFSET(  18, NF_TIME_HHMMAMPM ),
    1000             :     EXC_NUMFMT_OFFSET(  19, NF_TIME_HHMMSSAMPM ),
    1001             :     EXC_NUMFMT_STRING(  22, "YYYY/MM/DD hh:mm" ),
    1002             :     EXC_NUMFMT_STRING(  63, "\\R #,##0;\\R -#,##0" ),
    1003             :     EXC_NUMFMT_STRING(  64, "\\R #,##0;[RED]\\R -#,##0" ),
    1004             :     EXC_NUMFMT_STRING(  65, "\\R #,##0.00;\\R -#,##0.00" ),
    1005             :     EXC_NUMFMT_STRING(  66, "\\R #,##0.00;[RED]\\R -#,##0.00" ),
    1006             :     EXC_NUMFMT_ENDTABLE()
    1007             : };
    1008             : 
    1009             : // FRENCH ---------------------------------------------------------------------
    1010             : 
    1011             : /** Base table for French locales. */
    1012             : static const XclBuiltInFormat spBuiltInFormats_FRENCH[] =
    1013             : {
    1014             :     EXC_NUMFMT_STRING(  15, "DD-MMM-YY" ),
    1015             :     EXC_NUMFMT_STRING(  16, "DD-MMM" ),
    1016             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1017             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1018             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1019             :     EXC_NUMFMT_ENDTABLE()
    1020             : };
    1021             : 
    1022             : static const XclBuiltInFormat spBuiltInFormats_FRENCH_FRANCE[] =
    1023             : {
    1024             :     EXC_NUMFMT_STRING(  22, "DD/MM/YYYY hh:mm" ),
    1025             :     EXC_NUMFMT_STRING(  37, "#,##0\\ _" UTF8_EURO ";-#,##0\\ _" UTF8_EURO ),
    1026             :     EXC_NUMFMT_STRING(  38, "#,##0\\ _" UTF8_EURO ";[RED]-#,##0\\ _" UTF8_EURO ),
    1027             :     EXC_NUMFMT_STRING(  39, "#,##0.00\\ _" UTF8_EURO ";-#,##0.00\\ _" UTF8_EURO ),
    1028             :     EXC_NUMFMT_STRING(  40, "#,##0.00\\ _" UTF8_EURO ";[RED]-#,##0.00\\ _" UTF8_EURO ),
    1029             :     EXC_NUMFMT_STRING(  63, "#,##0\\ " UTF8_EURO ";-#,##0\\ " UTF8_EURO ),
    1030             :     EXC_NUMFMT_STRING(  64, "#,##0\\ " UTF8_EURO ";[RED]-#,##0\\ " UTF8_EURO ),
    1031             :     EXC_NUMFMT_STRING(  65, "#,##0.00\\ " UTF8_EURO ";-#,##0.00\\ " UTF8_EURO ),
    1032             :     EXC_NUMFMT_STRING(  66, "#,##0.00\\ " UTF8_EURO ";[RED]-#,##0.00\\ " UTF8_EURO ),
    1033             :     EXC_NUMFMT_ENDTABLE()
    1034             : };
    1035             : 
    1036             : static const XclBuiltInFormat spBuiltInFormats_FRENCH_CANADIAN[] =
    1037             : {
    1038             :     EXC_NUMFMT_STRING(  22, "YYYY-MM-DD hh:mm" ),
    1039             :     EXC_NUMFMT_STRING(  37, "#,##0\\ _$_-;#,##0\\ _$-" ),
    1040             :     EXC_NUMFMT_STRING(  38, "#,##0\\ _$_-;[RED]#,##0\\ _$-" ),
    1041             :     EXC_NUMFMT_STRING(  39, "#,##0.00\\ _$_-;#,##0.00\\ _$-" ),
    1042             :     EXC_NUMFMT_STRING(  40, "#,##0.00\\ _$_-;[RED]#,##0.00\\ _$-" ),
    1043             :     EXC_NUMFMT_STRING(  63, "#,##0\\ $_-;#,##0\\ $-" ),
    1044             :     EXC_NUMFMT_STRING(  64, "#,##0\\ $_-;[RED]#,##0\\ $-" ),
    1045             :     EXC_NUMFMT_STRING(  65, "#,##0.00\\ $_-;#,##0.00\\ $-" ),
    1046             :     EXC_NUMFMT_STRING(  66, "#,##0.00\\ $_-;[RED]#,##0.00\\ $-" ),
    1047             :     EXC_NUMFMT_ENDTABLE()
    1048             : };
    1049             : 
    1050             : static const XclBuiltInFormat spBuiltInFormats_FRENCH_SWISS[] =
    1051             : {
    1052             :     EXC_NUMFMT_STRING(  15, "DD.MMM.YY" ),
    1053             :     EXC_NUMFMT_STRING(  16, "DD.MMM" ),
    1054             :     EXC_NUMFMT_STRING(  17, "MMM.YY" ),
    1055             :     EXC_NUMFMT_STRING(  22, "DD.MM.YYYY hh:mm" ),
    1056             :     EXC_NUMFMT_STRING(  63, "\"SFr. \"#,##0;\"SFr. \"-#,##0" ),
    1057             :     EXC_NUMFMT_STRING(  64, "\"SFr. \"#,##0;[RED]\"SFr. \"-#,##0" ),
    1058             :     EXC_NUMFMT_STRING(  65, "\"SFr. \"#,##0.00;\"SFr. \"-#,##0.00" ),
    1059             :     EXC_NUMFMT_STRING(  66, "\"SFr. \"#,##0.00;[RED]\"SFr. \"-#,##0.00" ),
    1060             :     EXC_NUMFMT_ENDTABLE()
    1061             : };
    1062             : 
    1063             : static const XclBuiltInFormat spBuiltInFormats_FRENCH_BELGIAN[] =
    1064             : {
    1065             :     EXC_NUMFMT_STRING(  14, "D/MM/YYYY" ),
    1066             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
    1067             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
    1068             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
    1069             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
    1070             :     EXC_NUMFMT_STRING(  22, "D/MM/YYYY h:mm" ),
    1071             :     EXC_NUMFMT_ENDTABLE()
    1072             : };
    1073             : 
    1074             : // GERMAN ---------------------------------------------------------------------
    1075             : 
    1076             : /** Base table for German locales. */
    1077             : static const XclBuiltInFormat spBuiltInFormats_GERMAN[] =
    1078             : {
    1079             :     EXC_NUMFMT_STRING(  15, "DD. MMM YY" ),
    1080             :     EXC_NUMFMT_STRING(  16, "DD. MMM" ),
    1081             :     EXC_NUMFMT_STRING(  17, "MMM YY" ),
    1082             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1083             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1084             :     EXC_NUMFMT_STRING(  22, "DD.MM.YYYY hh:mm" ),
    1085             :     EXC_NUMFMT_ENDTABLE()
    1086             : };
    1087             : 
    1088             : static const XclBuiltInFormat spBuiltInFormats_GERMAN_GERMANY[] =
    1089             : {
    1090             :     EXC_NUMFMT_STRING(  37, "#,##0 _" UTF8_EURO ";-#,##0 _" UTF8_EURO ),
    1091             :     EXC_NUMFMT_STRING(  38, "#,##0 _" UTF8_EURO ";[RED]-#,##0 _" UTF8_EURO ),
    1092             :     EXC_NUMFMT_STRING(  39, "#,##0.00 _" UTF8_EURO ";-#,##0.00 _" UTF8_EURO ),
    1093             :     EXC_NUMFMT_STRING(  40, "#,##0.00 _" UTF8_EURO ";[RED]-#,##0.00 _" UTF8_EURO ),
    1094             :     EXC_NUMFMT_STRING(  63, "#,##0 " UTF8_EURO ";-#,##0 " UTF8_EURO ),
    1095             :     EXC_NUMFMT_STRING(  64, "#,##0 " UTF8_EURO ";[RED]-#,##0 " UTF8_EURO ),
    1096             :     EXC_NUMFMT_STRING(  65, "#,##0.00 " UTF8_EURO ";-#,##0.00 " UTF8_EURO ),
    1097             :     EXC_NUMFMT_STRING(  66, "#,##0.00 " UTF8_EURO ";[RED]-#,##0.00 " UTF8_EURO ),
    1098             :     EXC_NUMFMT_ENDTABLE()
    1099             : };
    1100             : 
    1101             : static const XclBuiltInFormat spBuiltInFormats_GERMAN_AUSTRIAN[] =
    1102             : {
    1103             :     EXC_NUMFMT_STRING(  15, "DD.MMM.YY" ),
    1104             :     EXC_NUMFMT_STRING(  16, "DD.MMM" ),
    1105             :     EXC_NUMFMT_STRING(  17, "MMM.YY" ),
    1106             :     EXC_NUMFMT_STRING(  63, UTF8_EURO " #,##0;-" UTF8_EURO " #,##0" ),
    1107             :     EXC_NUMFMT_STRING(  64, UTF8_EURO " #,##0;[RED]-" UTF8_EURO " #,##0" ),
    1108             :     EXC_NUMFMT_STRING(  65, UTF8_EURO " #,##0.00;-" UTF8_EURO " #,##0.00" ),
    1109             :     EXC_NUMFMT_STRING(  66, UTF8_EURO " #,##0.00;[RED]-" UTF8_EURO " #,##0.00" ),
    1110             :     EXC_NUMFMT_ENDTABLE()
    1111             : };
    1112             : 
    1113             : static const XclBuiltInFormat spBuiltInFormats_GERMAN_SWISS[] =
    1114             : {
    1115             :     EXC_NUMFMT_STRING(  63, "\"SFr. \"#,##0;\"SFr. \"-#,##0" ),
    1116             :     EXC_NUMFMT_STRING(  64, "\"SFr. \"#,##0;[RED]\"SFr. \"-#,##0" ),
    1117             :     EXC_NUMFMT_STRING(  65, "\"SFr. \"#,##0.00;\"SFr. \"-#,##0.00" ),
    1118             :     EXC_NUMFMT_STRING(  66, "\"SFr. \"#,##0.00;[RED]\"SFr. \"-#,##0.00" ),
    1119             :     EXC_NUMFMT_ENDTABLE()
    1120             : };
    1121             : 
    1122             : static const XclBuiltInFormat spBuiltInFormats_GERMAN_LUXEMBOURG[] =
    1123             : {
    1124             :     EXC_NUMFMT_STRING(  15, "DD.MMM.YY" ),
    1125             :     EXC_NUMFMT_STRING(  16, "DD.MMM" ),
    1126             :     EXC_NUMFMT_STRING(  17, "MMM.YY" ),
    1127             :     EXC_NUMFMT_STRING(  37, "#,##0 _" UTF8_EURO ";-#,##0 _" UTF8_EURO ),
    1128             :     EXC_NUMFMT_STRING(  38, "#,##0 _" UTF8_EURO ";[RED]-#,##0 _" UTF8_EURO ),
    1129             :     EXC_NUMFMT_STRING(  39, "#,##0.00 _" UTF8_EURO ";-#,##0.00 _" UTF8_EURO ),
    1130             :     EXC_NUMFMT_STRING(  40, "#,##0.00 _" UTF8_EURO ";[RED]-#,##0.00 _" UTF8_EURO ),
    1131             :     EXC_NUMFMT_STRING(  63, "#,##0 " UTF8_EURO ";-#,##0 " UTF8_EURO ),
    1132             :     EXC_NUMFMT_STRING(  64, "#,##0 " UTF8_EURO ";[RED]-#,##0 " UTF8_EURO ),
    1133             :     EXC_NUMFMT_STRING(  65, "#,##0.00 " UTF8_EURO ";-#,##0.00 " UTF8_EURO ),
    1134             :     EXC_NUMFMT_STRING(  66, "#,##0.00 " UTF8_EURO ";[RED]-#,##0.00 " UTF8_EURO ),
    1135             :     EXC_NUMFMT_ENDTABLE()
    1136             : };
    1137             : 
    1138             : static const XclBuiltInFormat spBuiltInFormats_GERMAN_LIECHTENSTEIN[] =
    1139             : {
    1140             :     EXC_NUMFMT_STRING(  63, "\"CHF \"#,##0;\"CHF \"-#,##0" ),
    1141             :     EXC_NUMFMT_STRING(  64, "\"CHF \"#,##0;[RED]\"CHF \"-#,##0" ),
    1142             :     EXC_NUMFMT_STRING(  65, "\"CHF \"#,##0.00;\"CHF \"-#,##0.00" ),
    1143             :     EXC_NUMFMT_STRING(  66, "\"CHF \"#,##0.00;[RED]\"CHF \"-#,##0.00" ),
    1144             :     EXC_NUMFMT_ENDTABLE()
    1145             : };
    1146             : 
    1147             : // ITALIAN --------------------------------------------------------------------
    1148             : 
    1149             : static const XclBuiltInFormat spBuiltInFormats_ITALIAN_ITALY[] =
    1150             : {
    1151             :     EXC_NUMFMT_STRING(  15, "DD-MMM-YY" ),
    1152             :     EXC_NUMFMT_STRING(  16, "DD-MMM" ),
    1153             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1154             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1155             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1156             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
    1157             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
    1158             :     EXC_NUMFMT_STRING(  22, "DD/MM/YYYY h:mm" ),
    1159             :     EXC_NUMFMT_STRING(  63, UTF8_EURO " #,##0;-" UTF8_EURO " #,##0" ),
    1160             :     EXC_NUMFMT_STRING(  64, UTF8_EURO " #,##0;[RED]-" UTF8_EURO " #,##0" ),
    1161             :     EXC_NUMFMT_STRING(  65, UTF8_EURO " #,##0.00;-" UTF8_EURO " #,##0.00" ),
    1162             :     EXC_NUMFMT_STRING(  66, UTF8_EURO " #,##0.00;[RED]-" UTF8_EURO " #,##0.00" ),
    1163             :     EXC_NUMFMT_ENDTABLE()
    1164             : };
    1165             : 
    1166             : static const XclBuiltInFormat spBuiltInFormats_ITALIAN_SWISS[] =
    1167             : {
    1168             :     EXC_NUMFMT_STRING(  15, "DD.MMM.YY" ),
    1169             :     EXC_NUMFMT_STRING(  16, "DD.MMM" ),
    1170             :     EXC_NUMFMT_STRING(  17, "MMM.YY" ),
    1171             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1172             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1173             :     EXC_NUMFMT_STRING(  22, "DD.MM.YYYY hh:mm" ),
    1174             :     EXC_NUMFMT_STRING(  63, "\"SFr. \"#,##0;\"SFr. \"-#,##0" ),
    1175             :     EXC_NUMFMT_STRING(  64, "\"SFr. \"#,##0;[RED]\"SFr. \"-#,##0" ),
    1176             :     EXC_NUMFMT_STRING(  65, "\"SFr. \"#,##0.00;\"SFr. \"-#,##0.00" ),
    1177             :     EXC_NUMFMT_STRING(  66, "\"SFr. \"#,##0.00;[RED]\"SFr. \"-#,##0.00" ),
    1178             :     EXC_NUMFMT_ENDTABLE()
    1179             : };
    1180             : 
    1181             : // SWEDISH --------------------------------------------------------------------
    1182             : 
    1183             : static const XclBuiltInFormat spBuiltInFormats_SWEDISH_SWEDEN[] =
    1184             : {
    1185             :     EXC_NUMFMT_STRING(  15, "DD-MMM-YY" ),
    1186             :     EXC_NUMFMT_STRING(  16, "DD-MMM" ),
    1187             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1188             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1189             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1190             :     EXC_NUMFMT_STRING(  22, "YYYY-MM-DD hh:mm" ),
    1191             :     EXC_NUMFMT_STRING(  37, "#,##0 _k_r;-#,##0 _k_r" ),
    1192             :     EXC_NUMFMT_STRING(  38, "#,##0 _k_r;[RED]-#,##0 _k_r" ),
    1193             :     EXC_NUMFMT_STRING(  39, "#,##0.00 _k_r;-#,##0.00 _k_r" ),
    1194             :     EXC_NUMFMT_STRING(  40, "#,##0.00 _k_r;[RED]-#,##0.00 _k_r" ),
    1195             :     EXC_NUMFMT_STRING(  63, "#,##0 \"kr\";-#,##0 \"kr\"" ),
    1196             :     EXC_NUMFMT_STRING(  64, "#,##0 \"kr\";[RED]-#,##0 \"kr\"" ),
    1197             :     EXC_NUMFMT_STRING(  65, "#,##0.00 \"kr\";-#,##0.00 \"kr\"" ),
    1198             :     EXC_NUMFMT_STRING(  66, "#,##0.00 \"kr\";[RED]-#,##0.00 \"kr\"" ),
    1199             :     EXC_NUMFMT_ENDTABLE()
    1200             : };
    1201             : 
    1202             : static const XclBuiltInFormat spBuiltInFormats_SWEDISH_FINLAND[] =
    1203             : {
    1204             :     EXC_NUMFMT_STRING(   9, "0 %" ),
    1205             :     EXC_NUMFMT_STRING(  10, "0.00 %" ),
    1206             :     EXC_NUMFMT_STRING(  15, "DD.MMM.YY" ),
    1207             :     EXC_NUMFMT_STRING(  16, "DD.MMM" ),
    1208             :     EXC_NUMFMT_STRING(  17, "MMM.YY" ),
    1209             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1210             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1211             :     EXC_NUMFMT_STRING(  22, "D.M.YYYY hh:mm" ),
    1212             :     EXC_NUMFMT_STRING(  37, "#,##0 _" UTF8_EURO ";-#,##0 _" UTF8_EURO ),
    1213             :     EXC_NUMFMT_STRING(  38, "#,##0 _" UTF8_EURO ";[RED]-#,##0 _" UTF8_EURO ),
    1214             :     EXC_NUMFMT_STRING(  39, "#,##0.00 _" UTF8_EURO ";-#,##0.00 _" UTF8_EURO ),
    1215             :     EXC_NUMFMT_STRING(  40, "#,##0.00 _" UTF8_EURO ";[RED]-#,##0.00 _" UTF8_EURO ),
    1216             :     EXC_NUMFMT_STRING(  63, "#,##0 " UTF8_EURO ";-#,##0 " UTF8_EURO ),
    1217             :     EXC_NUMFMT_STRING(  64, "#,##0 " UTF8_EURO ";[RED]-#,##0 " UTF8_EURO ),
    1218             :     EXC_NUMFMT_STRING(  65, "#,##0.00 " UTF8_EURO ";-#,##0.00 " UTF8_EURO ),
    1219             :     EXC_NUMFMT_STRING(  66, "#,##0.00 " UTF8_EURO ";[RED]-#,##0.00 " UTF8_EURO ),
    1220             :     EXC_NUMFMT_ENDTABLE()
    1221             : };
    1222             : 
    1223             : // ASIAN ----------------------------------------------------------------------
    1224             : 
    1225             : /** Base table for Asian locales. */
    1226             : static const XclBuiltInFormat spBuiltInFormats_ASIAN[] =
    1227             : {
    1228             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1229             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1230             :     EXC_NUMFMT_STRING(  20, "h:mm" ),
    1231             :     EXC_NUMFMT_STRING(  21, "h:mm:ss" ),
    1232             :     EXC_NUMFMT_STRING(  23, "$#,##0_);($#,##0)" ),
    1233             :     EXC_NUMFMT_STRING(  24, "$#,##0_);[RED]($#,##0)" ),
    1234             :     EXC_NUMFMT_STRING(  25, "$#,##0.00_);($#,##0.00)" ),
    1235             :     EXC_NUMFMT_STRING(  26, "$#,##0.00_);[RED]($#,##0.00)" ),
    1236             :     EXC_NUMFMT_REUSE(   29, 28 ),
    1237             :     EXC_NUMFMT_REUSE(   36, 27 ),
    1238             :     EXC_NUMFMT_REUSE(   50, 27 ),
    1239             :     EXC_NUMFMT_REUSE(   51, 28 ),
    1240             :     EXC_NUMFMT_REUSE(   52, 34 ),
    1241             :     EXC_NUMFMT_REUSE(   53, 35 ),
    1242             :     EXC_NUMFMT_REUSE(   54, 28 ),
    1243             :     EXC_NUMFMT_REUSE(   55, 34 ),
    1244             :     EXC_NUMFMT_REUSE(   56, 35 ),
    1245             :     EXC_NUMFMT_REUSE(   57, 27 ),
    1246             :     EXC_NUMFMT_REUSE(   58, 28 ),
    1247             :     EXC_NUMFMT_ENDTABLE()
    1248             : };
    1249             : 
    1250             : static const XclBuiltInFormat spBuiltInFormats_JAPANESE[] =
    1251             : {
    1252             :     EXC_NUMFMT_STRING(  14, "YYYY/M/D" ),
    1253             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
    1254             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
    1255             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1256             :     EXC_NUMFMT_STRING(  22, "YYYY/M/D h:mm" ),
    1257             :     EXC_NUMFMT_STRING(  27, "[$-0411]GE.M.D" ),
    1258             :     EXC_NUMFMT_STRING(  28, "[$-0411]GGGE" UTF8_CJ_YEAR "M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1259             :     EXC_NUMFMT_STRING(  30, "[$-0411]M/D/YY" ),
    1260             :     EXC_NUMFMT_STRING(  31, "[$-0411]YYYY" UTF8_CJ_YEAR "M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1261             :     EXC_NUMFMT_STRING(  32, "[$-0411]h" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN ),
    1262             :     EXC_NUMFMT_STRING(  33, "[$-0411]h" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN "ss" UTF8_CJ_SEC ),
    1263             :     EXC_NUMFMT_STRING(  34, "[$-0411]YYYY" UTF8_CJ_YEAR "M" UTF8_CJ_MON ),
    1264             :     EXC_NUMFMT_STRING(  35, "[$-0411]M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1265             :     EXC_NUMFMT_STRING(  63, UTF8_YEN_JP "#,##0;-" UTF8_YEN_JP "#,##0" ),
    1266             :     EXC_NUMFMT_STRING(  64, UTF8_YEN_JP "#,##0;[RED]-" UTF8_YEN_JP "#,##0" ),
    1267             :     EXC_NUMFMT_STRING(  65, UTF8_YEN_JP "#,##0.00;-" UTF8_YEN_JP "#,##0.00" ),
    1268             :     EXC_NUMFMT_STRING(  66, UTF8_YEN_JP "#,##0.00;[RED]-" UTF8_YEN_JP "#,##0.00" ),
    1269             :     EXC_NUMFMT_ENDTABLE()
    1270             : };
    1271             : 
    1272             : static const XclBuiltInFormat spBuiltInFormats_KOREAN[] =
    1273             : {
    1274             :     EXC_NUMFMT_STRING(  14, "YYYY-MM-DD" ),
    1275             :     EXC_NUMFMT_STRING(  15, "DD-MMM-YY" ),
    1276             :     EXC_NUMFMT_STRING(  16, "DD-MMM" ),
    1277             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1278             :     EXC_NUMFMT_STRING(  22, "YYYY-MM-DD h:mm" ),
    1279             :     EXC_NUMFMT_STRING(  27, "[$-0412]YYYY" UTF8_CJ_YEAR " MM" UTF8_CJ_MON " DD" UTF8_CJ_DAY ),
    1280             :     EXC_NUMFMT_STRING(  28, "[$-0412]MM-DD" ),
    1281             :     EXC_NUMFMT_STRING(  30, "[$-0412]MM-DD-YY" ),
    1282             :     EXC_NUMFMT_STRING(  31, "[$-0412]YYYY" UTF8_KO_YEAR " MM" UTF8_KO_MON " DD" UTF8_KO_DAY ),
    1283             :     EXC_NUMFMT_STRING(  32, "[$-0412]h" UTF8_KO_HOUR " mm" UTF8_KO_MIN ),
    1284             :     EXC_NUMFMT_STRING(  33, "[$-0412]h" UTF8_KO_HOUR " mm" UTF8_KO_MIN " ss" UTF8_KO_SEC ),
    1285             :     EXC_NUMFMT_STRING(  34, "[$-0412]YYYY\"/\"MM\"/\"DD" ),
    1286             :     EXC_NUMFMT_STRING(  35, "[$-0412]YYYY-MM-DD" ),
    1287             :     EXC_NUMFMT_STRING(  63, UTF8_WON "#,##0;-" UTF8_WON "#,##0" ),
    1288             :     EXC_NUMFMT_STRING(  64, UTF8_WON "#,##0;[RED]-" UTF8_WON "#,##0" ),
    1289             :     EXC_NUMFMT_STRING(  65, UTF8_WON "#,##0.00;-" UTF8_WON "#,##0.00" ),
    1290             :     EXC_NUMFMT_STRING(  66, UTF8_WON "#,##0.00;[RED]-" UTF8_WON "#,##0.00" ),
    1291             :     EXC_NUMFMT_ENDTABLE()
    1292             : };
    1293             : 
    1294             : static const XclBuiltInFormat spBuiltInFormats_CHINESE_SIMPLIFIED[] =
    1295             : {
    1296             :     EXC_NUMFMT_STRING(  14, "YYYY-M-D" ),
    1297             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
    1298             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
    1299             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1300             :     EXC_NUMFMT_STRING(  22, "YYYY-M-D h:mm" ),
    1301             :     EXC_NUMFMT_STRING(  27, "[$-0804]YYYY" UTF8_CJ_YEAR "M" UTF8_CJ_MON ),
    1302             :     EXC_NUMFMT_STRING(  28, "[$-0804]M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1303             :     EXC_NUMFMT_STRING(  30, "[$-0804]M-D-YY" ),
    1304             :     EXC_NUMFMT_STRING(  31, "[$-0804]YYYY" UTF8_CJ_YEAR "M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1305             :     EXC_NUMFMT_STRING(  32, "[$-0804]h" UTF8_CS_HOUR "mm" UTF8_CJ_MIN ),
    1306             :     EXC_NUMFMT_STRING(  33, "[$-0804]h" UTF8_CS_HOUR "mm" UTF8_CJ_MIN "ss" UTF8_CJ_SEC ),
    1307             :     EXC_NUMFMT_STRING(  34, "[$-0804]AM/PMh" UTF8_CS_HOUR "mm" UTF8_CJ_MIN ),
    1308             :     EXC_NUMFMT_STRING(  35, "[$-0804]AM/PMh" UTF8_CS_HOUR "mm" UTF8_CJ_MIN "ss" UTF8_CJ_SEC ),
    1309             :     EXC_NUMFMT_REUSE(   52, 27 ),
    1310             :     EXC_NUMFMT_REUSE(   53, 28 ),
    1311             :     EXC_NUMFMT_STRING(  63, UTF8_YEN_CS "#,##0;-" UTF8_YEN_CS "#,##0" ),
    1312             :     EXC_NUMFMT_STRING(  64, UTF8_YEN_CS "#,##0;[RED]-" UTF8_YEN_CS "#,##0" ),
    1313             :     EXC_NUMFMT_STRING(  65, UTF8_YEN_CS "#,##0.00;-" UTF8_YEN_CS "#,##0.00" ),
    1314             :     EXC_NUMFMT_STRING(  66, UTF8_YEN_CS "#,##0.00;[RED]-" UTF8_YEN_CS "#,##0.00" ),
    1315             :     EXC_NUMFMT_ENDTABLE()
    1316             : };
    1317             : 
    1318             : static const XclBuiltInFormat spBuiltInFormats_CHINESE_TRADITIONAL[] =
    1319             : {
    1320             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
    1321             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
    1322             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1323             :     EXC_NUMFMT_STRING(  18, "hh:mm AM/PM" ),
    1324             :     EXC_NUMFMT_STRING(  19, "hh:mm:ss AM/PM" ),
    1325             :     EXC_NUMFMT_OFFSET(  20, NF_TIME_HHMM ),
    1326             :     EXC_NUMFMT_OFFSET(  21, NF_TIME_HHMMSS ),
    1327             :     EXC_NUMFMT_STRING(  22, "YYYY/M/D hh:mm" ),
    1328             :     EXC_NUMFMT_STRING(  23, "US$#,##0_);(US$#,##0)" ),
    1329             :     EXC_NUMFMT_STRING(  24, "US$#,##0_);[RED](US$#,##0)" ),
    1330             :     EXC_NUMFMT_STRING(  25, "US$#,##0.00_);(US$#,##0.00)" ),
    1331             :     EXC_NUMFMT_STRING(  26, "US$#,##0.00_);[RED](US$#,##0.00)" ),
    1332             :     EXC_NUMFMT_STRING(  27, "[$-0404]E/M/D" ),
    1333             :     EXC_NUMFMT_STRING(  28, "[$-0404]E" UTF8_CJ_YEAR "M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1334             :     EXC_NUMFMT_STRING(  30, "[$-0404]M/D/YY" ),
    1335             :     EXC_NUMFMT_STRING(  31, "[$-0404]YYYY" UTF8_CJ_YEAR "M" UTF8_CJ_MON "D" UTF8_CJ_DAY ),
    1336             :     EXC_NUMFMT_STRING(  32, "[$-0404]hh" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN ),
    1337             :     EXC_NUMFMT_STRING(  33, "[$-0404]hh" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN "ss" UTF8_CJ_SEC ),
    1338             :     EXC_NUMFMT_STRING(  34, "[$-0404]AM/PMhh" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN ),
    1339             :     EXC_NUMFMT_STRING(  35, "[$-0404]AM/PMhh" UTF8_CJ_HOUR "mm" UTF8_CJ_MIN "ss" UTF8_CJ_SEC ),
    1340             :     EXC_NUMFMT_STRING(  63, "$#,##0;-$#,##0" ),
    1341             :     EXC_NUMFMT_STRING(  64, "$#,##0;[RED]-$#,##0" ),
    1342             :     EXC_NUMFMT_STRING(  65, "$#,##0.00;-$#,##0.00" ),
    1343             :     EXC_NUMFMT_STRING(  66, "$#,##0.00;[RED]-$#,##0.00" ),
    1344             :     EXC_NUMFMT_ENDTABLE()
    1345             : };
    1346             : 
    1347             : // OTHER ----------------------------------------------------------------------
    1348             : 
    1349             : static const XclBuiltInFormat spBuiltInFormats_HEBREW[] =
    1350             : {
    1351             :     EXC_NUMFMT_STRING(  15, "DD-MMMM-YY" ),
    1352             :     EXC_NUMFMT_STRING(  16, "DD-MMMM" ),
    1353             :     EXC_NUMFMT_STRING(  17, "MMMM-YY" ),
    1354             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1355             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1356             :     EXC_NUMFMT_STRING(  63, UTF8_SHEQEL " #,##0;" UTF8_SHEQEL " -#,##0" ),
    1357             :     EXC_NUMFMT_STRING(  64, UTF8_SHEQEL " #,##0;[RED]" UTF8_SHEQEL " -#,##0" ),
    1358             :     EXC_NUMFMT_STRING(  65, UTF8_SHEQEL " #,##0.00;" UTF8_SHEQEL " -#,##0.00" ),
    1359             :     EXC_NUMFMT_STRING(  66, UTF8_SHEQEL " #,##0.00;[RED]" UTF8_SHEQEL " -#,##0.00" ),
    1360             :     EXC_NUMFMT_ENDTABLE()
    1361             : };
    1362             : 
    1363             : static const XclBuiltInFormat spBuiltInFormats_THAI[] =
    1364             : {
    1365             :     EXC_NUMFMT_STRING(  14, "D/M/YYYY" ),
    1366             :     EXC_NUMFMT_STRING(  15, "D-MMM-YY" ),
    1367             :     EXC_NUMFMT_STRING(  16, "D-MMM" ),
    1368             :     EXC_NUMFMT_STRING(  17, "MMM-YY" ),
    1369             :     EXC_NUMFMT_STRING(  18, "h:mm AM/PM" ),
    1370             :     EXC_NUMFMT_STRING(  19, "h:mm:ss AM/PM" ),
    1371             :     EXC_NUMFMT_STRING(  22, "D/M/YYYY h:mm" ),
    1372             :     EXC_NUMFMT_STRING(  59, "t0" ),
    1373             :     EXC_NUMFMT_STRING(  60, "t0.00" ),
    1374             :     EXC_NUMFMT_STRING(  61, "t#,##0" ),
    1375             :     EXC_NUMFMT_STRING(  62, "t#,##0.00" ),
    1376             :     EXC_NUMFMT_STRING(  63, "t" UTF8_BAHT "#,##0_);t(" UTF8_BAHT "#,##0)" ),
    1377             :     EXC_NUMFMT_STRING(  64, "t" UTF8_BAHT "#,##0_);[RED]t(" UTF8_BAHT "#,##0)" ),
    1378             :     EXC_NUMFMT_STRING(  65, "t" UTF8_BAHT "#,##0.00_);t(" UTF8_BAHT "#,##0.00)" ),
    1379             :     EXC_NUMFMT_STRING(  66, "t" UTF8_BAHT "#,##0.00_);[RED]t(" UTF8_BAHT "#,##0.00)" ),
    1380             :     EXC_NUMFMT_STRING(  67, "t0%" ),
    1381             :     EXC_NUMFMT_STRING(  68, "t0.00%" ),
    1382             :     EXC_NUMFMT_STRING(  69, "t# ?/?" ),
    1383             :     EXC_NUMFMT_STRING(  70, "t# ?\?/?\?" ),
    1384             :     EXC_NUMFMT_STRING(  71, "tD/M/EE" ),
    1385             :     EXC_NUMFMT_STRING(  72, "tD-MMM-E" ),
    1386             :     EXC_NUMFMT_STRING(  73, "tD-MMM" ),
    1387             :     EXC_NUMFMT_STRING(  74, "tMMM-E" ),
    1388             :     EXC_NUMFMT_STRING(  75, "th:mm" ),
    1389             :     EXC_NUMFMT_STRING(  76, "th:mm:ss" ),
    1390             :     EXC_NUMFMT_STRING(  77, "tD/M/EE h:mm" ),
    1391             :     EXC_NUMFMT_STRING(  78, "tmm:ss" ),
    1392             :     EXC_NUMFMT_STRING(  79, "t[h]:mm:ss" ),
    1393             :     EXC_NUMFMT_STRING(  80, "tmm:ss.0" ),
    1394             :     EXC_NUMFMT_STRING(  81, "D/M/E" ),
    1395             :     EXC_NUMFMT_ENDTABLE()
    1396             : };
    1397             : 
    1398             : // ----------------------------------------------------------------------------
    1399             : 
    1400             : #undef EXC_NUMFMT_ENDTABLE
    1401             : #undef EXC_NUMFMT_REUSE
    1402             : #undef EXC_NUMFMT_OFFSET
    1403             : #undef EXC_NUMFMT_STRING
    1404             : 
    1405             : // ----------------------------------------------------------------------------
    1406             : 
    1407             : /** Specifies a number format table for a specific langauge. */
    1408             : struct XclBuiltInFormatTable
    1409             : {
    1410             :     LanguageType        meLanguage;         /// The language of this table.
    1411             :     LanguageType        meParentLang;       /// The language of the parent table.
    1412             :     const XclBuiltInFormat* mpFormats;      /// The number format table.
    1413             : };
    1414             : 
    1415             : static const XclBuiltInFormatTable spBuiltInFormatTables[] =
    1416             : {   //  language                        parent language             format table
    1417             :     {   LANGUAGE_DONTKNOW,              LANGUAGE_NONE,              spBuiltInFormats_DONTKNOW               },
    1418             : 
    1419             :     {   LANGUAGE_ENGLISH,               LANGUAGE_DONTKNOW,          spBuiltInFormats_ENGLISH                },
    1420             :     {   LANGUAGE_ENGLISH_UK,            LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_UK             },
    1421             :     {   LANGUAGE_ENGLISH_EIRE,          LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_EIRE           },
    1422             :     {   LANGUAGE_ENGLISH_US,            LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_US             },
    1423             :     {   LANGUAGE_ENGLISH_CAN,           LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_CAN            },
    1424             :     {   LANGUAGE_ENGLISH_AUS,           LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_AUS            },
    1425             :     {   LANGUAGE_ENGLISH_SAFRICA,       LANGUAGE_ENGLISH,           spBuiltInFormats_ENGLISH_SAFRICA        },
    1426             :     {   LANGUAGE_ENGLISH_NZ,            LANGUAGE_ENGLISH_AUS,       0                                       },
    1427             : 
    1428             :     {   PRV_LANGUAGE_FRENCH_PRIM,       LANGUAGE_DONTKNOW,          spBuiltInFormats_FRENCH                 },
    1429             :     {   LANGUAGE_FRENCH,                PRV_LANGUAGE_FRENCH_PRIM,   spBuiltInFormats_FRENCH_FRANCE          },
    1430             :     {   LANGUAGE_FRENCH_CANADIAN,       PRV_LANGUAGE_FRENCH_PRIM,   spBuiltInFormats_FRENCH_CANADIAN        },
    1431             :     {   LANGUAGE_FRENCH_SWISS,          PRV_LANGUAGE_FRENCH_PRIM,   spBuiltInFormats_FRENCH_SWISS           },
    1432             :     {   LANGUAGE_FRENCH_BELGIAN,        LANGUAGE_FRENCH,            spBuiltInFormats_FRENCH_BELGIAN         },
    1433             :     {   LANGUAGE_FRENCH_LUXEMBOURG,     LANGUAGE_FRENCH,            0                                       },
    1434             :     {   LANGUAGE_FRENCH_MONACO,         LANGUAGE_FRENCH,            0                                       },
    1435             : 
    1436             :     {   PRV_LANGUAGE_GERMAN_PRIM,       LANGUAGE_DONTKNOW,          spBuiltInFormats_GERMAN                 },
    1437             :     {   LANGUAGE_GERMAN,                PRV_LANGUAGE_GERMAN_PRIM,   spBuiltInFormats_GERMAN_GERMANY         },
    1438             :     {   LANGUAGE_GERMAN_AUSTRIAN,       PRV_LANGUAGE_GERMAN_PRIM,   spBuiltInFormats_GERMAN_AUSTRIAN        },
    1439             :     {   LANGUAGE_GERMAN_SWISS,          PRV_LANGUAGE_GERMAN_PRIM,   spBuiltInFormats_GERMAN_SWISS           },
    1440             :     {   LANGUAGE_GERMAN_LUXEMBOURG,     PRV_LANGUAGE_GERMAN_PRIM,   spBuiltInFormats_GERMAN_LUXEMBOURG      },
    1441             :     {   LANGUAGE_GERMAN_LIECHTENSTEIN,  PRV_LANGUAGE_GERMAN_PRIM,   spBuiltInFormats_GERMAN_LIECHTENSTEIN   },
    1442             : 
    1443             :     {   LANGUAGE_ITALIAN,               LANGUAGE_DONTKNOW,          spBuiltInFormats_ITALIAN_ITALY          },
    1444             :     {   LANGUAGE_ITALIAN_SWISS,         LANGUAGE_DONTKNOW,          spBuiltInFormats_ITALIAN_SWISS          },
    1445             : 
    1446             :     {   LANGUAGE_SWEDISH,               LANGUAGE_DONTKNOW,          spBuiltInFormats_SWEDISH_SWEDEN         },
    1447             :     {   LANGUAGE_SWEDISH_FINLAND,       LANGUAGE_DONTKNOW,          spBuiltInFormats_SWEDISH_FINLAND        },
    1448             : 
    1449             :     {   PRV_LANGUAGE_ASIAN_PRIM,        LANGUAGE_DONTKNOW,          spBuiltInFormats_ASIAN                  },
    1450             :     {   LANGUAGE_JAPANESE,              PRV_LANGUAGE_ASIAN_PRIM,    spBuiltInFormats_JAPANESE               },
    1451             :     {   LANGUAGE_KOREAN,                PRV_LANGUAGE_ASIAN_PRIM,    spBuiltInFormats_KOREAN                 },
    1452             :     {   LANGUAGE_CHINESE_SIMPLIFIED,    PRV_LANGUAGE_ASIAN_PRIM,    spBuiltInFormats_CHINESE_SIMPLIFIED     },
    1453             :     {   LANGUAGE_CHINESE_TRADITIONAL,   PRV_LANGUAGE_ASIAN_PRIM,    spBuiltInFormats_CHINESE_TRADITIONAL    },
    1454             : 
    1455             :     {   LANGUAGE_HEBREW,                LANGUAGE_DONTKNOW,          spBuiltInFormats_HEBREW                 },
    1456             :     {   LANGUAGE_THAI,                  LANGUAGE_DONTKNOW,          spBuiltInFormats_THAI                   }
    1457             : };
    1458             : 
    1459             : // ----------------------------------------------------------------------------
    1460             : 
    1461             : } // namespace
    1462             : 
    1463             : // ============================================================================
    1464             : 
    1465          20 : XclNumFmtBuffer::XclNumFmtBuffer( const XclRoot& rRoot ) :
    1466          20 :     meSysLang( rRoot.GetSysLanguage() ),
    1467          40 :     mnStdScNumFmt( rRoot.GetFormatter().GetStandardFormat( ScGlobal::eLnge ) )
    1468             : {
    1469             :     // *** insert default formats (BIFF5+ only)***
    1470             : 
    1471          20 :     if( rRoot.GetBiff() >= EXC_BIFF5 )
    1472          20 :         InsertBuiltinFormats();
    1473          20 : }
    1474             : 
    1475           0 : void XclNumFmtBuffer::InitializeImport()
    1476             : {
    1477           0 :     maFmtMap.clear();
    1478           0 : }
    1479             : 
    1480         174 : void XclNumFmtBuffer::InsertFormat( sal_uInt16 nXclNumFmt, const String& rFormat )
    1481             : {
    1482         174 :     XclNumFmt& rNumFmt = maFmtMap[ nXclNumFmt ];
    1483         174 :     rNumFmt.maFormat = rFormat;
    1484             :     // #i62053# rFormat may be an empty string, meOffset must be initialized
    1485         174 :     rNumFmt.meOffset = NF_NUMBER_STANDARD;
    1486         174 :     rNumFmt.meLanguage = LANGUAGE_SYSTEM;
    1487         174 : }
    1488             : 
    1489          20 : void XclNumFmtBuffer::InsertBuiltinFormats()
    1490             : {
    1491             :     // build a map containing tables for all languages
    1492             :     typedef ::std::map< LanguageType, const XclBuiltInFormatTable* > XclBuiltInMap;
    1493          20 :     XclBuiltInMap aBuiltInMap;
    1494         680 :     for( const XclBuiltInFormatTable* pTable = spBuiltInFormatTables;
    1495             :             pTable != STATIC_ARRAY_END( spBuiltInFormatTables ); ++pTable )
    1496         660 :         aBuiltInMap[ pTable->meLanguage ] = pTable;
    1497             : 
    1498             :     // build a list of table pointers for the current language, with all parent tables
    1499             :     typedef ::std::vector< const XclBuiltInFormatTable* > XclBuiltInVec;
    1500          20 :     XclBuiltInVec aBuiltInVec;
    1501          80 :     for( XclBuiltInMap::const_iterator aMIt = aBuiltInMap.find( meSysLang ), aMEnd = aBuiltInMap.end();
    1502          60 :             aMIt != aMEnd; aMIt = aBuiltInMap.find( aMIt->second->meParentLang ) )
    1503          60 :         aBuiltInVec.push_back( aMIt->second );
    1504             :     // language not supported
    1505          20 :     if( aBuiltInVec.empty() )
    1506             :     {
    1507             :         OSL_TRACE( "XclNumFmtBuffer::InsertBuiltinFormats - language 0x%04hX not supported (#i29949#)", meSysLang );
    1508           0 :         XclBuiltInMap::const_iterator aMIt = aBuiltInMap.find( LANGUAGE_DONTKNOW );
    1509             :         OSL_ENSURE( aMIt != aBuiltInMap.end(), "XclNumFmtBuffer::InsertBuiltinFormats - default map not found" );
    1510           0 :         if( aMIt != aBuiltInMap.end() )
    1511           0 :             aBuiltInVec.push_back( aMIt->second );
    1512             :     }
    1513             : 
    1514             :     // insert the default formats in the format map, from root parent to system language
    1515             :     typedef ::std::map< sal_uInt16, sal_uInt16 > XclReuseMap;
    1516          20 :     XclReuseMap aReuseMap;
    1517          80 :     for( XclBuiltInVec::reverse_iterator aVIt = aBuiltInVec.rbegin(), aVEnd = aBuiltInVec.rend(); aVIt != aVEnd; ++aVIt )
    1518             :     {
    1519             :         // put LANGUAGE_SYSTEM for all entries in default table
    1520          60 :         LanguageType eLang = ((*aVIt)->meLanguage == LANGUAGE_DONTKNOW) ? LANGUAGE_SYSTEM : meSysLang;
    1521        1860 :         for( const XclBuiltInFormat* pBuiltIn = (*aVIt)->mpFormats; pBuiltIn && (pBuiltIn->mnXclNumFmt != EXC_FORMAT_NOTFOUND); ++pBuiltIn )
    1522             :         {
    1523        1800 :             XclNumFmt& rNumFmt = maFmtMap[ pBuiltIn->mnXclNumFmt ];
    1524             : 
    1525        1800 :             rNumFmt.meOffset = pBuiltIn->meOffset;
    1526        1800 :             rNumFmt.meLanguage = eLang;
    1527             : 
    1528        1800 :             if( pBuiltIn->mpFormat )
    1529         560 :                 rNumFmt.maFormat = String( pBuiltIn->mpFormat, RTL_TEXTENCODING_UTF8 );
    1530             :             else
    1531        1240 :                 rNumFmt.maFormat = EMPTY_STRING;
    1532             : 
    1533        1800 :             if( pBuiltIn->meOffset == PRV_NF_INDEX_REUSE )
    1534         840 :                 aReuseMap[ pBuiltIn->mnXclNumFmt ] = pBuiltIn->mnXclReuseFmt;
    1535             :             else
    1536         960 :                 aReuseMap.erase( pBuiltIn->mnXclNumFmt );
    1537             :         }
    1538             :     }
    1539             : 
    1540             :     // copy reused number formats
    1541         860 :     for( XclReuseMap::const_iterator aRIt = aReuseMap.begin(), aREnd = aReuseMap.end(); aRIt != aREnd; ++aRIt )
    1542         860 :         maFmtMap[ aRIt->first ] = maFmtMap[ aRIt->second ];
    1543          20 : }
    1544             : 
    1545             : // Cell formatting data (XF) ==================================================
    1546             : 
    1547        1740 : XclCellProt::XclCellProt() :
    1548             :     mbLocked( true ),       // default in Excel and Calc
    1549        1740 :     mbHidden( false )
    1550             : {
    1551        1740 : }
    1552             : 
    1553        1033 : bool operator==( const XclCellProt& rLeft, const XclCellProt& rRight )
    1554             : {
    1555        1033 :     return (rLeft.mbLocked == rRight.mbLocked) && (rLeft.mbHidden == rRight.mbHidden);
    1556             : }
    1557             : 
    1558             : // ----------------------------------------------------------------------------
    1559             : 
    1560        1740 : XclCellAlign::XclCellAlign() :
    1561             :     mnHorAlign( EXC_XF_HOR_GENERAL ),
    1562             :     mnVerAlign( EXC_XF_VER_BOTTOM ),
    1563             :     mnOrient( EXC_ORIENT_NONE ),
    1564             :     mnTextDir( EXC_XF_TEXTDIR_CONTEXT ),
    1565             :     mnRotation( EXC_ROT_NONE ),
    1566             :     mnIndent( 0 ),
    1567             :     mbLineBreak( false ),
    1568        1740 :     mbShrink( false )
    1569             : {
    1570        1740 : }
    1571             : 
    1572         767 : SvxCellHorJustify XclCellAlign::GetScHorAlign() const
    1573             : {
    1574         767 :     SvxCellHorJustify eHorJust = SVX_HOR_JUSTIFY_STANDARD;
    1575         767 :     switch( mnHorAlign )
    1576             :     {
    1577          84 :         case EXC_XF_HOR_GENERAL:    eHorJust = SVX_HOR_JUSTIFY_STANDARD;    break;
    1578          32 :         case EXC_XF_HOR_LEFT:       eHorJust = SVX_HOR_JUSTIFY_LEFT;        break;
    1579             :         case EXC_XF_HOR_CENTER_AS:
    1580         645 :         case EXC_XF_HOR_CENTER:     eHorJust = SVX_HOR_JUSTIFY_CENTER;      break;
    1581           5 :         case EXC_XF_HOR_RIGHT:      eHorJust = SVX_HOR_JUSTIFY_RIGHT;       break;
    1582           0 :         case EXC_XF_HOR_FILL:       eHorJust = SVX_HOR_JUSTIFY_REPEAT;      break;
    1583             :         case EXC_XF_HOR_JUSTIFY:
    1584           1 :         case EXC_XF_HOR_DISTRIB:    eHorJust = SVX_HOR_JUSTIFY_BLOCK;       break;
    1585             :         default:    OSL_FAIL( "XclCellAlign::GetScHorAlign - unknown horizontal alignment" );
    1586             :     }
    1587         767 :     return eHorJust;
    1588             : }
    1589             : 
    1590         767 : SvxCellJustifyMethod XclCellAlign::GetScHorJustifyMethod() const
    1591             : {
    1592         767 :     return (mnHorAlign == EXC_XF_HOR_DISTRIB) ? SVX_JUSTIFY_METHOD_DISTRIBUTE : SVX_JUSTIFY_METHOD_AUTO;
    1593             : }
    1594             : 
    1595         767 : SvxCellVerJustify XclCellAlign::GetScVerAlign() const
    1596             : {
    1597         767 :     SvxCellVerJustify eVerJust = SVX_VER_JUSTIFY_STANDARD;
    1598         767 :     switch( mnVerAlign )
    1599             :     {
    1600           9 :         case EXC_XF_VER_TOP:        eVerJust = SVX_VER_JUSTIFY_TOP;         break;
    1601          99 :         case EXC_XF_VER_CENTER:     eVerJust = SVX_VER_JUSTIFY_CENTER;      break;
    1602         659 :         case EXC_XF_VER_BOTTOM:     eVerJust = SVX_VER_JUSTIFY_STANDARD;    break;
    1603             :         case EXC_XF_VER_JUSTIFY:
    1604           0 :         case EXC_XF_VER_DISTRIB:    eVerJust = SVX_VER_JUSTIFY_BLOCK;       break;
    1605             :         default:    OSL_FAIL( "XclCellAlign::GetScVerAlign - unknown vertical alignment" );
    1606             :     }
    1607         767 :     return eVerJust;
    1608             : }
    1609             : 
    1610         767 : SvxCellJustifyMethod XclCellAlign::GetScVerJustifyMethod() const
    1611             : {
    1612         767 :     return (mnVerAlign == EXC_XF_VER_DISTRIB) ? SVX_JUSTIFY_METHOD_DISTRIBUTE : SVX_JUSTIFY_METHOD_AUTO;
    1613             : }
    1614             : 
    1615         767 : SvxFrameDirection XclCellAlign::GetScFrameDir() const
    1616             : {
    1617         767 :     SvxFrameDirection eFrameDir = FRMDIR_ENVIRONMENT;
    1618         767 :     switch( mnTextDir )
    1619             :     {
    1620         767 :         case EXC_XF_TEXTDIR_CONTEXT:    eFrameDir = FRMDIR_ENVIRONMENT;     break;
    1621           0 :         case EXC_XF_TEXTDIR_LTR:        eFrameDir = FRMDIR_HORI_LEFT_TOP;   break;
    1622           0 :         case EXC_XF_TEXTDIR_RTL:        eFrameDir = FRMDIR_HORI_RIGHT_TOP;  break;
    1623             :         default:    OSL_FAIL( "XclCellAlign::GetScFrameDir - unknown CTL text direction" );
    1624             :     }
    1625         767 :     return eFrameDir;
    1626             : }
    1627             : 
    1628          18 : void XclCellAlign::SetScHorAlign( SvxCellHorJustify eHorJust )
    1629             : {
    1630          18 :     switch( eHorJust )
    1631             :     {
    1632          18 :         case SVX_HOR_JUSTIFY_STANDARD:  mnHorAlign = EXC_XF_HOR_GENERAL;    break;
    1633           0 :         case SVX_HOR_JUSTIFY_LEFT:      mnHorAlign = EXC_XF_HOR_LEFT;       break;
    1634           0 :         case SVX_HOR_JUSTIFY_CENTER:    mnHorAlign = EXC_XF_HOR_CENTER;     break;
    1635           0 :         case SVX_HOR_JUSTIFY_RIGHT:     mnHorAlign = EXC_XF_HOR_RIGHT;      break;
    1636           0 :         case SVX_HOR_JUSTIFY_BLOCK:     mnHorAlign = EXC_XF_HOR_JUSTIFY;    break;
    1637           0 :         case SVX_HOR_JUSTIFY_REPEAT:    mnHorAlign = EXC_XF_HOR_FILL;       break;
    1638           0 :         default:                        mnHorAlign = EXC_XF_HOR_GENERAL;
    1639             :             OSL_FAIL( "XclCellAlign::SetScHorAlign - unknown horizontal alignment" );
    1640             :     }
    1641          18 : }
    1642             : 
    1643          18 : void XclCellAlign::SetScVerAlign( SvxCellVerJustify eVerJust )
    1644             : {
    1645          18 :     switch( eVerJust )
    1646             :     {
    1647           0 :         case SVX_VER_JUSTIFY_STANDARD:  mnVerAlign = EXC_XF_VER_BOTTOM; break;
    1648           0 :         case SVX_VER_JUSTIFY_TOP:       mnVerAlign = EXC_XF_VER_TOP;    break;
    1649           0 :         case SVX_VER_JUSTIFY_CENTER:    mnVerAlign = EXC_XF_VER_CENTER; break;
    1650          18 :         case SVX_VER_JUSTIFY_BOTTOM:    mnVerAlign = EXC_XF_VER_BOTTOM; break;
    1651           0 :         default:                        mnVerAlign = EXC_XF_VER_BOTTOM;
    1652             :             OSL_FAIL( "XclCellAlign::SetScVerAlign - unknown vertical alignment" );
    1653             :     }
    1654          18 : }
    1655             : 
    1656          18 : void XclCellAlign::SetScFrameDir( SvxFrameDirection eFrameDir )
    1657             : {
    1658          18 :     switch( eFrameDir )
    1659             :     {
    1660          18 :         case FRMDIR_ENVIRONMENT:    mnTextDir = EXC_XF_TEXTDIR_CONTEXT; break;
    1661           0 :         case FRMDIR_HORI_LEFT_TOP:  mnTextDir = EXC_XF_TEXTDIR_LTR;     break;
    1662           0 :         case FRMDIR_HORI_RIGHT_TOP: mnTextDir = EXC_XF_TEXTDIR_RTL;     break;
    1663           0 :         default:                    mnTextDir = EXC_XF_TEXTDIR_CONTEXT;
    1664             :             OSL_FAIL( "XclCellAlign::SetScFrameDir - unknown CTL text direction" );
    1665             :     }
    1666          18 : }
    1667             : 
    1668         310 : bool operator==( const XclCellAlign& rLeft, const XclCellAlign& rRight )
    1669             : {
    1670             :     return
    1671             :         (rLeft.mnHorAlign  == rRight.mnHorAlign)  && (rLeft.mnVerAlign == rRight.mnVerAlign) &&
    1672             :         (rLeft.mnTextDir   == rRight.mnTextDir)   && (rLeft.mnOrient   == rRight.mnOrient)   &&
    1673             :         (rLeft.mnRotation  == rRight.mnRotation)  && (rLeft.mnIndent   == rRight.mnIndent)   &&
    1674         310 :         (rLeft.mbLineBreak == rRight.mbLineBreak) && (rLeft.mbShrink   == rRight.mbShrink);
    1675             : }
    1676             : 
    1677             : // ----------------------------------------------------------------------------
    1678             : 
    1679        1748 : XclCellBorder::XclCellBorder() :
    1680             :     mnLeftColor( 0 ),
    1681             :     mnRightColor( 0 ),
    1682             :     mnTopColor( 0 ),
    1683             :     mnBottomColor( 0 ),
    1684             :     mnDiagColor( 0 ),
    1685             :     mnLeftLine( EXC_LINE_NONE ),
    1686             :     mnRightLine( EXC_LINE_NONE ),
    1687             :     mnTopLine( EXC_LINE_NONE ),
    1688             :     mnBottomLine( EXC_LINE_NONE ),
    1689             :     mnDiagLine( EXC_LINE_NONE ),
    1690             :     mbDiagTLtoBR( false ),
    1691        1748 :     mbDiagBLtoTR( false )
    1692             : {
    1693        1748 : }
    1694             : 
    1695         152 : bool operator==( const XclCellBorder& rLeft, const XclCellBorder& rRight )
    1696             : {
    1697             :     return
    1698             :         (rLeft.mnLeftColor  == rRight.mnLeftColor)  && (rLeft.mnRightColor  == rRight.mnRightColor)  &&
    1699             :         (rLeft.mnTopColor   == rRight.mnTopColor)   && (rLeft.mnBottomColor == rRight.mnBottomColor) &&
    1700             :         (rLeft.mnLeftLine   == rRight.mnLeftLine)   && (rLeft.mnRightLine   == rRight.mnRightLine)   &&
    1701             :         (rLeft.mnTopLine    == rRight.mnTopLine)    && (rLeft.mnBottomLine  == rRight.mnBottomLine)  &&
    1702             :         (rLeft.mnDiagColor  == rRight.mnDiagColor)  && (rLeft.mnDiagLine    == rRight.mnDiagLine)    &&
    1703         152 :         (rLeft.mbDiagTLtoBR == rRight.mbDiagTLtoBR) && (rLeft.mbDiagBLtoTR  == rRight.mbDiagBLtoTR);
    1704             : }
    1705             : 
    1706             : // ----------------------------------------------------------------------------
    1707             : 
    1708        1742 : XclCellArea::XclCellArea() :
    1709             :     mnForeColor( EXC_COLOR_WINDOWTEXT ),
    1710             :     mnBackColor( EXC_COLOR_WINDOWBACK ),
    1711        1742 :     mnPattern( EXC_PATT_NONE )
    1712             : {
    1713        1742 : }
    1714             : 
    1715           0 : bool XclCellArea::IsTransparent() const
    1716             : {
    1717           0 :     return (mnPattern == EXC_PATT_NONE) && (mnBackColor == EXC_COLOR_WINDOWBACK);
    1718             : }
    1719             : 
    1720         155 : bool operator==( const XclCellArea& rLeft, const XclCellArea& rRight )
    1721             : {
    1722             :     return
    1723             :         (rLeft.mnForeColor == rRight.mnForeColor) && (rLeft.mnBackColor == rRight.mnBackColor) &&
    1724         155 :         (rLeft.mnPattern == rRight.mnPattern);
    1725             : }
    1726             : 
    1727             : // ----------------------------------------------------------------------------
    1728             : 
    1729        1732 : XclXFBase::XclXFBase( bool bCellXF ) :
    1730             :     mnParent( bCellXF ? EXC_XF_DEFAULTSTYLE : EXC_XF_STYLEPARENT ),
    1731        1732 :     mbCellXF( bCellXF )
    1732             : {
    1733        1732 :     SetAllUsedFlags( false );
    1734        1732 : }
    1735             : 
    1736        1751 : XclXFBase::~XclXFBase()
    1737             : {
    1738        1751 : }
    1739             : 
    1740        1749 : void XclXFBase::SetAllUsedFlags( bool bUsed )
    1741             : {
    1742        1749 :     mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = bUsed;
    1743        1749 : }
    1744             : 
    1745           0 : bool XclXFBase::HasUsedFlags() const
    1746             : {
    1747           0 :     return mbProtUsed || mbFontUsed || mbFmtUsed || mbAlignUsed || mbBorderUsed || mbAreaUsed;
    1748             : }
    1749             : 
    1750           8 : bool XclXFBase::Equals( const XclXFBase& rCmp ) const
    1751             : {
    1752             :     return
    1753             :         (mbCellXF     == rCmp.mbCellXF)     && (mnParent    == rCmp.mnParent)    &&
    1754             :         (mbProtUsed   == rCmp.mbProtUsed)   && (mbFontUsed  == rCmp.mbFontUsed)  &&
    1755             :         (mbFmtUsed    == rCmp.mbFmtUsed)    && (mbAlignUsed == rCmp.mbAlignUsed) &&
    1756           8 :         (mbBorderUsed == rCmp.mbBorderUsed) && (mbAreaUsed  == rCmp.mbAreaUsed);
    1757             : }
    1758             : 
    1759             : // ============================================================================
    1760             : 
    1761             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10