lotuswordpro/source/filter/lwpfilter.cxx

   1 /*************************************************************************
   2  *
   3  *  The Contents of this file are made available subject to the terms of
   4  *  either of the following licenses
   5  *
   6  *         - GNU Lesser General Public License Version 2.1
   7  *         - Sun Industry Standards Source License Version 1.1
   8  *
   9  *  Sun Microsystems Inc., October, 2000
  10  *
  11  *  GNU Lesser General Public License Version 2.1
  12  *  =============================================
  13  *  Copyright 2000 by Sun Microsystems, Inc.
  14  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  15  *
  16  *  This library is free software; you can redistribute it and/or
  17  *  modify it under the terms of the GNU Lesser General Public
  18  *  License version 2.1, as published by the Free Software Foundation.
  19  *
  20  *  This library is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  *  Lesser General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU Lesser General Public
  26  *  License along with this library; if not, write to the Free Software
  27  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *  MA  02111-1307  USA
  29  *
  30  *
  31  *  Sun Industry Standards Source License Version 1.1
  32  *  =================================================
  33  *  The contents of this file are subject to the Sun Industry Standards
  34  *  Source License Version 1.1 (the "License"); You may not use this file
  35  *  except in compliance with the License. You may obtain a copy of the
  36  *  License at http://www.openoffice.org/license.html.
  37  *
  38  *  Software provided under this License is provided on an "AS IS" basis,
  39  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  40  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  41  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  42  *  See the License for the specific provisions governing your rights and
  43  *  obligations concerning the Software.
  44  *
  45  *  The Initial Developer of the Original Code is: IBM Corporation
  46  *
  47  *  Copyright: 2008 by IBM Corporation
  48  *
  49  *  All Rights Reserved.
  50  *
  51  *  Contributor(s): _______________________________________
  52  *
  53  *
  54  ************************************************************************/
  55 /*************************************************************************
  56  * @file
  57  * Circle object.
  58  ************************************************************************/
  59 /*************************************************************************
  60  * Change History
  61  * 2005-1-17  create this file.
  62  ************************************************************************/
  63 #include "lwpfilter.hxx"
  64 #include "lwpresource.hxx"
  65 //for sax stream
  66 #include "xfilter/xfsaxstream.hxx"
  67 #include "xfilter/xffilestream.hxx"
  68 //for file parser
  69 #include "lwp9reader.hxx"
  70 #include "lwpsvstream.hxx"
  71 //for container reset
  72 #include "xfilter/xffontfactory.hxx"
  73 #include "xfilter/xfstylemanager.hxx"
  74
  75 #include <osl/file.h>
  76 #include <osl/file.hxx>
  77 #include <vcl/svapp.hxx>
  78 //#include <vcl/vclasynload.hxx>
  79 #include <xmloff/attrlist.hxx>
  80 #include <com/sun/star/io/IOException.hpp>
  81 #include <com/sun/star/frame/XDesktop.hpp>
  82 #include <com/sun/star/frame/XController.hpp>
  83 #include <com/sun/star/text/XTextDocument.hpp>
  84 #include <com/sun/star/text/XText.hpp>
  85
  86 #include <tools/stream.hxx>
  87 #include <sfx2/docfile.hxx>
  88
  89 using namespace ::cppu;
  90 using namespace ::com::sun::star::lang;
  91 using namespace ::com::sun::star::frame;
  92 using namespace ::com::sun::star::text;
  93 using namespace ::com::sun::star::io;
  94 using namespace ::com::sun::star::registry;
  95 using namespace ::com::sun::star::document;
  96 using namespace ::com::sun::star::beans;
  97 using namespace ::com::sun::star::xml::sax;
  98 using namespace ::com::sun::star;
  99 using ::rtl::OUString;
 100 using ::com::sun::star::uno::Sequence;
 101
 102 sal_Bool IsWordproFile( uno::Reference<XInputStream>& rInputStream);
 103 sal_Bool IsWordproFile(rtl::OUString file);
 104
 105 LWPFilterReader::LWPFilterReader()
 106 {
 107 }
 108
 109 LWPFilterReader::~LWPFilterReader()
 110 {
 111 }
 112
 113 sal_Bool LWPFilterReader::filter( const Sequence< PropertyValue >& aDescriptor )
 114     throw( RuntimeException )
 115 {
 116         uno::Reference< XInputStream> xInputStream;
 117         ::rtl::OUString sURL;
 118     for( sal_Int32 i = 0; i < aDescriptor.getLength(); i++ )
 119         {
 120                 if( aDescriptor[i].Name == OUString::createFromAscii( "InputStream" ) )
 121                         aDescriptor[i].Value >>= xInputStream;
 122                 if( aDescriptor[i].Name == OUString::createFromAscii( "URL" ) )
 123                         aDescriptor[i].Value >>= sURL;
 124         }
 125
 126     if ( !xInputStream.is() )
 127     {
 128         OSL_ASSERT( 0 );
 129         return sal_False;
 130     }
 131
 132     OString sFileName;
 133     sFileName = ::rtl::OUStringToOString(sURL, RTL_TEXTENCODING_INFO_ASCII);
 134
 135     SvFileStream inputStream( sURL, STREAM_READ );
 136     if ( inputStream.IsEof() || ( inputStream.GetError() != SVSTREAM_OK ) )
 137         return sal_False;
 138
 139
 140     return (ReadWordproFile( &inputStream ,m_DocumentHandler) == 0);
 141 }
 142
 143 void LWPFilterReader::cancel() throw (com::sun::star::uno::RuntimeException)
 144 {
 145 }
 146
 147 uno::Reference< XInterface > LWPFilterImportFilter_CreateInstance(
 148     const uno::Reference< XMultiServiceFactory >& rSMgr ) throw( Exception )
 149 {
 150     LWPFilterImportFilter *p = new LWPFilterImportFilter( rSMgr );
 151
 152     return uno::Reference< XInterface > ( (OWeakObject* )p );
 153 }
 154
 155 Sequence< OUString > LWPFilterImportFilter::getSupportedServiceNames_Static( void ) throw ()
 156 {
 157     Sequence< OUString > aRet(1);
 158     aRet.getArray()[0] = LWPFilterImportFilter::getImplementationName_Static();
 159     return aRet;
 160 }
 161
 162 LWPFilterImportFilter::LWPFilterImportFilter( const uno::Reference< XMultiServiceFactory >& xFact )
 163 {
 164     //OUString sService = OUString( SwXMLImport_getImplementationName ); //STR_WRITER_IMPORTER_NAME
 165
 166     try
 167         {
 168         uno::Reference< XDocumentHandler > xDoc( xFact->createInstance( OUString::createFromAscii( STR_WRITER_IMPORTER_NAME ) ), UNO_QUERY );
 169
 170         LWPFilterReader *p = new LWPFilterReader;
 171         p->setDocumentHandler( xDoc );
 172
 173         uno::Reference< XImporter > xImporter = uno::Reference< XImporter >( xDoc, UNO_QUERY );
 174         rImporter = xImporter;
 175         uno::Reference< XFilter > xFilter = uno::Reference< XFilter >( p );
 176         rFilter = xFilter;
 177     }
 178     catch( Exception & )
 179     {
 180        exit( 1 );
 181     }
 182 }
 183
 184 LWPFilterImportFilter::~LWPFilterImportFilter()
 185 {
 186 }
 187
 188 sal_Bool LWPFilterImportFilter::filter( const Sequence< PropertyValue >& aDescriptor )
 189     throw( RuntimeException )
 190 {
 191     sal_Bool ret =  rFilter->filter( aDescriptor );
 192
 193     return ret;
 194 }
 195
 196 void LWPFilterImportFilter::cancel() throw (::com::sun::star::uno::RuntimeException)
 197 {
 198     rFilter->cancel();
 199 }
 200
 201 void LWPFilterImportFilter::setTargetDocument( const uno::Reference< XComponent >& xDoc )
 202     throw( IllegalArgumentException, RuntimeException )
 203 {
 204     rImporter->setTargetDocument( xDoc );
 205 }
 206
 207 OUString LWPFilterImportFilter::getImplementationName_Static() throw()
 208 {
 209     return OUString::createFromAscii( STR_IMPLEMENTATION_NAME );
 210 }
 211
 212 OUString LWPFilterImportFilter::getImplementationName() throw()
 213 {
 214     return OUString::createFromAscii( STR_IMPLEMENTATION_NAME );
 215 }
 216
 217 sal_Bool LWPFilterImportFilter::supportsService( const OUString& ServiceName ) throw()
 218 {
 219     Sequence< OUString > aSNL = getSupportedServiceNames();
 220     const OUString *pArray = aSNL.getConstArray();
 221
 222     for ( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 223         {
 224         if ( pArray[i] == ServiceName ) return sal_True;
 225         }
 226
 227     return sal_False;
 228 }
 229
 230 Sequence< OUString> LWPFilterImportFilter::getSupportedServiceNames( void ) throw()
 231 {
 232     Sequence< OUString > seq(1);
 233     seq.getArray()[0] = OUString::createFromAscii( STR_SERVICE_NAME );
 234     return seq;
 235 }
 236
 237
 238 ::rtl::OUString SAL_CALL LWPFilterImportFilter::detect( ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aDescriptor )
 239                 throw (::com::sun::star::uno::RuntimeException)
 240 {
 241         rtl::OUString   ret;
 242     rtl::OUString aTypeName;            // a name describing the type (from MediaDescriptor, usually from flat detection)
 243         // opening as template is done when a parameter tells to do so and a template filter can be detected
 244     // (otherwise no valid filter would be found) or if the detected filter is a template filter and
 245         // there is no parameter that forbids to open as template
 246         sal_Bool bOpenAsTemplate = sal_False;
 247         sal_Int32 nPropertyCount = aDescriptor.getLength();
 248          for( sal_Int32 nProperty=0; nProperty<nPropertyCount; ++nProperty )
 249         {
 250                 if( aDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("TypeName")) )
 251                 {
 252                         aDescriptor[nProperty].Value >>= aTypeName;
 253                 }
 254                 else if( aDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("AsTemplate")) )
 255                 {
 256                         bOpenAsTemplate = sal_True;
 257                 }
 258         }
 259
 260     for( sal_Int32 i = 0; i < aDescriptor.getLength(); i++ )
 261         {
 262                 OUString strTemp;
 263                 aDescriptor[i].Value >>= strTemp;
 264         if( aDescriptor[i].Name == OUString::createFromAscii( "InputStream" ) )
 265                 {
 266             uno::Reference< XInputStream> rInputStream;
 267             aDescriptor[i].Value >>= rInputStream;
 268             //
 269             // TRANSFORM IMPLEMENTATION HERE!!!!!!
 270             // and call m_DocumentHandler's SAX mDochods
 271             //
 272                         if( IsWordproFile(rInputStream) )
 273                         {
 274                                 if( aTypeName == OUString(RTL_CONSTASCII_USTRINGPARAM("wordpro_template")) )
 275                                 {
 276                                         if(!bOpenAsTemplate)
 277                                         {
 278                                                 aDescriptor.realloc( nPropertyCount + 1 );
 279                                                 aDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("AsTemplate");
 280                                                 aDescriptor[nPropertyCount].Value <<= sal_True;
 281                                         }
 282                                         return OUString::createFromAscii("wordpro_template");
 283                                 }
 284                                 else
 285                                 {
 286                                         return OUString::createFromAscii("wordpro");
 287                                 }
 288                         }
 289                         return ret;
 290         }
 291                 else if( aDescriptor[i].Name == OUString::createFromAscii( "URL" ) )
 292                 {
 293                         OUString                sURL;
 294                         OUString                sFileName;
 295
 296                         aDescriptor[i].Value >>= sURL;
 297                         /*
 298                         osl::FileBase::RC rc = osl::FileBase::getSystemPathFromFileURL( sURL, sFileName );
 299                         if(rc != osl::FileBase::E_None)
 300                         {
 301                                 SAXException except;
 302                                 except.Message = OUString( RTL_CONSTASCII_USTRINGPARAM( "GDocting system path from URL failed!"));
 303                                 throw except;
 304                         }
 305                         */
 306                         //end with .lwp:
 307                         if( IsWordproFile(sURL) )
 308                         {
 309                                 if( aTypeName == OUString(RTL_CONSTASCII_USTRINGPARAM("wordpro_template")) )
 310                                 {
 311                                         if(!bOpenAsTemplate)
 312                                         {
 313                                                 aDescriptor.realloc( nPropertyCount + 1 );
 314                                                 aDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("AsTemplate");
 315                                                 aDescriptor[nPropertyCount].Value <<= sal_True;
 316                                         }
 317                                         return OUString::createFromAscii("wordpro_template");
 318                                 }
 319                                 else
 320                                 {
 321                                         return OUString::createFromAscii("wordpro");
 322                                 }
 323                         }
 324                         return ret;
 325         }
 326         }
 327         return ret;
 328 }
 329 #if 0
 330 EXTERN_C void SAL_CALL
 331 component_getImplementationEnvironment(const sal_Char** ppEnvTypeName, uno_Environment** ppEnv)
 332 {
 333         *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
 334 }
 335
 336 EXTERN_C sal_Bool SAL_CALL
 337 component_writeInfo(void* pServiceManager, void* pRegistryKey)
 338 {
 339         if (pRegistryKey)
 340         {
 341                 try
 342                 {
 343                         uno::Reference< XRegistryKey > xKey( reinterpret_cast<XRegistryKey*>(pRegistryKey) );
 344
 345                         uno::Reference< XRegistryKey > xNewKey = xKey->createKey( OUString::createFromAscii( IMPLEMENTATION_NAME ) );
 346                         xNewKey = xNewKey->createKey( OUString::createFromAscii( "/UNO/SERVICES" ) );
 347
 348                         xNewKey->createKey( OUString::createFromAscii( STR_SERVICE_NAME ) );
 349
 350                         return sal_True;
 351                 }
 352                 catch (InvalidRegistryException &)
 353                 {
 354                         OSL_ENSURE( sal_False, "### InvalidRegistryException!" );
 355                 }
 356         }
 357         return sal_False;
 358 }
 359
 360 EXTERN_C void* SAL_CALL
 361 component_getFactory(const sal_Char* pImplName, void* pServiceManager, void* pRegistryKey)
 362 {
 363         void * pRet = 0;
 364
 365         if(pServiceManager )
 366         {
 367                 uno::Reference< XSingleServiceFactory > xRet;
 368                 uno::Reference< XMultiServiceFactory > xSMgr = reinterpret_cast< XMultiServiceFactory * > ( pServiceManager );
 369
 370                 OUString aImplementationName = OUString::createFromAscii( pImplName );
 371
 372                 if(aImplementationName == OUString::createFromAscii( STR_IMPLEMENTATION_NAME ) )
 373                 {
 374                         xRet = createSingleFactory( xSMgr, aImplementationName,
 375                                 LWPFilterImportFilter_CreateInstance,
 376                                 LWPFilterImportFilter::getSupportedServiceNames_Static() );
 377                 }
 378                 if (xRet.is())
 379                 {
 380                         xRet->acquire();
 381                         pRet = xRet.get();
 382                 }
 383         }
 384
 385         return pRet;
 386 }
 387 #endif
 388
 389  /**
 390  * @descr       decompressed small file
 391  * @param       pCompressed - real file stream
 392  * @param       pDecompressed - file decompressed, create inside, caller should delete it
 393  * @return      success - sal_True, fail - sal_False
 394  */
 395 #include "bento.hxx"
 396 using namespace OpenStormBento;
 397 #include "explode.hxx"
 398  sal_Bool Decompress(SvStream *pCompressed, SvStream * & pDecompressed)
 399 {
 400         pCompressed->Seek(0);
 401         pDecompressed = new SvMemoryStream(4096, 4096);
 402         unsigned char buffer[512];
 403         pCompressed->Read(buffer, 16);
 404         pDecompressed->Write(buffer, 16);
 405
 406         LwpSvStream * pLwpStream = new LwpSvStream(pCompressed);
 407         LtcBenContainer* pBentoContainer;
 408         ULONG ulRet = BenOpenContainer(pLwpStream, &pBentoContainer);
 409         LtcUtBenValueStream * pWordProData = (LtcUtBenValueStream *)pBentoContainer->FindValueStreamWithPropertyName("WordProData");
 410
 411         // decompressing
 412         Decompression decompress(pWordProData, pDecompressed);
 413         if (0!= decompress.explode())
 414         {
 415                 delete pDecompressed;
 416                 pDecompressed = NULL;
 417                 delete pWordProData;
 418                 delete pLwpStream;
 419                 return sal_False;
 420         }
 421
 422         sal_uInt32 nPos = pWordProData->GetSize();
 423         nPos += 0x10;
 424
 425         pCompressed->Seek(nPos);
 426         while (sal_uInt32 iRead = pCompressed->Read(buffer, 512))
 427         {
 428                 pDecompressed->Write(buffer, iRead);
 429         }
 430
 431         delete pWordProData;
 432         delete pLwpStream;
 433         return sal_True;
 434 }
 435
 436  /**
 437  * @descr       Get LwpSvStream, if small file, both compressed/decompressed stream
 438  *                  Otherwise, only normal stream
 439  * @param       pStream - real file stream
 440  * @param        LwpSvStream * , created inside, deleted outside
 441  * @param      sal_Bool, sal_True -
 442  */
 443  sal_Bool GetLwpSvStream(SvStream *pStream, LwpSvStream * & pLwpSvStream)
 444 {
 445         SvStream * pDecompressed = NULL;
 446
 447         sal_uInt32 nTag;
 448         pStream->Seek(0x10);
 449         pStream->Read(&nTag, sizeof(nTag));
 450         if (nTag != 0x3750574c) // "LWP7"
 451         {
 452                 // small file, needs decompression
 453                 if (!Decompress(pStream, pDecompressed))
 454                 {
 455                         pLwpSvStream = NULL;
 456                         return sal_True;
 457                 }
 458                 pStream->Seek(0);
 459                 pDecompressed->Seek(0);
 460         }
 461
 462         pLwpSvStream = NULL;
 463         sal_Bool bCompressed = sal_False;
 464         if (pDecompressed)
 465         {
 466                 LwpSvStream *pOriginalLwpSvStream = new LwpSvStream(pStream);
 467                 pLwpSvStream  = new LwpSvStream(pDecompressed, pOriginalLwpSvStream);
 468                 bCompressed = sal_True;
 469         }
 470         else
 471         {
 472                 pLwpSvStream  = new LwpSvStream(pStream);
 473         }
 474         return bCompressed;
 475 }
 476 int ReadWordproFile(SvStream* pStream, uno::Reference<XDocumentHandler>& xHandler)
 477 {
 478         try
 479         {
 480                 LwpSvStream *pLwpSvStream = NULL;
 481                 SvStream * pDecompressed = NULL;
 482                 if ( GetLwpSvStream(pStream, pLwpSvStream) && pLwpSvStream)
 483                 {
 484                         pDecompressed = pLwpSvStream->GetStream();
 485                 }
 486                 if (!pLwpSvStream)
 487                 {
 488                         // nothing returned, fail when uncompressing
 489                         return 1;
 490                 }
 491
 492                 IXFStream *pStrm = new XFSaxStream(xHandler);
 493                 Lwp9Reader reader(pLwpSvStream, pStrm);
 494                 //Reset all static objects,because this function may be called many times.
 495                 XFGlobalReset();
 496                 reader.Read();
 497
 498                 // added by
 499
 500                 if (pDecompressed)
 501                 {
 502                         delete pDecompressed;
 503                         LwpSvStream * pTemp = pLwpSvStream->GetCompressedStream();
 504                         delete pTemp;
 505                 }
 506                 delete pLwpSvStream;
 507                 // end added by
 508
 509                 delete pStrm;
 510                 return 0;
 511         }
 512         catch (...)
 513         {
 514                 return 1;
 515         }
 516         return 1;
 517 }
 518
 519 void ErrorMsg(int iErrCode)
 520 {
 521
 522 }
 523
 524 /**
 525  * @descr               Compare if pBuf equals with the first 16 bytes
 526  * @param       pBuf that contains the file data
 527  * @return              if equals with the Word Pro characteristic strings
 528  */
 529 sal_Bool IsWordProStr(const sal_Int8 *pBuf)
 530 {
 531         sal_Bool bRet = sal_True;
 532         const sal_Int8 pLotusLwp[] =
 533         {
 534                 0x57, 0x6F, 0x72, 0x64,
 535                 0x50, 0x72, 0x6F
 536 #if 0
 537                 , 0,
 538                 0, 0, 0, 0,
 539                 0, 0, 0, 0
 540 #endif
 541         };
 542         for(int i=0; i<sizeof(pLotusLwp); i++)
 543         {
 544                 if( pBuf[i] != pLotusLwp[i] )
 545                 {
 546                         bRet = sal_False;
 547                 }
 548         }
 549         return bRet;
 550 }
 551
 552 sal_Bool IsWordproFile(rtl::OUString file)
 553 {
 554         sal_Bool bRet = sal_False;
 555         SfxMedium aMedium( file, STREAM_STD_READ, FALSE);
 556         SvStream* pStm = aMedium.GetInStream();
 557
 558         if(pStm)
 559         {
 560                 sal_Int8 buf[16];
 561                 bRet = sal_True;
 562                 sal_Int32       nRead = -1;
 563
 564                 pStm->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 565                 pStm->Seek(STREAM_SEEK_TO_BEGIN);
 566                 nRead = pStm->Read(buf, sizeof(buf));
 567                 if( nRead< sizeof(buf) )
 568                         bRet = sal_False;
 569                 else
 570                         bRet = IsWordProStr(buf);
 571         }
 572         return bRet;
 573 }
 574
 575
 576 sal_Bool IsWordproFile( uno::Reference<XInputStream>& rInputStream)
 577 {
 578         Sequence<sal_Int8> aData;
 579         sal_Int32       nRead = -1;
 580         sal_Bool bRet = sal_False;
 581
 582         nRead = rInputStream->readBytes(aData,16);
 583         if( nRead != 16 )
 584         {
 585                 bRet = sal_False;
 586         }
 587         else
 588         {
 589                 const sal_Int8 *data = aData.getConstArray();
 590                 bRet = IsWordProStr(data);
 591         }
 592         return bRet;
 593 }