svtools/source/filter.vcl/filter/FilterConfigCache.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: FilterConfigCache.cxx,v $
  10  * $Revision: 1.24.100.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33 #include "FilterConfigCache.hxx"
  34 #include <svtools/filter.hxx>
  35 #include <tools/debug.hxx>
  36 #include <com/sun/star/uno/Any.h>
  37 #include <unotools/processfactory.hxx>
  38 #include <com/sun/star/uno/Exception.hpp>
  39 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  40 #include <com/sun/star/beans/XPropertySet.hpp>
  41
  42 #define TOKEN_COUNT_FOR_OWN_FILTER      3
  43 // #define TOKEN_INDEX_FOR_IDENT          0
  44 #define TOKEN_INDEX_FOR_FILTER          1
  45 // #define TOKEN_INDEX_FOR_HASDIALOG      2
  46
  47 using namespace ::com::sun::star::lang          ;   // XMultiServiceFactory
  48 using namespace ::com::sun::star::container             ;       // XNameAccess
  49 using namespace ::com::sun::star::uno                   ;       // Reference
  50 using namespace ::com::sun::star::beans                 ;       // PropertyValue
  51 using namespace ::utl                           ;   // getProcessServiceFactory();
  52 using namespace ::rtl                                                   ;
  53
  54 const char* FilterConfigCache::FilterConfigCacheEntry::InternalPixelFilterNameList[] =
  55 {
  56     IMP_BMP, IMP_GIF, IMP_PNG,IMP_JPEG, IMP_XBM, IMP_XPM,
  57     EXP_BMP, EXP_JPEG, EXP_PNG, NULL
  58 };
  59
  60 const char* FilterConfigCache::FilterConfigCacheEntry::InternalVectorFilterNameList[] =
  61 {
  62     IMP_SVMETAFILE, IMP_WMF, IMP_EMF, IMP_SVSGF, IMP_SVSGV,
  63     EXP_SVMETAFILE, EXP_WMF, EXP_EMF, EXP_SVG, NULL
  64 };
  65
  66 const char* FilterConfigCache::FilterConfigCacheEntry::ExternalPixelFilterNameList[] =
  67 {
  68     "egi", "icd", "ipd", "ipx", "ipb", "epb", "epg",
  69     "epp", "ira", "era", "itg", "iti", "eti", "exp", NULL
  70 };
  71
  72 sal_Bool FilterConfigCache::FilterConfigCacheEntry::IsValid()
  73 {
  74     return sFilterName.Len() != 0;
  75 }
  76
  77 sal_Bool FilterConfigCache::bInitialized = sal_False;
  78 sal_Int32 FilterConfigCache::nIndType = -1;
  79 sal_Int32 FilterConfigCache::nIndUIName = -1;
  80 sal_Int32 FilterConfigCache::nIndDocumentService = -1;
  81 sal_Int32 FilterConfigCache::nIndFilterService = -1;
  82 sal_Int32 FilterConfigCache::nIndFlags = -1;
  83 sal_Int32 FilterConfigCache::nIndUserData = -1;
  84 sal_Int32 FilterConfigCache::nIndFileFormatVersion = -1;
  85 sal_Int32 FilterConfigCache::nIndTemplateName = -1;
  86
  87 sal_Bool FilterConfigCache::FilterConfigCacheEntry::CreateFilterName( const OUString& rUserDataEntry )
  88 {
  89     bIsPixelFormat = bIsInternalFilter = sal_False;
  90     sFilterName = String( rUserDataEntry );
  91     const char** pPtr;
  92     for ( pPtr = InternalPixelFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
  93     {
  94         if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
  95         {
  96             bIsInternalFilter = sal_True;
  97             bIsPixelFormat = sal_True;
  98         }
  99     }
 100     for ( pPtr = InternalVectorFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
 101     {
 102         if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
 103             bIsInternalFilter = sal_True;
 104     }
 105     if ( !bIsInternalFilter )
 106     {
 107         for ( pPtr = ExternalPixelFilterNameList; *pPtr && ( bIsPixelFormat == sal_False ); pPtr++ )
 108         {
 109             if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
 110                 bIsPixelFormat = sal_True;
 111         }
 112         String aTemp( OUString::createFromAscii( SVLIBRARY( "?" ) ) );
 113         xub_StrLen nIndex = aTemp.Search( (sal_Unicode)'?' );
 114         aTemp.Replace( nIndex, 1, sFilterName );
 115         sFilterName = aTemp;
 116     }
 117     return sFilterName.Len() != 0;
 118 }
 119
 120 String FilterConfigCache::FilterConfigCacheEntry::GetShortName()
 121 {
 122     String aShortName;
 123     if ( lExtensionList.getLength() )
 124     {
 125         aShortName = lExtensionList[ 0 ];
 126         if ( aShortName.SearchAscii( "*.", 0 ) == 0 )
 127             aShortName.Erase( 0, 2 );
 128     }
 129     return aShortName;
 130 }
 131
 132 /** helper to open the configuration root of the underlying
 133     config package
 134
 135     @param  sPackage
 136             specify, which config package should be opened.
 137             Must be one of the defined static values TYPEPKG or FILTERPKG.
 138
 139     @return A valid object if open was successfull. The access on opened
 140             data will be readonly. It returns NULL in case open failed.
 141
 142     @throws It let pass RuntimeExceptions only.
 143  */
 144 Reference< XInterface > openConfig(const char* sPackage)
 145     throw(RuntimeException)
 146 {
 147     static OUString TYPEPKG( RTL_CONSTASCII_USTRINGPARAM( "types" ) );
 148     static OUString FILTERPKG( RTL_CONSTASCII_USTRINGPARAM( "filters" ) );
 149
 150     Reference< XMultiServiceFactory > xSMGR = getProcessServiceFactory();
 151     Reference< XInterface >           xCfg;
 152     try
 153     {
 154         // get access to config API (not to file!)
 155         Reference< XMultiServiceFactory > xConfigProvider( xSMGR->createInstance(
 156             OUString::createFromAscii("com.sun.star.configuration.ConfigurationProvider")), UNO_QUERY);
 157
 158         if (xConfigProvider.is())
 159         {
 160             Sequence< Any > lParams(1);
 161             PropertyValue   aParam    ;
 162
 163             // define cfg path for open
 164             aParam.Name = OUString::createFromAscii("nodepath");
 165             if (TYPEPKG.equalsIgnoreAsciiCaseAscii(sPackage))
 166                 aParam.Value <<= OUString::createFromAscii("/org.openoffice.TypeDetection.Types/Types");
 167             if (FILTERPKG.equalsIgnoreAsciiCaseAscii(sPackage))
 168                 aParam.Value <<= OUString::createFromAscii("/org.openoffice.TypeDetection.GraphicFilter/Filters");
 169             lParams[0] = makeAny(aParam);
 170
 171             // get access to file
 172             xCfg = xConfigProvider->createInstanceWithArguments(
 173                 OUString::createFromAscii("com.sun.star.configuration.ConfigurationAccess"), lParams);
 174         }
 175     }
 176     catch(const RuntimeException&)
 177         { throw; }
 178     catch(const Exception&)
 179         { xCfg.clear(); }
 180
 181     return xCfg;
 182 }
 183
 184 void FilterConfigCache::ImplInit()
 185 {
 186     static OUString STYPE                ( RTL_CONSTASCII_USTRINGPARAM( "Type"               ) );
 187     static OUString SUINAME              ( RTL_CONSTASCII_USTRINGPARAM( "UIName"             ) );
 188     static OUString SDOCUMENTSERVICE     ( RTL_CONSTASCII_USTRINGPARAM( "DocumentService"    ) );
 189     static OUString SFILTERSERVICE       ( RTL_CONSTASCII_USTRINGPARAM( "FilterService"      ) );
 190     static OUString STEMPLATENAME        ( RTL_CONSTASCII_USTRINGPARAM( "TemplateName"       ) );
 191     static OUString SFILEFORMATVERSION   ( RTL_CONSTASCII_USTRINGPARAM( "FileFormatVersion"  ) );
 192     static OUString SUICOMPONENT         ( RTL_CONSTASCII_USTRINGPARAM( "UIComponent"        ) );
 193     static OUString SFLAGS               ( RTL_CONSTASCII_USTRINGPARAM( "Flags"              ) );
 194     static OUString SUSERDATA            ( RTL_CONSTASCII_USTRINGPARAM( "UserData"           ) );
 195     static OUString SMEDIATYPE           ( RTL_CONSTASCII_USTRINGPARAM( "MediaType"          ) );
 196     static OUString SEXTENSIONS          ( RTL_CONSTASCII_USTRINGPARAM( "Extensions"         ) );
 197     static OUString SFORMATNAME          ( RTL_CONSTASCII_USTRINGPARAM( "FormatName"         ) );
 198     static OUString SREALFILTERNAME      ( RTL_CONSTASCII_USTRINGPARAM( "RealFilterName"     ) );
 199
 200     // get access to config
 201     Reference< XNameAccess > xTypeAccess  ( openConfig("types"  ), UNO_QUERY );
 202     Reference< XNameAccess > xFilterAccess( openConfig("filters"), UNO_QUERY );
 203
 204     if ( xTypeAccess.is() && xFilterAccess.is() )
 205     {
 206         Sequence< OUString > lAllFilter = xFilterAccess->getElementNames();
 207         sal_Int32 nAllFilterCount = lAllFilter.getLength();
 208
 209         for ( sal_Int32 i = 0; i < nAllFilterCount; i++ )
 210         {
 211             OUString sInternalFilterName = lAllFilter[ i ];
 212             Reference< XPropertySet > xFilterSet;
 213             xFilterAccess->getByName( sInternalFilterName ) >>= xFilterSet;
 214             if (!xFilterSet.is())
 215                 continue;
 216
 217             FilterConfigCacheEntry aEntry;
 218
 219             aEntry.sInternalFilterName = sInternalFilterName;
 220             xFilterSet->getPropertyValue(STYPE) >>= aEntry.sType;
 221             xFilterSet->getPropertyValue(SUINAME) >>= aEntry.sUIName;
 222             xFilterSet->getPropertyValue(SREALFILTERNAME) >>= aEntry.sFilterType;
 223             Sequence< OUString > lFlags;
 224             xFilterSet->getPropertyValue(SFLAGS) >>= lFlags;
 225             if (lFlags.getLength()!=1 || !lFlags[0].getLength())
 226                 continue;
 227             if (lFlags[0].equalsIgnoreAsciiCaseAscii("import"))
 228                 aEntry.nFlags = 1;
 229             else
 230             if (lFlags[0].equalsIgnoreAsciiCaseAscii("export"))
 231                 aEntry.nFlags = 2;
 232
 233             OUString sUIComponent;
 234             xFilterSet->getPropertyValue(SUICOMPONENT) >>= sUIComponent;
 235             aEntry.bHasDialog = sUIComponent.getLength();
 236
 237             ::rtl::OUString sFormatName;
 238             xFilterSet->getPropertyValue(SFORMATNAME) >>= sFormatName;
 239             aEntry.CreateFilterName( sFormatName );
 240
 241             Reference< XPropertySet > xTypeSet;
 242             xTypeAccess->getByName( aEntry.sType ) >>= xTypeSet;
 243             if (!xTypeSet.is())
 244                 continue;
 245
 246             xTypeSet->getPropertyValue(SMEDIATYPE) >>= aEntry.sMediaType;
 247             xTypeSet->getPropertyValue(SEXTENSIONS) >>= aEntry.lExtensionList;
 248
 249             // The first extension will be used
 250             // to generate our internal FilterType ( BMP, WMF ... )
 251             String aExtension( aEntry.GetShortName() );
 252             if (aExtension.Len() != 3)
 253                 continue;
 254
 255             if ( aEntry.nFlags & 1 )
 256                 aImport.push_back( aEntry );
 257             if ( aEntry.nFlags & 2 )
 258                 aExport.push_back( aEntry );
 259
 260             // bFilterEntryCreated!?
 261             if (!( aEntry.nFlags & 3 ))
 262                 continue; //? Entry was already inserted ... but following code will be supressed?!
 263         }
 264     }
 265 };
 266
 267 const char* FilterConfigCache::InternalFilterListForSvxLight[] =
 268 {
 269     "bmp","1","SVBMP",
 270     "bmp","2","SVBMP",
 271     "dxf","1","idx",
 272     "eps","1","ips",
 273     "eps","2","eps",
 274     "gif","1","SVIGIF",
 275     "gif","2","egi",
 276     "jpg","1","SVIJPEG",
 277     "jpg","2","SVEJPEG",
 278     "sgv","1","SVSGV",
 279     "sgf","1","SVSGF",
 280     "met","1","ime",
 281     "met","2","eme",
 282     "png","1","SVIPNG",
 283     "png","2","SVEPNG",
 284     "pct","1","ipt",
 285     "pct","2","ept",
 286     "pcd","1","icd",
 287     "psd","1","ipd",
 288     "pcx","1","ipx",
 289     "pbm","1","ipb",
 290     "pbm","2","epb",
 291     "pgm","1","ipb",
 292     "pgm","2","epg",
 293     "ppm","1","ipb",
 294     "ppm","2","epp",
 295     "ras","1","ira",
 296     "ras","2","era",
 297     "svm","1","SVMETAFILE",
 298     "svm","2","SVMETAFILE",
 299     "tga","1","itg",
 300     "tif","1","iti",
 301     "tif","2","eti",
 302     "emf","1","SVEMF",
 303     "emf","2","SVEMF",
 304     "wmf","1","SVWMF",
 305     "wmf","2","SVWMF",
 306     "xbm","1","SVIXBM",
 307     "xpm","1","SVIXPM",
 308     "xpm","2","exp",
 309     "svg","2","SVESVG",
 310     NULL
 311 };
 312
 313 void FilterConfigCache::ImplInitSmart()
 314 {
 315     const char** pPtr;
 316     for ( pPtr = InternalFilterListForSvxLight; *pPtr; pPtr++ )
 317     {
 318         FilterConfigCacheEntry  aEntry;
 319
 320         OUString        sExtension( OUString::createFromAscii( *pPtr++ ) );
 321
 322         aEntry.lExtensionList.realloc( 1 );
 323         aEntry.lExtensionList[ 0 ] = sExtension;
 324
 325         aEntry.sType = sExtension;
 326         aEntry.sUIName = sExtension;
 327
 328         ByteString sFlags( *pPtr++ );
 329         aEntry.nFlags = sFlags.ToInt32();
 330
 331         OUString        sUserData( OUString::createFromAscii( *pPtr ) );
 332         aEntry.CreateFilterName( sUserData );
 333
 334         if ( aEntry.nFlags & 1 )
 335             aImport.push_back( aEntry );
 336         if ( aEntry.nFlags & 2 )
 337             aExport.push_back( aEntry );
 338     }
 339 }
 340
 341 // ------------------------------------------------------------------------
 342
 343 FilterConfigCache::FilterConfigCache( sal_Bool bConfig ) :
 344     bUseConfig ( bConfig )
 345 {
 346     if ( bUseConfig )
 347         ImplInit();
 348     else
 349         ImplInitSmart();
 350 }
 351
 352 FilterConfigCache::~FilterConfigCache()
 353 {
 354
 355 }
 356
 357 String FilterConfigCache::GetImportFilterName( sal_uInt16 nFormat )
 358 {
 359     if( nFormat < aImport.size() )
 360         return aImport[ nFormat ].sFilterName;
 361     return String::EmptyString();
 362 }
 363
 364 sal_uInt16 FilterConfigCache::GetImportFormatNumber( const String& rFormatName )
 365 {
 366     CacheVector::iterator aIter( aImport.begin() );
 367     while ( aIter != aImport.end() )
 368     {
 369         if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
 370             break;
 371         aIter++;
 372     }
 373     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 374 }
 375
 376 sal_uInt16 FilterConfigCache::GetImportFormatNumberForMediaType( const String& rMediaType )
 377 {
 378     CacheVector::iterator aIter( aImport.begin() );
 379     while ( aIter != aImport.end() )
 380     {
 381         if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
 382             break;
 383         aIter++;
 384     }
 385     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 386 }
 387
 388 sal_uInt16 FilterConfigCache::GetImportFormatNumberForShortName( const String& rShortName )
 389 {
 390     CacheVector::iterator aIter( aImport.begin() );
 391     while ( aIter != aImport.end() )
 392     {
 393         if ( aIter->GetShortName().EqualsIgnoreCaseAscii( rShortName ) )
 394             break;
 395         aIter++;
 396     }
 397     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 398 }
 399
 400 sal_uInt16 FilterConfigCache::GetImportFormatNumberForTypeName( const String& rType )
 401 {
 402     CacheVector::iterator aIter( aImport.begin() );
 403     while ( aIter != aImport.end() )
 404     {
 405         if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
 406             break;
 407         aIter++;
 408     }
 409     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 410 }
 411
 412 String FilterConfigCache::GetImportFormatName( sal_uInt16 nFormat )
 413 {
 414     if( nFormat < aImport.size() )
 415         return aImport[ nFormat ].sUIName;
 416     return String::EmptyString();
 417 }
 418
 419 String FilterConfigCache::GetImportFormatMediaType( sal_uInt16 nFormat )
 420 {
 421     if( nFormat < aImport.size() )
 422         return aImport[ nFormat ].sMediaType;
 423     return String::EmptyString();
 424 }
 425
 426 String FilterConfigCache::GetImportFormatShortName( sal_uInt16 nFormat )
 427 {
 428     if( nFormat < aImport.size() )
 429         return aImport[ nFormat ].GetShortName();
 430     return String::EmptyString();
 431 }
 432
 433 String FilterConfigCache::GetImportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
 434 {
 435     if ( (nFormat < aImport.size()) && (nEntry < aImport[ nFormat ].lExtensionList.getLength()) )
 436         return aImport[ nFormat ].lExtensionList[ nEntry ];
 437     return String::EmptyString();
 438 }
 439
 440 String FilterConfigCache::GetImportFilterType( sal_uInt16 nFormat )
 441 {
 442     if( nFormat < aImport.size() )
 443         return aImport[ nFormat ].sType;
 444     return String::EmptyString();
 445 }
 446
 447 String FilterConfigCache::GetImportFilterTypeName( sal_uInt16 nFormat )
 448 {
 449     if( nFormat < aImport.size() )
 450         return aImport[ nFormat ].sFilterType;
 451     return String::EmptyString();
 452 }
 453
 454 String FilterConfigCache::GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
 455 {
 456     String aWildcard( GetImportFormatExtension( nFormat, nEntry ) );
 457     if ( aWildcard.Len() )
 458         aWildcard.Insert( UniString::CreateFromAscii( "*.", 2 ), 0 );
 459     return aWildcard;
 460 }
 461
 462 sal_Bool FilterConfigCache::IsImportInternalFilter( sal_uInt16 nFormat )
 463 {
 464     return (nFormat < aImport.size()) && aImport[ nFormat ].bIsInternalFilter;
 465 }
 466
 467 sal_Bool FilterConfigCache::IsImportPixelFormat( sal_uInt16 nFormat )
 468 {
 469     return (nFormat < aImport.size()) && aImport[ nFormat ].bIsPixelFormat;
 470 }
 471
 472 sal_Bool FilterConfigCache::IsImportDialog( sal_uInt16 nFormat )
 473 {
 474     return (nFormat < aImport.size()) && aImport[ nFormat ].bHasDialog;
 475 }
 476
 477 // ------------------------------------------------------------------------
 478
 479 String FilterConfigCache::GetExportFilterName( sal_uInt16 nFormat )
 480 {
 481     if( nFormat < aExport.size() )
 482         return aExport[ nFormat ].sFilterName;
 483     return String::EmptyString();
 484 }
 485
 486 sal_uInt16 FilterConfigCache::GetExportFormatNumber( const String& rFormatName )
 487 {
 488     CacheVector::iterator aIter( aExport.begin() );
 489     while ( aIter != aExport.end() )
 490     {
 491         if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
 492             break;
 493         aIter++;
 494     }
 495     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 496 }
 497
 498 sal_uInt16 FilterConfigCache::GetExportFormatNumberForMediaType( const String& rMediaType )
 499 {
 500     CacheVector::iterator aIter( aExport.begin() );
 501     while ( aIter != aExport.end() )
 502     {
 503         if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
 504             break;
 505         aIter++;
 506     }
 507     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 508 }
 509
 510 sal_uInt16 FilterConfigCache::GetExportFormatNumberForShortName( const String& rShortName )
 511 {
 512     CacheVector::iterator aIter( aExport.begin() );
 513     while ( aIter != aExport.end() )
 514     {
 515         if ( aIter->GetShortName().EqualsIgnoreCaseAscii( rShortName ) )
 516             break;
 517         aIter++;
 518     }
 519     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 520 }
 521
 522 sal_uInt16 FilterConfigCache::GetExportFormatNumberForTypeName( const String& rType )
 523 {
 524     CacheVector::iterator aIter( aExport.begin() );
 525     while ( aIter != aExport.end() )
 526     {
 527         if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
 528             break;
 529         aIter++;
 530     }
 531     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 532 }
 533
 534 String FilterConfigCache::GetExportFormatName( sal_uInt16 nFormat )
 535 {
 536     if( nFormat < aExport.size() )
 537         return aExport[ nFormat ].sUIName;
 538     return String::EmptyString();
 539 }
 540
 541 String FilterConfigCache::GetExportFormatMediaType( sal_uInt16 nFormat )
 542 {
 543     if( nFormat < aExport.size() )
 544         return aExport[ nFormat ].sMediaType;
 545     return String::EmptyString();
 546 }
 547
 548 String FilterConfigCache::GetExportFormatShortName( sal_uInt16 nFormat )
 549 {
 550     if( nFormat < aExport.size() )
 551         return aExport[ nFormat ].GetShortName();
 552     return String::EmptyString();
 553 }
 554
 555 String FilterConfigCache::GetExportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
 556 {
 557     if ( (nFormat < aExport.size()) && (nEntry < aExport[ nFormat ].lExtensionList.getLength()) )
 558         return aExport[ nFormat ].lExtensionList[ nEntry ];
 559     return String::EmptyString();
 560 }
 561
 562 String FilterConfigCache::GetExportFilterTypeName( sal_uInt16 nFormat )
 563 {
 564     if( nFormat < aExport.size() )
 565         return aExport[ nFormat ].sFilterType;
 566     return String::EmptyString();
 567 }
 568
 569 String FilterConfigCache::GetExportInternalFilterName( sal_uInt16 nFormat )
 570 {
 571     if( nFormat < aExport.size() )
 572         return aExport[ nFormat ].sInternalFilterName;
 573     return String::EmptyString();
 574 }
 575
 576 String FilterConfigCache::GetExportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
 577 {
 578     String aWildcard( GetExportFormatExtension( nFormat, nEntry ) );
 579     if ( aWildcard.Len() )
 580         aWildcard.Insert( UniString::CreateFromAscii( "*.", 2 ), 0 );
 581     return aWildcard;
 582 }
 583
 584 sal_Bool FilterConfigCache::IsExportInternalFilter( sal_uInt16 nFormat )
 585 {
 586     return (nFormat < aExport.size()) && aExport[ nFormat ].bIsInternalFilter;
 587 }
 588
 589 sal_Bool FilterConfigCache::IsExportPixelFormat( sal_uInt16 nFormat )
 590 {
 591     return (nFormat < aExport.size()) && aExport[ nFormat ].bIsPixelFormat;
 592 }
 593
 594 sal_Bool FilterConfigCache::IsExportDialog( sal_uInt16 nFormat )
 595 {
 596     return (nFormat < aExport.size()) && aExport[ nFormat ].bHasDialog;
 597 }
 598
 599 // ------------------------------------------------------------------------