xref: /aoo4110/main/svtools/source/filter/FilterConfigCache.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svtools.hxx"
#include "FilterConfigCache.hxx"
#include <svtools/filter.hxx>
#include <tools/debug.hxx>
#include <com/sun/star/uno/Any.h>
#include <unotools/processfactory.hxx>
#include <com/sun/star/uno/Exception.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>

#define TOKEN_COUNT_FOR_OWN_FILTER      3
// #define TOKEN_INDEX_FOR_IDENT          0
#define TOKEN_INDEX_FOR_FILTER          1
// #define TOKEN_INDEX_FOR_HASDIALOG      2

using namespace ::com::sun::star::lang          ;   // XMultiServiceFactory
using namespace ::com::sun::star::container		;	// XNameAccess
using namespace ::com::sun::star::uno			;	// Reference
using namespace ::com::sun::star::beans			;	// PropertyValue
using namespace ::utl                           ;   // getProcessServiceFactory();
using ::rtl::OUString;

const char* FilterConfigCache::FilterConfigCacheEntry::InternalPixelFilterNameList[] =
{
	IMP_BMP, IMP_GIF, IMP_PNG,IMP_JPEG, IMP_XBM, IMP_XPM,
	EXP_BMP, EXP_JPEG, EXP_PNG, NULL
};

const char* FilterConfigCache::FilterConfigCacheEntry::InternalVectorFilterNameList[] =
{
	IMP_SVMETAFILE, IMP_WMF, IMP_EMF, IMP_SVSGF, IMP_SVSGV, IMP_SVG,
	EXP_SVMETAFILE, EXP_WMF, EXP_EMF, EXP_SVG, NULL
};

const char* FilterConfigCache::FilterConfigCacheEntry::ExternalPixelFilterNameList[] =
{
	"egi", "icd", "ipd", "ipx", "ipb", "epb", "epg",
	"epp", "ira", "era", "itg", "iti", "eti", "exp", NULL
};

sal_Bool FilterConfigCache::FilterConfigCacheEntry::IsValid()
{
	return sFilterName.Len() != 0;
}

sal_Bool FilterConfigCache::bInitialized = sal_False;
sal_Int32 FilterConfigCache::nIndType = -1;
sal_Int32 FilterConfigCache::nIndUIName = -1;
sal_Int32 FilterConfigCache::nIndDocumentService = -1;
sal_Int32 FilterConfigCache::nIndFilterService = -1;
sal_Int32 FilterConfigCache::nIndFlags = -1;
sal_Int32 FilterConfigCache::nIndUserData = -1;
sal_Int32 FilterConfigCache::nIndFileFormatVersion = -1;
sal_Int32 FilterConfigCache::nIndTemplateName = -1;

sal_Bool FilterConfigCache::FilterConfigCacheEntry::CreateFilterName( const OUString& rUserDataEntry )
{
	bIsPixelFormat = bIsInternalFilter = sal_False;
	sFilterName = String( rUserDataEntry );
	const char** pPtr;
	for ( pPtr = InternalPixelFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
	{
		if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
		{
			bIsInternalFilter = sal_True;
			bIsPixelFormat = sal_True;
		}
	}
	for ( pPtr = InternalVectorFilterNameList; *pPtr && ( bIsInternalFilter == sal_False ); pPtr++ )
	{
		if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
			bIsInternalFilter = sal_True;
	}
	if ( !bIsInternalFilter )
	{
		for ( pPtr = ExternalPixelFilterNameList; *pPtr && ( bIsPixelFormat == sal_False ); pPtr++ )
		{
			if ( sFilterName.EqualsIgnoreCaseAscii( *pPtr ) )
				bIsPixelFormat = sal_True;
		}
		String aTemp( OUString::createFromAscii( SVLIBRARY( "?" ) ) );
		xub_StrLen nIndex = aTemp.Search( (sal_Unicode)'?' );
		aTemp.Replace( nIndex, 1, sFilterName );
		sFilterName = aTemp;
	}
	return sFilterName.Len() != 0;
}

String FilterConfigCache::FilterConfigCacheEntry::GetShortName()
{
    String aShortName;
	if ( lExtensionList.getLength() )
    {
	    aShortName = lExtensionList[ 0 ];
	    if ( aShortName.SearchAscii( "*.", 0 ) == 0 )
		    aShortName.Erase( 0, 2 );
    }
    return aShortName;
}

/** helper to open the configuration root of the underlying
    config package

    @param  sPackage
            specify, which config package should be opened.
            Must be one of the defined static values TYPEPKG or FILTERPKG.

    @return A valid object if open was successfull. The access on opened
            data will be readonly. It returns NULL in case open failed.

    @throws It let pass RuntimeExceptions only.
 */
Reference< XInterface > openConfig(const char* sPackage)
    throw(RuntimeException)
{
    static OUString TYPEPKG( RTL_CONSTASCII_USTRINGPARAM( "types" ) );
    static OUString FILTERPKG( RTL_CONSTASCII_USTRINGPARAM( "filters" ) );

    Reference< XMultiServiceFactory > xSMGR = getProcessServiceFactory();
    Reference< XInterface >           xCfg;
    try
    {
        // get access to config API (not to file!)
        Reference< XMultiServiceFactory > xConfigProvider( xSMGR->createInstance(
            OUString::createFromAscii("com.sun.star.configuration.ConfigurationProvider")), UNO_QUERY);

        if (xConfigProvider.is())
        {
            Sequence< Any > lParams(1);
            PropertyValue   aParam    ;

            // define cfg path for open
            aParam.Name = OUString::createFromAscii("nodepath");
            if (TYPEPKG.equalsIgnoreAsciiCaseAscii(sPackage))
                aParam.Value <<= OUString::createFromAscii("/org.openoffice.TypeDetection.Types/Types");
            if (FILTERPKG.equalsIgnoreAsciiCaseAscii(sPackage))
                aParam.Value <<= OUString::createFromAscii("/org.openoffice.TypeDetection.GraphicFilter/Filters");
            lParams[0] = makeAny(aParam);

            // get access to file
            xCfg = xConfigProvider->createInstanceWithArguments(
                OUString::createFromAscii("com.sun.star.configuration.ConfigurationAccess"), lParams);
        }
    }
    catch(const RuntimeException&)
        { throw; }
    catch(const Exception&)
        { xCfg.clear(); }

    return xCfg;
}

void FilterConfigCache::ImplInit()
{
    static OUString STYPE                ( RTL_CONSTASCII_USTRINGPARAM( "Type"               ) );
    static OUString SUINAME              ( RTL_CONSTASCII_USTRINGPARAM( "UIName"             ) );
    static OUString SDOCUMENTSERVICE     ( RTL_CONSTASCII_USTRINGPARAM( "DocumentService"    ) );
    static OUString SFILTERSERVICE       ( RTL_CONSTASCII_USTRINGPARAM( "FilterService"      ) );
    static OUString STEMPLATENAME        ( RTL_CONSTASCII_USTRINGPARAM( "TemplateName"       ) );
    static OUString SFILEFORMATVERSION   ( RTL_CONSTASCII_USTRINGPARAM( "FileFormatVersion"  ) );
    static OUString SUICOMPONENT         ( RTL_CONSTASCII_USTRINGPARAM( "UIComponent"        ) );
    static OUString SFLAGS               ( RTL_CONSTASCII_USTRINGPARAM( "Flags"              ) );
    static OUString SUSERDATA            ( RTL_CONSTASCII_USTRINGPARAM( "UserData"           ) );
    static OUString SMEDIATYPE           ( RTL_CONSTASCII_USTRINGPARAM( "MediaType"          ) );
    static OUString SEXTENSIONS          ( RTL_CONSTASCII_USTRINGPARAM( "Extensions"         ) );
    static OUString SFORMATNAME          ( RTL_CONSTASCII_USTRINGPARAM( "FormatName"         ) );
    static OUString SREALFILTERNAME      ( RTL_CONSTASCII_USTRINGPARAM( "RealFilterName"     ) );

    // get access to config
    Reference< XNameAccess > xTypeAccess  ( openConfig("types"  ), UNO_QUERY );
    Reference< XNameAccess > xFilterAccess( openConfig("filters"), UNO_QUERY );

	if ( xTypeAccess.is() && xFilterAccess.is() )
	{
		Sequence< OUString > lAllFilter = xFilterAccess->getElementNames();
		sal_Int32 nAllFilterCount = lAllFilter.getLength();

		for ( sal_Int32 i = 0; i < nAllFilterCount; i++ )
		{
			OUString sInternalFilterName = lAllFilter[ i ];
			Reference< XPropertySet > xFilterSet;
			xFilterAccess->getByName( sInternalFilterName ) >>= xFilterSet;
			if (!xFilterSet.is())
				continue;

			FilterConfigCacheEntry aEntry;

			aEntry.sInternalFilterName = sInternalFilterName;
			xFilterSet->getPropertyValue(STYPE) >>= aEntry.sType;
			xFilterSet->getPropertyValue(SUINAME) >>= aEntry.sUIName;
			xFilterSet->getPropertyValue(SREALFILTERNAME) >>= aEntry.sFilterType;
			Sequence< OUString > lFlags;
			xFilterSet->getPropertyValue(SFLAGS) >>= lFlags;
			if (lFlags.getLength()!=1 || !lFlags[0].getLength())
				continue;
			if (lFlags[0].equalsIgnoreAsciiCaseAscii("import"))
				aEntry.nFlags = 1;
			else
			if (lFlags[0].equalsIgnoreAsciiCaseAscii("export"))
				aEntry.nFlags = 2;

			OUString sUIComponent;
			xFilterSet->getPropertyValue(SUICOMPONENT) >>= sUIComponent;
			aEntry.bHasDialog = sUIComponent.getLength();

			::rtl::OUString sFormatName;
			xFilterSet->getPropertyValue(SFORMATNAME) >>= sFormatName;
			aEntry.CreateFilterName( sFormatName );

			Reference< XPropertySet > xTypeSet;
			xTypeAccess->getByName( aEntry.sType ) >>= xTypeSet;
			if (!xTypeSet.is())
				continue;

			xTypeSet->getPropertyValue(SMEDIATYPE) >>= aEntry.sMediaType;
			xTypeSet->getPropertyValue(SEXTENSIONS) >>= aEntry.lExtensionList;

			// The first extension will be used
			// to generate our internal FilterType ( BMP, WMF ... )
			String aExtension( aEntry.GetShortName() );
			if (aExtension.Len() != 3)
				continue;

			if ( aEntry.nFlags & 1 )
				aImport.push_back( aEntry );
			if ( aEntry.nFlags & 2 )
				aExport.push_back( aEntry );

			// bFilterEntryCreated!?
			if (!( aEntry.nFlags & 3 ))
				continue; //? Entry was already inserted ... but following code will be supressed?!
		}
	}
};

const char* FilterConfigCache::InternalFilterListForSvxLight[] =
{
	"bmp","1","SVBMP",
	"bmp","2","SVBMP",
	"dxf","1","idx",
	"eps","1","ips",
	"eps","2","eps",
	"gif","1","SVIGIF",
	"gif","2","egi",
	"jpg","1","SVIJPEG",
	"jpg","2","SVEJPEG",
	"sgv","1","SVSGV",
	"sgf","1","SVSGF",
	"met","1","ime",
	"met","2","eme",
	"png","1","SVIPNG",
	"png","2","SVEPNG",
	"pct","1","ipt",
	"pct","2","ept",
	"pcd","1","icd",
	"psd","1","ipd",
	"pcx","1","ipx",
	"pbm","1","ipb",
	"pbm","2","epb",
	"pgm","1","ipb",
	"pgm","2","epg",
	"ppm","1","ipb",
	"ppm","2","epp",
	"ras","1","ira",
	"ras","2","era",
	"svm","1","SVMETAFILE",
	"svm","2","SVMETAFILE",
	"tga","1","itg",
	"tif","1","iti",
	"tif","2","eti",
	"emf","1","SVEMF",
	"emf","2","SVEMF",
	"wmf","1","SVWMF",
	"wmf","2","SVWMF",
	"xbm","1","SVIXBM",
	"xpm","1","SVIXPM",
	"xpm","2","exp",
	"svg","1","SVISVG",
	"svg","2","SVESVG",
	NULL
};

void FilterConfigCache::ImplInitSmart()
{
	const char** pPtr;
	for ( pPtr = InternalFilterListForSvxLight; *pPtr; pPtr++ )
	{
		FilterConfigCacheEntry	aEntry;

		OUString	sExtension( OUString::createFromAscii( *pPtr++ ) );

		aEntry.lExtensionList.realloc( 1 );
        aEntry.lExtensionList[ 0 ] = sExtension;

		aEntry.sType = sExtension;
		aEntry.sUIName = sExtension;

		ByteString sFlags( *pPtr++ );
		aEntry.nFlags = sFlags.ToInt32();

		OUString	sUserData( OUString::createFromAscii( *pPtr ) );
		aEntry.CreateFilterName( sUserData );

		if ( aEntry.nFlags & 1 )
			aImport.push_back( aEntry );
		if ( aEntry.nFlags & 2 )
			aExport.push_back( aEntry );
	}
}

// ------------------------------------------------------------------------

FilterConfigCache::FilterConfigCache( sal_Bool bConfig ) :
	bUseConfig ( bConfig )
{
	if ( bUseConfig )
		ImplInit();
	else
		ImplInitSmart();
}

FilterConfigCache::~FilterConfigCache()
{

}

String FilterConfigCache::GetImportFilterName( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].sFilterName;
    return String::EmptyString();
}

