src/msw/ole/droptgt.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        ole/droptgt.cpp
// Purpose:     wxDropTarget implementation
// Author:      Vadim Zeitlin
// Modified by:
// Created:
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// Declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "droptgt.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if defined(__BORLANDC__)
#pragma hdrstop
#endif

#include "wx/setup.h"

#if wxUSE_OLE && wxUSE_DRAG_AND_DROP

#include "wx/msw/private.h"
#include "wx/log.h"

#ifdef __WXWINCE__
    #include <winreg.h>
    #include <ole2.h>
#endif

#ifdef __WIN32__
    #if !defined(__GNUWIN32__) || wxUSE_NORLANDER_HEADERS
        #if wxCHECK_W32API_VERSION( 1, 0 )
            #include "wx/msw/wrapwin.h"
        #endif
        #include <shlobj.h>            // for DROPFILES structure
    #endif
#else
    #include <shellapi.h>
#endif

#include "wx/dnd.h"

#include "wx/msw/ole/oleutils.h"

// ----------------------------------------------------------------------------
// IDropTarget interface: forward all interesting things to wxDropTarget
// (the name is unfortunate, but wx_I_DropTarget is not at all the same thing
//  as wxDropTarget which is 'public' class, while this one is private)
// ----------------------------------------------------------------------------

class wxIDropTarget : public IDropTarget
{
public:
    wxIDropTarget(wxDropTarget *p);
    virtual ~wxIDropTarget();

    // accessors for wxDropTarget
    void SetHwnd(HWND hwnd) { m_hwnd = hwnd; }

    // IDropTarget methods
    STDMETHODIMP DragEnter(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
    STDMETHODIMP DragOver(DWORD, POINTL, LPDWORD);
    STDMETHODIMP DragLeave();
    STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);

    DECLARE_IUNKNOWN_METHODS;

protected:
    IDataObject  *m_pIDataObject; // !NULL between DragEnter and DragLeave/Drop
    wxDropTarget *m_pTarget;      // the real target (we're just a proxy)

    HWND          m_hwnd;         // window we're associated with

    // get default drop effect for given keyboard flags
    static inline DWORD GetDropEffect(DWORD flags);

    DECLARE_NO_COPY_CLASS(wxIDropTarget)
};

// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

static wxDragResult ConvertDragEffectToResult(DWORD dwEffect);
static DWORD ConvertDragResultToEffect(wxDragResult result);

// ============================================================================
// wxIDropTarget implementation
// ============================================================================

// Name    : static wxIDropTarget::GetDropEffect
// Purpose : determine the drop operation from keyboard/mouse state.
// Returns : DWORD combined from DROPEFFECT_xxx constants
// Params  : [in] DWORD flags       kbd & mouse flags as passed to
//                                  IDropTarget methods
// Notes   : We do "move" normally and "copy" if <Ctrl> is pressed,
//           which is the standard behaviour (currently there is no
//           way to redefine it)
DWORD wxIDropTarget::GetDropEffect(DWORD flags)
{
  return flags & MK_CONTROL ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
}

wxIDropTarget::wxIDropTarget(wxDropTarget *pTarget)
{
  m_pTarget      = pTarget;
  m_pIDataObject = NULL;
}

wxIDropTarget::~wxIDropTarget()
{
}

BEGIN_IID_TABLE(wxIDropTarget)
  ADD_IID(Unknown)
  ADD_IID(DropTarget)
END_IID_TABLE;

IMPLEMENT_IUNKNOWN_METHODS(wxIDropTarget)

