| /************************************************************** |
| * |
| * 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_comphelper.hxx" |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| #include <com/sun/star/container/XContainerQuery.hpp> |
| #include <com/sun/star/document/XTypeDetection.hpp> |
| |
| #include <comphelper/fileformat.h> |
| #include <comphelper/mimeconfighelper.hxx> |
| #include <comphelper/classids.hxx> |
| #include <comphelper/sequenceashashmap.hxx> |
| #include <comphelper/documentconstants.hxx> |
| |
| |
| using namespace ::com::sun::star; |
| using namespace comphelper; |
| |
| //----------------------------------------------------------------------- |
| MimeConfigurationHelper::MimeConfigurationHelper( const uno::Reference< lang::XMultiServiceFactory >& xFactory ) |
| : m_xFactory( xFactory ) |
| { |
| if ( !m_xFactory.is() ) |
| throw uno::RuntimeException(); |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetStringClassIDRepresentation( const uno::Sequence< sal_Int8 >& aClassID ) |
| { |
| ::rtl::OUString aResult; |
| |
| if ( aClassID.getLength() == 16 ) |
| { |
| for ( sal_Int32 nInd = 0; nInd < aClassID.getLength(); nInd++ ) |
| { |
| if ( nInd == 4 || nInd == 6 || nInd == 8 || nInd == 10 ) |
| aResult += ::rtl::OUString::createFromAscii( "-" ); |
| |
| sal_Int32 nDigit1 = (sal_Int32)( (sal_uInt8)aClassID[nInd] / 16 ); |
| sal_Int32 nDigit2 = (sal_uInt8)aClassID[nInd] % 16; |
| aResult += ::rtl::OUString::valueOf( nDigit1, 16 ); |
| aResult += ::rtl::OUString::valueOf( nDigit2, 16 ); |
| } |
| } |
| |
| return aResult; |
| } |
| |
| //----------------------------------------------------------------------- |
| sal_uInt8 GetDigit_Impl( sal_Char aChar ) |
| { |
| if ( aChar >= '0' && aChar <= '9' ) |
| return aChar - '0'; |
| else if ( aChar >= 'a' && aChar <= 'f' ) |
| return aChar - 'a' + 10; |
| else if ( aChar >= 'A' && aChar <= 'F' ) |
| return aChar - 'A' + 10; |
| else |
| return 16; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassIDRepresentation( const ::rtl::OUString& aClassID ) |
| { |
| sal_Int32 nLength = aClassID.getLength(); |
| if ( nLength == 36 ) |
| { |
| ::rtl::OString aCharClassID = ::rtl::OUStringToOString( aClassID, RTL_TEXTENCODING_ASCII_US ); |
| const sal_Char* pString = aCharClassID.getStr(); |
| if ( pString ) |
| { |
| uno::Sequence< sal_Int8 > aResult( 16 ); |
| |
| sal_Int32 nStrPointer = 0; |
| sal_Int32 nSeqInd = 0; |
| while( nSeqInd < 16 && nStrPointer + 1 < nLength ) |
| { |
| sal_uInt8 nDigit1 = GetDigit_Impl( pString[nStrPointer++] ); |
| sal_uInt8 nDigit2 = GetDigit_Impl( pString[nStrPointer++] ); |
| |
| if ( nDigit1 > 15 || nDigit2 > 15 ) |
| break; |
| |
| aResult[nSeqInd++] = (sal_Int8)( nDigit1 * 16 + nDigit2 ); |
| |
| if ( nStrPointer < nLength && pString[nStrPointer] == '-' ) |
| nStrPointer++; |
| } |
| |
| if ( nSeqInd == 16 && nStrPointer == nLength ) |
| return aResult; |
| } |
| } |
| |
| return uno::Sequence< sal_Int8 >(); |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetConfigurationByPath( const ::rtl::OUString& aPath ) |
| { |
| osl::MutexGuard aGuard( m_aMutex ); |
| |
| uno::Reference< container::XNameAccess > xConfig; |
| |
| try |
| { |
| if ( !m_xConfigProvider.is() ) |
| m_xConfigProvider = uno::Reference< lang::XMultiServiceFactory >( |
| m_xFactory->createInstance( |
| ::rtl::OUString::createFromAscii( "com.sun.star.configuration.ConfigurationProvider" ) ), |
| uno::UNO_QUERY_THROW ); |
| |
| uno::Sequence< uno::Any > aArgs( 1 ); |
| beans::PropertyValue aPathProp; |
| aPathProp.Name = ::rtl::OUString::createFromAscii( "nodepath" ); |
| aPathProp.Value <<= aPath; |
| aArgs[0] <<= aPathProp; |
| |
| xConfig = uno::Reference< container::XNameAccess >( |
| m_xConfigProvider->createInstanceWithArguments( |
| ::rtl::OUString::createFromAscii( "com.sun.star.configuration.ConfigurationAccess" ), |
| aArgs ), |
| uno::UNO_QUERY ); |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return xConfig; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetObjConfiguration() |
| { |
| osl::MutexGuard aGuard( m_aMutex ); |
| |
| if ( !m_xObjectConfig.is() ) |
| m_xObjectConfig = GetConfigurationByPath( |
| ::rtl::OUString::createFromAscii( "/org.openoffice.Office.Embedding/Objects" ) ); |
| |
| return m_xObjectConfig; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetVerbsConfiguration() |
| { |
| osl::MutexGuard aGuard( m_aMutex ); |
| |
| if ( !m_xVerbsConfig.is() ) |
| m_xVerbsConfig = GetConfigurationByPath( |
| ::rtl::OUString::createFromAscii( "/org.openoffice.Office.Embedding/Verbs" ) ); |
| |
| return m_xVerbsConfig; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetMediaTypeConfiguration() |
| { |
| osl::MutexGuard aGuard( m_aMutex ); |
| |
| if ( !m_xMediaTypeConfig.is() ) |
| m_xMediaTypeConfig = GetConfigurationByPath( |
| ::rtl::OUString::createFromAscii( "/org.openoffice.Office.Embedding/MimeTypeClassIDRelations" ) ); |
| |
| return m_xMediaTypeConfig; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetFilterFactory() |
| { |
| osl::MutexGuard aGuard( m_aMutex ); |
| |
| if ( !m_xFilterFactory.is() ) |
| m_xFilterFactory.set( |
| m_xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ), |
| uno::UNO_QUERY ); |
| |
| return m_xFilterFactory; |
| } |
| |
| //----------------------------------------------------------------------- |
| sal_Int32 MimeConfigurationHelper::GetFilterFlags( const ::rtl::OUString& aFilterName ) |
| { |
| sal_Int32 nFlags = 0; |
| try |
| { |
| if ( !aFilterName.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xFilterFactory( |
| GetFilterFactory(), |
| uno::UNO_SET_THROW ); |
| |
| uno::Any aFilterAny = xFilterFactory->getByName( aFilterName ); |
| uno::Sequence< beans::PropertyValue > aData; |
| if ( aFilterAny >>= aData ) |
| { |
| SequenceAsHashMap aFilterHM( aData ); |
| nFlags = aFilterHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), (sal_Int32)0 ); |
| } |
| } |
| } catch( uno::Exception& ) |
| {} |
| |
| return nFlags; |
| } |
| |
| //------------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetDocServiceNameFromFilter( const ::rtl::OUString& aFilterName ) |
| { |
| ::rtl::OUString aDocServiceName; |
| |
| try |
| { |
| uno::Reference< container::XNameAccess > xFilterFactory( |
| GetFilterFactory(), |
| uno::UNO_SET_THROW ); |
| |
| uno::Any aFilterAnyData = xFilterFactory->getByName( aFilterName ); |
| uno::Sequence< beans::PropertyValue > aFilterData; |
| if ( aFilterAnyData >>= aFilterData ) |
| { |
| for ( sal_Int32 nInd = 0; nInd < aFilterData.getLength(); nInd++ ) |
| if ( aFilterData[nInd].Name.equalsAscii( "DocumentService" ) ) |
| aFilterData[nInd].Value >>= aDocServiceName; |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return aDocServiceName; |
| } |
| |
| //------------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetDocServiceNameFromMediaType( const ::rtl::OUString& aMediaType ) |
| { |
| uno::Reference< container::XContainerQuery > xTypeCFG( |
| m_xFactory->createInstance( |
| ::rtl::OUString::createFromAscii( "com.sun.star.document.TypeDetection" ) ), |
| uno::UNO_QUERY ); |
| |
| if ( xTypeCFG.is() ) |
| { |
| try |
| { |
| // make query for all types matching the properties |
| uno::Sequence < beans::NamedValue > aSeq( 1 ); |
| aSeq[0].Name = ::rtl::OUString::createFromAscii( "MediaType" ); |
| aSeq[0].Value <<= aMediaType; |
| |
| uno::Reference < container::XEnumeration > xEnum = xTypeCFG->createSubSetEnumerationByProperties( aSeq ); |
| while ( xEnum->hasMoreElements() ) |
| { |
| uno::Sequence< beans::PropertyValue > aType; |
| if ( xEnum->nextElement() >>= aType ) |
| { |
| for ( sal_Int32 nInd = 0; nInd < aType.getLength(); nInd++ ) |
| { |
| ::rtl::OUString aFilterName; |
| if ( aType[nInd].Name.equalsAscii( "PreferredFilter" ) |
| && ( aType[nInd].Value >>= aFilterName ) && !aFilterName.isEmpty() ) |
| { |
| ::rtl::OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName ); |
| if ( !aDocumentName.isEmpty() ) |
| return aDocumentName; |
| } |
| } |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| |
| return ::rtl::OUString(); |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool MimeConfigurationHelper::GetVerbByShortcut( const ::rtl::OUString& aVerbShortcut, |
| embed::VerbDescriptor& aDescriptor ) |
| { |
| sal_Bool bResult = sal_False; |
| |
| uno::Reference< container::XNameAccess > xVerbsConfig = GetVerbsConfiguration(); |
| uno::Reference< container::XNameAccess > xVerbsProps; |
| try |
| { |
| if ( xVerbsConfig.is() && ( xVerbsConfig->getByName( aVerbShortcut ) >>= xVerbsProps ) && xVerbsProps.is() ) |
| { |
| embed::VerbDescriptor aTempDescr; |
| if ( ( xVerbsProps->getByName( ::rtl::OUString::createFromAscii( "VerbID" ) ) >>= aTempDescr.VerbID ) |
| && ( xVerbsProps->getByName( ::rtl::OUString::createFromAscii( "VerbUIName" ) ) >>= aTempDescr.VerbName ) |
| && ( xVerbsProps->getByName( ::rtl::OUString::createFromAscii( "VerbFlags" ) ) >>= aTempDescr.VerbFlags ) |
| && ( xVerbsProps->getByName( ::rtl::OUString::createFromAscii( "VerbAttributes" ) ) >>= aTempDescr.VerbAttributes ) ) |
| { |
| aDescriptor = aTempDescr; |
| bResult = sal_True; |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| |
| return bResult; |
| } |
| |
| //------------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjPropsFromConfigEntry( |
| const uno::Sequence< sal_Int8 >& aClassID, |
| const uno::Reference< container::XNameAccess >& xObjectProps ) |
| { |
| uno::Sequence< beans::NamedValue > aResult; |
| |
| if ( aClassID.getLength() == 16 ) |
| { |
| try |
| { |
| uno::Sequence< ::rtl::OUString > aObjPropNames = xObjectProps->getElementNames(); |
| |
| aResult.realloc( aObjPropNames.getLength() + 1 ); |
| aResult[0].Name = ::rtl::OUString::createFromAscii( "ClassID" ); |
| aResult[0].Value <<= aClassID; |
| |
| for ( sal_Int32 nInd = 0; nInd < aObjPropNames.getLength(); nInd++ ) |
| { |
| aResult[nInd + 1].Name = aObjPropNames[nInd]; |
| |
| if ( aObjPropNames[nInd].equalsAscii( "ObjectVerbs" ) ) |
| { |
| uno::Sequence< ::rtl::OUString > aVerbShortcuts; |
| if ( xObjectProps->getByName( aObjPropNames[nInd] ) >>= aVerbShortcuts ) |
| { |
| uno::Sequence< embed::VerbDescriptor > aVerbDescriptors( aVerbShortcuts.getLength() ); |
| for ( sal_Int32 nVerbI = 0; nVerbI < aVerbShortcuts.getLength(); nVerbI++ ) |
| if ( !GetVerbByShortcut( aVerbShortcuts[nVerbI], aVerbDescriptors[nVerbI] ) ) |
| throw uno::RuntimeException(); |
| |
| aResult[nInd+1].Value <<= aVerbDescriptors; |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| else |
| aResult[nInd+1].Value = xObjectProps->getByName( aObjPropNames[nInd] ); |
| } |
| } |
| catch( uno::Exception& ) |
| { |
| aResult.realloc( 0 ); |
| } |
| } |
| |
| return aResult; |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetExplicitlyRegisteredObjClassID( const ::rtl::OUString& aMediaType ) |
| { |
| ::rtl::OUString aStringClassID; |
| |
| uno::Reference< container::XNameAccess > xMediaTypeConfig = GetMediaTypeConfiguration(); |
| try |
| { |
| if ( xMediaTypeConfig.is() ) |
| xMediaTypeConfig->getByName( aMediaType ) >>= aStringClassID; |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| |
| return aStringClassID; |
| |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByStringClassID( |
| const ::rtl::OUString& aStringClassID ) |
| { |
| uno::Sequence< beans::NamedValue > aObjProps; |
| |
| uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID ); |
| if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) ) |
| { |
| aObjProps.realloc(2); |
| aObjProps[0].Name = ::rtl::OUString::createFromAscii("ObjectFactory"); |
| aObjProps[0].Value <<= ::rtl::OUString::createFromAscii("com.sun.star.embed.OOoSpecialEmbeddedObjectFactory"); |
| aObjProps[1].Name = ::rtl::OUString::createFromAscii("ClassID"); |
| aObjProps[1].Value <<= aClassID; |
| return aObjProps; |
| } |
| |
| if ( aClassID.getLength() == 16 ) |
| { |
| uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration(); |
| uno::Reference< container::XNameAccess > xObjectProps; |
| try |
| { |
| // TODO/LATER: allow to provide ClassID string in any format, only digits are counted |
| if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() ) |
| aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps ); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| |
| return aObjProps; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByClassID( |
| const uno::Sequence< sal_Int8 >& aClassID ) |
| { |
| uno::Sequence< beans::NamedValue > aObjProps; |
| if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) ) |
| { |
| aObjProps.realloc(2); |
| aObjProps[0].Name = ::rtl::OUString::createFromAscii("ObjectFactory"); |
| aObjProps[0].Value <<= ::rtl::OUString::createFromAscii("com.sun.star.embed.OOoSpecialEmbeddedObjectFactory"); |
| aObjProps[1].Name = ::rtl::OUString::createFromAscii("ClassID"); |
| aObjProps[1].Value <<= aClassID; |
| } |
| |
| ::rtl::OUString aStringClassID = GetStringClassIDRepresentation( aClassID ); |
| if ( !aStringClassID.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration(); |
| uno::Reference< container::XNameAccess > xObjectProps; |
| try |
| { |
| if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() ) |
| aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps ); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| |
| return aObjProps; |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByMediaType( const ::rtl::OUString& aMediaType ) |
| { |
| uno::Sequence< beans::NamedValue > aObject = |
| GetObjectPropsByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) ); |
| if ( aObject.getLength() ) |
| return aObject; |
| |
| ::rtl::OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType ); |
| if ( !aDocumentName.isEmpty() ) |
| return GetObjectPropsByDocumentName( aDocumentName ); |
| |
| return uno::Sequence< beans::NamedValue >(); |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByFilter( const ::rtl::OUString& aFilterName ) |
| { |
| ::rtl::OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName ); |
| if ( !aDocumentName.isEmpty() ) |
| return GetObjectPropsByDocumentName( aDocumentName ); |
| |
| return uno::Sequence< beans::NamedValue >(); |
| } |
| |
| //----------------------------------------------------------------------- |
| uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByDocumentName( const ::rtl::OUString& aDocName ) |
| { |
| if ( !aDocName.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration(); |
| if ( xObjConfig.is() ) |
| { |
| try |
| { |
| uno::Sequence< ::rtl::OUString > aClassIDs = xObjConfig->getElementNames(); |
| for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ ) |
| { |
| uno::Reference< container::XNameAccess > xObjectProps; |
| ::rtl::OUString aEntryDocName; |
| |
| if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is() |
| && ( xObjectProps->getByName( |
| ::rtl::OUString::createFromAscii( "ObjectDocumentServiceName" ) ) >>= aEntryDocName ) |
| && aEntryDocName.equals( aDocName ) ) |
| { |
| return GetObjPropsFromConfigEntry( GetSequenceClassIDRepresentation( aClassIDs[nInd] ), |
| xObjectProps ); |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| } |
| |
| return uno::Sequence< beans::NamedValue >(); |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetFactoryNameByClassID( const uno::Sequence< sal_Int8 >& aClassID ) |
| { |
| return GetFactoryNameByStringClassID( GetStringClassIDRepresentation( aClassID ) ); |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetFactoryNameByStringClassID( const ::rtl::OUString& aStringClassID ) |
| { |
| ::rtl::OUString aResult; |
| |
| if ( !aStringClassID.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration(); |
| uno::Reference< container::XNameAccess > xObjectProps; |
| try |
| { |
| if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() ) |
| xObjectProps->getByName( ::rtl::OUString::createFromAscii( "ObjectFactory" ) ) >>= aResult; |
| } |
| catch( uno::Exception& ) |
| { |
| uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID ); |
| if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) ) |
| return ::rtl::OUString::createFromAscii("com.sun.star.embed.OOoSpecialEmbeddedObjectFactory"); |
| } |
| } |
| |
| return aResult; |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetFactoryNameByDocumentName( const ::rtl::OUString& aDocName ) |
| { |
| ::rtl::OUString aResult; |
| |
| if ( !aDocName.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration(); |
| if ( xObjConfig.is() ) |
| { |
| try |
| { |
| uno::Sequence< ::rtl::OUString > aClassIDs = xObjConfig->getElementNames(); |
| for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ ) |
| { |
| uno::Reference< container::XNameAccess > xObjectProps; |
| ::rtl::OUString aEntryDocName; |
| |
| if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is() |
| && ( xObjectProps->getByName( |
| ::rtl::OUString::createFromAscii( "ObjectDocumentServiceName" ) ) >>= aEntryDocName ) |
| && aEntryDocName.equals( aDocName ) ) |
| { |
| xObjectProps->getByName( ::rtl::OUString::createFromAscii( "ObjectFactory" ) ) >>= aResult; |
| break; |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| } |
| |
| return aResult; |
| } |
| |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetFactoryNameByMediaType( const ::rtl::OUString& aMediaType ) |
| { |
| ::rtl::OUString aResult = GetFactoryNameByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) ); |
| |
| if ( aResult.isEmpty() ) |
| { |
| ::rtl::OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType ); |
| if ( !aDocumentName.isEmpty() ) |
| aResult = GetFactoryNameByDocumentName( aDocumentName ); |
| } |
| |
| return aResult; |
| } |
| |
| //----------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName( |
| uno::Sequence< beans::PropertyValue >& aMediaDescr, |
| sal_Bool bIgnoreType ) |
| { |
| ::rtl::OUString aFilterName; |
| |
| for ( sal_Int32 nInd = 0; nInd < aMediaDescr.getLength(); nInd++ ) |
| if ( aMediaDescr[nInd].Name.equalsAscii( "FilterName" ) ) |
| aMediaDescr[nInd].Value >>= aFilterName; |
| |
| if ( aFilterName.isEmpty() ) |
| { |
| // filter name is not specified, so type detection should be done |
| |
| uno::Reference< document::XTypeDetection > xTypeDetection( |
| m_xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.TypeDetection" ) ), |
| uno::UNO_QUERY ); |
| |
| if ( !xTypeDetection.is() ) |
| throw uno::RuntimeException(); // TODO |
| |
| // typedetection can change the mode, add a stream and so on, thus a copy should be used |
| uno::Sequence< beans::PropertyValue > aTempMD( aMediaDescr ); |
| |
| // get TypeName |
| ::rtl::OUString aTypeName = xTypeDetection->queryTypeByDescriptor( aTempMD, sal_True ); |
| |
| // get FilterName |
| for ( sal_Int32 nInd = 0; nInd < aTempMD.getLength(); nInd++ ) |
| if ( aTempMD[nInd].Name.equalsAscii( "FilterName" ) ) |
| aTempMD[nInd].Value >>= aFilterName; |
| |
| if ( !aFilterName.isEmpty() ) |
| { |
| sal_Int32 nOldLen = aMediaDescr.getLength(); |
| aMediaDescr.realloc( nOldLen + 1 ); |
| aMediaDescr[nOldLen].Name = ::rtl::OUString::createFromAscii( "FilterName" ); |
| aMediaDescr[ nOldLen ].Value <<= aFilterName; |
| |
| } |
| else if ( !aTypeName.isEmpty() && !bIgnoreType ) |
| { |
| uno::Reference< container::XNameAccess > xNameAccess( xTypeDetection, uno::UNO_QUERY ); |
| uno::Sequence< beans::PropertyValue > aTypes; |
| |
| if ( xNameAccess.is() && ( xNameAccess->getByName( aTypeName ) >>= aTypes ) ) |
| { |
| for ( sal_Int32 nInd = 0; nInd < aTypes.getLength(); nInd++ ) |
| { |
| if ( aTypes[nInd].Name.equalsAscii( "PreferredFilter" ) && ( aTypes[nInd].Value >>= aFilterName ) ) |
| { |
| sal_Int32 nOldLen = aMediaDescr.getLength(); |
| aMediaDescr.realloc( nOldLen + 1 ); |
| aMediaDescr[nOldLen].Name = ::rtl::OUString::createFromAscii( "FilterName" ); |
| aMediaDescr[ nOldLen ].Value = aTypes[nInd].Value; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| return aFilterName; |
| } |
| |
| ::rtl::OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName( |
| uno::Sequence< beans::PropertyValue >& aMediaDescr, |
| uno::Sequence< beans::NamedValue >& aObject ) |
| { |
| ::rtl::OUString aDocName; |
| for ( sal_Int32 nInd = 0; nInd < aObject.getLength(); nInd++ ) |
| if ( aObject[nInd].Name.equalsAscii( "ObjectDocumentServiceName" ) ) |
| { |
| aObject[nInd].Value >>= aDocName; |
| break; |
| } |
| |
| OSL_ENSURE( !aDocName.isEmpty(), "The name must exist at this point!\n" ); |
| |
| |
| sal_Bool bNeedsAddition = sal_True; |
| for ( sal_Int32 nMedInd = 0; nMedInd < aMediaDescr.getLength(); nMedInd++ ) |
| if ( aMediaDescr[nMedInd].Name.equalsAscii( "DocumentService" ) ) |
| { |
| aMediaDescr[nMedInd].Value <<= aDocName; |
| bNeedsAddition = sal_False; |
| break; |
| } |
| |
| if ( bNeedsAddition ) |
| { |
| sal_Int32 nOldLen = aMediaDescr.getLength(); |
| aMediaDescr.realloc( nOldLen + 1 ); |
| aMediaDescr[nOldLen].Name = ::rtl::OUString::createFromAscii( "DocumentService" ); |
| aMediaDescr[nOldLen].Value <<= aDocName; |
| } |
| |
| return UpdateMediaDescriptorWithFilterName( aMediaDescr, sal_True ); |
| } |
| |
| sal_Bool MimeConfigurationHelper::AddFilterNameCheckOwnFile( |
| uno::Sequence< beans::PropertyValue >& aMediaDescr ) |
| { |
| sal_Bool bResult = sal_False; |
| |
| ::rtl::OUString aFilterName = UpdateMediaDescriptorWithFilterName( aMediaDescr, sal_False ); |
| if ( !aFilterName.isEmpty() ) |
| { |
| sal_Int32 nFlags = GetFilterFlags( aFilterName ); |
| // check the OWN flag |
| bResult = ( nFlags & SFX_FILTER_OWN ); |
| } |
| |
| return bResult; |
| } |
| |
| //----------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetDefaultFilterFromServiceName( const ::rtl::OUString& aServiceName, sal_Int32 nVersion ) |
| { |
| rtl::OUString aResult; |
| |
| if ( !aServiceName.isEmpty() && nVersion ) |
| try |
| { |
| uno::Reference< container::XContainerQuery > xFilterQuery( |
| GetFilterFactory(), |
| uno::UNO_QUERY_THROW ); |
| |
| uno::Sequence< beans::NamedValue > aSearchRequest( 2 ); |
| aSearchRequest[0].Name = ::rtl::OUString::createFromAscii( "DocumentService" ); |
| aSearchRequest[0].Value <<= aServiceName; |
| aSearchRequest[1].Name = ::rtl::OUString::createFromAscii( "FileFormatVersion" ); |
| aSearchRequest[1].Value <<= nVersion; |
| |
| uno::Sequence< beans::PropertyValue > aFilterProps; |
| uno::Reference< container::XEnumeration > xFilterEnum = |
| xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest ); |
| |
| // use the first filter that is found |
| if ( xFilterEnum.is() ) |
| while ( xFilterEnum->hasMoreElements() ) |
| { |
| uno::Sequence< beans::PropertyValue > aProps; |
| if ( xFilterEnum->nextElement() >>= aProps ) |
| { |
| SequenceAsHashMap aPropsHM( aProps ); |
| sal_Int32 nFlags = aPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), |
| (sal_Int32)0 ); |
| |
| // that should be import, export, own filter and not a template filter ( TemplatePath flag ) |
| sal_Int32 nRequired = ( SFX_FILTER_OWN | SFX_FILTER_EXPORT | SFX_FILTER_IMPORT ); |
| if ( ( ( nFlags & nRequired ) == nRequired ) && !( nFlags & SFX_FILTER_TEMPLATEPATH ) ) |
| { |
| // if there are more than one filter the preffered one should be used |
| // if there is no preffered filter the first one will be used |
| if ( aResult.isEmpty() || ( nFlags & SFX_FILTER_PREFERED ) ) |
| aResult = aPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Name" ), |
| ::rtl::OUString() ); |
| if ( nFlags & SFX_FILTER_PREFERED ) |
| break; // the preffered filter was found |
| } |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return aResult; |
| } |
| |
| //------------------------------------------------------------------------- |
| ::rtl::OUString MimeConfigurationHelper::GetExportFilterFromImportFilter( const ::rtl::OUString& aImportFilterName ) |
| { |
| ::rtl::OUString aExportFilterName; |
| |
| try |
| { |
| if ( !aImportFilterName.isEmpty() ) |
| { |
| uno::Reference< container::XNameAccess > xFilterFactory( |
| GetFilterFactory(), |
| uno::UNO_SET_THROW ); |
| |
| uno::Any aImpFilterAny = xFilterFactory->getByName( aImportFilterName ); |
| uno::Sequence< beans::PropertyValue > aImpData; |
| if ( aImpFilterAny >>= aImpData ) |
| { |
| SequenceAsHashMap aImpFilterHM( aImpData ); |
| sal_Int32 nFlags = aImpFilterHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), |
| (sal_Int32)0 ); |
| |
| if ( !( nFlags & SFX_FILTER_IMPORT ) ) |
| { |
| OSL_ENSURE( sal_False, "This is no import filter!" ); |
| throw uno::Exception(); |
| } |
| |
| if ( nFlags & SFX_FILTER_EXPORT ) |
| { |
| aExportFilterName = aImportFilterName; |
| } |
| else |
| { |
| ::rtl::OUString aDocumentServiceName = aImpFilterHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "DocumentService" ), ::rtl::OUString() ); |
| ::rtl::OUString aTypeName = aImpFilterHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Type" ), ::rtl::OUString() ); |
| |
| OSL_ENSURE( !aDocumentServiceName.isEmpty() && !aTypeName.isEmpty(), "Incomplete filter data!" ); |
| if ( !aDocumentServiceName.isEmpty() && !aTypeName.isEmpty() ) |
| { |
| uno::Sequence< beans::NamedValue > aSearchRequest( 2 ); |
| aSearchRequest[0].Name = ::rtl::OUString::createFromAscii( "Type" ); |
| aSearchRequest[0].Value <<= aTypeName; |
| aSearchRequest[1].Name = ::rtl::OUString::createFromAscii( "DocumentService" ); |
| aSearchRequest[1].Value <<= aDocumentServiceName; |
| |
| uno::Sequence< beans::PropertyValue > aExportFilterProps = SearchForFilter( |
| uno::Reference< container::XContainerQuery >( xFilterFactory, uno::UNO_QUERY_THROW ), |
| aSearchRequest, |
| SFX_FILTER_EXPORT, |
| SFX_FILTER_INTERNAL ); |
| |
| if ( aExportFilterProps.getLength() ) |
| { |
| SequenceAsHashMap aExpPropsHM( aExportFilterProps ); |
| aExportFilterName = aExpPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Name" ), ::rtl::OUString() ); |
| } |
| } |
| } |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return aExportFilterName; |
| } |
| |
| //------------------------------------------------------------------------- |
| // static |
| uno::Sequence< beans::PropertyValue > MimeConfigurationHelper::SearchForFilter( |
| const uno::Reference< container::XContainerQuery >& xFilterQuery, |
| const uno::Sequence< beans::NamedValue >& aSearchRequest, |
| sal_Int32 nMustFlags, |
| sal_Int32 nDontFlags ) |
| { |
| uno::Sequence< beans::PropertyValue > aFilterProps; |
| uno::Reference< container::XEnumeration > xFilterEnum = |
| xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest ); |
| |
| // the first default filter will be taken, |
| // if there is no filter with flag default the first acceptable filter will be taken |
| if ( xFilterEnum.is() ) |
| { |
| while ( xFilterEnum->hasMoreElements() ) |
| { |
| uno::Sequence< beans::PropertyValue > aProps; |
| if ( xFilterEnum->nextElement() >>= aProps ) |
| { |
| SequenceAsHashMap aPropsHM( aProps ); |
| sal_Int32 nFlags = aPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), |
| (sal_Int32)0 ); |
| if ( ( ( nFlags & nMustFlags ) == nMustFlags ) && !( nFlags & nDontFlags ) ) |
| { |
| if ( ( nFlags & SFX_FILTER_DEFAULT ) == SFX_FILTER_DEFAULT ) |
| { |
| aFilterProps = aProps; |
| break; |
| } |
| else if ( !aFilterProps.getLength() ) |
| aFilterProps = aProps; |
| } |
| } |
| } |
| } |
| |
| return aFilterProps; |
| } |
| |
| |
| //------------------------------------------------------------------------- |
| sal_Bool MimeConfigurationHelper::ClassIDsEqual( const uno::Sequence< sal_Int8 >& aClassID1, const uno::Sequence< sal_Int8 >& aClassID2 ) |
| { |
| if ( aClassID1.getLength() != aClassID2.getLength() ) |
| return sal_False; |
| |
| for ( sal_Int32 nInd = 0; nInd < aClassID1.getLength(); nInd++ ) |
| if ( aClassID1[nInd] != aClassID2[nInd] ) |
| return sal_False; |
| |
| return sal_True; |
| } |
| |
| //------------------------------------------------------------------------- |
| uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassID( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3, |
| sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11, |
| sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 ) |
| { |
| uno::Sequence< sal_Int8 > aResult( 16 ); |
| aResult[0] = (sal_Int8)( n1 >> 24 ); |
| aResult[1] = (sal_Int8)( ( n1 << 8 ) >> 24 ); |
| aResult[2] = (sal_Int8)( ( n1 << 16 ) >> 24 ); |
| aResult[3] = (sal_Int8)( ( n1 << 24 ) >> 24 ); |
| aResult[4] = (sal_Int8)( n2 >> 8 ); |
| aResult[5] = (sal_Int8)( ( n2 << 8 ) >> 8 ); |
| aResult[6] = (sal_Int8)( n3 >> 8 ); |
| aResult[7] = (sal_Int8)( ( n3 << 8 ) >> 8 ); |
| aResult[8] = b8; |
| aResult[9] = b9; |
| aResult[10] = b10; |
| aResult[11] = b11; |
| aResult[12] = b12; |
| aResult[13] = b13; |
| aResult[14] = b14; |
| aResult[15] = b15; |
| |
| return aResult; |
| } |
| |
| //------------------------------------------------------------------------- |
| uno::Sequence<sal_Int8> MimeConfigurationHelper::GetSequenceClassIDFromObjectName(const ::rtl::OUString& _sObjectName) |
| { |
| uno::Sequence<sal_Int8> aClassId; |
| uno::Reference< container::XNameAccess > xObjectNames = GetConfigurationByPath(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/org.openoffice.Office.Embedding/ObjectNames"))); |
| uno::Reference< container::XNameAccess > xProps; |
| if ( xObjectNames.is() && (xObjectNames->getByName(_sObjectName) >>= xProps) && xProps.is() ) |
| { |
| ::rtl::OUString sValue; |
| xProps->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ClassID"))) >>= sValue; |
| aClassId = GetSequenceClassIDRepresentation(sValue); |
| } |
| return aClassId; |
| } |
| |