sal_uInt16 FilterConfigCache::GetImportFormatNumber( const String& rFormatName )
{
	CacheVector::iterator aIter( aImport.begin() );
	while ( aIter != aImport.end() )
	{
		if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
}

sal_uInt16 FilterConfigCache::GetImportFormatNumberForMediaType( const String& rMediaType )
{
	CacheVector::iterator aIter( aImport.begin() );
	while ( aIter != aImport.end() )
	{
		if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
}

sal_uInt16 FilterConfigCache::GetImportFormatNumberForShortName( const String& rShortName )
{
	CacheVector::iterator aIter( aImport.begin() );
	while ( aIter != aImport.end() )
	{
		if ( aIter->GetShortName().EqualsIgnoreCaseAscii( rShortName ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
}

sal_uInt16 FilterConfigCache::GetImportFormatNumberForTypeName( const String& rType )
{
	CacheVector::iterator aIter( aImport.begin() );
	while ( aIter != aImport.end() )
	{
		if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aImport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aImport.begin());
}

String FilterConfigCache::GetImportFormatName( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].sUIName;
    return String::EmptyString();
}

String FilterConfigCache::GetImportFormatMediaType( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].sMediaType;
    return String::EmptyString();
}

String FilterConfigCache::GetImportFormatShortName( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].GetShortName();
    return String::EmptyString();
}

String FilterConfigCache::GetImportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
{
    if ( (nFormat < aImport.size()) && (nEntry < aImport[ nFormat ].lExtensionList.getLength()) )
        return aImport[ nFormat ].lExtensionList[ nEntry ];
    return String::EmptyString();
}

String FilterConfigCache::GetImportFilterType( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].sType;
    return String::EmptyString();
}

String FilterConfigCache::GetImportFilterTypeName( sal_uInt16 nFormat )
{
    if( nFormat < aImport.size() )
        return aImport[ nFormat ].sFilterType;
    return String::EmptyString();
}

String FilterConfigCache::GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
{
    String aWildcard( GetImportFormatExtension( nFormat, nEntry ) );
    if ( aWildcard.Len() )
	    aWildcard.Insert( UniString::CreateFromAscii( "*.", 2 ), 0 );
	return aWildcard;
}

sal_Bool FilterConfigCache::IsImportInternalFilter( sal_uInt16 nFormat )
{
    return (nFormat < aImport.size()) && aImport[ nFormat ].bIsInternalFilter;
}

sal_Bool FilterConfigCache::IsImportPixelFormat( sal_uInt16 nFormat )
{
    return (nFormat < aImport.size()) && aImport[ nFormat ].bIsPixelFormat;
}

sal_Bool FilterConfigCache::IsImportDialog( sal_uInt16 nFormat )
{
    return (nFormat < aImport.size()) && aImport[ nFormat ].bHasDialog;
}

// ------------------------------------------------------------------------

String FilterConfigCache::GetExportFilterName( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].sFilterName;
    return String::EmptyString();
}