// Name    : wxIDropTarget::DragEnter
// Purpose : Called when the mouse enters the window (dragging something)
// Returns : S_OK
// Params  : [in] IDataObject *pIDataSource : source data
//           [in] DWORD        grfKeyState  : kbd & mouse state
//           [in] POINTL       pt           : mouse coordinates
//           [out]DWORD       *pdwEffect    : effect flag
// Notes   :
STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
                                      DWORD        grfKeyState,
                                      POINTL       pt,
                                      DWORD       *pdwEffect)
{
    wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::DragEnter"));

    wxASSERT_MSG( m_pIDataObject == NULL,
                  _T("drop target must have data object") );

    // show the list of formats supported by the source data object for the
    // debugging purposes, this is quite useful sometimes - please don't remove
#if 0
    IEnumFORMATETC *penumFmt;
    if ( SUCCEEDED(pIDataSource->EnumFormatEtc(DATADIR_GET, &penumFmt)) )
    {
        FORMATETC fmt;
        while ( penumFmt->Next(1, &fmt, NULL) == S_OK )
        {
            wxLogDebug(_T("Drop source supports format %s"),
                       wxDataObject::GetFormatName(fmt.cfFormat));
        }

        penumFmt->Release();
    }
    else
    {
        wxLogLastError(_T("IDataObject::EnumFormatEtc"));
    }
#endif // 0

    if ( !m_pTarget->IsAcceptedData(pIDataSource) ) {
        // we don't accept this kind of data
        *pdwEffect = DROPEFFECT_NONE;

        return S_OK;
    }

    // get hold of the data object
    m_pIDataObject = pIDataSource;
    m_pIDataObject->AddRef();

    // we need client coordinates to pass to wxWin functions
    if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
    {
        wxLogLastError(wxT("ScreenToClient"));
    }

    // give some visual feedback
    *pdwEffect = ConvertDragResultToEffect(
                    m_pTarget->OnEnter(pt.x, pt.y,
                        ConvertDragEffectToResult(GetDropEffect(grfKeyState))
                    )
                 );

    return S_OK;
}

// Name    : wxIDropTarget::DragOver
// Purpose : Indicates that the mouse was moved inside the window represented
//           by this drop target.
// Returns : S_OK
// Params  : [in] DWORD   grfKeyState     kbd & mouse state
//           [in] POINTL  pt              mouse coordinates
//           [out]LPDWORD pdwEffect       effect flag
// Notes   : We're called on every WM_MOUSEMOVE, so this function should be
//           very efficient.
STDMETHODIMP wxIDropTarget::DragOver(DWORD   grfKeyState,
                                     POINTL  pt,
                                     LPDWORD pdwEffect)
{
    // there are too many of them... wxLogDebug("IDropTarget::DragOver");

    wxDragResult result;
    if ( m_pIDataObject ) {
        result = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
    }
    else {
        // can't accept data anyhow normally
        result = wxDragNone;
    }

    // we need client coordinates to pass to wxWin functions
    if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
    {
        wxLogLastError(wxT("ScreenToClient"));
    }

    *pdwEffect = ConvertDragResultToEffect(
                    m_pTarget->OnDragOver(pt.x, pt.y, result)
                 );

    return S_OK;
}

// Name    : wxIDropTarget::DragLeave
// Purpose : Informs the drop target that the operation has left its window.
// Returns : S_OK
// Notes   : good place to do any clean-up
STDMETHODIMP wxIDropTarget::DragLeave()
{
  wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::DragLeave"));

  // remove the UI feedback
  m_pTarget->OnLeave();

  // release the held object
  RELEASE_AND_NULL(m_pIDataObject);

  return S_OK;
}

// Name    : wxIDropTarget::Drop
// Purpose : Instructs the drop target to paste data that was just now
//           dropped on it.
// Returns : S_OK
// Params  : [in] IDataObject *pIDataSource     the data to paste
//           [in] DWORD        grfKeyState      kbd & mouse state
//           [in] POINTL       pt               where the drop occured?
//           [ouy]DWORD       *pdwEffect        operation effect
// Notes   :
STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
                                 DWORD        grfKeyState,
                                 POINTL       pt,
                                 DWORD       *pdwEffect)
{
    wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::Drop"));

    // TODO I don't know why there is this parameter, but so far I assume
    //      that it's the same we've already got in DragEnter
    wxASSERT( m_pIDataObject == pIDataSource );

    // by default, nothing happens
    *pdwEffect = DROPEFFECT_NONE;

    // we need client coordinates to pass to wxWin functions
    if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
    {
        wxLogLastError(wxT("ScreenToClient"));
    }

    // first ask the drop target if it wants data
    if ( m_pTarget->OnDrop(pt.x, pt.y) ) {
        // it does, so give it the data source
        m_pTarget->SetDataSource(pIDataSource);

        // and now it has the data
        wxDragResult rc = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
        rc = m_pTarget->OnData(pt.x, pt.y, rc);
        if ( wxIsDragResultOk(rc) ) {
            // operation succeeded
            *pdwEffect = ConvertDragResultToEffect(rc);
        }
        //else: *pdwEffect is already DROPEFFECT_NONE
    }
    //else: OnDrop() returned FALSE, no need to copy data

    // release the held object
    RELEASE_AND_NULL(m_pIDataObject);

    return S_OK;
}

