filter/source/flash/swffilter.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/frame/Desktop.hpp>
  21 #include <com/sun/star/frame/XStorable.hpp>
  22 #include <com/sun/star/document/XFilter.hpp>
  23 #include <com/sun/star/document/XExporter.hpp>
  24 #include <com/sun/star/lang/XInitialization.hpp>
  25 #include <com/sun/star/lang/XServiceInfo.hpp>
  26 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  27 #include <com/sun/star/drawing/XDrawView.hpp>
  28 #include <com/sun/star/container/XIndexAccess.hpp>
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/task/XStatusIndicatorFactory.hpp>
  31 #include <com/sun/star/io/XOutputStream.hpp>
  32 #include <cppuhelper/implbase1.hxx>
  33 #include <cppuhelper/implbase4.hxx>
  34 #include <comphelper/processfactory.hxx>
  35 #include <osl/file.hxx>
  36
  37 #include "swfexporter.hxx"
  38
  39 #include <string.h>
  40
  41 using namespace ::com::sun::star::uno;
  42 using namespace ::com::sun::star::frame;
  43 using namespace ::com::sun::star::lang;
  44 using namespace ::com::sun::star::drawing;
  45 using namespace ::com::sun::star::presentation;
  46 using namespace ::com::sun::star::task;
  47
  48 using ::com::sun::star::lang::XComponent;
  49 using ::com::sun::star::beans::PropertyValue;
  50 using ::com::sun::star::io::XOutputStream;
  51 using ::com::sun::star::container::XIndexAccess;
  52 using ::osl::FileBase;
  53 using ::com::sun::star::frame::XModel;
  54
  55 namespace swf {
  56
  57 typedef ::cppu::WeakImplHelper1<com::sun::star::io::XOutputStream> OslOutputStreamWrapper_Base;
  58     // needed for some compilers
  59 class OslOutputStreamWrapper : public OslOutputStreamWrapper_Base
  60 {
  61     osl::File   mrFile;
  62
  63 public:
  64     OslOutputStreamWrapper(const OUString& sFileName) : mrFile(sFileName)
  65     {
  66         osl_removeFile(sFileName.pData);
  67         mrFile.open( osl_File_OpenFlag_Create|osl_File_OpenFlag_Write );
  68     }
  69
  70     // stario::XOutputStream
  71     virtual void SAL_CALL writeBytes( const ::com::sun::star::uno::Sequence< sal_Int8 >& aData ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException);
  72     virtual void SAL_CALL flush(  ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException);
  73     virtual void SAL_CALL closeOutput(  ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException);
  74 };
  75
  76 void SAL_CALL OslOutputStreamWrapper::writeBytes( const ::com::sun::star::uno::Sequence< sal_Int8 >& aData ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException)
  77 {
  78     sal_uInt64 uBytesToWrite = aData.getLength();
  79     sal_uInt64 uBytesWritten = 0;
  80
  81     sal_Int8 const * pBuffer = aData.getConstArray();
  82
  83     while( uBytesToWrite )
  84     {
  85         osl::File::RC eRC = mrFile.write( pBuffer, uBytesToWrite, uBytesWritten);
  86
  87         switch( eRC )
  88         {
  89         case osl::File::E_INVAL:    // the format of the parameters was not valid
  90         case osl::File::E_FBIG:        // File too large
  91
  92         case osl::File::E_AGAIN:    // Operation would block
  93         case osl::File::E_BADF:        // Bad file
  94         case osl::File::E_FAULT:    // Bad address
  95         case osl::File::E_INTR:        // function call was interrupted
  96         case osl::File::E_IO:        // I/O error
  97         case osl::File::E_NOLCK:    // No record locks available
  98         case osl::File::E_NOLINK:    // Link has been severed
  99         case osl::File::E_NOSPC:    // No space left on device
 100         case osl::File::E_NXIO:        // No such device or address
 101             throw com::sun::star::io::IOException();    // TODO: Better error handling
 102         default: break;
 103         }
 104
 105         uBytesToWrite -= uBytesWritten;
 106         pBuffer += uBytesWritten;
 107     }
 108 }
 109
 110 void SAL_CALL OslOutputStreamWrapper::flush(  ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException)
 111 {
 112 }
 113
 114 void SAL_CALL OslOutputStreamWrapper::closeOutput(  ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException)
 115 {
 116     osl::File::RC eRC = mrFile.close();
 117
 118     switch( eRC )
 119     {
 120     case osl::File::E_INVAL:    // the format of the parameters was not valid
 121
 122     case osl::File::E_BADF:        // Bad file
 123     case osl::File::E_INTR:        // function call was interrupted
 124     case osl::File::E_NOLINK:    // Link has been severed
 125     case osl::File::E_NOSPC:    // No space left on device
 126     case osl::File::E_IO:        // I/O error
 127         throw com::sun::star::io::IOException();    // TODO: Better error handling
 128     default: break;
 129     }
 130 }
 131
 132 // -----------------------------------------------------------------------------
 133
 134 class FlashExportFilter : public cppu::WeakImplHelper4
 135 <
 136     com::sun::star::document::XFilter,
 137     com::sun::star::document::XExporter,
 138     com::sun::star::lang::XInitialization,
 139     com::sun::star::lang::XServiceInfo
 140 >
 141 {
 142     Reference< XComponent > mxDoc;
 143     Reference< XComponentContext > mxContext;
 144     Reference< XStatusIndicator> mxStatusIndicator;
 145
 146 public:
 147     FlashExportFilter( const Reference< XComponentContext > &rxContext);
 148
 149     // XFilter
 150     virtual sal_Bool SAL_CALL filter( const Sequence< PropertyValue >& aDescriptor ) throw(RuntimeException);
 151
 152     sal_Bool ExportAsMultipleFiles( const Sequence< PropertyValue >& aDescriptor );
 153     sal_Bool ExportAsSingleFile( const Sequence< PropertyValue >& aDescriptor );
 154
 155     virtual void SAL_CALL cancel( ) throw (RuntimeException);
 156
 157     // XExporter
 158     virtual void SAL_CALL setSourceDocument( const Reference< XComponent >& xDoc ) throw(IllegalArgumentException, RuntimeException);
 159
 160     // XInitialization
 161     virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException);
 162
 163     // XServiceInfo
 164     virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
 165     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
 166     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames()  throw(RuntimeException);
 167 };
 168
 169 // -----------------------------------------------------------------------------
 170
 171 FlashExportFilter::FlashExportFilter(const Reference< XComponentContext > &rxContext)
 172 :   mxContext( rxContext )
 173 {
 174 }
 175
 176
 177 // -----------------------------------------------------------------------------
 178
 179 OUString exportBackground(FlashExporter &aFlashExporter, Reference< XDrawPage > xDrawPage, OUString sPath, sal_uInt32 nPage, const char* suffix)
 180 {
 181     OUString filename = STR("slide") + VAL(nPage+1) + STR(suffix) + STR(".swf");
 182     OUString fullpath = sPath + STR("/") + filename;
 183
 184     // AS: If suffix is "o" then the last paramter is true (for exporting objects).
 185     Reference<XOutputStream> xOutputStreamWrap(*(new OslOutputStreamWrapper(fullpath)), UNO_QUERY);
 186     sal_uInt16 nCached = aFlashExporter.exportBackgrounds( xDrawPage, xOutputStreamWrap, sal::static_int_cast<sal_uInt16>( nPage ), *suffix == 'o' );
 187     aFlashExporter.Flush();
 188     xOutputStreamWrap.clear();
 189
 190     if (nCached != nPage)
 191     {
 192         osl_removeFile(fullpath.pData);
 193         if ( 0xffff == nCached )
 194             return STR("NULL");
 195         else
 196             return STR("slide") + VAL(nCached+1) + STR(suffix) + STR(".swf");
 197     }
 198
 199     return filename;
 200 }
 201
 202 template <typename TYPE>
 203 TYPE findPropertyValue(const Sequence< PropertyValue >& aPropertySequence, const sal_Char* name, TYPE def)
 204 {
 205     TYPE temp = TYPE();
 206
 207     sal_Int32 nLength = aPropertySequence.getLength();
 208     const PropertyValue * pValue = aPropertySequence.getConstArray();
 209
 210     for ( sal_Int32 i = 0 ; i < nLength; i++)
 211     {
 212         if ( pValue[i].Name.equalsAsciiL ( name, strlen(name) ) )
 213         {
 214             pValue[i].Value >>= temp;
 215             return temp;
 216         }
 217     }
 218
 219     return def;
 220 }
 221
 222 sal_Bool SAL_CALL FlashExportFilter::filter( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aDescriptor )
 223     throw (RuntimeException)
 224 {
 225     mxStatusIndicator = findPropertyValue<Reference<XStatusIndicator> >(aDescriptor, "StatusIndicator", mxStatusIndicator);
 226
 227     Sequence< PropertyValue > aFilterData;
 228     aFilterData = findPropertyValue<Sequence< PropertyValue > >(aDescriptor, "FilterData", aFilterData);
 229
 230     if (findPropertyValue<sal_Bool>(aFilterData, "ExportMultipleFiles", false ))
 231     {
 232         ExportAsMultipleFiles(aDescriptor);
 233     }
 234     else
 235     {
 236         ExportAsSingleFile(aDescriptor);
 237     }
 238
 239     if( mxStatusIndicator.is() )
 240         mxStatusIndicator->end();
 241
 242     return sal_True;
 243 }
 244
 245
 246 // AS: When exporting as multiple files, each background, object layer, and slide gets its own
 247 //  file.  Additionally, a file called BackgroundConfig.txt is generated, indicating which
 248 //  background and objects (if any) go with each slide.  The files are named slideNb.swf,
 249 //  slideNo.swf, and slideNp.swf, where N is the slide number, and b=background, o=objects, and
 250 //  p=slide contents.  Note that under normal circumstances, there will be very few b and o files.
 251
 252 // AS: HACK!  Right now, I create a directory as a sibling to the swf file selected in the Export
 253 //  dialog.  This directory is called presentation.sxi-swf-files.  The name of the swf file selected
 254 //  in the Export dialog has no impact on this.  All files created are placed in this directory.
 255 sal_Bool FlashExportFilter::ExportAsMultipleFiles(const Sequence< PropertyValue >& aDescriptor)
 256 {
 257     Reference< XDrawPagesSupplier > xDrawPagesSupplier(mxDoc, UNO_QUERY);
 258     if(!xDrawPagesSupplier.is())
 259         return sal_False;
 260
 261     Reference< XIndexAccess > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_QUERY );
 262     if(!xDrawPages.is())
 263         return sal_False;
 264
 265     Reference< XDesktop2 > rDesktop = Desktop::create( mxContext );
 266
 267     Reference< XStorable > xStorable(rDesktop->getCurrentComponent(), UNO_QUERY);
 268     if (!xStorable.is())
 269         return sal_False;
 270
 271     Reference< XDrawPage > xDrawPage;
 272
 273     Reference< XFrame > rFrame = rDesktop->getCurrentFrame();
 274     Reference< XDrawView > rDrawView = Reference< XDrawView >( rFrame->getController(), UNO_QUERY );
 275
 276     Reference< XDrawPage > rCurrentPage = rDrawView->getCurrentPage();
 277
 278     Sequence< PropertyValue > aFilterData;
 279
 280     aFilterData = findPropertyValue<Sequence< PropertyValue > >(aDescriptor, "FilterData", aFilterData);
 281
 282     //AS: Do a bunch of path mangling to figure out where to put the files.
 283
 284     OUString sOriginalPath = findPropertyValue<OUString>(aDescriptor, "URL", OUString());
 285
 286     // AS: sPath is the parent directory, where everything else exists (like the sxi,
 287     //  the -swf-files folder, the -audio files, etc.
 288     sal_Int32 lastslash = sOriginalPath.lastIndexOf('/');
 289     OUString sPath( sOriginalPath.copy(0, lastslash) );
 290
 291     OUString sPresentation(xStorable->getLocation());
 292
 293     lastslash = sPresentation.lastIndexOf('/') + 1;
 294     sal_Int32 lastdot = sPresentation.lastIndexOf('.');
 295
 296     // AS: The name of the presentation, without 3 character extension.
 297     OUString sPresentationName;
 298     if (lastdot < 0)  // fdo#71309 in case file has no name
 299         sPresentationName = sPresentation.copy(lastslash);
 300     else
 301         sPresentationName = sPresentation.copy(lastslash, lastdot - lastslash);
 302
 303     OUString fullpath, swfdirpath, backgroundfilename, objectsfilename;
 304
 305     swfdirpath = sPath + STR("/") + sPresentationName + STR(".sxi-swf-files");
 306
 307     oslFileError err;
 308     err = osl_createDirectory( swfdirpath.pData );
 309
 310     fullpath = swfdirpath + STR("/backgroundconfig.txt");
 311
 312     oslFileHandle xBackgroundConfig( 0 );
 313
 314     // AS: Only export the background config if we're exporting all of the pages, otherwise we'll
 315     //  screw it up.
 316     sal_Bool bExportAll = findPropertyValue<sal_Bool>(aFilterData, "ExportAll", true);
 317     if (bExportAll)
 318     {
 319         osl_removeFile(fullpath.pData);
 320         osl_openFile( fullpath.pData, &xBackgroundConfig, osl_File_OpenFlag_Create | osl_File_OpenFlag_Write );
 321
 322         sal_uInt64 bytesWritten;
 323         err = osl_writeFile(xBackgroundConfig, "slides=", strlen("slides="), &bytesWritten);
 324     }
 325
 326     // TODO: check for errors
 327     (void) err;
 328
 329     FlashExporter aFlashExporter( mxContext, findPropertyValue<sal_Int32>(aFilterData, "CompressMode", 75),
 330                                          findPropertyValue<sal_Bool>(aFilterData, "ExportOLEAsJPEG", false));
 331
 332     const sal_Int32 nPageCount = xDrawPages->getCount();
 333     if ( mxStatusIndicator.is() )
 334         mxStatusIndicator->start( "Saving :", nPageCount);
 335
 336     for(sal_Int32 nPage = 0; nPage < nPageCount; nPage++)
 337     {
 338         if ( mxStatusIndicator.is() )
 339             mxStatusIndicator->setValue( nPage );
 340         xDrawPages->getByIndex(nPage) >>= xDrawPage;
 341
 342         // AS: If we're only exporting the current page, then skip the rest.
 343         if (!bExportAll && xDrawPage != rCurrentPage)
 344             continue;
 345
 346         // AS: Export the background, the background objects, and then the slide contents.
 347         if (bExportAll || findPropertyValue<sal_Bool>(aFilterData, "ExportBackgrounds", true))
 348         {
 349             backgroundfilename = exportBackground(aFlashExporter, xDrawPage, swfdirpath, nPage, "b");
 350         }
 351
 352         if (bExportAll || findPropertyValue<sal_Bool>(aFilterData, "ExportBackgroundObjects", true))
 353         {
 354             objectsfilename = exportBackground(aFlashExporter, xDrawPage, swfdirpath, nPage, "o");
 355         }
 356
 357         if (bExportAll || findPropertyValue<sal_Bool>(aFilterData, "ExportSlideContents", true))
 358         {
 359             fullpath = swfdirpath + STR("/slide") + VAL(nPage+1) + STR("p.swf");
 360
 361             Reference<XOutputStream> xOutputStreamWrap(*(new OslOutputStreamWrapper(fullpath)), UNO_QUERY);
 362             sal_Bool ret = aFlashExporter.exportSlides( xDrawPage, xOutputStreamWrap, sal::static_int_cast<sal_uInt16>( nPage ) );
 363             aFlashExporter.Flush();
 364             xOutputStreamWrap.clear();
 365
 366             if (!ret)
 367                 osl_removeFile(fullpath.pData);
 368         }
 369
 370         // AS: Write out to the background config what backgrounds and objects this
 371         //  slide used.
 372         if (bExportAll)
 373         {
 374             OUString temp = backgroundfilename + STR("|") + objectsfilename;
 375             OString ASCIItemp(temp.getStr(), temp.getLength(), RTL_TEXTENCODING_ASCII_US);
 376
 377             sal_uInt64 bytesWritten;
 378             osl_writeFile(xBackgroundConfig, ASCIItemp.getStr(), ASCIItemp.getLength(), &bytesWritten);
 379
 380             if (nPage < nPageCount - 1)
 381                 osl_writeFile(xBackgroundConfig, "|", 1, &bytesWritten);
 382         }
 383
 384 #ifdef AUGUSTUS
 385         if (findPropertyValue<sal_Bool>(aFilterData, "ExportSound", true))
 386         {
 387             fullpath = swfdirpath + STR("/slide") + VAL(nPage+1) + STR("s.swf");
 388
 389             OUString wavpath = sPath + STR("/") + sPresentationName + STR(".ppt-audio/slide") + VAL(nPage+1) + STR(".wav");
 390             FileBase::getSystemPathFromFileURL(wavpath, wavpath);
 391             OString sASCIIPath(wavpath.getStr(), wavpath.getLength(), RTL_TEXTENCODING_ASCII_US);
 392
 393             Reference<XOutputStream> xOutputStreamWrap(*(new OslOutputStreamWrapper(fullpath)), UNO_QUERY);
 394             sal_Bool ret = aFlashExporter.exportSound(xOutputStreamWrap, sASCIIPath.getStr());
 395             aFlashExporter.Flush();
 396             xOutputStreamWrap.clear();
 397
 398             if (!ret)
 399                 osl_removeFile(fullpath.pData);
 400         }
 401 #endif // defined AUGUSTUS
 402     }
 403
 404     if (bExportAll)
 405         osl_closeFile(xBackgroundConfig);
 406
 407     return sal_True;
 408 }
 409
 410 sal_Bool FlashExportFilter::ExportAsSingleFile(const Sequence< PropertyValue >& aDescriptor)
 411 {
 412     Reference < XOutputStream > xOutputStream = findPropertyValue<Reference<XOutputStream> >(aDescriptor, "OutputStream", 0);
 413     Sequence< PropertyValue > aFilterData;
 414
 415     if (!xOutputStream.is() )
 416     {
 417         OSL_ASSERT ( 0 );
 418         return sal_False;
 419     }
 420
 421     FlashExporter aFlashExporter( mxContext, findPropertyValue<sal_Int32>(aFilterData, "CompressMode", 75),
 422                                          findPropertyValue<sal_Bool>(aFilterData, "ExportOLEAsJPEG", false));
 423
 424     return aFlashExporter.exportAll( mxDoc, xOutputStream, mxStatusIndicator );
 425 }
 426
 427 // -----------------------------------------------------------------------------
 428
 429 void SAL_CALL FlashExportFilter::cancel(  )
 430     throw (RuntimeException)
 431 {
 432 }
 433
 434 // -----------------------------------------------------------------------------
 435
 436 // XExporter
 437 void SAL_CALL FlashExportFilter::setSourceDocument( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >& xDoc )
 438     throw (::com::sun::star::lang::IllegalArgumentException, RuntimeException)
 439 {
 440     mxDoc = xDoc;
 441 }
 442
 443 // -----------------------------------------------------------------------------
 444
 445 // XInitialization
 446 void SAL_CALL FlashExportFilter::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& /* aArguments */ )
 447     throw (Exception, RuntimeException)
 448 {
 449 }
 450
 451 // -----------------------------------------------------------------------------
 452
 453 OUString FlashExportFilter_getImplementationName ()
 454     throw (RuntimeException)
 455 {
 456     return OUString ( "com.sun.star.comp.Impress.FlashExportFilter" );
 457 }
 458
 459 // -----------------------------------------------------------------------------
 460
 461 #define SERVICE_NAME "com.sun.star.document.ExportFilter"
 462
 463 sal_Bool SAL_CALL FlashExportFilter_supportsService( const OUString& ServiceName )
 464     throw (RuntimeException)
 465 {
 466     return ServiceName == SERVICE_NAME;
 467 }
 468
 469 // -----------------------------------------------------------------------------
 470
 471 Sequence< OUString > SAL_CALL FlashExportFilter_getSupportedServiceNames(  )
 472     throw (RuntimeException)
 473 {
 474     Sequence < OUString > aRet(1);
 475     OUString* pArray = aRet.getArray();
 476     pArray[0] =  OUString ( SERVICE_NAME );
 477     return aRet;
 478 }
 479 #undef SERVICE_NAME
 480
 481 // -----------------------------------------------------------------------------
 482
 483 Reference< XInterface > SAL_CALL FlashExportFilter_createInstance( const Reference< XMultiServiceFactory > & rSMgr)
 484     throw( Exception )
 485 {
 486     return (cppu::OWeakObject*) new FlashExportFilter( comphelper::getComponentContext(rSMgr) );
 487 }
 488
 489 // -----------------------------------------------------------------------------
 490
 491 // XServiceInfo
 492 OUString SAL_CALL FlashExportFilter::getImplementationName(  )
 493     throw (RuntimeException)
 494 {
 495     return FlashExportFilter_getImplementationName();
 496 }
 497
 498 // -----------------------------------------------------------------------------
 499
 500 sal_Bool SAL_CALL FlashExportFilter::supportsService( const OUString& rServiceName )
 501     throw (RuntimeException)
 502 {
 503     return FlashExportFilter_supportsService( rServiceName );
 504 }
 505
 506 // -----------------------------------------------------------------------------
 507
 508 ::com::sun::star::uno::Sequence< OUString > SAL_CALL FlashExportFilter::getSupportedServiceNames(  )
 509     throw (RuntimeException)
 510 {
 511     return FlashExportFilter_getSupportedServiceNames();
 512 }
 513
 514 // -----------------------------------------------------------------------------
 515
 516 }
 517
 518 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */