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

Generated by: LCOV version 1.10