// ============================================================================
// wxDropTarget implementation
// ============================================================================

// ----------------------------------------------------------------------------
// ctor/dtor
// ----------------------------------------------------------------------------

wxDropTarget::wxDropTarget(wxDataObject *dataObj)
            : wxDropTargetBase(dataObj)
{
    // create an IDropTarget implementation which will notify us about d&d
    // operations.
    m_pIDropTarget = new wxIDropTarget(this);
    m_pIDropTarget->AddRef();
}

wxDropTarget::~wxDropTarget()
{
    ReleaseInterface(m_pIDropTarget);
}

// ----------------------------------------------------------------------------
// [un]register drop handler
// ----------------------------------------------------------------------------

bool wxDropTarget::Register(WXHWND hwnd)
{
    // FIXME
    // RegisterDragDrop not available on Windows CE >= 400?
    // Or maybe we can dynamically load them from ceshell.dll
    // or similar.
#if defined(__WXWINCE__) && _WIN32_WCE >= 400
    return FALSE;
#else
    HRESULT hr;

    // May exist in later WinCE versions
#ifndef __WXWINCE__
    hr = ::CoLockObjectExternal(m_pIDropTarget, TRUE, FALSE);
    if ( FAILED(hr) ) {
        wxLogApiError(wxT("CoLockObjectExternal"), hr);
        return FALSE;
    }
#endif

    hr = ::RegisterDragDrop((HWND) hwnd, m_pIDropTarget);
    if ( FAILED(hr) ) {
    // May exist in later WinCE versions
#ifndef __WXWINCE__
        ::CoLockObjectExternal(m_pIDropTarget, FALSE, FALSE);
#endif
        wxLogApiError(wxT("RegisterDragDrop"), hr);
        return FALSE;
    }

    // we will need the window handle for coords transformation later
    m_pIDropTarget->SetHwnd((HWND)hwnd);

    return TRUE;
#endif
}

void wxDropTarget::Revoke(WXHWND hwnd)
{
#if defined(__WXWINCE__) && _WIN32_WCE >= 400
    // Not available, see note above
#else
    HRESULT hr = ::RevokeDragDrop((HWND) hwnd);

    if ( FAILED(hr) ) {
        wxLogApiError(wxT("RevokeDragDrop"), hr);
    }

    // May exist in later WinCE versions
#ifndef __WXWINCE__
    ::CoLockObjectExternal(m_pIDropTarget, FALSE, TRUE);
#endif

    m_pIDropTarget->SetHwnd(0);
#endif
}

// ----------------------------------------------------------------------------
// base class pure virtuals
// ----------------------------------------------------------------------------

// OnDrop() is called only if we previously returned TRUE from
// IsAcceptedData(), so no need to check anything here
bool wxDropTarget::OnDrop(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
{
    return TRUE;
}

// copy the data from the data source to the target data object
bool wxDropTarget::GetData()
{
    wxDataFormat format = GetSupportedFormat(m_pIDataSource);
    if ( format == wxDF_INVALID ) {
        // this is strange because IsAcceptedData() succeeded previously!
        wxFAIL_MSG(wxT("strange - did supported formats list change?"));

        return FALSE;
    }

    STGMEDIUM stm;
    FORMATETC fmtMemory;
    fmtMemory.cfFormat  = format;
    fmtMemory.ptd       = NULL;
    fmtMemory.dwAspect  = DVASPECT_CONTENT;
    fmtMemory.lindex    = -1;
    fmtMemory.tymed     = TYMED_HGLOBAL;  // TODO to add other media

    bool rc = FALSE;

    HRESULT hr = m_pIDataSource->GetData(&fmtMemory, &stm);
    if ( SUCCEEDED(hr) ) {
        IDataObject *dataObject = m_dataObject->GetInterface();

        hr = dataObject->SetData(&fmtMemory, &stm, TRUE);
        if ( SUCCEEDED(hr) ) {
            rc = TRUE;
        }
        else {
            wxLogApiError(wxT("IDataObject::SetData()"), hr);
        }
    }
    else {
        wxLogApiError(wxT("IDataObject::GetData()"), hr);
    }

    return rc;
}

// ----------------------------------------------------------------------------
// callbacks used by wxIDropTarget
// ----------------------------------------------------------------------------

// we need a data source, so wxIDropTarget gives it to us using this function
void wxDropTarget::SetDataSource(IDataObject *pIDataSource)
{
    m_pIDataSource = pIDataSource;
}

// determine if we accept data of this type
bool wxDropTarget::IsAcceptedData(IDataObject *pIDataSource) const
{
    return GetSupportedFormat(pIDataSource) != wxDF_INVALID;
}

// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------

wxDataFormat wxDropTarget::GetSupportedFormat(IDataObject *pIDataSource) const
{
    // this strucutre describes a data of any type (first field will be
    // changing) being passed through global memory block.
    static FORMATETC s_fmtMemory = {
        0,
        NULL,
        DVASPECT_CONTENT,
        -1,
        TYMED_HGLOBAL       // TODO is it worth supporting other tymeds here?
    };

    // get the list of supported formats
    size_t nFormats = m_dataObject->GetFormatCount(wxDataObject::Set);
    wxDataFormat format;
    wxDataFormat *formats;
    formats = nFormats == 1 ? &format :  new wxDataFormat[nFormats];

    m_dataObject->GetAllFormats(formats, wxDataObject::Set);

    // cycle through all supported formats
    size_t n;
    for ( n = 0; n < nFormats; n++ ) {
        s_fmtMemory.cfFormat = formats[n];

        // NB: don't use SUCCEEDED macro here: QueryGetData returns S_FALSE
        //     for file drag and drop (format == CF_HDROP)
        if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
            format = formats[n];

            break;
        }
    }

    if ( formats != &format ) {
        // free memory if we allocated it
        delete [] formats;
    }

    return n < nFormats ? format : wxFormatInvalid;
}

// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

static wxDragResult ConvertDragEffectToResult(DWORD dwEffect)
{
    switch ( dwEffect ) {
        case DROPEFFECT_COPY:
            return wxDragCopy;

        case DROPEFFECT_LINK:
            return wxDragLink;

        case DROPEFFECT_MOVE:
            return wxDragMove;

        default:
            wxFAIL_MSG(wxT("invalid value in ConvertDragEffectToResult"));
            // fall through

        case DROPEFFECT_NONE:
            return wxDragNone;
    }
}

static DWORD ConvertDragResultToEffect(wxDragResult result)
{
    switch ( result ) {
        case wxDragCopy:
            return DROPEFFECT_COPY;

        case wxDragLink:
            return DROPEFFECT_LINK;

        case wxDragMove:
            return DROPEFFECT_MOVE;

        default:
            wxFAIL_MSG(wxT("invalid value in ConvertDragResultToEffect"));
            // fall through

        case wxDragNone:
            return DROPEFFECT_NONE;
    }
}

#endif
 // wxUSE_DRAG_AND_DROP
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: ole/droptgt.cpp
	3	// Purpose: wxDropTarget implementation
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created:
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// Declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	21	#pragma implementation "droptgt.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#if defined(__BORLANDC__)
	28	#pragma hdrstop
	29	#endif
	30
	31	#include "wx/setup.h"
	32
	33	#if wxUSE_OLE && wxUSE_DRAG_AND_DROP
	34
	35	#include "wx/msw/private.h"
	36	#include "wx/log.h"
	37
	38	#ifdef __WXWINCE__
	39	#include <winreg.h>
	40	#include <ole2.h>
	41	#endif
	42
	43	#ifdef __WIN32__
	44	#if !defined(__GNUWIN32__) \|\| wxUSE_NORLANDER_HEADERS
	45	#if wxCHECK_W32API_VERSION( 1, 0 )
	46	#include "wx/msw/wrapwin.h"
	47	#endif
	48	#include <shlobj.h> // for DROPFILES structure
	49	#endif
	50	#else
	51	#include <shellapi.h>
	52	#endif
	53
	54	#include "wx/dnd.h"
	55
	56	#include "wx/msw/ole/oleutils.h"
	57
	58	// ----------------------------------------------------------------------------
	59	// IDropTarget interface: forward all interesting things to wxDropTarget
	60	// (the name is unfortunate, but wx_I_DropTarget is not at all the same thing
	61	// as wxDropTarget which is 'public' class, while this one is private)
	62	// ----------------------------------------------------------------------------
	63
	64	class wxIDropTarget : public IDropTarget
	65	{
	66	public:
	67	wxIDropTarget(wxDropTarget *p);
	68	virtual ~wxIDropTarget();
	69
	70	// accessors for wxDropTarget
	71	void SetHwnd(HWND hwnd) { m_hwnd = hwnd; }
	72
	73	// IDropTarget methods
	74	STDMETHODIMP DragEnter(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
	75	STDMETHODIMP DragOver(DWORD, POINTL, LPDWORD);
	76	STDMETHODIMP DragLeave();
	77	STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
	78
	79	DECLARE_IUNKNOWN_METHODS;
	80
	81	protected:
	82	IDataObject *m_pIDataObject; // !NULL between DragEnter and DragLeave/Drop
	83	wxDropTarget *m_pTarget; // the real target (we're just a proxy)
	84
	85	HWND m_hwnd; // window we're associated with
	86
	87	// get default drop effect for given keyboard flags
	88	static inline DWORD GetDropEffect(DWORD flags);
	89
	90	DECLARE_NO_COPY_CLASS(wxIDropTarget)
	91	};
	92
	93	// ----------------------------------------------------------------------------
	94	// private functions
	95	// ----------------------------------------------------------------------------
	96
	97	static wxDragResult ConvertDragEffectToResult(DWORD dwEffect);
	98	static DWORD ConvertDragResultToEffect(wxDragResult result);
	99
	100	// ============================================================================
	101	// wxIDropTarget implementation
	102	// ============================================================================
	103
	104	// Name : static wxIDropTarget::GetDropEffect
	105	// Purpose : determine the drop operation from keyboard/mouse state.
	106	// Returns : DWORD combined from DROPEFFECT_xxx constants
	107	// Params : [in] DWORD flags kbd & mouse flags as passed to
	108	// IDropTarget methods
	109	// Notes : We do "move" normally and "copy" if <Ctrl> is pressed,
	110	// which is the standard behaviour (currently there is no
	111	// way to redefine it)
	112	DWORD wxIDropTarget::GetDropEffect(DWORD flags)
	113	{
	114	return flags & MK_CONTROL ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
	115	}
	116
	117	wxIDropTarget::wxIDropTarget(wxDropTarget *pTarget)
	118	{
	119	m_pTarget = pTarget;
	120	m_pIDataObject = NULL;
	121	}
	122
	123	wxIDropTarget::~wxIDropTarget()
	124	{
	125	}
	126
	127	BEGIN_IID_TABLE(wxIDropTarget)
	128	ADD_IID(Unknown)
	129	ADD_IID(DropTarget)
	130	END_IID_TABLE;
	131
	132	IMPLEMENT_IUNKNOWN_METHODS(wxIDropTarget)
	133
	134	// Name : wxIDropTarget::DragEnter
	135	// Purpose : Called when the mouse enters the window (dragging something)
	136	// Returns : S_OK
	137	// Params : [in] IDataObject *pIDataSource : source data
	138	// [in] DWORD grfKeyState : kbd & mouse state
	139	// [in] POINTL pt : mouse coordinates
	140	// [out]DWORD *pdwEffect : effect flag
	141	// Notes :
	142	STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
	143	DWORD grfKeyState,
	144	POINTL pt,
	145	DWORD *pdwEffect)
	146	{
	147	wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::DragEnter"));
	148
	149	wxASSERT_MSG( m_pIDataObject == NULL,
	150	_T("drop target must have data object") );
	151
	152	// show the list of formats supported by the source data object for the
	153	// debugging purposes, this is quite useful sometimes - please don't remove
	154	#if 0
	155	IEnumFORMATETC *penumFmt;
	156	if ( SUCCEEDED(pIDataSource->EnumFormatEtc(DATADIR_GET, &penumFmt)) )
	157	{
	158	FORMATETC fmt;
	159	while ( penumFmt->Next(1, &fmt, NULL) == S_OK )
	160	{
	161	wxLogDebug(_T("Drop source supports format %s"),
	162	wxDataObject::GetFormatName(fmt.cfFormat));
	163	}
	164
	165	penumFmt->Release();
	166	}
	167	else
	168	{
	169	wxLogLastError(_T("IDataObject::EnumFormatEtc"));
	170	}
	171	#endif // 0
	172
	173	if ( !m_pTarget->IsAcceptedData(pIDataSource) ) {
	174	// we don't accept this kind of data
	175	*pdwEffect = DROPEFFECT_NONE;
	176
	177	return S_OK;
	178	}
	179
	180	// get hold of the data object
	181	m_pIDataObject = pIDataSource;
	182	m_pIDataObject->AddRef();
	183
	184	// we need client coordinates to pass to wxWin functions
	185	if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
	186	{
	187	wxLogLastError(wxT("ScreenToClient"));
	188	}
	189
	190	// give some visual feedback
	191	*pdwEffect = ConvertDragResultToEffect(
	192	m_pTarget->OnEnter(pt.x, pt.y,
	193	ConvertDragEffectToResult(GetDropEffect(grfKeyState))
	194	)
	195	);
	196
	197	return S_OK;
	198	}
	199
	200	// Name : wxIDropTarget::DragOver
	201	// Purpose : Indicates that the mouse was moved inside the window represented
	202	// by this drop target.
	203	// Returns : S_OK
	204	// Params : [in] DWORD grfKeyState kbd & mouse state
	205	// [in] POINTL pt mouse coordinates
	206	// [out]LPDWORD pdwEffect effect flag
	207	// Notes : We're called on every WM_MOUSEMOVE, so this function should be
	208	// very efficient.
	209	STDMETHODIMP wxIDropTarget::DragOver(DWORD grfKeyState,
	210	POINTL pt,
	211	LPDWORD pdwEffect)
	212	{
	213	// there are too many of them... wxLogDebug("IDropTarget::DragOver");
	214
	215	wxDragResult result;
	216	if ( m_pIDataObject ) {
	217	result = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
	218	}
	219	else {
	220	// can't accept data anyhow normally
	221	result = wxDragNone;
	222	}
	223
	224	// we need client coordinates to pass to wxWin functions
	225	if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
	226	{
	227	wxLogLastError(wxT("ScreenToClient"));
	228	}
	229
	230	*pdwEffect = ConvertDragResultToEffect(
	231	m_pTarget->OnDragOver(pt.x, pt.y, result)
	232	);
	233
	234	return S_OK;
	235	}
	236
	237	// Name : wxIDropTarget::DragLeave
	238	// Purpose : Informs the drop target that the operation has left its window.
	239	// Returns : S_OK
	240	// Notes : good place to do any clean-up
	241	STDMETHODIMP wxIDropTarget::DragLeave()
	242	{
	243	wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::DragLeave"));
	244
	245	// remove the UI feedback
	246	m_pTarget->OnLeave();
	247
	248	// release the held object
	249	RELEASE_AND_NULL(m_pIDataObject);
	250
	251	return S_OK;
	252	}
	253
	254	// Name : wxIDropTarget::Drop
	255	// Purpose : Instructs the drop target to paste data that was just now
	256	// dropped on it.
	257	// Returns : S_OK
	258	// Params : [in] IDataObject *pIDataSource the data to paste
	259	// [in] DWORD grfKeyState kbd & mouse state
	260	// [in] POINTL pt where the drop occured?
	261	// [ouy]DWORD *pdwEffect operation effect
	262	// Notes :
	263	STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
	264	DWORD grfKeyState,
	265	POINTL pt,
	266	DWORD *pdwEffect)
	267	{
	268	wxLogTrace(wxTRACE_OleCalls, wxT("IDropTarget::Drop"));
	269
	270	// TODO I don't know why there is this parameter, but so far I assume
	271	// that it's the same we've already got in DragEnter
	272	wxASSERT( m_pIDataObject == pIDataSource );
	273
	274	// by default, nothing happens
	275	*pdwEffect = DROPEFFECT_NONE;
	276
	277	// we need client coordinates to pass to wxWin functions
	278	if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
	279	{
	280	wxLogLastError(wxT("ScreenToClient"));
	281	}
	282
	283	// first ask the drop target if it wants data
	284	if ( m_pTarget->OnDrop(pt.x, pt.y) ) {
	285	// it does, so give it the data source
	286	m_pTarget->SetDataSource(pIDataSource);
	287
	288	// and now it has the data
	289	wxDragResult rc = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
	290	rc = m_pTarget->OnData(pt.x, pt.y, rc);
	291	if ( wxIsDragResultOk(rc) ) {
	292	// operation succeeded
	293	*pdwEffect = ConvertDragResultToEffect(rc);
	294	}
	295	//else: *pdwEffect is already DROPEFFECT_NONE
	296	}
	297	//else: OnDrop() returned FALSE, no need to copy data
	298
	299	// release the held object
	300	RELEASE_AND_NULL(m_pIDataObject);
	301
	302	return S_OK;
	303	}
	304
	305	// ============================================================================
	306	// wxDropTarget implementation
	307	// ============================================================================
	308
	309	// ----------------------------------------------------------------------------
	310	// ctor/dtor
	311	// ----------------------------------------------------------------------------
	312
	313	wxDropTarget::wxDropTarget(wxDataObject *dataObj)
	314	: wxDropTargetBase(dataObj)
	315	{
	316	// create an IDropTarget implementation which will notify us about d&d
	317	// operations.
	318	m_pIDropTarget = new wxIDropTarget(this);
	319	m_pIDropTarget->AddRef();
	320	}
	321
	322	wxDropTarget::~wxDropTarget()
	323	{
	324	ReleaseInterface(m_pIDropTarget);
	325	}
	326
	327	// ----------------------------------------------------------------------------
	328	// [un]register drop handler
	329	// ----------------------------------------------------------------------------
	330
	331	bool wxDropTarget::Register(WXHWND hwnd)
	332	{
	333	// FIXME
	334	// RegisterDragDrop not available on Windows CE >= 400?
	335	// Or maybe we can dynamically load them from ceshell.dll
	336	// or similar.
	337	#if defined(__WXWINCE__) && _WIN32_WCE >= 400
	338	return FALSE;
	339	#else
	340	HRESULT hr;
	341
	342	// May exist in later WinCE versions
	343	#ifndef __WXWINCE__
	344	hr = ::CoLockObjectExternal(m_pIDropTarget, TRUE, FALSE);
	345	if ( FAILED(hr) ) {
	346	wxLogApiError(wxT("CoLockObjectExternal"), hr);
	347	return FALSE;
	348	}
	349	#endif
	350
	351	hr = ::RegisterDragDrop((HWND) hwnd, m_pIDropTarget);
	352	if ( FAILED(hr) ) {
	353	// May exist in later WinCE versions
	354	#ifndef __WXWINCE__
	355	::CoLockObjectExternal(m_pIDropTarget, FALSE, FALSE);
	356	#endif
	357	wxLogApiError(wxT("RegisterDragDrop"), hr);
	358	return FALSE;
	359	}
	360
	361	// we will need the window handle for coords transformation later
	362	m_pIDropTarget->SetHwnd((HWND)hwnd);
	363
	364	return TRUE;
	365	#endif
	366	}
	367
	368	void wxDropTarget::Revoke(WXHWND hwnd)
	369	{
	370	#if defined(__WXWINCE__) && _WIN32_WCE >= 400
	371	// Not available, see note above
	372	#else
	373	HRESULT hr = ::RevokeDragDrop((HWND) hwnd);
	374
	375	if ( FAILED(hr) ) {
	376	wxLogApiError(wxT("RevokeDragDrop"), hr);
	377	}
	378
	379	// May exist in later WinCE versions
	380	#ifndef __WXWINCE__
	381	::CoLockObjectExternal(m_pIDropTarget, FALSE, TRUE);
	382	#endif
	383
	384	m_pIDropTarget->SetHwnd(0);
	385	#endif
	386	}
	387
	388	// ----------------------------------------------------------------------------
	389	// base class pure virtuals
	390	// ----------------------------------------------------------------------------
	391
	392	// OnDrop() is called only if we previously returned TRUE from
	393	// IsAcceptedData(), so no need to check anything here
	394	bool wxDropTarget::OnDrop(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
	395	{
	396	return TRUE;
	397	}
	398
	399	// copy the data from the data source to the target data object
	400	bool wxDropTarget::GetData()
	401	{
	402	wxDataFormat format = GetSupportedFormat(m_pIDataSource);
	403	if ( format == wxDF_INVALID ) {
	404	// this is strange because IsAcceptedData() succeeded previously!
	405	wxFAIL_MSG(wxT("strange - did supported formats list change?"));
	406
	407	return FALSE;
	408	}
	409
	410	STGMEDIUM stm;
	411	FORMATETC fmtMemory;
	412	fmtMemory.cfFormat = format;
	413	fmtMemory.ptd = NULL;
	414	fmtMemory.dwAspect = DVASPECT_CONTENT;
	415	fmtMemory.lindex = -1;
	416	fmtMemory.tymed = TYMED_HGLOBAL; // TODO to add other media
	417
	418	bool rc = FALSE;
	419
	420	HRESULT hr = m_pIDataSource->GetData(&fmtMemory, &stm);
	421	if ( SUCCEEDED(hr) ) {
	422	IDataObject *dataObject = m_dataObject->GetInterface();
	423
	424	hr = dataObject->SetData(&fmtMemory, &stm, TRUE);
	425	if ( SUCCEEDED(hr) ) {
	426	rc = TRUE;
	427	}
	428	else {
	429	wxLogApiError(wxT("IDataObject::SetData()"), hr);
	430	}
	431	}
	432	else {
	433	wxLogApiError(wxT("IDataObject::GetData()"), hr);
	434	}
	435
	436	return rc;
	437	}
	438
	439	// ----------------------------------------------------------------------------
	440	// callbacks used by wxIDropTarget
	441	// ----------------------------------------------------------------------------
	442
	443	// we need a data source, so wxIDropTarget gives it to us using this function
	444	void wxDropTarget::SetDataSource(IDataObject *pIDataSource)
	445	{
	446	m_pIDataSource = pIDataSource;
	447	}
	448
	449	// determine if we accept data of this type
	450	bool wxDropTarget::IsAcceptedData(IDataObject *pIDataSource) const
	451	{
	452	return GetSupportedFormat(pIDataSource) != wxDF_INVALID;
	453	}
	454
	455	// ----------------------------------------------------------------------------
	456	// helper functions
	457	// ----------------------------------------------------------------------------
	458
	459	wxDataFormat wxDropTarget::GetSupportedFormat(IDataObject *pIDataSource) const
	460	{
	461	// this strucutre describes a data of any type (first field will be
	462	// changing) being passed through global memory block.
	463	static FORMATETC s_fmtMemory = {
	464	0,
	465	NULL,
	466	DVASPECT_CONTENT,
	467	-1,
	468	TYMED_HGLOBAL // TODO is it worth supporting other tymeds here?
	469	};
	470
	471	// get the list of supported formats
	472	size_t nFormats = m_dataObject->GetFormatCount(wxDataObject::Set);
	473	wxDataFormat format;
	474	wxDataFormat *formats;
	475	formats = nFormats == 1 ? &format : new wxDataFormat[nFormats];
	476
	477	m_dataObject->GetAllFormats(formats, wxDataObject::Set);
	478
	479	// cycle through all supported formats
	480	size_t n;
	481	for ( n = 0; n < nFormats; n++ ) {
	482	s_fmtMemory.cfFormat = formats[n];
	483
	484	// NB: don't use SUCCEEDED macro here: QueryGetData returns S_FALSE
	485	// for file drag and drop (format == CF_HDROP)
	486	if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
	487	format = formats[n];
	488
	489	break;
	490	}
	491	}
	492
	493	if ( formats != &format ) {
	494	// free memory if we allocated it
	495	delete [] formats;
	496	}
	497
	498	return n < nFormats ? format : wxFormatInvalid;
	499	}
	500
	501	// ----------------------------------------------------------------------------
	502	// private functions
	503	// ----------------------------------------------------------------------------
	504
	505	static wxDragResult ConvertDragEffectToResult(DWORD dwEffect)
	506	{
	507	switch ( dwEffect ) {
	508	case DROPEFFECT_COPY:
	509	return wxDragCopy;
	510
	511	case DROPEFFECT_LINK:
	512	return wxDragLink;
	513
	514	case DROPEFFECT_MOVE:
	515	return wxDragMove;
	516
	517	default:
	518	wxFAIL_MSG(wxT("invalid value in ConvertDragEffectToResult"));
	519	// fall through
	520
	521	case DROPEFFECT_NONE:
	522	return wxDragNone;
	523	}
	524	}
	525
	526	static DWORD ConvertDragResultToEffect(wxDragResult result)
	527	{
	528	switch ( result ) {
	529	case wxDragCopy:
	530	return DROPEFFECT_COPY;
	531
	532	case wxDragLink:
	533	return DROPEFFECT_LINK;
	534
	535	case wxDragMove:
	536	return DROPEFFECT_MOVE;
	537
	538	default:
	539	wxFAIL_MSG(wxT("invalid value in ConvertDragResultToEffect"));
	540	// fall through
	541
	542	case wxDragNone:
	543	return DROPEFFECT_NONE;
	544	}
	545	}
	546
	547	#endif
	548	// wxUSE_DRAG_AND_DROP