sc/source/filter/excel/xehelper.cxx

   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 #include <com/sun/star/i18n/XBreakIterator.hpp>
  21 #include <com/sun/star/i18n/ScriptType.hpp>
  22 #include <sfx2/objsh.hxx>
  23 #include <vcl/font.hxx>
  24 #include <tools/urlobj.hxx>
  25 #include <svl/itemset.hxx>
  26 #include <svtools/ctrltool.hxx>
  27 #include <svx/svdotext.hxx>
  28 #include <editeng/outlobj.hxx>
  29 #include "scitems.hxx"
  30 #include <editeng/fhgtitem.hxx>
  31 #include <editeng/flstitem.hxx>
  32 #include <editeng/colritem.hxx>
  33 #include <editeng/eeitem.hxx>
  34 #include <editeng/flditem.hxx>
  35 #include <editeng/escapementitem.hxx>
  36 #include <editeng/svxfont.hxx>
  37
  38 #include "document.hxx"
  39 #include "docpool.hxx"
  40 #include "formulacell.hxx"
  41 #include "editutil.hxx"
  42 #include "patattr.hxx"
  43 #include "xestyle.hxx"
  44 #include "fprogressbar.hxx"
  45 #include "xltracer.hxx"
  46 #include "xecontent.hxx"
  47 #include "xelink.hxx"
  48 #include "xehelper.hxx"
  49
  50 using ::com::sun::star::uno::Reference;
  51 using ::com::sun::star::i18n::XBreakIterator;
  52
  53 // Export progress bar ========================================================
  54
  55 XclExpProgressBar::XclExpProgressBar( const XclExpRoot& rRoot ) :
  56     XclExpRoot( rRoot ),
  57     mxProgress( new ScfProgressBar( rRoot.GetDocShell(), STR_SAVE_DOC ) ),
  58     mpSubProgress( 0 ),
  59     mpSubRowCreate( 0 ),
  60     mpSubRowFinal( 0 ),
  61     mnSegRowFinal( SCF_INV_SEGMENT ),
  62     mnRowCount( 0 )
  63 {
  64 }
  65
  66 XclExpProgressBar::~XclExpProgressBar()
  67 {
  68 }
  69
  70 void XclExpProgressBar::Initialize()
  71 {
  72     const ScDocument& rDoc = GetDoc();
  73     const XclExpTabInfo& rTabInfo = GetTabInfo();
  74     SCTAB nScTabCount = rTabInfo.GetScTabCount();
  75
  76     // *** segment: creation of ROW records *** -------------------------------
  77
  78     sal_Int32 nSegRowCreate = mxProgress->AddSegment( 2000 );
  79     mpSubRowCreate = &mxProgress->GetSegmentProgressBar( nSegRowCreate );
  80     maSubSegRowCreate.resize( nScTabCount, SCF_INV_SEGMENT );
  81
  82     for( SCTAB nScTab = 0; nScTab < nScTabCount; ++nScTab )
  83     {
  84         if( rTabInfo.IsExportTab( nScTab ) )
  85         {
  86             SCCOL nLastUsedScCol;
  87             SCROW nLastUsedScRow;
  88             rDoc.GetTableArea( nScTab, nLastUsedScCol, nLastUsedScRow );
  89             sal_Size nSegSize = static_cast< sal_Size >( nLastUsedScRow + 1 );
  90             maSubSegRowCreate[ nScTab ] = mpSubRowCreate->AddSegment( nSegSize );
  91         }
  92     }
  93
  94     // *** segment: writing all ROW records *** -------------------------------
  95
  96     mnSegRowFinal = mxProgress->AddSegment( 1000 );
  97     // sub progress bar and segment are created later in ActivateFinalRowsSegment()
  98 }
  99
 100 void XclExpProgressBar::IncRowRecordCount()
 101 {
 102     ++mnRowCount;
 103 }
 104
 105 void XclExpProgressBar::ActivateCreateRowsSegment()
 106 {
 107     OSL_ENSURE( (0 <= GetCurrScTab()) && (GetCurrScTab() < GetTabInfo().GetScTabCount()),
 108         "XclExpProgressBar::ActivateCreateRowsSegment - invalid sheet" );
 109     sal_Int32 nSeg = maSubSegRowCreate[ GetCurrScTab() ];
 110     OSL_ENSURE( nSeg != SCF_INV_SEGMENT, "XclExpProgressBar::ActivateCreateRowsSegment - invalid segment" );
 111     if( nSeg != SCF_INV_SEGMENT )
 112     {
 113         mpSubProgress = mpSubRowCreate;
 114         mpSubProgress->ActivateSegment( nSeg );
 115     }
 116     else
 117         mpSubProgress = 0;
 118 }
 119
 120 void XclExpProgressBar::ActivateFinalRowsSegment()
 121 {
 122     if( !mpSubRowFinal && (mnRowCount > 0) )
 123     {
 124         mpSubRowFinal = &mxProgress->GetSegmentProgressBar( mnSegRowFinal );
 125         mpSubRowFinal->AddSegment( mnRowCount );
 126     }
 127     mpSubProgress = mpSubRowFinal;
 128     if( mpSubProgress )
 129         mpSubProgress->Activate();
 130 }
 131
 132 void XclExpProgressBar::Progress()
 133 {
 134     if( mpSubProgress && !mpSubProgress->IsFull() )
 135         mpSubProgress->Progress();
 136 }
 137
 138 // Calc->Excel cell address/range conversion ==================================
 139
 140 namespace {
 141
 142 /** Fills the passed Excel address with the passed Calc cell coordinates without checking any limits. */
 143 inline void lclFillAddress( XclAddress& rXclPos, SCCOL nScCol, SCROW nScRow )
 144 {
 145     rXclPos.mnCol = static_cast< sal_uInt16 >( nScCol );
 146     rXclPos.mnRow = static_cast< sal_uInt32 >( nScRow );
 147 }
 148
 149 } // namespace
 150
 151 // ----------------------------------------------------------------------------
 152
 153 XclExpAddressConverter::XclExpAddressConverter( const XclExpRoot& rRoot ) :
 154     XclAddressConverterBase( rRoot.GetTracer(), rRoot.GetXclMaxPos() )
 155 {
 156 }
 157
 158 // cell address ---------------------------------------------------------------
 159
 160 bool XclExpAddressConverter::CheckAddress( const ScAddress& rScPos, bool bWarn )
 161 {
 162     // ScAddress::operator<=() doesn't do what we want here
 163     bool bValidCol = (0 <= rScPos.Col()) && (rScPos.Col() <= maMaxPos.Col());
 164     bool bValidRow = (0 <= rScPos.Row()) && (rScPos.Row() <= maMaxPos.Row());
 165     bool bValidTab = (0 <= rScPos.Tab()) && (rScPos.Tab() <= maMaxPos.Tab());
 166
 167     bool bValid = bValidCol && bValidRow && bValidTab;
 168     if( !bValid && bWarn )
 169     {
 170         mbColTrunc |= !bValidCol;
 171         mbRowTrunc |= !bValidRow;
 172         mbTabTrunc |= (rScPos.Tab() > maMaxPos.Tab());  // do not warn for deleted refs
 173         mrTracer.TraceInvalidAddress( rScPos, maMaxPos );
 174     }
 175     return bValid;
 176 }
 177
 178 bool XclExpAddressConverter::ConvertAddress( XclAddress& rXclPos,
 179         const ScAddress& rScPos, bool bWarn )
 180 {
 181     bool bValid = CheckAddress( rScPos, bWarn );
 182     if( bValid )
 183         lclFillAddress( rXclPos, rScPos.Col(), rScPos.Row() );
 184     return bValid;
 185 }
 186
 187 XclAddress XclExpAddressConverter::CreateValidAddress( const ScAddress& rScPos, bool bWarn )
 188 {
 189     XclAddress aXclPos( ScAddress::UNINITIALIZED );
 190     if( !ConvertAddress( aXclPos, rScPos, bWarn ) )
 191         lclFillAddress( aXclPos, ::std::min( rScPos.Col(), maMaxPos.Col() ), ::std::min( rScPos.Row(), maMaxPos.Row() ) );
 192     return aXclPos;
 193 }
 194
 195 // cell range -----------------------------------------------------------------
 196
 197 bool XclExpAddressConverter::CheckRange( const ScRange& rScRange, bool bWarn )
 198 {
 199     return CheckAddress( rScRange.aStart, bWarn ) && CheckAddress( rScRange.aEnd, bWarn );
 200 }
 201
 202 bool XclExpAddressConverter::ValidateRange( ScRange& rScRange, bool bWarn )
 203 {
 204     rScRange.Justify();
 205
 206     // check start position
 207     bool bValidStart = CheckAddress( rScRange.aStart, bWarn );
 208     if( bValidStart )
 209     {
 210         // check & correct end position
 211         ScAddress& rScEnd = rScRange.aEnd;
 212         if( !CheckAddress( rScEnd, bWarn ) )
 213         {
 214             rScEnd.SetCol( ::std::min( rScEnd.Col(), maMaxPos.Col() ) );
 215             rScEnd.SetRow( ::std::min( rScEnd.Row(), maMaxPos.Row() ) );
 216             rScEnd.SetTab( ::std::min( rScEnd.Tab(), maMaxPos.Tab() ) );
 217         }
 218     }
 219
 220     return bValidStart;
 221 }
 222
 223 bool XclExpAddressConverter::ConvertRange( XclRange& rXclRange,
 224         const ScRange& rScRange, bool bWarn )
 225 {
 226     // check start position
 227     bool bValidStart = CheckAddress( rScRange.aStart, bWarn );
 228     if( bValidStart )
 229     {
 230         lclFillAddress( rXclRange.maFirst, rScRange.aStart.Col(), rScRange.aStart.Row() );
 231
 232         // check & correct end position
 233         SCCOL nScCol2 = rScRange.aEnd.Col();
 234         SCROW nScRow2 = rScRange.aEnd.Row();
 235         if( !CheckAddress( rScRange.aEnd, bWarn ) )
 236         {
 237             nScCol2 = ::std::min( nScCol2, maMaxPos.Col() );
 238             nScRow2 = ::std::min( nScRow2, maMaxPos.Row() );
 239         }
 240         lclFillAddress( rXclRange.maLast, nScCol2, nScRow2 );
 241     }
 242     return bValidStart;
 243 }
 244
 245 // cell range list ------------------------------------------------------------
 246
 247 void XclExpAddressConverter::ValidateRangeList( ScRangeList& rScRanges, bool bWarn )
 248 {
 249     for ( size_t nRange = rScRanges.size(); nRange > 0; )
 250     {
 251         ScRange* pScRange = rScRanges[ --nRange ];
 252         if( !CheckRange( *pScRange, bWarn ) )
 253             delete rScRanges.Remove(nRange);
 254     }
 255 }
 256
 257 void XclExpAddressConverter::ConvertRangeList( XclRangeList& rXclRanges,
 258         const ScRangeList& rScRanges, bool bWarn )
 259 {
 260     rXclRanges.clear();
 261     for( size_t nPos = 0, nCount = rScRanges.size(); nPos < nCount; ++nPos )
 262     {
 263         if( const ScRange* pScRange = rScRanges[ nPos ] )
 264         {
 265             XclRange aXclRange( ScAddress::UNINITIALIZED );
 266             if( ConvertRange( aXclRange, *pScRange, bWarn ) )
 267                 rXclRanges.push_back( aXclRange );
 268         }
 269     }
 270 }
 271
 272 // EditEngine->String conversion ==============================================
 273
 274 namespace {
 275
 276 OUString lclGetUrlRepresentation( const SvxURLField& rUrlField )
 277 {
 278     const OUString& aRepr = rUrlField.GetRepresentation();
 279     // no representation -> use URL
 280     return aRepr.isEmpty() ? rUrlField.GetURL() : aRepr;
 281 }
 282
 283 } // namespace
 284
 285 // ----------------------------------------------------------------------------
 286
 287 XclExpHyperlinkHelper::XclExpHyperlinkHelper( const XclExpRoot& rRoot, const ScAddress& rScPos ) :
 288     XclExpRoot( rRoot ),
 289     maScPos( rScPos ),
 290     mbMultipleUrls( false )
 291 {
 292 }
 293
 294 XclExpHyperlinkHelper::~XclExpHyperlinkHelper()
 295 {
 296 }
 297
 298 OUString XclExpHyperlinkHelper::ProcessUrlField( const SvxURLField& rUrlField )
 299 {
 300     OUString aUrlRepr;
 301
 302     if( GetBiff() == EXC_BIFF8 )    // no HLINK records in BIFF2-BIFF7
 303     {
 304         // there was/is already a HLINK record
 305         mbMultipleUrls = static_cast< bool >(mxLinkRec);
 306
 307         mxLinkRec.reset( new XclExpHyperlink( GetRoot(), rUrlField, maScPos ) );
 308
 309         if( const String* pRepr = mxLinkRec->GetRepr() )
 310             aUrlRepr = *pRepr;
 311
 312         // add URL to note text
 313         maUrlList = ScGlobal::addToken( maUrlList, rUrlField.GetURL(), '\n' );
 314     }
 315
 316     // no hyperlink representation from Excel HLINK record -> use it from text field
 317     return aUrlRepr.isEmpty() ? lclGetUrlRepresentation(rUrlField) : aUrlRepr;
 318 }
 319
 320 bool XclExpHyperlinkHelper::HasLinkRecord() const
 321 {
 322     return !mbMultipleUrls && mxLinkRec;
 323 }
 324
 325 XclExpHyperlinkHelper::XclExpHyperlinkRef XclExpHyperlinkHelper::GetLinkRecord()
 326 {
 327     if( HasLinkRecord() )
 328         return mxLinkRec;
 329     return XclExpHyperlinkRef();
 330 }
 331
 332 // ----------------------------------------------------------------------------
 333
 334 namespace {
 335
 336 /** Creates a new formatted string from the passed unformatted string.
 337
 338     Creates a Unicode string or a byte string, depending on the current BIFF
 339     version contained in the passed XclExpRoot object. May create a formatted
 340     string object, if the text contains different script types.
 341
 342     @param pCellAttr
 343         Cell attributes used for font formatting.
 344     @param nFlags
 345         Modifiers for string export.
 346     @param nMaxLen
 347         The maximum number of characters to store in this string.
 348     @return
 349         The new string object.
 350  */
 351 XclExpStringRef lclCreateFormattedString(
 352         const XclExpRoot& rRoot, const String& rText, const ScPatternAttr* pCellAttr,
 353         XclStrFlags nFlags, sal_uInt16 nMaxLen )
 354 {
 355     /*  Create an empty Excel string object with correctly initialized BIFF mode,
 356         because this function only uses Append() functions that require this. */
 357     XclExpStringRef xString = XclExpStringHelper::CreateString( rRoot, EMPTY_STRING, nFlags, nMaxLen );
 358
 359     // script type handling
 360     Reference< XBreakIterator > xBreakIt = rRoot.GetDoc().GetBreakIterator();
 361     namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;
 362     // #i63255# get script type for leading weak characters
 363     sal_Int16 nLastScript = XclExpStringHelper::GetLeadingScriptType( rRoot, rText );
 364
 365     // font buffer and cell item set
 366     XclExpFontBuffer& rFontBuffer = rRoot.GetFontBuffer();
 367     const SfxItemSet& rItemSet = pCellAttr ? pCellAttr->GetItemSet() : rRoot.GetDoc().GetDefPattern()->GetItemSet();
 368
 369     // process all script portions
 370     OUString aOUText( rText );
 371     sal_Int32 nPortionPos = 0;
 372     sal_Int32 nTextLen = aOUText.getLength();
 373     while( nPortionPos < nTextLen )
 374     {
 375         // get script type and end position of next script portion
 376         sal_Int16 nScript = xBreakIt->getScriptType( aOUText, nPortionPos );
 377         sal_Int32 nPortionEnd = xBreakIt->endOfScript( aOUText, nPortionPos, nScript );
 378
 379         // reuse previous script for following weak portions
 380         if( nScript == ApiScriptType::WEAK )
 381             nScript = nLastScript;
 382
 383         // construct font from current text portion
 384         SvxFont aFont( XclExpFontHelper::GetFontFromItemSet( rRoot, rItemSet, nScript ) );
 385
 386         // Excel start position of this portion
 387         sal_uInt16 nXclPortionStart = xString->Len();
 388         // add portion text to Excel string
 389         XclExpStringHelper::AppendString( *xString, rRoot, aOUText.copy( nPortionPos, nPortionEnd - nPortionPos ) );
 390         if( nXclPortionStart < xString->Len() )
 391         {
 392             // insert font into buffer
 393             sal_uInt16 nFontIdx = rFontBuffer.Insert( aFont, EXC_COLOR_CELLTEXT );
 394             // insert font index into format run vector
 395             xString->AppendFormat( nXclPortionStart, nFontIdx );
 396         }
 397
 398         // go to next script portion
 399         nLastScript = nScript;
 400         nPortionPos = nPortionEnd;
 401     }
 402
 403     return xString;
 404 }
 405
 406 /** Creates a new formatted string from an edit engine text object.
 407
 408     Creates a Unicode string or a byte string, depending on the current BIFF
 409     version contained in the passed XclExpRoot object.
 410
 411     @param rEE
 412         The edit engine in use. The text object must already be set.
 413     @param nFlags
 414         Modifiers for string export.
 415     @param nMaxLen
 416         The maximum number of characters to store in this string.
 417     @return
 418         The new string object.
 419  */
 420 XclExpStringRef lclCreateFormattedString(
 421         const XclExpRoot& rRoot, EditEngine& rEE, XclExpHyperlinkHelper* pLinkHelper,
 422         XclStrFlags nFlags, sal_uInt16 nMaxLen )
 423 {
 424     /*  Create an empty Excel string object with correctly initialized BIFF mode,
 425         because this function only uses Append() functions that require this. */
 426     XclExpStringRef xString = XclExpStringHelper::CreateString( rRoot, EMPTY_STRING, nFlags, nMaxLen );
 427
 428     // font buffer and helper item set for edit engine -> Calc item conversion
 429     XclExpFontBuffer& rFontBuffer = rRoot.GetFontBuffer();
 430     SfxItemSet aItemSet( *rRoot.GetDoc().GetPool(), ATTR_PATTERN_START, ATTR_PATTERN_END );
 431
 432     // script type handling
 433     Reference< XBreakIterator > xBreakIt = rRoot.GetDoc().GetBreakIterator();
 434     namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;
 435     // #i63255# get script type for leading weak characters
 436     sal_Int16 nLastScript = XclExpStringHelper::GetLeadingScriptType( rRoot, rEE.GetText() );
 437
 438     // process all paragraphs
 439     sal_Int32 nParaCount = rEE.GetParagraphCount();
 440     for( sal_Int32 nPara = 0; nPara < nParaCount; ++nPara )
 441     {
 442         ESelection aSel( nPara, 0 );
 443         String aParaText( rEE.GetText( nPara ) );
 444
 445         std::vector<sal_uInt16> aPosList;
 446         rEE.GetPortions( nPara, aPosList );
 447
 448         // process all portions in the paragraph
 449         for( std::vector<sal_uInt16>::const_iterator it(aPosList.begin()); it != aPosList.end(); ++it )
 450         {
 451             aSel.nEndPos = static_cast< xub_StrLen >( *it );
 452             String aXclPortionText( aParaText, aSel.nStartPos, aSel.nEndPos - aSel.nStartPos );
 453
 454             aItemSet.ClearItem();
 455             SfxItemSet aEditSet( rEE.GetAttribs( aSel ) );
 456             ScPatternAttr::GetFromEditItemSet( aItemSet, aEditSet );
 457
 458             // get escapement value
 459             short nEsc = GETITEM( aEditSet, SvxEscapementItem, EE_CHAR_ESCAPEMENT ).GetEsc();
 460
 461             // process text fields
 462             bool bIsHyperlink = false;
 463             if( aSel.nStartPos + 1 == aSel.nEndPos )
 464             {
 465                 // test if the character is a text field
 466                 const SfxPoolItem* pItem;
 467                 if( aEditSet.GetItemState( EE_FEATURE_FIELD, false, &pItem ) == SFX_ITEM_SET )
 468                 {
 469                     const SvxFieldData* pField = static_cast< const SvxFieldItem* >( pItem )->GetField();
 470                     if( const SvxURLField* pUrlField = PTR_CAST( SvxURLField, pField ) )
 471                     {
 472                         // convert URL field to string representation
 473                         aXclPortionText = pLinkHelper ?
 474                             pLinkHelper->ProcessUrlField( *pUrlField ) :
 475                             lclGetUrlRepresentation( *pUrlField );
 476                         bIsHyperlink = true;
 477                     }
 478                     else
 479                     {
 480                         OSL_FAIL( "lclCreateFormattedString - unknown text field" );
 481                         aXclPortionText.Erase();
 482                     }
 483                 }
 484             }
 485
 486             // Excel start position of this portion
 487             sal_uInt16 nXclPortionStart = xString->Len();
 488             // add portion text to Excel string
 489             XclExpStringHelper::AppendString( *xString, rRoot, aXclPortionText );
 490             if( (nXclPortionStart < xString->Len()) || (aParaText.Len() == 0) )
 491             {
 492                 /*  Construct font from current edit engine text portion. Edit engine
 493                     creates different portions for different script types, no need to loop. */
 494                 sal_Int16 nScript = xBreakIt->getScriptType( aXclPortionText, 0 );
 495                 if( nScript == ApiScriptType::WEAK )
 496                     nScript = nLastScript;
 497                 SvxFont aFont( XclExpFontHelper::GetFontFromItemSet( rRoot, aItemSet, nScript ) );
 498                 nLastScript = nScript;
 499
 500                 // add escapement
 501                 aFont.SetEscapement( nEsc );
 502                 // modify automatic font color for hyperlinks
 503                 if( bIsHyperlink && (GETITEM( aItemSet, SvxColorItem, ATTR_FONT_COLOR ).GetValue().GetColor() == COL_AUTO) )
 504                     aFont.SetColor( Color( COL_LIGHTBLUE ) );
 505
 506                 // insert font into buffer
 507                 sal_uInt16 nFontIdx = rFontBuffer.Insert( aFont, EXC_COLOR_CELLTEXT );
 508                 // insert font index into format run vector
 509                 xString->AppendFormat( nXclPortionStart, nFontIdx );
 510             }
 511
 512             aSel.nStartPos = aSel.nEndPos;
 513         }
 514
 515         // add trailing newline (important for correct character index calculation)
 516         if( nPara + 1 < nParaCount )
 517             XclExpStringHelper::AppendChar( *xString, rRoot, '\n' );
 518     }
 519
 520     return xString;
 521 }
 522
 523 } // namespace
 524
 525 // ----------------------------------------------------------------------------
 526
 527 XclExpStringRef XclExpStringHelper::CreateString(
 528         const XclExpRoot& rRoot, const String& rString, XclStrFlags nFlags, sal_uInt16 nMaxLen )
 529 {
 530     XclExpStringRef xString( new XclExpString );
 531     if( rRoot.GetBiff() == EXC_BIFF8 )
 532         xString->Assign( rString, nFlags, nMaxLen );
 533     else
 534         xString->AssignByte( rString, rRoot.GetTextEncoding(), nFlags, nMaxLen );
 535     return xString;
 536 }
 537
 538 XclExpStringRef XclExpStringHelper::CreateString(
 539         const XclExpRoot& rRoot, sal_Unicode cChar, XclStrFlags nFlags, sal_uInt16 nMaxLen )
 540 {
 541     XclExpStringRef xString = CreateString( rRoot, EMPTY_STRING, nFlags, nMaxLen );
 542     AppendChar( *xString, rRoot, cChar );
 543     return xString;
 544 }
 545
 546 void XclExpStringHelper::AppendString( XclExpString& rXclString, const XclExpRoot& rRoot, const String& rString )
 547 {
 548     if( rRoot.GetBiff() == EXC_BIFF8 )
 549         rXclString.Append( rString );
 550     else
 551         rXclString.AppendByte( rString, rRoot.GetTextEncoding() );
 552 }
 553
 554 void XclExpStringHelper::AppendChar( XclExpString& rXclString, const XclExpRoot& rRoot, sal_Unicode cChar )
 555 {
 556     if( rRoot.GetBiff() == EXC_BIFF8 )
 557         rXclString.Append( OUString(cChar) );
 558     else
 559         rXclString.AppendByte( cChar, rRoot.GetTextEncoding() );
 560 }
 561
 562 XclExpStringRef XclExpStringHelper::CreateCellString(
 563         const XclExpRoot& rRoot, const OUString& rString, const ScPatternAttr* pCellAttr,
 564         XclStrFlags nFlags, sal_uInt16 nMaxLen )
 565 {
 566     return lclCreateFormattedString(rRoot, rString, pCellAttr, nFlags, nMaxLen);
 567 }
 568
 569 XclExpStringRef XclExpStringHelper::CreateCellString(
 570         const XclExpRoot& rRoot, const EditTextObject& rEditText, const ScPatternAttr* pCellAttr,
 571         XclExpHyperlinkHelper& rLinkHelper, XclStrFlags nFlags, sal_uInt16 nMaxLen )
 572 {
 573     XclExpStringRef xString;
 574
 575     // formatted cell
 576     ScEditEngineDefaulter& rEE = rRoot.GetEditEngine();
 577     sal_Bool bOldUpdateMode = rEE.GetUpdateMode();
 578     rEE.SetUpdateMode( sal_True );
 579
 580     // default items
 581     const SfxItemSet& rItemSet = pCellAttr ? pCellAttr->GetItemSet() : rRoot.GetDoc().GetDefPattern()->GetItemSet();
 582     SfxItemSet* pEEItemSet = new SfxItemSet( rEE.GetEmptyItemSet() );
 583     ScPatternAttr::FillToEditItemSet( *pEEItemSet, rItemSet );
 584     rEE.SetDefaults( pEEItemSet );      // edit engine takes ownership
 585
 586     // create the string
 587     rEE.SetText(rEditText);
 588     xString = lclCreateFormattedString( rRoot, rEE, &rLinkHelper, nFlags, nMaxLen );
 589     rEE.SetUpdateMode( bOldUpdateMode );
 590
 591     return xString;
 592 }
 593
 594 XclExpStringRef XclExpStringHelper::CreateString(
 595         const XclExpRoot& rRoot, const SdrTextObj& rTextObj,
 596         XclStrFlags nFlags, sal_uInt16 nMaxLen )
 597 {
 598     XclExpStringRef xString;
 599     if( const OutlinerParaObject* pParaObj = rTextObj.GetOutlinerParaObject() )
 600     {
 601         EditEngine& rEE = rRoot.GetDrawEditEngine();
 602         sal_Bool bOldUpdateMode = rEE.GetUpdateMode();
 603         rEE.SetUpdateMode( sal_True );
 604         // create the string
 605         rEE.SetText( pParaObj->GetTextObject() );
 606         xString = lclCreateFormattedString( rRoot, rEE, 0, nFlags, nMaxLen );
 607         rEE.SetUpdateMode( bOldUpdateMode );
 608         // limit formats - TODO: BIFF dependent
 609         if( !xString->IsEmpty() )
 610         {
 611             xString->LimitFormatCount( EXC_MAXRECSIZE_BIFF8 / 8 - 1 );
 612             xString->AppendTrailingFormat( EXC_FONT_APP );
 613         }
 614     }
 615     else
 616     {
 617         OSL_FAIL( "XclExpStringHelper::CreateString - textbox without para object" );
 618         // create BIFF dependent empty Excel string
 619         xString = CreateString( rRoot, EMPTY_STRING, nFlags, nMaxLen );
 620     }
 621     return xString;
 622 }
 623
 624 XclExpStringRef XclExpStringHelper::CreateString(
 625         const XclExpRoot& rRoot, const EditTextObject& rEditObj,
 626         XclStrFlags nFlags, sal_uInt16 nMaxLen )
 627 {
 628     XclExpStringRef xString;
 629     EditEngine& rEE = rRoot.GetDrawEditEngine();
 630     sal_Bool bOldUpdateMode = rEE.GetUpdateMode();
 631     rEE.SetUpdateMode( sal_True );
 632     rEE.SetText( rEditObj );
 633     xString = lclCreateFormattedString( rRoot, rEE, 0, nFlags, nMaxLen );
 634     rEE.SetUpdateMode( bOldUpdateMode );
 635     // limit formats - TODO: BIFF dependent
 636     if( !xString->IsEmpty() )
 637     {
 638         xString->LimitFormatCount( EXC_MAXRECSIZE_BIFF8 / 8 - 1 );
 639         xString->AppendTrailingFormat( EXC_FONT_APP );
 640     }
 641     return xString;
 642 }
 643
 644 sal_Int16 XclExpStringHelper::GetLeadingScriptType( const XclExpRoot& rRoot, const String& rString )
 645 {
 646     namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;
 647     Reference< XBreakIterator > xBreakIt = rRoot.GetDoc().GetBreakIterator();
 648     OUString aOUString( rString );
 649     sal_Int32 nStrPos = 0;
 650     sal_Int32 nStrLen = aOUString.getLength();
 651     sal_Int16 nScript = ApiScriptType::WEAK;
 652     while( (nStrPos < nStrLen) && (nScript == ApiScriptType::WEAK) )
 653     {
 654         nScript = xBreakIt->getScriptType( aOUString, nStrPos );
 655         nStrPos = xBreakIt->endOfScript( aOUString, nStrPos, nScript );
 656     }
 657     return (nScript == ApiScriptType::WEAK) ? rRoot.GetDefApiScript() : nScript;
 658 }
 659
 660 // Header/footer conversion ===================================================
 661
 662 XclExpHFConverter::XclExpHFConverter( const XclExpRoot& rRoot ) :
 663     XclExpRoot( rRoot ),
 664     mrEE( rRoot.GetHFEditEngine() ),
 665     mnTotalHeight( 0 )
 666 {
 667 }
 668
 669 void XclExpHFConverter::GenerateString(
 670         const EditTextObject* pLeftObj,
 671         const EditTextObject* pCenterObj,
 672         const EditTextObject* pRightObj )
 673 {
 674     maHFString.Erase();
 675     mnTotalHeight = 0;
 676     AppendPortion( pLeftObj, 'L' );
 677     AppendPortion( pCenterObj, 'C' );
 678     AppendPortion( pRightObj, 'R' );
 679 }
 680
 681 void XclExpHFConverter::AppendPortion( const EditTextObject* pTextObj, sal_Unicode cPortionCode )
 682 {
 683     if( !pTextObj ) return;
 684
 685     String aText;
 686     sal_Int32 nHeight = 0;
 687     SfxItemSet aItemSet( *GetDoc().GetPool(), ATTR_PATTERN_START, ATTR_PATTERN_END );
 688
 689     // edit engine
 690     sal_Bool bOldUpdateMode = mrEE.GetUpdateMode();
 691     mrEE.SetUpdateMode( sal_True );
 692     mrEE.SetText( *pTextObj );
 693
 694     // font information
 695     XclFontData aFontData, aNewData;
 696     if( const XclExpFont* pFirstFont = GetFontBuffer().GetFont( EXC_FONT_APP ) )
 697     {
 698         aFontData = pFirstFont->GetFontData();
 699         (aFontData.mnHeight += 10) /= 20;   // using pt here, not twips
 700     }
 701     else
 702         aFontData.mnHeight = 10;
 703
 704     const FontList* pFontList = 0;
 705     if( SfxObjectShell* pDocShell = GetDocShell() )
 706     {
 707         if( const SvxFontListItem* pInfoItem = static_cast< const SvxFontListItem* >(
 708                 pDocShell->GetItem( SID_ATTR_CHAR_FONTLIST ) ) )
 709             pFontList = pInfoItem->GetFontList();
 710     }
 711
 712     sal_Int32 nParaCount = mrEE.GetParagraphCount();
 713     for( sal_Int32 nPara = 0; nPara < nParaCount; ++nPara )
 714     {
 715         ESelection aSel( nPara, 0 );
 716         String aParaText;
 717         sal_Int32 nParaHeight = 0;
 718         std::vector<sal_uInt16> aPosList;
 719         mrEE.GetPortions( nPara, aPosList );
 720
 721         for( std::vector<sal_uInt16>::const_iterator it( aPosList.begin() ); it != aPosList.end(); ++it )
 722         {
 723             aSel.nEndPos = static_cast< xub_StrLen >( *it );
 724             if( aSel.nStartPos < aSel.nEndPos )
 725             {
 726
 727 // --- font attributes ---
 728
 729                 Font aFont;
 730                 aItemSet.ClearItem();
 731                 SfxItemSet aEditSet( mrEE.GetAttribs( aSel ) );
 732                 ScPatternAttr::GetFromEditItemSet( aItemSet, aEditSet );
 733                 ScPatternAttr::GetFont( aFont, aItemSet, SC_AUTOCOL_RAW );
 734
 735                 // font name and style
 736                 aNewData.maName = XclTools::GetXclFontName( aFont.GetName() );
 737                 aNewData.mnWeight = (aFont.GetWeight() > WEIGHT_NORMAL) ? EXC_FONTWGHT_BOLD : EXC_FONTWGHT_NORMAL;
 738                 aNewData.mbItalic = (aFont.GetItalic() != ITALIC_NONE);
 739                 bool bNewFont = !(aFontData.maName == aNewData.maName);
 740                 bool bNewStyle = (aFontData.mnWeight != aNewData.mnWeight) ||
 741                                  (aFontData.mbItalic != aNewData.mbItalic);
 742                 if( bNewFont || (bNewStyle && pFontList) )
 743                 {
 744                     aParaText.AppendAscii( "&\"" ).Append( aNewData.maName );
 745                     if( pFontList )
 746                     {
 747                         FontInfo aFontInfo( pFontList->Get(
 748                             aNewData.maName,
 749                             (aNewData.mnWeight > EXC_FONTWGHT_NORMAL) ? WEIGHT_BOLD : WEIGHT_NORMAL,
 750                             aNewData.mbItalic ? ITALIC_NORMAL : ITALIC_NONE ) );
 751                         aNewData.maStyle = pFontList->GetStyleName( aFontInfo );
 752                         if( aNewData.maStyle.Len() )
 753                             aParaText.Append( ',' ).Append( aNewData.maStyle );
 754                     }
 755                     aParaText.Append( '"' );
 756                 }
 757
 758                 // height
 759                 // is calculated wrong in ScPatternAttr::GetFromEditItemSet, because already in twips and not 100thmm
 760                 // -> get it directly from edit engine item set
 761                 aNewData.mnHeight = ulimit_cast< sal_uInt16 >( GETITEM( aEditSet, SvxFontHeightItem, EE_CHAR_FONTHEIGHT ).GetHeight() );
 762                 (aNewData.mnHeight += 10) /= 20;
 763                 bool bFontHtChanged = (aFontData.mnHeight != aNewData.mnHeight);
 764                 if( bFontHtChanged )
 765                     aParaText.Append( '&' ).Append( OUString::number( aNewData.mnHeight ) );
 766                 // update maximum paragraph height, convert to twips
 767                 nParaHeight = ::std::max< sal_Int32 >( nParaHeight, aNewData.mnHeight * 20 );
 768
 769                 // underline
 770                 aNewData.mnUnderline = EXC_FONTUNDERL_NONE;
 771                 switch( aFont.GetUnderline() )
 772                 {
 773                     case UNDERLINE_NONE:    aNewData.mnUnderline = EXC_FONTUNDERL_NONE;    break;
 774                     case UNDERLINE_SINGLE:  aNewData.mnUnderline = EXC_FONTUNDERL_SINGLE;  break;
 775                     case UNDERLINE_DOUBLE:  aNewData.mnUnderline = EXC_FONTUNDERL_DOUBLE;  break;
 776                     default:                aNewData.mnUnderline = EXC_FONTUNDERL_SINGLE;
 777                 }
 778                 if( aFontData.mnUnderline != aNewData.mnUnderline )
 779                 {
 780                     sal_uInt8 nTmpUnderl = (aNewData.mnUnderline == EXC_FONTUNDERL_NONE) ?
 781                         aFontData.mnUnderline : aNewData.mnUnderline;
 782                     aParaText.AppendAscii( (nTmpUnderl == EXC_FONTUNDERL_SINGLE) ? "&U" : "&E" );
 783                 }
 784
 785                 // strikeout
 786                 aNewData.mbStrikeout = (aFont.GetStrikeout() != STRIKEOUT_NONE);
 787                 if( aFontData.mbStrikeout != aNewData.mbStrikeout )
 788                     aParaText.AppendAscii( "&S" );
 789
 790                 // super/sub script
 791                 const SvxEscapementItem& rEscapeItem = GETITEM( aEditSet, SvxEscapementItem, EE_CHAR_ESCAPEMENT );
 792                 aNewData.SetScEscapement( rEscapeItem.GetEsc() );
 793                 if( aFontData.mnEscapem != aNewData.mnEscapem )
 794                 {
 795                     switch(aNewData.mnEscapem)
 796                     {
 797                         // close the previous super/sub script.
 798                         case EXC_FONTESC_NONE:  aParaText.AppendAscii( (aFontData.mnEscapem == EXC_FONTESC_SUPER) ? "&X" : "&Y" ); break;
 799                         case EXC_FONTESC_SUPER: aParaText.AppendAscii( "&X" );  break;
 800                         case EXC_FONTESC_SUB:   aParaText.AppendAscii( "&Y" );  break;
 801                         default: break;
 802                     }
 803                 }
 804
 805                 aFontData = aNewData;
 806
 807 // --- text content or text fields ---
 808
 809                 const SfxPoolItem* pItem;
 810                 if( (aSel.nStartPos + 1 == aSel.nEndPos) &&     // fields are single characters
 811                     (aEditSet.GetItemState( EE_FEATURE_FIELD, false, &pItem ) == SFX_ITEM_SET) )
 812                 {
 813                     if( const SvxFieldData* pFieldData = static_cast< const SvxFieldItem* >( pItem )->GetField() )
 814                     {
 815                         if( pFieldData->ISA( SvxPageField ) )
 816                             aParaText.AppendAscii( "&P" );
 817                         else if( pFieldData->ISA( SvxPagesField ) )
 818                             aParaText.AppendAscii( "&N" );
 819                         else if( pFieldData->ISA( SvxDateField ) )
 820                             aParaText.AppendAscii( "&D" );
 821                         else if( pFieldData->ISA( SvxTimeField ) || pFieldData->ISA( SvxExtTimeField ) )
 822                             aParaText.AppendAscii( "&T" );
 823                         else if( pFieldData->ISA( SvxTableField ) )
 824                             aParaText.AppendAscii( "&A" );
 825                         else if( pFieldData->ISA( SvxFileField ) )  // title -> file name
 826                             aParaText.AppendAscii( "&F" );
 827                         else if( const SvxExtFileField* pFileField = PTR_CAST( SvxExtFileField, pFieldData ) )
 828                         {
 829                             switch( pFileField->GetFormat() )
 830                             {
 831                                 case SVXFILEFORMAT_NAME_EXT:
 832                                 case SVXFILEFORMAT_NAME:
 833                                     aParaText.AppendAscii( "&F" );
 834                                 break;
 835                                 case SVXFILEFORMAT_PATH:
 836                                     aParaText.AppendAscii( "&Z" );
 837                                 break;
 838                                 case SVXFILEFORMAT_FULLPATH:
 839                                     aParaText.AppendAscii( "&Z&F" );
 840                                 break;
 841                                 default:
 842                                     OSL_FAIL( "XclExpHFConverter::AppendPortion - unknown file field" );
 843                             }
 844                         }
 845                     }
 846                 }
 847                 else
 848                 {
 849                     String aPortionText( mrEE.GetText( aSel ) );
 850                     aPortionText.SearchAndReplaceAll( OUString('&'), OUString("&&") );
 851                     // #i17440# space between font height and numbers in text
 852                     if( bFontHtChanged && aParaText.Len() && aPortionText.Len() )
 853                     {
 854                         sal_Unicode cLast = aParaText.GetChar( aParaText.Len() - 1 );
 855                         sal_Unicode cFirst = aPortionText.GetChar( 0 );
 856                         if( ('0' <= cLast) && (cLast <= '9') && ('0' <= cFirst) && (cFirst <= '9') )
 857                             aParaText.Append( ' ' );
 858                     }
 859                     aParaText.Append( aPortionText );
 860                 }
 861             }
 862
 863             aSel.nStartPos = aSel.nEndPos;
 864         }
 865
 866         aText = ScGlobal::addToken( aText, aParaText, '\n' );
 867         if( nParaHeight == 0 )
 868             nParaHeight = aFontData.mnHeight * 20;  // points -> twips
 869         nHeight += nParaHeight;
 870     }
 871
 872     mrEE.SetUpdateMode( bOldUpdateMode );
 873
 874     if( aText.Len() )
 875     {
 876         maHFString.Append( '&' ).Append( cPortionCode ).Append( aText );
 877         mnTotalHeight = ::std::max( mnTotalHeight, nHeight );
 878     }
 879 }
 880
 881 // URL conversion =============================================================
 882
 883 namespace {
 884
 885 /** Encodes special parts of the URL, i.e. directory separators and volume names.
 886     @param pTableName  Pointer to a table name to be encoded in this URL, or 0. */
 887 OUString lclEncodeDosUrl(
 888     XclBiff eBiff, const OUString& rUrl, const OUString& rBase, const OUString* pTableName)
 889 {
 890     OUStringBuffer aBuf;
 891
 892     if (!rUrl.isEmpty())
 893     {
 894         OUString aOldUrl = rUrl;
 895         aBuf.append(EXC_URLSTART_ENCODED);
 896
 897         if ( aOldUrl.getLength() > 2 && aOldUrl.copy(0,2) == "\\\\" )
 898         {
 899             // UNC
 900             aBuf.append(EXC_URL_DOSDRIVE).append(sal_Unicode('@'));
 901             aOldUrl = aOldUrl.copy(2);
 902         }
 903         else if ( aOldUrl.getLength() > 2 && aOldUrl.copy(1,2) == ":\\" )
 904         {
 905             // drive letter
 906             sal_Unicode cThisDrive = rBase.isEmpty() ? ' ' : rBase.getStr()[0];
 907             sal_Unicode cDrive = aOldUrl.getStr()[0];
 908             if (cThisDrive == cDrive)
 909                 // This document and the referenced document are under the same drive.
 910                 aBuf.append(EXC_URL_DRIVEROOT);
 911             else
 912                 aBuf.append(EXC_URL_DOSDRIVE).append(cDrive);
 913             aOldUrl = aOldUrl.copy(3);
 914         }
 915
 916         // directories
 917         sal_Int32 nPos = -1;
 918         while((nPos = aOldUrl.indexOf('\\')) != -1)
 919         {
 920             if ( aOldUrl.copy(0,2) == ".." )
 921                 // parent dir (NOTE: the MS-XLS spec doesn't mention this, and
 922                 // Excel seems confused by this token).
 923                 aBuf.append(EXC_URL_PARENTDIR);
 924             else
 925                 aBuf.append(aOldUrl.copy(0,nPos)).append(EXC_URL_SUBDIR);
 926
 927             aOldUrl = aOldUrl.copy(nPos + 1);
 928         }
 929
 930         // file name
 931         if (pTableName)    // enclose file name in brackets if table name follows
 932             aBuf.append(sal_Unicode('[')).append(aOldUrl).append(sal_Unicode(']'));
 933         else
 934             aBuf.append(aOldUrl);
 935     }
 936     else    // empty URL -> self reference
 937     {
 938         switch( eBiff )
 939         {
 940             case EXC_BIFF5:
 941                 aBuf.append(pTableName ? EXC_URLSTART_SELFENCODED : EXC_URLSTART_SELF);
 942             break;
 943             case EXC_BIFF8:
 944                 DBG_ASSERT( pTableName, "lclEncodeDosUrl - sheet name required for BIFF8" );
 945                 aBuf.append(EXC_URLSTART_SELF);
 946             break;
 947             default:
 948                 DBG_ERROR_BIFF();
 949         }
 950     }
 951
 952     // table name
 953     if (pTableName)
 954         aBuf.append(*pTableName);
 955
 956     return aBuf.makeStringAndClear();
 957 }
 958
 959 } // namespace
 960
 961 // ----------------------------------------------------------------------------
 962
 963 OUString XclExpUrlHelper::EncodeUrl( const XclExpRoot& rRoot, const OUString& rAbsUrl, const OUString* pTableName )
 964 {
 965     OUString aDosUrl = INetURLObject(rAbsUrl).getFSysPath(INetURLObject::FSYS_DOS);
 966     OUString aDosBase = INetURLObject(rRoot.GetBasePath()).getFSysPath(INetURLObject::FSYS_DOS);
 967     return lclEncodeDosUrl(rRoot.GetBiff(), aDosUrl, aDosBase, pTableName);
 968 }
 969
 970 OUString XclExpUrlHelper::EncodeDde( const OUString& rApplic, const OUString& rTopic )
 971 {
 972     OUStringBuffer aBuf;
 973     aBuf.append(rApplic).append(EXC_DDE_DELIM).append(rTopic);
 974     return aBuf.makeStringAndClear();
 975 }
 976
 977 // Cached Value Lists =========================================================
 978
 979 XclExpCachedMatrix::XclExpCachedMatrix( const ScMatrix& rMatrix )
 980     : mrMatrix( rMatrix )
 981 {
 982     mrMatrix.IncRef();
 983 }
 984 XclExpCachedMatrix::~XclExpCachedMatrix()
 985 {
 986     mrMatrix.DecRef();
 987 }
 988
 989 void XclExpCachedMatrix::GetDimensions( SCSIZE & nCols, SCSIZE & nRows ) const
 990 {
 991     mrMatrix.GetDimensions( nCols, nRows );
 992
 993     OSL_ENSURE( nCols && nRows, "XclExpCachedMatrix::GetDimensions - empty matrix" );
 994     OSL_ENSURE( nCols <= 256, "XclExpCachedMatrix::GetDimensions - too many columns" );
 995 }
 996
 997 sal_Size XclExpCachedMatrix::GetSize() const
 998 {
 999     SCSIZE nCols, nRows;
1000
1001     GetDimensions( nCols, nRows );
1002
1003     /*  The returned size may be wrong if the matrix contains strings. The only
1004         effect is that the export stream has to update a wrong record size which is
1005         faster than to iterate through all cached values and calculate their sizes. */
1006     return 3 + 9 * (nCols * nRows);
1007 }
1008
1009 void XclExpCachedMatrix::Save( XclExpStream& rStrm ) const
1010 {
1011     SCSIZE nCols, nRows;
1012
1013     GetDimensions( nCols, nRows );
1014
1015     if( rStrm.GetRoot().GetBiff() <= EXC_BIFF5 )
1016         // in BIFF2-BIFF7: 256 columns represented by 0 columns
1017         rStrm << static_cast< sal_uInt8 >( nCols ) << static_cast< sal_uInt16 >( nRows );
1018     else
1019         // in BIFF8: columns and rows decreaed by 1
1020         rStrm << static_cast< sal_uInt8 >( nCols - 1 ) << static_cast< sal_uInt16 >( nRows - 1 );
1021
1022     for( SCSIZE nRow = 0; nRow < nRows; ++nRow )
1023     {
1024         for( SCSIZE nCol = 0; nCol < nCols; ++nCol )
1025         {
1026             ScMatrixValue nMatVal = mrMatrix.Get( nCol, nRow );
1027
1028             if( SC_MATVAL_EMPTY == nMatVal.nType )
1029             {
1030                 rStrm.SetSliceSize( 9 );
1031                 rStrm << EXC_CACHEDVAL_EMPTY;
1032                 rStrm.WriteZeroBytes( 8 );
1033             }
1034             else if( ScMatrix::IsNonValueType( nMatVal.nType ) )
1035             {
1036                 XclExpString aStr( nMatVal.GetString(), EXC_STR_DEFAULT );
1037                 rStrm.SetSliceSize( 6 );
1038                 rStrm << EXC_CACHEDVAL_STRING << aStr;
1039             }
1040             else if( SC_MATVAL_BOOLEAN == nMatVal.nType )
1041             {
1042                 sal_Int8 nBool = nMatVal.GetBoolean();
1043                 rStrm.SetSliceSize( 9 );
1044                 rStrm << EXC_CACHEDVAL_BOOL << nBool;
1045                 rStrm.WriteZeroBytes( 7 );
1046             }
1047             else if( sal_uInt16 nScError = nMatVal.GetError() )
1048             {
1049                 sal_Int8 nError ( XclTools::GetXclErrorCode( nScError ) );
1050                 rStrm.SetSliceSize( 9 );
1051                 rStrm << EXC_CACHEDVAL_ERROR << nError;
1052                 rStrm.WriteZeroBytes( 7 );
1053             }
1054             else
1055             {
1056                 rStrm.SetSliceSize( 9 );
1057                 rStrm << EXC_CACHEDVAL_DOUBLE << nMatVal.fVal;
1058             }
1059         }
1060     }
1061 }
1062
1063 // ============================================================================
1064
1065 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */