sc/source/filter/excel/xistyle.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xistyle.cxx,v $
  10  * $Revision: 1.38.14.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33 #include "xistyle.hxx"
  34 #include <sfx2/printer.hxx>
  35 #include <sfx2/objsh.hxx>
  36 #include <svtools/ctrltool.hxx>
  37 #include <svx/editobj.hxx>
  38 #include "scitems.hxx"
  39 #include <svx/fontitem.hxx>
  40 #include <svx/fhgtitem.hxx>
  41 #include <svx/wghtitem.hxx>
  42 #include <svx/udlnitem.hxx>
  43 #include <svx/postitem.hxx>
  44 #include <svx/crsditem.hxx>
  45 #include <svx/cntritem.hxx>
  46 #include <svx/shdditem.hxx>
  47 #include <svx/escpitem.hxx>
  48 #include <svx/algitem.hxx>
  49 #include <svx/boxitem.hxx>
  50 #include <svx/bolnitem.hxx>
  51 #include <svx/rotmodit.hxx>
  52 #include <svx/colritem.hxx>
  53 #include <svx/brshitem.hxx>
  54 #include <svx/frmdiritem.hxx>
  55 #include <svx/eeitem.hxx>
  56 #include <svx/flstitem.hxx>
  57 #include "document.hxx"
  58 #include "docpool.hxx"
  59 #include "attrib.hxx"
  60 #include "stlpool.hxx"
  61 #include "stlsheet.hxx"
  62 #include "cell.hxx"
  63 #include "globstr.hrc"
  64 #include "xltracer.hxx"
  65 #include "xistream.hxx"
  66 #include "xicontent.hxx"
  67
  68 #include "root.hxx"
  69 #include "colrowst.hxx"
  70
  71 #include <cppuhelper/implbase1.hxx>
  72 #include <com/sun/star/container/XIndexAccess.hpp>
  73 #include <com/sun/star/beans/XPropertySet.hpp>
  74 using namespace ::com::sun::star;
  75
  76 typedef ::cppu::WeakImplHelper1< container::XIndexAccess > XIndexAccess_BASE;
  77 typedef ::std::vector< ColorData > ColorDataVec;
  78
  79 class PaletteIndex : public XIndexAccess_BASE
  80 {
  81 public:
  82     PaletteIndex( const ColorDataVec& rColorDataTable ) : maColorData( rColorDataTable ) {}
  83
  84     // Methods XIndexAccess
  85     virtual ::sal_Int32 SAL_CALL getCount() throw (uno::RuntimeException)
  86     {
  87          return  maColorData.size();
  88     }
  89
  90     virtual uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
  91     {
  92         //--Index;  // apparently the palette is already 1 based
  93         return uno::makeAny( sal_Int32( maColorData[ Index ] ) );
  94     }
  95
  96     // Methods XElementAcess
  97     virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException)
  98     {
  99         return ::getCppuType( (sal_Int32*)0 );
 100     }
 101     virtual ::sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException)
 102     {
 103         return (maColorData.size() > 0);
 104     }
 105
 106 private:
 107     ColorDataVec        maColorData;
 108 };
 109
 110 void
 111 XclImpPalette::ExportPalette()
 112 {
 113     if( SfxObjectShell* pDocShell = mrRoot.GetDocShell() )
 114     {
 115         // copy values in color palette
 116         sal_Int16 nColors =  maColorTable.size();
 117         ColorDataVec aColors;
 118         aColors.resize( nColors );
 119         for( sal_uInt16 nIndex = 0; nIndex < nColors; ++nIndex )
 120             aColors[ nIndex ] = GetColorData( nIndex );
 121
 122         uno::Reference< beans::XPropertySet > xProps( pDocShell->GetModel(), uno::UNO_QUERY );
 123         if ( xProps.is() )
 124         {
 125             uno::Reference< container::XIndexAccess > xIndex( new PaletteIndex( aColors ) );
 126             xProps->setPropertyValue( CREATE_OUSTRING("ColorPalette"), uno::makeAny( xIndex ) );
 127         }
 128     }
 129
 130 }
 131 // PALETTE record - color information =========================================
 132
 133 XclImpPalette::XclImpPalette( const XclImpRoot& rRoot ) :
 134     XclDefaultPalette( rRoot ), mrRoot( rRoot )
 135 {
 136 }
 137
 138 void XclImpPalette::Initialize()
 139 {
 140     maColorTable.clear();
 141 }
 142
 143 ColorData XclImpPalette::GetColorData( sal_uInt16 nXclIndex ) const
 144 {
 145     if( nXclIndex >= EXC_COLOR_USEROFFSET )
 146     {
 147         sal_uInt32 nIx = nXclIndex - EXC_COLOR_USEROFFSET;
 148         if( nIx < maColorTable.size() )
 149             return maColorTable[ nIx ];
 150     }
 151     return GetDefColorData( nXclIndex );
 152 }
 153
 154 void XclImpPalette::ReadPalette( XclImpStream& rStrm )
 155 {
 156     sal_uInt16 nCount;
 157     rStrm >> nCount;
 158     DBG_ASSERT( rStrm.GetRecLeft() == static_cast< sal_Size >( 4 * nCount ),
 159         "XclImpPalette::ReadPalette - size mismatch" );
 160
 161     maColorTable.resize( nCount );
 162     Color aColor;
 163     for( sal_uInt16 nIndex = 0; nIndex < nCount; ++nIndex )
 164     {
 165         rStrm >> aColor;
 166         maColorTable[ nIndex ] = aColor.GetColor();
 167     }
 168     ExportPalette();
 169 }
 170
 171 // FONT record - font information =============================================
 172
 173 XclImpFont::XclImpFont( const XclImpRoot& rRoot ) :
 174     XclImpRoot( rRoot ),
 175     mbHasCharSet( false ),
 176     mbHasWstrn( true ),
 177     mbHasAsian( false ),
 178     mbHasCmplx( false )
 179 {
 180     SetAllUsedFlags( false );
 181 }
 182
 183 XclImpFont::XclImpFont( const XclImpRoot& rRoot, const XclFontData& rFontData ) :
 184     XclImpRoot( rRoot )
 185 {
 186     SetFontData( rFontData, false );
 187 }
 188
 189 void XclImpFont::SetAllUsedFlags( bool bUsed )
 190 {
 191     mbFontNameUsed = mbHeightUsed = mbColorUsed = mbWeightUsed = mbEscapemUsed =
 192         mbUnderlUsed = mbItalicUsed = mbStrikeUsed = mbOutlineUsed = mbShadowUsed = bUsed;
 193 }
 194
 195 void XclImpFont::SetFontData( const XclFontData& rFontData, bool bHasCharSet )
 196 {
 197     maData = rFontData;
 198     mbHasCharSet = bHasCharSet;
 199     if( maData.maStyle.Len() )
 200     {
 201         if( SfxObjectShell* pDocShell = GetDocShell() )
 202         {
 203             if( const SvxFontListItem* pInfoItem = static_cast< const SvxFontListItem* >(
 204                 pDocShell->GetItem( SID_ATTR_CHAR_FONTLIST ) ) )
 205             {
 206                 if( const FontList* pFontList = pInfoItem->GetFontList() )
 207                 {
 208                     FontInfo aFontInfo( pFontList->Get( maData.maName, maData.maStyle ) );
 209                     maData.SetScWeight( aFontInfo.GetWeight() );
 210                     maData.SetScPosture( aFontInfo.GetItalic() );
 211                 }
 212             }
 213         }
 214         maData.maStyle.Erase();
 215     }
 216     GuessScriptType();
 217     SetAllUsedFlags( true );
 218 }
 219
 220 rtl_TextEncoding XclImpFont::GetFontEncoding() const
 221 {
 222     // #i63105# use text encoding from FONT record
 223     // #i67768# BIFF2-BIFF4 FONT records do not contain character set
 224     rtl_TextEncoding eFontEnc = mbHasCharSet ? maData.GetFontEncoding() : GetTextEncoding();
 225     return (eFontEnc == RTL_TEXTENCODING_DONTKNOW) ? GetTextEncoding() : eFontEnc;
 226 }
 227
 228 void XclImpFont::ReadFont( XclImpStream& rStrm )
 229 {
 230     switch( GetBiff() )
 231     {
 232         case EXC_BIFF2:
 233             ReadFontData2( rStrm );
 234             ReadFontName2( rStrm );
 235         break;
 236         case EXC_BIFF3:
 237         case EXC_BIFF4:
 238             ReadFontData2( rStrm );
 239             ReadFontColor( rStrm );
 240             ReadFontName2( rStrm );
 241         break;
 242         case EXC_BIFF5:
 243             ReadFontData5( rStrm );
 244             ReadFontName2( rStrm );
 245         break;
 246         case EXC_BIFF8:
 247             ReadFontData5( rStrm );
 248             ReadFontName8( rStrm );
 249         break;
 250         default:
 251             DBG_ERROR_BIFF();
 252             return;
 253     }
 254     GuessScriptType();
 255     SetAllUsedFlags( true );
 256 }
 257
 258 void XclImpFont::ReadEfont( XclImpStream& rStrm )
 259 {
 260     ReadFontColor( rStrm );
 261 }
 262
 263 void XclImpFont::ReadCFFontBlock( XclImpStream& rStrm )
 264 {
 265     DBG_ASSERT_BIFF( GetBiff() == EXC_BIFF8 );
 266     if( GetBiff() != EXC_BIFF8 )
 267         return;
 268
 269     sal_uInt32 nHeight, nStyle, nColor, nFontFlags1, nFontFlags2, nFontFlags3;
 270     sal_uInt16 nWeight, nEscapem;
 271     sal_uInt8 nUnderl;
 272
 273     rStrm.Ignore( 64 );
 274     rStrm >> nHeight >> nStyle >> nWeight >> nEscapem >> nUnderl;
 275     rStrm.Ignore( 3 );
 276     rStrm >> nColor;
 277     rStrm.Ignore( 4 );
 278     rStrm >> nFontFlags1 >> nFontFlags2 >> nFontFlags3;
 279     rStrm.Ignore( 18 );
 280
 281     if( (mbHeightUsed = (nHeight <= 0x7FFF)) == true )
 282         maData.mnHeight = static_cast< sal_uInt16 >( nHeight );
 283     if( (mbWeightUsed = !::get_flag( nFontFlags1, EXC_CF_FONT_STYLE ) && (nWeight < 0x7FFF)) == true )
 284         maData.mnWeight = static_cast< sal_uInt16 >( nWeight );
 285     if( (mbItalicUsed = !::get_flag( nFontFlags1, EXC_CF_FONT_STYLE )) == true )
 286         maData.mbItalic = ::get_flag( nStyle, EXC_CF_FONT_STYLE );
 287     if( (mbUnderlUsed = !::get_flag( nFontFlags3, EXC_CF_FONT_UNDERL ) && (nUnderl <= 0x7F)) == true )
 288         maData.mnUnderline = nUnderl;
 289     if( (mbColorUsed = (nColor <= 0x7FFF)) == true )
 290         maData.maColor = GetPalette().GetColor( static_cast< sal_uInt16 >( nColor ) );
 291     if( (mbStrikeUsed = !::get_flag( nFontFlags1, EXC_CF_FONT_STRIKEOUT )) == true )
 292         maData.mbStrikeout = ::get_flag( nStyle, EXC_CF_FONT_STRIKEOUT );
 293 }
 294
 295 void XclImpFont::FillToItemSet( SfxItemSet& rItemSet, XclFontItemType eType, bool bSkipPoolDefs ) const
 296 {
 297     // true = edit engine Which-IDs (EE_CHAR_*); false = Calc Which-IDs (ATTR_*)
 298     bool bEE = eType != EXC_FONTITEM_CELL;
 299
 300 // item = the item to put into the item set
 301 // sc_which = the Calc Which-ID of the item
 302 // ee_which = the edit engine Which-ID of the item
 303 #define PUTITEM( item, sc_which, ee_which ) \
 304     ScfTools::PutItem( rItemSet, item, (bEE ? (ee_which) : (sc_which)), bSkipPoolDefs )
 305
 306 // Font item
 307     // #i36997# do not set default Tahoma font from notes
 308     bool bDefNoteFont = (eType == EXC_FONTITEM_NOTE) && (maData.maName.EqualsIgnoreCaseAscii( "Tahoma" ));
 309     if( mbFontNameUsed && !bDefNoteFont )
 310     {
 311         rtl_TextEncoding eFontEnc = maData.GetFontEncoding();
 312         rtl_TextEncoding eTempTextEnc = (bEE && (eFontEnc == GetTextEncoding())) ?
 313             ScfTools::GetSystemTextEncoding() : eFontEnc;
 314
 315         SvxFontItem aFontItem( maData.GetScFamily( GetTextEncoding() ), maData.maName, EMPTY_STRING,
 316                 PITCH_DONTKNOW, eTempTextEnc, ATTR_FONT );
 317         // #91658# set only for valid script types
 318         if( mbHasWstrn )
 319             PUTITEM( aFontItem, ATTR_FONT,      EE_CHAR_FONTINFO );
 320         if( mbHasAsian )
 321             PUTITEM( aFontItem, ATTR_CJK_FONT,  EE_CHAR_FONTINFO_CJK );
 322         if( mbHasCmplx )
 323             PUTITEM( aFontItem, ATTR_CTL_FONT,  EE_CHAR_FONTINFO_CTL );
 324     }
 325
 326 // Font height (for all script types)
 327     if( mbHeightUsed )
 328     {
 329         sal_Int32 nHeight = maData.mnHeight;
 330         if( bEE && (eType != EXC_FONTITEM_HF) )     // do not convert header/footer height
 331             nHeight = (nHeight * 127 + 36) / EXC_POINTS_PER_INCH;   // #98527# 1 in == 72 pt
 332
 333         SvxFontHeightItem aHeightItem( nHeight, 100, ATTR_FONT_HEIGHT );
 334         PUTITEM( aHeightItem,   ATTR_FONT_HEIGHT,       EE_CHAR_FONTHEIGHT );
 335         PUTITEM( aHeightItem,   ATTR_CJK_FONT_HEIGHT,   EE_CHAR_FONTHEIGHT_CJK );
 336         PUTITEM( aHeightItem,   ATTR_CTL_FONT_HEIGHT,   EE_CHAR_FONTHEIGHT_CTL );
 337     }
 338
 339 // Font color - pass AUTO_COL to item
 340     if( mbColorUsed )
 341         PUTITEM( SvxColorItem( maData.maColor, ATTR_FONT_COLOR  ), ATTR_FONT_COLOR, EE_CHAR_COLOR );
 342
 343 // Font weight (for all script types)
 344     if( mbWeightUsed )
 345     {
 346         SvxWeightItem aWeightItem( maData.GetScWeight(), ATTR_FONT_WEIGHT );
 347         PUTITEM( aWeightItem,   ATTR_FONT_WEIGHT,       EE_CHAR_WEIGHT );
 348         PUTITEM( aWeightItem,   ATTR_CJK_FONT_WEIGHT,   EE_CHAR_WEIGHT_CJK );
 349         PUTITEM( aWeightItem,   ATTR_CTL_FONT_WEIGHT,   EE_CHAR_WEIGHT_CTL );
 350     }
 351
 352 // Font underline
 353     if( mbUnderlUsed )
 354     {
 355         SvxUnderlineItem aUnderlItem( maData.GetScUnderline(), ATTR_FONT_UNDERLINE );
 356         PUTITEM( aUnderlItem,   ATTR_FONT_UNDERLINE,    EE_CHAR_UNDERLINE );
 357     }
 358
 359 // Font posture (for all script types)
 360     if( mbItalicUsed )
 361     {
 362         SvxPostureItem aPostItem( maData.GetScPosture(), ATTR_FONT_POSTURE );
 363         PUTITEM( aPostItem, ATTR_FONT_POSTURE,      EE_CHAR_ITALIC );
 364         PUTITEM( aPostItem, ATTR_CJK_FONT_POSTURE,  EE_CHAR_ITALIC_CJK );
 365         PUTITEM( aPostItem, ATTR_CTL_FONT_POSTURE,  EE_CHAR_ITALIC_CTL );
 366     }
 367
 368 // Boolean attributes crossed out, contoured, shadowed
 369     if( mbStrikeUsed )
 370         PUTITEM( SvxCrossedOutItem( maData.GetScStrikeout(), ATTR_FONT_CROSSEDOUT ), ATTR_FONT_CROSSEDOUT, EE_CHAR_STRIKEOUT );
 371     if( mbOutlineUsed )
 372         PUTITEM( SvxContourItem( maData.mbOutline, ATTR_FONT_CONTOUR ), ATTR_FONT_CONTOUR, EE_CHAR_OUTLINE );
 373     if( mbShadowUsed )
 374         PUTITEM( SvxShadowedItem( maData.mbShadow, ATTR_FONT_SHADOWED ), ATTR_FONT_SHADOWED, EE_CHAR_SHADOW );
 375
 376 // Super-/subscript: only on edit engine objects
 377     if( mbEscapemUsed && bEE )
 378         rItemSet.Put( SvxEscapementItem( maData.GetScEscapement(), EE_CHAR_ESCAPEMENT ) );
 379
 380 #undef PUTITEM
 381 }
 382
 383 void XclImpFont::WriteFontProperties( ScfPropertySet& rPropSet,
 384         XclFontPropSetType eType, const Color* pFontColor ) const
 385 {
 386     GetFontPropSetHelper().WriteFontProperties(
 387         rPropSet, eType, maData, mbHasWstrn, mbHasAsian, mbHasCmplx, pFontColor );
 388 }
 389
 390 void XclImpFont::ReadFontData2( XclImpStream& rStrm )
 391 {
 392     sal_uInt16 nFlags;
 393     rStrm >> maData.mnHeight >> nFlags;
 394
 395     maData.mnWeight     = ::get_flagvalue( nFlags, EXC_FONTATTR_BOLD, EXC_FONTWGHT_BOLD, EXC_FONTWGHT_NORMAL );
 396     maData.mnUnderline  = ::get_flagvalue( nFlags, EXC_FONTATTR_UNDERLINE, EXC_FONTUNDERL_SINGLE, EXC_FONTUNDERL_NONE );
 397     maData.mbItalic     = ::get_flag( nFlags, EXC_FONTATTR_ITALIC );
 398     maData.mbStrikeout  = ::get_flag( nFlags, EXC_FONTATTR_STRIKEOUT );
 399     maData.mbOutline    = ::get_flag( nFlags, EXC_FONTATTR_OUTLINE );
 400     maData.mbShadow     = ::get_flag( nFlags, EXC_FONTATTR_SHADOW );
 401     mbHasCharSet = false;
 402 }
 403
 404 void XclImpFont::ReadFontData5( XclImpStream& rStrm )
 405 {
 406     sal_uInt16 nFlags;
 407
 408     rStrm >> maData.mnHeight >> nFlags;
 409     ReadFontColor( rStrm );
 410     rStrm >> maData.mnWeight >> maData.mnEscapem >> maData.mnUnderline >> maData.mnFamily >> maData.mnCharSet;
 411     rStrm.Ignore( 1 );
 412
 413     maData.mbItalic     = ::get_flag( nFlags, EXC_FONTATTR_ITALIC );
 414     maData.mbStrikeout  = ::get_flag( nFlags, EXC_FONTATTR_STRIKEOUT );
 415     maData.mbOutline    = ::get_flag( nFlags, EXC_FONTATTR_OUTLINE );
 416     maData.mbShadow     = ::get_flag( nFlags, EXC_FONTATTR_SHADOW );
 417     mbHasCharSet = true;
 418 }
 419
 420 void XclImpFont::ReadFontColor( XclImpStream& rStrm )
 421 {
 422     maData.maColor = GetPalette().GetColor( rStrm.ReaduInt16() );
 423 }
 424
 425 void XclImpFont::ReadFontName2( XclImpStream& rStrm )
 426 {
 427     maData.maName = rStrm.ReadByteString( false );
 428 }
 429
 430 void XclImpFont::ReadFontName8( XclImpStream& rStrm )
 431 {
 432     maData.maName = rStrm.ReadUniString( rStrm.ReaduInt8() );
 433 }
 434
 435 void XclImpFont::GuessScriptType()
 436 {
 437     mbHasWstrn = true;
 438     mbHasAsian = mbHasCmplx = false;
 439
 440     // #91658# #113783# find the script types for which the font contains characters
 441     if( OutputDevice* pPrinter = GetPrinter() )
 442     {
 443         Font aFont( maData.maName, Size( 0, 10 ) );
 444         FontCharMap aCharMap;
 445
 446         pPrinter->SetFont( aFont );
 447         if( pPrinter->GetFontCharMap( aCharMap ) )
 448         {
 449             // #91658# CJK fonts
 450             mbHasAsian =
 451                 aCharMap.HasChar( 0x3041 ) ||   // 3040-309F: Hiragana
 452                 aCharMap.HasChar( 0x30A1 ) ||   // 30A0-30FF: Katakana
 453                 aCharMap.HasChar( 0x3111 ) ||   // 3100-312F: Bopomofo
 454                 aCharMap.HasChar( 0x3131 ) ||   // 3130-318F: Hangul Compatibility Jamo
 455                 aCharMap.HasChar( 0x3301 ) ||   // 3300-33FF: CJK Compatibility
 456                 aCharMap.HasChar( 0x3401 ) ||   // 3400-4DBF: CJK Unified Ideographs Extension A
 457                 aCharMap.HasChar( 0x4E01 ) ||   // 4E00-9FAF: CJK Unified Ideographs
 458                 aCharMap.HasChar( 0x7E01 ) ||   // 4E00-9FAF: CJK unified ideographs
 459                 aCharMap.HasChar( 0xA001 ) ||   // A001-A48F: Yi Syllables
 460                 aCharMap.HasChar( 0xAC01 ) ||   // AC00-D7AF: Hangul Syllables
 461                 aCharMap.HasChar( 0xCC01 ) ||   // AC00-D7AF: Hangul Syllables
 462                 aCharMap.HasChar( 0xF901 ) ||   // F900-FAFF: CJK Compatibility Ideographs
 463                 aCharMap.HasChar( 0xFF71 );     // FF00-FFEF: Halfwidth/Fullwidth Forms
 464             // #113783# CTL fonts
 465             mbHasCmplx =
 466                 aCharMap.HasChar( 0x05D1 ) ||   // 0590-05FF: Hebrew
 467                 aCharMap.HasChar( 0x0631 ) ||   // 0600-06FF: Arabic
 468                 aCharMap.HasChar( 0x0721 ) ||   // 0700-074F: Syriac
 469                 aCharMap.HasChar( 0x0911 ) ||   // 0900-0DFF: Indic scripts
 470                 aCharMap.HasChar( 0x0E01 ) ||   // 0E00-0E7F: Thai
 471                 aCharMap.HasChar( 0xFB21 ) ||   // FB1D-FB4F: Hebrew Presentation Forms
 472                 aCharMap.HasChar( 0xFB51 ) ||   // FB50-FDFF: Arabic Presentation Forms-A
 473                 aCharMap.HasChar( 0xFE71 );     // FE70-FEFF: Arabic Presentation Forms-B
 474             // Western fonts
 475             mbHasWstrn = (!mbHasAsian && !mbHasCmplx) || aCharMap.HasChar( 'A' );
 476         }
 477     }
 478 }
 479
 480 // ----------------------------------------------------------------------------
 481
 482 XclImpFontBuffer::XclImpFontBuffer( const XclImpRoot& rRoot ) :
 483     XclImpRoot( rRoot ),
 484     maFont4( rRoot ),
 485     maCtrlFont( rRoot )
 486 {
 487     Initialize();
 488
 489     // default font for form controls without own font information
 490     XclFontData aCtrlFontData;
 491     switch( GetBiff() )
 492     {
 493         case EXC_BIFF2:
 494         case EXC_BIFF3:
 495         case EXC_BIFF4:
 496         case EXC_BIFF5:
 497             aCtrlFontData.maName.AssignAscii( "Helv" );
 498             aCtrlFontData.mnHeight = 160;
 499             aCtrlFontData.mnWeight = EXC_FONTWGHT_BOLD;
 500         break;
 501         case EXC_BIFF8:
 502             aCtrlFontData.maName.AssignAscii( "Tahoma" );
 503             aCtrlFontData.mnHeight = 160;
 504             aCtrlFontData.mnWeight = EXC_FONTWGHT_NORMAL;
 505         break;
 506         default:
 507             DBG_ERROR_BIFF();
 508     }
 509     maCtrlFont.SetFontData( aCtrlFontData, false );
 510 }
 511
 512 void XclImpFontBuffer::Initialize()
 513 {
 514     maFontList.Clear();
 515
 516     // application font for column width calculation, later filled with first font from font list
 517     XclFontData aAppFontData;
 518     aAppFontData.maName.AssignAscii( "Arial" );
 519     aAppFontData.mnHeight = 200;
 520     aAppFontData.mnWeight = EXC_FONTWGHT_NORMAL;
 521     UpdateAppFont( aAppFontData, false );
 522 }
 523
 524 const XclImpFont* XclImpFontBuffer::GetFont( sal_uInt16 nFontIndex ) const
 525 {
 526     /*  Font with index 4 is not stored in an Excel file, but used e.g. by
 527         BIFF5 form pushbutton objects. It is the bold default font. */
 528     return (nFontIndex == 4) ? &maFont4 :
 529         maFontList.GetObject( (nFontIndex < 4) ? nFontIndex : (nFontIndex - 1) );
 530 }
 531
 532 void XclImpFontBuffer::ReadFont( XclImpStream& rStrm )
 533 {
 534     XclImpFont* pFont = new XclImpFont( GetRoot() );
 535     pFont->ReadFont( rStrm );
 536     maFontList.Append( pFont );
 537
 538     if( maFontList.Count() == 1 )
 539     {
 540         UpdateAppFont( pFont->GetFontData(), pFont->HasCharSet() );
 541         // #i71033# set text encoding from application font, if CODEPAGE is missing
 542         SetAppFontEncoding( pFont->GetFontEncoding() );
 543     }
 544 }
 545
 546 void XclImpFontBuffer::ReadEfont( XclImpStream& rStrm )
 547 {
 548     if( XclImpFont* pFont = maFontList.Last() )
 549         pFont->ReadEfont( rStrm );
 550 }
 551
 552 void XclImpFontBuffer::FillToItemSet(
 553         SfxItemSet& rItemSet, XclFontItemType eType,
 554         sal_uInt16 nFontIdx, bool bSkipPoolDefs ) const
 555 {
 556     if( const XclImpFont* pFont = GetFont( nFontIdx ) )
 557         pFont->FillToItemSet( rItemSet, eType, bSkipPoolDefs );
 558 }
 559
 560 void XclImpFontBuffer::WriteFontProperties( ScfPropertySet& rPropSet,
 561         XclFontPropSetType eType, sal_uInt16 nFontIdx, const Color* pFontColor ) const
 562 {
 563     if( const XclImpFont* pFont = GetFont( nFontIdx ) )
 564         pFont->WriteFontProperties( rPropSet, eType, pFontColor );
 565 }
 566
 567 void XclImpFontBuffer::WriteDefaultCtrlFontProperties( ScfPropertySet& rPropSet ) const
 568 {
 569     maCtrlFont.WriteFontProperties( rPropSet, EXC_FONTPROPSET_CONTROL );
 570 }
 571
 572 void XclImpFontBuffer::UpdateAppFont( const XclFontData& rFontData, bool bHasCharSet )
 573 {
 574     maAppFont = rFontData;
 575     // #i3006# Calculate the width of '0' from first font and current printer.
 576     SetCharWidth( maAppFont );
 577
 578     // font 4 is bold font 0
 579     XclFontData aFont4Data( maAppFont );
 580     aFont4Data.mnWeight = EXC_FONTWGHT_BOLD;
 581     maFont4.SetFontData( aFont4Data, bHasCharSet );
 582 }
 583
 584 // FORMAT record - number formats =============================================
 585
 586 XclImpNumFmtBuffer::XclImpNumFmtBuffer( const XclImpRoot& rRoot ) :
 587     XclNumFmtBuffer( rRoot ),
 588     XclImpRoot( rRoot ),
 589     mnNextXclIdx( 0 )
 590 {
 591 }
 592
 593 void XclImpNumFmtBuffer::Initialize()
 594 {
 595     maIndexMap.clear();
 596     mnNextXclIdx = 0;
 597     InitializeImport();     // base class
 598 }
 599
 600 void XclImpNumFmtBuffer::ReadFormat( XclImpStream& rStrm )
 601 {
 602     String aFormat;
 603     switch( GetBiff() )
 604     {
 605         case EXC_BIFF2:
 606         case EXC_BIFF3:
 607             aFormat = rStrm.ReadByteString( false );
 608         break;
 609
 610         case EXC_BIFF4:
 611             rStrm.Ignore( 2 );  // in BIFF4 the index field exists, but is undefined
 612             aFormat = rStrm.ReadByteString( false );
 613         break;
 614
 615         case EXC_BIFF5:
 616             rStrm >> mnNextXclIdx;
 617             aFormat = rStrm.ReadByteString( false );
 618         break;
 619
 620         case EXC_BIFF8:
 621             rStrm >> mnNextXclIdx;
 622             aFormat = rStrm.ReadUniString();
 623         break;
 624
 625         default:
 626             DBG_ERROR_BIFF();
 627             return;
 628     }
 629
 630     if( mnNextXclIdx < 0xFFFF )
 631     {
 632         InsertFormat( mnNextXclIdx, aFormat );
 633         ++mnNextXclIdx;
 634     }
 635 }
 636
 637 void XclImpNumFmtBuffer::CreateScFormats()
 638 {
 639     DBG_ASSERT( maIndexMap.empty(), "XclImpNumFmtBuffer::CreateScFormats - already created" );
 640
 641     SvNumberFormatter& rFormatter = GetFormatter();
 642     for( XclNumFmtMap::const_iterator aIt = GetFormatMap().begin(), aEnd = GetFormatMap().end(); aIt != aEnd; ++aIt )
 643     {
 644         const XclNumFmt& rNumFmt = aIt->second;
 645
 646         // insert/convert the Excel number format
 647         xub_StrLen nCheckPos;
 648         short nType = NUMBERFORMAT_DEFINED;
 649         sal_uInt32 nKey;
 650         if( rNumFmt.maFormat.Len() )
 651         {
 652             String aFormat( rNumFmt.maFormat );
 653             rFormatter.PutandConvertEntry( aFormat, nCheckPos,
 654                 nType, nKey, LANGUAGE_ENGLISH_US, rNumFmt.meLanguage );
 655         }
 656         else
 657             nKey = rFormatter.GetFormatIndex( rNumFmt.meOffset, rNumFmt.meLanguage );
 658
 659         // insert the resulting format key into the Excel->Calc index map
 660         maIndexMap[ aIt->first ] = nKey;
 661     }
 662 }
 663
 664 ULONG XclImpNumFmtBuffer::GetScFormat( sal_uInt16 nXclNumFmt ) const
 665 {
 666     XclImpIndexMap::const_iterator aIt = maIndexMap.find( nXclNumFmt );
 667     return (aIt != maIndexMap.end()) ? aIt->second : NUMBERFORMAT_ENTRY_NOT_FOUND;
 668 }
 669
 670 void XclImpNumFmtBuffer::FillToItemSet( SfxItemSet& rItemSet, sal_uInt16 nXclNumFmt, bool bSkipPoolDefs ) const
 671 {
 672     ULONG nScNumFmt = GetScFormat( nXclNumFmt );
 673     if( nScNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND )
 674         nScNumFmt = GetStdScNumFmt();
 675     FillScFmtToItemSet( rItemSet, nScNumFmt, bSkipPoolDefs );
 676 }
 677
 678 void XclImpNumFmtBuffer::FillScFmtToItemSet( SfxItemSet& rItemSet, ULONG nScNumFmt, bool bSkipPoolDefs ) const
 679 {
 680     DBG_ASSERT( nScNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND, "XclImpNumFmtBuffer::FillScFmtToItemSet - invalid number format" );
 681     ScfTools::PutItem( rItemSet, SfxUInt32Item( ATTR_VALUE_FORMAT, nScNumFmt ), bSkipPoolDefs );
 682     if( rItemSet.GetItemState( ATTR_VALUE_FORMAT, FALSE ) == SFX_ITEM_SET )
 683         ScGlobal::AddLanguage( rItemSet, GetFormatter() );
 684 }
 685
 686 // XF, STYLE record - Cell formatting =========================================
 687
 688 void XclImpCellProt::FillFromXF2( sal_uInt8 nNumFmt )
 689 {
 690     mbLocked = ::get_flag( nNumFmt, EXC_XF2_LOCKED );
 691     mbHidden = ::get_flag( nNumFmt, EXC_XF2_HIDDEN );
 692 }
 693
 694 void XclImpCellProt::FillFromXF3( sal_uInt16 nProt )
 695 {
 696     mbLocked = ::get_flag( nProt, EXC_XF_LOCKED );
 697     mbHidden = ::get_flag( nProt, EXC_XF_HIDDEN );
 698 }
 699
 700 void XclImpCellProt::FillToItemSet( SfxItemSet& rItemSet, bool bSkipPoolDefs ) const
 701 {
 702     ScfTools::PutItem( rItemSet, ScProtectionAttr( mbLocked, mbHidden ), bSkipPoolDefs );
 703 }
 704
 705
 706 // ----------------------------------------------------------------------------
 707
 708 void XclImpCellAlign::FillFromXF2( sal_uInt8 nFlags )
 709 {
 710     mnHorAlign = ::extract_value< sal_uInt8 >( nFlags, 0, 3 );
 711 }
 712
 713 void XclImpCellAlign::FillFromXF3( sal_uInt16 nAlign )
 714 {
 715     mnHorAlign = ::extract_value< sal_uInt8 >( nAlign, 0, 3 );
 716     mbLineBreak = ::get_flag( nAlign, EXC_XF_LINEBREAK );   // new in BIFF3
 717 }
 718
 719 void XclImpCellAlign::FillFromXF4( sal_uInt16 nAlign )
 720 {
 721     FillFromXF3( nAlign );
 722     mnVerAlign = ::extract_value< sal_uInt8 >( nAlign, 4, 2 );  // new in BIFF4
 723     mnOrient = ::extract_value< sal_uInt8 >( nAlign, 6, 2 );    // new in BIFF4
 724 }
 725
 726 void XclImpCellAlign::FillFromXF5( sal_uInt16 nAlign )
 727 {
 728     mnHorAlign = ::extract_value< sal_uInt8 >( nAlign, 0, 3 );
 729     mnVerAlign = ::extract_value< sal_uInt8 >( nAlign, 4, 3 );
 730     mbLineBreak = ::get_flag( nAlign, EXC_XF_LINEBREAK );
 731     mnOrient = ::extract_value< sal_uInt8 >( nAlign, 8, 2 );
 732 }
 733
 734 void XclImpCellAlign::FillFromXF8( sal_uInt16 nAlign, sal_uInt16 nMiscAttrib )
 735 {
 736     mnHorAlign = ::extract_value< sal_uInt8 >( nAlign, 0, 3 );
 737     mnVerAlign = ::extract_value< sal_uInt8 >( nAlign, 4, 3 );
 738     mbLineBreak = ::get_flag( nAlign, EXC_XF_LINEBREAK );
 739     mnRotation = ::extract_value< sal_uInt8 >( nAlign, 8, 8 );      // new in BIFF8
 740     mnIndent = ::extract_value< sal_uInt8 >( nMiscAttrib, 0, 4 );   // new in BIFF8
 741     mbShrink = ::get_flag( nMiscAttrib, EXC_XF8_SHRINK );           // new in BIFF8
 742     mnTextDir = ::extract_value< sal_uInt8 >( nMiscAttrib, 6, 2 );  // new in BIFF8
 743 }
 744
 745 void XclImpCellAlign::FillToItemSet( SfxItemSet& rItemSet, const XclImpFont* pFont, bool bSkipPoolDefs ) const
 746 {
 747     // horizontal alignment
 748     ScfTools::PutItem( rItemSet, SvxHorJustifyItem( GetScHorAlign(), ATTR_HOR_JUSTIFY ), bSkipPoolDefs );
 749
 750     // text wrap (#i74508# always if vertical alignment is justified or distributed)
 751     bool bLineBreak = mbLineBreak || (mnVerAlign == EXC_XF_VER_JUSTIFY) || (mnVerAlign == EXC_XF_VER_DISTRIB);
 752     ScfTools::PutItem( rItemSet, SfxBoolItem( ATTR_LINEBREAK, bLineBreak ), bSkipPoolDefs );
 753
 754     // vertical alignment
 755     ScfTools::PutItem( rItemSet, SvxVerJustifyItem( GetScVerAlign(), ATTR_VER_JUSTIFY ), bSkipPoolDefs );
 756
 757     // indent
 758     sal_uInt16 nScIndent = mnIndent * 200; // 1 Excel unit == 10 pt == 200 twips
 759     ScfTools::PutItem( rItemSet, SfxUInt16Item( ATTR_INDENT, nScIndent ), bSkipPoolDefs );
 760
 761     // shrink to fit
 762     ScfTools::PutItem( rItemSet, SfxBoolItem( ATTR_SHRINKTOFIT, mbShrink ), bSkipPoolDefs );
 763
 764     // text orientation/rotation (BIFF2-BIFF7 sets mnOrient)
 765     sal_uInt8 nXclRot = (mnOrient == EXC_ORIENT_NONE) ? mnRotation : XclTools::GetXclRotFromOrient( mnOrient );
 766     bool bStacked = (nXclRot == EXC_ROT_STACKED);
 767     ScfTools::PutItem( rItemSet, SfxBoolItem( ATTR_STACKED, bStacked ), bSkipPoolDefs );
 768     ScfTools::PutItem( rItemSet, SvxRotateModeItem( SVX_ROTATE_MODE_STANDARD, ATTR_ROTATE_MODE ), bSkipPoolDefs );
 769     // set an angle in the range from -90 to 90 degrees
 770     sal_Int32 nAngle = XclTools::GetScRotation( nXclRot, 0 );
 771     ScfTools::PutItem( rItemSet, SfxInt32Item( ATTR_ROTATE_VALUE, nAngle ), bSkipPoolDefs );
 772     // #105933# set "Use asian vertical layout", if cell is stacked and font contains CKJ characters
 773     bool bAsianVert = bStacked && pFont && pFont->HasAsianChars();
 774     ScfTools::PutItem( rItemSet, SfxBoolItem( ATTR_VERTICAL_ASIAN, bAsianVert ), bSkipPoolDefs );
 775
 776     // CTL text direction
 777     ScfTools::PutItem( rItemSet, SvxFrameDirectionItem( GetScFrameDir(), ATTR_WRITINGDIR ), bSkipPoolDefs );
 778 }
 779
 780 // ----------------------------------------------------------------------------
 781
 782 XclImpCellBorder::XclImpCellBorder()
 783 {
 784     SetUsedFlags( false, false );
 785 }
 786
 787 void XclImpCellBorder::SetUsedFlags( bool bOuterUsed, bool bDiagUsed )
 788 {
 789     mbLeftUsed = mbRightUsed = mbTopUsed = mbBottomUsed = bOuterUsed;
 790     mbDiagUsed = bDiagUsed;
 791 }
 792
 793 void XclImpCellBorder::FillFromXF2( sal_uInt8 nFlags )
 794 {
 795     mnLeftLine   = ::get_flagvalue( nFlags, EXC_XF2_LEFTLINE,   EXC_LINE_THIN, EXC_LINE_NONE );
 796     mnRightLine  = ::get_flagvalue( nFlags, EXC_XF2_RIGHTLINE,  EXC_LINE_THIN, EXC_LINE_NONE );
 797     mnTopLine    = ::get_flagvalue( nFlags, EXC_XF2_TOPLINE,    EXC_LINE_THIN, EXC_LINE_NONE );
 798     mnBottomLine = ::get_flagvalue( nFlags, EXC_XF2_BOTTOMLINE, EXC_LINE_THIN, EXC_LINE_NONE );
 799     mnLeftColor = mnRightColor = mnTopColor = mnBottomColor = EXC_COLOR_BIFF2_BLACK;
 800     SetUsedFlags( true, false );
 801 }
 802
 803 void XclImpCellBorder::FillFromXF3( sal_uInt32 nBorder )
 804 {
 805     mnTopLine     = ::extract_value< sal_uInt8  >( nBorder,  0, 3 );
 806     mnLeftLine    = ::extract_value< sal_uInt8  >( nBorder,  8, 3 );
 807     mnBottomLine  = ::extract_value< sal_uInt8  >( nBorder, 16, 3 );
 808     mnRightLine   = ::extract_value< sal_uInt8  >( nBorder, 24, 3 );
 809     mnTopColor    = ::extract_value< sal_uInt16 >( nBorder,  3, 5 );
 810     mnLeftColor   = ::extract_value< sal_uInt16 >( nBorder, 11, 5 );
 811     mnBottomColor = ::extract_value< sal_uInt16 >( nBorder, 19, 5 );
 812     mnRightColor  = ::extract_value< sal_uInt16 >( nBorder, 27, 5 );
 813     SetUsedFlags( true, false );
 814 }
 815
 816 void XclImpCellBorder::FillFromXF5( sal_uInt32 nBorder, sal_uInt32 nArea )
 817 {
 818     mnTopLine     = ::extract_value< sal_uInt8  >( nBorder,  0, 3 );
 819     mnLeftLine    = ::extract_value< sal_uInt8  >( nBorder,  3, 3 );
 820     mnBottomLine  = ::extract_value< sal_uInt8  >( nArea,   22, 3 );
 821     mnRightLine   = ::extract_value< sal_uInt8  >( nBorder,  6, 3 );
 822     mnTopColor    = ::extract_value< sal_uInt16 >( nBorder,  9, 7 );
 823     mnLeftColor   = ::extract_value< sal_uInt16 >( nBorder, 16, 7 );
 824     mnBottomColor = ::extract_value< sal_uInt16 >( nArea,   25, 7 );
 825     mnRightColor  = ::extract_value< sal_uInt16 >( nBorder, 23, 7 );
 826     SetUsedFlags( true, false );
 827 }
 828
 829 void XclImpCellBorder::FillFromXF8( sal_uInt32 nBorder1, sal_uInt32 nBorder2 )
 830 {
 831     mnLeftLine    = ::extract_value< sal_uInt8  >( nBorder1,  0, 4 );
 832     mnRightLine   = ::extract_value< sal_uInt8  >( nBorder1,  4, 4 );
 833     mnTopLine     = ::extract_value< sal_uInt8  >( nBorder1,  8, 4 );
 834     mnBottomLine  = ::extract_value< sal_uInt8  >( nBorder1, 12, 4 );
 835     mnLeftColor   = ::extract_value< sal_uInt16 >( nBorder1, 16, 7 );
 836     mnRightColor  = ::extract_value< sal_uInt16 >( nBorder1, 23, 7 );
 837     mnTopColor    = ::extract_value< sal_uInt16 >( nBorder2,  0, 7 );
 838     mnBottomColor = ::extract_value< sal_uInt16 >( nBorder2,  7, 7 );
 839     mbDiagTLtoBR  = ::get_flag( nBorder1, EXC_XF_DIAGONAL_TL_TO_BR );
 840     mbDiagBLtoTR  = ::get_flag( nBorder1, EXC_XF_DIAGONAL_BL_TO_TR );
 841     if( mbDiagTLtoBR || mbDiagBLtoTR )
 842     {
 843         mnDiagLine  = ::extract_value< sal_uInt8 >( nBorder2, 21, 4 );
 844         mnDiagColor = ::extract_value< sal_uInt16 >( nBorder2, 14, 7 );
 845     }
 846     SetUsedFlags( true, true );
 847 }
 848
 849 void XclImpCellBorder::FillFromCF8( sal_uInt16 nLineStyle, sal_uInt32 nLineColor, sal_uInt32 nFlags )
 850 {
 851     mnLeftLine    = ::extract_value< sal_uInt8  >( nLineStyle,  0, 4 );
 852     mnRightLine   = ::extract_value< sal_uInt8  >( nLineStyle,  4, 4 );
 853     mnTopLine     = ::extract_value< sal_uInt8  >( nLineStyle,  8, 4 );
 854     mnBottomLine  = ::extract_value< sal_uInt8  >( nLineStyle, 12, 4 );
 855     mnLeftColor   = ::extract_value< sal_uInt16 >( nLineColor,  0, 7 );
 856     mnRightColor  = ::extract_value< sal_uInt16 >( nLineColor,  7, 7 );
 857     mnTopColor    = ::extract_value< sal_uInt16 >( nLineColor, 16, 7 );
 858     mnBottomColor = ::extract_value< sal_uInt16 >( nLineColor, 23, 7 );
 859     mbLeftUsed    = !::get_flag( nFlags, EXC_CF_BORDER_LEFT );
 860     mbRightUsed   = !::get_flag( nFlags, EXC_CF_BORDER_RIGHT );
 861     mbTopUsed     = !::get_flag( nFlags, EXC_CF_BORDER_TOP );
 862     mbBottomUsed  = !::get_flag( nFlags, EXC_CF_BORDER_BOTTOM );
 863     mbDiagUsed    = false;
 864 }
 865
 866 namespace {
 867
 868 /** Converts the passed line style to a SvxBorderLine, or returns false, if style is "no line". */
 869 bool lclConvertBorderLine( SvxBorderLine& rLine, const XclImpPalette& rPalette, sal_uInt8 nXclLine, sal_uInt16 nXclColor )
 870 {
 871     static const sal_uInt16 ppnLineParam[][ 3 ] =
 872     {
 873         //  outer width,        inner width,        distance
 874         {   0,                  0,                  0 },                // 0 = none
 875         {   DEF_LINE_WIDTH_1,   0,                  0 },                // 1 = thin
 876         {   DEF_LINE_WIDTH_2,   0,                  0 },                // 2 = medium
 877         {   DEF_LINE_WIDTH_1,   0,                  0 },                // 3 = dashed
 878         {   DEF_LINE_WIDTH_0,   0,                  0 },                // 4 = dotted
 879         {   DEF_LINE_WIDTH_3,   0,                  0 },                // 5 = thick
 880         {   DEF_LINE_WIDTH_1,   DEF_LINE_WIDTH_1,   DEF_LINE_WIDTH_1 }, // 6 = double
 881         {   DEF_LINE_WIDTH_0,   0,                  0 },                // 7 = hair
 882         {   DEF_LINE_WIDTH_2,   0,                  0 },                // 8 = med dash
 883         {   DEF_LINE_WIDTH_1,   0,                  0 },                // 9 = thin dashdot
 884         {   DEF_LINE_WIDTH_2,   0,                  0 },                // A = med dashdot
 885         {   DEF_LINE_WIDTH_1,   0,                  0 },                // B = thin dashdotdot
 886         {   DEF_LINE_WIDTH_2,   0,                  0 },                // C = med dashdotdot
 887         {   DEF_LINE_WIDTH_2,   0,                  0 }                 // D = med slant dashdot
 888     };
 889
 890     if( nXclLine == EXC_LINE_NONE )
 891         return false;
 892     if( nXclLine >= STATIC_TABLE_SIZE( ppnLineParam ) )
 893         nXclLine = EXC_LINE_THIN;
 894
 895     rLine.SetColor( rPalette.GetColor( nXclColor ) );
 896     rLine.SetOutWidth( ppnLineParam[ nXclLine ][ 0 ] );
 897     rLine.SetInWidth(  ppnLineParam[ nXclLine ][ 1 ] );
 898     rLine.SetDistance( ppnLineParam[ nXclLine ][ 2 ] );
 899     return true;
 900 }
 901
 902 } // namespace
 903
 904 void XclImpCellBorder::FillToItemSet( SfxItemSet& rItemSet, const XclImpPalette& rPalette, bool bSkipPoolDefs ) const
 905 {
 906     if( mbLeftUsed || mbRightUsed || mbTopUsed || mbBottomUsed )
 907     {
 908         SvxBoxItem aBoxItem( ATTR_BORDER );
 909         SvxBorderLine aLine;
 910         if( mbLeftUsed && lclConvertBorderLine( aLine, rPalette, mnLeftLine, mnLeftColor ) )
 911             aBoxItem.SetLine( &aLine, BOX_LINE_LEFT );
 912         if( mbRightUsed && lclConvertBorderLine( aLine, rPalette, mnRightLine, mnRightColor ) )
 913             aBoxItem.SetLine( &aLine, BOX_LINE_RIGHT );
 914         if( mbTopUsed && lclConvertBorderLine( aLine, rPalette, mnTopLine, mnTopColor ) )
 915             aBoxItem.SetLine( &aLine, BOX_LINE_TOP );
 916         if( mbBottomUsed && lclConvertBorderLine( aLine, rPalette, mnBottomLine, mnBottomColor ) )
 917             aBoxItem.SetLine( &aLine, BOX_LINE_BOTTOM );
 918         ScfTools::PutItem( rItemSet, aBoxItem, bSkipPoolDefs );
 919     }
 920     if( mbDiagUsed )
 921     {
 922         SvxLineItem aTLBRItem( ATTR_BORDER_TLBR );
 923         SvxLineItem aBLTRItem( ATTR_BORDER_BLTR );
 924         SvxBorderLine aLine;
 925         if( lclConvertBorderLine( aLine, rPalette, mnDiagLine, mnDiagColor ) )
 926         {
 927             if( mbDiagTLtoBR )
 928                 aTLBRItem.SetLine( &aLine );
 929             if( mbDiagBLtoTR )
 930                 aBLTRItem.SetLine( &aLine );
 931         }
 932         ScfTools::PutItem( rItemSet, aTLBRItem, bSkipPoolDefs );
 933         ScfTools::PutItem( rItemSet, aBLTRItem, bSkipPoolDefs );
 934     }
 935 }
 936
 937 // ----------------------------------------------------------------------------
 938
 939 XclImpCellArea::XclImpCellArea()
 940 {
 941     SetUsedFlags( false );
 942 }
 943
 944 void XclImpCellArea::SetUsedFlags( bool bUsed )
 945 {
 946     mbForeUsed = mbBackUsed = mbPattUsed = bUsed;
 947 }
 948
 949 void XclImpCellArea::FillFromXF2( sal_uInt8 nFlags )
 950 {
 951     mnPattern = ::get_flagvalue( nFlags, EXC_XF2_BACKGROUND, EXC_PATT_12_5_PERC, EXC_PATT_NONE );
 952     mnForeColor = EXC_COLOR_BIFF2_BLACK;
 953     mnBackColor = EXC_COLOR_BIFF2_WHITE;
 954     SetUsedFlags( true );
 955 }
 956
 957 void XclImpCellArea::FillFromXF3( sal_uInt16 nArea )
 958 {
 959     mnPattern   = ::extract_value< sal_uInt8  >( nArea,  0, 6 );
 960     mnForeColor = ::extract_value< sal_uInt16 >( nArea,  6, 5 );
 961     mnBackColor = ::extract_value< sal_uInt16 >( nArea, 11, 5 );
 962     SetUsedFlags( true );
 963 }
 964
 965 void XclImpCellArea::FillFromXF5( sal_uInt32 nArea )
 966 {
 967     mnPattern   = ::extract_value< sal_uInt8  >( nArea, 16, 6 );
 968     mnForeColor = ::extract_value< sal_uInt16 >( nArea,  0, 7 );
 969     mnBackColor = ::extract_value< sal_uInt16 >( nArea,  7, 7 );
 970     SetUsedFlags( true );
 971 }
 972
 973 void XclImpCellArea::FillFromXF8( sal_uInt32 nBorder2, sal_uInt16 nArea )
 974 {
 975     mnPattern   = ::extract_value< sal_uInt8  >( nBorder2, 26, 6 );
 976     mnForeColor = ::extract_value< sal_uInt16 >( nArea,     0, 7 );
 977     mnBackColor = ::extract_value< sal_uInt16 >( nArea,     7, 7 );
 978     SetUsedFlags( true );
 979 }
 980
 981 void XclImpCellArea::FillFromCF8( sal_uInt16 nPattern, sal_uInt16 nColor, sal_uInt32 nFlags )
 982 {
 983     mnForeColor = ::extract_value< sal_uInt16 >( nColor,    0, 7 );
 984     mnBackColor = ::extract_value< sal_uInt16 >( nColor,    7, 7 );
 985     mnPattern   = ::extract_value< sal_uInt8  >( nPattern, 10, 6 );
 986     mbForeUsed  = !::get_flag( nFlags, EXC_CF_AREA_FGCOLOR );
 987     mbBackUsed  = !::get_flag( nFlags, EXC_CF_AREA_BGCOLOR );
 988     mbPattUsed  = !::get_flag( nFlags, EXC_CF_AREA_PATTERN );
 989
 990     if( mbBackUsed && (!mbPattUsed || (mnPattern == EXC_PATT_SOLID)) )
 991     {
 992         mnForeColor = mnBackColor;
 993         mnPattern = EXC_PATT_SOLID;
 994         mbForeUsed = mbPattUsed = true;
 995     }
 996     else if( !mbBackUsed && mbPattUsed && (mnPattern == EXC_PATT_SOLID) )
 997     {
 998         mbPattUsed = false;
 999     }
1000 }
1001
1002 void XclImpCellArea::FillToItemSet( SfxItemSet& rItemSet, const XclImpPalette& rPalette, bool bSkipPoolDefs ) const
1003 {
1004     if( mbPattUsed )    // colors may be both unused in cond. formats
1005     {
1006         SvxBrushItem aBrushItem( ATTR_BACKGROUND );
1007
1008         // #108935# do not use IsTransparent() - old Calc filter writes tranparency with different color indexes
1009         if( mnPattern == EXC_PATT_NONE )
1010         {
1011             aBrushItem.SetColor( Color( COL_TRANSPARENT ) );
1012         }
1013         else
1014         {
1015             Color aFore( rPalette.GetColor( mbForeUsed ? mnForeColor : EXC_COLOR_WINDOWTEXT ) );
1016             Color aBack( rPalette.GetColor( mbBackUsed ? mnBackColor : EXC_COLOR_WINDOWBACK ) );
1017             aBrushItem.SetColor( XclTools::GetPatternColor( aFore, aBack, mnPattern ) );
1018         }
1019
1020         ScfTools::PutItem( rItemSet, aBrushItem, bSkipPoolDefs );
1021     }
1022 }
1023
1024
1025 // ----------------------------------------------------------------------------
1026
1027 XclImpXF::XclImpXF( const XclImpRoot& rRoot ) :
1028     XclXFBase( true ),      // default is cell XF
1029     XclImpRoot( rRoot ),
1030     mpStyleSheet( 0 ),
1031     mnXclNumFmt( 0 ),
1032     mnXclFont( 0 )
1033 {
1034 }
1035
1036 XclImpXF::~XclImpXF()
1037 {
1038 }
1039
1040 void XclImpXF::ReadXF2( XclImpStream& rStrm )
1041 {
1042     sal_uInt8 nReadFont, nReadNumFmt, nFlags;
1043     rStrm >> nReadFont;
1044     rStrm.Ignore( 1 );
1045     rStrm >> nReadNumFmt >> nFlags;
1046
1047     // XF type always cell, no parent, used flags always true
1048     SetAllUsedFlags( true );
1049
1050     // attributes
1051     maProtection.FillFromXF2( nReadNumFmt );
1052     mnXclFont = nReadFont;
1053     mnXclNumFmt = nReadNumFmt & EXC_XF2_VALFMT_MASK;
1054     maAlignment.FillFromXF2( nFlags );
1055     maBorder.FillFromXF2( nFlags );
1056     maArea.FillFromXF2( nFlags );
1057 }
1058
1059 void XclImpXF::ReadXF3( XclImpStream& rStrm )
1060 {
1061     sal_uInt32 nBorder;
1062     sal_uInt16 nTypeProt, nAlign, nArea;
1063     sal_uInt8 nReadFont, nReadNumFmt;
1064     rStrm >> nReadFont >> nReadNumFmt >> nTypeProt >> nAlign >> nArea >> nBorder;
1065
1066     // XF type/parent, attribute used flags
1067     mbCellXF = !::get_flag( nTypeProt, EXC_XF_STYLE );          // new in BIFF3
1068     mnParent = ::extract_value< sal_uInt16 >( nAlign, 4, 12 );  // new in BIFF3
1069     SetUsedFlags( ::extract_value< sal_uInt8 >( nTypeProt, 10, 6 ) );
1070
1071     // attributes
1072     maProtection.FillFromXF3( nTypeProt );
1073     mnXclFont = nReadFont;
1074     mnXclNumFmt = nReadNumFmt;
1075     maAlignment.FillFromXF3( nAlign );
1076     maBorder.FillFromXF3( nBorder );
1077     maArea.FillFromXF3( nArea );                        // new in BIFF3
1078 }
1079
1080 void XclImpXF::ReadXF4( XclImpStream& rStrm )
1081 {
1082     sal_uInt32 nBorder;
1083     sal_uInt16 nTypeProt, nAlign, nArea;
1084     sal_uInt8 nReadFont, nReadNumFmt;
1085     rStrm >> nReadFont >> nReadNumFmt >> nTypeProt >> nAlign >> nArea >> nBorder;
1086
1087     // XF type/parent, attribute used flags
1088     mbCellXF = !::get_flag( nTypeProt, EXC_XF_STYLE );
1089     mnParent = ::extract_value< sal_uInt16 >( nTypeProt, 4, 12 );
1090     SetUsedFlags( ::extract_value< sal_uInt8 >( nAlign, 10, 6 ) );
1091
1092     // attributes
1093     maProtection.FillFromXF3( nTypeProt );
1094     mnXclFont = nReadFont;
1095     mnXclNumFmt = nReadNumFmt;
1096     maAlignment.FillFromXF4( nAlign );
1097     maBorder.FillFromXF3( nBorder );
1098     maArea.FillFromXF3( nArea );
1099 }
1100
1101 void XclImpXF::ReadXF5( XclImpStream& rStrm )
1102 {
1103     sal_uInt32 nArea, nBorder;
1104     sal_uInt16 nTypeProt, nAlign;
1105     rStrm >> mnXclFont >> mnXclNumFmt >> nTypeProt >> nAlign >> nArea >> nBorder;
1106
1107     // XF type/parent, attribute used flags
1108     mbCellXF = !::get_flag( nTypeProt, EXC_XF_STYLE );
1109     mnParent = ::extract_value< sal_uInt16 >( nTypeProt, 4, 12 );
1110     SetUsedFlags( ::extract_value< sal_uInt8 >( nAlign, 10, 6 ) );
1111
1112     // attributes
1113     maProtection.FillFromXF3( nTypeProt );
1114     maAlignment.FillFromXF5( nAlign );
1115     maBorder.FillFromXF5( nBorder, nArea );
1116     maArea.FillFromXF5( nArea );
1117 }
1118
1119 void XclImpXF::ReadXF8( XclImpStream& rStrm )
1120 {
1121     sal_uInt32 nBorder1, nBorder2;
1122     sal_uInt16 nTypeProt, nAlign, nMiscAttrib, nArea;
1123     rStrm >> mnXclFont >> mnXclNumFmt >> nTypeProt >> nAlign >> nMiscAttrib >> nBorder1 >> nBorder2 >> nArea;
1124
1125     // XF type/parent, attribute used flags
1126     mbCellXF = !::get_flag( nTypeProt, EXC_XF_STYLE );
1127     mnParent = ::extract_value< sal_uInt16 >( nTypeProt, 4, 12 );
1128     SetUsedFlags( ::extract_value< sal_uInt8 >( nMiscAttrib, 10, 6 ) );
1129
1130     // attributes
1131     maProtection.FillFromXF3( nTypeProt );
1132     maAlignment.FillFromXF8( nAlign, nMiscAttrib );
1133     maBorder.FillFromXF8( nBorder1, nBorder2 );
1134     maArea.FillFromXF8( nBorder2, nArea );
1135 }
1136
1137 void XclImpXF::ReadXF( XclImpStream& rStrm )
1138 {
1139     switch( GetBiff() )
1140     {
1141         case EXC_BIFF2: ReadXF2( rStrm );   break;
1142         case EXC_BIFF3: ReadXF3( rStrm );   break;
1143         case EXC_BIFF4: ReadXF4( rStrm );   break;
1144         case EXC_BIFF5: ReadXF5( rStrm );   break;
1145         case EXC_BIFF8: ReadXF8( rStrm );   break;
1146         default:        DBG_ERROR_BIFF();
1147     }
1148 }
1149
1150 const ScPatternAttr& XclImpXF::CreatePattern( bool bSkipPoolDefs )
1151 {
1152     if( mpPattern.get() )
1153         return *mpPattern;
1154
1155     // create new pattern attribute set
1156     mpPattern.reset( new ScPatternAttr( GetDoc().GetPool() ) );
1157     SfxItemSet& rItemSet = mpPattern->GetItemSet();
1158
1159     // parent cell style
1160     if( IsCellXF() && !mpStyleSheet )
1161     {
1162         mpStyleSheet = GetXFBuffer().CreateStyleSheet( mnParent );
1163         if( XclImpXF* pParentXF = GetXFBuffer().GetXF( mnParent ) )
1164             UpdateUsedFlags( *pParentXF );
1165     }
1166
1167     // cell protection
1168     if( mbProtUsed )
1169         maProtection.FillToItemSet( rItemSet, bSkipPoolDefs );
1170
1171     // font
1172     if( mbFontUsed )
1173         GetFontBuffer().FillToItemSet( rItemSet, EXC_FONTITEM_CELL, mnXclFont, bSkipPoolDefs );
1174
1175     // value format
1176     if( mbFmtUsed )
1177     {
1178         GetNumFmtBuffer().FillToItemSet( rItemSet, mnXclNumFmt, bSkipPoolDefs );
1179         // Trace occurrences of Windows date formats
1180         GetTracer().TraceDates( mnXclNumFmt );
1181     }
1182
1183     // alignment
1184     if( mbAlignUsed )
1185         maAlignment.FillToItemSet( rItemSet, GetFontBuffer().GetFont( mnXclFont ), bSkipPoolDefs );
1186
1187     // border
1188     if( mbBorderUsed )
1189     {
1190         maBorder.FillToItemSet( rItemSet, GetPalette(), bSkipPoolDefs );
1191         GetTracer().TraceBorderLineStyle(maBorder.mnLeftLine > EXC_LINE_HAIR ||
1192             maBorder.mnRightLine > EXC_LINE_HAIR || maBorder.mnTopLine > EXC_LINE_HAIR ||
1193             maBorder.mnBottomLine > EXC_LINE_HAIR );
1194     }
1195
1196     // area
1197     if( mbAreaUsed )
1198     {
1199         maArea.FillToItemSet( rItemSet, GetPalette(), bSkipPoolDefs );
1200         GetTracer().TraceFillPattern(maArea.mnPattern != EXC_PATT_NONE &&
1201             maArea.mnPattern != EXC_PATT_SOLID);
1202     }
1203
1204     return *mpPattern;
1205 }
1206
1207 void XclImpXF::ApplyPattern(
1208         SCCOL nScCol1, SCROW nScRow1, SCCOL nScCol2, SCROW nScRow2,
1209         SCTAB nScTab, ULONG nForceScNumFmt )
1210 {
1211     // force creation of cell style and hard formatting, do it here to have mpStyleSheet
1212     const ScPatternAttr& rPattern = CreatePattern();
1213
1214     // insert into document
1215     ScDocument& rDoc = GetDoc();
1216     if( IsCellXF() && mpStyleSheet )
1217         rDoc.ApplyStyleAreaTab( nScCol1, nScRow1, nScCol2, nScRow2, nScTab, *mpStyleSheet );
1218     if( HasUsedFlags() )
1219         rDoc.ApplyPatternAreaTab( nScCol1, nScRow1, nScCol2, nScRow2, nScTab, rPattern );
1220
1221     // #108770# apply special number format
1222     if( nForceScNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND )
1223     {
1224         ScPatternAttr aPattern( GetDoc().GetPool() );
1225         GetNumFmtBuffer().FillScFmtToItemSet( aPattern.GetItemSet(), nForceScNumFmt );
1226         rDoc.ApplyPatternAreaTab( nScCol1, nScRow1, nScCol2, nScRow2, nScTab, aPattern );
1227     }
1228 }
1229
1230 void XclImpXF::SetUsedFlags( sal_uInt8 nUsedFlags )
1231 {
1232     /*  Notes about finding the mb***Used flags:
1233         - In cell XFs a *set* bit means a used attribute.
1234         - In style XFs a *cleared* bit means a used attribute.
1235         The mb***Used members always store true, if the attribute is used.
1236         The "mbCellXF == ::get_flag(...)" construct evaluates to true in
1237         both mentioned cases: cell XF and set bit; or style XF and cleared bit.
1238      */
1239     mbProtUsed   = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_PROT ));
1240     mbFontUsed   = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_FONT ));
1241     mbFmtUsed    = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_VALFMT ));
1242     mbAlignUsed  = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_ALIGN ));
1243     mbBorderUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_BORDER ));
1244     mbAreaUsed   = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_AREA ));
1245 }
1246
1247 void XclImpXF::UpdateUsedFlags( const XclImpXF& rParentXF )
1248 {
1249     /*  Enables mb***Used flags, if the formatting attributes differ from
1250         the passed XF record. In cell XFs Excel uses the cell attributes,
1251         if they differ from the parent style XF.
1252         #109899# ...or if the respective flag is not set in parent style XF. */
1253     if( !mbProtUsed )
1254         mbProtUsed = !rParentXF.mbProtUsed || !(maProtection == rParentXF.maProtection);
1255     if( !mbFontUsed )
1256         mbFontUsed = !rParentXF.mbFontUsed || (mnXclFont != rParentXF.mnXclFont);
1257     if( !mbFmtUsed )
1258         mbFmtUsed = !rParentXF.mbFmtUsed || (mnXclNumFmt != rParentXF.mnXclNumFmt);
1259     if( !mbAlignUsed )
1260         mbAlignUsed = !rParentXF.mbAlignUsed || !(maAlignment == rParentXF.maAlignment);
1261     if( !mbBorderUsed )
1262         mbBorderUsed = !rParentXF.mbBorderUsed || !(maBorder == rParentXF.maBorder);
1263     if( !mbAreaUsed )
1264         mbAreaUsed = !rParentXF.mbAreaUsed || !(maArea == rParentXF.maArea);
1265 }
1266
1267 // ----------------------------------------------------------------------------
1268
1269 XclImpStyle::XclImpStyle( const XclImpRoot& rRoot ) :
1270     XclImpRoot( rRoot ),
1271     mnXfId( EXC_XF_NOTFOUND ),
1272     mnBuiltinId( EXC_STYLE_USERDEF ),
1273     mnLevel( EXC_STYLE_NOLEVEL ),
1274     mbBuiltin( false ),
1275     mbCustom( false ),
1276     mbHidden( false ),
1277     mpStyleSheet( 0 )
1278 {
1279 }
1280
1281 void XclImpStyle::ReadStyle( XclImpStream& rStrm )
1282 {
1283     DBG_ASSERT_BIFF( GetBiff() >= EXC_BIFF3 );
1284
1285     sal_uInt16 nXFIndex;
1286     rStrm >> nXFIndex;
1287     mnXfId = nXFIndex & EXC_STYLE_XFMASK;
1288     mbBuiltin = ::get_flag( nXFIndex, EXC_STYLE_BUILTIN );
1289
1290     if( mbBuiltin )
1291     {
1292         rStrm >> mnBuiltinId >> mnLevel;
1293     }
1294     else
1295     {
1296         maName = (GetBiff() <= EXC_BIFF5) ? rStrm.ReadByteString( false ) : rStrm.ReadUniString();
1297         // #i103281# check if this is a new built-in style introduced in XL2007
1298         if( (GetBiff() == EXC_BIFF8) && (rStrm.GetNextRecId() == EXC_ID_STYLEEXT) && rStrm.StartNextRecord() )
1299         {
1300             sal_uInt8 nExtFlags;
1301             rStrm.Ignore( 12 );
1302             rStrm >> nExtFlags;
1303             mbBuiltin = ::get_flag( nExtFlags, EXC_STYLEEXT_BUILTIN );
1304             mbCustom = ::get_flag( nExtFlags, EXC_STYLEEXT_CUSTOM );
1305             mbHidden = ::get_flag( nExtFlags, EXC_STYLEEXT_HIDDEN );
1306             if( mbBuiltin )
1307             {
1308                 rStrm.Ignore( 1 );  // category
1309                 rStrm >> mnBuiltinId >> mnLevel;
1310             }
1311         }
1312     }
1313 }
1314
1315 ScStyleSheet* XclImpStyle::CreateStyleSheet()
1316 {
1317     // #i1624# #i1768# ignore unnamed user styles
1318     if( !mpStyleSheet && (maFinalName.Len() > 0) )
1319     {
1320         bool bCreatePattern = false;
1321         XclImpXF* pXF = GetXFBuffer().GetXF( mnXfId );
1322
1323         bool bDefStyle = mbBuiltin && (mnBuiltinId == EXC_STYLE_NORMAL);
1324         if( bDefStyle )
1325         {
1326             // set all flags to true to get all items in XclImpXF::CreatePattern()
1327             if( pXF ) pXF->SetAllUsedFlags( true );
1328             // use existing "Default" style sheet
1329             mpStyleSheet = static_cast< ScStyleSheet* >( GetStyleSheetPool().Find(
1330                 ScGlobal::GetRscString( STR_STYLENAME_STANDARD ), SFX_STYLE_FAMILY_PARA ) );
1331             DBG_ASSERT( mpStyleSheet, "XclImpStyle::CreateStyleSheet - Default style not found" );
1332             bCreatePattern = true;
1333         }
1334         else
1335         {
1336             /*  #i103281# do not create another style sheet of the same name,
1337                 if it exists already. This is needed to prevent that styles
1338                 pasted from clipboard get duplicated over and over. */
1339             mpStyleSheet = static_cast< ScStyleSheet* >( GetStyleSheetPool().Find( maFinalName, SFX_STYLE_FAMILY_PARA ) );
1340             if( !mpStyleSheet )
1341             {
1342                 mpStyleSheet = &static_cast< ScStyleSheet& >( GetStyleSheetPool().Make( maFinalName, SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_USERDEF ) );
1343                 bCreatePattern = true;
1344             }
1345         }
1346
1347         // bDefStyle==true omits default pool items in CreatePattern()
1348         if( bCreatePattern && mpStyleSheet && pXF )
1349             mpStyleSheet->GetItemSet().Put( pXF->CreatePattern( bDefStyle ).GetItemSet() );
1350     }
1351     return mpStyleSheet;
1352 }
1353
1354 void XclImpStyle::CreateUserStyle( const String& rFinalName )
1355 {
1356     maFinalName = rFinalName;
1357     if( !IsBuiltin() || mbCustom )
1358         CreateStyleSheet();
1359 }
1360
1361 // ----------------------------------------------------------------------------
1362
1363 XclImpXFBuffer::XclImpXFBuffer( const XclImpRoot& rRoot ) :
1364     XclImpRoot( rRoot )
1365 {
1366 }
1367
1368 void XclImpXFBuffer::Initialize()
1369 {
1370     maXFList.Clear();
1371     maBuiltinStyles.Clear();
1372     maUserStyles.Clear();
1373     maStylesByXf.clear();
1374 }
1375
1376 void XclImpXFBuffer::ReadXF( XclImpStream& rStrm )
1377 {
1378     XclImpXF* pXF = new XclImpXF( GetRoot() );
1379     pXF->ReadXF( rStrm );
1380     maXFList.Append( pXF );
1381 }
1382
1383 void XclImpXFBuffer::ReadStyle( XclImpStream& rStrm )
1384 {
1385     XclImpStyle* pStyle = new XclImpStyle( GetRoot() );
1386     pStyle->ReadStyle( rStrm );
1387     (pStyle->IsBuiltin() ? maBuiltinStyles : maUserStyles).Append( pStyle );
1388     DBG_ASSERT( maStylesByXf.count( pStyle->GetXfId() ) == 0, "XclImpXFBuffer::ReadStyle - multiple styles with equal XF identifier" );
1389     maStylesByXf[ pStyle->GetXfId() ] = pStyle;
1390 }
1391
1392 sal_uInt16 XclImpXFBuffer::GetFontIndex( sal_uInt16 nXFIndex ) const
1393 {
1394     const XclImpXF* pXF = GetXF( nXFIndex );
1395     return pXF ? pXF->GetFontIndex() : EXC_FONT_NOTFOUND;
1396 }
1397
1398 const XclImpFont* XclImpXFBuffer::GetFont( sal_uInt16 nXFIndex ) const
1399 {
1400     return GetFontBuffer().GetFont( GetFontIndex( nXFIndex ) );
1401 }
1402
1403 namespace {
1404
1405 /** Functor for case-insensitive string comparison, usable in maps etc. */
1406 struct IgnoreCaseCompare
1407 {
1408     inline bool operator()( const String& rName1, const String& rName2 ) const
1409         { return rName1.CompareIgnoreCaseToAscii( rName2 ) == COMPARE_LESS; }
1410 };
1411
1412 } // namespace
1413
1414 void XclImpXFBuffer::CreateUserStyles()
1415 {
1416     // calculate final names of all styles
1417     typedef ::std::map< String, XclImpStyle*, IgnoreCaseCompare > CellStyleNameMap;
1418     typedef ::std::vector< XclImpStyle* > XclImpStyleVector;
1419
1420     CellStyleNameMap aCellStyles;
1421     XclImpStyleVector aConflictNameStyles;
1422
1423     /*  First, reserve style names that are built-in in Calc. This causes that
1424         imported cell styles get different unused names and thus do not try to
1425         overwrite these built-in styles. For BIFF4 workbooks (which contain a
1426         separate list of cell styles per sheet), reserve all existing styles if
1427         current sheet is not the first sheet (this styles buffer will be
1428         initialized again for every new sheet). This will create unique names
1429         for styles in different sheets with the same name. Assuming that the
1430         BIFF4W import filter is never used to import from clipboard... */
1431     bool bReserveAll = (GetBiff() == EXC_BIFF4) && (GetCurrScTab() > 0);
1432     SfxStyleSheetIterator aStyleIter( GetDoc().GetStyleSheetPool(), SFX_STYLE_FAMILY_PARA );
1433     String aStandardName = ScGlobal::GetRscString( STR_STYLENAME_STANDARD );
1434     for( SfxStyleSheetBase* pStyleSheet = aStyleIter.First(); pStyleSheet; pStyleSheet = aStyleIter.Next() )
1435         if( (pStyleSheet->GetName() != aStandardName) && (bReserveAll || !pStyleSheet->IsUserDefined()) )
1436             if( aCellStyles.count( pStyleSheet->GetName() ) == 0 )
1437                 aCellStyles[ pStyleSheet->GetName() ] = 0;
1438
1439     /*  Calculate names of built-in styles. Store styles with reserved names
1440         in the aConflictNameStyles list. */
1441     for( XclImpStyle* pStyle = maBuiltinStyles.First(); pStyle; pStyle = maBuiltinStyles.Next() )
1442     {
1443         String aStyleName = XclTools::GetBuiltInStyleName( pStyle->GetBuiltinId(), pStyle->GetName(), pStyle->GetLevel() );
1444         DBG_ASSERT( bReserveAll || (aCellStyles.count( aStyleName ) == 0),
1445             "XclImpXFBuffer::CreateUserStyles - multiple styles with equal built-in identifier" );
1446         if( aCellStyles.count( aStyleName ) > 0 )
1447             aConflictNameStyles.push_back( pStyle );
1448         else
1449             aCellStyles[ aStyleName ] = pStyle;
1450     }
1451
1452     /*  Calculate names of user defined styles. Store styles with reserved
1453         names in the aConflictNameStyles list. */
1454     for( XclImpStyle* pStyle = maUserStyles.First(); pStyle; pStyle = maUserStyles.Next() )
1455     {
1456         // #i1624# #i1768# ignore unnamed user styles
1457         if( pStyle->GetName().Len() > 0 )
1458         {
1459             if( aCellStyles.count( pStyle->GetName() ) > 0 )
1460                 aConflictNameStyles.push_back( pStyle );
1461             else
1462                 aCellStyles[ pStyle->GetName() ] = pStyle;
1463         }
1464     }
1465
1466     // find unused names for all styles with conflicting names
1467     for( XclImpStyleVector::iterator aIt = aConflictNameStyles.begin(), aEnd = aConflictNameStyles.end(); aIt != aEnd; ++aIt )
1468     {
1469         XclImpStyle* pStyle = *aIt;
1470         String aUnusedName;
1471         sal_Int32 nIndex = 0;
1472         do
1473         {
1474             aUnusedName.Assign( pStyle->GetName() ).Append( ' ' ).Append( String::CreateFromInt32( ++nIndex ) );
1475         }
1476         while( aCellStyles.count( aUnusedName ) > 0 );
1477         aCellStyles[ aUnusedName ] = pStyle;
1478     }
1479
1480     // set final names and create user-defined and modified built-in cell styles
1481     for( CellStyleNameMap::iterator aIt = aCellStyles.begin(), aEnd = aCellStyles.end(); aIt != aEnd; ++aIt )
1482         if( aIt->second )
1483             aIt->second->CreateUserStyle( aIt->first );
1484 }
1485
1486 ScStyleSheet* XclImpXFBuffer::CreateStyleSheet( sal_uInt16 nXFIndex )
1487 {
1488     XclImpStyleMap::iterator aIt = maStylesByXf.find( nXFIndex );
1489     return (aIt == maStylesByXf.end()) ? 0 : aIt->second->CreateStyleSheet();
1490 }
1491
1492 void XclImpXFBuffer::ApplyPattern(
1493         SCCOL nScCol1, SCROW nScRow1, SCCOL nScCol2, SCROW nScRow2,
1494         SCTAB nScTab, const XclImpXFIndex& rXFIndex )
1495 {
1496     if( XclImpXF* pXF = GetXF( rXFIndex.GetXFIndex() ) )
1497     {
1498         // #108770# set 'Standard' number format for all Boolean cells
1499         ULONG nForceScNumFmt = rXFIndex.IsBoolCell() ? GetNumFmtBuffer().GetStdScNumFmt() : NUMBERFORMAT_ENTRY_NOT_FOUND;
1500         pXF->ApplyPattern( nScCol1, nScRow1, nScCol2, nScRow2, nScTab, nForceScNumFmt );
1501     }
1502 }
1503
1504 // Buffer for XF indexes in cells =============================================
1505
1506 IMPL_FIXEDMEMPOOL_NEWDEL( XclImpXFRange, 100, 500 )
1507
1508 bool XclImpXFRange::Expand( SCROW nScRow, const XclImpXFIndex& rXFIndex )
1509 {
1510     if( maXFIndex != rXFIndex )
1511         return false;
1512
1513     if( mnScRow2 + 1 == nScRow )
1514     {
1515         ++mnScRow2;
1516         return true;
1517     }
1518     if( mnScRow1 > 0 && (mnScRow1 - 1 == nScRow) )
1519     {
1520         --mnScRow1;
1521         return true;
1522     }
1523
1524     return false;
1525 }
1526
1527 bool XclImpXFRange::Expand( const XclImpXFRange& rNextRange )
1528 {
1529     DBG_ASSERT( mnScRow2 < rNextRange.mnScRow1, "XclImpXFRange::Expand - rows out of order" );
1530     if( (maXFIndex == rNextRange.maXFIndex) && (mnScRow2 + 1 == rNextRange.mnScRow1) )
1531     {
1532         mnScRow2 = rNextRange.mnScRow2;
1533         return true;
1534     }
1535     return false;
1536 }
1537
1538 // ----------------------------------------------------------------------------
1539
1540 void XclImpXFRangeColumn::SetDefaultXF( const XclImpXFIndex& rXFIndex )
1541 {
1542     // List should be empty when inserting the default column format.
1543     // Later explicit SetXF() calls will break up this range.
1544     DBG_ASSERT( maIndexList.Empty(), "XclImpXFRangeColumn::SetDefaultXF - Setting Default Column XF is not empty" );
1545
1546     // insert a complete row range with one insert.
1547     maIndexList.Append( new XclImpXFRange( 0, MAXROW, rXFIndex ) );
1548 }
1549
1550 // ----------------------------------------------------------------------------
1551
1552 void XclImpXFRangeColumn::SetXF( SCROW nScRow, const XclImpXFIndex& rXFIndex )
1553 {
1554     XclImpXFRange* pPrevRange;
1555     XclImpXFRange* pNextRange;
1556     ULONG nNextIndex;
1557
1558     Find( pPrevRange, pNextRange, nNextIndex, nScRow );
1559
1560     // previous range:
1561     // try to overwrite XF (if row is contained in) or try to expand range
1562     if( pPrevRange )
1563     {
1564         if( pPrevRange->Contains( nScRow ) )        // overwrite old XF
1565         {
1566             if( rXFIndex == pPrevRange->maXFIndex )
1567                 return;
1568
1569             SCROW nFirstScRow = pPrevRange->mnScRow1;
1570             SCROW nLastScRow = pPrevRange->mnScRow2;
1571             ULONG nIndex = nNextIndex - 1;
1572             XclImpXFRange* pThisRange = pPrevRange;
1573             pPrevRange = nIndex ? maIndexList.GetObject( nIndex - 1 ) : 0;
1574
1575             if( nFirstScRow == nLastScRow )         // replace solely XF
1576             {
1577                 pThisRange->maXFIndex = rXFIndex;
1578                 TryConcatPrev( nNextIndex );        // try to concat. next with this
1579                 TryConcatPrev( nIndex );            // try to concat. this with previous
1580             }
1581             else if( nFirstScRow == nScRow )        // replace first XF
1582             {
1583                 ++(pThisRange->mnScRow1);
1584                 // try to concatenate with previous of this
1585                 if( !pPrevRange || !pPrevRange->Expand( nScRow, rXFIndex ) )
1586                     maIndexList.Insert( new XclImpXFRange( nScRow, rXFIndex ), nIndex );
1587             }
1588             else if( nLastScRow == nScRow )         // replace last XF
1589             {
1590                 --(pThisRange->mnScRow2);
1591                 if( !pNextRange || !pNextRange->Expand( nScRow, rXFIndex ) )
1592                     maIndexList.Insert( new XclImpXFRange( nScRow, rXFIndex ), nNextIndex );
1593             }
1594             else                                    // insert in the middle of the range
1595             {
1596                 pThisRange->mnScRow1 = nScRow + 1;
1597                 // List::Insert() moves entries towards end of list, so insert twice at nIndex
1598                 maIndexList.Insert( new XclImpXFRange( nScRow, rXFIndex ), nIndex );
1599                 maIndexList.Insert( new XclImpXFRange( nFirstScRow, nScRow - 1, pThisRange->maXFIndex ), nIndex );
1600             }
1601             return;
1602         }
1603         else if( pPrevRange->Expand( nScRow, rXFIndex ) )    // try to expand
1604         {
1605             TryConcatPrev( nNextIndex );    // try to concatenate next with expanded
1606             return;
1607         }
1608     }
1609
1610     // try to expand next range
1611     if( pNextRange && pNextRange->Expand( nScRow, rXFIndex ) )
1612         return;
1613
1614     // create new range
1615     maIndexList.Insert( new XclImpXFRange( nScRow, rXFIndex ), nNextIndex );
1616 }
1617
1618 void XclImpXFRangeColumn::Find(
1619         XclImpXFRange*& rpPrevRange, XclImpXFRange*& rpNextRange,
1620         ULONG& rnNextIndex, SCROW nScRow ) const
1621 {
1622
1623     // test whether list is empty
1624     if( maIndexList.Empty() )
1625     {
1626         rpPrevRange = rpNextRange = 0;
1627         rnNextIndex = 0;
1628         return;
1629     }
1630
1631     rpPrevRange = maIndexList.GetObject( 0 );
1632     rpNextRange = maIndexList.GetObject( maIndexList.Count() - 1 );
1633
1634     // test whether row is at end of list (contained in or behind last range)
1635     // rpPrevRange will contain a possible existing row
1636     if( rpNextRange->mnScRow1 <= nScRow )
1637     {
1638         rpPrevRange = rpNextRange;
1639         rpNextRange = 0;
1640         rnNextIndex = maIndexList.Count();
1641         return;
1642     }
1643
1644     // test whether row is at beginning of list (really before first range)
1645     if( nScRow < rpPrevRange->mnScRow1 )
1646     {
1647         rpNextRange = rpPrevRange;
1648         rpPrevRange = 0;
1649         rnNextIndex = 0;
1650         return;
1651     }
1652
1653     // loop: find range entries before and after new row
1654     // break the loop if there is no more range between first and last -or-
1655     // if rpPrevRange contains nScRow (rpNextRange will never contain nScRow)
1656     ULONG nPrevIndex = 0;
1657     ULONG nMidIndex;
1658     rnNextIndex = maIndexList.Count() - 1;
1659     XclImpXFRange* pMidRange;
1660     while( ((rnNextIndex - nPrevIndex) > 1) && (rpPrevRange->mnScRow2 < nScRow) )
1661     {
1662         nMidIndex = (nPrevIndex + rnNextIndex) / 2;
1663         pMidRange = maIndexList.GetObject( nMidIndex );
1664         DBG_ASSERT( pMidRange, "XclImpXFRangeColumn::Find - missing XF index range" );
1665         if( nScRow < pMidRange->mnScRow1 )      // row is really before pMidRange
1666         {
1667             rpNextRange = pMidRange;
1668             rnNextIndex = nMidIndex;
1669         }
1670         else                                    // row is in or after pMidRange
1671         {
1672             rpPrevRange = pMidRange;
1673             nPrevIndex = nMidIndex;
1674         }
1675     }
1676
1677     // find next rpNextRange if rpPrevRange contains nScRow
1678     if( nScRow <= rpPrevRange->mnScRow2 )
1679     {
1680         rnNextIndex = nPrevIndex + 1;
1681         rpNextRange = maIndexList.GetObject( rnNextIndex );
1682     }
1683 }
1684
1685 void XclImpXFRangeColumn::TryConcatPrev( ULONG nIndex )
1686 {
1687     if( !nIndex )
1688         return;
1689
1690     XclImpXFRange* pPrevRange = maIndexList.GetObject( nIndex - 1 );
1691     XclImpXFRange* pNextRange = maIndexList.GetObject( nIndex );
1692     if( !pPrevRange || !pNextRange )
1693         return;
1694
1695     if( pPrevRange->Expand( *pNextRange ) )
1696         maIndexList.Delete( nIndex );
1697 }
1698
1699 // ----------------------------------------------------------------------------
1700
1701 XclImpXFRangeBuffer::XclImpXFRangeBuffer( const XclImpRoot& rRoot ) :
1702     XclImpRoot( rRoot )
1703 {
1704 }
1705
1706 XclImpXFRangeBuffer::~XclImpXFRangeBuffer()
1707 {
1708 }
1709
1710 void XclImpXFRangeBuffer::Initialize()
1711 {
1712     maColumns.clear();
1713     maHyperlinks.clear();
1714     maMergeList.RemoveAll();
1715 }
1716
1717 void XclImpXFRangeBuffer::SetXF( const ScAddress& rScPos, sal_uInt16 nXFIndex, XclImpXFInsertMode eMode )
1718 {
1719     SCCOL nScCol = rScPos.Col();
1720     SCROW nScRow = rScPos.Row();
1721
1722     // set cell XF's
1723     size_t nIndex = static_cast< size_t >( nScCol );
1724     if( maColumns.size() <= nIndex )
1725         maColumns.resize( nIndex + 1 );
1726     if( !maColumns[ nIndex ] )
1727         maColumns[ nIndex ].reset( new XclImpXFRangeColumn );
1728     // #108770# remember all Boolean cells, they will get 'Standard' number format
1729     maColumns[ nIndex ]->SetXF( nScRow, XclImpXFIndex( nXFIndex, eMode == xlXFModeBoolCell ) );
1730
1731     // set "center across selection" and "fill" attribute for all following empty cells
1732     // #97130# ignore it on row default XFs
1733     if( eMode != xlXFModeRow )
1734     {
1735         const XclImpXF* pXF = GetXFBuffer().GetXF( nXFIndex );
1736         if( pXF && ((pXF->GetHorAlign() == EXC_XF_HOR_CENTER_AS) || (pXF->GetHorAlign() == EXC_XF_HOR_FILL)) )
1737         {
1738             // expand last merged range if this attribute is set repeatedly
1739             ScRange* pRange = maMergeList.Last();
1740             if( pRange && (pRange->aEnd.Row() == nScRow) && (pRange->aEnd.Col() + 1 == nScCol)
1741                     && (eMode == xlXFModeBlank) )
1742                 pRange->aEnd.IncCol();
1743             else if( eMode != xlXFModeBlank )   // #108781# do not merge empty cells
1744                 SetMerge( nScCol, nScRow );
1745         }
1746     }
1747 }
1748
1749 void XclImpXFRangeBuffer::SetXF( const ScAddress& rScPos, sal_uInt16 nXFIndex )
1750 {
1751     SetXF( rScPos, nXFIndex, xlXFModeCell );
1752 }
1753
1754 void XclImpXFRangeBuffer::SetBlankXF( const ScAddress& rScPos, sal_uInt16 nXFIndex )
1755 {
1756     SetXF( rScPos, nXFIndex, xlXFModeBlank );
1757 }
1758
1759 void XclImpXFRangeBuffer::SetBoolXF( const ScAddress& rScPos, sal_uInt16 nXFIndex )
1760 {
1761     SetXF( rScPos, nXFIndex, xlXFModeBoolCell );
1762 }
1763
1764 void XclImpXFRangeBuffer::SetRowDefXF( SCROW nScRow, sal_uInt16 nXFIndex )
1765 {
1766     for( SCCOL nScCol = 0; nScCol <= MAXCOL; ++nScCol )
1767         SetXF( ScAddress( nScCol, nScRow, 0 ), nXFIndex, xlXFModeRow );
1768 }
1769
1770 void XclImpXFRangeBuffer::SetColumnDefXF( SCCOL nScCol, sal_uInt16 nXFIndex )
1771 {
1772     // our array should not have values when creating the default column format.
1773     size_t nIndex = static_cast< size_t >( nScCol );
1774     if( maColumns.size() <= nIndex )
1775         maColumns.resize( nIndex + 1 );
1776     DBG_ASSERT( !maColumns[ nIndex ], "XclImpXFRangeBuffer::SetColumnDefXF - default column of XFs already has values" );
1777     maColumns[ nIndex ].reset( new XclImpXFRangeColumn );
1778     maColumns[ nIndex ]->SetDefaultXF( XclImpXFIndex( nXFIndex ) );
1779 }
1780
1781 void XclImpXFRangeBuffer::SetBorderLine( const ScRange& rRange, SCTAB nScTab, USHORT nLine )
1782 {
1783     SCCOL nFromScCol = (nLine == BOX_LINE_RIGHT) ? rRange.aEnd.Col() : rRange.aStart.Col();
1784     SCROW nFromScRow = (nLine == BOX_LINE_BOTTOM) ? rRange.aEnd.Row() : rRange.aStart.Row();
1785     ScDocument& rDoc = GetDoc();
1786
1787     const SvxBoxItem* pFromItem = static_cast< const SvxBoxItem* >(
1788         rDoc.GetAttr( nFromScCol, nFromScRow, nScTab, ATTR_BORDER ) );
1789     const SvxBoxItem* pToItem = static_cast< const SvxBoxItem* >(
1790         rDoc.GetAttr( rRange.aStart.Col(), rRange.aStart.Row(), nScTab, ATTR_BORDER ) );
1791
1792     SvxBoxItem aNewItem( *pToItem );
1793     aNewItem.SetLine( pFromItem->GetLine( nLine ), nLine );
1794     rDoc.ApplyAttr( rRange.aStart.Col(), rRange.aStart.Row(), nScTab, aNewItem );
1795 }
1796
1797 void XclImpXFRangeBuffer::SetHyperlink( const XclRange& rXclRange, const String& rUrl )
1798 {
1799     maHyperlinks.push_back( XclImpHyperlinkRange( rXclRange, rUrl ) );
1800 }
1801
1802 void XclImpXFRangeBuffer::SetMerge( SCCOL nScCol, SCROW nScRow )
1803 {
1804     maMergeList.Append( ScRange( nScCol, nScRow, 0 ) );
1805 }
1806
1807 void XclImpXFRangeBuffer::SetMerge( SCCOL nScCol1, SCROW nScRow1, SCCOL nScCol2, SCROW nScRow2 )
1808 {
1809     if( (nScCol1 < nScCol2) || (nScRow1 < nScRow2) )
1810         maMergeList.Append( ScRange( nScCol1, nScRow1, 0, nScCol2, nScRow2, 0 ) );
1811 }
1812
1813 void XclImpXFRangeBuffer::Finalize()
1814 {
1815     ScDocument& rDoc = GetDoc();
1816     SCTAB nScTab = GetCurrScTab();
1817
1818     // apply patterns
1819     XclImpXFBuffer& rXFBuffer = GetXFBuffer();
1820     for( XclImpXFRangeColumnVec::const_iterator aVBeg = maColumns.begin(), aVEnd = maColumns.end(), aVIt = aVBeg; aVIt != aVEnd; ++aVIt )
1821     {
1822         // apply all cell styles of an existing column
1823         if( aVIt->is() )
1824         {
1825             XclImpXFRangeColumn& rColumn = **aVIt;
1826             SCCOL nScCol = static_cast< SCCOL >( aVIt - aVBeg );
1827             for( XclImpXFRange* pStyle = rColumn.First(); pStyle; pStyle = rColumn.Next() )
1828                 rXFBuffer.ApplyPattern( nScCol, pStyle->mnScRow1, nScCol, pStyle->mnScRow2, nScTab, pStyle->maXFIndex );
1829         }
1830     }
1831
1832     // insert hyperlink cells
1833     for( XclImpHyperlinkList::const_iterator aLIt = maHyperlinks.begin(), aLEnd = maHyperlinks.end(); aLIt != aLEnd; ++aLIt )
1834         XclImpHyperlink::InsertUrl( GetRoot(), aLIt->first, aLIt->second );
1835
1836     // apply cell merging
1837     for( const ScRange* pRange = maMergeList.First(); pRange; pRange = maMergeList.Next() )
1838     {
1839         const ScAddress& rStart = pRange->aStart;
1840         const ScAddress& rEnd = pRange->aEnd;
1841         bool bMultiCol = rStart.Col() != rEnd.Col();
1842         bool bMultiRow = rStart.Row() != rEnd.Row();
1843         // set correct right border
1844         if( bMultiCol )
1845             SetBorderLine( *pRange, nScTab, BOX_LINE_RIGHT );
1846         // set correct lower border
1847         if( bMultiRow )
1848             SetBorderLine( *pRange, nScTab, BOX_LINE_BOTTOM );
1849         // do merge
1850         if( bMultiCol || bMultiRow )
1851             rDoc.DoMerge( nScTab, rStart.Col(), rStart.Row(), rEnd.Col(), rEnd.Row() );
1852         // #i93609# merged range in a single row: test if manual row height is needed
1853         if( !bMultiRow )
1854         {
1855             bool bTextWrap = static_cast< const SfxBoolItem* >( rDoc.GetAttr( rStart.Col(), rStart.Row(), rStart.Tab(), ATTR_LINEBREAK ) )->GetValue();
1856             if( !bTextWrap && (rDoc.GetCellType( rStart ) == CELLTYPE_EDIT) )
1857                 if( const EditTextObject* pEditObj = static_cast< const ScEditCell* >( rDoc.GetCell( rStart ) )->GetData() )
1858                     bTextWrap = pEditObj->GetParagraphCount() > 1;
1859             if( bTextWrap )
1860                 GetOldRoot().pColRowBuff->SetManualRowHeight( rStart.Row() );
1861         }
1862     }
1863 }
1864
1865 // ============================================================================
1866