xref: /aoo41x/main/dtrans/source/win32/dtobj/FetcList.cxx (revision 69da7f00)

/**************************************************************
 *
 * 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_dtrans.hxx"

//------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------
#include <osl/diagnose.h>
#include "FetcList.hxx"
#include "Fetc.hxx"
#include <com/sun/star/datatransfer/XMimeContentTypeFactory.hpp>
#include <com/sun/star/datatransfer/XMimeContentType.hpp>

#ifndef _DATAFORMATTRANSLATOR_HXX_
#include "DataFmtTransl.hxx"
#endif
#include "..\misc\ImplHelper.hxx"
#include "..\misc\WinClip.hxx"

#include <algorithm>

#include "MimeAttrib.hxx"

//------------------------------------------------------------------------
// namespace directives
//------------------------------------------------------------------------

using namespace com::sun::star::uno;
using namespace com::sun::star::datatransfer;
using namespace com::sun::star::lang;
using namespace com::sun::star::container;
using namespace rtl;
using namespace std;

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

LCID       CFormatRegistrar::m_TxtLocale   = 0;
sal_uInt32 CFormatRegistrar::m_TxtCodePage = GetACP( );

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

CFormatEtcContainer::CFormatEtcContainer( )
{
	m_EnumIterator = m_FormatMap.begin( );
}

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

void CFormatEtcContainer::addFormatEtc( const CFormatEtc& fetc )
{
	m_FormatMap.push_back( CFormatEtc( fetc ) );
}

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

void SAL_CALL CFormatEtcContainer::removeFormatEtc( const CFormatEtc& fetc )
{
	FormatEtcMap_t::iterator iter =
		find( m_FormatMap.begin(), m_FormatMap.end(), fetc );

	if ( iter != m_FormatMap.end( ) )
		m_FormatMap.erase( iter );
}

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

void SAL_CALL CFormatEtcContainer::removeAllFormatEtc( )
{
	m_FormatMap.clear( );
}

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

sal_Bool CFormatEtcContainer::hasFormatEtc( const CFormatEtc& fetc ) const
{
	FormatEtcMap_t::const_iterator iter =
		find( m_FormatMap.begin(), m_FormatMap.end(), fetc );

	return ( iter != m_FormatMap.end( ) );
}

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

sal_Bool CFormatEtcContainer::hasElements( ) const
{
	return ( m_FormatMap.size( ) > 0 );
}

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

void CFormatEtcContainer::beginEnumFormatEtc( )
{
	m_EnumIterator = m_FormatMap.begin( );
}

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

sal_uInt32 SAL_CALL CFormatEtcContainer::nextFormatEtc( LPFORMATETC lpFetc,
													    sal_uInt32 aNum )
{
	OSL_ASSERT( lpFetc );
	OSL_ASSERT( !IsBadWritePtr( lpFetc, sizeof( FORMATETC ) * aNum ) );

	sal_uInt32 nFetched = 0;

	for ( sal_uInt32 i = 0; i < aNum; i++, nFetched++, lpFetc++, ++m_EnumIterator )
	{
		if ( m_EnumIterator == m_FormatMap.end() )
			break;
		CopyFormatEtc( lpFetc, *m_EnumIterator );
	}

	return nFetched;
}


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

sal_Bool SAL_CALL CFormatEtcContainer::skipFormatEtc( sal_uInt32 aNum )
{
	FormatEtcMap_t::const_iterator iter_end = m_FormatMap.end( );
	for ( sal_uInt32 i = 0;
		  (i < aNum) && (m_EnumIterator != iter_end);
		  i++, ++m_EnumIterator )
		;/* intentionally left empty */

	return ( m_EnumIterator != m_FormatMap.end( ) );
}


//#########################################################################


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

CFormatRegistrar::CFormatRegistrar( const Reference< XMultiServiceFactory >& ServiceManager,
								    const CDataFormatTranslator& aDataFormatTranslator ) :
	m_DataFormatTranslator( aDataFormatTranslator ),
	m_bHasSynthesizedLocale( sal_False ),
	m_SrvMgr( ServiceManager )
{
}

// ----------------------------------------------------------------------------------------
// this function converts all DataFlavors of the given FlavorList into
// an appropriate FORMATETC structure, for some formats like unicodetext,
// text and text/html we will offer an accompany format e.g.:
//
// DataFlavor				| Registered Clipformat		|	Registered accompany clipformat
// -------------------------|---------------------------|-----------------------------------
// text/plain;charset=ansi	| CF_TEXT					|	CF_UNICODETEXT
//							|							|	CF_LOCALE (if charset != GetACP()
//							|							|
// text/plain;charset=oem	| CF_OEMTEXT				|	CF_UNICODETEXT
//							|							|	CF_LOCALE (if charset != GetOEMCP()
//							|							|
// text/plain;charset=utf-16| CF_UNICODETEXT			|	CF_TEXT
//							|							|
// text/html				| HTML (Hypertext ...)		|	HTML Format
//							|							|
//
// if some tries to register different text formats with different charsets the last
// registered wins and the others are ignored
// ----------------------------------------------------------------------------------------

void SAL_CALL CFormatRegistrar::RegisterFormats(
	const Reference< XTransferable >& aXTransferable, CFormatEtcContainer& aFormatEtcContainer )
{
	Sequence< DataFlavor > aFlavorList = aXTransferable->getTransferDataFlavors( );
	sal_Int32  nFlavors                = aFlavorList.getLength( );
	sal_Bool   bUnicodeRegistered      = sal_False;
	DataFlavor aFlavor;

	for( sal_Int32 i = 0; i < nFlavors; i++ )
	{
		aFlavor = aFlavorList[i];
		CFormatEtc fetc = m_DataFormatTranslator.getFormatEtcFromDataFlavor( aFlavor );

		// maybe an internal format so we ignore it
		if ( CF_INVALID == fetc.getClipformat( ) )
			continue;

		if ( !needsToSynthesizeAccompanyFormats( fetc ) )
			aFormatEtcContainer.addFormatEtc( fetc );
		else
		{
			// if we haven't registered any text format up to now
			if ( m_DataFormatTranslator.isTextFormat( fetc.getClipformat() ) && !bUnicodeRegistered )
			{
				// if the transferable supports unicode text we ignore
				// any further text format the transferable offers
				// because we can create it from Unicode text in addition
				// we register CF_TEXT for non unicode clients
				if ( m_DataFormatTranslator.isUnicodeTextFormat( fetc.getClipformat() ) )
				{
					aFormatEtcContainer.addFormatEtc( fetc ); // add CF_UNICODE
					aFormatEtcContainer.addFormatEtc(
						m_DataFormatTranslator.getFormatEtcForClipformat( CF_TEXT ) ); // add CF_TEXT
					bUnicodeRegistered = sal_True;
				}
				else if ( !hasUnicodeFlavor( aXTransferable ) )
				{
					// we try to investigate the charset and make a valid
					// windows codepage from this charset the default
					// return value is the result of GetACP( )
					OUString charset = getCharsetFromDataFlavor( aFlavor );
					sal_uInt32 txtCP = getWinCPFromMimeCharset( charset );

					// we try to get a Locale appropriate for this codepage
					if ( findLocaleForTextCodePage( ) )
					{
						m_TxtCodePage = txtCP;

						aFormatEtcContainer.addFormatEtc(
							m_DataFormatTranslator.getFormatEtcForClipformat( CF_UNICODETEXT ) );

						if ( !IsOEMCP( m_TxtCodePage ) )
							aFormatEtcContainer.addFormatEtc(
								m_DataFormatTranslator.getFormatEtcForClipformat( CF_TEXT ) );
						else
							aFormatEtcContainer.addFormatEtc(
								m_DataFormatTranslator.getFormatEtcForClipformat( CF_OEMTEXT ) );

						aFormatEtcContainer.addFormatEtc(
							m_DataFormatTranslator.getFormatEtcForClipformat( CF_LOCALE ) );

						// we save the flavor so it's easier when
						// queried for it in XTDataObject::GetData(...)
						m_RegisteredTextFlavor  = aFlavor;
						m_bHasSynthesizedLocale = sal_True;
					}
				}
			}
			else if ( m_DataFormatTranslator.isTextHtmlFormat( fetc.getClipformat( ) ) ) // Html (Hyper Text...)
			{
				// we add text/html ( HTML (HyperText Markup Language) )
				aFormatEtcContainer.addFormatEtc( fetc );

				// and HTML Format
				OUString htmlFormat( OUString::createFromAscii( "HTML Format" ) );
				aFormatEtcContainer.addFormatEtc(
					m_DataFormatTranslator.getFormatEtcForClipformatName( htmlFormat ) );
			}
		}
	}
}

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

sal_Bool SAL_CALL CFormatRegistrar::hasSynthesizedLocale( ) const
{
	return m_bHasSynthesizedLocale;
}

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

LCID SAL_CALL CFormatRegistrar::getSynthesizedLocale( ) const
{
	return m_TxtLocale;
}

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

sal_uInt32 SAL_CALL CFormatRegistrar::getRegisteredTextCodePage( ) const
{
	return m_TxtCodePage;
}

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

DataFlavor SAL_CALL CFormatRegistrar::getRegisteredTextFlavor( ) const
{
	return m_RegisteredTextFlavor;
}

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

sal_Bool SAL_CALL CFormatRegistrar::isSynthesizeableFormat( const CFormatEtc& aFormatEtc ) const
{
	return ( m_DataFormatTranslator.isOemOrAnsiTextFormat( aFormatEtc.getClipformat() ) ||
		     m_DataFormatTranslator.isUnicodeTextFormat( aFormatEtc.getClipformat() ) ||
			 m_DataFormatTranslator.isHTMLFormat( aFormatEtc.getClipformat() ) );
}

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

inline
sal_Bool SAL_CALL CFormatRegistrar::needsToSynthesizeAccompanyFormats( const CFormatEtc& aFormatEtc ) const
{
	return ( m_DataFormatTranslator.isOemOrAnsiTextFormat( aFormatEtc.getClipformat() ) ||
		     m_DataFormatTranslator.isUnicodeTextFormat( aFormatEtc.getClipformat() ) ||
			 m_DataFormatTranslator.isTextHtmlFormat( aFormatEtc.getClipformat( ) ) );
}

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

OUString SAL_CALL CFormatRegistrar::getCharsetFromDataFlavor( const DataFlavor& aFlavor )
{
	OUString charset;

	try
	{
		Reference< XMimeContentTypeFactory > xMimeFac(
			m_SrvMgr->createInstance( OUString::createFromAscii( \
				"com.sun.star.datatransfer.MimeContentTypeFactory" ) ), UNO_QUERY );

		if( xMimeFac.is( ) )
		{
			Reference< XMimeContentType > xMimeType( xMimeFac->createMimeContentType( aFlavor.MimeType ) );
			if ( xMimeType->hasParameter( TEXTPLAIN_PARAM_CHARSET ) )
				charset = xMimeType->getParameterValue( TEXTPLAIN_PARAM_CHARSET );
			else
				charset = getMimeCharsetFromWinCP( GetACP( ), PRE_WINDOWS_CODEPAGE );
		}
	}
	catch(NoSuchElementException&)
	{
		OSL_ENSURE( sal_False, "Unexpected" );
	}
	catch(...)
	{
		OSL_ENSURE( sal_False, "Invalid data flavor" );
	}

	return charset;
}

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

sal_Bool SAL_CALL CFormatRegistrar::hasUnicodeFlavor( const Reference< XTransferable >& aXTransferable ) const
{
	CFormatEtc fetc( CF_UNICODETEXT );

	DataFlavor aFlavor =
		m_DataFormatTranslator.getDataFlavorFromFormatEtc( fetc );

	return aXTransferable->isDataFlavorSupported( aFlavor );
}

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

inline
sal_Bool CFormatRegistrar::isEqualCurrentSystemCodePage( sal_uInt32 aCodePage ) const
{
	return ( (aCodePage == GetOEMCP()) || (aCodePage == GetACP()) );
}

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

sal_Bool SAL_CALL CFormatRegistrar::findLocaleForTextCodePage( )
{
	m_TxtLocale = 0;
	EnumSystemLocalesA( CFormatRegistrar::EnumLocalesProc, LCID_INSTALLED );
	return ( IsValidLocale( m_TxtLocale, LCID_INSTALLED ) ) ? sal_True : sal_False;
}

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

sal_Bool SAL_CALL CFormatRegistrar::isLocaleCodePage( LCID lcid, LCTYPE lctype, sal_uInt32 codepage )
{
	char  buff[6];
	sal_uInt32 localeCodePage;

	OSL_ASSERT( IsValidLocale( lcid, LCID_INSTALLED ) );

	// get the ansi codepage of the current locale
	GetLocaleInfoA( lcid, lctype, buff, sizeof( buff ) );
	localeCodePage = atol( buff );

	return ( localeCodePage == codepage );
}

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

inline
sal_Bool SAL_CALL CFormatRegistrar::isLocaleOemCodePage( LCID lcid, sal_uInt32 codepage )
{
	return isLocaleCodePage( lcid, LOCALE_IDEFAULTCODEPAGE, codepage );
}

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

inline
sal_Bool SAL_CALL CFormatRegistrar::isLocaleAnsiCodePage( LCID lcid, sal_uInt32 codepage )
{
	return isLocaleCodePage( lcid, LOCALE_IDEFAULTANSICODEPAGE, codepage );
}

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

BOOL CALLBACK CFormatRegistrar::EnumLocalesProc( LPSTR lpLocaleStr )
{
	// the lpLocaleStr parametere is hexadecimal
	LCID lcid = strtol( lpLocaleStr, NULL, 16 );

	if ( isLocaleAnsiCodePage( lcid, CFormatRegistrar::m_TxtCodePage ) ||
		 isLocaleOemCodePage( lcid, CFormatRegistrar::m_TxtCodePage ) )
	{
		CFormatRegistrar::m_TxtLocale = lcid;
		return sal_False; // stop enumerating
	}

	return sal_True;
}