comphelper/source/misc/mimeconfighelper.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/beans/PropertyValue.hpp>
  21 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  22 #include <com/sun/star/container/XContainerQuery.hpp>
  23 #include <com/sun/star/document/XTypeDetection.hpp>
  24
  25 #include <comphelper/fileformat.h>
  26 #include <comphelper/mimeconfighelper.hxx>
  27 #include <comphelper/processfactory.hxx>
  28 #include <comphelper/classids.hxx>
  29 #include <comphelper/sequenceashashmap.hxx>
  30 #include <comphelper/documentconstants.hxx>
  31
  32
  33 using namespace ::com::sun::star;
  34 using namespace comphelper;
  35
  36 //-----------------------------------------------------------------------
  37 MimeConfigurationHelper::MimeConfigurationHelper( const uno::Reference< uno::XComponentContext >& rxContext )
  38 : m_xContext( rxContext )
  39 {
  40     if ( !m_xContext.is() )
  41         throw uno::RuntimeException();
  42 }
  43
  44 //-----------------------------------------------------------------------
  45 OUString MimeConfigurationHelper::GetStringClassIDRepresentation( const uno::Sequence< sal_Int8 >& aClassID )
  46 {
  47     OUString aResult;
  48
  49     if ( aClassID.getLength() == 16 )
  50     {
  51         for ( sal_Int32 nInd = 0; nInd < aClassID.getLength(); nInd++ )
  52         {
  53             if ( nInd == 4 || nInd == 6 || nInd == 8 || nInd == 10 )
  54                 aResult += "-";
  55
  56             sal_Int32 nDigit1 = (sal_Int32)( (sal_uInt8)aClassID[nInd] / 16 );
  57             sal_Int32 nDigit2 = (sal_uInt8)aClassID[nInd] % 16;
  58             aResult += OUString::valueOf( nDigit1, 16 );
  59             aResult += OUString::valueOf( nDigit2, 16 );
  60         }
  61     }
  62
  63     return aResult;
  64 }
  65
  66 //-----------------------------------------------------------------------
  67 sal_uInt8 GetDigit_Impl( sal_Char aChar )
  68 {
  69     if ( aChar >= '0' && aChar <= '9' )
  70         return aChar - '0';
  71     else if ( aChar >= 'a' && aChar <= 'f' )
  72         return aChar - 'a' + 10;
  73     else if ( aChar >= 'A' && aChar <= 'F' )
  74         return aChar - 'A' + 10;
  75     else
  76         return 16;
  77 }
  78
  79 //-----------------------------------------------------------------------
  80 uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassIDRepresentation( const OUString& aClassID )
  81 {
  82     sal_Int32 nLength = aClassID.getLength();
  83     if ( nLength == 36 )
  84     {
  85         OString aCharClassID = OUStringToOString( aClassID, RTL_TEXTENCODING_ASCII_US );
  86         const sal_Char* pString = aCharClassID.getStr();
  87         if ( pString )
  88         {
  89             uno::Sequence< sal_Int8 > aResult( 16 );
  90
  91             sal_Int32 nStrPointer = 0;
  92             sal_Int32 nSeqInd = 0;
  93             while( nSeqInd < 16 && nStrPointer + 1 < nLength )
  94             {
  95                 sal_uInt8 nDigit1 = GetDigit_Impl( pString[nStrPointer++] );
  96                 sal_uInt8 nDigit2 = GetDigit_Impl( pString[nStrPointer++] );
  97
  98                 if ( nDigit1 > 15 || nDigit2 > 15 )
  99                     break;
 100
 101                 aResult[nSeqInd++] = (sal_Int8)( nDigit1 * 16 + nDigit2 );
 102
 103                 if ( nStrPointer < nLength && pString[nStrPointer] == '-' )
 104                     nStrPointer++;
 105             }
 106
 107             if ( nSeqInd == 16 && nStrPointer == nLength )
 108                 return aResult;
 109         }
 110     }
 111
 112     return uno::Sequence< sal_Int8 >();
 113 }
 114
 115 //-----------------------------------------------------------------------
 116 uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetConfigurationByPath( const OUString& aPath )
 117 {
 118     osl::MutexGuard aGuard( m_aMutex );
 119
 120     uno::Reference< container::XNameAccess > xConfig;
 121
 122     try
 123     {
 124         if ( !m_xConfigProvider.is() )
 125             m_xConfigProvider = configuration::theDefaultProvider::get( m_xContext );
 126
 127         uno::Sequence< uno::Any > aArgs( 1 );
 128         beans::PropertyValue aPathProp;
 129         aPathProp.Name = "nodepath";
 130         aPathProp.Value <<= aPath;
 131         aArgs[0] <<= aPathProp;
 132
 133         xConfig = uno::Reference< container::XNameAccess >(
 134                             m_xConfigProvider->createInstanceWithArguments(
 135                                 OUString( "com.sun.star.configuration.ConfigurationAccess" ),
 136                                 aArgs ),
 137                             uno::UNO_QUERY );
 138     }
 139     catch( uno::Exception& )
 140     {}
 141
 142     return xConfig;
 143 }
 144
 145 //-----------------------------------------------------------------------
 146 uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetObjConfiguration()
 147 {
 148     osl::MutexGuard aGuard( m_aMutex );
 149
 150     if ( !m_xObjectConfig.is() )
 151         m_xObjectConfig = GetConfigurationByPath(
 152                                          OUString( "/org.openoffice.Office.Embedding/Objects" ) );
 153
 154     return m_xObjectConfig;
 155 }
 156
 157 //-----------------------------------------------------------------------
 158 uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetVerbsConfiguration()
 159 {
 160     osl::MutexGuard aGuard( m_aMutex );
 161
 162     if ( !m_xVerbsConfig.is() )
 163         m_xVerbsConfig = GetConfigurationByPath(
 164                                         OUString( "/org.openoffice.Office.Embedding/Verbs" ));
 165
 166     return m_xVerbsConfig;
 167 }
 168
 169 //-----------------------------------------------------------------------
 170 uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetMediaTypeConfiguration()
 171 {
 172     osl::MutexGuard aGuard( m_aMutex );
 173
 174     if ( !m_xMediaTypeConfig.is() )
 175         m_xMediaTypeConfig = GetConfigurationByPath(
 176                     OUString( "/org.openoffice.Office.Embedding/MimeTypeClassIDRelations" ));
 177
 178     return m_xMediaTypeConfig;
 179 }
 180
 181 //-----------------------------------------------------------------------
 182 uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetFilterFactory()
 183 {
 184     osl::MutexGuard aGuard( m_aMutex );
 185
 186     if ( !m_xFilterFactory.is() )
 187         m_xFilterFactory.set(
 188             m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.FilterFactory", m_xContext),
 189             uno::UNO_QUERY );
 190
 191     return m_xFilterFactory;
 192 }
 193
 194 //-------------------------------------------------------------------------
 195 OUString MimeConfigurationHelper::GetDocServiceNameFromFilter( const OUString& aFilterName )
 196 {
 197     OUString aDocServiceName;
 198
 199     try
 200     {
 201         uno::Reference< container::XNameAccess > xFilterFactory(
 202             GetFilterFactory(),
 203             uno::UNO_SET_THROW );
 204
 205         uno::Any aFilterAnyData = xFilterFactory->getByName( aFilterName );
 206         uno::Sequence< beans::PropertyValue > aFilterData;
 207         if ( aFilterAnyData >>= aFilterData )
 208         {
 209             for ( sal_Int32 nInd = 0; nInd < aFilterData.getLength(); nInd++ )
 210                 if ( aFilterData[nInd].Name == "DocumentService" )
 211                     aFilterData[nInd].Value >>= aDocServiceName;
 212         }
 213     }
 214     catch( uno::Exception& )
 215     {}
 216
 217     return aDocServiceName;
 218 }
 219
 220 //-------------------------------------------------------------------------
 221 OUString MimeConfigurationHelper::GetDocServiceNameFromMediaType( const OUString& aMediaType )
 222 {
 223     uno::Reference< container::XContainerQuery > xTypeCFG(
 224             m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", m_xContext),
 225             uno::UNO_QUERY );
 226
 227     if ( xTypeCFG.is() )
 228     {
 229         try
 230         {
 231             // make query for all types matching the properties
 232             uno::Sequence < beans::NamedValue > aSeq( 1 );
 233             aSeq[0].Name = "MediaType";
 234             aSeq[0].Value <<= aMediaType;
 235
 236             uno::Reference < container::XEnumeration > xEnum = xTypeCFG->createSubSetEnumerationByProperties( aSeq );
 237             while ( xEnum->hasMoreElements() )
 238             {
 239                 uno::Sequence< beans::PropertyValue > aType;
 240                 if ( xEnum->nextElement() >>= aType )
 241                 {
 242                     for ( sal_Int32 nInd = 0; nInd < aType.getLength(); nInd++ )
 243                     {
 244                         OUString aFilterName;
 245                         if ( aType[nInd].Name == "PreferredFilter"
 246                           && ( aType[nInd].Value >>= aFilterName ) && !aFilterName.isEmpty() )
 247                         {
 248                             OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName );
 249                             if ( !aDocumentName.isEmpty() )
 250                                 return aDocumentName;
 251                         }
 252                     }
 253                 }
 254             }
 255         }
 256         catch( uno::Exception& )
 257         {}
 258     }
 259
 260     return OUString();
 261 }
 262
 263 //-------------------------------------------------------------------------
 264 sal_Bool MimeConfigurationHelper::GetVerbByShortcut( const OUString& aVerbShortcut,
 265                                                 embed::VerbDescriptor& aDescriptor )
 266 {
 267     sal_Bool bResult = sal_False;
 268
 269     uno::Reference< container::XNameAccess > xVerbsConfig = GetVerbsConfiguration();
 270     uno::Reference< container::XNameAccess > xVerbsProps;
 271     try
 272     {
 273         if ( xVerbsConfig.is() && ( xVerbsConfig->getByName( aVerbShortcut ) >>= xVerbsProps ) && xVerbsProps.is() )
 274         {
 275             embed::VerbDescriptor aTempDescr;
 276             if ( ( xVerbsProps->getByName( OUString( "VerbID" ) ) >>= aTempDescr.VerbID )
 277               && ( xVerbsProps->getByName( OUString( "VerbUIName" ) ) >>= aTempDescr.VerbName )
 278               && ( xVerbsProps->getByName( OUString( "VerbFlags" ) ) >>= aTempDescr.VerbFlags )
 279               && ( xVerbsProps->getByName( OUString( "VerbAttributes" ) ) >>= aTempDescr.VerbAttributes ) )
 280             {
 281                 aDescriptor = aTempDescr;
 282                 bResult = sal_True;
 283             }
 284         }
 285     }
 286     catch( uno::Exception& )
 287     {
 288     }
 289
 290     return bResult;
 291 }
 292
 293 //-------------------------------------------------------------------------
 294 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjPropsFromConfigEntry(
 295                                             const uno::Sequence< sal_Int8 >& aClassID,
 296                                             const uno::Reference< container::XNameAccess >& xObjectProps )
 297 {
 298     uno::Sequence< beans::NamedValue > aResult;
 299
 300     if ( aClassID.getLength() == 16 )
 301     {
 302         try
 303         {
 304             uno::Sequence< OUString > aObjPropNames = xObjectProps->getElementNames();
 305
 306             aResult.realloc( aObjPropNames.getLength() + 1 );
 307             aResult[0].Name = "ClassID";
 308             aResult[0].Value <<= aClassID;
 309
 310             for ( sal_Int32 nInd = 0; nInd < aObjPropNames.getLength(); nInd++ )
 311             {
 312                 aResult[nInd + 1].Name = aObjPropNames[nInd];
 313
 314                 if ( aObjPropNames[nInd] == "ObjectVerbs" )
 315                 {
 316                     uno::Sequence< OUString > aVerbShortcuts;
 317                     if ( xObjectProps->getByName( aObjPropNames[nInd] ) >>= aVerbShortcuts )
 318                     {
 319                         uno::Sequence< embed::VerbDescriptor > aVerbDescriptors( aVerbShortcuts.getLength() );
 320                         for ( sal_Int32 nVerbI = 0; nVerbI < aVerbShortcuts.getLength(); nVerbI++ )
 321                             if ( !GetVerbByShortcut( aVerbShortcuts[nVerbI], aVerbDescriptors[nVerbI] ) )
 322                                 throw uno::RuntimeException();
 323
 324                         aResult[nInd+1].Value <<= aVerbDescriptors;
 325                     }
 326                     else
 327                         throw uno::RuntimeException();
 328                 }
 329                 else
 330                     aResult[nInd+1].Value = xObjectProps->getByName( aObjPropNames[nInd] );
 331             }
 332         }
 333         catch( uno::Exception& )
 334         {
 335             aResult.realloc( 0 );
 336         }
 337     }
 338
 339     return aResult;
 340 }
 341
 342 //-----------------------------------------------------------------------
 343 OUString MimeConfigurationHelper::GetExplicitlyRegisteredObjClassID( const OUString& aMediaType )
 344 {
 345     OUString aStringClassID;
 346
 347     uno::Reference< container::XNameAccess > xMediaTypeConfig = GetMediaTypeConfiguration();
 348     try
 349     {
 350         if ( xMediaTypeConfig.is() )
 351             xMediaTypeConfig->getByName( aMediaType ) >>= aStringClassID;
 352     }
 353     catch( uno::Exception& )
 354     {
 355     }
 356
 357     return aStringClassID;
 358
 359 }
 360
 361 //-----------------------------------------------------------------------
 362 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByStringClassID(
 363                                                                 const OUString& aStringClassID )
 364 {
 365     uno::Sequence< beans::NamedValue > aObjProps;
 366
 367     uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID );
 368     if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
 369     {
 370         aObjProps.realloc(2);
 371         aObjProps[0].Name = "ObjectFactory";
 372         aObjProps[0].Value <<= OUString( "com.sun.star.embed.OOoSpecialEmbeddedObjectFactory" );
 373         aObjProps[1].Name = "ClassID";
 374         aObjProps[1].Value <<= aClassID;
 375         return aObjProps;
 376     }
 377
 378     if ( aClassID.getLength() == 16 )
 379     {
 380         uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
 381         uno::Reference< container::XNameAccess > xObjectProps;
 382         try
 383         {
 384             // TODO/LATER: allow to provide ClassID string in any format, only digits are counted
 385             if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
 386                 aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps );
 387         }
 388         catch( uno::Exception& )
 389         {
 390         }
 391     }
 392
 393     return aObjProps;
 394 }
 395
 396 //-----------------------------------------------------------------------
 397 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByClassID(
 398                                                                 const uno::Sequence< sal_Int8 >& aClassID )
 399 {
 400     uno::Sequence< beans::NamedValue > aObjProps;
 401     if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
 402     {
 403         aObjProps.realloc(2);
 404         aObjProps[0].Name = "ObjectFactory";
 405         aObjProps[0].Value <<= OUString( "com.sun.star.embed.OOoSpecialEmbeddedObjectFactory" );
 406         aObjProps[1].Name = "ClassID";
 407         aObjProps[1].Value <<= aClassID;
 408     }
 409
 410     OUString aStringClassID = GetStringClassIDRepresentation( aClassID );
 411     if ( !aStringClassID.isEmpty() )
 412     {
 413         uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
 414         uno::Reference< container::XNameAccess > xObjectProps;
 415         try
 416         {
 417             if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
 418                 aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps );
 419         }
 420         catch( uno::Exception& )
 421         {
 422         }
 423     }
 424
 425     return aObjProps;
 426 }
 427
 428 //-----------------------------------------------------------------------
 429 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByMediaType( const OUString& aMediaType )
 430 {
 431     uno::Sequence< beans::NamedValue > aObject =
 432                                     GetObjectPropsByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) );
 433     if ( aObject.getLength() )
 434         return aObject;
 435
 436     OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType );
 437     if ( !aDocumentName.isEmpty() )
 438         return GetObjectPropsByDocumentName( aDocumentName );
 439
 440     return uno::Sequence< beans::NamedValue >();
 441 }
 442
 443 //-----------------------------------------------------------------------
 444 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByFilter( const OUString& aFilterName )
 445 {
 446     OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName );
 447     if ( !aDocumentName.isEmpty() )
 448         return GetObjectPropsByDocumentName( aDocumentName );
 449
 450     return uno::Sequence< beans::NamedValue >();
 451 }
 452
 453 //-----------------------------------------------------------------------
 454 uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByDocumentName( const OUString& aDocName )
 455 {
 456     if ( !aDocName.isEmpty() )
 457     {
 458         uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
 459         if ( xObjConfig.is() )
 460         {
 461             try
 462             {
 463                 uno::Sequence< OUString > aClassIDs = xObjConfig->getElementNames();
 464                 for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ )
 465                 {
 466                     uno::Reference< container::XNameAccess > xObjectProps;
 467                     OUString aEntryDocName;
 468
 469                     if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is()
 470                       && ( xObjectProps->getByName( OUString( "ObjectDocumentServiceName" ) ) >>= aEntryDocName )
 471                       && aEntryDocName == aDocName )
 472                     {
 473                         return GetObjPropsFromConfigEntry( GetSequenceClassIDRepresentation( aClassIDs[nInd] ),
 474                                                             xObjectProps );
 475                     }
 476                 }
 477             }
 478             catch( uno::Exception& )
 479             {}
 480         }
 481     }
 482
 483     return uno::Sequence< beans::NamedValue >();
 484 }
 485
 486 //-----------------------------------------------------------------------
 487 OUString MimeConfigurationHelper::GetFactoryNameByClassID( const uno::Sequence< sal_Int8 >& aClassID )
 488 {
 489     return GetFactoryNameByStringClassID( GetStringClassIDRepresentation( aClassID ) );
 490 }
 491
 492 //-----------------------------------------------------------------------
 493 OUString MimeConfigurationHelper::GetFactoryNameByStringClassID( const OUString& aStringClassID )
 494 {
 495     OUString aResult;
 496
 497     if ( !aStringClassID.isEmpty() )
 498     {
 499         uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
 500         uno::Reference< container::XNameAccess > xObjectProps;
 501         try
 502         {
 503             if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
 504                 xObjectProps->getByName( OUString( "ObjectFactory" ) ) >>= aResult;
 505         }
 506         catch( uno::Exception& )
 507         {
 508             uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID );
 509             if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
 510                 return OUString( "com.sun.star.embed.OOoSpecialEmbeddedObjectFactory" );
 511         }
 512     }
 513
 514     return aResult;
 515 }
 516
 517 //-----------------------------------------------------------------------
 518 OUString MimeConfigurationHelper::GetFactoryNameByDocumentName( const OUString& aDocName )
 519 {
 520     OUString aResult;
 521
 522     if ( !aDocName.isEmpty() )
 523     {
 524         uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
 525         if ( xObjConfig.is() )
 526         {
 527             try
 528             {
 529                 uno::Sequence< OUString > aClassIDs = xObjConfig->getElementNames();
 530                 for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ )
 531                 {
 532                     uno::Reference< container::XNameAccess > xObjectProps;
 533                     OUString aEntryDocName;
 534
 535                     if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is()
 536                       && ( xObjectProps->getByName(
 537                                   OUString( "ObjectDocumentServiceName" ) ) >>= aEntryDocName )
 538                       && aEntryDocName == aDocName )
 539                     {
 540                         xObjectProps->getByName( OUString( "ObjectFactory" ) ) >>= aResult;
 541                         break;
 542                     }
 543                 }
 544             }
 545             catch( uno::Exception& )
 546             {}
 547         }
 548     }
 549
 550     return aResult;
 551 }
 552
 553
 554 //-----------------------------------------------------------------------
 555 OUString MimeConfigurationHelper::GetFactoryNameByMediaType( const OUString& aMediaType )
 556 {
 557     OUString aResult = GetFactoryNameByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) );
 558
 559     if ( aResult.isEmpty() )
 560     {
 561         OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType );
 562         if ( !aDocumentName.isEmpty() )
 563             aResult = GetFactoryNameByDocumentName( aDocumentName );
 564     }
 565
 566     return aResult;
 567 }
 568
 569 //-----------------------------------------------------------------------
 570 OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName(
 571                                         uno::Sequence< beans::PropertyValue >& aMediaDescr,
 572                                         sal_Bool bIgnoreType )
 573 {
 574     OUString aFilterName;
 575
 576     for ( sal_Int32 nInd = 0; nInd < aMediaDescr.getLength(); nInd++ )
 577         if ( aMediaDescr[nInd].Name == "FilterName" )
 578             aMediaDescr[nInd].Value >>= aFilterName;
 579
 580     if ( aFilterName.isEmpty() )
 581     {
 582         // filter name is not specified, so type detection should be done
 583
 584         uno::Reference< document::XTypeDetection > xTypeDetection(
 585                 m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", m_xContext),
 586                 uno::UNO_QUERY );
 587
 588         if ( !xTypeDetection.is() )
 589             throw uno::RuntimeException(); // TODO
 590
 591         // typedetection can change the mode, add a stream and so on, thus a copy should be used
 592         uno::Sequence< beans::PropertyValue > aTempMD( aMediaDescr );
 593
 594         // get TypeName
 595         OUString aTypeName = xTypeDetection->queryTypeByDescriptor( aTempMD, sal_True );
 596
 597         // get FilterName
 598         for ( sal_Int32 nInd = 0; nInd < aTempMD.getLength(); nInd++ )
 599             if ( aTempMD[nInd].Name == "FilterName" )
 600                 aTempMD[nInd].Value >>= aFilterName;
 601
 602         if ( !aFilterName.isEmpty() )
 603         {
 604             sal_Int32 nOldLen = aMediaDescr.getLength();
 605             aMediaDescr.realloc( nOldLen + 1 );
 606             aMediaDescr[nOldLen].Name = "FilterName";
 607             aMediaDescr[ nOldLen ].Value <<= aFilterName;
 608
 609         }
 610         else if ( !aTypeName.isEmpty() && !bIgnoreType )
 611         {
 612             uno::Reference< container::XNameAccess > xNameAccess( xTypeDetection, uno::UNO_QUERY );
 613             uno::Sequence< beans::PropertyValue > aTypes;
 614
 615             if ( xNameAccess.is() && ( xNameAccess->getByName( aTypeName ) >>= aTypes ) )
 616             {
 617                 for ( sal_Int32 nInd = 0; nInd < aTypes.getLength(); nInd++ )
 618                 {
 619                     if ( aTypes[nInd].Name == "PreferredFilter" && ( aTypes[nInd].Value >>= aFilterName ) )
 620                     {
 621                         sal_Int32 nOldLen = aMediaDescr.getLength();
 622                         aMediaDescr.realloc( nOldLen + 1 );
 623                         aMediaDescr[nOldLen].Name = "FilterName";
 624                         aMediaDescr[ nOldLen ].Value = aTypes[nInd].Value;
 625                         break;
 626                     }
 627                 }
 628             }
 629         }
 630     }
 631
 632     return aFilterName;
 633 }
 634
 635 OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName(
 636                         uno::Sequence< beans::PropertyValue >& aMediaDescr,
 637                         uno::Sequence< beans::NamedValue >& aObject )
 638 {
 639     OUString aDocName;
 640     for ( sal_Int32 nInd = 0; nInd < aObject.getLength(); nInd++ )
 641         if ( aObject[nInd].Name == "ObjectDocumentServiceName" )
 642         {
 643             aObject[nInd].Value >>= aDocName;
 644             break;
 645         }
 646
 647     OSL_ENSURE( !aDocName.isEmpty(), "The name must exist at this point!\n" );
 648
 649
 650     sal_Bool bNeedsAddition = sal_True;
 651     for ( sal_Int32 nMedInd = 0; nMedInd < aMediaDescr.getLength(); nMedInd++ )
 652         if ( aMediaDescr[nMedInd].Name == "DocumentService" )
 653         {
 654             aMediaDescr[nMedInd].Value <<= aDocName;
 655             bNeedsAddition = sal_False;
 656             break;
 657         }
 658
 659     if ( bNeedsAddition )
 660     {
 661         sal_Int32 nOldLen = aMediaDescr.getLength();
 662         aMediaDescr.realloc( nOldLen + 1 );
 663         aMediaDescr[nOldLen].Name = "DocumentService";
 664         aMediaDescr[nOldLen].Value <<= aDocName;
 665     }
 666
 667     return UpdateMediaDescriptorWithFilterName( aMediaDescr, sal_True );
 668 }
 669
 670 #ifdef WNT
 671
 672 sal_Int32 MimeConfigurationHelper::GetFilterFlags( const OUString& aFilterName )
 673 {
 674     sal_Int32 nFlags = 0;
 675     try
 676     {
 677         if ( !aFilterName.isEmpty() )
 678         {
 679             uno::Reference< container::XNameAccess > xFilterFactory(
 680                 GetFilterFactory(),
 681                 uno::UNO_SET_THROW );
 682
 683             uno::Any aFilterAny = xFilterFactory->getByName( aFilterName );
 684             uno::Sequence< beans::PropertyValue > aData;
 685             if ( aFilterAny >>= aData )
 686             {
 687                 SequenceAsHashMap aFilterHM( aData );
 688                 nFlags = aFilterHM.getUnpackedValueOrDefault( "Flags", (sal_Int32)0 );
 689             }
 690         }
 691     } catch( uno::Exception& )
 692     {}
 693
 694     return nFlags;
 695 }
 696
 697 sal_Bool MimeConfigurationHelper::AddFilterNameCheckOwnFile(
 698                         uno::Sequence< beans::PropertyValue >& aMediaDescr )
 699 {
 700     sal_Bool bResult = sal_False;
 701
 702     OUString aFilterName = UpdateMediaDescriptorWithFilterName( aMediaDescr, sal_False );
 703     if ( !aFilterName.isEmpty() )
 704     {
 705         sal_Int32 nFlags = GetFilterFlags( aFilterName );
 706         // check the OWN flag
 707         bResult = ( nFlags & SFX_FILTER_OWN );
 708     }
 709
 710     return bResult;
 711 }
 712 #endif
 713
 714 //-----------------------------------------------------------
 715 OUString MimeConfigurationHelper::GetDefaultFilterFromServiceName( const OUString& aServiceName, sal_Int32 nVersion )
 716 {
 717     OUString aResult;
 718
 719     if ( !aServiceName.isEmpty() && nVersion )
 720         try
 721         {
 722             uno::Reference< container::XContainerQuery > xFilterQuery(
 723                 GetFilterFactory(),
 724                 uno::UNO_QUERY_THROW );
 725
 726             uno::Sequence< beans::NamedValue > aSearchRequest( 2 );
 727             aSearchRequest[0].Name = "DocumentService";
 728             aSearchRequest[0].Value <<= aServiceName;
 729             aSearchRequest[1].Name = "FileFormatVersion";
 730             aSearchRequest[1].Value <<= nVersion;
 731
 732             uno::Sequence< beans::PropertyValue > aFilterProps;
 733             uno::Reference< container::XEnumeration > xFilterEnum =
 734                                             xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest );
 735
 736             // use the first filter that is found
 737             if ( xFilterEnum.is() )
 738                 while ( xFilterEnum->hasMoreElements() )
 739                 {
 740                     uno::Sequence< beans::PropertyValue > aProps;
 741                     if ( xFilterEnum->nextElement() >>= aProps )
 742                     {
 743                         SequenceAsHashMap aPropsHM( aProps );
 744                         sal_Int32 nFlags = aPropsHM.getUnpackedValueOrDefault( "Flags", (sal_Int32)0 );
 745
 746                         // that should be import, export, own filter and not a template filter ( TemplatePath flag )
 747                         sal_Int32 nRequired = ( SFX_FILTER_OWN | SFX_FILTER_EXPORT | SFX_FILTER_IMPORT );
 748                         if ( ( ( nFlags & nRequired ) == nRequired ) && !( nFlags & SFX_FILTER_TEMPLATEPATH ) )
 749                         {
 750                             // if there are more than one filter the preffered one should be used
 751                             // if there is no preffered filter the first one will be used
 752                             if ( aResult.isEmpty() || ( nFlags & SFX_FILTER_PREFERED ) )
 753                                 aResult = aPropsHM.getUnpackedValueOrDefault( "Name", OUString() );
 754                             if ( nFlags & SFX_FILTER_PREFERED )
 755                                 break; // the preferred filter was found
 756                         }
 757                     }
 758                 }
 759         }
 760         catch( uno::Exception& )
 761         {}
 762
 763     return aResult;
 764 }
 765
 766 //-------------------------------------------------------------------------
 767 OUString MimeConfigurationHelper::GetExportFilterFromImportFilter( const OUString& aImportFilterName )
 768 {
 769     OUString aExportFilterName;
 770
 771     try
 772     {
 773         if ( !aImportFilterName.isEmpty() )
 774         {
 775             uno::Reference< container::XNameAccess > xFilterFactory(
 776                 GetFilterFactory(),
 777                 uno::UNO_SET_THROW );
 778
 779             uno::Any aImpFilterAny = xFilterFactory->getByName( aImportFilterName );
 780             uno::Sequence< beans::PropertyValue > aImpData;
 781             if ( aImpFilterAny >>= aImpData )
 782             {
 783                 SequenceAsHashMap aImpFilterHM( aImpData );
 784                 sal_Int32 nFlags = aImpFilterHM.getUnpackedValueOrDefault( "Flags", (sal_Int32)0 );
 785
 786                 if ( !( nFlags & SFX_FILTER_IMPORT ) )
 787                 {
 788                     OSL_FAIL( "This is no import filter!" );
 789                     throw uno::Exception();
 790                 }
 791
 792                 if ( nFlags & SFX_FILTER_EXPORT )
 793                 {
 794                     aExportFilterName = aImportFilterName;
 795                 }
 796                 else
 797                 {
 798                     OUString aDocumentServiceName = aImpFilterHM.getUnpackedValueOrDefault( "DocumentService", OUString() );
 799                     OUString aTypeName = aImpFilterHM.getUnpackedValueOrDefault( "Type", OUString() );
 800
 801                     OSL_ENSURE( !aDocumentServiceName.isEmpty() && !aTypeName.isEmpty(), "Incomplete filter data!" );
 802                     if ( !(aDocumentServiceName.isEmpty() || aTypeName.isEmpty()) )
 803                     {
 804                         uno::Sequence< beans::NamedValue > aSearchRequest( 2 );
 805                         aSearchRequest[0].Name = "Type";
 806                         aSearchRequest[0].Value <<= aTypeName;
 807                         aSearchRequest[1].Name = "DocumentService";
 808                         aSearchRequest[1].Value <<= aDocumentServiceName;
 809
 810                         uno::Sequence< beans::PropertyValue > aExportFilterProps = SearchForFilter(
 811                             uno::Reference< container::XContainerQuery >( xFilterFactory, uno::UNO_QUERY_THROW ),
 812                             aSearchRequest,
 813                             SFX_FILTER_EXPORT,
 814                             SFX_FILTER_INTERNAL );
 815
 816                         if ( aExportFilterProps.getLength() )
 817                         {
 818                             SequenceAsHashMap aExpPropsHM( aExportFilterProps );
 819                             aExportFilterName = aExpPropsHM.getUnpackedValueOrDefault( "Name", OUString() );
 820                         }
 821                     }
 822                 }
 823             }
 824         }
 825     }
 826     catch( uno::Exception& )
 827     {}
 828
 829     return aExportFilterName;
 830 }
 831
 832 //-------------------------------------------------------------------------
 833 // static
 834 uno::Sequence< beans::PropertyValue > MimeConfigurationHelper::SearchForFilter(
 835                                                         const uno::Reference< container::XContainerQuery >& xFilterQuery,
 836                                                         const uno::Sequence< beans::NamedValue >& aSearchRequest,
 837                                                         sal_Int32 nMustFlags,
 838                                                         sal_Int32 nDontFlags )
 839 {
 840     uno::Sequence< beans::PropertyValue > aFilterProps;
 841     uno::Reference< container::XEnumeration > xFilterEnum =
 842                                             xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest );
 843
 844     // the first default filter will be taken,
 845     // if there is no filter with flag default the first acceptable filter will be taken
 846     if ( xFilterEnum.is() )
 847     {
 848         while ( xFilterEnum->hasMoreElements() )
 849         {
 850             uno::Sequence< beans::PropertyValue > aProps;
 851             if ( xFilterEnum->nextElement() >>= aProps )
 852             {
 853                 SequenceAsHashMap aPropsHM( aProps );
 854                 sal_Int32 nFlags = aPropsHM.getUnpackedValueOrDefault( OUString("Flags"),
 855                                                                         (sal_Int32)0 );
 856                 if ( ( ( nFlags & nMustFlags ) == nMustFlags ) && !( nFlags & nDontFlags ) )
 857                 {
 858                     if ( ( nFlags & SFX_FILTER_DEFAULT ) == SFX_FILTER_DEFAULT )
 859                     {
 860                         aFilterProps = aProps;
 861                         break;
 862                     }
 863                     else if ( !aFilterProps.getLength() )
 864                         aFilterProps = aProps;
 865                 }
 866             }
 867         }
 868     }
 869
 870     return aFilterProps;
 871 }
 872
 873
 874 //-------------------------------------------------------------------------
 875 sal_Bool MimeConfigurationHelper::ClassIDsEqual( const uno::Sequence< sal_Int8 >& aClassID1, const uno::Sequence< sal_Int8 >& aClassID2 )
 876 {
 877     if ( aClassID1.getLength() != aClassID2.getLength() )
 878         return sal_False;
 879
 880     for ( sal_Int32 nInd = 0; nInd < aClassID1.getLength(); nInd++ )
 881         if ( aClassID1[nInd] != aClassID2[nInd] )
 882             return sal_False;
 883
 884     return sal_True;
 885 }
 886
 887 //-------------------------------------------------------------------------
 888 uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassID( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3,
 889                                                 sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11,
 890                                                 sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 )
 891 {
 892     uno::Sequence< sal_Int8 > aResult( 16 );
 893     aResult[0] = (sal_Int8)( n1 >> 24 );
 894     aResult[1] = (sal_Int8)( ( n1 << 8 ) >> 24 );
 895     aResult[2] = (sal_Int8)( ( n1 << 16 ) >> 24 );
 896     aResult[3] = (sal_Int8)( ( n1 << 24 ) >> 24 );
 897     aResult[4] = (sal_Int8)( n2 >> 8 );
 898     aResult[5] = (sal_Int8)( ( n2 << 8 ) >> 8 );
 899     aResult[6] = (sal_Int8)( n3 >> 8 );
 900     aResult[7] = (sal_Int8)( ( n3 << 8 ) >> 8 );
 901     aResult[8] = b8;
 902     aResult[9] = b9;
 903     aResult[10] = b10;
 904     aResult[11] = b11;
 905     aResult[12] = b12;
 906     aResult[13] = b13;
 907     aResult[14] = b14;
 908     aResult[15] = b15;
 909
 910     return aResult;
 911 }
 912
 913 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */