sw/source/core/swg/SwXMLTextBlocks1.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/embed/ElementModes.hpp>
  21 #include <com/sun/star/embed/XTransactedObject.hpp>
  22 #include <svl/macitem.hxx>
  23 #include <svtools/unoevent.hxx>
  24 #include <sfx2/docfile.hxx>
  25 #include <unotools/streamwrap.hxx>
  26 #include <comphelper/componentcontext.hxx>
  27 #include <comphelper/processfactory.hxx>
  28 #include <com/sun/star/xml/sax/InputSource.hpp>
  29 #include <com/sun/star/io/XActiveDataSource.hpp>
  30 #include <com/sun/star/xml/sax/Parser.hpp>
  31 #include <com/sun/star/xml/sax/Writer.hpp>
  32 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  33 #include <doc.hxx>
  34 #include <docsh.hxx>
  35 #include <shellio.hxx>
  36 #include <SwXMLTextBlocks.hxx>
  37 #include <SwXMLBlockImport.hxx>
  38 #include <SwXMLBlockExport.hxx>
  39 #include <swevent.hxx>
  40 #include <swerror.h>
  41
  42 const char XMLN_BLOCKLIST[] = "BlockList.xml";
  43
  44 using namespace ::com::sun::star;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::container;
  47
  48 using ::xmloff::token::XML_BLOCK_LIST;
  49 using ::xmloff::token::XML_UNFORMATTED_TEXT;
  50 using ::xmloff::token::GetXMLToken;
  51
  52 sal_uLong SwXMLTextBlocks::GetDoc( sal_uInt16 nIdx )
  53 {
  54     String aFolderName ( GetPackageName ( nIdx ) );
  55
  56     if (!IsOnlyTextBlock ( nIdx ) )
  57     {
  58         try
  59         {
  60             xRoot = xBlkRoot->openStorageElement( aFolderName, embed::ElementModes::READ );
  61             xMedium = new SfxMedium( xRoot, GetBaseURL(), OUString( "writer8" ) );
  62             SwReader aReader( *xMedium, aFolderName, pDoc );
  63             ReadXML->SetBlockMode( sal_True );
  64             aReader.Read( *ReadXML );
  65             ReadXML->SetBlockMode( sal_False );
  66             // Ole objects fails to display when inserted into document
  67             // because the ObjectReplacement folder ( and contents are missing )
  68             OUString sObjReplacements( "ObjectReplacements" );
  69             if ( xRoot->hasByName( sObjReplacements ) )
  70             {
  71                 uno::Reference< document::XStorageBasedDocument > xDocStor( pDoc->GetDocShell()->GetModel(), uno::UNO_QUERY_THROW );
  72                 uno::Reference< embed::XStorage > xStr( xDocStor->getDocumentStorage() );
  73                 if ( xStr.is() )
  74                 {
  75                     xRoot->copyElementTo( sObjReplacements, xStr, sObjReplacements );
  76                     uno::Reference< embed::XTransactedObject > xTrans( xStr, uno::UNO_QUERY );
  77                     if ( xTrans.is() )
  78                         xTrans->commit();
  79                 }
  80             }
  81         }
  82         catch( uno::Exception& )
  83         {
  84         }
  85
  86         xRoot = 0;
  87     }
  88     else
  89     {
  90         String aStreamName = aFolderName + OUString(".xml");
  91         try
  92         {
  93             xRoot = xBlkRoot->openStorageElement( aFolderName, embed::ElementModes::READ );
  94             uno::Reference < io::XStream > xStream = xRoot->openStreamElement( aStreamName, embed::ElementModes::READ );
  95
  96             uno::Reference< uno::XComponentContext > xContext =
  97                 comphelper::getProcessComponentContext();
  98
  99             xml::sax::InputSource aParserInput;
 100             aParserInput.sSystemId = aNames[nIdx]->aPackageName;
 101
 102             aParserInput.aInputStream = xStream->getInputStream();
 103
 104             // get filter
 105             // uno::Reference< xml::sax::XDocumentHandler > xFilter = new SwXMLTextBlockImport( *this, aCur, sal_True );
 106             uno::Reference< xml::sax::XDocumentHandler > xFilter = new SwXMLTextBlockImport( xContext, *this, aCur, sal_True );
 107
 108             // connect parser and filter
 109             uno::Reference< xml::sax::XParser > xParser = xml::sax::Parser::create(xContext);
 110             xParser->setDocumentHandler( xFilter );
 111
 112             // parse
 113             try
 114             {
 115                 xParser->parseStream( aParserInput );
 116             }
 117             catch( xml::sax::SAXParseException&  )
 118             {
 119                 // re throw ?
 120             }
 121             catch( xml::sax::SAXException&  )
 122             {
 123                 // re throw ?
 124             }
 125             catch( io::IOException& )
 126             {
 127                 // re throw ?
 128             }
 129
 130             bInfoChanged = sal_False;
 131             MakeBlockText(aCur);
 132         }
 133         catch( uno::Exception& )
 134         {
 135         }
 136
 137         xRoot = 0;
 138     }
 139     return 0;
 140 }
 141
 142 // event description for autotext events; this constant should really be
 143 // taken from unocore/unoevents.cxx or ui/unotxt.cxx
 144 const struct SvEventDescription aAutotextEvents[] =
 145 {
 146     { SW_EVENT_START_INS_GLOSSARY,  "OnInsertStart" },
 147     { SW_EVENT_END_INS_GLOSSARY,    "OnInsertDone" },
 148     { 0, NULL }
 149 };
 150
 151 sal_uLong SwXMLTextBlocks::GetMacroTable( sal_uInt16 nIdx,
 152                                       SvxMacroTableDtor& rMacroTbl,
 153                                       sal_Bool bFileAlreadyOpen )
 154 {
 155     // set current auto text
 156
 157     aShort = aNames[nIdx]->aShort;
 158     aLong = aNames[nIdx]->aLong;
 159     aPackageName = aNames[nIdx]->aPackageName;
 160
 161     sal_uLong nRet = 0;
 162
 163     // open stream in proper sub-storage
 164     if( !bFileAlreadyOpen )
 165     {
 166         CloseFile();
 167         nRet = OpenFile ( sal_True );
 168     }
 169     if ( 0 == nRet )
 170     {
 171         try
 172         {
 173             xRoot = xBlkRoot->openStorageElement( aPackageName, embed::ElementModes::READ );
 174             long nTmp = SOT_FORMATSTR_ID_STARWRITER_60;
 175             bool bOasis = ( SotStorage::GetVersion( xRoot ) > nTmp );
 176
 177             OUString sStreamName("atevent.xml");
 178             uno::Reference < io::XStream > xDocStream = xRoot->openStreamElement(
 179                 sStreamName, embed::ElementModes::READ );
 180             OSL_ENSURE(xDocStream.is(), "Can't create stream");
 181             if ( xDocStream.is() )
 182             {
 183                 uno::Reference<io::XInputStream> xInputStream = xDocStream->getInputStream();
 184
 185                 // prepare ParserInputSrouce
 186                 xml::sax::InputSource aParserInput;
 187                 aParserInput.sSystemId = aName;
 188                 aParserInput.aInputStream = xInputStream;
 189
 190                 // get service factory
 191                 uno::Reference< uno::XComponentContext > xContext =
 192                     comphelper::getProcessComponentContext();
 193
 194                 // get parser
 195                 uno::Reference< xml::sax::XParser > xParser = xml::sax::Parser::create( xContext );
 196
 197                 // create descriptor and reference to it. Either
 198                 // both or neither must be kept because of the
 199                 // reference counting!
 200                 SvMacroTableEventDescriptor* pDescriptor =
 201                     new SvMacroTableEventDescriptor(aAutotextEvents);
 202                 uno::Reference<XNameReplace> xReplace = pDescriptor;
 203                 Sequence<Any> aFilterArguments( 1 );
 204                 aFilterArguments[0] <<= xReplace;
 205
 206                 // get filter
 207                 OUString sFilterComponent = bOasis
 208                     ? OUString("com.sun.star.comp.Writer.XMLOasisAutotextEventsImporter")
 209                     : OUString("com.sun.star.comp.Writer.XMLAutotextEventsImporter");
 210                 uno::Reference< xml::sax::XDocumentHandler > xFilter(
 211                     xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
 212                         sFilterComponent, aFilterArguments, xContext),
 213                     UNO_QUERY );
 214                 OSL_ENSURE( xFilter.is(),
 215                             "can't instantiate atevents filter");
 216                 if ( xFilter.is() )
 217                 {
 218                     // connect parser and filter
 219                     xParser->setDocumentHandler( xFilter );
 220
 221                     // connect model and filter
 222                     uno::Reference<document::XImporter> xImporter( xFilter,
 223                                                             UNO_QUERY );
 224
 225                     // we don't need a model
 226                     // xImporter->setTargetDocument( xModelComponent );
 227
 228                     // parse the stream
 229                     try
 230                     {
 231                         xParser->parseStream( aParserInput );
 232                     }
 233                     catch( xml::sax::SAXParseException& )
 234                     {
 235                         // workaround for #83452#: SetSize doesn't work
 236                         // nRet = ERR_SWG_READ_ERROR;
 237                     }
 238                     catch( xml::sax::SAXException& )
 239                     {
 240                         nRet = ERR_SWG_READ_ERROR;
 241                     }
 242                     catch( io::IOException& )
 243                     {
 244                         nRet = ERR_SWG_READ_ERROR;
 245                     }
 246
 247                     // and finally, copy macro into table
 248                     if (0 == nRet)
 249                         pDescriptor->copyMacrosIntoTable(rMacroTbl);
 250                 }
 251                 else
 252                     nRet = ERR_SWG_READ_ERROR;
 253             }
 254             else
 255                 nRet = ERR_SWG_READ_ERROR;
 256         }
 257         catch( uno::Exception& )
 258         {
 259             nRet = ERR_SWG_READ_ERROR;
 260         }
 261     }
 262     else
 263         nRet = ERR_SWG_READ_ERROR;
 264
 265     // success!
 266     return nRet;
 267 }
 268
 269
 270 sal_uLong SwXMLTextBlocks::GetBlockText( const String& rShort, String& rText )
 271 {
 272     sal_uLong n = 0;
 273     sal_Bool bTextOnly = sal_True;
 274     String aFolderName = GeneratePackageName ( rShort );
 275     String aStreamName = aFolderName + OUString(".xml");
 276     rText.Erase();
 277
 278     try
 279     {
 280         xRoot = xBlkRoot->openStorageElement( aFolderName, embed::ElementModes::READ );
 281         uno::Reference < container::XNameAccess > xAccess( xRoot, uno::UNO_QUERY );
 282         if ( !xAccess->hasByName( aStreamName ) || !xRoot->isStreamElement( aStreamName ) )
 283         {
 284             bTextOnly = sal_False;
 285             aStreamName = OUString("content.xml");
 286         }
 287
 288         uno::Reference < io::XStream > xContents = xRoot->openStreamElement( aStreamName, embed::ElementModes::READ );
 289         uno::Reference< uno::XComponentContext > xContext =
 290             comphelper::getProcessComponentContext();
 291
 292         xml::sax::InputSource aParserInput;
 293         aParserInput.sSystemId = aName;
 294         aParserInput.aInputStream = xContents->getInputStream();
 295
 296         // get filter
 297         // #110680#
 298         // uno::Reference< xml::sax::XDocumentHandler > xFilter = new SwXMLTextBlockImport( *this, rText, bTextOnly );
 299         uno::Reference< xml::sax::XDocumentHandler > xFilter = new SwXMLTextBlockImport( xContext, *this, rText, bTextOnly );
 300
 301         // connect parser and filter
 302         uno::Reference< xml::sax::XParser > xParser = xml::sax::Parser::create(xContext);
 303         xParser->setDocumentHandler( xFilter );
 304
 305         // parse
 306         try
 307         {
 308             xParser->parseStream( aParserInput );
 309         }
 310         catch( xml::sax::SAXParseException&  )
 311         {
 312             // re throw ?
 313         }
 314         catch( xml::sax::SAXException&  )
 315         {
 316             // re throw ?
 317         }
 318         catch( io::IOException& )
 319         {
 320             // re throw ?
 321         }
 322
 323         xRoot = 0;
 324     }
 325     catch ( uno::Exception& )
 326     {
 327         OSL_FAIL( "Tried to open non-existent folder or stream!");
 328     }
 329
 330     return n;
 331 }
 332
 333 sal_uLong SwXMLTextBlocks::PutBlockText( const String& rShort, const String& ,
 334                                      const String& rText,  const String& rPackageName )
 335 {
 336     GetIndex ( rShort );
 337     /*
 338     if (xBlkRoot->IsContained ( rPackageName ) )
 339     {
 340         xBlkRoot->Remove ( rPackageName );
 341         xBlkRoot->Commit ( );
 342     }
 343     */
 344     String aFolderName( rPackageName );
 345     String aStreamName = aFolderName + OUString(".xml");
 346
 347     uno::Reference< uno::XComponentContext > xContext =
 348         comphelper::getProcessComponentContext();
 349
 350     uno::Reference < xml::sax::XWriter > xWriter = xml::sax::Writer::create(xContext);
 351     sal_uLong nRes = 0;
 352
 353     try
 354     {
 355     xRoot = xBlkRoot->openStorageElement( aFolderName, embed::ElementModes::WRITE );
 356     uno::Reference < io::XStream > xDocStream = xRoot->openStreamElement( aStreamName,
 357                 embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 358
 359     uno::Reference < beans::XPropertySet > xSet( xDocStream, uno::UNO_QUERY );
 360     OUString aMime ( "text/xml" );
 361     Any aAny;
 362     aAny <<= aMime;
 363     xSet->setPropertyValue( OUString("MediaType"), aAny );
 364     uno::Reference < io::XOutputStream > xOut = xDocStream->getOutputStream();
 365        uno::Reference<io::XActiveDataSource> xSrc(xWriter, uno::UNO_QUERY);
 366        xSrc->setOutputStream(xOut);
 367
 368        uno::Reference<xml::sax::XDocumentHandler> xHandler(xWriter,
 369         uno::UNO_QUERY);
 370
 371    SwXMLTextBlockExport aExp( xContext, *this, GetXMLToken ( XML_UNFORMATTED_TEXT ), xHandler);
 372
 373     aExp.exportDoc( rText );
 374
 375     uno::Reference < embed::XTransactedObject > xTrans( xRoot, uno::UNO_QUERY );
 376     if ( xTrans.is() )
 377         xTrans->commit();
 378
 379     if (! (nFlags & SWXML_NOROOTCOMMIT) )
 380     {
 381         uno::Reference < embed::XTransactedObject > xTmpTrans( xBlkRoot, uno::UNO_QUERY );
 382         if ( xTmpTrans.is() )
 383             xTmpTrans->commit();
 384     }
 385     }
 386     catch ( uno::Exception& )
 387     {
 388         nRes = ERR_SWG_WRITE_ERROR;
 389     }
 390
 391     xRoot = 0;
 392
 393     //TODO/LATER: error handling
 394     /*
 395     sal_uLong nErr = xBlkRoot->GetError();
 396     sal_uLong nRes = 0;
 397     if( nErr == SVSTREAM_DISK_FULL )
 398         nRes = ERR_W4W_WRITE_FULL;
 399     else if( nErr != SVSTREAM_OK )
 400         nRes = ERR_SWG_WRITE_ERROR;
 401     */
 402     if( !nRes )         // damit ueber GetText & nCur aufs Doc zugegriffen
 403         MakeBlockText( rText );
 404
 405     return nRes;
 406 }
 407
 408 void SwXMLTextBlocks::ReadInfo( void )
 409 {
 410     try
 411     {
 412     const OUString sDocName( XMLN_BLOCKLIST );
 413     uno::Reference < container::XNameAccess > xAccess( xBlkRoot, uno::UNO_QUERY );
 414     if ( xAccess.is() && xAccess->hasByName( sDocName ) && xBlkRoot->isStreamElement( sDocName ) )
 415     {
 416         uno::Reference< uno::XComponentContext > xContext =
 417                 comphelper::getProcessComponentContext();
 418
 419         xml::sax::InputSource aParserInput;
 420         aParserInput.sSystemId = sDocName;
 421
 422         uno::Reference < io::XStream > xDocStream = xBlkRoot->openStreamElement( sDocName, embed::ElementModes::READ );
 423         aParserInput.aInputStream = xDocStream->getInputStream();
 424
 425         // get filter
 426         uno::Reference< xml::sax::XDocumentHandler > xFilter = new SwXMLBlockListImport( xContext, *this );
 427
 428         // connect parser and filter
 429         uno::Reference< xml::sax::XParser > xParser = xml::sax::Parser::create( xContext );
 430         xParser->setDocumentHandler( xFilter );
 431
 432         // parse
 433         try
 434         {
 435             xParser->parseStream( aParserInput );
 436         }
 437         catch( xml::sax::SAXParseException&  )
 438         {
 439             // re throw ?
 440         }
 441         catch( xml::sax::SAXException&  )
 442         {
 443             // re throw ?
 444         }
 445         catch( io::IOException& )
 446         {
 447             // re throw ?
 448         }
 449     }
 450     }
 451     catch ( uno::Exception& )
 452     {
 453     }
 454 }
 455 void SwXMLTextBlocks::WriteInfo( void )
 456 {
 457     if ( xBlkRoot.is() || 0 == OpenFile ( sal_False ) )
 458     {
 459         uno::Reference< uno::XComponentContext > xContext =
 460             comphelper::getProcessComponentContext();
 461
 462         uno::Reference < xml::sax::XWriter > xWriter = xml::sax::Writer::create(xContext);
 463         OUString sDocName( XMLN_BLOCKLIST );
 464
 465         /*
 466         if ( xBlkRoot->IsContained( sDocName) )
 467         {
 468             xBlkRoot->Remove ( sDocName );
 469             xBlkRoot->Commit();
 470         }
 471         */
 472
 473         try
 474         {
 475         uno::Reference < io::XStream > xDocStream = xBlkRoot->openStreamElement( sDocName,
 476                     embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 477
 478         uno::Reference < beans::XPropertySet > xSet( xDocStream, uno::UNO_QUERY );
 479         OUString aMime ( "text/xml" );
 480         Any aAny;
 481         aAny <<= aMime;
 482         xSet->setPropertyValue( OUString("MediaType"), aAny );
 483         uno::Reference < io::XOutputStream > xOut = xDocStream->getOutputStream();
 484         uno::Reference<io::XActiveDataSource> xSrc(xWriter, uno::UNO_QUERY);
 485         xSrc->setOutputStream(xOut);
 486
 487         uno::Reference<xml::sax::XDocumentHandler> xHandler(xWriter, uno::UNO_QUERY);
 488
 489         SwXMLBlockListExport aExp( xContext, *this, OUString(XMLN_BLOCKLIST), xHandler);
 490
 491         aExp.exportDoc( XML_BLOCK_LIST );
 492
 493         uno::Reference < embed::XTransactedObject > xTrans( xBlkRoot, uno::UNO_QUERY );
 494         if ( xTrans.is() )
 495             xTrans->commit();
 496         }
 497         catch ( uno::Exception& )
 498         {
 499         }
 500
 501         bInfoChanged = sal_False;
 502         return;
 503     }
 504 }
 505
 506 sal_uLong SwXMLTextBlocks::SetMacroTable(
 507     sal_uInt16 nIdx,
 508     const SvxMacroTableDtor& rMacroTbl,
 509     sal_Bool bFileAlreadyOpen )
 510 {
 511     // set current autotext
 512     aShort = aNames[nIdx]->aShort;
 513     aLong = aNames[nIdx]->aLong;
 514     aPackageName = aNames[nIdx]->aPackageName;
 515
 516     // start XML autotext event export
 517     sal_uLong nRes = 0;
 518
 519     uno::Reference< uno::XComponentContext > xContext =
 520         comphelper::getProcessComponentContext();
 521
 522     // Get model
 523     uno::Reference< lang::XComponent > xModelComp(
 524         pDoc->GetDocShell()->GetModel(), UNO_QUERY );
 525     OSL_ENSURE( xModelComp.is(), "XMLWriter::Write: got no model" );
 526     if( !xModelComp.is() )
 527         return ERR_SWG_WRITE_ERROR;
 528
 529     // open stream in proper sub-storage
 530     if( !bFileAlreadyOpen )
 531     {
 532         CloseFile();    // close (it may be open in read-only-mode)
 533         nRes = OpenFile ( sal_False );
 534     }
 535
 536     if ( 0 == nRes )
 537     {
 538         try
 539         {
 540             xRoot = xBlkRoot->openStorageElement( aPackageName, embed::ElementModes::WRITE );
 541             OUString sStreamName("atevent.xml" );
 542             long nTmp = SOT_FORMATSTR_ID_STARWRITER_60;
 543             bool bOasis = ( SotStorage::GetVersion( xRoot ) > nTmp );
 544
 545             uno::Reference < io::XStream > xDocStream = xRoot->openStreamElement( sStreamName,
 546                         embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 547
 548             uno::Reference < beans::XPropertySet > xSet( xDocStream, uno::UNO_QUERY );
 549             OUString aMime( "text/xml" );
 550             Any aAny;
 551             aAny <<= aMime;
 552             xSet->setPropertyValue( OUString("MediaType"), aAny );
 553             uno::Reference < io::XOutputStream > xOutputStream = xDocStream->getOutputStream();
 554
 555             // get XML writer
 556             uno::Reference< xml::sax::XWriter > xSaxWriter =
 557                 xml::sax::Writer::create( xContext );
 558
 559             // connect XML writer to output stream
 560             xSaxWriter->setOutputStream( xOutputStream );
 561             uno::Reference<xml::sax::XDocumentHandler> xDocHandler(
 562                 xSaxWriter, UNO_QUERY);
 563
 564             // construct events object
 565             uno::Reference<XNameAccess> xEvents =
 566                 new SvMacroTableEventDescriptor(rMacroTbl,aAutotextEvents);
 567
 568             // prepare arguments (prepend doc handler to given arguments)
 569             Sequence<Any> aParams(2);
 570             aParams[0] <<= xDocHandler;
 571             aParams[1] <<= xEvents;
 572
 573
 574             // get filter component
 575             OUString sFilterComponent = bOasis
 576                 ? OUString("com.sun.star.comp.Writer.XMLOasisAutotextEventsExporter")
 577                 : OUString("com.sun.star.comp.Writer.XMLAutotextEventsExporter");
 578             uno::Reference< document::XExporter > xExporter(
 579                 xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
 580                     sFilterComponent, aParams, xContext), UNO_QUERY);
 581             OSL_ENSURE( xExporter.is(),
 582                     "can't instantiate export filter component" );
 583             if( xExporter.is() )
 584             {
 585                 // connect model and filter
 586                 xExporter->setSourceDocument( xModelComp );
 587
 588                 // filter!
 589                 Sequence<beans::PropertyValue> aFilterProps( 0 );
 590                 uno::Reference < document::XFilter > xFilter( xExporter,
 591                                                          UNO_QUERY );
 592                 xFilter->filter( aFilterProps );
 593             }
 594             else
 595                 nRes = ERR_SWG_WRITE_ERROR;
 596
 597             // finally, commit stream, sub-storage and storage
 598             uno::Reference < embed::XTransactedObject > xTmpTrans( xRoot, uno::UNO_QUERY );
 599             if ( xTmpTrans.is() )
 600                 xTmpTrans->commit();
 601
 602             if ( !bFileAlreadyOpen )
 603             {
 604                 uno::Reference < embed::XTransactedObject > xTrans( xBlkRoot, uno::UNO_QUERY );
 605                 if ( xTrans.is() )
 606                     xTrans->commit();
 607             }
 608
 609             xRoot = 0;
 610         }
 611         catch ( uno::Exception& )
 612         {
 613             nRes = ERR_SWG_WRITE_ERROR;
 614         }
 615
 616         if( !bFileAlreadyOpen )
 617             CloseFile();
 618     }
 619     else
 620         nRes = ERR_SWG_WRITE_ERROR;
 621
 622     return nRes;
 623 }
 624
 625 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */