sw/source/filter/writer/writer.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: writer.cxx,v $
  10  * $Revision: 1.26 $
  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_sw.hxx"
  33 #include <hintids.hxx>
  34
  35 #define _SVSTDARR_STRINGSSORTDTOR
  36 #include <svtools/svstdarr.hxx>
  37
  38 #include <sot/storage.hxx>
  39 #include <sfx2/docfile.hxx>
  40 #include <svtools/urihelper.hxx>
  41 #include <svtools/filter.hxx>
  42 #include <svx/impgrf.hxx>
  43 #include <svx/fontitem.hxx>
  44 #include <svx/eeitem.hxx>
  45 #include <shellio.hxx>
  46 #include <pam.hxx>
  47 #include <doc.hxx>
  48 #include <docary.hxx>
  49 #include <IMark.hxx>
  50 #include <numrule.hxx>
  51 #include <swerror.h>
  52 #include <boost/bind.hpp>
  53
  54 using namespace ::com::sun::star;
  55
  56
  57 // Stringbuffer fuer die umgewandelten Zahlen
  58 static sal_Char aNToABuf[] = "0000000000000000000000000";
  59 #define NTOABUFLEN (sizeof(aNToABuf))
  60
  61 DECLARE_TABLE( SwBookmarkNodeTable, SvPtrarr* )
  62
  63 struct Writer_Impl
  64 {
  65     SvStringsSortDtor *pSrcArr, *pDestArr;
  66     SvPtrarr* pFontRemoveLst, *pBkmkArr;
  67     SwBookmarkNodeTable* pBkmkNodePos;
  68
  69     Writer_Impl( const SwDoc& rDoc );
  70     ~Writer_Impl();
  71
  72     void RemoveFontList( SwDoc& rDoc );
  73     void InsertBkmk( const ::sw::mark::IMark& rBkmk );
  74 };
  75
  76 Writer_Impl::Writer_Impl( const SwDoc& /*rDoc*/ )
  77     : pSrcArr( 0 ), pDestArr( 0 ), pFontRemoveLst( 0 ), pBkmkNodePos( 0 )
  78 {
  79 }
  80
  81 Writer_Impl::~Writer_Impl()
  82 {
  83     delete pSrcArr;
  84     delete pDestArr;
  85     delete pFontRemoveLst;
  86
  87     if( pBkmkNodePos )
  88     {
  89         for( SvPtrarr* p = pBkmkNodePos->First(); p; p = pBkmkNodePos->Next() )
  90             delete p;
  91         delete pBkmkNodePos;
  92     }
  93 }
  94
  95 void Writer_Impl::RemoveFontList( SwDoc& rDoc )
  96 {
  97     ASSERT( pFontRemoveLst, "wo ist die FontListe?" );
  98     for( USHORT i = pFontRemoveLst->Count(); i; )
  99     {
 100         SvxFontItem* pItem = (SvxFontItem*)(*pFontRemoveLst)[ --i ];
 101         rDoc.GetAttrPool().Remove( *pItem );
 102     }
 103 }
 104
 105 void Writer_Impl::InsertBkmk(const ::sw::mark::IMark& rBkmk)
 106 {
 107     if( !pBkmkNodePos )
 108         pBkmkNodePos = new SwBookmarkNodeTable;
 109
 110     ULONG nNd = rBkmk.GetMarkPos().nNode.GetIndex();
 111     SvPtrarr* pArr = pBkmkNodePos->Get( nNd );
 112     if( !pArr )
 113     {
 114         pArr = new SvPtrarr( 1, 4 );
 115         pBkmkNodePos->Insert( nNd, pArr );
 116     }
 117
 118     void* p = (void*)&rBkmk;
 119     pArr->Insert( p, pArr->Count() );
 120
 121     if(rBkmk.IsExpanded() && rBkmk.GetOtherMarkPos().nNode != nNd)
 122     {
 123         nNd = rBkmk.GetOtherMarkPos().nNode.GetIndex();
 124         pArr = pBkmkNodePos->Get( nNd );
 125         if( !pArr )
 126         {
 127             pArr = new SvPtrarr( 1, 4 );
 128             pBkmkNodePos->Insert( nNd, pArr );
 129         }
 130         pArr->Insert( p, pArr->Count() );
 131     }
 132 }
 133
 134 /*
 135  * Dieses Modul ist die Zentrale-Sammelstelle fuer alle Write-Filter
 136  * und ist eine DLL !
 137  *
 138  * Damit der Writer mit den unterschiedlichen Writern arbeiten kann,
 139  * muessen fuer diese die Ausgabe-Funktionen der Inhalts tragenden
 140  * Objecte auf die verschiedenen Ausgabe-Funktionen gemappt werden.
 141  *
 142  * Dazu kann fuer jedes Object ueber den Which-Wert in einen Tabelle ge-
 143  * griffen werden, um seine Ausgabe-Funktion zu erfragen.
 144  * Diese Funktionen stehen in den entsprechenden Writer-DLL's.
 145  */
 146
 147 Writer::Writer()
 148     : pImpl(0), pStrm(0), pOrigPam(0), pOrigFileName(0), pDoc(0), pCurPam(0)
 149 {
 150     bWriteAll = bShowProgress = bUCS2_WithStartChar = true;
 151     bASCII_NoLastLineEnd = bASCII_ParaAsBlanc = bASCII_ParaAsCR =
 152         bWriteClipboardDoc = bWriteOnlyFirstTable = bBlock =
 153         bOrganizerMode = false;
 154     bExportPargraphNumbering = sal_True;
 155 }
 156
 157 Writer::~Writer()
 158 {
 159 }
 160
 161 /*
 162  * Document Interface Access
 163  */
 164 IDocumentSettingAccess* Writer::getIDocumentSettingAccess() { return pDoc; }
 165 const IDocumentSettingAccess* Writer::getIDocumentSettingAccess() const { return pDoc; }
 166 IDocumentStylePoolAccess* Writer::getIDocumentStylePoolAccess() { return pDoc; }
 167 const IDocumentStylePoolAccess* Writer::getIDocumentStylePoolAccess() const { return pDoc; }
 168
 169 void Writer::ResetWriter()
 170 {
 171     if( pImpl && pImpl->pFontRemoveLst )
 172         pImpl->RemoveFontList( *pDoc );
 173     delete pImpl, pImpl = 0;
 174
 175     if( pCurPam )
 176     {
 177         while( pCurPam->GetNext() != pCurPam )
 178             delete pCurPam->GetNext();
 179         delete pCurPam;
 180     }
 181     pCurPam = 0;
 182     pOrigFileName = 0;
 183     pDoc = 0;
 184     pStrm = 0;
 185
 186     bShowProgress = bUCS2_WithStartChar = TRUE;
 187     bASCII_NoLastLineEnd = bASCII_ParaAsBlanc = bASCII_ParaAsCR =
 188         bWriteClipboardDoc = bWriteOnlyFirstTable = bBlock =
 189         bOrganizerMode = FALSE;
 190 }
 191
 192 BOOL Writer::CopyNextPam( SwPaM ** ppPam )
 193 {
 194     if( (*ppPam)->GetNext() == pOrigPam )
 195     {
 196         *ppPam = pOrigPam;                      // wieder auf den Anfangs-Pam setzen
 197         return FALSE;                           // Ende vom Ring
 198     }
 199
 200     // ansonsten kopiere den die Werte aus dem naechsten Pam
 201     *ppPam = ((SwPaM*)(*ppPam)->GetNext() );
 202
 203     *pCurPam->GetPoint() = *(*ppPam)->Start();
 204     *pCurPam->GetMark() = *(*ppPam)->End();
 205
 206     return TRUE;
 207 }
 208
 209 // suche die naechste Bookmark-Position aus der Bookmark-Tabelle
 210
 211 sal_Int32 Writer::FindPos_Bkmk(const SwPosition& rPos) const
 212 {
 213     const IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
 214     const IDocumentMarkAccess::const_iterator_t ppBkmk = ::std::lower_bound(
 215         pMarkAccess->getMarksBegin(),
 216         pMarkAccess->getMarksEnd(),
 217         rPos,
 218         ::boost::bind(&::sw::mark::IMark::StartsBefore, _1, _2)); // find the first Mark that does not start before
 219     if(ppBkmk != pMarkAccess->getMarksEnd())
 220         return ppBkmk - pMarkAccess->getMarksBegin();
 221     return -1;
 222 }
 223
 224
 225 SwPaM* Writer::NewSwPaM( SwDoc & rDoc, ULONG nStartIdx, ULONG nEndIdx,
 226                         BOOL bNodesArray )
 227 {
 228     SwNodes* pNds = bNodesArray ? &rDoc.GetNodes() : (SwNodes*)rDoc.GetUndoNds();
 229
 230     SwNodeIndex aStt( *pNds, nStartIdx );
 231     SwCntntNode* pCNode = aStt.GetNode().GetCntntNode();
 232     if( !pCNode && 0 == ( pCNode = pNds->GoNext( &aStt )) )
 233     {
 234         ASSERT( false, "An StartPos kein ContentNode mehr" );
 235     }
 236
 237     SwPaM* pNew = new SwPaM( aStt );
 238     pNew->SetMark();
 239     aStt = nEndIdx;
 240     if( 0 == (pCNode = aStt.GetNode().GetCntntNode()) &&
 241         0 == (pCNode = pNds->GoPrevious( &aStt )) )
 242     {
 243         ASSERT( false, "An StartPos kein ContentNode mehr" );
 244     }
 245     pCNode->MakeEndIndex( &pNew->GetPoint()->nContent );
 246     pNew->GetPoint()->nNode = aStt;
 247     return pNew;
 248 }
 249
 250 /////////////////////////////////////////////////////////////////////////////
 251
 252 // Stream-spezifisches
 253 #ifndef PRODUCT
 254 SvStream& Writer::Strm()
 255 {
 256     ASSERT( pStrm, "Oh-oh. Dies ist ein Storage-Writer. Gleich knallts!" );
 257     return *pStrm;
 258 }
 259 #endif
 260
 261
 262 SvStream& Writer::OutHex( SvStream& rStrm, ULONG nHex, BYTE nLen )
 263 {                                                                                                  // in einen Stream aus
 264     // Pointer an das Bufferende setzen
 265     sal_Char* pStr = aNToABuf + (NTOABUFLEN-1);
 266     for( BYTE n = 0; n < nLen; ++n )
 267     {
 268         *(--pStr) = (sal_Char)(nHex & 0xf ) + 48;
 269         if( *pStr > '9' )
 270             *pStr += 39;
 271         nHex >>= 4;
 272     }
 273     return rStrm << pStr;
 274 }
 275
 276 SvStream& Writer::OutLong( SvStream& rStrm, long nVal )
 277 {
 278     // Pointer an das Bufferende setzen
 279     sal_Char* pStr = aNToABuf + (NTOABUFLEN-1);
 280
 281     int bNeg = nVal < 0;
 282     if( bNeg )
 283         nVal = -nVal;
 284
 285     do {
 286         *(--pStr) = (sal_Char)(nVal % 10 ) + 48;
 287         nVal /= 10;
 288     } while( nVal );
 289
 290     // Ist Zahl negativ, dann noch -
 291     if( bNeg )
 292         *(--pStr) = '-';
 293
 294     return rStrm << pStr;
 295 }
 296
 297 SvStream& Writer::OutULong( SvStream& rStrm, ULONG nVal )
 298 {
 299     // Pointer an das Bufferende setzen
 300     sal_Char* pStr = aNToABuf + (NTOABUFLEN-1);
 301
 302     do {
 303         *(--pStr) = (sal_Char)(nVal % 10 ) + 48;
 304         nVal /= 10;
 305     } while ( nVal );
 306     return rStrm << pStr;
 307 }
 308
 309
 310 ULONG Writer::Write( SwPaM& rPaM, SvStream& rStrm, const String* pFName )
 311 {
 312     if ( IsStgWriter() )
 313     {
 314         SotStorageRef aRef = new SotStorage( rStrm );
 315         ULONG nResult = Write( rPaM, *aRef, pFName );
 316         if ( nResult == ERRCODE_NONE )
 317             aRef->Commit();
 318         return nResult;
 319     }
 320
 321     pStrm = &rStrm;
 322     pDoc = rPaM.GetDoc();
 323     pOrigFileName = pFName;
 324     pImpl = new Writer_Impl( *pDoc );
 325
 326     // PaM kopieren, damit er veraendert werden kann
 327     pCurPam = new SwPaM( *rPaM.End(), *rPaM.Start() );
 328     // zum Vergleich auf den akt. Pam sichern
 329     pOrigPam = &rPaM;
 330
 331     ULONG nRet = WriteStream();
 332
 333     ResetWriter();
 334
 335     return nRet;
 336 }
 337
 338 ULONG Writer::Write( SwPaM& rPam, SfxMedium& rMed, const String* pFileName )
 339 {
 340     // This method must be overloaded in SwXMLWriter a storage from medium will be used there.
 341     // The microsoft format can write to storage but the storage will be based on the stream.
 342     return Write( rPam, *rMed.GetOutStream(), pFileName );
 343 }
 344
 345 ULONG Writer::Write( SwPaM& /*rPam*/, SvStorage&, const String* )
 346 {
 347     ASSERT( !this, "Schreiben in Storages auf einem Stream?" );
 348     return ERR_SWG_WRITE_ERROR;
 349 }
 350
 351 ULONG Writer::Write( SwPaM&, const uno::Reference < embed::XStorage >&, const String*, SfxMedium* )
 352 {
 353     ASSERT( !this, "Schreiben in Storages auf einem Stream?" );
 354     return ERR_SWG_WRITE_ERROR;
 355 }
 356
 357 BOOL Writer::CopyLocalFileToINet( String& rFileNm )
 358 {
 359     if( !pOrigFileName )                        // can be happen, by example if we
 360         return FALSE;                   // write into the clipboard
 361
 362     BOOL bRet = FALSE;
 363     INetURLObject aFileUrl( rFileNm ), aTargetUrl( *pOrigFileName );
 364
 365 // JP 01.11.00: what is the correct question for the portal??
 366 //      if( aFileUrl.GetProtocol() == aFileUrl.GetProtocol() )
 367 //              return bRet;
 368 // this is our old without the Mail-Export
 369     if( ! ( INET_PROT_FILE == aFileUrl.GetProtocol() &&
 370             INET_PROT_FILE != aTargetUrl.GetProtocol() &&
 371             INET_PROT_FTP <= aTargetUrl.GetProtocol() &&
 372             INET_PROT_NEWS >= aTargetUrl.GetProtocol() ) )
 373         return bRet;
 374
 375     if( pImpl->pSrcArr )
 376     {
 377         // wurde die Datei schon verschoben
 378         USHORT nPos;
 379         if( pImpl->pSrcArr->Seek_Entry( &rFileNm, &nPos ))
 380         {
 381             rFileNm = *(*pImpl->pDestArr)[ nPos ];
 382             return TRUE;
 383         }
 384     }
 385     else
 386     {
 387         pImpl->pSrcArr = new SvStringsSortDtor( 4, 4 );
 388         pImpl->pDestArr = new SvStringsSortDtor( 4, 4 );
 389     }
 390
 391     String *pSrc = new String( rFileNm );
 392     String *pDest = new String( aTargetUrl.GetPartBeforeLastName() );
 393     *pDest += String(aFileUrl.GetName());
 394
 395     SfxMedium aSrcFile( *pSrc, STREAM_READ, FALSE );
 396     SfxMedium aDstFile( *pDest, STREAM_WRITE | STREAM_SHARE_DENYNONE, FALSE );
 397
 398     *aDstFile.GetOutStream() << *aSrcFile.GetInStream();
 399
 400     aSrcFile.Close();
 401     aDstFile.Commit();
 402
 403     bRet = 0 == aDstFile.GetError();
 404
 405     if( bRet )
 406     {
 407         pImpl->pSrcArr->Insert( pSrc );
 408         pImpl->pDestArr->Insert( pDest );
 409         rFileNm = *pDest;
 410     }
 411     else
 412     {
 413         delete pSrc;
 414         delete pDest;
 415     }
 416
 417     return bRet;
 418 }
 419
 420 void Writer::PutNumFmtFontsInAttrPool()
 421 {
 422     if( !pImpl )
 423         pImpl = new Writer_Impl( *pDoc );
 424
 425     // dann gibt es noch in den NumRules ein paar Fonts
 426     // Diese in den Pool putten. Haben sie danach einen RefCount > 1
 427     // kann es wieder entfernt werden - ist schon im Pool
 428     SfxItemPool& rPool = pDoc->GetAttrPool();
 429     const SwNumRuleTbl& rListTbl = pDoc->GetNumRuleTbl();
 430     const SwNumRule* pRule;
 431     const SwNumFmt* pFmt;
 432     // --> OD 2006-06-27 #b644095#
 433 //    const Font *pFont, *pDefFont = &SwNumRule::GetDefBulletFont();
 434     const Font* pFont;
 435     const Font* pDefFont = &numfunc::GetDefBulletFont();
 436     // <--
 437     BOOL bCheck = FALSE;
 438
 439     for( USHORT nGet = rListTbl.Count(); nGet; )
 440         if( pDoc->IsUsed( *(pRule = rListTbl[ --nGet ] )))
 441             for( BYTE nLvl = 0; nLvl < MAXLEVEL; ++nLvl )
 442                 if( SVX_NUM_CHAR_SPECIAL == (pFmt = &pRule->Get( nLvl ))->GetNumberingType() ||
 443                     SVX_NUM_BITMAP == pFmt->GetNumberingType() )
 444                 {
 445                     if( 0 == ( pFont = pFmt->GetBulletFont() ) )
 446                         pFont = pDefFont;
 447
 448                     if( bCheck )
 449                     {
 450                         if( *pFont == *pDefFont )
 451                             continue;
 452                     }
 453                     else if( *pFont == *pDefFont )
 454                         bCheck = TRUE;
 455
 456                     _AddFontItem( rPool, SvxFontItem( pFont->GetFamily(),
 457                                 pFont->GetName(), pFont->GetStyleName(),
 458                                 pFont->GetPitch(), pFont->GetCharSet(), RES_CHRATR_FONT ));
 459                 }
 460 }
 461
 462 void Writer::PutEditEngFontsInAttrPool( BOOL bIncl_CJK_CTL )
 463 {
 464     if( !pImpl )
 465         pImpl = new Writer_Impl( *pDoc );
 466
 467     SfxItemPool& rPool = pDoc->GetAttrPool();
 468     if( rPool.GetSecondaryPool() )
 469     {
 470         _AddFontItems( rPool, EE_CHAR_FONTINFO );
 471         if( bIncl_CJK_CTL )
 472         {
 473             _AddFontItems( rPool, EE_CHAR_FONTINFO_CJK );
 474             _AddFontItems( rPool, EE_CHAR_FONTINFO_CTL );
 475         }
 476     }
 477 }
 478
 479 void Writer::PutCJKandCTLFontsInAttrPool()
 480 {
 481     if( !pImpl )
 482         pImpl = new Writer_Impl( *pDoc );
 483
 484     SfxItemPool& rPool = pDoc->GetAttrPool();
 485     _AddFontItems( rPool, RES_CHRATR_CJK_FONT );
 486     _AddFontItems( rPool, RES_CHRATR_CTL_FONT );
 487 }
 488
 489
 490 void Writer::_AddFontItems( SfxItemPool& rPool, USHORT nW )
 491 {
 492     const SvxFontItem* pFont = (const SvxFontItem*)&rPool.GetDefaultItem( nW );
 493     _AddFontItem( rPool, *pFont );
 494
 495     if( 0 != ( pFont = (const SvxFontItem*)rPool.GetPoolDefaultItem( nW )) )
 496         _AddFontItem( rPool, *pFont );
 497
 498     USHORT nMaxItem = rPool.GetItemCount( nW );
 499     for( USHORT nGet = 0; nGet < nMaxItem; ++nGet )
 500         if( 0 != (pFont = (const SvxFontItem*)rPool.GetItem( nW, nGet )) )
 501             _AddFontItem( rPool, *pFont );
 502 }
 503
 504 void Writer::_AddFontItem( SfxItemPool& rPool, const SvxFontItem& rFont )
 505 {
 506     const SvxFontItem* pItem;
 507     if( RES_CHRATR_FONT != rFont.Which() )
 508     {
 509         SvxFontItem aFont( rFont );
 510         aFont.SetWhich( RES_CHRATR_FONT );
 511         pItem = (SvxFontItem*)&rPool.Put( aFont );
 512     }
 513     else
 514         pItem = (SvxFontItem*)&rPool.Put( rFont );
 515
 516     if( 1 < pItem->GetRefCount() )
 517         rPool.Remove( *pItem );
 518     else
 519     {
 520         if( !pImpl->pFontRemoveLst )
 521             pImpl->pFontRemoveLst = new SvPtrarr( 0, 10 );
 522
 523         void* p = (void*)pItem;
 524         pImpl->pFontRemoveLst->Insert( p, pImpl->pFontRemoveLst->Count() );
 525     }
 526 }
 527
 528 // build a bookmark table, which is sort by the node position. The
 529 // OtherPos of the bookmarks also inserted.
 530 void Writer::CreateBookmarkTbl()
 531 {
 532     const IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
 533     for(IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->getBookmarksBegin();
 534         ppBkmk != pMarkAccess->getBookmarksEnd();
 535         ++ppBkmk)
 536             pImpl->InsertBkmk(**ppBkmk);
 537 }
 538
 539
 540 // search alle Bookmarks in the range and return it in the Array
 541 USHORT Writer::GetBookmarks(const SwCntntNode& rNd, xub_StrLen nStt,
 542     xub_StrLen nEnd, SvPtrarr& rArr)
 543 {
 544     ASSERT( !rArr.Count(), "es sind noch Eintraege vorhanden" );
 545
 546     ULONG nNd = rNd.GetIndex();
 547     SvPtrarr* pArr = pImpl->pBkmkNodePos ? pImpl->pBkmkNodePos->Get( nNd ) : 0;
 548     if( pArr )
 549     {
 550         // there exist some bookmarks, search now all which is in the range
 551         if( !nStt && nEnd == rNd.Len() )
 552             // all
 553             rArr.Insert( pArr, 0 );
 554         else
 555         {
 556             USHORT n;
 557             xub_StrLen nCntnt;
 558             for( n = 0; n < pArr->Count(); ++n )
 559             {
 560                 void* p = (*pArr)[ n ];
 561                 const ::sw::mark::IMark& rBkmk = *(::sw::mark::IMark *)p;
 562                 if( rBkmk.GetMarkPos().nNode == nNd &&
 563                     (nCntnt = rBkmk.GetMarkPos().nContent.GetIndex() ) >= nStt &&
 564                     nCntnt < nEnd )
 565                 {
 566                     rArr.Insert( p, rArr.Count() );
 567                 }
 568                 else if( rBkmk.IsExpanded() && nNd ==
 569                         rBkmk.GetOtherMarkPos().nNode.GetIndex() && (nCntnt =
 570                         rBkmk.GetOtherMarkPos().nContent.GetIndex() ) >= nStt &&
 571                         nCntnt < nEnd )
 572                 {
 573                     rArr.Insert( p, rArr.Count() );
 574                 }
 575             }
 576         }
 577     }
 578     return rArr.Count();
 579 }
 580
 581 ////////////////////////////////////////////////////////////////////////////
 582
 583 // Storage-spezifisches
 584
 585 ULONG StgWriter::WriteStream()
 586 {
 587     ASSERT( !this, "Schreiben in Streams auf einem Storage?" );
 588     return ERR_SWG_WRITE_ERROR;
 589 }
 590
 591 ULONG StgWriter::Write( SwPaM& rPaM, SvStorage& rStg, const String* pFName )
 592 {
 593     pStrm = 0;
 594     pStg = &rStg;
 595     pDoc = rPaM.GetDoc();
 596     pOrigFileName = pFName;
 597     pImpl = new Writer_Impl( *pDoc );
 598
 599     // PaM kopieren, damit er veraendert werden kann
 600     pCurPam = new SwPaM( *rPaM.End(), *rPaM.Start() );
 601     // zum Vergleich auf den akt. Pam sichern
 602     pOrigPam = &rPaM;
 603
 604     ULONG nRet = WriteStorage();
 605
 606     pStg = NULL;
 607     ResetWriter();
 608
 609     return nRet;
 610 }
 611
 612 ULONG StgWriter::Write( SwPaM& rPaM, const uno::Reference < embed::XStorage >& rStg, const String* pFName, SfxMedium* pMedium )
 613 {
 614     pStrm = 0;
 615     pStg = 0;
 616     xStg = rStg;
 617     pDoc = rPaM.GetDoc();
 618     pOrigFileName = pFName;
 619     pImpl = new Writer_Impl( *pDoc );
 620
 621     // PaM kopieren, damit er veraendert werden kann
 622     pCurPam = new SwPaM( *rPaM.End(), *rPaM.Start() );
 623     // zum Vergleich auf den akt. Pam sichern
 624     pOrigPam = &rPaM;
 625
 626     ULONG nRet = pMedium ? WriteMedium( *pMedium ) : WriteStorage();
 627
 628     pStg = NULL;
 629     ResetWriter();
 630
 631     return nRet;
 632 }
 633