sal_uInt16 FilterConfigCache::GetExportFormatNumber( const String& rFormatName )
{
	CacheVector::iterator aIter( aExport.begin() );
	while ( aIter != aExport.end() )
	{
		if ( aIter->sUIName.equalsIgnoreAsciiCase( rFormatName ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
}

sal_uInt16 FilterConfigCache::GetExportFormatNumberForMediaType( const String& rMediaType )
{
	CacheVector::iterator aIter( aExport.begin() );
	while ( aIter != aExport.end() )
	{
		if ( aIter->sMediaType.equalsIgnoreAsciiCase( rMediaType ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
}

sal_uInt16 FilterConfigCache::GetExportFormatNumberForShortName( const String& rShortName )
{
	CacheVector::iterator aIter( aExport.begin() );
	while ( aIter != aExport.end() )
	{
		if ( aIter->GetShortName().EqualsIgnoreCaseAscii( rShortName ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
}

sal_uInt16 FilterConfigCache::GetExportFormatNumberForTypeName( const String& rType )
{
	CacheVector::iterator aIter( aExport.begin() );
	while ( aIter != aExport.end() )
	{
		if ( aIter->sType.equalsIgnoreAsciiCase( rType ) )
			break;
		aIter++;
	}
	return sal::static_int_cast< sal_uInt16 >(aIter == aExport.end() ? GRFILTER_FORMAT_NOTFOUND : aIter - aExport.begin());
}

String FilterConfigCache::GetExportFormatName( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].sUIName;
    return String::EmptyString();
}

String FilterConfigCache::GetExportFormatMediaType( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].sMediaType;
    return String::EmptyString();
}

String FilterConfigCache::GetExportFormatShortName( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].GetShortName();
    return String::EmptyString();
}

String FilterConfigCache::GetExportFormatExtension( sal_uInt16 nFormat, sal_Int32 nEntry )
{
    if ( (nFormat < aExport.size()) && (nEntry < aExport[ nFormat ].lExtensionList.getLength()) )
        return aExport[ nFormat ].lExtensionList[ nEntry ];
    return String::EmptyString();
}

String FilterConfigCache::GetExportFilterTypeName( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].sFilterType;
    return String::EmptyString();
}

String FilterConfigCache::GetExportInternalFilterName( sal_uInt16 nFormat )
{
    if( nFormat < aExport.size() )
        return aExport[ nFormat ].sInternalFilterName;
    return String::EmptyString();
}

String FilterConfigCache::GetExportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
{
    String aWildcard( GetExportFormatExtension( nFormat, nEntry ) );
    if ( aWildcard.Len() )
	    aWildcard.Insert( UniString::CreateFromAscii( "*.", 2 ), 0 );
	return aWildcard;
}

sal_Bool FilterConfigCache::IsExportInternalFilter( sal_uInt16 nFormat )
{
    return (nFormat < aExport.size()) && aExport[ nFormat ].bIsInternalFilter;
}

sal_Bool FilterConfigCache::IsExportPixelFormat( sal_uInt16 nFormat )
{
    return (nFormat < aExport.size()) && aExport[ nFormat ].bIsPixelFormat;
}

sal_Bool FilterConfigCache::IsExportDialog( sal_uInt16 nFormat )
{
    return (nFormat < aExport.size()) && aExport[ nFormat ].bHasDialog;
}

// ------------------------------------------------------------------------