embeddedobj/source/general/xcreator.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/EntryInitModes.hpp>
  22 #include <com/sun/star/embed/XEmbedObjectFactory.hpp>
  23 #include <com/sun/star/embed/OOoEmbeddedObjectFactory.hpp>
  24 #include <com/sun/star/embed/OLEEmbeddedObjectFactory.hpp>
  25 #include <com/sun/star/beans/PropertyValue.hpp>
  26 #include <com/sun/star/beans/XPropertySet.hpp>
  27 #include <com/sun/star/container/XNameAccess.hpp>
  28 #include <com/sun/star/lang/XComponent.hpp>
  29
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <cppuhelper/weak.hxx>
  32 #include <comphelper/documentconstants.hxx>
  33 #include <officecfg/Office/Common.hxx>
  34
  35 #include <xcreator.hxx>
  36 #include <dummyobject.hxx>
  37
  38
  39 using namespace ::com::sun::star;
  40
  41 uno::Reference< uno::XInterface > SAL_CALL UNOEmbeddedObjectCreator::createInstanceInitNew(
  42                                             const uno::Sequence< sal_Int8 >& aClassID,
  43                                             const OUString& aClassName,
  44                                             const uno::Reference< embed::XStorage >& xStorage,
  45                                             const OUString& sEntName,
  46                                             const uno::Sequence< beans::PropertyValue >& lObjArgs )
  47 {
  48     if ( !xStorage.is() )
  49         throw lang::IllegalArgumentException( "No parent storage is provided!",
  50                                             static_cast< ::cppu::OWeakObject* >(this),
  51                                             3 );
  52
  53     if ( sEntName.isEmpty() )
  54         throw lang::IllegalArgumentException( "Empty element name is provided!",
  55                                             static_cast< ::cppu::OWeakObject* >(this),
  56                                             4 );
  57
  58     OUString aEmbedFactory = m_aConfigHelper.GetFactoryNameByClassID( aClassID );
  59     if ( aEmbedFactory.isEmpty() )
  60     {
  61         // use system fallback
  62         // TODO: in future users factories can be tested
  63         aEmbedFactory = "com.sun.star.embed.OLEEmbeddedObjectFactory";
  64     }
  65
  66     uno::Reference < uno::XInterface > xFact( m_xContext->getServiceManager()->createInstanceWithContext(aEmbedFactory, m_xContext) );
  67     uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY );
  68     if ( xEmbCreator.is() )
  69         return xEmbCreator->createInstanceInitNew( aClassID, aClassName, xStorage, sEntName, lObjArgs );
  70
  71     uno::Reference < embed::XEmbedObjectFactory > xEmbFact( xFact, uno::UNO_QUERY_THROW );
  72     return xEmbFact->createInstanceUserInit( aClassID, aClassName, xStorage, sEntName, embed::EntryInitModes::TRUNCATE_INIT, uno::Sequence < beans::PropertyValue >(), lObjArgs);
  73 }
  74
  75
  76 uno::Reference< uno::XInterface > SAL_CALL UNOEmbeddedObjectCreator::createInstanceInitFromEntry(
  77                                                                     const uno::Reference< embed::XStorage >& xStorage,
  78                                                                     const OUString& sEntName,
  79                                                                     const uno::Sequence< beans::PropertyValue >& aMedDescr,
  80                                                                     const uno::Sequence< beans::PropertyValue >& lObjArgs )
  81 {
  82     if ( !xStorage.is() )
  83         throw lang::IllegalArgumentException( "No parent storage is provided!",
  84                                             static_cast< ::cppu::OWeakObject* >(this),
  85                                             1 );
  86
  87     if ( sEntName.isEmpty() )
  88         throw lang::IllegalArgumentException( "Empty element name is provided!",
  89                                             static_cast< ::cppu::OWeakObject* >(this),
  90                                             2 );
  91
  92     uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY_THROW );
  93
  94     // detect entry existence
  95     if ( !xNameAccess->hasByName( sEntName ) )
  96         throw container::NoSuchElementException();
  97
  98     OUString aMediaType;
  99     OUString aEmbedFactory;
 100     if ( xStorage->isStorageElement( sEntName ) )
 101     {
 102         // the object must be based on storage
 103         uno::Reference< embed::XStorage > xSubStorage =
 104                 xStorage->openStorageElement( sEntName, embed::ElementModes::READ );
 105
 106         uno::Reference< beans::XPropertySet > xPropSet( xSubStorage, uno::UNO_QUERY_THROW );
 107
 108         try {
 109             uno::Any aAny = xPropSet->getPropertyValue("MediaType");
 110             aAny >>= aMediaType;
 111         }
 112         catch ( const uno::Exception& )
 113         {
 114         }
 115
 116         try {
 117             if ( xSubStorage.is() )
 118                 xSubStorage->dispose();
 119         }
 120         catch ( const uno::Exception& )
 121         {
 122         }
 123     }
 124     else
 125     {
 126         // the object must be based on stream
 127         // it means for now that this is an OLE object
 128
 129         // the object will be created as embedded object
 130         // after it is loaded it can detect that it is a link
 131
 132         uno::Reference< io::XStream > xSubStream =
 133                 xStorage->openStreamElement( sEntName, embed::ElementModes::READ );
 134
 135         uno::Reference< beans::XPropertySet > xPropSet( xSubStream, uno::UNO_QUERY_THROW );
 136
 137         try {
 138             uno::Any aAny = xPropSet->getPropertyValue("MediaType");
 139             aAny >>= aMediaType;
 140             if ( aMediaType == "application/vnd.sun.star.oleobject" )
 141                 aEmbedFactory = "com.sun.star.embed.OLEEmbeddedObjectFactory";
 142         }
 143         catch ( const uno::Exception& )
 144         {
 145         }
 146
 147         try {
 148             uno::Reference< lang::XComponent > xComp( xSubStream, uno::UNO_QUERY );
 149             if ( xComp.is() )
 150                 xComp->dispose();
 151         }
 152         catch ( const uno::Exception& )
 153         {
 154         }
 155     }
 156
 157     OSL_ENSURE( !aMediaType.isEmpty(), "No media type is specified for the object!" );
 158     if ( !aMediaType.isEmpty() && aEmbedFactory.isEmpty() )
 159     {
 160         aEmbedFactory = m_aConfigHelper.GetFactoryNameByMediaType( aMediaType );
 161
 162         // If no factory is found, fall back to the FileFormatVersion=6200 filter, Base only has that.
 163         if (aEmbedFactory.isEmpty() && aMediaType == MIMETYPE_OASIS_OPENDOCUMENT_DATABASE_ASCII)
 164             aEmbedFactory = m_aConfigHelper.GetFactoryNameByMediaType(MIMETYPE_VND_SUN_XML_BASE_ASCII);
 165     }
 166
 167     if ( !aEmbedFactory.isEmpty() )
 168     {
 169         uno::Reference< uno::XInterface > xFact = m_xContext->getServiceManager()->createInstanceWithContext(aEmbedFactory, m_xContext);
 170
 171         uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY );
 172         if ( xEmbCreator.is() )
 173             return xEmbCreator->createInstanceInitFromEntry( xStorage, sEntName, aMedDescr, lObjArgs );
 174
 175         uno::Reference < embed::XEmbedObjectFactory > xEmbFact( xFact, uno::UNO_QUERY );
 176         if ( xEmbFact.is() )
 177             return xEmbFact->createInstanceUserInit( uno::Sequence< sal_Int8 >(), OUString(), xStorage, sEntName, embed::EntryInitModes::DEFAULT_INIT, aMedDescr, lObjArgs);
 178     }
 179
 180     // the default object should be created, it will allow to store the contents on the next saving
 181     uno::Reference< uno::XInterface > xResult( static_cast< cppu::OWeakObject* >( new ODummyEmbeddedObject() ) );
 182     uno::Reference< embed::XEmbedPersist > xPersist( xResult, uno::UNO_QUERY_THROW );
 183     xPersist->setPersistentEntry( xStorage, sEntName, embed::EntryInitModes::DEFAULT_INIT, aMedDescr, lObjArgs );
 184     return xResult;
 185 }
 186
 187 /**
 188  * Decides if rFilter should be used to load data into a doc model or real OLE embedding should
 189  * happen. Empty return value means the later.
 190  */
 191 static OUString HandleFilter(const uno::Reference<uno::XComponentContext>& xComponentContext,
 192                              const OUString& rFilter)
 193 {
 194     OUString aRet = rFilter;
 195
 196     if (!officecfg::Office::Common::Filter::Microsoft::Import::WinWordToWriter::get(
 197             xComponentContext))
 198     {
 199         if (rFilter == "MS Word 97" || rFilter == "MS Word 2007 XML")
 200         {
 201             aRet.clear();
 202         }
 203     }
 204
 205     if (!officecfg::Office::Common::Filter::Microsoft::Import::ExcelToCalc::get(xComponentContext))
 206     {
 207         if (rFilter == "MS Excel 97" || rFilter == "Calc MS Excel 2007 XML")
 208         {
 209             aRet.clear();
 210         }
 211     }
 212     if (!officecfg::Office::Common::Filter::Microsoft::Import::PowerPointToImpress::get(
 213             xComponentContext))
 214     {
 215         if (rFilter == "MS PowerPoint 97" || rFilter == "Impress MS PowerPoint 2007 XML")
 216         {
 217             aRet.clear();
 218         }
 219     }
 220     if (!officecfg::Office::Common::Filter::Microsoft::Import::VisioToDraw::get(xComponentContext))
 221     {
 222         if (rFilter == "Visio Document")
 223         {
 224             aRet.clear();
 225         }
 226     }
 227     if (!officecfg::Office::Common::Filter::Adobe::Import::PDFToDraw::get(xComponentContext))
 228     {
 229         if (rFilter == "draw_pdf_import")
 230         {
 231             aRet.clear();
 232         }
 233     }
 234
 235     return aRet;
 236 }
 237
 238 uno::Reference< uno::XInterface > SAL_CALL UNOEmbeddedObjectCreator::createInstanceInitFromMediaDescriptor(
 239         const uno::Reference< embed::XStorage >& xStorage,
 240         const OUString& sEntName,
 241         const uno::Sequence< beans::PropertyValue >& aMediaDescr,
 242         const uno::Sequence< beans::PropertyValue >& lObjArgs )
 243 {
 244     // TODO: use lObjArgs
 245
 246     if ( !xStorage.is() )
 247         throw lang::IllegalArgumentException( "No parent storage is provided!",
 248                                             static_cast< ::cppu::OWeakObject* >(this),
 249                                             1 );
 250
 251     if ( sEntName.isEmpty() )
 252         throw lang::IllegalArgumentException( "Empty element name is provided!",
 253                                             static_cast< ::cppu::OWeakObject* >(this),
 254                                             2 );
 255
 256     uno::Reference< uno::XInterface > xResult;
 257     uno::Sequence< beans::PropertyValue > aTempMedDescr( aMediaDescr );
 258
 259     // check if there is FilterName
 260     OUString aFilterName = m_aConfigHelper.UpdateMediaDescriptorWithFilterName( aTempMedDescr, false );
 261
 262     aFilterName = HandleFilter(m_xContext, aFilterName);
 263
 264     if ( !aFilterName.isEmpty() )
 265     {
 266         // the object can be loaded by one of the office application
 267         uno::Reference< embed::XEmbeddedObjectCreator > xOOoEmbCreator =
 268                             embed::OOoEmbeddedObjectFactory::create( m_xContext );
 269
 270         xResult = xOOoEmbCreator->createInstanceInitFromMediaDescriptor( xStorage,
 271                                                                          sEntName,
 272                                                                          aTempMedDescr,
 273                                                                          lObjArgs );
 274     }
 275     else
 276     {
 277         // must be an OLE object
 278
 279         // TODO: in future, when more object types are possible this place seems
 280         // to be a weak one, probably configuration must provide a type detection service
 281         // for every factory, so any file could go through services until it is recognized
 282         // or there is no more services
 283         // Or for example the typename can be used to detect object type if typedetection
 284         // was also extended.
 285
 286         uno::Reference< embed::XEmbeddedObjectCreator > xOleEmbCreator =
 287                             embed::OLEEmbeddedObjectFactory::create( m_xContext );
 288
 289         xResult = xOleEmbCreator->createInstanceInitFromMediaDescriptor( xStorage, sEntName, aTempMedDescr, lObjArgs );
 290     }
 291
 292     return xResult;
 293 }
 294
 295
 296 uno::Reference< uno::XInterface > SAL_CALL UNOEmbeddedObjectCreator::createInstanceUserInit(
 297         const uno::Sequence< sal_Int8 >& aClassID,
 298         const OUString& sClassName,
 299         const uno::Reference< embed::XStorage >& xStorage,
 300         const OUString& sEntName,
 301         sal_Int32 nEntryConnectionMode,
 302         const uno::Sequence< beans::PropertyValue >& aArgs,
 303         const uno::Sequence< beans::PropertyValue >& aObjectArgs )
 304 {
 305     if ( !xStorage.is() )
 306         throw lang::IllegalArgumentException( "No parent storage is provided!",
 307                                             static_cast< ::cppu::OWeakObject* >(this),
 308                                             3 );
 309
 310     if ( sEntName.isEmpty() )
 311         throw lang::IllegalArgumentException( "Empty element name is provided!",
 312                                             static_cast< ::cppu::OWeakObject* >(this),
 313                                             4 );
 314
 315     OUString aEmbedFactory = m_aConfigHelper.GetFactoryNameByClassID( aClassID );
 316     uno::Reference< embed::XEmbedObjectFactory > xEmbFactory(
 317                         m_xContext->getServiceManager()->createInstanceWithContext(aEmbedFactory, m_xContext),
 318                         uno::UNO_QUERY_THROW );
 319
 320     return xEmbFactory->createInstanceUserInit( aClassID,
 321                                                 sClassName,
 322                                                 xStorage,
 323                                                 sEntName,
 324                                                 nEntryConnectionMode,
 325                                                 aArgs,
 326                                                 aObjectArgs );
 327 }
 328
 329
 330 uno::Reference< uno::XInterface > SAL_CALL UNOEmbeddedObjectCreator::createInstanceLink(
 331                                             const uno::Reference< embed::XStorage >& xStorage,
 332                                             const OUString& sEntName,
 333                                             const uno::Sequence< beans::PropertyValue >& aMediaDescr,
 334                                             const uno::Sequence< beans::PropertyValue >& lObjArgs )
 335 {
 336     uno::Reference< uno::XInterface > xResult;
 337
 338     uno::Sequence< beans::PropertyValue > aTempMedDescr( aMediaDescr );
 339
 340     // check if there is URL, URL must exist
 341     OUString aURL;
 342     for ( beans::PropertyValue const & prop : std::as_const(aTempMedDescr) )
 343         if ( prop.Name == "URL" )
 344             prop.Value >>= aURL;
 345
 346     if ( aURL.isEmpty() )
 347         throw lang::IllegalArgumentException( "No URL for the link is provided!",
 348                                         static_cast< ::cppu::OWeakObject* >(this),
 349                                         3 );
 350
 351     OUString aFilterName = m_aConfigHelper.UpdateMediaDescriptorWithFilterName( aTempMedDescr, false );
 352
 353     if ( !aFilterName.isEmpty() )
 354     {
 355         // the object can be loaded by one of the office application
 356         uno::Reference< embed::XEmbeddedObjectCreator > xOOoLinkCreator =
 357                             embed::OOoEmbeddedObjectFactory::create( m_xContext );
 358
 359         xResult = xOOoLinkCreator->createInstanceLink( xStorage,
 360                                                         sEntName,
 361                                                         aTempMedDescr,
 362                                                         lObjArgs );
 363     }
 364     else
 365     {
 366         // must be an OLE link
 367
 368         // TODO: in future, when more object types are possible this place seems
 369         // to be a weak one, probably configuration must provide a type detection service
 370         // for every factory, so any file could go through services until it is recognized
 371         // or there is no more services
 372         // Or for example the typename can be used to detect object type if typedetection
 373         // was also extended.
 374
 375         if ( !xStorage.is() )
 376             throw lang::IllegalArgumentException( "No parent storage is provided!",
 377                                                 static_cast< ::cppu::OWeakObject* >(this),
 378                                                 3 );
 379
 380         if ( sEntName.isEmpty() )
 381             throw lang::IllegalArgumentException( "Empty element name is provided!",
 382                                                 static_cast< ::cppu::OWeakObject* >(this),
 383                                                 4 );
 384
 385         uno::Reference< embed::XEmbeddedObjectCreator > xLinkCreator =
 386                             embed::OLEEmbeddedObjectFactory::create( m_xContext);
 387
 388         xResult = xLinkCreator->createInstanceLink( xStorage, sEntName, aTempMedDescr, lObjArgs );
 389     }
 390
 391     return xResult;
 392 }
 393
 394 OUString SAL_CALL UNOEmbeddedObjectCreator::getImplementationName()
 395 {
 396     return "com.sun.star.comp.embed.EmbeddedObjectCreator";
 397 }
 398
 399 sal_Bool SAL_CALL UNOEmbeddedObjectCreator::supportsService( const OUString& ServiceName )
 400 {
 401     return cppu::supportsService(this, ServiceName);
 402 }
 403
 404 uno::Sequence< OUString > SAL_CALL UNOEmbeddedObjectCreator::getSupportedServiceNames()
 405 {
 406     return { "com.sun.star.embed.EmbeddedObjectCreator", "com.sun.star.comp.embed.EmbeddedObjectCreator" };
 407 }
 408
 409 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 410 embeddedobj_UNOEmbeddedObjectCreator_get_implementation(
 411     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 412 {
 413     return cppu::acquire(new UNOEmbeddedObjectCreator(context));
 414 }
 415
 416 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */