writerfilter/source/filter/ImportFilter.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 <osl/diagnose.h>
  21 #include <com/sun/star/uno/XComponentContext.hpp>
  22 #include <com/sun/star/beans/XPropertySet.hpp>
  23 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  24 #include <com/sun/star/io/XInputStream.hpp>
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <unotools/mediadescriptor.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <oox/core/filterdetect.hxx>
  29 #include <dmapper/DomainMapper.hxx>
  30 #include <WriterFilter.hxx>
  31 #include <ooxml/OOXMLDocument.hxx>
  32 #ifdef DEBUG_IMPORT
  33 #include <iostream>
  34 #include <osl/process.h>
  35 #endif
  36
  37 #include <resourcemodel/TagLogger.hxx>
  38 #include <oox/ole/olestorage.hxx>
  39 #include <oox/ole/vbaproject.hxx>
  40 #include <oox/helper/graphichelper.hxx>
  41 using namespace ::rtl;
  42 using namespace ::com::sun::star;
  43 using utl::MediaDescriptor;
  44
  45
  46
  47 sal_Bool WriterFilter::filter( const uno::Sequence< beans::PropertyValue >& aDescriptor )
  48    throw (uno::RuntimeException, std::exception)
  49 {
  50     if( m_xSrcDoc.is() )
  51     {
  52         uno::Reference< lang::XMultiServiceFactory > xMSF(m_xContext->getServiceManager(), uno::UNO_QUERY_THROW);
  53         uno::Reference< uno::XInterface > xIfc( xMSF->createInstance("com.sun.star.comp.Writer.DocxExport"), uno::UNO_QUERY_THROW);
  54         if (!xIfc.is())
  55             return sal_False;
  56         uno::Reference< document::XExporter > xExprtr(xIfc, uno::UNO_QUERY_THROW);
  57         uno::Reference< document::XFilter > xFltr(xIfc, uno::UNO_QUERY_THROW);
  58         if (!xExprtr.is() || !xFltr.is())
  59             return sal_False;
  60         xExprtr->setSourceDocument(m_xSrcDoc);
  61         return xFltr->filter(aDescriptor);
  62     }
  63     else if (m_xDstDoc.is())
  64     {
  65         MediaDescriptor aMediaDesc( aDescriptor );
  66         bool bRepairStorage = aMediaDesc.getUnpackedValueOrDefault( "RepairPackage", false );
  67
  68         uno::Reference< io::XInputStream > xInputStream;
  69         try
  70         {
  71             // use the oox.core.FilterDetect implementation to extract the decrypted ZIP package
  72             ::oox::core::FilterDetect aDetector( m_xContext );
  73             xInputStream = aDetector.extractUnencryptedPackage( aMediaDesc );
  74         }
  75         catch( uno::Exception& )
  76         {
  77         }
  78
  79         if ( !xInputStream.is() )
  80             return sal_False;
  81
  82 #ifdef DEBUG_IMPORT
  83         OUString sURL = aMediaDesc.getUnpackedValueOrDefault( MediaDescriptor::PROP_URL(), OUString() );
  84         ::std::string sURLc = OUStringToOString(sURL, RTL_TEXTENCODING_ASCII_US).getStr();
  85
  86         writerfilter::TagLogger::Pointer_t debugLogger
  87         (writerfilter::TagLogger::getInstance("DEBUG"));
  88         debugLogger->setFileName(sURLc);
  89         debugLogger->startDocument();
  90
  91         writerfilter::TagLogger::Pointer_t dmapperLogger
  92         (writerfilter::TagLogger::getInstance("DOMAINMAPPER"));
  93         dmapperLogger->setFileName(sURLc);
  94         dmapperLogger->startDocument();
  95 #endif
  96
  97     writerfilter::dmapper::SourceDocumentType eType =
  98         (m_sFilterName == "writer_MS_Word_2007" || m_sFilterName == "writer_MS_Word_2007_Template" ||
  99          m_sFilterName == "writer_OOXML" || m_sFilterName == "writer_OOXML_Text_Template" ) ?
 100             writerfilter::dmapper::DOCUMENT_OOXML : writerfilter::dmapper::DOCUMENT_DOC;
 101
 102     writerfilter::dmapper::DomainMapper* aDomainMapper = new writerfilter::dmapper::DomainMapper(m_xContext, xInputStream, m_xDstDoc, bRepairStorage, eType, uno::Reference<text::XTextRange>());
 103     writerfilter::Stream::Pointer_t pStream(aDomainMapper);
 104     //create the tokenizer and domain mapper
 105     if( eType == writerfilter::dmapper::DOCUMENT_OOXML )
 106     {
 107         writerfilter::ooxml::OOXMLStream::Pointer_t pDocStream = writerfilter::ooxml::OOXMLDocumentFactory::createStream(m_xContext, xInputStream, bRepairStorage);
 108         uno::Reference<task::XStatusIndicator> xStatusIndicator = aMediaDesc.getUnpackedValueOrDefault(MediaDescriptor::PROP_STATUSINDICATOR(), uno::Reference<task::XStatusIndicator>());
 109         writerfilter::ooxml::OOXMLDocument::Pointer_t pDocument(writerfilter::ooxml::OOXMLDocumentFactory::createDocument(pDocStream, xStatusIndicator));
 110
 111         uno::Reference<frame::XModel> xModel(m_xDstDoc, uno::UNO_QUERY_THROW);
 112         pDocument->setModel(xModel);
 113
 114         uno::Reference<drawing::XDrawPageSupplier> xDrawings
 115             (m_xDstDoc, uno::UNO_QUERY_THROW);
 116         uno::Reference<drawing::XDrawPage> xDrawPage
 117             (xDrawings->getDrawPage(), uno::UNO_SET_THROW);
 118         pDocument->setDrawPage(xDrawPage);
 119
 120         pDocument->resolve(*pStream);
 121
 122         // Adding some properties to the document's grab bag for interoperability purposes:
 123         uno::Sequence<beans::PropertyValue> aGrabBagProperties(10);
 124
 125         // Adding the saved Theme DOM
 126         aGrabBagProperties[0].Name = "OOXTheme";
 127         aGrabBagProperties[0].Value = uno::makeAny( pDocument->getThemeDom() );
 128
 129         // Adding the saved custom xml DOM
 130         aGrabBagProperties[1].Name = "OOXCustomXml";
 131         aGrabBagProperties[1].Value = uno::makeAny( pDocument->getCustomXmlDomList() );
 132         aGrabBagProperties[2].Name = "OOXCustomXmlProps";
 133         aGrabBagProperties[2].Value = uno::makeAny( pDocument->getCustomXmlDomPropsList() );
 134
 135         // Adding the saved ActiveX DOM
 136         aGrabBagProperties[3].Name = "OOXActiveX";
 137         aGrabBagProperties[3].Value = uno::makeAny( pDocument->getActiveXDomList() );
 138         aGrabBagProperties[4].Name = "OOXActiveXBin";
 139         aGrabBagProperties[4].Value = uno::makeAny( pDocument->getActiveXBinList() );
 140
 141         // Adding the saved w:themeFontLang setting
 142         aGrabBagProperties[5].Name = "ThemeFontLangProps";
 143         aGrabBagProperties[5].Value = uno::makeAny( aDomainMapper->GetThemeFontLangProperties() );
 144
 145         // Adding the saved Glossary Documnet DOM to the document's grab bag
 146         aGrabBagProperties[6].Name = "OOXGlossary";
 147         aGrabBagProperties[6].Value = uno::makeAny( pDocument->getGlossaryDocDom() );
 148         aGrabBagProperties[7].Name = "OOXGlossaryDom";
 149         aGrabBagProperties[7].Value = uno::makeAny( pDocument->getGlossaryDomList() );
 150
 151         // Adding the saved embedding document to document's grab bag
 152         aGrabBagProperties[8].Name = "OOXEmbeddings";
 153         aGrabBagProperties[8].Value = uno::makeAny( pDocument->getEmbeddingsList() );
 154
 155         // Adding the saved compat settings
 156         aGrabBagProperties[9].Name = "CompatSettings";
 157         aGrabBagProperties[9].Value = uno::makeAny( aDomainMapper->GetCompatSettings() );
 158
 159         putPropertiesToDocumentGrabBag( aGrabBagProperties );
 160
 161         writerfilter::ooxml::OOXMLStream::Pointer_t  pVBAProjectStream(writerfilter::ooxml::OOXMLDocumentFactory::createStream( pDocStream, writerfilter::ooxml::OOXMLStream::VBAPROJECT ));
 162         oox::StorageRef xVbaPrjStrg( new ::oox::ole::OleStorage( m_xContext, pVBAProjectStream->getDocumentStream(), false ) );
 163         if( xVbaPrjStrg.get() && xVbaPrjStrg->isStorage() )
 164         {
 165             ::oox::ole::VbaProject aVbaProject( m_xContext, xModel, "Writer" );
 166             uno::Reference< frame::XFrame > xFrame = aMediaDesc.getUnpackedValueOrDefault(  MediaDescriptor::PROP_FRAME(), uno::Reference< frame::XFrame > () );
 167
 168             // if no XFrame try fallback to what we can glean from the Model
 169             if ( !xFrame.is() )
 170             {
 171                 uno::Reference< frame::XController > xController =  xModel->getCurrentController();
 172                 xFrame =  xController.is() ? xController->getFrame() : NULL;
 173             }
 174
 175             oox::GraphicHelper gHelper( m_xContext, xFrame, xVbaPrjStrg );
 176             aVbaProject.importVbaProject( *xVbaPrjStrg, gHelper );
 177         }
 178     }
 179
 180     pStream.reset();
 181 #ifdef DEBUG_IMPORT
 182
 183     dmapperLogger->endDocument();
 184     debugLogger->endDocument();
 185 #endif
 186
 187     return sal_True;
 188     }
 189     return sal_False;
 190 }
 191
 192
 193 void WriterFilter::cancel(  ) throw (uno::RuntimeException, std::exception)
 194 {
 195 }
 196
 197
 198
 199 void WriterFilter::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
 200    throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 201 {
 202    m_xDstDoc = xDoc;
 203
 204    // Set some compatibility options that are valid for all the formats
 205    uno::Reference< lang::XMultiServiceFactory > xFactory( xDoc, uno::UNO_QUERY );
 206    uno::Reference< beans::XPropertySet > xSettings( xFactory->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY );
 207
 208    xSettings->setPropertyValue( "AddFrameOffsets", uno::makeAny( sal_True ) );
 209    xSettings->setPropertyValue( "UseOldNumbering", uno::makeAny( sal_False ) );
 210    xSettings->setPropertyValue( "IgnoreFirstLineIndentInNumbering", uno::makeAny( sal_False ) );
 211    xSettings->setPropertyValue( "DoNotResetParaAttrsForNumFont", uno::makeAny( sal_False ) );
 212    xSettings->setPropertyValue( "UseFormerLineSpacing", uno::makeAny( sal_False ) );
 213    xSettings->setPropertyValue( "AddParaSpacingToTableCells", uno::makeAny( sal_True ) );
 214    xSettings->setPropertyValue( "UseFormerObjectPositioning", uno::makeAny( sal_False ) );
 215    xSettings->setPropertyValue( "ConsiderTextWrapOnObjPos", uno::makeAny( sal_True ) );
 216    xSettings->setPropertyValue( "UseFormerTextWrapping", uno::makeAny( sal_False ) );
 217    xSettings->setPropertyValue( "TableRowKeep", uno::makeAny( sal_True ) );
 218    xSettings->setPropertyValue( "IgnoreTabsAndBlanksForLineCalculation", uno::makeAny( sal_True ) );
 219    xSettings->setPropertyValue( "InvertBorderSpacing", uno::makeAny( sal_True ) );
 220    xSettings->setPropertyValue( "CollapseEmptyCellPara", uno::makeAny( sal_True ) );
 221    xSettings->setPropertyValue( "TabOverflow", uno::makeAny( sal_True ) );
 222    xSettings->setPropertyValue( "UnbreakableNumberings", uno::makeAny( sal_True ) );
 223
 224    xSettings->setPropertyValue("FloattableNomargins", uno::makeAny( sal_True ));
 225    xSettings->setPropertyValue( "ClippedPictures", uno::makeAny( sal_True ) );
 226    xSettings->setPropertyValue( "BackgroundParaOverDrawings", uno::makeAny( sal_True ) );
 227    xSettings->setPropertyValue( "TabOverMargin", uno::makeAny( sal_True ) );
 228    xSettings->setPropertyValue("PropLineSpacingShrinksFirstLine", uno::makeAny(sal_True));
 229 }
 230
 231 void WriterFilter::setSourceDocument( const uno::Reference< lang::XComponent >& xDoc )
 232    throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 233 {
 234    m_xSrcDoc = xDoc;
 235 }
 236
 237
 238
 239 void WriterFilter::initialize( const uno::Sequence< uno::Any >& aArguments ) throw (uno::Exception, uno::RuntimeException, std::exception)
 240 {
 241    uno::Sequence < beans::PropertyValue > aAnySeq;
 242    sal_Int32 nLength = aArguments.getLength();
 243    if ( nLength && ( aArguments[0] >>= aAnySeq ) )
 244    {
 245        const beans::PropertyValue * pValue = aAnySeq.getConstArray();
 246        nLength = aAnySeq.getLength();
 247        for ( sal_Int32 i = 0 ; i < nLength; i++)
 248        {
 249            if ( pValue[i].Name == "Type" )
 250            {
 251                pValue[i].Value >>= m_sFilterName;
 252                break;
 253            }
 254        }
 255    }
 256 }
 257
 258
 259 OUString WriterFilter_getImplementationName () throw (uno::RuntimeException)
 260 {
 261    return OUString ( "com.sun.star.comp.Writer.WriterFilter" );
 262 }
 263
 264 uno::Sequence< OUString > WriterFilter_getSupportedServiceNames(  ) throw (uno::RuntimeException)
 265 {
 266    uno::Sequence < OUString > aRet(2);
 267    OUString* pArray = aRet.getArray();
 268    pArray[0] = "com.sun.star.document.ImportFilter";
 269    pArray[1] = "com.sun.star.document.ExportFilter";
 270    return aRet;
 271 }
 272
 273 uno::Reference< uno::XInterface > WriterFilter_createInstance( const uno::Reference< uno::XComponentContext >& xContext)
 274                 throw( uno::Exception )
 275 {
 276    return (cppu::OWeakObject*) new WriterFilter( xContext );
 277 }
 278
 279
 280
 281 OUString WriterFilter::getImplementationName(  ) throw (uno::RuntimeException, std::exception)
 282 {
 283    return WriterFilter_getImplementationName();
 284 }
 285
 286
 287 sal_Bool WriterFilter::supportsService( const OUString& rServiceName ) throw (uno::RuntimeException, std::exception)
 288 {
 289     return cppu::supportsService( this, rServiceName );
 290 }
 291
 292
 293 uno::Sequence< OUString > WriterFilter::getSupportedServiceNames(  ) throw (uno::RuntimeException, std::exception)
 294 {
 295     return WriterFilter_getSupportedServiceNames();
 296 }
 297
 298 void WriterFilter::putPropertiesToDocumentGrabBag( const uno::Sequence< beans::PropertyValue >& aProperties )
 299 {
 300     try
 301     {
 302         uno::Reference<beans::XPropertySet> xDocProps(m_xDstDoc, uno::UNO_QUERY);
 303         if( xDocProps.is() )
 304         {
 305             uno::Reference<beans::XPropertySetInfo> xPropsInfo = xDocProps->getPropertySetInfo();
 306
 307             const OUString aGrabBagPropName = "InteropGrabBag";
 308             if( xPropsInfo.is() && xPropsInfo->hasPropertyByName( aGrabBagPropName ) )
 309             {
 310                 // get existing grab bag
 311                 uno::Sequence<beans::PropertyValue> aGrabBag;
 312                 xDocProps->getPropertyValue( aGrabBagPropName ) >>= aGrabBag;
 313                 sal_Int32 length = aGrabBag.getLength();
 314
 315                 // update grab bag size to contain the new items
 316                 aGrabBag.realloc( length + aProperties.getLength() );
 317
 318                 // put the new items
 319                 for( sal_Int32 i=0; i < aProperties.getLength(); ++i )
 320                 {
 321                     aGrabBag[length + i].Name = aProperties[i].Name;
 322                     aGrabBag[length + i].Value = aProperties[i].Value;
 323                 }
 324
 325                 // put it back to the document
 326                 xDocProps->setPropertyValue( aGrabBagPropName, uno::Any( aGrabBag ) );
 327             }
 328         }
 329     }
 330     catch(const uno::Exception&)
 331     {
 332         SAL_WARN("writerfilter","Failed to save documents grab bag");
 333     }
 334 }
 335
 336 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */