Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

22 files changed, 4409 insertions, 0 deletions

diff --git a/dtrans/source/win32/dtobj/APNDataObject.cxx b/dtrans/source/win32/dtobj/APNDataObject.cxx
new file mode 100644
index 000000000..53342f21f
--- /dev/null
+++ b/dtrans/source/win32/dtobj/APNDataObject.cxx
@@ -0,0 +1,327 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include "APNDataObject.hxx"
+#include <osl/diagnose.h>
+
+#include <systools/win32/comtools.hxx>
+
+#define FREE_HGLOB_ON_RELEASE   TRUE
+#define KEEP_HGLOB_ON_RELEASE   FALSE
+
+// ctor
+
+CAPNDataObject::CAPNDataObject( IDataObjectPtr rIDataObject ) :
+    m_rIDataObjectOrg( rIDataObject ),
+    m_hGlobal( nullptr ),
+    m_nRefCnt( 0 )
+{
+
+    OSL_ENSURE( m_rIDataObjectOrg.get( ), "constructing CAPNDataObject with empty data object" );
+
+    // we marshal the IDataObject interface pointer here so
+    // that it can be unmarshalled multiple times when this
+    // class will be used from another apartment
+    IStreamPtr pStm;
+    HRESULT hr = CreateStreamOnHGlobal( nullptr, KEEP_HGLOB_ON_RELEASE, &pStm );
+
+    OSL_ENSURE( E_INVALIDARG != hr, "invalid args passed to CreateStreamOnHGlobal" );
+
+    if ( SUCCEEDED( hr ) )
+    {
+        HRESULT hr_marshal = CoMarshalInterface(
+            pStm.get(),
+            __uuidof(IDataObject),
+            static_cast<LPUNKNOWN>(m_rIDataObjectOrg.get()),
+            MSHCTX_LOCAL,
+            nullptr,
+            MSHLFLAGS_TABLEWEAK );
+
+        OSL_ENSURE( CO_E_NOTINITIALIZED != hr_marshal, "COM is not initialized" );
+
+        // marshalling may fail if COM is not initialized
+        // for the calling thread which is a program time
+        // error or because of stream errors which are runtime
+        // errors for instance E_OUTOFMEMORY etc.
+
+        hr = GetHGlobalFromStream(pStm.get(), &m_hGlobal );
+
+        OSL_ENSURE( E_INVALIDARG != hr, "invalid stream passed to GetHGlobalFromStream" );
+
+        // if the marshalling failed we free the
+        // global memory again and set m_hGlobal
+        // to a defined value
+        if (FAILED(hr_marshal))
+        {
+            OSL_FAIL("marshalling failed");
+
+            HGLOBAL hGlobal =
+                GlobalFree(m_hGlobal);
+            OSL_ENSURE(nullptr == hGlobal, "GlobalFree failed");
+            m_hGlobal = nullptr;
+        }
+    }
+}
+
+CAPNDataObject::~CAPNDataObject( )
+{
+    if (m_hGlobal)
+    {
+        IStreamPtr pStm;
+        HRESULT  hr = CreateStreamOnHGlobal(m_hGlobal, FREE_HGLOB_ON_RELEASE, &pStm);
+
+        OSL_ENSURE( E_INVALIDARG != hr, "invalid args passed to CreateStreamOnHGlobal" );
+
+        if (SUCCEEDED(hr))
+        {
+            hr = CoReleaseMarshalData(pStm.get());
+            OSL_ENSURE(SUCCEEDED(hr), "CoReleaseMarshalData failed");
+        }
+    }
+}
+
+// IUnknown->QueryInterface
+
+STDMETHODIMP CAPNDataObject::QueryInterface( REFIID iid, void** ppvObject )
+{
+    OSL_ASSERT( nullptr != ppvObject );
+
+    if ( nullptr == ppvObject )
+        return E_INVALIDARG;
+
+    HRESULT hr = E_NOINTERFACE;
+    *ppvObject = nullptr;
+
+    if ( ( __uuidof( IUnknown ) == iid ) || ( __uuidof( IDataObject ) == iid ) )
+    {
+        *ppvObject = static_cast< IUnknown* >( this );
+        static_cast<LPUNKNOWN>(*ppvObject)->AddRef( );
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+// IUnknown->AddRef
+
+STDMETHODIMP_(ULONG) CAPNDataObject::AddRef( )
+{
+    return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
+}
+
+// IUnknown->Release
+
+STDMETHODIMP_(ULONG) CAPNDataObject::Release( )
+{
+    // we need a helper variable because it's not allowed to access
+    // a member variable after an object is destroyed
+    ULONG nRefCnt = static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
+
+    if ( 0 == nRefCnt )
+        delete this;
+
+    return nRefCnt;
+}
+
+// IDataObject->GetData
+
+STDMETHODIMP CAPNDataObject::GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium )
+{
+    HRESULT hr = m_rIDataObjectOrg->GetData( pFormatetc, pmedium );
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->GetData(pFormatetc, pmedium);
+    }
+    return hr;
+}
+
+// IDataObject->EnumFormatEtc
+
+STDMETHODIMP CAPNDataObject::EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
+{
+    HRESULT hr = m_rIDataObjectOrg->EnumFormatEtc(dwDirection, ppenumFormatetc);
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->EnumFormatEtc(dwDirection, ppenumFormatetc);
+    }
+    return hr;
+}
+
+// IDataObject->QueryGetData
+
+STDMETHODIMP CAPNDataObject::QueryGetData( FORMATETC * pFormatetc )
+{
+    HRESULT hr = m_rIDataObjectOrg->QueryGetData( pFormatetc );
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment( &pIDOTmp );
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->QueryGetData(pFormatetc);
+    }
+    return hr;
+}
+
+// IDataObject->GetDataHere
+
+STDMETHODIMP CAPNDataObject::GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pmedium )
+{
+    HRESULT hr = m_rIDataObjectOrg->GetDataHere(pFormatetc, pmedium);
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->GetDataHere(pFormatetc, pmedium);
+    }
+    return hr;
+}
+
+// IDataObject->GetCanonicalFormatEtc
+
+STDMETHODIMP CAPNDataObject::GetCanonicalFormatEtc(FORMATETC * pFormatectIn, FORMATETC * pFormatetcOut)
+{
+    HRESULT hr = m_rIDataObjectOrg->GetCanonicalFormatEtc( pFormatectIn, pFormatetcOut );
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->GetCanonicalFormatEtc(pFormatectIn, pFormatetcOut);
+    }
+    return hr;
+}
+
+// IDataObject->SetData
+
+STDMETHODIMP CAPNDataObject::SetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium, BOOL fRelease )
+{
+    HRESULT hr = m_rIDataObjectOrg->SetData( pFormatetc, pmedium, fRelease );
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->SetData(pFormatetc, pmedium, fRelease);
+    }
+    return hr;
+}
+
+// IDataObject->DAdvise
+
+STDMETHODIMP CAPNDataObject::DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection )
+{
+    HRESULT hr = m_rIDataObjectOrg->DAdvise(pFormatetc, advf, pAdvSink, pdwConnection);
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->DAdvise(pFormatetc, advf, pAdvSink, pdwConnection);
+    }
+    return hr;
+}
+
+// IDataObject->DUnadvise
+
+STDMETHODIMP CAPNDataObject::DUnadvise( DWORD dwConnection )
+{
+    HRESULT hr = m_rIDataObjectOrg->DUnadvise( dwConnection );
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->DUnadvise(dwConnection);
+    }
+    return hr;
+}
+
+// IDataObject->EnumDAdvise
+
+STDMETHODIMP CAPNDataObject::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise )
+{
+    HRESULT hr = m_rIDataObjectOrg->EnumDAdvise(ppenumAdvise);
+
+    if (RPC_E_WRONG_THREAD == hr)
+    {
+        IDataObjectPtr pIDOTmp;
+        hr = MarshalIDataObjectIntoCurrentApartment(&pIDOTmp);
+
+        if (SUCCEEDED(hr))
+            hr = pIDOTmp->EnumDAdvise(ppenumAdvise);
+    }
+    return hr;
+}
+
+// for our convenience
+
+CAPNDataObject::operator IDataObject*( )
+{
+    return static_cast< IDataObject* >( this );
+}
+
+// helper function
+
+HRESULT CAPNDataObject::MarshalIDataObjectIntoCurrentApartment( IDataObject** ppIDataObj )
+{
+    OSL_ASSERT(nullptr != ppIDataObj);
+
+    *ppIDataObj = nullptr;
+    HRESULT hr = E_FAIL;
+
+    if (m_hGlobal)
+    {
+        IStreamPtr pStm;
+        hr = CreateStreamOnHGlobal(m_hGlobal, KEEP_HGLOB_ON_RELEASE, &pStm);
+
+        OSL_ENSURE(E_INVALIDARG != hr, "CreateStreamOnHGlobal with invalid args called");
+
+        if (SUCCEEDED(hr))
+        {
+            hr = CoUnmarshalInterface(pStm.get(), __uuidof(IDataObject), reinterpret_cast<void**>(ppIDataObj));
+            OSL_ENSURE(CO_E_NOTINITIALIZED != hr, "COM is not initialized");
+        }
+    }
+    return hr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/APNDataObject.hxx b/dtrans/source/win32/dtobj/APNDataObject.hxx
new file mode 100644
index 000000000..2c1d9718e
--- /dev/null
+++ b/dtrans/source/win32/dtobj/APNDataObject.hxx
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_APNDATAOBJECT_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_APNDATAOBJECT_HXX
+
+#include <systools/win32/comtools.hxx>
+
+/*
+    an APartment Neutral dataobject wrapper; this wrapper of an IDataObject
+    pointer can be used from any apartment without RPC_E_WRONG_THREAD
+    which normally occurs if an apartment tries to use an interface
+    pointer of another apartment; we use containment to hold the original
+    DataObject
+*/
+class CAPNDataObject : public IDataObject
+{
+public:
+    explicit CAPNDataObject(IDataObjectPtr rIDataObject);
+    virtual ~CAPNDataObject();
+
+    //IUnknown interface methods
+
+    STDMETHODIMP           QueryInterface(REFIID iid, void** ppvObject) override;
+    STDMETHODIMP_( ULONG ) AddRef( ) override;
+    STDMETHODIMP_( ULONG ) Release( ) override;
+
+    // IDataObject interface methods
+
+    STDMETHODIMP GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP QueryGetData( FORMATETC * pFormatetc ) override;
+    STDMETHODIMP GetCanonicalFormatEtc( FORMATETC * pFormatectIn, FORMATETC * pFormatetcOut ) override;
+    STDMETHODIMP SetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium, BOOL fRelease ) override;
+    STDMETHODIMP EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc ) override;
+    STDMETHODIMP DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD* pdwConnection ) override;
+    STDMETHODIMP DUnadvise( DWORD dwConnection ) override;
+    STDMETHODIMP EnumDAdvise( IEnumSTATDATA** ppenumAdvise ) override;
+
+    operator IDataObject*( );
+
+private:
+    HRESULT MarshalIDataObjectIntoCurrentApartment( IDataObject** ppIDataObj );
+
+private:
+    IDataObjectPtr  m_rIDataObjectOrg;
+    HGLOBAL         m_hGlobal;
+    LONG            m_nRefCnt;
+
+// prevent copy and assignment
+private:
+    CAPNDataObject( const CAPNDataObject& theOther );
+    CAPNDataObject& operator=( const CAPNDataObject& theOther );
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DOTransferable.cxx b/dtrans/source/win32/dtobj/DOTransferable.cxx
new file mode 100644
index 000000000..8f27e7124
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DOTransferable.cxx
@@ -0,0 +1,589 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <sal/types.h>
+#include <rtl/process.h>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+
+#include "DOTransferable.hxx"
+#include "../misc/ImplHelper.hxx"
+#include <WinClip.hxx>
+#include "DTransHelper.hxx"
+#include "TxtCnvtHlp.hxx"
+#include "MimeAttrib.hxx"
+#include "FmtFilter.hxx"
+#include "Fetc.hxx"
+#include <com/sun/star/container/NoSuchElementException.hpp>
+#include <com/sun/star/datatransfer/MimeContentTypeFactory.hpp>
+#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+
+using namespace std;
+using namespace osl;
+using namespace cppu;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::datatransfer;
+using namespace com::sun::star::io;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::container;
+
+namespace
+{
+    const Type CPPUTYPE_SEQINT8  = cppu::UnoType<Sequence< sal_Int8 >>::get();
+    const Type CPPUTYPE_OUSTRING = cppu::UnoType<OUString>::get();
+
+    bool isValidFlavor( const DataFlavor& aFlavor )
+    {
+        return ( aFlavor.MimeType.getLength( ) &&
+                 ( ( aFlavor.DataType ==  CPPUTYPE_SEQINT8 ) ||
+                 ( aFlavor.DataType == CPPUTYPE_OUSTRING ) ) );
+    }
+
+void clipDataToByteStream( CLIPFORMAT cf, STGMEDIUM stgmedium, CDOTransferable::ByteSequence_t& aByteSequence )
+{
+    CStgTransferHelper memTransferHelper;
+    LPSTREAM pStream = nullptr;
+
+    switch( stgmedium.tymed )
+    {
+    case TYMED_HGLOBAL:
+        memTransferHelper.init( stgmedium.hGlobal );
+        break;
+
+    case TYMED_MFPICT:
+        memTransferHelper.init( stgmedium.hMetaFilePict );
+        break;
+
+    case TYMED_ENHMF:
+        memTransferHelper.init( stgmedium.hEnhMetaFile );
+        break;
+
+    case TYMED_ISTREAM:
+        pStream = stgmedium.pstm;
+        break;
+
+    default:
+        throw UnsupportedFlavorException( );
+        break;
+    }
+
+    if (pStream)
+    {
+        // We have a stream, read from it.
+        STATSTG aStat;
+        HRESULT hr = pStream->Stat(&aStat, STATFLAG_NONAME);
+        if (FAILED(hr))
+        {
+            SAL_WARN("dtrans", "clipDataToByteStream: Stat() failed");
+            return;
+        }
+
+        size_t nMemSize = aStat.cbSize.QuadPart;
+        aByteSequence.realloc(nMemSize);
+        LARGE_INTEGER li;
+        li.QuadPart = 0;
+        hr = pStream->Seek(li, STREAM_SEEK_SET, nullptr);
+        if (FAILED(hr))
+        {
+            SAL_WARN("dtrans", "clipDataToByteStream: Seek() failed");
+        }
+
+        ULONG nRead = 0;
+        hr = pStream->Read(aByteSequence.getArray(), nMemSize, &nRead);
+        if (FAILED(hr))
+        {
+            SAL_WARN("dtrans", "clipDataToByteStream: Read() failed");
+        }
+        if (nRead < nMemSize)
+        {
+            SAL_WARN("dtrans", "clipDataToByteStream: Read() was partial");
+        }
+
+        return;
+    }
+
+    int nMemSize = memTransferHelper.memSize( cf );
+    aByteSequence.realloc( nMemSize );
+    memTransferHelper.read( aByteSequence.getArray( ), nMemSize );
+}
+
+OUString byteStreamToOUString( CDOTransferable::ByteSequence_t& aByteStream )
+{
+    sal_Int32 nWChars;
+    sal_Int32 nMemSize = aByteStream.getLength( );
+
+    // if there is a trailing L"\0" subtract 1 from length
+    // for unknown reason, the sequence may sometimes arrive empty
+    if ( aByteStream.getLength( ) > 1 &&
+         0 == aByteStream[ aByteStream.getLength( ) - 2 ] &&
+         0 == aByteStream[ aByteStream.getLength( ) - 1 ] )
+        nWChars = static_cast< sal_Int32 >( nMemSize / sizeof( sal_Unicode ) ) - 1;
+    else
+        nWChars = static_cast< sal_Int32 >( nMemSize / sizeof( sal_Unicode ) );
+
+    return OUString( reinterpret_cast< sal_Unicode* >( aByteStream.getArray( ) ), nWChars );
+}
+
+Any byteStreamToAny( CDOTransferable::ByteSequence_t& aByteStream, const Type& aRequestedDataType )
+{
+    Any aAny;
+
+    if ( aRequestedDataType == CPPUTYPE_OUSTRING )
+    {
+        OUString str = byteStreamToOUString( aByteStream );
+        if (str.isEmpty())
+            throw RuntimeException();
+        aAny <<= str;
+    }
+    else
+        aAny <<= aByteStream;
+
+    return aAny;
+}
+
+bool cmpFullMediaType(
+    const Reference< XMimeContentType >& xLhs, const Reference< XMimeContentType >& xRhs )
+{
+    return xLhs->getFullMediaType().equalsIgnoreAsciiCase( xRhs->getFullMediaType( ) );
+}
+
+bool cmpAllContentTypeParameter(
+    const Reference< XMimeContentType >& xLhs, const Reference< XMimeContentType >& xRhs )
+{
+    Sequence< OUString > xLhsFlavors = xLhs->getParameters( );
+    Sequence< OUString > xRhsFlavors = xRhs->getParameters( );
+    bool bRet = true;
+
+    try
+    {
+        if ( xLhsFlavors.getLength( ) == xRhsFlavors.getLength( ) )
+        {
+            OUString pLhs;
+            OUString pRhs;
+
+            for ( sal_Int32 i = 0; i < xLhsFlavors.getLength( ); i++ )
+            {
+                pLhs = xLhs->getParameterValue( xLhsFlavors[i] );
+                pRhs = xRhs->getParameterValue( xLhsFlavors[i] );
+
+                if ( !pLhs.equalsIgnoreAsciiCase( pRhs ) )
+                {
+                    bRet = false;
+                    break;
+                }
+            }
+        }
+        else
+            bRet = false;
+    }
+    catch( NoSuchElementException& )
+    {
+        bRet = false;
+    }
+    catch( IllegalArgumentException& )
+    {
+        bRet = false;
+    }
+
+    return bRet;
+}
+
+} // end namespace
+
+Reference< XTransferable > CDOTransferable::create( const Reference< XComponentContext >& rxContext,
+                                                                                     IDataObjectPtr pIDataObject )
+{
+    CDOTransferable* pTransf = new CDOTransferable(rxContext, pIDataObject);
+    Reference<XTransferable> refDOTransf(pTransf);
+
+    pTransf->acquire();
+    pTransf->initFlavorList();
+    pTransf->release();
+
+    return refDOTransf;
+}
+
+CDOTransferable::CDOTransferable(
+    const Reference< XComponentContext >& rxContext, IDataObjectPtr rDataObject ) :
+    m_rDataObject( rDataObject ),
+    m_xContext( rxContext ),
+    m_DataFormatTranslator( rxContext ),
+    m_bUnicodeRegistered( false ),
+    m_TxtFormatOnClipboard( CF_INVALID )
+{
+}
+
+Any SAL_CALL CDOTransferable::getTransferData( const DataFlavor& aFlavor )
+{
+    OSL_ASSERT( isValidFlavor( aFlavor ) );
+
+    MutexGuard aGuard( m_aMutex );
+
+    // convert dataflavor to formatetc
+
+    CFormatEtc fetc = m_DataFormatTranslator.getFormatEtcFromDataFlavor( aFlavor );
+    OSL_ASSERT( CF_INVALID != fetc.getClipformat() );
+
+    //  get the data from clipboard in a byte stream
+
+    ByteSequence_t clipDataStream;
+
+    try
+    {
+        clipDataStream = getClipboardData( fetc );
+    }
+    catch( UnsupportedFlavorException& )
+    {
+        if ( CDataFormatTranslator::isUnicodeTextFormat( fetc.getClipformat( ) ) &&
+             m_bUnicodeRegistered )
+        {
+             OUString aUnicodeText = synthesizeUnicodeText( );
+             Any aAny = makeAny( aUnicodeText );
+             return aAny;
+        }
+        // #i124085# CF_DIBV5 should not be possible, but keep for reading from the
+        // clipboard for being on the safe side
+        else if(CF_DIBV5 == fetc.getClipformat())
+        {
+            // #i123407# CF_DIBV5 has priority; if the try to fetch this failed,
+            // check CF_DIB availability as an alternative
+            fetc.setClipformat(CF_DIB);
+
+            clipDataStream = getClipboardData( fetc );
+                // pass UnsupportedFlavorException out, tried all possibilities
+        }
+        else
+            throw; // pass through exception
+    }
+
+    // return the data as any
+
+    return byteStreamToAny( clipDataStream, aFlavor.DataType );
+}
+
+// getTransferDataFlavors
+
+Sequence< DataFlavor > SAL_CALL CDOTransferable::getTransferDataFlavors(  )
+{
+    return m_FlavorList;
+}
+
+// isDataFlavorSupported
+// returns true if we find a DataFlavor with the same MimeType and
+// DataType
+
+sal_Bool SAL_CALL CDOTransferable::isDataFlavorSupported( const DataFlavor& aFlavor )
+{
+    OSL_ASSERT( isValidFlavor( aFlavor ) );
+
+    for ( DataFlavor const & df : std::as_const(m_FlavorList) )
+        if ( compareDataFlavors( aFlavor, df ) )
+            return true;
+
+    return false;
+}
+
+// the list of dataflavors currently on the clipboard will be initialized
+// only once; if the client of this Transferable will hold a reference
+// to it and the underlying clipboard content changes, the client does
+// possible operate on an invalid list
+// if there is only text on the clipboard we will also offer unicode text
+// an synthesize this format on the fly if requested, to accomplish this
+// we save the first offered text format which we will later use for the
+// conversion
+
+void CDOTransferable::initFlavorList( )
+{
+    sal::systools::COMReference<IEnumFORMATETC> pEnumFormatEtc;
+    HRESULT hr = m_rDataObject->EnumFormatEtc( DATADIR_GET, &pEnumFormatEtc );
+    if ( SUCCEEDED( hr ) )
+    {
+        pEnumFormatEtc->Reset( );
+
+        FORMATETC fetc;
+        while ( S_OK == pEnumFormatEtc->Next( 1, &fetc, nullptr ) )
+        {
+            // we use locales only to determine the
+            // charset if there is text on the cliboard
+            // we don't offer this format
+            if ( CF_LOCALE == fetc.cfFormat )
+                continue;
+
+            DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
+
+            // if text or oemtext is offered we also pretend to have unicode text
+            if ( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) &&
+                 !m_bUnicodeRegistered )
+            {
+                addSupportedFlavor( aFlavor );
+
+                m_TxtFormatOnClipboard = fetc.cfFormat;
+                m_bUnicodeRegistered   = true;
+
+                // register unicode text as accompany format
+                aFlavor = formatEtcToDataFlavor(
+                    CDataFormatTranslator::getFormatEtcForClipformat( CF_UNICODETEXT ) );
+                addSupportedFlavor( aFlavor );
+            }
+            else if ( (CF_UNICODETEXT == fetc.cfFormat) && !m_bUnicodeRegistered )
+            {
+                addSupportedFlavor( aFlavor );
+                m_bUnicodeRegistered = true;
+            }
+            else
+                addSupportedFlavor( aFlavor );
+
+            // see MSDN IEnumFORMATETC
+            CoTaskMemFree( fetc.ptd );
+        }
+    }
+}
+
+inline
+void CDOTransferable::addSupportedFlavor( const DataFlavor& aFlavor )
+{
+    // we ignore all formats that couldn't be translated
+    if ( aFlavor.MimeType.getLength( ) )
+    {
+        OSL_ASSERT( isValidFlavor( aFlavor ) );
+
+        m_FlavorList.realloc( m_FlavorList.getLength( ) + 1 );
+        m_FlavorList[m_FlavorList.getLength( ) - 1] = aFlavor;
+    }
+}
+
+DataFlavor CDOTransferable::formatEtcToDataFlavor( const FORMATETC& aFormatEtc )
+{
+    LCID lcid = 0;
+
+    // for non-unicode text format we must provide a locale to get
+    // the character-set of the text, if there is no locale on the
+    // clipboard we assume the text is in a charset appropriate for
+    // the current thread locale
+    if ( (CF_TEXT == aFormatEtc.cfFormat) || (CF_OEMTEXT == aFormatEtc.cfFormat) )
+        lcid = getLocaleFromClipboard( );
+
+    return m_DataFormatTranslator.getDataFlavorFromFormatEtc( aFormatEtc, lcid );
+}
+
+// returns the current locale on clipboard; if there is no locale on
+// clipboard the function returns the current thread locale
+
+LCID CDOTransferable::getLocaleFromClipboard( )
+{
+    LCID lcid = GetThreadLocale( );
+
+    try
+    {
+        CFormatEtc fetc = CDataFormatTranslator::getFormatEtcForClipformat( CF_LOCALE );
+        ByteSequence_t aLCIDSeq = getClipboardData( fetc );
+        lcid = *reinterpret_cast<LCID*>( aLCIDSeq.getArray( ) );
+
+        // because of a Win95/98 Bug; there the high word
+        // of a locale has the same value as the
+        // low word e.g. 0x07040704 that's not right
+        // correct is 0x00000704
+        lcid &= 0x0000FFFF;
+    }
+    catch(...)
+    {
+        // we take the default locale
+    }
+
+    return lcid;
+}
+
+// I think it's not necessary to call ReleaseStgMedium
+// in case of failures because nothing should have been
+// allocated etc.
+
+CDOTransferable::ByteSequence_t CDOTransferable::getClipboardData( CFormatEtc& aFormatEtc )
+{
+    STGMEDIUM stgmedium;
+    HRESULT hr = m_rDataObject->GetData( aFormatEtc, &stgmedium );
+
+    // in case of failure to get a WMF metafile handle, try to get a memory block
+    if( FAILED( hr ) &&
+        ( CF_METAFILEPICT == aFormatEtc.getClipformat() ) &&
+        ( TYMED_MFPICT == aFormatEtc.getTymed() ) )
+    {
+        CFormatEtc aTempFormat( aFormatEtc );
+        aTempFormat.setTymed( TYMED_HGLOBAL );
+        hr = m_rDataObject->GetData( aTempFormat, &stgmedium );
+    }
+
+    if (FAILED(hr) && aFormatEtc.getTymed() == TYMED_HGLOBAL)
+    {
+        // Handle type is not memory, try stream.
+        CFormatEtc aTempFormat(aFormatEtc);
+        aTempFormat.setTymed(TYMED_ISTREAM);
+        hr = m_rDataObject->GetData(aTempFormat, &stgmedium);
+    }
+
+    if ( FAILED( hr ) )
+    {
+        OSL_ASSERT( (hr != E_INVALIDARG) &&
+                    (hr != DV_E_DVASPECT) &&
+                    (hr != DV_E_LINDEX) &&
+                    (hr != DV_E_TYMED) );
+
+        if ( DV_E_FORMATETC == hr )
+            throw UnsupportedFlavorException( );
+        else if ( STG_E_MEDIUMFULL == hr )
+            throw IOException( );
+        else
+            throw RuntimeException( );
+    }
+
+    ByteSequence_t byteStream;
+
+    try
+    {
+        if ( CF_ENHMETAFILE == aFormatEtc.getClipformat() )
+            byteStream = WinENHMFPictToOOMFPict( stgmedium.hEnhMetaFile );
+        else if (CF_HDROP == aFormatEtc.getClipformat())
+            byteStream = CF_HDROPToFileList(stgmedium.hGlobal);
+        else if ( CF_BITMAP == aFormatEtc.getClipformat() )
+        {
+            byteStream = WinBITMAPToOOBMP(stgmedium.hBitmap);
+            if( aFormatEtc.getTymed() == TYMED_GDI &&
+                ! stgmedium.pUnkForRelease )
+            {
+                DeleteObject(stgmedium.hBitmap);
+            }
+        }
+        else
+        {
+            clipDataToByteStream( aFormatEtc.getClipformat( ), stgmedium, byteStream );
+
+            // format conversion if necessary
+            // #i124085# DIBV5 should not happen currently, but keep as a hint here
+            if(CF_DIBV5 == aFormatEtc.getClipformat() || CF_DIB == aFormatEtc.getClipformat())
+            {
+                byteStream = WinDIBToOOBMP(byteStream);
+            }
+            else if(CF_METAFILEPICT == aFormatEtc.getClipformat())
+            {
+                byteStream = WinMFPictToOOMFPict(byteStream);
+            }
+        }
+
+        ReleaseStgMedium( &stgmedium );
+    }
+    catch( CStgTransferHelper::CStgTransferException& )
+    {
+        ReleaseStgMedium( &stgmedium );
+        throw IOException( );
+    }
+
+    return byteStream;
+}
+
+OUString CDOTransferable::synthesizeUnicodeText( )
+{
+    ByteSequence_t aTextSequence;
+    CFormatEtc     fetc;
+    LCID           lcid = getLocaleFromClipboard( );
+    sal_uInt32     cpForTxtCnvt = 0;
+
+    if ( CF_TEXT == m_TxtFormatOnClipboard )
+    {
+        fetc = CDataFormatTranslator::getFormatEtcForClipformat( CF_TEXT );
+        aTextSequence = getClipboardData( fetc );
+
+        // determine the codepage used for text conversion
+        cpForTxtCnvt = getWinCPFromLocaleId( lcid, LOCALE_IDEFAULTANSICODEPAGE ).toInt32( );
+    }
+    else if ( CF_OEMTEXT == m_TxtFormatOnClipboard )
+    {
+        fetc = CDataFormatTranslator::getFormatEtcForClipformat( CF_OEMTEXT );
+        aTextSequence = getClipboardData( fetc );
+
+        // determine the codepage used for text conversion
+        cpForTxtCnvt = getWinCPFromLocaleId( lcid, LOCALE_IDEFAULTCODEPAGE ).toInt32( );
+    }
+    else
+        OSL_ASSERT( false );
+
+    CStgTransferHelper stgTransferHelper;
+
+    // convert the text
+    MultiByteToWideCharEx( cpForTxtCnvt,
+                           reinterpret_cast<char*>( aTextSequence.getArray( ) ),
+                           sal::static_int_cast<sal_uInt32>(-1), // Huh ?
+                           stgTransferHelper,
+                           false);
+
+    CRawHGlobalPtr  ptrHGlob(stgTransferHelper);
+    sal_Unicode*    pWChar = static_cast<sal_Unicode*>(ptrHGlob.GetMemPtr());
+
+    return OUString(pWChar);
+}
+
+bool CDOTransferable::compareDataFlavors(
+    const DataFlavor& lhs, const DataFlavor& rhs )
+{
+    if ( !m_rXMimeCntFactory.is( ) )
+    {
+        m_rXMimeCntFactory = MimeContentTypeFactory::create( m_xContext );
+    }
+
+    bool bRet = false;
+
+    try
+    {
+        Reference< XMimeContentType > xLhs( m_rXMimeCntFactory->createMimeContentType( lhs.MimeType ) );
+        Reference< XMimeContentType > xRhs( m_rXMimeCntFactory->createMimeContentType( rhs.MimeType ) );
+
+        if ( cmpFullMediaType( xLhs, xRhs ) )
+        {
+            bRet = cmpAllContentTypeParameter( xLhs, xRhs );
+        }
+    }
+    catch( IllegalArgumentException& )
+    {
+        OSL_FAIL( "Invalid content type detected" );
+        bRet = false;
+    }
+
+    return bRet;
+}
+
+css::uno::Any SAL_CALL CDOTransferable::getData( const Sequence< sal_Int8>& aProcessId  )
+{
+    Any retVal;
+
+    sal_Int8 const * arProcCaller= aProcessId.getConstArray();
+    sal_uInt8 arId[16];
+    rtl_getGlobalProcessId(arId);
+    if( ! memcmp( arId, arProcCaller,16))
+    {
+        if (m_rDataObject.is())
+        {
+            IDataObject* pObj= m_rDataObject.get();
+            pObj->AddRef();
+            retVal.setValue( &pObj, cppu::UnoType<sal_uInt32>::get());
+        }
+    }
+    return retVal;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DOTransferable.hxx b/dtrans/source/win32/dtobj/DOTransferable.hxx
new file mode 100644
index 000000000..f45e18c4f
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DOTransferable.hxx
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DOTRANSFERABLE_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DOTRANSFERABLE_HXX
+
+#include <com/sun/star/datatransfer/XTransferable.hpp>
+
+#include <cppuhelper/implbase.hxx>
+#include "DataFmtTransl.hxx"
+#include <com/sun/star/datatransfer/XMimeContentTypeFactory.hpp>
+#include <com/sun/star/datatransfer/XMimeContentType.hpp>
+#include <com/sun/star/datatransfer/XSystemTransferable.hpp>
+
+#include <systools/win32/comtools.hxx>
+
+// forward
+class CFormatEtc;
+
+class CDOTransferable : public ::cppu::WeakImplHelper<
+                            css::datatransfer::XTransferable,
+                            css::datatransfer::XSystemTransferable>
+{
+public:
+    typedef css::uno::Sequence< sal_Int8 > ByteSequence_t;
+
+    static css::uno::Reference< css::datatransfer::XTransferable > create(
+        const css::uno::Reference< css::uno::XComponentContext >& rxContext, IDataObjectPtr pIDataObject );
+
+    // XTransferable
+
+    virtual css::uno::Any SAL_CALL getTransferData( const css::datatransfer::DataFlavor& aFlavor ) override;
+
+    virtual css::uno::Sequence< css::datatransfer::DataFlavor > SAL_CALL getTransferDataFlavors(  ) override;
+
+    virtual sal_Bool SAL_CALL isDataFlavorSupported( const css::datatransfer::DataFlavor& aFlavor ) override;
+
+    // XSystemTransferable
+
+    virtual css::uno::Any SAL_CALL getData( const css::uno::Sequence<sal_Int8>& aProcessId  ) override;
+
+private:
+    explicit CDOTransferable(
+        const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+        IDataObjectPtr rDataObject );
+
+    // some helper functions
+
+    void initFlavorList( );
+
+    void addSupportedFlavor( const css::datatransfer::DataFlavor& aFlavor );
+    css::datatransfer::DataFlavor formatEtcToDataFlavor( const FORMATETC& aFormatEtc );
+
+    ByteSequence_t getClipboardData( CFormatEtc& aFormatEtc );
+    OUString synthesizeUnicodeText( );
+
+    LCID getLocaleFromClipboard( );
+
+    bool compareDataFlavors( const css::datatransfer::DataFlavor& lhs,
+                                          const css::datatransfer::DataFlavor& rhs );
+
+private:
+    IDataObjectPtr                                                                          m_rDataObject;
+    css::uno::Sequence< css::datatransfer::DataFlavor >               m_FlavorList;
+    const css::uno::Reference< css::uno::XComponentContext >          m_xContext;
+    CDataFormatTranslator                                             m_DataFormatTranslator;
+    css::uno::Reference< css::datatransfer::XMimeContentTypeFactory > m_rXMimeCntFactory;
+    ::osl::Mutex                                                      m_aMutex;
+    bool                                                              m_bUnicodeRegistered;
+    CLIPFORMAT                                                        m_TxtFormatOnClipboard;
+
+// non supported operations
+private:
+    CDOTransferable( const CDOTransferable& );
+    CDOTransferable& operator=( const CDOTransferable& );
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DTransHelper.cxx b/dtrans/source/win32/dtobj/DTransHelper.cxx
new file mode 100644
index 000000000..66d18f9fb
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DTransHelper.cxx
@@ -0,0 +1,205 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <rtl/ustring.h>
+#include <osl/diagnose.h>
+#include "DTransHelper.hxx"
+
+// implementation
+
+CStgTransferHelper::CStgTransferHelper( bool bAutoInit,
+                                        HGLOBAL hGlob,
+                                        bool bDelStgOnRelease ) :
+    m_lpStream( nullptr ),
+    m_bDelStgOnRelease( bDelStgOnRelease )
+{
+    if ( bAutoInit )
+        init( hGlob, m_bDelStgOnRelease );
+}
+
+// dtor
+
+CStgTransferHelper::~CStgTransferHelper( )
+{
+    if ( m_lpStream )
+        m_lpStream->Release( );
+}
+
+// TransferData into the
+
+void CStgTransferHelper::write( const void* lpData, ULONG cb, ULONG* cbWritten )
+{
+    HRESULT hr = E_FAIL;
+
+    if ( m_lpStream )
+        hr = m_lpStream->Write( lpData, cb, cbWritten );
+
+    if ( FAILED( hr ) )
+        throw CStgTransferException( hr );
+
+#if OSL_DEBUG_LEVEL > 0
+    HGLOBAL hGlob;
+    hr = GetHGlobalFromStream( m_lpStream, &hGlob );
+    OSL_ASSERT( SUCCEEDED( hr ) );
+
+    /*DWORD dwSize =*/ GlobalSize( hGlob );
+    /*LPVOID lpdbgData =*/ GlobalLock( hGlob );
+    GlobalUnlock( hGlob );
+#endif
+}
+
+// read
+
+void CStgTransferHelper::read( LPVOID pv, ULONG cb, ULONG* pcbRead )
+{
+    HRESULT hr = E_FAIL;
+
+    if ( m_lpStream )
+        hr = m_lpStream->Read( pv, cb , pcbRead );
+
+    if ( FAILED( hr ) )
+        throw CStgTransferException( hr );
+}
+
+// GetHGlobal
+
+HGLOBAL CStgTransferHelper::getHGlobal( ) const
+{
+    OSL_ASSERT( m_lpStream );
+
+    HGLOBAL hGlob = nullptr;
+
+    if ( m_lpStream )
+    {
+        HRESULT hr = GetHGlobalFromStream( m_lpStream, &hGlob );
+        if ( FAILED( hr ) )
+            hGlob = nullptr;
+    }
+
+    return hGlob;
+}
+
+// getIStream
+
+void CStgTransferHelper::getIStream( LPSTREAM* ppStream )
+{
+    OSL_ASSERT( ppStream );
+    *ppStream = m_lpStream;
+    if ( *ppStream )
+        static_cast< LPUNKNOWN >( *ppStream )->AddRef( );
+}
+
+// Init
+
+void CStgTransferHelper::init( SIZE_T newSize,
+                                        sal_uInt32 uiFlags,
+                                        bool bDelStgOnRelease )
+{
+    cleanup( );
+
+    m_bDelStgOnRelease      = bDelStgOnRelease;
+
+    HGLOBAL hGlob = GlobalAlloc( uiFlags, newSize );
+    if ( nullptr == hGlob )
+        throw CStgTransferException( STG_E_MEDIUMFULL );
+
+    HRESULT hr = CreateStreamOnHGlobal( hGlob, m_bDelStgOnRelease, &m_lpStream );
+    if ( FAILED( hr ) )
+    {
+        GlobalFree( hGlob );
+        m_lpStream = nullptr;
+        throw CStgTransferException( hr );
+    }
+
+#if OSL_DEBUG_LEVEL > 0
+    STATSTG statstg;
+    hr = m_lpStream->Stat( &statstg, STATFLAG_DEFAULT );
+    OSL_ASSERT( SUCCEEDED( hr ) );
+#endif
+}
+
+// Init
+
+void CStgTransferHelper::init( HGLOBAL hGlob,
+                                        bool bDelStgOnRelease )
+{
+    cleanup( );
+
+    m_bDelStgOnRelease      = bDelStgOnRelease;
+
+    HRESULT hr = CreateStreamOnHGlobal( hGlob, m_bDelStgOnRelease, &m_lpStream );
+    if ( FAILED( hr ) )
+        throw CStgTransferException( hr );
+}
+
+// free the global memory and invalidate the stream pointer
+
+void CStgTransferHelper::cleanup( )
+{
+    if ( m_lpStream && !m_bDelStgOnRelease )
+    {
+        HGLOBAL hGlob;
+        GetHGlobalFromStream( m_lpStream, &hGlob );
+        GlobalFree( hGlob );
+    }
+
+    if ( m_lpStream )
+    {
+        m_lpStream->Release( );
+        m_lpStream = nullptr;
+    }
+}
+
+// return the size of memory we point to
+
+sal_uInt32 CStgTransferHelper::memSize( CLIPFORMAT cf ) const
+{
+    DWORD dwSize = 0;
+
+    if ( nullptr != m_lpStream )
+    {
+        HGLOBAL hGlob;
+        GetHGlobalFromStream( m_lpStream, &hGlob );
+
+        if ( CF_TEXT == cf || RegisterClipboardFormatW( L"HTML Format" ) == cf )
+        {
+            char* pText = static_cast< char* >( GlobalLock( hGlob ) );
+            if ( pText )
+            {
+                dwSize = strlen(pText) + 1; // strlen + trailing '\0'
+                GlobalUnlock( hGlob );
+            }
+        }
+        else if ( CF_UNICODETEXT == cf )
+        {
+            sal_Unicode* pText = static_cast< sal_Unicode* >( GlobalLock( hGlob ) );
+            if ( pText )
+            {
+                dwSize = rtl_ustr_getLength( pText ) * sizeof( sal_Unicode );
+                GlobalUnlock( hGlob );
+            }
+        }
+        else
+            dwSize = GlobalSize( hGlob );
+    }
+
+    return dwSize;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DTransHelper.hxx b/dtrans/source/win32/dtobj/DTransHelper.hxx
new file mode 100644
index 000000000..d677184fb
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DTransHelper.hxx
@@ -0,0 +1,170 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DTRANSHELPER_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DTRANSHELPER_HXX
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <objidl.h>
+#include <WinClip.hxx>
+
+#define AUTO_INIT                 true
+
+// a helper class to manage a global memory area, the clients can write
+// into the global memory area and extract the handle to the global mem
+// note: not thread-safe
+
+class CStgTransferHelper
+{
+public:
+    // will be thrown in case of failures
+    class CStgTransferException
+    {
+    public:
+        HRESULT m_hr;
+        explicit CStgTransferException( HRESULT hr ) : m_hr( hr ) {};
+    };
+
+public:
+    CStgTransferHelper(
+        bool bAutoInit = false,
+        HGLOBAL  hGlob = nullptr,
+        bool bDelStgOnRelease = false );
+
+    ~CStgTransferHelper( );
+
+    void write( const void* lpData, ULONG cb, ULONG* cbWritten = nullptr );
+    void read( LPVOID pv, ULONG cb, ULONG* pcbRead = nullptr );
+
+    HGLOBAL getHGlobal( ) const;
+    void    getIStream( LPSTREAM* ppStream );
+
+    void init(
+        SIZE_T newSize,
+        sal_uInt32 uiFlags = GHND,
+        bool bDelStgOnRelease = false );
+
+    void init(
+        HGLOBAL hGlob,
+        bool bDelStgOnRelease = false );
+
+    // returns the size of the managed memory
+    sal_uInt32 memSize( CLIPFORMAT cf = CF_INVALID ) const;
+
+    // free the global memory and necessary
+    // release the internal stream pointer
+    void cleanup( );
+
+private:
+    LPSTREAM m_lpStream;
+    bool m_bDelStgOnRelease;
+
+private:
+    CStgTransferHelper( const CStgTransferHelper& );
+    CStgTransferHelper& operator=( const CStgTransferHelper& );
+};
+
+// something like an auto-pointer - allows access to the memory belonging
+// to a HGLOBAL and automatically unlocks a global memory at destruction
+// time
+
+class CRawHGlobalPtr
+{
+public:
+
+    // ctor
+
+    explicit CRawHGlobalPtr( HGLOBAL hGlob ) :
+        m_hGlob( hGlob ),
+        m_bIsLocked( false ),
+        m_pGlobMem( nullptr )
+    {
+    }
+
+    // ctor
+
+    explicit CRawHGlobalPtr( const CStgTransferHelper& theHGlobalHelper ) :
+        m_hGlob( theHGlobalHelper.getHGlobal( ) ),
+        m_bIsLocked( false ),
+        m_pGlobMem( nullptr )
+    {
+    }
+
+    // dtor
+
+    ~CRawHGlobalPtr( )
+    {
+        if ( m_bIsLocked )
+            GlobalUnlock( m_hGlob );
+    }
+
+    // lock the global memory (initializes a
+    // pointer to this memory)
+
+    BOOL Lock( )
+    {
+        if ( !m_bIsLocked && ( nullptr != m_hGlob ) )
+        {
+            m_pGlobMem = GlobalLock( m_hGlob );
+            m_bIsLocked = ( nullptr != m_pGlobMem );
+        }
+
+        return m_bIsLocked;
+    }
+
+    // unlock the global memory (invalidates the
+    // pointer to this memory)
+
+    BOOL Unlock( )
+    {
+        GlobalUnlock( m_hGlob );
+        m_bIsLocked = false;
+        m_pGlobMem = nullptr;
+
+        return ( NO_ERROR == GetLastError( ) );
+    }
+
+    // locks the global memory and returns a
+    // pointer to this memory
+
+    LPVOID GetMemPtr( )
+    {
+        Lock( );
+        return m_pGlobMem;
+    }
+
+    // size of mem we point to
+
+    int MemSize( ) const
+    {
+        return GlobalSize( m_hGlob );
+    }
+
+private:
+    HGLOBAL m_hGlob;
+    bool    m_bIsLocked;
+    LPVOID  m_pGlobMem;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DataFmtTransl.cxx b/dtrans/source/win32/dtobj/DataFmtTransl.cxx
new file mode 100644
index 000000000..b8513c6e7
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DataFmtTransl.cxx
@@ -0,0 +1,259 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include "DataFmtTransl.hxx"
+#include <rtl/string.hxx>
+#include <osl/diagnose.h>
+#include <rtl/tencinfo.h>
+#include "../misc/ImplHelper.hxx"
+#include <WinClip.hxx>
+#include "MimeAttrib.hxx"
+#include "DTransHelper.hxx"
+#include <rtl/string.h>
+#include <o3tl/char16_t2wchar_t.hxx>
+#include "Fetc.hxx"
+#include <com/sun/star/datatransfer/DataFormatTranslator.hpp>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <shlobj.h>
+
+using namespace std;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::datatransfer;
+using namespace com::sun::star::lang;
+
+const Type       CPPUTYPE_SALINT32   = cppu::UnoType<sal_Int32>::get();
+const Type       CPPUTYPE_SALINT8    = cppu::UnoType<sal_Int8>::get();
+const Type       CPPUTYPE_OUSTRING   = cppu::UnoType<OUString>::get();
+const Type       CPPUTYPE_SEQSALINT8 = cppu::UnoType<Sequence< sal_Int8>>::get();
+const sal_Int32  MAX_CLIPFORMAT_NAME = 256;
+
+const OUString TEXT_PLAIN_CHARSET   ("text/plain;charset=");
+const OUString HPNAME_OEM_ANSI_TEXT ("OEM/ANSI Text");
+
+const OUString HTML_FORMAT_NAME_WINDOWS ("HTML Format");
+const OUString HTML_FORMAT_NAME_SOFFICE ("HTML (HyperText Markup Language)");
+
+CDataFormatTranslator::CDataFormatTranslator( const Reference< XComponentContext >& rxContext )
+{
+    m_XDataFormatTranslator = DataFormatTranslator::create( rxContext );
+}
+
+CFormatEtc CDataFormatTranslator::getFormatEtcFromDataFlavor( const DataFlavor& aDataFlavor ) const
+{
+    sal_Int32 cf = CF_INVALID;
+
+    try
+    {
+        if( m_XDataFormatTranslator.is( ) )
+        {
+            Any aFormat = m_XDataFormatTranslator->getSystemDataTypeFromDataFlavor( aDataFlavor );
+
+            if ( aFormat.hasValue( ) )
+            {
+                if ( aFormat.getValueType( ) == CPPUTYPE_SALINT32 )
+                {
+                    aFormat >>= cf;
+                    OSL_ENSURE( CF_INVALID != cf, "Invalid Clipboard format delivered" );
+                }
+                else if ( aFormat.getValueType( ) == CPPUTYPE_OUSTRING )
+                {
+                    OUString aClipFmtName;
+                    aFormat >>= aClipFmtName;
+
+                    OSL_ASSERT( aClipFmtName.getLength( ) );
+                    cf = RegisterClipboardFormatW( o3tl::toW(aClipFmtName.getStr( )) );
+
+                    OSL_ENSURE( CF_INVALID != cf, "RegisterClipboardFormat failed" );
+                }
+                else
+                    OSL_FAIL( "Wrong Any-Type detected" );
+            }
+        }
+    }
+    catch( ... )
+    {
+        OSL_FAIL( "Unexpected error" );
+    }
+
+    return sal::static_int_cast<CFormatEtc>(getFormatEtcForClipformat( sal::static_int_cast<CLIPFORMAT>(cf) ));
+}
+
+DataFlavor CDataFormatTranslator::getDataFlavorFromFormatEtc( const FORMATETC& aFormatEtc, LCID lcid ) const
+{
+    DataFlavor aFlavor;
+
+    try
+    {
+        CLIPFORMAT aClipformat = aFormatEtc.cfFormat;
+
+        Any aAny;
+        aAny <<= static_cast< sal_Int32 >( aClipformat );
+
+        if ( isOemOrAnsiTextFormat( aClipformat ) )
+        {
+            aFlavor.MimeType             = TEXT_PLAIN_CHARSET;
+            aFlavor.MimeType            += getTextCharsetFromLCID( lcid, aClipformat );
+
+            aFlavor.HumanPresentableName = HPNAME_OEM_ANSI_TEXT;
+            aFlavor.DataType             = CPPUTYPE_SEQSALINT8;
+        }
+        else if ( CF_INVALID != aClipformat )
+        {
+            if ( m_XDataFormatTranslator.is( ) )
+            {
+                aFlavor = m_XDataFormatTranslator->getDataFlavorFromSystemDataType( aAny );
+
+                if ( !aFlavor.MimeType.getLength( ) )
+                {
+                    // lookup of DataFlavor from clipboard format id
+                    // failed, so we try to resolve via clipboard
+                    // format name
+                    OUString clipFormatName = getClipboardFormatName( aClipformat );
+
+                    // if we could not get a clipboard format name an
+                    // error must have occurred or it is a standard
+                    // clipboard format that we don't translate, e.g.
+                    // CF_BITMAP (the office only uses CF_DIB)
+                    if ( clipFormatName.getLength( ) )
+                    {
+                        aAny <<= clipFormatName;
+                        aFlavor = m_XDataFormatTranslator->getDataFlavorFromSystemDataType( aAny );
+                    }
+                }
+            }
+        }
+    }
+    catch( ... )
+    {
+        OSL_FAIL( "Unexpected error" );
+    }
+
+    return aFlavor;
+}
+
+CFormatEtc CDataFormatTranslator::getFormatEtcForClipformatName( const OUString& aClipFmtName )
+{
+    // check parameter
+    if ( !aClipFmtName.getLength( ) )
+        return CFormatEtc( CF_INVALID );
+
+    CLIPFORMAT cf = sal::static_int_cast<CLIPFORMAT>(RegisterClipboardFormatW( o3tl::toW(aClipFmtName.getStr( )) ));
+    return getFormatEtcForClipformat( cf );
+}
+
+OUString CDataFormatTranslator::getClipboardFormatName( CLIPFORMAT aClipformat )
+{
+    OSL_PRECOND( CF_INVALID != aClipformat, "Invalid clipboard format" );
+
+    sal_Unicode wBuff[ MAX_CLIPFORMAT_NAME + 1 ]; // Null terminator isn't counted, apparently.
+    sal_Int32   nLen = GetClipboardFormatNameW( aClipformat, o3tl::toW(wBuff), MAX_CLIPFORMAT_NAME );
+
+    return OUString( wBuff, nLen );
+}
+
+CFormatEtc CDataFormatTranslator::getFormatEtcForClipformat( CLIPFORMAT cf )
+{
+    CFormatEtc fetc( cf, TYMED_NULL, nullptr, DVASPECT_CONTENT );
+
+    switch( cf )
+    {
+    case CF_METAFILEPICT:
+        fetc.setTymed( TYMED_MFPICT );
+        break;
+
+    case CF_ENHMETAFILE:
+        fetc.setTymed( TYMED_ENHMF );
+        break;
+
+    default:
+        fetc.setTymed( TYMED_HGLOBAL /*| TYMED_ISTREAM*/ );
+    }
+
+    /*
+        hack: in order to paste urls copied by Internet Explorer
+        with "copy link" we set the lindex member to 0
+        but if we really want to support CFSTR_FILECONTENT and
+        the accompany format CFSTR_FILEDESCRIPTOR (FileGroupDescriptor)
+        the client of the clipboard service has to provide a id
+        of which FileContents it wants to paste
+        see MSDN: "Handling Shell Data Transfer Scenarios"
+    */
+    if ( cf == RegisterClipboardFormat( CFSTR_FILECONTENTS ) )
+         fetc.setLindex( 0 );
+
+    return fetc;
+}
+
+bool CDataFormatTranslator::isOemOrAnsiTextFormat( CLIPFORMAT cf )
+{
+    return ( (cf == CF_TEXT) || (cf == CF_OEMTEXT) );
+}
+
+bool CDataFormatTranslator::isUnicodeTextFormat( CLIPFORMAT cf )
+{
+    return ( cf == CF_UNICODETEXT );
+}
+
+bool CDataFormatTranslator::isTextFormat( CLIPFORMAT cf )
+{
+    return ( isOemOrAnsiTextFormat( cf ) || isUnicodeTextFormat( cf ) );
+}
+
+bool CDataFormatTranslator::isHTMLFormat( CLIPFORMAT cf )
+{
+    OUString clipFormatName = getClipboardFormatName( cf );
+    return ( clipFormatName == HTML_FORMAT_NAME_WINDOWS );
+}
+
+bool CDataFormatTranslator::isTextHtmlFormat( CLIPFORMAT cf )
+{
+    OUString clipFormatName = getClipboardFormatName( cf );
+    return clipFormatName.equalsIgnoreAsciiCase( HTML_FORMAT_NAME_SOFFICE );
+}
+
+OUString CDataFormatTranslator::getTextCharsetFromLCID( LCID lcid, CLIPFORMAT aClipformat )
+{
+    OSL_ASSERT( isOemOrAnsiTextFormat( aClipformat ) );
+
+    OUString charset;
+    if ( CF_TEXT == aClipformat )
+    {
+        charset = getMimeCharsetFromLocaleId(
+                    lcid,
+                    LOCALE_IDEFAULTANSICODEPAGE,
+                    PRE_WINDOWS_CODEPAGE );
+    }
+    else if ( CF_OEMTEXT == aClipformat )
+    {
+        charset = getMimeCharsetFromLocaleId(
+                    lcid,
+                    LOCALE_IDEFAULTCODEPAGE,
+                    PRE_OEM_CODEPAGE );
+    }
+    else // CF_UNICODE
+        OSL_ASSERT( false );
+
+    return charset;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DataFmtTransl.hxx b/dtrans/source/win32/dtobj/DataFmtTransl.hxx
new file mode 100644
index 000000000..3fad9bbdc
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DataFmtTransl.hxx
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DATAFMTTRANSL_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_DATAFMTTRANSL_HXX
+
+#include <com/sun/star/datatransfer/XDataFormatTranslator.hpp>
+#include <com/sun/star/datatransfer/XTransferable.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <sal/types.h>
+#include <rtl/ustring.hxx>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <objidl.h>
+
+// declaration
+
+class CFormatEtc;
+
+class CDataFormatTranslator
+{
+public:
+    explicit CDataFormatTranslator( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+
+    CFormatEtc getFormatEtcFromDataFlavor( const css::datatransfer::DataFlavor& aDataFlavor ) const;
+    css::datatransfer::DataFlavor getDataFlavorFromFormatEtc(
+        const FORMATETC& aFormatEtc, LCID lcid = GetThreadLocale( ) ) const;
+
+    static CFormatEtc getFormatEtcForClipformat( CLIPFORMAT cf );
+    static CFormatEtc getFormatEtcForClipformatName( const OUString& aClipFmtName );
+    static OUString getClipboardFormatName( CLIPFORMAT aClipformat );
+
+    static bool isHTMLFormat( CLIPFORMAT cf );
+    static bool isTextHtmlFormat( CLIPFORMAT cf );
+    static bool isOemOrAnsiTextFormat( CLIPFORMAT cf );
+    static bool isUnicodeTextFormat( CLIPFORMAT cf );
+    static bool isTextFormat( CLIPFORMAT cf );
+
+private:
+    static OUString getTextCharsetFromLCID( LCID lcid, CLIPFORMAT aClipformat );
+
+private:
+    css::uno::Reference< css::datatransfer::XDataFormatTranslator >   m_XDataFormatTranslator;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/DtObjFactory.cxx b/dtrans/source/win32/dtobj/DtObjFactory.cxx
new file mode 100644
index 000000000..29f630bf4
--- /dev/null
+++ b/dtrans/source/win32/dtobj/DtObjFactory.cxx
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include "../../inc/DtObjFactory.hxx"
+
+#include "XTDataObject.hxx"
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::datatransfer;
+using namespace com::sun::star::lang;
+
+IDataObjectPtr CDTransObjFactory::createDataObjFromTransferable(const Reference<XComponentContext>& rxContext,
+                                                                       const Reference< XTransferable >& refXTransferable)
+{
+    return (IDataObjectPtr(new CXTDataObject(rxContext, refXTransferable)));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/Fetc.cxx b/dtrans/source/win32/dtobj/Fetc.cxx
new file mode 100644
index 000000000..048b9228d
--- /dev/null
+++ b/dtrans/source/win32/dtobj/Fetc.cxx
@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <osl/diagnose.h>
+#include "Fetc.hxx"
+#include "../misc/ImplHelper.hxx"
+
+CFormatEtc::CFormatEtc(  )
+{
+    m_FormatEtc.cfFormat = 0;
+    m_FormatEtc.ptd      = nullptr;
+    m_FormatEtc.dwAspect = 0;
+    m_FormatEtc.lindex   = -1;
+    m_FormatEtc.tymed    = TYMED_NULL;
+}
+
+// transfer of ownership
+
+CFormatEtc::CFormatEtc( const FORMATETC& aFormatEtc )
+{
+    CopyFormatEtc( &m_FormatEtc, &const_cast< FORMATETC& >( aFormatEtc ) );
+}
+
+CFormatEtc::~CFormatEtc( )
+{
+    DeleteTargetDevice( m_FormatEtc.ptd );
+}
+
+CFormatEtc::CFormatEtc( CLIPFORMAT cf, DWORD tymed, DVTARGETDEVICE* ptd, DWORD dwAspect, LONG lindex )
+{
+    m_FormatEtc.cfFormat = cf;
+    m_FormatEtc.ptd      = CopyTargetDevice( ptd );
+    m_FormatEtc.dwAspect = dwAspect;
+    m_FormatEtc.lindex   = lindex;
+    m_FormatEtc.tymed    = tymed;
+}
+
+CFormatEtc::CFormatEtc( const CFormatEtc& theOther )
+{
+    m_FormatEtc.cfFormat = theOther.m_FormatEtc.cfFormat;
+    m_FormatEtc.ptd      = CopyTargetDevice( theOther.m_FormatEtc.ptd );
+    m_FormatEtc.dwAspect = theOther.m_FormatEtc.dwAspect;
+    m_FormatEtc.lindex   = theOther.m_FormatEtc.lindex;
+    m_FormatEtc.tymed    = theOther.m_FormatEtc.tymed;
+}
+
+CFormatEtc& CFormatEtc::operator=( const CFormatEtc& theOther )
+{
+    if ( this != &theOther )
+    {
+        DeleteTargetDevice( m_FormatEtc.ptd );
+
+        m_FormatEtc.cfFormat = theOther.m_FormatEtc.cfFormat;
+        m_FormatEtc.ptd      = CopyTargetDevice( theOther.m_FormatEtc.ptd );
+        m_FormatEtc.dwAspect = theOther.m_FormatEtc.dwAspect;
+        m_FormatEtc.lindex   = theOther.m_FormatEtc.lindex;
+        m_FormatEtc.tymed    = theOther.m_FormatEtc.tymed;
+    }
+
+    return *this;
+}
+
+CFormatEtc::operator FORMATETC*( )
+{
+    return &m_FormatEtc;
+}
+
+CFormatEtc::operator FORMATETC( )
+{
+    return m_FormatEtc;
+}
+
+void CFormatEtc::getFORMATETC( LPFORMATETC lpFormatEtc )
+{
+    OSL_ASSERT( lpFormatEtc );
+    OSL_ASSERT( !IsBadWritePtr( lpFormatEtc, sizeof( FORMATETC ) ) );
+
+    CopyFormatEtc( lpFormatEtc, &m_FormatEtc );
+}
+
+CLIPFORMAT CFormatEtc::getClipformat( ) const
+{
+    return m_FormatEtc.cfFormat;
+}
+
+DWORD CFormatEtc::getTymed( ) const
+{
+    return m_FormatEtc.tymed;
+}
+
+void CFormatEtc::getTargetDevice( DVTARGETDEVICE** lpDvTargetDevice ) const
+{
+    OSL_ASSERT( lpDvTargetDevice );
+    OSL_ASSERT( !IsBadWritePtr( lpDvTargetDevice, sizeof( DVTARGETDEVICE ) ) );
+
+    *lpDvTargetDevice = nullptr;
+
+    if ( m_FormatEtc.ptd )
+        *lpDvTargetDevice = CopyTargetDevice( m_FormatEtc.ptd );
+}
+
+DWORD CFormatEtc::getDvAspect( ) const
+{
+    return m_FormatEtc.dwAspect;
+}
+
+LONG CFormatEtc::getLindex( ) const
+{
+    return m_FormatEtc.lindex;
+}
+
+void CFormatEtc::setClipformat( CLIPFORMAT cf )
+{
+    m_FormatEtc.cfFormat = cf;
+}
+
+void CFormatEtc::setTymed( DWORD tymed )
+{
+    m_FormatEtc.tymed = tymed;
+}
+
+// transfer of ownership!
+
+void CFormatEtc::setTargetDevice( DVTARGETDEVICE* ptd )
+{
+    DeleteTargetDevice( m_FormatEtc.ptd );
+    m_FormatEtc.ptd = ptd;
+}
+
+void CFormatEtc::setDvAspect( DWORD dwAspect )
+{
+    m_FormatEtc.dwAspect = dwAspect;
+}
+
+void CFormatEtc::setLindex( LONG lindex )
+{
+    m_FormatEtc.lindex = lindex;
+}
+
+bool operator==( const CFormatEtc& lhs, const CFormatEtc& rhs )
+{
+    return CompareFormatEtc( &lhs.m_FormatEtc, &rhs.m_FormatEtc );
+}
+
+bool operator!=( const CFormatEtc& lhs, const CFormatEtc& rhs )
+{
+    return !( lhs == rhs );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/Fetc.hxx b/dtrans/source/win32/dtobj/Fetc.hxx
new file mode 100644
index 000000000..5ec3e4b94
--- /dev/null
+++ b/dtrans/source/win32/dtobj/Fetc.hxx
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FETC_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FETC_HXX
+
+#include <sal/types.h>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <objidl.h>
+
+/**********************************************************************
+ stl container elements must fulfill the following requirements:
+ 1. they need a copy ctor and assignment operator(?)
+ 2. they must be comparable
+ because the FORMATETC structure has a pointer to a TARGETDEVICE
+ structure we need a simple wrapper class to fulfill these needs
+***********************************************************************/
+
+class CFormatEtc
+{
+public:
+    CFormatEtc( );
+    explicit CFormatEtc( const FORMATETC& aFormatEtc );
+    CFormatEtc( CLIPFORMAT cf, DWORD tymed = TYMED_HGLOBAL, DVTARGETDEVICE* ptd = nullptr, DWORD dwAspect = DVASPECT_CONTENT, LONG lindex = -1 );
+    CFormatEtc( const CFormatEtc& theOther );
+
+    ~CFormatEtc( );
+
+    CFormatEtc& operator=( const CFormatEtc& theOther );
+    operator FORMATETC*( );
+    operator FORMATETC( );
+
+    void getFORMATETC( LPFORMATETC lpFormatEtc );
+
+    CLIPFORMAT getClipformat( ) const;
+    DWORD      getTymed( ) const;
+    void       getTargetDevice( DVTARGETDEVICE** ptd ) const;
+    DWORD      getDvAspect( ) const;
+    LONG       getLindex( ) const;
+
+    void setClipformat( CLIPFORMAT cf );
+    void setTymed( DWORD tymed );
+    void setTargetDevice( DVTARGETDEVICE* ptd );
+    void setDvAspect( DWORD dwAspect );
+    void setLindex( LONG lindex );
+
+private:
+    FORMATETC m_FormatEtc;
+
+    friend bool operator==( const CFormatEtc& lhs, const CFormatEtc& rhs );
+    friend bool operator!=( const CFormatEtc& lhs, const CFormatEtc& rhs );
+};
+
+bool operator==( const CFormatEtc& lhs, const CFormatEtc& rhs );
+bool operator!=( const CFormatEtc& lhs, const CFormatEtc& rhs );
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/FetcList.cxx b/dtrans/source/win32/dtobj/FetcList.cxx
new file mode 100644
index 000000000..0a262b067
--- /dev/null
+++ b/dtrans/source/win32/dtobj/FetcList.cxx
@@ -0,0 +1,344 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <osl/diagnose.h>
+#include "FetcList.hxx"
+#include "Fetc.hxx"
+#include <com/sun/star/container/NoSuchElementException.hpp>
+#include <com/sun/star/datatransfer/MimeContentTypeFactory.hpp>
+#include <com/sun/star/datatransfer/XMimeContentType.hpp>
+
+#include "DataFmtTransl.hxx"
+#include "../misc/ImplHelper.hxx"
+#include <WinClip.hxx>
+
+#include <algorithm>
+
+#include "MimeAttrib.hxx"
+
+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 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( fetc );
+}
+
+void 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 CFormatEtcContainer::removeAllFormatEtc( )
+{
+    m_FormatMap.clear( );
+}
+
+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( ) );
+}
+
+bool CFormatEtcContainer::hasElements( ) const
+{
+    return !m_FormatMap.empty();
+}
+
+void CFormatEtcContainer::beginEnumFormatEtc( )
+{
+    m_EnumIterator = m_FormatMap.begin( );
+}
+
+sal_uInt32 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;
+}
+
+bool 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< XComponentContext >& rxContext,
+                                    const CDataFormatTranslator& aDataFormatTranslator ) :
+    m_DataFormatTranslator( aDataFormatTranslator ),
+    m_bHasSynthesizedLocale( false ),
+    m_xContext( rxContext )
+{
+}
+
+// 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 CFormatRegistrar::RegisterFormats(
+    const Reference< XTransferable >& aXTransferable, CFormatEtcContainer& aFormatEtcContainer )
+{
+    Sequence< DataFlavor > aFlavorList = aXTransferable->getTransferDataFlavors( );
+    sal_Int32  nFlavors                = aFlavorList.getLength( );
+    bool   bUnicodeRegistered      = 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 ( CDataFormatTranslator::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 ( CDataFormatTranslator::isUnicodeTextFormat( fetc.getClipformat() ) )
+                {
+                    aFormatEtcContainer.addFormatEtc( fetc ); // add CF_UNICODE
+                    aFormatEtcContainer.addFormatEtc(
+                        CDataFormatTranslator::getFormatEtcForClipformat( CF_TEXT ) ); // add CF_TEXT
+                    bUnicodeRegistered = 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(
+                            CDataFormatTranslator::getFormatEtcForClipformat( CF_UNICODETEXT ) );
+
+                        if ( !IsOEMCP( m_TxtCodePage ) )
+                            aFormatEtcContainer.addFormatEtc(
+                                CDataFormatTranslator::getFormatEtcForClipformat( CF_TEXT ) );
+                        else
+                            aFormatEtcContainer.addFormatEtc(
+                                CDataFormatTranslator::getFormatEtcForClipformat( CF_OEMTEXT ) );
+
+                        aFormatEtcContainer.addFormatEtc(
+                            CDataFormatTranslator::getFormatEtcForClipformat( CF_LOCALE ) );
+
+                        // we save the flavor so it's easier when
+                        // queried for it in XTDataObject::GetData(...)
+                        m_RegisteredTextFlavor  = aFlavor;
+                        m_bHasSynthesizedLocale = true;
+                    }
+                }
+            }
+            else if ( CDataFormatTranslator::isTextHtmlFormat( fetc.getClipformat( ) ) ) // Html (Hyper Text...)
+            {
+                // we add text/html ( HTML (HyperText Markup Language) )
+                aFormatEtcContainer.addFormatEtc( fetc );
+
+                // and HTML Format
+                aFormatEtcContainer.addFormatEtc(
+                    CDataFormatTranslator::getFormatEtcForClipformatName( "HTML Format" ) );
+            }
+        }
+    }
+}
+
+bool CFormatRegistrar::hasSynthesizedLocale( ) const
+{
+    return m_bHasSynthesizedLocale;
+}
+
+LCID CFormatRegistrar::getSynthesizedLocale( )
+{
+    return m_TxtLocale;
+}
+
+sal_uInt32 CFormatRegistrar::getRegisteredTextCodePage( )
+{
+    return m_TxtCodePage;
+}
+
+DataFlavor CFormatRegistrar::getRegisteredTextFlavor( ) const
+{
+    return m_RegisteredTextFlavor;
+}
+
+bool CFormatRegistrar::isSynthesizeableFormat( const CFormatEtc& aFormatEtc )
+{
+    return ( CDataFormatTranslator::isOemOrAnsiTextFormat( aFormatEtc.getClipformat() ) ||
+             CDataFormatTranslator::isUnicodeTextFormat( aFormatEtc.getClipformat() ) ||
+             CDataFormatTranslator::isHTMLFormat( aFormatEtc.getClipformat() ) );
+}
+
+inline
+bool CFormatRegistrar::needsToSynthesizeAccompanyFormats( const CFormatEtc& aFormatEtc )
+{
+    return ( CDataFormatTranslator::isOemOrAnsiTextFormat( aFormatEtc.getClipformat() ) ||
+             CDataFormatTranslator::isUnicodeTextFormat( aFormatEtc.getClipformat() ) ||
+             CDataFormatTranslator::isTextHtmlFormat( aFormatEtc.getClipformat( ) ) );
+}
+
+OUString CFormatRegistrar::getCharsetFromDataFlavor( const DataFlavor& aFlavor )
+{
+    OUString charset;
+
+    try
+    {
+        Reference< XMimeContentTypeFactory > xMimeFac =
+            MimeContentTypeFactory::create(m_xContext);
+
+        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_FAIL( "Unexpected" );
+    }
+    catch(...)
+    {
+        OSL_FAIL( "Invalid data flavor" );
+    }
+
+    return charset;
+}
+
+bool CFormatRegistrar::hasUnicodeFlavor( const Reference< XTransferable >& aXTransferable ) const
+{
+    CFormatEtc fetc( CF_UNICODETEXT );
+
+    DataFlavor aFlavor =
+        m_DataFormatTranslator.getDataFlavorFromFormatEtc( fetc );
+
+    return aXTransferable->isDataFlavorSupported( aFlavor );
+}
+
+bool CFormatRegistrar::findLocaleForTextCodePage( )
+{
+    m_TxtLocale = 0;
+    EnumSystemLocalesA( CFormatRegistrar::EnumLocalesProc, LCID_INSTALLED );
+    return IsValidLocale( m_TxtLocale, LCID_INSTALLED );
+}
+
+bool 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
+bool CFormatRegistrar::isLocaleOemCodePage( LCID lcid, sal_uInt32 codepage )
+{
+    return isLocaleCodePage( lcid, LOCALE_IDEFAULTCODEPAGE, codepage );
+}
+
+inline
+bool CFormatRegistrar::isLocaleAnsiCodePage( LCID lcid, sal_uInt32 codepage )
+{
+    return isLocaleCodePage( lcid, LOCALE_IDEFAULTANSICODEPAGE, codepage );
+}
+
+BOOL CALLBACK CFormatRegistrar::EnumLocalesProc( LPSTR lpLocaleStr )
+{
+    // the lpLocaleStr parameter is hexadecimal
+    LCID lcid = strtol( lpLocaleStr, nullptr, 16 );
+
+    if ( isLocaleAnsiCodePage( lcid, CFormatRegistrar::m_TxtCodePage ) ||
+         isLocaleOemCodePage( lcid, CFormatRegistrar::m_TxtCodePage ) )
+    {
+        CFormatRegistrar::m_TxtLocale = lcid;
+        return false; // stop enumerating
+    }
+
+    return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/FetcList.hxx b/dtrans/source/win32/dtobj/FetcList.hxx
new file mode 100644
index 000000000..cf7697e1b
--- /dev/null
+++ b/dtrans/source/win32/dtobj/FetcList.hxx
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FETCLIST_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FETCLIST_HXX
+
+#include <sal/types.h>
+#include <com/sun/star/datatransfer/XTransferable.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include "Fetc.hxx"
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+#include <vector>
+
+/*****************************************************************
+    a simple container for FORMATECT structures
+    instances of this class are not thread-safe
+*****************************************************************/
+
+class CFormatEtcContainer
+{
+public:
+    CFormatEtcContainer( );
+
+    // duplicates not allowed
+    void addFormatEtc( const CFormatEtc& fetc );
+
+    // removes the specified formatetc
+    void removeFormatEtc( const CFormatEtc& fetc );
+
+    // removes the formatetc at pos
+    void removeAllFormatEtc( );
+
+    bool hasFormatEtc( const CFormatEtc& fetc ) const;
+
+    bool hasElements( ) const;
+
+    // begin enumeration
+    void beginEnumFormatEtc( );
+
+    // copies the specified number of formatetc structures starting
+    // at the current enum position
+    // the return value is the number of copied elements; if the
+    // current enum position is at the end the return value is 0
+    sal_uInt32 nextFormatEtc( LPFORMATETC lpFetc, sal_uInt32 aNum = 1 );
+
+    // skips the specified number of elements in the container
+    bool skipFormatEtc( sal_uInt32 aNum );
+
+protected:
+    typedef std::vector< CFormatEtc > FormatEtcMap_t;
+
+private:
+    FormatEtcMap_t           m_FormatMap;
+    FormatEtcMap_t::iterator m_EnumIterator;
+};
+
+/*****************************************************************
+    a helper class which converts data flavors to clipformats,
+    creates an appropriate formatetc structures and if possible
+    synthesizes clipboard formats if necessary, e.g. if text
+    is provided a locale will also be provided;
+    the class registers the formatetc within a CFormatEtcContainer
+
+    instances of this class are not thread-safe and multiple
+    instances of this class would use the same static variables
+    that's why this class should not be used by multiple threads,
+    only one thread of a process should use it
+*****************************************************************/
+
+// forward
+class CDataFormatTranslator;
+
+class CFormatRegistrar
+{
+public:
+    CFormatRegistrar( const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+                      const CDataFormatTranslator& aDataFormatTranslator );
+
+    void RegisterFormats( const css::uno::Reference< css::datatransfer::XTransferable >& aXTransferable,
+                                   CFormatEtcContainer& aFormatEtcContainer );
+
+    bool hasSynthesizedLocale( ) const;
+    static LCID getSynthesizedLocale( );
+    static sal_uInt32 getRegisteredTextCodePage( );
+    css::datatransfer::DataFlavor getRegisteredTextFlavor( ) const;
+
+    static bool isSynthesizeableFormat( const CFormatEtc& aFormatEtc );
+    static bool needsToSynthesizeAccompanyFormats( const CFormatEtc& aFormatEtc );
+
+private:
+    OUString getCharsetFromDataFlavor( const css::datatransfer::DataFlavor& aFlavor );
+
+    bool hasUnicodeFlavor(
+        const css::uno::Reference< css::datatransfer::XTransferable >& aXTransferable ) const;
+
+    static bool findLocaleForTextCodePage( );
+
+    static bool isLocaleOemCodePage( LCID lcid, sal_uInt32 codepage );
+    static bool isLocaleAnsiCodePage( LCID lcid, sal_uInt32 codepage );
+    static bool isLocaleCodePage( LCID lcid, LCTYPE lctype, sal_uInt32 codepage );
+
+    static BOOL CALLBACK EnumLocalesProc( LPSTR lpLocaleStr );
+
+private:
+    const CDataFormatTranslator&             m_DataFormatTranslator;
+    bool                                     m_bHasSynthesizedLocale;
+    css::datatransfer::DataFlavor            m_RegisteredTextFlavor;
+
+    const css::uno::Reference< css::uno::XComponentContext >  m_xContext;
+
+    static LCID       m_TxtLocale;
+    static sal_uInt32 m_TxtCodePage;
+
+private:
+    CFormatRegistrar( const CFormatRegistrar& );
+    CFormatRegistrar& operator=( const CFormatRegistrar& );
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/FmtFilter.cxx b/dtrans/source/win32/dtobj/FmtFilter.cxx
new file mode 100644
index 000000000..e9c4b42f8
--- /dev/null
+++ b/dtrans/source/win32/dtobj/FmtFilter.cxx
@@ -0,0 +1,437 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <string.h>
+
+#include "FmtFilter.hxx"
+
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+
+#include <shobjidl.h>
+#include <shlguid.h>
+#include <objidl.h>
+#include <shellapi.h>
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <iomanip>
+
+#include <systools/win32/comtools.hxx>
+
+using namespace com::sun::star::uno;
+
+namespace {
+
+#pragma pack(2)
+struct METAFILEHEADER
+{
+    DWORD       key;
+    short       hmf;
+    SMALL_RECT  bbox;
+    WORD        inch;
+    DWORD       reserved;
+    WORD        checksum;
+};
+#pragma pack()
+
+}
+
+// convert a windows metafile picture to a LibreOffice metafile picture
+
+Sequence< sal_Int8 > WinMFPictToOOMFPict( Sequence< sal_Int8 >& aMetaFilePict )
+{
+    OSL_ASSERT( aMetaFilePict.getLength( ) == sizeof( METAFILEPICT ) );
+
+    Sequence< sal_Int8 > mfpictStream;
+    METAFILEPICT* pMFPict = reinterpret_cast< METAFILEPICT* >( aMetaFilePict.getArray( ) );
+    HMETAFILE hMf = pMFPict->hMF;
+    sal_uInt32 nCount = GetMetaFileBitsEx( hMf, 0, nullptr );
+
+    if ( nCount > 0 )
+    {
+        mfpictStream.realloc( nCount + sizeof( METAFILEHEADER ) );
+
+        METAFILEHEADER* pMFHeader = reinterpret_cast< METAFILEHEADER* >( mfpictStream.getArray( ) );
+        SMALL_RECT aRect = { 0,
+                             0,
+                             static_cast< short >( pMFPict->xExt ),
+                             static_cast< short >( pMFPict->yExt ) };
+        USHORT nInch;
+
+        switch( pMFPict->mm )
+        {
+        case MM_TEXT:
+            nInch = 72;
+            break;
+
+        case MM_LOMETRIC:
+            nInch = 100;
+            break;
+
+        case MM_HIMETRIC:
+            nInch = 1000;
+            break;
+
+        case MM_LOENGLISH:
+            nInch = 254;
+            break;
+
+        case MM_HIENGLISH:
+        case MM_ISOTROPIC:
+        case MM_ANISOTROPIC:
+            nInch = 2540;
+            break;
+
+        case MM_TWIPS:
+            nInch = 1440;
+            break;
+
+        default:
+            nInch = 576;
+        }
+
+        pMFHeader->key      = 0x9AC6CDD7L;
+        pMFHeader->hmf      = 0;
+        pMFHeader->bbox     = aRect;
+        pMFHeader->inch     = nInch;
+        pMFHeader->reserved = 0;
+        pMFHeader->checksum = 0;
+
+        char* pMFBuff = reinterpret_cast< char* >( mfpictStream.getArray( ) );
+
+        nCount = GetMetaFileBitsEx( pMFPict->hMF, nCount, pMFBuff + sizeof( METAFILEHEADER ) );
+        OSL_ASSERT( nCount > 0 );
+    }
+
+    return mfpictStream;
+}
+
+// convert a windows enhanced metafile to a LibreOffice metafile
+
+Sequence< sal_Int8 > WinENHMFPictToOOMFPict( HENHMETAFILE hEnhMetaFile )
+{
+    Sequence< sal_Int8 >    aRet;
+    UINT                    nSize = 0;
+
+    if( hEnhMetaFile &&
+        ( ( nSize = GetEnhMetaFileBits( hEnhMetaFile, 0, nullptr ) ) != 0 ) )
+    {
+        aRet.realloc( nSize );
+
+        if( GetEnhMetaFileBits( hEnhMetaFile, nSize, reinterpret_cast<unsigned char*>(aRet.getArray()) ) != nSize )
+            aRet.realloc( 0 );
+    }
+
+    return aRet;
+}
+
+// convert a LibreOffice metafile picture to a windows metafile picture
+
+HMETAFILEPICT OOMFPictToWinMFPict( Sequence< sal_Int8 > const & aOOMetaFilePict )
+{
+    HMETAFILEPICT   hPict = nullptr;
+    HMETAFILE       hMtf = SetMetaFileBitsEx( aOOMetaFilePict.getLength(), reinterpret_cast<unsigned char const *>(aOOMetaFilePict.getConstArray()) );
+
+    if( hMtf )
+    {
+        METAFILEPICT* pPict = static_cast<METAFILEPICT*>(GlobalLock( hPict = GlobalAlloc( GHND, sizeof( METAFILEPICT ) ) ));
+
+        pPict->mm = 8;
+        pPict->xExt = 0;
+        pPict->yExt = 0;
+        pPict->hMF = hMtf;
+
+        GlobalUnlock( hPict );
+    }
+
+    return hPict;
+}
+
+// convert a LibreOffice metafile picture to a windows enhanced metafile picture
+
+HENHMETAFILE OOMFPictToWinENHMFPict( Sequence< sal_Int8 > const & aOOMetaFilePict )
+{
+    HENHMETAFILE hEnhMtf = SetEnhMetaFileBits( aOOMetaFilePict.getLength(), reinterpret_cast<unsigned char const *>(aOOMetaFilePict.getConstArray()) );
+
+    return hEnhMtf;
+}
+
+// convert a windows device independent bitmap into a LibreOffice bitmap
+
+Sequence< sal_Int8 > WinDIBToOOBMP( const Sequence< sal_Int8 >& aWinDIB )
+{
+    OSL_ENSURE(o3tl::make_unsigned(aWinDIB.getLength()) > sizeof(BITMAPINFOHEADER), "CF_DIBV5/CF_DIB too small (!)");
+    Sequence< sal_Int8 > ooBmpStream;
+
+    ooBmpStream.realloc(aWinDIB.getLength( ) + sizeof(BITMAPFILEHEADER));
+    const BITMAPINFOHEADER* pBmpInfoHdr = reinterpret_cast< const BITMAPINFOHEADER* >(aWinDIB.getConstArray());
+    BITMAPFILEHEADER* pBmpFileHdr = reinterpret_cast< BITMAPFILEHEADER* >(ooBmpStream.getArray());
+    const DWORD nSizeInfoOrV5(pBmpInfoHdr->biSize > sizeof(BITMAPINFOHEADER) ? sizeof(BITMAPV5HEADER) : sizeof(BITMAPINFOHEADER));
+    DWORD nOffset(sizeof(BITMAPFILEHEADER) + nSizeInfoOrV5);
+
+    memcpy(pBmpFileHdr + 1, pBmpInfoHdr, aWinDIB.getLength());
+
+    if(pBmpInfoHdr->biBitCount <= 8)
+    {
+        nOffset += (pBmpInfoHdr->biClrUsed ? pBmpInfoHdr->biClrUsed : (1 << pBmpInfoHdr->biBitCount)) << 2;
+    }
+    else if((BI_BITFIELDS == pBmpInfoHdr->biCompression ) && ((16 == pBmpInfoHdr->biBitCount ) || (32 == pBmpInfoHdr->biBitCount )))
+    {
+        nOffset += 12;
+    }
+
+    pBmpFileHdr->bfType = ('M' << 8) | 'B';
+    pBmpFileHdr->bfSize = 0; // maybe: nMemSize + sizeof(BITMAPFILEHEADER)
+    pBmpFileHdr->bfReserved1 = 0;
+    pBmpFileHdr->bfReserved2 = 0;
+    pBmpFileHdr->bfOffBits = nOffset;
+
+    return ooBmpStream;
+}
+
+// convert a LibreOffice bitmap into a windows device independent bitmap
+
+Sequence< sal_Int8 > OOBmpToWinDIB( Sequence< sal_Int8 >& aOOBmp )
+{
+    Sequence< sal_Int8 > winDIBStream( aOOBmp.getLength( ) - sizeof( BITMAPFILEHEADER ) );
+
+    memcpy( winDIBStream.getArray( ),
+                    aOOBmp.getArray( )  + sizeof( BITMAPFILEHEADER ),
+                    aOOBmp.getLength( ) - sizeof( BITMAPFILEHEADER ) );
+
+    return winDIBStream;
+}
+
+static std::string GetHtmlFormatHeader(size_t startHtml, size_t endHtml, size_t startFragment, size_t endFragment)
+{
+    std::ostringstream htmlHeader;
+    htmlHeader << "Version:1.0" << '\r' << '\n';
+    htmlHeader << "StartHTML:" << std::setw(10) << std::setfill('0') << std::dec << startHtml << '\r' << '\n';
+    htmlHeader << "EndHTML:" << std::setw(10) << std::setfill('0') << std::dec << endHtml << '\r' << '\n';
+    htmlHeader << "StartFragment:" << std::setw(10) << std::setfill('0') << std::dec << startFragment << '\r' << '\n';
+    htmlHeader << "EndFragment:" << std::setw(10) << std::setfill('0') << std::dec << endFragment << '\r' << '\n';
+    return htmlHeader.str();
+}
+
+// the case of these tags has to match what we output in our filters
+// both tags don't allow parameters
+const std::string TAG_HTML("<html>");
+const std::string TAG_END_HTML("</html>");
+
+// The body tag may have parameters so we need to search for the
+// closing '>' manually e.g. <body param> #92840#
+const std::string TAG_BODY("<body");
+const std::string TAG_END_BODY("</body");
+
+Sequence<sal_Int8> TextHtmlToHTMLFormat(Sequence<sal_Int8> const & aTextHtml)
+{
+    OSL_ASSERT(aTextHtml.getLength() > 0);
+
+    if (aTextHtml.getLength() <= 0)
+        return Sequence<sal_Int8>();
+
+    // fill the buffer with dummy values to calc the exact length
+    std::string dummyHtmlHeader = GetHtmlFormatHeader(0, 0, 0, 0);
+    size_t lHtmlFormatHeader = dummyHtmlHeader.length();
+
+    std::string textHtml(
+        reinterpret_cast<const char*>(aTextHtml.getConstArray()),
+        reinterpret_cast<const char*>(aTextHtml.getConstArray()) + aTextHtml.getLength());
+
+    std::string::size_type nStartHtml = textHtml.find(TAG_HTML) + lHtmlFormatHeader - 1; // we start one before '<HTML>' Word 2000 does also so
+    std::string::size_type nEndHtml = textHtml.find(TAG_END_HTML) + lHtmlFormatHeader + TAG_END_HTML.length() + 1; // our SOffice 5.2 wants 2 behind </HTML>?
+
+    // The body tag may have parameters so we need to search for the
+    // closing '>' manually e.g. <BODY param> #92840#
+    std::string::size_type nStartFragment = textHtml.find(">", textHtml.find(TAG_BODY)) + lHtmlFormatHeader + 1;
+    std::string::size_type nEndFragment = textHtml.find(TAG_END_BODY) + lHtmlFormatHeader;
+
+    std::string htmlFormat = GetHtmlFormatHeader(nStartHtml, nEndHtml, nStartFragment, nEndFragment);
+    htmlFormat += textHtml;
+
+    Sequence<sal_Int8> byteSequence(htmlFormat.length() + 1); // space the trailing '\0'
+    memset(byteSequence.getArray(), 0, byteSequence.getLength());
+
+    memcpy(
+        static_cast<void*>(byteSequence.getArray()),
+        static_cast<const void*>(htmlFormat.c_str()),
+        htmlFormat.length());
+
+    return byteSequence;
+}
+
+static std::wstring getFileExtension(const std::wstring& aFilename)
+{
+    std::wstring::size_type idx = aFilename.rfind(L".");
+    if (idx != std::wstring::npos)
+    {
+        return std::wstring(aFilename, idx);
+    }
+    return std::wstring();
+}
+
+const std::wstring SHELL_LINK_FILE_EXTENSION = L".lnk";
+
+static bool isShellLink(const std::wstring& aFilename)
+{
+    std::wstring ext = getFileExtension(aFilename);
+    return (_wcsicmp(ext.c_str(), SHELL_LINK_FILE_EXTENSION.c_str()) == 0);
+}
+
+/** Resolve a Windows Shell Link (lnk) file. If a resolution
+    is not possible simply return the provided name of the
+    lnk file. */
+static std::wstring getShellLinkTarget(const std::wstring& aLnkFile)
+{
+    OSL_ASSERT(isShellLink(aLnkFile));
+
+    std::wstring target = aLnkFile;
+
+    try
+    {
+        sal::systools::COMReference<IShellLinkW> pIShellLink;
+        HRESULT hr = CoCreateInstance(
+            CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER, IID_IShellLinkW, reinterpret_cast<LPVOID*>(&pIShellLink));
+        if (FAILED(hr))
+            return target;
+
+        sal::systools::COMReference<IPersistFile> pIPersistFile =
+            pIShellLink.QueryInterface<IPersistFile>(IID_IPersistFile);
+
+        hr = pIPersistFile->Load(aLnkFile.c_str(), STGM_READ);
+        if (FAILED(hr))
+            return target;
+
+        hr = pIShellLink->Resolve(nullptr, SLR_UPDATE | SLR_NO_UI);
+        if (FAILED(hr))
+            return target;
+
+        wchar_t pathW[MAX_PATH];
+        WIN32_FIND_DATAW wfd;
+        hr = pIShellLink->GetPath(pathW, MAX_PATH, &wfd, SLGP_RAWPATH);
+        if (FAILED(hr))
+            return target;
+
+        target = pathW;
+    }
+    catch(sal::systools::ComError& ex)
+    {
+        OSL_FAIL(ex.what());
+    }
+    return target;
+}
+
+typedef Sequence<sal_Int8> ByteSequence_t;
+
+/* Calculate the size required for turning a string list into
+   a double '\0' terminated string buffer */
+static size_t CalcSizeForStringListBuffer(const std::vector<std::wstring>& fileList)
+{
+    if ( fileList.empty() )
+        return 0;
+
+    size_t size = 1; // one for the very final '\0'
+    for (auto const& elem : fileList)
+    {
+        size += elem.length() + 1; // length including terminating '\0'
+    }
+    return (size * sizeof(std::vector<std::wstring>::value_type::value_type));
+}
+
+static ByteSequence_t FileListToByteSequence(const std::vector<std::wstring>& fileList)
+{
+    ByteSequence_t bseq;
+    size_t size = CalcSizeForStringListBuffer(fileList);
+
+    if (size > 0)
+    {
+        bseq.realloc(size);
+        wchar_t* p = reinterpret_cast<wchar_t*>(bseq.getArray());
+        ZeroMemory(p, size);
+
+        for (auto const& elem : fileList)
+        {
+            wcsncpy(p, elem.c_str(), elem.length());
+            p += (elem.length() + 1);
+        }
+    }
+    return bseq;
+}
+
+css::uno::Sequence<sal_Int8> CF_HDROPToFileList(HGLOBAL hGlobal)
+{
+    UINT nFiles = DragQueryFileW(static_cast<HDROP>(hGlobal), 0xFFFFFFFF, nullptr, 0);
+    std::vector<std::wstring> files;
+
+    for (UINT i = 0; i < nFiles; i++)
+    {
+        wchar_t buff[MAX_PATH];
+        /*UINT size =*/ DragQueryFileW(static_cast<HDROP>(hGlobal), i, buff, MAX_PATH);
+        std::wstring filename = buff;
+        if (isShellLink(filename))
+            filename = getShellLinkTarget(filename);
+        files.push_back(filename);
+    }
+    return FileListToByteSequence(files);
+}
+
+// convert a windows bitmap handle into a LibreOffice bitmap
+
+Sequence< sal_Int8 > WinBITMAPToOOBMP( HBITMAP aHBMP )
+{
+    Sequence< sal_Int8 > ooBmpStream;
+
+    SIZE aBmpSize;
+    if( GetBitmapDimensionEx( aHBMP, &aBmpSize ) )
+    {
+        // fill bitmap info header
+        size_t nDataBytes = 4 * aBmpSize.cy * aBmpSize.cy;
+        Sequence< sal_Int8 > aBitmapStream(
+            sizeof(BITMAPINFO) +
+            nDataBytes
+            );
+        PBITMAPINFOHEADER pBmp = reinterpret_cast<PBITMAPINFOHEADER>(aBitmapStream.getArray());
+        pBmp->biSize = sizeof( BITMAPINFOHEADER );
+        pBmp->biWidth  = aBmpSize.cx;
+        pBmp->biHeight = aBmpSize.cy;
+        pBmp->biPlanes = 1;
+        pBmp->biBitCount = 32;
+        pBmp->biCompression = BI_RGB;
+        pBmp->biSizeImage = static_cast<DWORD>(nDataBytes);
+        pBmp->biXPelsPerMeter = 1000;
+        pBmp->biYPelsPerMeter = 1000;
+        pBmp->biClrUsed = 0;
+        pBmp->biClrImportant = 0;
+        if( GetDIBits( nullptr, // DC, 0 is a default GC, basically that of the desktop
+                       aHBMP,
+                       0, aBmpSize.cy,
+                       aBitmapStream.getArray() + sizeof(BITMAPINFO),
+                       reinterpret_cast<LPBITMAPINFO>(pBmp),
+                       DIB_RGB_COLORS ) )
+        {
+            ooBmpStream = WinDIBToOOBMP( aBitmapStream );
+        }
+    }
+
+    return ooBmpStream;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/FmtFilter.hxx b/dtrans/source/win32/dtobj/FmtFilter.hxx
new file mode 100644
index 000000000..1c2325851
--- /dev/null
+++ b/dtrans/source/win32/dtobj/FmtFilter.hxx
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FMTFILTER_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_FMTFILTER_HXX
+
+#include <sal/types.h>
+
+#include <com/sun/star/uno/Sequence.hxx>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <objidl.h>
+
+/*------------------------------------------------------------------------
+    input:
+    aMetaFilePict - a sequence of bytes containing a METAFILEPICT struct
+------------------------------------------------------------------------*/
+css::uno::Sequence< sal_Int8 > WinMFPictToOOMFPict( css::uno::Sequence< sal_Int8 >& aMetaFilePict );
+css::uno::Sequence< sal_Int8 > WinENHMFPictToOOMFPict( HENHMETAFILE hEnhMetaFile );
+
+/*------------------------------------------------------------------------
+    input:
+    aByteStream - a sequence of bytes containing a LibreOffice metafile
+                  picture with a leading METAFILEHEADER
+------------------------------------------------------------------------*/
+HMETAFILEPICT OOMFPictToWinMFPict( css::uno::Sequence< sal_Int8 > const & aOOMetaFilePict );
+HENHMETAFILE  OOMFPictToWinENHMFPict( css::uno::Sequence< sal_Int8 > const & aOOMetaFilePict );
+
+/*------------------------------------------------------------------------
+    input:
+    aWinDIB - sequence of bytes containing a windows device independent
+              bitmap
+------------------------------------------------------------------------*/
+css::uno::Sequence< sal_Int8 > WinDIBToOOBMP( const css::uno::Sequence< sal_Int8 >& aWinDIB );
+
+/*------------------------------------------------------------------------
+    input:
+    aWinDIB - sequence of bytes containing a windows bitmap handle
+------------------------------------------------------------------------*/
+css::uno::Sequence< sal_Int8 > WinBITMAPToOOBMP( HBITMAP );
+
+/*------------------------------------------------------------------------
+    input:
+    aOOBmp - sequence of bytes containing a LibreOffice bitmap
+    May contain CF_DIBV5 or CF_DIB, but removing the BITMAPFILEHEADER
+    is always the same size
+------------------------------------------------------------------------*/
+css::uno::Sequence< sal_Int8 > OOBmpToWinDIB( css::uno::Sequence< sal_Int8 >& aOOBmp );
+
+/*------------------------------------------------------------------------
+    input:
+    aTextHtml - a sequence of text/html which will be converted to the
+    HTML Format; the HTML Format has header before the real html data
+    the Format is described in the MSDN Library under HTML Clipboard
+    Format
+------------------------------------------------------------------------*/
+css::uno::Sequence< sal_Int8 > TextHtmlToHTMLFormat( css::uno::Sequence< sal_Int8 > const & aTextHtml );
+
+/**
+    Return a FileList in which Windows Shell Links (lnk) are resolved.
+    If for whatever reason a resolution is not possible leave the
+    original lnk file.
+*/
+css::uno::Sequence< sal_Int8 > CF_HDROPToFileList(HGLOBAL hGlobal);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/MimeAttrib.hxx b/dtrans/source/win32/dtobj/MimeAttrib.hxx
new file mode 100644
index 000000000..eb57ba750
--- /dev/null
+++ b/dtrans/source/win32/dtobj/MimeAttrib.hxx
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_MIMEATTRIB_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_MIMEATTRIB_HXX
+
+#include <rtl/ustring.hxx>
+
+const OUString TEXTPLAIN_PARAM_CHARSET("charset");
+
+const OUString PRE_WINDOWS_CODEPAGE ("windows");
+const OUString PRE_OEM_CODEPAGE     ("cp");
+const OUString CHARSET_UTF16        ("utf-16");
+const OUString CHARSET_UNICODE      ("unicode");
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/TxtCnvtHlp.cxx b/dtrans/source/win32/dtobj/TxtCnvtHlp.cxx
new file mode 100644
index 000000000..1ea9f4c9f
--- /dev/null
+++ b/dtrans/source/win32/dtobj/TxtCnvtHlp.cxx
@@ -0,0 +1,124 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <osl/diagnose.h>
+#include "TxtCnvtHlp.hxx"
+#include "DTransHelper.hxx"
+#include "../misc/ImplHelper.hxx"
+
+using namespace ::com::sun::star::datatransfer;
+using namespace ::com::sun::star::uno;
+
+// assuming a '\0' terminated string if no length specified
+
+static int CalcBuffSizeForTextConversion( UINT code_page, LPCSTR lpMultiByteString, int nLen = -1 )
+{
+    return ( MultiByteToWideChar( code_page,
+                                0,
+                                lpMultiByteString,
+                                nLen,
+                                nullptr,
+                                0 ) * sizeof( sal_Unicode ) );
+}
+
+// assuming a '\0' terminated string if no length specified
+
+static int CalcBuffSizeForTextConversion( UINT code_page, LPCWSTR lpWideCharString, int nLen = -1 )
+{
+    return WideCharToMultiByte( code_page,
+                                0,
+                                lpWideCharString,
+                                nLen,
+                                nullptr,
+                                0,
+                                nullptr,
+                                nullptr );
+}
+
+// converts text in one code page into unicode text
+// automatically calculates the necessary buffer size and allocates
+// the buffer
+
+int MultiByteToWideCharEx( UINT cp_src,
+                           LPCSTR lpMultiByteString,
+                           sal_uInt32 lenStr,
+                           CStgTransferHelper& refDTransHelper,
+                           BOOL bEnsureTrailingZero )
+{
+    OSL_ASSERT( IsValidCodePage( cp_src ) );
+    OSL_ASSERT( nullptr != lpMultiByteString );
+
+    // calculate the required buff size
+    int reqSize = CalcBuffSizeForTextConversion( cp_src, lpMultiByteString, lenStr );
+
+    if ( bEnsureTrailingZero )
+        reqSize += sizeof( sal_Unicode );
+
+    // initialize the data-transfer helper
+    refDTransHelper.init( reqSize );
+
+    // setup a global memory pointer
+    CRawHGlobalPtr ptrHGlob( refDTransHelper );
+
+    // do the conversion and return
+    return MultiByteToWideChar( cp_src,
+                                0,
+                                lpMultiByteString,
+                                lenStr,
+                                static_cast< LPWSTR >( ptrHGlob.GetMemPtr( ) ),
+                                ptrHGlob.MemSize( ) );
+}
+
+// converts unicode text into text of the specified code page
+// automatically calculates the necessary buffer size and allocates
+// the buffer
+
+int WideCharToMultiByteEx( UINT cp_dest,
+                           LPCWSTR lpWideCharString,
+                           sal_uInt32 lenStr,
+                           CStgTransferHelper& refDTransHelper,
+                           BOOL bEnsureTrailingZero )
+{
+    OSL_ASSERT( IsValidCodePage( cp_dest ) );
+    OSL_ASSERT( nullptr != lpWideCharString );
+
+    // calculate the required buff size
+    int reqSize = CalcBuffSizeForTextConversion( cp_dest, lpWideCharString, lenStr );
+
+    if ( bEnsureTrailingZero )
+        reqSize += sizeof( sal_Int8 );
+
+    // initialize the data-transfer helper
+    refDTransHelper.init( reqSize );
+
+    // setup a global memory pointer
+    CRawHGlobalPtr ptrHGlob( refDTransHelper );
+
+    // do the conversion and return
+    return WideCharToMultiByte( cp_dest,
+                                0,
+                                lpWideCharString,
+                                lenStr,
+                                static_cast< LPSTR >( ptrHGlob.GetMemPtr( ) ),
+                                ptrHGlob.MemSize( ),
+                                nullptr,
+                                nullptr );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/TxtCnvtHlp.hxx b/dtrans/source/win32/dtobj/TxtCnvtHlp.hxx
new file mode 100644
index 000000000..9f8d47209
--- /dev/null
+++ b/dtrans/source/win32/dtobj/TxtCnvtHlp.hxx
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_TXTCNVTHLP_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_TXTCNVTHLP_HXX
+
+#include <com/sun/star/datatransfer/DataFlavor.hpp>
+
+#include "DTransHelper.hxx"
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+int MultiByteToWideCharEx( UINT cp_src,
+                           LPCSTR lpMultiByteString,
+                           sal_uInt32 lenStr,
+                           CStgTransferHelper& refDTransHelper,
+                           BOOL bEnsureTrailingZero = TRUE );
+
+int WideCharToMultiByteEx( UINT cp_dest,
+                           LPCWSTR lpWideCharString,
+                           sal_uInt32 lenStr,
+                           CStgTransferHelper& refDTransHelper,
+                           BOOL bEnsureTrailingZero = TRUE );
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/XNotifyingDataObject.cxx b/dtrans/source/win32/dtobj/XNotifyingDataObject.cxx
new file mode 100644
index 000000000..46f563f94
--- /dev/null
+++ b/dtrans/source/win32/dtobj/XNotifyingDataObject.cxx
@@ -0,0 +1,149 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <osl/diagnose.h>
+#include "XNotifyingDataObject.hxx"
+#include "../clipb/WinClipbImpl.hxx"
+#include "../clipb/WinClipboard.hxx"
+
+using namespace com::sun::star::datatransfer;
+using namespace com::sun::star::datatransfer::clipboard;
+using com::sun::star::uno::RuntimeException;
+using com::sun::star::uno::Reference;
+
+CXNotifyingDataObject::CXNotifyingDataObject(
+    const IDataObjectPtr& aIDataObject,
+    const Reference< XTransferable >& aXTransferable,
+    const Reference< XClipboardOwner >& aXClipOwner,
+    CWinClipbImpl* theWinClipImpl ) :
+    m_nRefCnt( 0 ),
+    m_aIDataObject( aIDataObject ),
+    m_XTransferable( aXTransferable ),
+    m_XClipboardOwner( aXClipOwner ),
+    m_pWinClipImpl( theWinClipImpl )
+{
+}
+
+STDMETHODIMP CXNotifyingDataObject::QueryInterface( REFIID iid, void** ppvObject )
+{
+    if ( nullptr == ppvObject )
+        return E_INVALIDARG;
+
+    HRESULT hr = E_NOINTERFACE;
+
+    *ppvObject = nullptr;
+    if ( ( __uuidof( IUnknown ) == iid ) ||
+         ( __uuidof( IDataObject ) == iid ) )
+    {
+        *ppvObject = static_cast< IUnknown* >( this );
+        static_cast<LPUNKNOWN>(*ppvObject)->AddRef( );
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+STDMETHODIMP_(ULONG) CXNotifyingDataObject::AddRef( )
+{
+    return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
+}
+
+STDMETHODIMP_(ULONG) CXNotifyingDataObject::Release( )
+{
+    ULONG nRefCnt =
+        static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
+
+    if ( 0 == nRefCnt )
+    {
+        if ( m_pWinClipImpl )
+            m_pWinClipImpl->onReleaseDataObject( this );
+
+        delete this;
+    }
+
+    return nRefCnt;
+}
+
+STDMETHODIMP CXNotifyingDataObject::GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium )
+{
+    return m_aIDataObject->GetData(pFormatetc, pmedium);
+}
+
+STDMETHODIMP CXNotifyingDataObject::EnumFormatEtc(
+    DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
+{
+    return m_aIDataObject->EnumFormatEtc(dwDirection, ppenumFormatetc);
+}
+
+STDMETHODIMP CXNotifyingDataObject::QueryGetData( FORMATETC * pFormatetc )
+{
+    return m_aIDataObject->QueryGetData(pFormatetc);
+}
+
+STDMETHODIMP CXNotifyingDataObject::GetDataHere( FORMATETC * lpFetc, STGMEDIUM * lpStgMedium )
+{
+    return m_aIDataObject->GetDataHere(lpFetc, lpStgMedium);
+}
+
+STDMETHODIMP CXNotifyingDataObject::GetCanonicalFormatEtc( FORMATETC * lpFetc, FORMATETC * lpCanonicalFetc )
+{
+    return m_aIDataObject->GetCanonicalFormatEtc(lpFetc, lpCanonicalFetc);
+}
+
+STDMETHODIMP CXNotifyingDataObject::SetData( FORMATETC * lpFetc, STGMEDIUM * lpStgMedium, BOOL bRelease )
+{
+    return m_aIDataObject->SetData( lpFetc, lpStgMedium, bRelease );
+}
+
+STDMETHODIMP CXNotifyingDataObject::DAdvise(
+    FORMATETC * lpFetc, DWORD advf, IAdviseSink * lpAdvSink, DWORD* pdwConnection )
+{
+    return m_aIDataObject->DAdvise( lpFetc, advf, lpAdvSink, pdwConnection );
+}
+
+STDMETHODIMP CXNotifyingDataObject::DUnadvise( DWORD dwConnection )
+{
+    return m_aIDataObject->DUnadvise( dwConnection );
+}
+
+STDMETHODIMP CXNotifyingDataObject::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise )
+{
+    return m_aIDataObject->EnumDAdvise( ppenumAdvise );
+}
+
+CXNotifyingDataObject::operator IDataObject*( )
+{
+    return static_cast< IDataObject* >( this );
+}
+
+void CXNotifyingDataObject::lostOwnership( )
+{
+    try
+    {
+        if (m_XClipboardOwner.is())
+            m_XClipboardOwner->lostOwnership(
+                static_cast<XClipboardEx*>(m_pWinClipImpl->m_pWinClipboard ), m_XTransferable);
+    }
+    catch(RuntimeException&)
+    {
+        OSL_FAIL( "RuntimeException caught" );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/XNotifyingDataObject.hxx b/dtrans/source/win32/dtobj/XNotifyingDataObject.hxx
new file mode 100644
index 000000000..0d72c760f
--- /dev/null
+++ b/dtrans/source/win32/dtobj/XNotifyingDataObject.hxx
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_XNOTIFYINGDATAOBJECT_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_XNOTIFYINGDATAOBJECT_HXX
+
+#include <com/sun/star/datatransfer/XTransferable.hpp>
+#include <com/sun/star/datatransfer/clipboard/XClipboardOwner.hpp>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <objidl.h>
+
+#include <systools/win32/comtools.hxx>
+
+/*--------------------------------------------------------------------------
+    To implement the lostOwnership mechanism cleanly we need this wrapper
+    object
+----------------------------------------------------------------------------*/
+
+// forward
+class CWinClipbImpl;
+
+class CXNotifyingDataObject : public IDataObject
+{
+public:
+    CXNotifyingDataObject(
+        const IDataObjectPtr& aIDataObject,
+        const css::uno::Reference< css::datatransfer::XTransferable >& aXTransferable,
+        const css::uno::Reference< css::datatransfer::clipboard::XClipboardOwner >& aXClipOwner,
+        CWinClipbImpl* theWinClipImpl );
+
+    virtual ~CXNotifyingDataObject() {}
+
+    // ole interface implementation
+
+    //IUnknown interface methods
+    STDMETHODIMP           QueryInterface(REFIID iid, void** ppvObject) override;
+    STDMETHODIMP_( ULONG ) AddRef( ) override;
+    STDMETHODIMP_( ULONG ) Release( ) override;
+
+    // IDataObject interface methods
+    STDMETHODIMP GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP QueryGetData( FORMATETC * pFormatetc ) override;
+    STDMETHODIMP GetCanonicalFormatEtc( FORMATETC * pFormatectIn, FORMATETC * pFormatetcOut ) override;
+    STDMETHODIMP SetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium, BOOL fRelease ) override;
+    STDMETHODIMP EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc ) override;
+    STDMETHODIMP DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD* pdwConnection ) override;
+    STDMETHODIMP DUnadvise( DWORD dwConnection ) override;
+    STDMETHODIMP EnumDAdvise( IEnumSTATDATA** ppenumAdvise ) override;
+
+    operator IDataObject*( );
+
+private:
+    void lostOwnership( );
+
+private:
+    sal_Int32                                                                     m_nRefCnt;
+    IDataObjectPtr                                                                m_aIDataObject;
+    const css::uno::Reference< css::datatransfer::XTransferable >                 m_XTransferable;
+    const css::uno::Reference< css::datatransfer::clipboard::XClipboardOwner >    m_XClipboardOwner;
+    CWinClipbImpl*                                                                m_pWinClipImpl;
+
+    friend class CWinClipbImpl;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/XTDataObject.cxx b/dtrans/source/win32/dtobj/XTDataObject.cxx
new file mode 100644
index 000000000..01b1ce39f
--- /dev/null
+++ b/dtrans/source/win32/dtobj/XTDataObject.cxx
@@ -0,0 +1,757 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <osl/diagnose.h>
+#include <o3tl/char16_t2wchar_t.hxx>
+#include <o3tl/safeint.hxx>
+
+#include "XTDataObject.hxx"
+#include <com/sun/star/datatransfer/DataFlavor.hpp>
+#include "../misc/ImplHelper.hxx"
+#include "DTransHelper.hxx"
+#include "TxtCnvtHlp.hxx"
+#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
+#include <com/sun/star/datatransfer/clipboard/XClipboardEx.hpp>
+#include <com/sun/star/awt/AsyncCallback.hpp>
+#include <com/sun/star/awt/XCallback.hpp>
+#include "FmtFilter.hxx"
+#include <cppuhelper/implbase.hxx>
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <shlobj.h>
+
+using namespace com::sun::star::datatransfer;
+using namespace com::sun::star::datatransfer::clipboard;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+
+namespace {
+
+void setupStgMedium( const FORMATETC& fetc,
+                                             CStgTransferHelper& stgTransHlp,
+                                             STGMEDIUM& stgmedium )
+{
+    stgmedium.pUnkForRelease = nullptr;
+
+    if ( fetc.cfFormat == CF_METAFILEPICT )
+    {
+        stgmedium.tymed         = TYMED_MFPICT;
+        stgmedium.hMetaFilePict = static_cast< HMETAFILEPICT >( stgTransHlp.getHGlobal( ) );
+    }
+    else if ( fetc.cfFormat == CF_ENHMETAFILE )
+    {
+        stgmedium.tymed        = TYMED_ENHMF;
+        stgmedium.hEnhMetaFile = static_cast< HENHMETAFILE >( stgTransHlp.getHGlobal( ) );
+    }
+    else if ( fetc.tymed & TYMED_HGLOBAL )
+    {
+        stgmedium.tymed   = TYMED_HGLOBAL;
+        stgmedium.hGlobal = stgTransHlp.getHGlobal( );
+    }
+    else if ( fetc.tymed & TYMED_ISTREAM )
+    {
+        stgmedium.tymed = TYMED_ISTREAM;
+        stgTransHlp.getIStream( &stgmedium.pstm );
+    }
+    else
+        OSL_ASSERT( false );
+}
+
+/**
+   We need to destroy XTransferable in the main thread to avoid dead lock
+   when locking in the clipboard thread. So we transfer the ownership of the
+   XTransferable reference to this object and release it when the callback
+   is executed in main thread.
+*/
+class AsyncDereference : public cppu::WeakImplHelper<css::awt::XCallback>
+{
+    Reference<XTransferable> maTransferable;
+
+public:
+    AsyncDereference(css::uno::Reference<css::datatransfer::XTransferable> const & rTransferable)
+        : maTransferable(rTransferable)
+    {}
+
+    virtual void SAL_CALL notify(css::uno::Any const &) override
+    {
+        maTransferable.set(nullptr);
+    }
+};
+
+// a helper class that will be thrown by the function validateFormatEtc
+
+class CInvalidFormatEtcException
+{
+public:
+    HRESULT m_hr;
+    explicit CInvalidFormatEtcException( HRESULT hr ) : m_hr( hr ) {};
+};
+
+void validateFormatEtc( LPFORMATETC lpFormatEtc )
+{
+    OSL_ASSERT( lpFormatEtc );
+
+    if ( lpFormatEtc->lindex != -1 )
+        throw CInvalidFormatEtcException( DV_E_LINDEX );
+
+    if ( !(lpFormatEtc->dwAspect & DVASPECT_CONTENT) &&
+         !(lpFormatEtc->dwAspect & DVASPECT_SHORTNAME) )
+        throw CInvalidFormatEtcException( DV_E_DVASPECT );
+
+    if ( !(lpFormatEtc->tymed & TYMED_HGLOBAL) &&
+         !(lpFormatEtc->tymed & TYMED_ISTREAM) &&
+         !(lpFormatEtc->tymed & TYMED_MFPICT) &&
+         !(lpFormatEtc->tymed & TYMED_ENHMF) )
+        throw CInvalidFormatEtcException( DV_E_TYMED );
+
+    if ( lpFormatEtc->cfFormat == CF_METAFILEPICT &&
+         !(lpFormatEtc->tymed & TYMED_MFPICT) )
+        throw CInvalidFormatEtcException( DV_E_TYMED );
+
+    if ( lpFormatEtc->cfFormat == CF_ENHMETAFILE &&
+         !(lpFormatEtc->tymed & TYMED_ENHMF) )
+        throw CInvalidFormatEtcException( DV_E_TYMED );
+}
+
+void invalidateStgMedium( STGMEDIUM& stgmedium )
+{
+    stgmedium.tymed = TYMED_NULL;
+}
+
+HRESULT translateStgExceptionCode( HRESULT hr )
+{
+    HRESULT hrTransl;
+
+    switch( hr )
+    {
+    case STG_E_MEDIUMFULL:
+        hrTransl = hr;
+        break;
+
+    default:
+        hrTransl = E_UNEXPECTED;
+        break;
+    }
+
+    return hrTransl;
+}
+
+// inline
+void renderDataAndSetupStgMedium(
+    const sal_Int8* lpStorage, const FORMATETC& fetc, sal_uInt32 nInitStgSize,
+    sal_uInt32 nBytesToTransfer, STGMEDIUM& stgmedium )
+{
+    OSL_PRECOND( !nInitStgSize || (nInitStgSize >= nBytesToTransfer),
+                 "Memory size less than number of bytes to transfer" );
+
+    CStgTransferHelper stgTransfHelper( AUTO_INIT );
+
+    // setup storage size
+    if ( nInitStgSize > 0 )
+        stgTransfHelper.init( nInitStgSize );
+
+#if OSL_DEBUG_LEVEL > 0
+    sal_uInt32 nBytesWritten = 0;
+    stgTransfHelper.write( lpStorage, nBytesToTransfer, &nBytesWritten );
+    OSL_ASSERT( nBytesWritten == nBytesToTransfer );
+#else
+    stgTransfHelper.write( lpStorage, nBytesToTransfer );
+#endif
+
+    setupStgMedium( fetc, stgTransfHelper, stgmedium );
+}
+
+}
+
+CXTDataObject::CXTDataObject( const Reference< XComponentContext >& rxContext,
+                              const Reference< XTransferable >& aXTransferable )
+    : m_nRefCnt( 0 )
+    , m_XTransferable( aXTransferable )
+    , m_XComponentContext( rxContext )
+    , m_bFormatEtcContainerInitialized( false )
+    , m_DataFormatTranslator( rxContext )
+    , m_FormatRegistrar( rxContext, m_DataFormatTranslator )
+{
+}
+
+CXTDataObject::~CXTDataObject()
+{
+    css::awt::AsyncCallback::create(m_XComponentContext)->addCallback(
+        new AsyncDereference(m_XTransferable),
+        css::uno::Any());
+}
+
+// IUnknown->QueryInterface
+
+STDMETHODIMP CXTDataObject::QueryInterface( REFIID iid, void** ppvObject )
+{
+    if ( nullptr == ppvObject )
+        return E_INVALIDARG;
+
+    HRESULT hr = E_NOINTERFACE;
+
+    *ppvObject = nullptr;
+    if ( ( __uuidof( IUnknown ) == iid ) ||
+         ( __uuidof( IDataObject ) == iid ) )
+    {
+        *ppvObject = static_cast< IUnknown* >( this );
+        static_cast<LPUNKNOWN>(*ppvObject)->AddRef( );
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+// IUnknown->AddRef
+
+STDMETHODIMP_(ULONG) CXTDataObject::AddRef( )
+{
+    return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
+}
+
+// IUnknown->Release
+
+STDMETHODIMP_(ULONG) CXTDataObject::Release( )
+{
+    ULONG nRefCnt =
+        static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
+
+    if ( 0 == nRefCnt )
+        delete this;
+
+    return nRefCnt;
+}
+
+STDMETHODIMP CXTDataObject::GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium )
+{
+    if ( !(pFormatetc && pmedium) )
+        return E_INVALIDARG;
+
+    try
+    {
+        // prepare data transfer
+        invalidateStgMedium( *pmedium );
+        validateFormatEtc( pFormatetc );
+
+        // handle locale request, because locale is an artificial format for us
+        if ( CF_LOCALE == pFormatetc->cfFormat )
+            renderLocaleAndSetupStgMedium( *pFormatetc, *pmedium );
+        else if ( CF_UNICODETEXT == pFormatetc->cfFormat )
+            renderUnicodeAndSetupStgMedium( *pFormatetc, *pmedium );
+        else
+            renderAnyDataAndSetupStgMedium( *pFormatetc, *pmedium );
+    }
+    catch(UnsupportedFlavorException&)
+    {
+        HRESULT hr = DV_E_FORMATETC;
+
+        CFormatEtc aFormatetc(*pFormatetc);
+        if (CFormatRegistrar::isSynthesizeableFormat(aFormatetc))
+            hr = renderSynthesizedFormatAndSetupStgMedium( *pFormatetc, *pmedium );
+
+        return hr;
+    }
+    catch( CInvalidFormatEtcException& ex )
+    {
+        return ex.m_hr;
+    }
+    catch( CStgTransferHelper::CStgTransferException& ex )
+    {
+        return translateStgExceptionCode( ex.m_hr );
+    }
+    catch(...)
+    {
+        return E_UNEXPECTED;
+    }
+
+    return S_OK;
+}
+
+//inline
+void CXTDataObject::renderLocaleAndSetupStgMedium(
+    FORMATETC const & fetc, STGMEDIUM& stgmedium )
+{
+    if ( !m_FormatRegistrar.hasSynthesizedLocale( ) )
+        throw CInvalidFormatEtcException( DV_E_FORMATETC );
+    LCID lcid = CFormatRegistrar::getSynthesizedLocale( );
+    renderDataAndSetupStgMedium(
+        reinterpret_cast< sal_Int8* >( &lcid ),
+        fetc,
+        0,
+        sizeof( LCID ),
+        stgmedium );
+}
+
+void CXTDataObject::renderUnicodeAndSetupStgMedium(
+    FORMATETC const & fetc, STGMEDIUM& stgmedium )
+{
+    DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
+
+    Any aAny = m_XTransferable->getTransferData( aFlavor );
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+    {
+        OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
+        throw UnsupportedFlavorException( );
+    }
+
+    OUString aText;
+    aAny >>= aText;
+
+    sal_uInt32 nBytesToTransfer = aText.getLength( ) * sizeof( sal_Unicode );
+
+    // to be sure there is an ending 0
+    sal_uInt32 nRequiredMemSize = nBytesToTransfer + sizeof( sal_Unicode );
+
+    renderDataAndSetupStgMedium(
+        reinterpret_cast< const sal_Int8* >( aText.getStr( ) ),
+        fetc,
+        nRequiredMemSize,
+        nBytesToTransfer,
+        stgmedium );
+}
+
+void CXTDataObject::renderAnyDataAndSetupStgMedium(
+    FORMATETC& fetc, STGMEDIUM& stgmedium )
+{
+    DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
+
+    Any aAny = m_XTransferable->getTransferData( aFlavor );
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+    {
+        OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
+        throw UnsupportedFlavorException( );
+    }
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+        throw UnsupportedFlavorException( );
+
+    Sequence< sal_Int8 > clipDataStream;
+    aAny >>= clipDataStream;
+
+    sal_uInt32 nRequiredMemSize = 0;
+    if ( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) )
+        nRequiredMemSize = sizeof( sal_Int8 ) * clipDataStream.getLength( ) + 1;
+
+    // prepare data for transmission
+    // #i124085# DIBV5 should not happen for now, but keep as hint here
+    if ( CF_DIBV5 == fetc.cfFormat || CF_DIB == fetc.cfFormat )
+    {
+#ifdef DBG_UTIL
+        if(CF_DIBV5 == fetc.cfFormat)
+        {
+            OSL_ENSURE(o3tl::make_unsigned(clipDataStream.getLength()) > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPV5HEADER)), "Wrong size on CF_DIBV5 data (!)");
+        }
+        else // CF_DIB == fetc.cfFormat
+        {
+            OSL_ENSURE(o3tl::make_unsigned(clipDataStream.getLength()) > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)), "Wrong size on CF_DIB data (!)");
+        }
+#endif
+
+        // remove BITMAPFILEHEADER
+        clipDataStream = OOBmpToWinDIB( clipDataStream );
+    }
+
+    if ( CF_METAFILEPICT == fetc.cfFormat )
+    {
+        stgmedium.tymed          = TYMED_MFPICT;
+        stgmedium.hMetaFilePict  = OOMFPictToWinMFPict( clipDataStream );
+        stgmedium.pUnkForRelease = nullptr;
+    }
+    else if( CF_ENHMETAFILE == fetc.cfFormat )
+    {
+        stgmedium.tymed          = TYMED_ENHMF;
+        stgmedium.hMetaFilePict  = OOMFPictToWinENHMFPict( clipDataStream );
+        stgmedium.pUnkForRelease = nullptr;
+    }
+    else
+        renderDataAndSetupStgMedium(
+            clipDataStream.getArray( ),
+            fetc,
+            nRequiredMemSize,
+            clipDataStream.getLength( ),
+            stgmedium );
+}
+
+HRESULT CXTDataObject::renderSynthesizedFormatAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
+{
+    HRESULT hr = S_OK;
+
+    try
+    {
+        if ( CF_UNICODETEXT == fetc.cfFormat )
+            // the transferable seems to have only text
+            renderSynthesizedUnicodeAndSetupStgMedium( fetc, stgmedium );
+        else if ( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) )
+            // the transferable seems to have only unicode text
+            renderSynthesizedTextAndSetupStgMedium( fetc, stgmedium );
+        else
+            // the transferable seems to have only text/html
+            renderSynthesizedHtmlAndSetupStgMedium( fetc, stgmedium );
+    }
+    catch(UnsupportedFlavorException&)
+    {
+        hr = DV_E_FORMATETC;
+    }
+    catch( CInvalidFormatEtcException& )
+    {
+        OSL_FAIL( "Unexpected exception" );
+    }
+    catch( CStgTransferHelper::CStgTransferException& ex )
+    {
+        return translateStgExceptionCode( ex.m_hr );
+    }
+    catch(...)
+    {
+        hr = E_UNEXPECTED;
+    }
+
+    return hr;
+}
+
+// the transferable must have only text, so we will synthesize unicode text
+
+void CXTDataObject::renderSynthesizedUnicodeAndSetupStgMedium( FORMATETC const & fetc, STGMEDIUM& stgmedium )
+{
+    OSL_ASSERT( CF_UNICODETEXT == fetc.cfFormat );
+
+    Any aAny = m_XTransferable->getTransferData( m_FormatRegistrar.getRegisteredTextFlavor( ) );
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+    {
+        OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
+        throw UnsupportedFlavorException( );
+    }
+
+    Sequence< sal_Int8 > aText;
+    aAny >>= aText;
+
+    CStgTransferHelper stgTransfHelper;
+
+    MultiByteToWideCharEx(
+        CFormatRegistrar::getRegisteredTextCodePage( ),
+        reinterpret_cast< char* >( aText.getArray( ) ),
+        aText.getLength( ),
+        stgTransfHelper );
+
+    setupStgMedium( fetc, stgTransfHelper, stgmedium );
+}
+
+// the transferable must have only unicode text so we will synthesize text
+
+void CXTDataObject::renderSynthesizedTextAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
+{
+    OSL_ASSERT( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) );
+
+    DataFlavor aFlavor = formatEtcToDataFlavor(
+        CDataFormatTranslator::getFormatEtcForClipformat( CF_UNICODETEXT ) );
+
+    Any aAny = m_XTransferable->getTransferData( aFlavor );
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+    {
+        OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
+        throw UnsupportedFlavorException( );
+    }
+
+    OUString aUnicodeText;
+    aAny >>= aUnicodeText;
+
+    CStgTransferHelper stgTransfHelper;
+
+    WideCharToMultiByteEx(
+        GetACP( ),
+        o3tl::toW( aUnicodeText.getStr( ) ),
+        aUnicodeText.getLength( ),
+        stgTransfHelper );
+
+    setupStgMedium( fetc, stgTransfHelper, stgmedium );
+}
+
+void CXTDataObject::renderSynthesizedHtmlAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
+{
+    OSL_ASSERT( CDataFormatTranslator::isHTMLFormat( fetc.cfFormat ) );
+
+    DataFlavor aFlavor;
+
+    // creating a DataFlavor on the fly
+    aFlavor.MimeType = "text/html";
+    aFlavor.DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
+
+    Any aAny = m_XTransferable->getTransferData( aFlavor );
+
+    // unfortunately not all transferables fulfill the
+    // spec. and do throw an UnsupportedFlavorException
+    // so we must check the any
+    if ( !aAny.hasValue( ) )
+    {
+        OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
+        throw UnsupportedFlavorException( );
+    }
+
+    Sequence< sal_Int8 > aTextHtmlSequence;
+    aAny >>= aTextHtmlSequence;
+
+    Sequence< sal_Int8 > aHTMLFormatSequence = TextHtmlToHTMLFormat( aTextHtmlSequence );
+
+    sal_uInt32 nBytesToTransfer = aHTMLFormatSequence.getLength( );
+
+    renderDataAndSetupStgMedium(
+        reinterpret_cast< const sal_Int8* >( aHTMLFormatSequence.getArray( ) ),
+        fetc,
+        0,
+        nBytesToTransfer,
+        stgmedium );
+}
+
+// IDataObject->EnumFormatEtc
+
+STDMETHODIMP CXTDataObject::EnumFormatEtc(
+    DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
+{
+    if ( nullptr == ppenumFormatetc )
+        return E_INVALIDARG;
+
+    if ( DATADIR_SET == dwDirection )
+        return E_NOTIMPL;
+
+    *ppenumFormatetc = nullptr;
+
+    InitializeFormatEtcContainer( );
+
+    HRESULT hr;
+    if ( DATADIR_GET == dwDirection )
+    {
+        *ppenumFormatetc = new CEnumFormatEtc( this, m_FormatEtcContainer );
+        static_cast< LPUNKNOWN >( *ppenumFormatetc )->AddRef( );
+
+        hr = S_OK;
+    }
+    else
+        hr = E_INVALIDARG;
+
+    return hr;
+}
+
+// IDataObject->QueryGetData
+
+STDMETHODIMP CXTDataObject::QueryGetData( FORMATETC * pFormatetc )
+{
+    if ( (nullptr == pFormatetc) || IsBadReadPtr( pFormatetc, sizeof( FORMATETC ) ) )
+        return E_INVALIDARG;
+
+    InitializeFormatEtcContainer( );
+
+    CFormatEtc aFormatetc(*pFormatetc);
+    return m_FormatEtcContainer.hasFormatEtc(aFormatetc) ? S_OK : S_FALSE;
+}
+
+// IDataObject->GetDataHere
+
+STDMETHODIMP CXTDataObject::GetDataHere( FORMATETC *, STGMEDIUM * )
+{
+    return E_NOTIMPL;
+}
+
+// IDataObject->GetCanonicalFormatEtc
+
+STDMETHODIMP CXTDataObject::GetCanonicalFormatEtc( FORMATETC *, FORMATETC * )
+{
+    return E_NOTIMPL;
+}
+
+// IDataObject->SetData
+
+STDMETHODIMP CXTDataObject::SetData( FORMATETC *, STGMEDIUM *, BOOL )
+{
+    return E_NOTIMPL;
+}
+
+// IDataObject->DAdvise
+
+STDMETHODIMP CXTDataObject::DAdvise( FORMATETC *, DWORD, IAdviseSink *, DWORD * )
+{
+    return E_NOTIMPL;
+}
+
+// IDataObject->DUnadvise
+
+STDMETHODIMP CXTDataObject::DUnadvise( DWORD )
+{
+    return E_NOTIMPL;
+}
+
+// IDataObject->EnumDAdvise
+
+STDMETHODIMP CXTDataObject::EnumDAdvise( IEnumSTATDATA ** )
+{
+    return E_NOTIMPL;
+}
+
+// for our convenience
+
+CXTDataObject::operator IDataObject*( )
+{
+    return static_cast< IDataObject* >( this );
+}
+
+inline
+DataFlavor CXTDataObject::formatEtcToDataFlavor( const FORMATETC& aFormatEtc ) const
+{
+    DataFlavor aFlavor;
+
+    if ( m_FormatRegistrar.hasSynthesizedLocale( ) )
+        aFlavor =
+            m_DataFormatTranslator.getDataFlavorFromFormatEtc( aFormatEtc, CFormatRegistrar::getSynthesizedLocale( ) );
+    else
+        aFlavor = m_DataFormatTranslator.getDataFlavorFromFormatEtc( aFormatEtc );
+
+    if ( !aFlavor.MimeType.getLength( ) )
+        throw UnsupportedFlavorException( );
+
+    return aFlavor;
+}
+
+inline void CXTDataObject::InitializeFormatEtcContainer( )
+{
+    if ( !m_bFormatEtcContainerInitialized )
+    {
+        m_FormatRegistrar.RegisterFormats( m_XTransferable, m_FormatEtcContainer );
+        m_bFormatEtcContainerInitialized = true;
+    }
+}
+
+CEnumFormatEtc::CEnumFormatEtc( LPUNKNOWN lpUnkOuter, const CFormatEtcContainer& aFormatEtcContainer ) :
+    m_nRefCnt( 0 ),
+    m_lpUnkOuter( lpUnkOuter ),
+    m_FormatEtcContainer( aFormatEtcContainer )
+{
+    Reset( );
+}
+
+// IUnknown->QueryInterface
+
+STDMETHODIMP CEnumFormatEtc::QueryInterface( REFIID iid, void** ppvObject )
+{
+    if ( nullptr == ppvObject )
+        return E_INVALIDARG;
+
+    HRESULT hr = E_NOINTERFACE;
+
+    *ppvObject = nullptr;
+
+    if ( ( __uuidof( IUnknown ) == iid ) ||
+         ( __uuidof( IEnumFORMATETC ) == iid ) )
+    {
+        *ppvObject = static_cast< IUnknown* >( this );
+        static_cast< LPUNKNOWN >( *ppvObject )->AddRef( );
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+// IUnknown->AddRef
+
+STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef( )
+{
+    // keep the dataobject alive
+    m_lpUnkOuter->AddRef( );
+    return InterlockedIncrement( &m_nRefCnt );
+}
+
+// IUnknown->Release
+
+STDMETHODIMP_(ULONG) CEnumFormatEtc::Release( )
+{
+    // release the outer dataobject
+    m_lpUnkOuter->Release( );
+
+    ULONG nRefCnt = InterlockedDecrement( &m_nRefCnt );
+    if ( 0 == nRefCnt )
+        delete this;
+
+    return nRefCnt;
+}
+
+// IEnumFORMATETC->Next
+
+STDMETHODIMP CEnumFormatEtc::Next( ULONG nRequested, FORMATETC * lpDest, ULONG* lpFetched )
+{
+    if ( ( nRequested < 1 ) ||
+         (( nRequested > 1 ) && ( nullptr == lpFetched )) ||
+         IsBadWritePtr( lpDest, sizeof( FORMATETC ) * nRequested ) )
+        return E_INVALIDARG;
+
+    sal_uInt32 nFetched = m_FormatEtcContainer.nextFormatEtc( lpDest, nRequested );
+
+    if ( nullptr != lpFetched )
+        *lpFetched = nFetched;
+
+    return (nFetched == nRequested) ? S_OK : S_FALSE;
+}
+
+// IEnumFORMATETC->Skip
+
+STDMETHODIMP CEnumFormatEtc::Skip( ULONG celt )
+{
+    return m_FormatEtcContainer.skipFormatEtc( celt ) ? S_OK : S_FALSE;
+}
+
+// IEnumFORMATETC->Reset
+
+STDMETHODIMP CEnumFormatEtc::Reset( )
+{
+    m_FormatEtcContainer.beginEnumFormatEtc( );
+    return S_OK;
+}
+
+// IEnumFORMATETC->Clone
+
+STDMETHODIMP CEnumFormatEtc::Clone( IEnumFORMATETC** ppenum )
+{
+    if ( nullptr == ppenum )
+        return E_INVALIDARG;
+
+    *ppenum = new CEnumFormatEtc( m_lpUnkOuter, m_FormatEtcContainer );
+    static_cast< LPUNKNOWN >( *ppenum )->AddRef( );
+
+    return S_OK;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/dtrans/source/win32/dtobj/XTDataObject.hxx b/dtrans/source/win32/dtobj/XTDataObject.hxx
new file mode 100644
index 000000000..ca30bbea2
--- /dev/null
+++ b/dtrans/source/win32/dtobj/XTDataObject.hxx
@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#ifndef INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_XTDATAOBJECT_HXX
+#define INCLUDED_DTRANS_SOURCE_WIN32_DTOBJ_XTDATAOBJECT_HXX
+
+#include <com/sun/star/datatransfer/XTransferable.hpp>
+#include <com/sun/star/datatransfer/clipboard/XClipboardOwner.hpp>
+
+#include "DataFmtTransl.hxx"
+
+#include "FetcList.hxx"
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <ole2.h>
+#include <objidl.h>
+
+/*--------------------------------------------------------------------------
+    - the function principle of the windows clipboard:
+      a data provider offers all formats he can deliver on the clipboard
+      a clipboard client ask for the available formats on the clipboard
+      and decides if there is a format he can use
+      if there is one, he requests the data in this format
+
+    - This class inherits from IDataObject and so can be placed on the
+      OleClipboard. The class wraps a transferable object which is the
+      original DataSource
+    - DataFlavors offered by this transferable will be translated into
+      appropriate clipboard formats
+    - if the transferable contains text data always text and unicodetext
+      will be offered or vice versa
+    - text data will be automatically converted between text and unicode text
+    - although the transferable may support text in different charsets
+      (codepages) only text in one codepage can be offered by the clipboard
+
+----------------------------------------------------------------------------*/
+
+class CStgTransferHelper;
+
+class CXTDataObject : public IDataObject
+{
+public:
+    CXTDataObject( const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+                   const css::uno::Reference< css::datatransfer::XTransferable >& aXTransferable );
+    virtual ~CXTDataObject();
+
+    // ole interface implementation
+
+    //IUnknown interface methods
+    STDMETHODIMP           QueryInterface(REFIID iid, void** ppvObject) override;
+    STDMETHODIMP_( ULONG ) AddRef( ) override;
+    STDMETHODIMP_( ULONG ) Release( ) override;
+
+    // IDataObject interface methods
+    STDMETHODIMP GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pmedium ) override;
+    STDMETHODIMP QueryGetData( FORMATETC * pFormatetc ) override;
+    STDMETHODIMP GetCanonicalFormatEtc( FORMATETC * pFormatectIn, FORMATETC * pFormatetcOut ) override;
+    STDMETHODIMP SetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium, BOOL fRelease ) override;
+    STDMETHODIMP EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc ) override;
+    STDMETHODIMP DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD* pdwConnection ) override;
+    STDMETHODIMP DUnadvise( DWORD dwConnection ) override;
+    STDMETHODIMP EnumDAdvise( IEnumSTATDATA** ppenumAdvise ) override;
+
+    operator IDataObject*( );
+
+private:
+    css::datatransfer::DataFlavor formatEtcToDataFlavor( const FORMATETC& aFormatEtc ) const;
+
+    void renderLocaleAndSetupStgMedium( FORMATETC const & fetc, STGMEDIUM& stgmedium );
+    void renderUnicodeAndSetupStgMedium( FORMATETC const & fetc, STGMEDIUM& stgmedium );
+    void renderAnyDataAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium );
+
+    HRESULT renderSynthesizedFormatAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium );
+    void    renderSynthesizedUnicodeAndSetupStgMedium( FORMATETC const & fetc, STGMEDIUM& stgmedium );
+    void    renderSynthesizedTextAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium );
+    void    renderSynthesizedHtmlAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium );
+
+    inline void InitializeFormatEtcContainer( );
+
+private:
+    LONG m_nRefCnt;
+    css::uno::Reference< css::datatransfer::XTransferable >      m_XTransferable;
+    css::uno::Reference< css::uno::XComponentContext>            m_XComponentContext;
+    CFormatEtcContainer                                          m_FormatEtcContainer;
+    bool                                                         m_bFormatEtcContainerInitialized;
+    CDataFormatTranslator                                        m_DataFormatTranslator;
+    CFormatRegistrar                                             m_FormatRegistrar;
+};
+
+class CEnumFormatEtc : public IEnumFORMATETC
+{
+public:
+    CEnumFormatEtc( LPUNKNOWN lpUnkOuter, const CFormatEtcContainer& aFormatEtcContainer );
+    virtual ~CEnumFormatEtc() {}
+
+    // IUnknown
+    STDMETHODIMP           QueryInterface( REFIID iid, void** ppvObject ) override;
+    STDMETHODIMP_( ULONG ) AddRef( ) override;
+    STDMETHODIMP_( ULONG ) Release( ) override;
+
+    //IEnumFORMATETC
+    STDMETHODIMP Next( ULONG nRequested, FORMATETC * lpDest, ULONG* lpFetched ) override;
+    STDMETHODIMP Skip( ULONG celt ) override;
+    STDMETHODIMP Reset( ) override;
+    STDMETHODIMP Clone( IEnumFORMATETC** ppenum ) override;
+
+private:
+    LONG                m_nRefCnt;
+    LPUNKNOWN           m_lpUnkOuter;
+    CFormatEtcContainer m_FormatEtcContainer;
+};
+
+typedef CEnumFormatEtc *PCEnumFormatEtc;
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */