vcl/source/filter/FilterConfigCache.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 "FilterConfigCache.hxx"
  21
  22 #include <vcl/graphicfilter.hxx>
  23 #include <com/sun/star/uno/Any.h>
  24 #include <comphelper/processfactory.hxx>
  25 #include <com/sun/star/uno/Exception.hpp>
  26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  27 #include <com/sun/star/beans/XPropertySet.hpp>
  28 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  29 #include <com/sun/star/container/XNameAccess.hpp>
  30
  31 using namespace ::com::sun::star::lang          ;   // XMultiServiceFactory
  32 using namespace ::com::sun::star::container     ;   // XNameAccess
  33 using namespace ::com::sun::star::uno           ;   // Reference
  34 using namespace ::com::sun::star::beans         ;   // PropertyValue
  35 using namespace ::com::sun::star::configuration ;
  36
  37 const char* FilterConfigCache::FilterConfigCacheEntry::InternalPixelFilterNameList[] =
  38 {
  39     IMP_BMP, IMP_GIF, IMP_PNG,IMP_JPEG, IMP_XBM, IMP_XPM,
  40     EXP_BMP, EXP_JPEG, EXP_PNG, NULL
  41 };
  42
  43 const char* FilterConfigCache::FilterConfigCacheEntry::InternalVectorFilterNameList[] =
  44 {
  45     IMP_SVMETAFILE, IMP_WMF, IMP_EMF, IMP_SVSGF, IMP_SVSGV, IMP_SVG,
  46     EXP_SVMETAFILE, EXP_WMF, EXP_EMF, EXP_SVG, NULL
  47 };
  48
  49 const char* FilterConfigCache::FilterConfigCacheEntry::ExternalPixelFilterNameList[] =
  50 {
  51     "egi", "icd", "ipd", "ipx", "ipb", "epb", "epg",
  52     "epp", "ira", "era", "itg", "iti", "eti", "exp", NULL
  53 };
  54
  55 sal_Bool FilterConfigCache::bInitialized = sal_False;
  56 sal_Int32 FilterConfigCache::nIndType = -1;
  57 sal_Int32 FilterConfigCache::nIndUIName = -1;
  58 sal_Int32 FilterConfigCache::nIndDocumentService = -1;
  59 sal_Int32 FilterConfigCache::nIndFilterService = -1;
  60 sal_Int32 FilterConfigCache::nIndFlags = -1;
  61 sal_Int32 FilterConfigCache::nIndUserData = -1;
  62 sal_Int32 FilterConfigCache::nIndFileFormatVersion = -1;
  63 sal_Int32 FilterConfigCache::nIndTemplateName = -1;
  64
  65 sal_Bool FilterConfigCache::FilterConfigCacheEntry::CreateFilterName( const OUString& rUserDataEntry )
  66 {
  67     bIsPixelFormat = bIsInternalFilter = sal_False;
  68     sFilterName = rUserDataEntry;
  69     const char** pPtr;
  70     for ( pPtr = InternalPixelFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
  71     {
  72         if ( sFilterName.equalsIgnoreAsciiCase( OUString(*pPtr, strlen(*pPtr), RTL_TEXTENCODING_ASCII_US) ) )
  73         {
  74             bIsInternalFilter = sal_True;
  75             bIsPixelFormat = sal_True;
  76         }
  77     }
  78     for ( pPtr = InternalVectorFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
  79     {
  80         if ( sFilterName.equalsIgnoreAsciiCase( OUString(*pPtr, strlen(*pPtr), RTL_TEXTENCODING_ASCII_US) ) )
  81             bIsInternalFilter = sal_True;
  82     }
  83     if ( !bIsInternalFilter )
  84     {
  85         for ( pPtr = ExternalPixelFilterNameList; *pPtr && ( bIsPixelFormat == sal_False ); pPtr++ )
  86         {
  87             if ( sFilterName.equalsIgnoreAsciiCase( OUString(*pPtr, strlen(*pPtr), RTL_TEXTENCODING_ASCII_US) ) )
  88                 bIsPixelFormat = sal_True;
  89         }
  90         OUString sTemp(SVLIBRARY("?"));
  91         sFilterName = sTemp.replaceFirst("?", sFilterName);
  92     }
  93     return ! sFilterName.isEmpty();
  94 }
  95
  96 OUString FilterConfigCache::FilterConfigCacheEntry::GetShortName()
  97 {
  98     OUString aShortName;
  99     if ( lExtensionList.getLength() )
 100     {
 101         aShortName = lExtensionList[ 0 ];
 102         if ( aShortName.startsWith( "*." ) )
 103             aShortName = aShortName.replaceAt( 0, 2, "" );
 104     }
 105     return aShortName;
 106 }
 107
 108 /** helper to open the configuration root of the underlying
 109     config package
 110
 111     @param  sPackage
 112             specify, which config package should be opened.
 113             Must be one of "types" or "filters"
 114
 115     @return A valid object if open was successful. The access on opened
 116             data will be readonly. It returns NULL in case open failed.
 117
 118     @throws It let pass RuntimeExceptions only.
 119  */
 120 Reference< XInterface > openConfig(const char* sPackage)
 121     throw(RuntimeException)
 122 {
 123     Reference< XComponentContext > xContext(
 124         comphelper::getProcessComponentContext() );
 125     Reference< XInterface >           xCfg;
 126     try
 127     {
 128         // get access to config API (not to file!)
 129         Reference< XMultiServiceFactory > xConfigProvider = theDefaultProvider::get( xContext );
 130
 131         Sequence< Any > lParams(1);
 132         PropertyValue   aParam    ;
 133
 134         // define cfg path for open
 135         aParam.Name = "nodepath";
 136         if (rtl_str_compareIgnoreAsciiCase(sPackage, "types") == 0)
 137             aParam.Value <<= OUString( "/org.openoffice.TypeDetection.Types/Types" );
 138         if (rtl_str_compareIgnoreAsciiCase(sPackage, "filters") == 0)
 139             aParam.Value <<= OUString( "/org.openoffice.TypeDetection.GraphicFilter/Filters" );
 140         lParams[0] = makeAny(aParam);
 141
 142         // get access to file
 143         xCfg = xConfigProvider->createInstanceWithArguments(
 144             OUString( "com.sun.star.configuration.ConfigurationAccess" ), lParams);
 145     }
 146     catch(const RuntimeException&)
 147         { throw; }
 148     catch(const Exception&)
 149         { xCfg.clear(); }
 150
 151     return xCfg;
 152 }
 153
 154 void FilterConfigCache::ImplInit()
 155 {
 156     OUString STYPE                ( "Type"                );
 157     OUString SUINAME              ( "UIName"              );
 158     OUString SFLAGS               ( "Flags"               );
 159     OUString SMEDIATYPE           ( "MediaType"           );
 160     OUString SEXTENSIONS          ( "Extensions"          );
 161     OUString SFORMATNAME          ( "FormatName"          );
 162     OUString SREALFILTERNAME      ( "RealFilterName"      );
 163
 164     // get access to config
 165     Reference< XNameAccess > xTypeAccess  ( openConfig("types"  ), UNO_QUERY );
 166     Reference< XNameAccess > xFilterAccess( openConfig("filters"), UNO_QUERY );
 167
 168     if ( xTypeAccess.is() && xFilterAccess.is() )
 169     {
 170         Sequence< OUString > lAllFilter = xFilterAccess->getElementNames();
 171         sal_Int32 nAllFilterCount = lAllFilter.getLength();
 172
 173         for ( sal_Int32 i = 0; i < nAllFilterCount; i++ )
 174         {
 175             OUString sInternalFilterName = lAllFilter[ i ];
 176             Reference< XPropertySet > xFilterSet;
 177             xFilterAccess->getByName( sInternalFilterName ) >>= xFilterSet;
 178             if (!xFilterSet.is())
 179                 continue;
 180
 181             FilterConfigCacheEntry aEntry;
 182
 183             aEntry.sInternalFilterName = sInternalFilterName;
 184             xFilterSet->getPropertyValue(STYPE) >>= aEntry.sType;
 185             xFilterSet->getPropertyValue(SUINAME) >>= aEntry.sUIName;
 186             xFilterSet->getPropertyValue(SREALFILTERNAME) >>= aEntry.sFilterType;
 187             Sequence< OUString > lFlags;
 188             xFilterSet->getPropertyValue(SFLAGS) >>= lFlags;
 189             if (lFlags.getLength()!=1 || lFlags[0].isEmpty())
 190                 continue;
 191             if (lFlags[0].equalsIgnoreAsciiCase("import"))
 192                 aEntry.nFlags = 1;
 193             else if (lFlags[0].equalsIgnoreAsciiCase("export"))
 194                 aEntry.nFlags = 2;
 195
 196             OUString sFormatName;
 197             xFilterSet->getPropertyValue(SFORMATNAME) >>= sFormatName;
 198             aEntry.CreateFilterName( sFormatName );
 199
 200             Reference< XPropertySet > xTypeSet;
 201             xTypeAccess->getByName( aEntry.sType ) >>= xTypeSet;
 202             if (!xTypeSet.is())
 203                 continue;
 204
 205             xTypeSet->getPropertyValue(SMEDIATYPE) >>= aEntry.sMediaType;
 206             xTypeSet->getPropertyValue(SEXTENSIONS) >>= aEntry.lExtensionList;
 207
 208             // The first extension will be used
 209             // to generate our internal FilterType ( BMP, WMF ... )
 210             OUString aExtension( aEntry.GetShortName() );
 211             if (aExtension.getLength() != 3)
 212                 continue;
 213
 214             if ( aEntry.nFlags & 1 )
 215                 aImport.push_back( aEntry );
 216             if ( aEntry.nFlags & 2 )
 217                 aExport.push_back( aEntry );
 218
 219             // bFilterEntryCreated!?
 220             if (!( aEntry.nFlags & 3 ))
 221                 continue; //? Entry was already inserted ... but following code will be supressed?!
 222         }
 223     }
 224 };
 225
 226 const char* FilterConfigCache::InternalFilterListForSvxLight[] =
 227 {
 228     "bmp","1","SVBMP",
 229     "bmp","2","SVBMP",
 230     "dxf","1","idx",
 231     "eps","1","ips",
 232     "eps","2","eps",
 233     "gif","1","SVIGIF",
 234     "gif","2","egi",
 235     "jpg","1","SVIJPEG",
 236     "jpg","2","SVEJPEG",
 237     "sgv","1","SVSGV",
 238     "sgf","1","SVSGF",
 239     "met","1","ime",
 240     "met","2","eme",
 241     "png","1","SVIPNG",
 242     "png","2","SVEPNG",
 243     "pct","1","ipt",
 244     "pct","2","ept",
 245     "pcd","1","icd",
 246     "psd","1","ipd",
 247     "pcx","1","ipx",
 248     "pbm","1","ipb",
 249     "pbm","2","epb",
 250     "pgm","1","ipb",
 251     "pgm","2","epg",
 252     "ppm","1","ipb",
 253     "ppm","2","epp",
 254     "ras","1","ira",
 255     "ras","2","era",
 256     "svm","1","SVMETAFILE",
 257     "svm","2","SVMETAFILE",
 258     "tga","1","itg",
 259     "tif","1","iti",
 260     "tif","2","eti",
 261     "emf","1","SVEMF",
 262     "emf","2","SVEMF",
 263     "wmf","1","SVWMF",
 264     "wmf","2","SVWMF",
 265     "xbm","1","SVIXBM",
 266     "xpm","1","SVIXPM",
 267     "xpm","2","exp",
 268     "svg","1","SVISVG",
 269     "svg","2","SVESVG",
 270     NULL
 271 };
 272
 273 void FilterConfigCache::ImplInitSmart()
 274 {
 275     const char** pPtr;
 276     for ( pPtr = InternalFilterListForSvxLight; *pPtr; pPtr++ )
 277     {
 278         FilterConfigCacheEntry  aEntry;
 279
 280         OUString    sExtension( OUString::createFromAscii( *pPtr++ ) );
 281
 282         aEntry.lExtensionList.realloc( 1 );
 283         aEntry.lExtensionList[ 0 ] = sExtension;
 284
 285         aEntry.sType = sExtension;
 286         aEntry.sUIName = sExtension;
 287
 288         OString sFlags( *pPtr++ );
 289         aEntry.nFlags = sFlags.toInt32();
 290
 291         OUString    sUserData( OUString::createFromAscii( *pPtr ) );
 292         aEntry.CreateFilterName( sUserData );
 293
 294         if ( aEntry.nFlags & 1 )
 295             aImport.push_back( aEntry );
 296         if ( aEntry.nFlags & 2 )
 297             aExport.push_back( aEntry );
 298     }
 299 }
 300
 301 // ------------------------------------------------------------------------
 302
 303 FilterConfigCache::FilterConfigCache( sal_Bool bConfig ) :
 304     bUseConfig ( bConfig )
 305 {
 306     if ( bUseConfig )
 307         ImplInit();
 308     else
 309         ImplInitSmart();
 310 }
 311
 312 FilterConfigCache::~FilterConfigCache()
 313 {
 314 }
 315
 316 OUString FilterConfigCache::GetImportFilterName( sal_uInt16 nFormat )
 317 {
 318     if( nFormat < aImport.size() )
 319         return aImport[ nFormat ].sFilterName;
 320     return OUString("");
 321 }
 322
 323 sal_uInt16 FilterConfigCache::GetImportFormatNumber( const OUString& rFormatName )
 324 {
 325     CacheVector::const_iterator aIter, aEnd;
 326     for (aIter = aImport.begin(), aEnd = aImport.end(); aIter != aEnd; ++aIter)
 327     {
 328         if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
 329             break;
 330     }
 331     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 332 }
 333
 334 /// get the index of the filter that matches this extension
 335 sal_uInt16 FilterConfigCache::GetImportFormatNumberForExtension( const OUString& rExt )
 336 {
 337     CacheVector::const_iterator aIter, aEnd;
 338     for (aIter = aImport.begin(), aEnd = aImport.end(); aIter != aEnd; ++aIter)
 339     {
 340         for ( sal_Int32 i = 0; i < aIter->lExtensionList.getLength(); i++ )
 341         {
 342             if ( aIter->lExtensionList[i].equalsIgnoreAsciiCase( rExt ) )
 343                 return sal::static_int_cast< sal_uInt16 >( aIter - aImport.begin() );
 344         }
 345     }
 346     return GRFILTER_FORMAT_NOTFOUND;
 347 }
 348
 349 sal_uInt16 FilterConfigCache::GetImportFormatNumberForMediaType( const OUString& rMediaType )
 350 {
 351     CacheVector::const_iterator aIter, aEnd;
 352     for (aIter = aImport.begin(), aEnd = aImport.end(); aIter != aEnd; ++aIter)
 353     {
 354         if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
 355             break;
 356     }
 357     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 358 }
 359
 360 sal_uInt16 FilterConfigCache::GetImportFormatNumberForShortName( const OUString& rShortName )
 361 {
 362     CacheVector::const_iterator aEnd;
 363     CacheVector::iterator aIter;
 364     for (aIter = aImport.begin(), aEnd = aImport.end(); aIter != aEnd; ++aIter)
 365     {
 366         if ( aIter->GetShortName().equalsIgnoreAsciiCase( rShortName ) )
 367             break;
 368     }
 369     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 370 }
 371
 372 sal_uInt16 FilterConfigCache::GetImportFormatNumberForTypeName( const OUString& rType )
 373 {
 374     CacheVector::const_iterator aIter, aEnd;
 375     for (aIter = aImport.begin(), aEnd = aImport.end(); aIter != aEnd; ++aIter)
 376     {
 377         if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
 378             break;
 379     }
 380     return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
 381 }
 382
 383 OUString FilterConfigCache::GetImportFormatName( sal_uInt16 nFormat )
 384 {
 385     if( nFormat < aImport.size() )
 386         return aImport[ nFormat ].sUIName;
 387     return OUString("");
 388 }
 389
 390 OUString FilterConfigCache::GetImportFormatMediaType( sal_uInt16 nFormat )
 391 {
 392     if( nFormat < aImport.size() )
 393         return aImport[ nFormat ].sMediaType;
 394     return OUString("");
 395 }
 396
 397 OUString FilterConfigCache::GetImportFormatShortName( sal_uInt16 nFormat )
 398 {
 399     if( nFormat < aImport.size() )
 400         return aImport[ nFormat ].GetShortName();
 401     return OUString("");
 402 }
 403
 404 OUString FilterConfigCache::GetImportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
 405 {
 406     if ( (nFormat < aImport.size()) && (nEntry < aImport[ nFormat ].lExtensionList.getLength()) )
 407         return aImport[ nFormat ].lExtensionList[ nEntry ];
 408     return OUString("");
 409 }
 410
 411 OUString FilterConfigCache::GetImportFilterType( sal_uInt16 nFormat )
 412 {
 413     if( nFormat < aImport.size() )
 414         return aImport[ nFormat ].sType;
 415     return OUString("");
 416 }
 417
 418 OUString FilterConfigCache::GetImportFilterTypeName( sal_uInt16 nFormat )
 419 {
 420     if( nFormat < aImport.size() )
 421         return aImport[ nFormat ].sFilterType;
 422     return OUString("");
 423 }
 424
 425 OUString FilterConfigCache::GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
 426 {
 427     OUString aWildcard( GetImportFormatExtension( nFormat, nEntry ) );
 428     if ( !aWildcard.isEmpty() )
 429         aWildcard = aWildcard.replaceAt( 0, 0, "*." );
 430     return aWildcard;
 431 }
 432
 433 sal_Bool FilterConfigCache::IsImportInternalFilter( sal_uInt16 nFormat )
 434 {
 435     return (nFormat < aImport.size()) && aImport[ nFormat ].bIsInternalFilter;
 436 }
 437
 438 sal_Bool FilterConfigCache::IsImportPixelFormat( sal_uInt16 nFormat )
 439 {
 440     return (nFormat < aImport.size()) && aImport[ nFormat ].bIsPixelFormat;
 441 }
 442
 443 // ------------------------------------------------------------------------
 444
 445 OUString FilterConfigCache::GetExportFilterName( sal_uInt16 nFormat )
 446 {
 447     if( nFormat < aExport.size() )
 448         return aExport[ nFormat ].sFilterName;
 449     return OUString("");
 450 }
 451
 452 sal_uInt16 FilterConfigCache::GetExportFormatNumber( const OUString& rFormatName )
 453 {
 454     CacheVector::const_iterator aIter, aEnd;
 455     for (aIter = aExport.begin(), aEnd = aExport.end(); aIter != aEnd; ++aIter)
 456     {
 457         if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
 458             break;
 459     }
 460     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 461 }
 462
 463 sal_uInt16 FilterConfigCache::GetExportFormatNumberForMediaType( const OUString& rMediaType )
 464 {
 465     CacheVector::const_iterator aIter, aEnd;
 466     for (aIter = aExport.begin(), aEnd = aExport.end(); aIter != aEnd; ++aIter)
 467     {
 468         if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
 469             break;
 470     }
 471     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 472 }
 473
 474 sal_uInt16 FilterConfigCache::GetExportFormatNumberForShortName( const OUString& rShortName )
 475 {
 476     CacheVector::const_iterator aEnd;
 477     CacheVector::iterator aIter;
 478     for (aIter = aExport.begin(), aEnd = aExport.end(); aIter != aEnd; ++aIter)
 479     {
 480         if ( aIter->GetShortName().equalsIgnoreAsciiCase( rShortName ) )
 481             break;
 482     }
 483     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 484 }
 485
 486 sal_uInt16 FilterConfigCache::GetExportFormatNumberForTypeName( const OUString& rType )
 487 {
 488     CacheVector::const_iterator aIter, aEnd;
 489     for (aIter = aExport.begin(), aEnd = aExport.end(); aIter != aEnd; ++aIter)
 490     {
 491         if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
 492             break;
 493     }
 494     return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
 495 }
 496
 497 OUString FilterConfigCache::GetExportFormatName( sal_uInt16 nFormat )
 498 {
 499     if( nFormat < aExport.size() )
 500         return aExport[ nFormat ].sUIName;
 501     return OUString("");
 502 }
 503
 504 OUString FilterConfigCache::GetExportFormatMediaType( sal_uInt16 nFormat )
 505 {
 506     if( nFormat < aExport.size() )
 507         return aExport[ nFormat ].sMediaType;
 508     return OUString("");
 509 }
 510
 511 OUString FilterConfigCache::GetExportFormatShortName( sal_uInt16 nFormat )
 512 {
 513     if( nFormat < aExport.size() )
 514         return aExport[ nFormat ].GetShortName();
 515     return OUString("");
 516 }
 517
 518 OUString FilterConfigCache::GetExportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
 519 {
 520     if ( (nFormat < aExport.size()) && (nEntry < aExport[ nFormat ].lExtensionList.getLength()) )
 521         return aExport[ nFormat ].lExtensionList[ nEntry ];
 522     return OUString("");
 523 }
 524
 525 OUString FilterConfigCache::GetExportFilterTypeName( sal_uInt16 nFormat )
 526 {
 527     if( nFormat < aExport.size() )
 528         return aExport[ nFormat ].sFilterType;
 529     return OUString("");
 530 }
 531
 532 OUString FilterConfigCache::GetExportInternalFilterName( sal_uInt16 nFormat )
 533 {
 534     if( nFormat < aExport.size() )
 535         return aExport[ nFormat ].sInternalFilterName;
 536     return OUString("");
 537 }
 538
 539 OUString FilterConfigCache::GetExportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
 540 {
 541     OUString aWildcard( GetExportFormatExtension( nFormat, nEntry ) );
 542     if ( !aWildcard.isEmpty() )
 543         aWildcard = aWildcard.replaceAt( 0, 0, "*." );
 544     return aWildcard;
 545 }
 546
 547 sal_Bool FilterConfigCache::IsExportInternalFilter( sal_uInt16 nFormat )
 548 {
 549     return (nFormat < aExport.size()) && aExport[ nFormat ].bIsInternalFilter;
 550 }
 551
 552 sal_Bool FilterConfigCache::IsExportPixelFormat( sal_uInt16 nFormat )
 553 {
 554     return (nFormat < aExport.size()) && aExport[ nFormat ].bIsPixelFormat;
 555 }
 556
 557 // ------------------------------------------------------------------------
 558
 559 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */