src/os2/dnd.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        dnd.cpp
// Purpose:     wxDropTarget, wxDropSource, wxDataObject implementation
// Author:      David Webster
// Modified by:
// Created:     10/21/99
// RCS-ID:      $Id$
// Copyright:   (c) 1998 AUTHOR
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "dnd.h"
#endif

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

#if wxUSE_DRAG_AND_DROP

#include "wx/window.h"
#include "wx/app.h"
#include "wx/gdicmn.h"
#include "wx/dnd.h"

#define INCL_PM
#define INCL_DOS
#include <os2.h>

// ----------------------------------------------------------------------------
// global
// ----------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////////////
// Private functions
/////////////////////////////////////////////////////////////////////////////

#if 0
static wxDragResult ConvertDragEffectToResult (
  DWORD                             dwEffect
)
{
    switch (dwEffect)
    {
        case DO_COPY:
            return wxDragCopy;

        case DO_LINK:
            return wxDragLink;

        case DO_MOVE:
            return wxDragMove;

        default:
        case DO_DEFAULT:
            return wxDragNone;
    }
} // end of ConvertDragEffectToResult

static DWORD ConvertDragResultToEffect (
  wxDragResult                      eResult
)
{
    switch (eResult)
    {
        case wxDragCopy:
            return DO_COPY;

        case wxDragLink:
            return DO_LINK;

        case wxDragMove:
            return DO_MOVE;

        default:
        case wxDragNone:
            return DO_DEFAULT;
    }
} // end of ConvertDragResultToEffect
#endif

class CIDropTarget
{
public:
    CIDropTarget(wxDropTarget* pTarget)
    {
        m_pTarget   = pTarget;
        m_pDragItem = NULL;
    }
    virtual ~CIDropTarget() { }

    //
    // Accessors for CDropTarget
    //
    void      Free(void) { ::DrgFreeDraginfo(m_pDragInfo); }
    PDRAGINFO GetDataSource(void) { return m_pDragInfo; }
    void      SetDataSource(PDRAGINFO pDragInfo) { m_pDragInfo = pDragInfo; }
    void      SetHWND(HWND hWnd) { m_hWnd = hWnd; }

    //
    // CIDropTarget methods
    //
           bool    DragLeave(void);
           MRESULT DragOver(void);
           MRESULT Drop(void);

protected:

    PDRAGINFO                       m_pDragInfo;
    PDRAGITEM                       m_pDragItem; // !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
}; // end of CLASS CIDropTarget

bool CIDropTarget::DragLeave()
{
    //
    // Remove the UI feedback
    //
    m_pTarget->OnLeave();

    //
    // Release the held object
    //
    Free();
    return true;
} // end of CIDropTarget::DragLeave

MRESULT CIDropTarget::DragOver ()
{
    char                            zBuffer[128];
    ULONG                           ulBytes;
    USHORT                          uOp = 0;
    USHORT                          uIndicator;
    ULONG                           ulItems;
    ULONG                           i;

    ::DrgAccessDraginfo(m_pDragInfo);
    switch(m_pDragInfo->usOperation)
    {
        case DO_UNKNOWN:
            Free();
            return (MRFROM2SHORT(DOR_NODROPOP, 0));

        case DO_DEFAULT:
            m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, 0);
            ulBytes     = ::DrgQueryStrName( m_pDragItem->hstrContainerName
                                            ,128
                                            ,zBuffer
                                           );
            if (!ulBytes)
                return (MRFROM2SHORT(DOR_NODROPOP, 0));
            else
                uOp = DO_MOVE;
            break;

        case DO_COPY:
        case DO_MOVE:
            uOp = m_pDragInfo->usOperation;
            break;
    }
    uIndicator = DOR_DROP;
    ulItems = (ULONG)::DrgQueryDragitemCount(m_pDragInfo);
    for (i = 0; i < ulItems; i++)
    {
        m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, i);
        if (((m_pDragItem->fsSupportedOps & DO_COPYABLE) &&
             (uOp == (USHORT)DO_COPY))                   ||
            ((m_pDragItem->fsSupportedOps & DO_MOVEABLE) &&
             (uOp == (USHORT)DO_COPY)))
        {
            if (::DrgVerifyRMF(m_pDragItem, "DRM_OS2FILE", "DRF_UNKNOWN"))
                uIndicator = (USHORT)DOR_DROP;
            else
                uIndicator = (USHORT)DOR_NEVERDROP;
        }
    }
    Free();
    return (MRFROM2SHORT(uIndicator, uOp));
} // end of CIDropTarget::DragOver

// #pragma page   "CIDropTarget::Drop"
/////////////////////////////////////////////////////////////////////////////
//
// CIDropTarget::Drop
//
//   Instructs the drop target to paste data that was just now dropped on it.
//
// PARAMETERS
//   pIDataSource -- the data to paste
//   dwKeyState   -- kbd & mouse state
//   pt           -- mouse coordinates
//   pdwEffect    -- effect flag
//
// RETURN VALUE
//  STDMETHODIMP S_OK
//
/////////////////////////////////////////////////////////////////////////////
MRESULT CIDropTarget::Drop ()
{
    char                            zBuffer[128];
    ULONG                           ulBytes;
    USHORT                          uOp = 0;
    USHORT                          uIndicator;
    ULONG                           ulItems;
    ULONG                           i;

    ::DrgAccessDraginfo(m_pDragInfo);
    switch(m_pDragInfo->usOperation)
    {
        case DO_UNKNOWN:
            Free();
            return (MRFROM2SHORT(DOR_NODROPOP, 0));

        case DO_DEFAULT:
            m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, 0);
            ulBytes     = ::DrgQueryStrName( m_pDragItem->hstrContainerName
                                            ,128
                                            ,zBuffer
                                           );
            if (!ulBytes)
                return (MRFROM2SHORT(DOR_NODROPOP, 0));
            else
                uOp = DO_MOVE;
            break;

        case DO_COPY:
        case DO_MOVE:
            uOp = m_pDragInfo->usOperation;
            break;
    }
    uIndicator = DOR_DROP;
    ulItems = (ULONG)::DrgQueryDragitemCount(m_pDragInfo);
    for (i = 0; i < ulItems; i++)
    {
        m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, i);
        if (((m_pDragItem->fsSupportedOps & DO_COPYABLE) &&
             (uOp == (USHORT)DO_COPY))                   ||
            ((m_pDragItem->fsSupportedOps & DO_MOVEABLE) &&
             (uOp == (USHORT)DO_COPY)))
        {
            if (::DrgVerifyRMF(m_pDragItem, "DRM_OS2FILE", "DRF_UNKNOWN"))
                uIndicator = (USHORT)DOR_DROP;
            else
                uIndicator = (USHORT)DOR_NEVERDROP;
        }
    }

    //
    // First ask the drop target if it wants data
    //
    if (m_pTarget->OnDrop( m_pDragInfo->xDrop
                          ,m_pDragInfo->yDrop
                         ))
    {
        wxDragResult                 eRc = wxDragNone;

        //
        // And now it has the data
        //
        eRc = m_pTarget->OnData( m_pDragInfo->xDrop
                                ,m_pDragInfo->yDrop
                                ,eRc
                               );
    }
    //else: OnDrop() returned false, no need to copy data

    //
    // Release the held object
    //
    Free();
    return (MRFROM2SHORT(uIndicator, uOp));
} // end of CIDropTarget::Drop

// ----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------

wxDropTarget::wxDropTarget (
  wxDataObject*                     pDataObject
)
{
    m_dataObject  = pDataObject;
    m_pDropTarget = new CIDropTarget(this);
} // end of wxDropTarget::wxDropTarget

wxDropTarget::~wxDropTarget()
{
    Release();
} // end of wxDropTarget::~wxDropTarget

bool wxDropTarget::GetData ()
{
    wxDataFormat                    vFormat = GetSupportedFormat(m_pDropTarget->GetDataSource());

    if (vFormat == wxDF_INVALID)
    {
        return false;
    }
    //
    // Under OS/2 we already have the data via the attached DRAGITEM's
    //
    return true;
} // end of wxDropTarget::GetData

wxDataFormat wxDropTarget::GetSupportedFormat (
  PDRAGINFO                         pDataSource
) const
{
    PDRAGITEM                       pDragItem;
    wxDataFormat                    vFormat;
    wxDataFormat*                   pFormats;
    ULONG                           ulFormats = m_dataObject->GetFormatCount(wxDataObject::Set);
    ULONG                           ulItems = (ULONG)::DrgQueryDragitemCount(pDataSource);
    ULONG                           i;
    ULONG                           n;
    wxString                        sMechanism;
    wxString                        sFormat;
    bool                            bValid = false;

    pFormats = ulFormats == 1 ? &vFormat :  new wxDataFormat[ulFormats];
    m_dataObject->GetAllFormats( pFormats
                                ,wxDataObject::Set
                               );

    for (n = 0; n < ulFormats; n++)
    {
        switch(pFormats[n].GetType())
        {
            case wxDF_TEXT:
            case wxDF_FILENAME:
            case wxDF_HTML:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_TEXT");
                break;

            case wxDF_OEMTEXT:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_OEMTEXT");
                break;

            case wxDF_BITMAP:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_BITMAP");
                break;

            case wxDF_METAFILE:
            case wxDF_ENHMETAFILE:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_METAFILE");
                break;

            case wxDF_TIFF:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_TIFF");
                break;

            case wxDF_SYLK:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_SYLK");
                break;

            case wxDF_DIF:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_DIF");
                break;

            case wxDF_DIB:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_DIB");
                break;

            case wxDF_PALETTE:
            case wxDF_PENDATA:
            case wxDF_RIFF:
            case wxDF_WAVE:
            case wxDF_UNICODETEXT:
            case wxDF_LOCALE:
                sMechanism = _T("DRM_OS2FILE");
                sFormat    = _T("DRF_UNKNOWN");
                break;

            case wxDF_PRIVATE:
                sMechanism = _T("DRM_OBJECT");
                sFormat    = _T("DRF_UNKNOWN");
                break;
        }
        for (i = 0; i < ulItems; i++)
        {
            pDragItem = ::DrgQueryDragitemPtr(pDataSource, i);
            if (::DrgVerifyRMF(pDragItem, (PSZ)sMechanism.c_str(), (PSZ)sFormat.c_str()))
            {
                bValid = true;
                break;
            }
        }
        if (bValid)
        {
            vFormat = pFormats[n];
            break;
        }
    }
    if (pFormats != &vFormat)
    {
        //
        // Free memory if we allocated it
        //
        delete [] pFormats;
    }
    return (n < ulFormats ? vFormat : wxFormatInvalid);
} // end of wxDropTarget::GetSupportedFormat

bool wxDropTarget::IsAcceptedData (
  PDRAGINFO                         pDataSource
) const
{
    return (GetSupportedFormat(pDataSource) != wxDF_INVALID);
} // end of wxDropTarget::IsAcceptedData

void wxDropTarget::Release ()
{
    m_pDropTarget->Free();
} // end of wxDropTarget::Release


wxDragResult wxDropTarget::OnData (
  wxCoord                           WXUNUSED(vX)
, wxCoord                           WXUNUSED(y)
, wxDragResult                      WXUNUSED(vResult)
)
{
    return (wxDragResult)0;
} // end of wxDropTarget::OnData

bool wxDropTarget::OnDrop (
  wxCoord                           WXUNUSED(x)
, wxCoord                           WXUNUSED(y)
)
{
    return true;
} // end of wxDropTarget::OnDrop

//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------

wxDropSource::wxDropSource (
  wxWindow*                         pWin
)
{
    Init();
} // end of wxDropSource::wxDropSource

wxDropSource::wxDropSource (
  wxDataObject&                     rData
, wxWindow*                         pWin
)
{
    Init();
    SetData(rData);
} // end of wxDropSource::wxDropSource

wxDropSource::~wxDropSource ()
{
    ::DrgFreeDraginfo(m_pDragInfo);
} // end of wxDropSource::~wxDropSource

wxDragResult wxDropSource::DoDragDrop (
  int                              WXUNUSED(flags)
)
{
    //
    // Need to specify drag items in derived classes that know their data types
    // before calling DoDragDrop
    //
    if (::DrgDrag( m_pWindow->GetHWND()
                  ,m_pDragInfo
                  ,&m_vDragImage
                  ,m_ulItems
                  ,VK_BUTTON2
                  ,NULL
                 ) != NULLHANDLE)
    {
        switch(m_pDragInfo->usOperation)
        {
            case DO_COPY:
                return wxDragCopy;

            case DO_MOVE:
                return wxDragCopy;

            case DO_LINK:
                return wxDragCopy;

            default:
                return wxDragNone;
        }
    }
    return wxDragError;
} // end of wxDropSource::DoDragDrop

bool wxDropSource::GiveFeedback (
  wxDragResult                      eEffect
)
{
    const wxCursor&                 rCursor = GetCursor(eEffect);

    if (rCursor.Ok())
    {
        ::WinSetPointer(HWND_DESKTOP, (HPOINTER)rCursor.GetHCURSOR());
        m_vDragImage.hImage = (LHANDLE)rCursor.GetHCURSOR();
        switch(eEffect)
        {
            case wxDragCopy:
                m_pDragInfo->usOperation = DO_COPY;
                break;

            case wxDragMove:
                m_pDragInfo->usOperation = DO_MOVE;
                break;

            case wxDragLink:
                m_pDragInfo->usOperation = DO_LINK;
                break;

            case wxDragNone:
            case wxDragCancel:
            case wxDragError:
                break;
        }
        return true;
    }
    else
    {
        return false;
    }
} // end of GuiAdvDnd_CDropSource::GiveFeedback

void wxDropSource::Init ()
{
    m_pDragInfo = ::DrgAllocDraginfo(m_ulItems);

    //
    // Set a default drag image struct with what we know so far
    //
    m_vDragImage.cb             = sizeof(DRAGIMAGE);
    m_vDragImage.cptl           = 0;  // non-zero if fl is DRG_POLYGON
    m_vDragImage.hImage         = 0;  // Set in GiveFeedback
    m_vDragImage.sizlStretch.cx = 20L;
    m_vDragImage.sizlStretch.cy = 20L;
    m_vDragImage.fl             = DRG_ICON | DRG_STRETCH;
    m_vDragImage.cxOffset       = 0;
    m_vDragImage.cyOffset       = 0;

    HSTR                            hStrType = ::DrgAddStrHandle(DRT_UNKNOWN);
    HSTR                            hStrRMF;
    HSTR                            hStrContainer;
    wxChar                          zFormats[128];
    wxChar                          zContainer[128];
    USHORT                          uSize = GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat()) + 1;
    wxChar*                         pzBuffer = new wxChar[uSize];

    memset(pzBuffer, '\0', GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat()));
    pzBuffer[GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat())] = '\0';
    GetDataObject()->GetDataHere( GetDataObject()->GetPreferredFormat()
                                 ,(void*)pzBuffer
                                );

    wxStrcpy(zFormats, _T("<DRM_OS2FILE, DRF_UNKNOWN>"));
    wxStrcpy(zContainer, GetDataObject()->GetPreferredFormat().GetId());

    hStrRMF       = ::DrgAddStrHandle((PSZ)zFormats);
    hStrContainer = ::DrgAddStrHandle((PSZ)zContainer);

    m_pDragItem = new DRAGITEM[m_ulItems];
    for (ULONG i = 0; i < m_ulItems; i++)
    {
        m_pDragItem[i].hwndItem          = m_pWindow->GetHWND();
        m_pDragItem[i].hstrType          = hStrType;
        m_pDragItem[i].hstrRMF           = hStrRMF;
        m_pDragItem[i].hstrContainerName = hStrContainer;
        m_pDragItem[i].fsControl         = 0;
        m_pDragItem[i].fsSupportedOps    = DO_COPYABLE | DO_MOVEABLE | DO_LINKABLE;
        m_pDragItem[i].hstrSourceName    = ::DrgAddStrHandle((PSZ)pzBuffer);
        m_pDragItem[i].hstrTargetName    = m_pDragItem[i].hstrSourceName;
        m_pDragItem[i].ulItemID          = i;
        ::DrgSetDragitem( m_pDragInfo
                         ,&m_pDragItem[i]
                         ,sizeof(DRAGITEM)
                         ,0
                        );
    }
    delete [] pzBuffer;
    delete [] m_pDragItem;
} // end of wxDropSource::Init

#endif //wxUSE_DRAG_AND_DROP
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: dnd.cpp
	3	// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 10/21/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 AUTHOR
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "dnd.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#if wxUSE_DRAG_AND_DROP
	20
	21	#include "wx/window.h"
	22	#include "wx/app.h"
	23	#include "wx/gdicmn.h"
	24	#include "wx/dnd.h"
	25
	26	#define INCL_PM
	27	#define INCL_DOS
	28	#include <os2.h>
	29
	30	// ----------------------------------------------------------------------------
	31	// global
	32	// ----------------------------------------------------------------------------
	33
	34	/////////////////////////////////////////////////////////////////////////////
	35	// Private functions
	36	/////////////////////////////////////////////////////////////////////////////
	37
	38	#if 0
	39	static wxDragResult ConvertDragEffectToResult (
	40	DWORD dwEffect
	41	)
	42	{
	43	switch (dwEffect)
	44	{
	45	case DO_COPY:
	46	return wxDragCopy;
	47
	48	case DO_LINK:
	49	return wxDragLink;
	50
	51	case DO_MOVE:
	52	return wxDragMove;
	53
	54	default:
	55	case DO_DEFAULT:
	56	return wxDragNone;
	57	}
	58	} // end of ConvertDragEffectToResult
	59
	60	static DWORD ConvertDragResultToEffect (
	61	wxDragResult eResult
	62	)
	63	{
	64	switch (eResult)
	65	{
	66	case wxDragCopy:
	67	return DO_COPY;
	68
	69	case wxDragLink:
	70	return DO_LINK;
	71
	72	case wxDragMove:
	73	return DO_MOVE;
	74
	75	default:
	76	case wxDragNone:
	77	return DO_DEFAULT;
	78	}
	79	} // end of ConvertDragResultToEffect
	80	#endif
	81
	82	class CIDropTarget
	83	{
	84	public:
	85	CIDropTarget(wxDropTarget* pTarget)
	86	{
	87	m_pTarget = pTarget;
	88	m_pDragItem = NULL;
	89	}
	90	virtual ~CIDropTarget() { }
	91
	92	//
	93	// Accessors for CDropTarget
	94	//
	95	void Free(void) { ::DrgFreeDraginfo(m_pDragInfo); }
	96	PDRAGINFO GetDataSource(void) { return m_pDragInfo; }
	97	void SetDataSource(PDRAGINFO pDragInfo) { m_pDragInfo = pDragInfo; }
	98	void SetHWND(HWND hWnd) { m_hWnd = hWnd; }
	99
	100	//
	101	// CIDropTarget methods
	102	//
	103	bool DragLeave(void);
	104	MRESULT DragOver(void);
	105	MRESULT Drop(void);
	106
	107	protected:
	108
	109	PDRAGINFO m_pDragInfo;
	110	PDRAGITEM m_pDragItem; // !NULL between DragEnter and DragLeave/Drop
	111	wxDropTarget* m_pTarget; // the real target (we're just a proxy)
	112	HWND m_hWnd; // window we're associated with
	113	}; // end of CLASS CIDropTarget
	114
	115	bool CIDropTarget::DragLeave()
	116	{
	117	//
	118	// Remove the UI feedback
	119	//
	120	m_pTarget->OnLeave();
	121
	122	//
	123	// Release the held object
	124	//
	125	Free();
	126	return true;
	127	} // end of CIDropTarget::DragLeave
	128
	129	MRESULT CIDropTarget::DragOver ()
	130	{
	131	char zBuffer[128];
	132	ULONG ulBytes;
	133	USHORT uOp = 0;
	134	USHORT uIndicator;
	135	ULONG ulItems;
	136	ULONG i;
	137
	138	::DrgAccessDraginfo(m_pDragInfo);
	139	switch(m_pDragInfo->usOperation)
	140	{
	141	case DO_UNKNOWN:
	142	Free();
	143	return (MRFROM2SHORT(DOR_NODROPOP, 0));
	144
	145	case DO_DEFAULT:
	146	m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, 0);
	147	ulBytes = ::DrgQueryStrName( m_pDragItem->hstrContainerName
	148	,128
	149	,zBuffer
	150	);
	151	if (!ulBytes)
	152	return (MRFROM2SHORT(DOR_NODROPOP, 0));
	153	else
	154	uOp = DO_MOVE;
	155	break;
	156
	157	case DO_COPY:
	158	case DO_MOVE:
	159	uOp = m_pDragInfo->usOperation;
	160	break;
	161	}
	162	uIndicator = DOR_DROP;
	163	ulItems = (ULONG)::DrgQueryDragitemCount(m_pDragInfo);
	164	for (i = 0; i < ulItems; i++)
	165	{
	166	m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, i);
	167	if (((m_pDragItem->fsSupportedOps & DO_COPYABLE) &&
	168	(uOp == (USHORT)DO_COPY)) \|\|
	169	((m_pDragItem->fsSupportedOps & DO_MOVEABLE) &&
	170	(uOp == (USHORT)DO_COPY)))
	171	{
	172	if (::DrgVerifyRMF(m_pDragItem, "DRM_OS2FILE", "DRF_UNKNOWN"))
	173	uIndicator = (USHORT)DOR_DROP;
	174	else
	175	uIndicator = (USHORT)DOR_NEVERDROP;
	176	}
	177	}
	178	Free();
	179	return (MRFROM2SHORT(uIndicator, uOp));
	180	} // end of CIDropTarget::DragOver
	181
	182	// #pragma page "CIDropTarget::Drop"
	183	/////////////////////////////////////////////////////////////////////////////
	184	//
	185	// CIDropTarget::Drop
	186	//
	187	// Instructs the drop target to paste data that was just now dropped on it.
	188	//
	189	// PARAMETERS
	190	// pIDataSource -- the data to paste
	191	// dwKeyState -- kbd & mouse state
	192	// pt -- mouse coordinates
	193	// pdwEffect -- effect flag
	194	//
	195	// RETURN VALUE
	196	// STDMETHODIMP S_OK
	197	//
	198	/////////////////////////////////////////////////////////////////////////////
	199	MRESULT CIDropTarget::Drop ()
	200	{
	201	char zBuffer[128];
	202	ULONG ulBytes;
	203	USHORT uOp = 0;
	204	USHORT uIndicator;
	205	ULONG ulItems;
	206	ULONG i;
	207
	208	::DrgAccessDraginfo(m_pDragInfo);
	209	switch(m_pDragInfo->usOperation)
	210	{
	211	case DO_UNKNOWN:
	212	Free();
	213	return (MRFROM2SHORT(DOR_NODROPOP, 0));
	214
	215	case DO_DEFAULT:
	216	m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, 0);
	217	ulBytes = ::DrgQueryStrName( m_pDragItem->hstrContainerName
	218	,128
	219	,zBuffer
	220	);
	221	if (!ulBytes)
	222	return (MRFROM2SHORT(DOR_NODROPOP, 0));
	223	else
	224	uOp = DO_MOVE;
	225	break;
	226
	227	case DO_COPY:
	228	case DO_MOVE:
	229	uOp = m_pDragInfo->usOperation;
	230	break;
	231	}
	232	uIndicator = DOR_DROP;
	233	ulItems = (ULONG)::DrgQueryDragitemCount(m_pDragInfo);
	234	for (i = 0; i < ulItems; i++)
	235	{
	236	m_pDragItem = ::DrgQueryDragitemPtr(m_pDragInfo, i);
	237	if (((m_pDragItem->fsSupportedOps & DO_COPYABLE) &&
	238	(uOp == (USHORT)DO_COPY)) \|\|
	239	((m_pDragItem->fsSupportedOps & DO_MOVEABLE) &&
	240	(uOp == (USHORT)DO_COPY)))
	241	{
	242	if (::DrgVerifyRMF(m_pDragItem, "DRM_OS2FILE", "DRF_UNKNOWN"))
	243	uIndicator = (USHORT)DOR_DROP;
	244	else
	245	uIndicator = (USHORT)DOR_NEVERDROP;
	246	}
	247	}
	248
	249	//
	250	// First ask the drop target if it wants data
	251	//
	252	if (m_pTarget->OnDrop( m_pDragInfo->xDrop
	253	,m_pDragInfo->yDrop
	254	))
	255	{
	256	wxDragResult eRc = wxDragNone;
	257
	258	//
	259	// And now it has the data
	260	//
	261	eRc = m_pTarget->OnData( m_pDragInfo->xDrop
	262	,m_pDragInfo->yDrop
	263	,eRc
	264	);
	265	}
	266	//else: OnDrop() returned false, no need to copy data
	267
	268	//
	269	// Release the held object
	270	//
	271	Free();
	272	return (MRFROM2SHORT(uIndicator, uOp));
	273	} // end of CIDropTarget::Drop
	274
	275	// ----------------------------------------------------------------------------
	276	// wxDropTarget
	277	// ----------------------------------------------------------------------------
	278
	279	wxDropTarget::wxDropTarget (
	280	wxDataObject* pDataObject
	281	)
	282	{
	283	m_dataObject = pDataObject;
	284	m_pDropTarget = new CIDropTarget(this);
	285	} // end of wxDropTarget::wxDropTarget
	286
	287	wxDropTarget::~wxDropTarget()
	288	{
	289	Release();
	290	} // end of wxDropTarget::~wxDropTarget
	291
	292	bool wxDropTarget::GetData ()
	293	{
	294	wxDataFormat vFormat = GetSupportedFormat(m_pDropTarget->GetDataSource());
	295
	296	if (vFormat == wxDF_INVALID)
	297	{
	298	return false;
	299	}
	300	//
	301	// Under OS/2 we already have the data via the attached DRAGITEM's
	302	//
	303	return true;
	304	} // end of wxDropTarget::GetData
	305
	306	wxDataFormat wxDropTarget::GetSupportedFormat (
	307	PDRAGINFO pDataSource
	308	) const
	309	{
	310	PDRAGITEM pDragItem;
	311	wxDataFormat vFormat;
	312	wxDataFormat* pFormats;
	313	ULONG ulFormats = m_dataObject->GetFormatCount(wxDataObject::Set);
	314	ULONG ulItems = (ULONG)::DrgQueryDragitemCount(pDataSource);
	315	ULONG i;
	316	ULONG n;
	317	wxString sMechanism;
	318	wxString sFormat;
	319	bool bValid = false;
	320
	321	pFormats = ulFormats == 1 ? &vFormat : new wxDataFormat[ulFormats];
	322	m_dataObject->GetAllFormats( pFormats
	323	,wxDataObject::Set
	324	);
	325
	326	for (n = 0; n < ulFormats; n++)
	327	{
	328	switch(pFormats[n].GetType())
	329	{
	330	case wxDF_TEXT:
	331	case wxDF_FILENAME:
	332	case wxDF_HTML:
	333	sMechanism = _T("DRM_OS2FILE");
	334	sFormat = _T("DRF_TEXT");
	335	break;
	336
	337	case wxDF_OEMTEXT:
	338	sMechanism = _T("DRM_OS2FILE");
	339	sFormat = _T("DRF_OEMTEXT");
	340	break;
	341
	342	case wxDF_BITMAP:
	343	sMechanism = _T("DRM_OS2FILE");
	344	sFormat = _T("DRF_BITMAP");
	345	break;
	346
	347	case wxDF_METAFILE:
	348	case wxDF_ENHMETAFILE:
	349	sMechanism = _T("DRM_OS2FILE");
	350	sFormat = _T("DRF_METAFILE");
	351	break;
	352
	353	case wxDF_TIFF:
	354	sMechanism = _T("DRM_OS2FILE");
	355	sFormat = _T("DRF_TIFF");
	356	break;
	357
	358	case wxDF_SYLK:
	359	sMechanism = _T("DRM_OS2FILE");
	360	sFormat = _T("DRF_SYLK");
	361	break;
	362
	363	case wxDF_DIF:
	364	sMechanism = _T("DRM_OS2FILE");
	365	sFormat = _T("DRF_DIF");
	366	break;
	367
	368	case wxDF_DIB:
	369	sMechanism = _T("DRM_OS2FILE");
	370	sFormat = _T("DRF_DIB");
	371	break;
	372
	373	case wxDF_PALETTE:
	374	case wxDF_PENDATA:
	375	case wxDF_RIFF:
	376	case wxDF_WAVE:
	377	case wxDF_UNICODETEXT:
	378	case wxDF_LOCALE:
	379	sMechanism = _T("DRM_OS2FILE");
	380	sFormat = _T("DRF_UNKNOWN");
	381	break;
	382
	383	case wxDF_PRIVATE:
	384	sMechanism = _T("DRM_OBJECT");
	385	sFormat = _T("DRF_UNKNOWN");
	386	break;
	387	}
	388	for (i = 0; i < ulItems; i++)
	389	{
	390	pDragItem = ::DrgQueryDragitemPtr(pDataSource, i);
	391	if (::DrgVerifyRMF(pDragItem, (PSZ)sMechanism.c_str(), (PSZ)sFormat.c_str()))
	392	{
	393	bValid = true;
	394	break;
	395	}
	396	}
	397	if (bValid)
	398	{
	399	vFormat = pFormats[n];
	400	break;
	401	}
	402	}
	403	if (pFormats != &vFormat)
	404	{
	405	//
	406	// Free memory if we allocated it
	407	//
	408	delete [] pFormats;
	409	}
	410	return (n < ulFormats ? vFormat : wxFormatInvalid);
	411	} // end of wxDropTarget::GetSupportedFormat
	412
	413	bool wxDropTarget::IsAcceptedData (
	414	PDRAGINFO pDataSource
	415	) const
	416	{
	417	return (GetSupportedFormat(pDataSource) != wxDF_INVALID);
	418	} // end of wxDropTarget::IsAcceptedData
	419
	420	void wxDropTarget::Release ()
	421	{
	422	m_pDropTarget->Free();
	423	} // end of wxDropTarget::Release
	424
	425
	426	wxDragResult wxDropTarget::OnData (
	427	wxCoord WXUNUSED(vX)
	428	, wxCoord WXUNUSED(y)
	429	, wxDragResult WXUNUSED(vResult)
	430	)
	431	{
	432	return (wxDragResult)0;
	433	} // end of wxDropTarget::OnData
	434
	435	bool wxDropTarget::OnDrop (
	436	wxCoord WXUNUSED(x)
	437	, wxCoord WXUNUSED(y)
	438	)
	439	{
	440	return true;
	441	} // end of wxDropTarget::OnDrop
	442
	443	//-------------------------------------------------------------------------
	444	// wxDropSource
	445	//-------------------------------------------------------------------------
	446
	447	wxDropSource::wxDropSource (
	448	wxWindow* pWin
	449	)
	450	{
	451	Init();
	452	} // end of wxDropSource::wxDropSource
	453
	454	wxDropSource::wxDropSource (
	455	wxDataObject& rData
	456	, wxWindow* pWin
	457	)
	458	{
	459	Init();
	460	SetData(rData);
	461	} // end of wxDropSource::wxDropSource
	462
	463	wxDropSource::~wxDropSource ()
	464	{
	465	::DrgFreeDraginfo(m_pDragInfo);
	466	} // end of wxDropSource::~wxDropSource
	467
	468	wxDragResult wxDropSource::DoDragDrop (
	469	int WXUNUSED(flags)
	470	)
	471	{
	472	//
	473	// Need to specify drag items in derived classes that know their data types
	474	// before calling DoDragDrop
	475	//
	476	if (::DrgDrag( m_pWindow->GetHWND()
	477	,m_pDragInfo
	478	,&m_vDragImage
	479	,m_ulItems
	480	,VK_BUTTON2
	481	,NULL
	482	) != NULLHANDLE)
	483	{
	484	switch(m_pDragInfo->usOperation)
	485	{
	486	case DO_COPY:
	487	return wxDragCopy;
	488
	489	case DO_MOVE:
	490	return wxDragCopy;
	491
	492	case DO_LINK:
	493	return wxDragCopy;
	494
	495	default:
	496	return wxDragNone;
	497	}
	498	}
	499	return wxDragError;
	500	} // end of wxDropSource::DoDragDrop
	501
	502	bool wxDropSource::GiveFeedback (
	503	wxDragResult eEffect
	504	)
	505	{
	506	const wxCursor& rCursor = GetCursor(eEffect);
	507
	508	if (rCursor.Ok())
	509	{
	510	::WinSetPointer(HWND_DESKTOP, (HPOINTER)rCursor.GetHCURSOR());
	511	m_vDragImage.hImage = (LHANDLE)rCursor.GetHCURSOR();
	512	switch(eEffect)
	513	{
	514	case wxDragCopy:
	515	m_pDragInfo->usOperation = DO_COPY;
	516	break;
	517
	518	case wxDragMove:
	519	m_pDragInfo->usOperation = DO_MOVE;
	520	break;
	521
	522	case wxDragLink:
	523	m_pDragInfo->usOperation = DO_LINK;
	524	break;
	525
	526	case wxDragNone:
	527	case wxDragCancel:
	528	case wxDragError:
	529	break;
	530	}
	531	return true;
	532	}
	533	else
	534	{
	535	return false;
	536	}
	537	} // end of GuiAdvDnd_CDropSource::GiveFeedback
	538
	539	void wxDropSource::Init ()
	540	{
	541	m_pDragInfo = ::DrgAllocDraginfo(m_ulItems);
	542
	543	//
	544	// Set a default drag image struct with what we know so far
	545	//
	546	m_vDragImage.cb = sizeof(DRAGIMAGE);
	547	m_vDragImage.cptl = 0; // non-zero if fl is DRG_POLYGON
	548	m_vDragImage.hImage = 0; // Set in GiveFeedback
	549	m_vDragImage.sizlStretch.cx = 20L;
	550	m_vDragImage.sizlStretch.cy = 20L;
	551	m_vDragImage.fl = DRG_ICON \| DRG_STRETCH;
	552	m_vDragImage.cxOffset = 0;
	553	m_vDragImage.cyOffset = 0;
	554
	555	HSTR hStrType = ::DrgAddStrHandle(DRT_UNKNOWN);
	556	HSTR hStrRMF;
	557	HSTR hStrContainer;
	558	wxChar zFormats[128];
	559	wxChar zContainer[128];
	560	USHORT uSize = GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat()) + 1;
	561	wxChar* pzBuffer = new wxChar[uSize];
	562
	563	memset(pzBuffer, '\0', GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat()));
	564	pzBuffer[GetDataObject()->GetDataSize(GetDataObject()->GetPreferredFormat())] = '\0';
	565	GetDataObject()->GetDataHere( GetDataObject()->GetPreferredFormat()
	566	,(void*)pzBuffer
	567	);
	568
	569	wxStrcpy(zFormats, _T("<DRM_OS2FILE, DRF_UNKNOWN>"));
	570	wxStrcpy(zContainer, GetDataObject()->GetPreferredFormat().GetId());
	571
	572	hStrRMF = ::DrgAddStrHandle((PSZ)zFormats);
	573	hStrContainer = ::DrgAddStrHandle((PSZ)zContainer);
	574
	575	m_pDragItem = new DRAGITEM[m_ulItems];
	576	for (ULONG i = 0; i < m_ulItems; i++)
	577	{
	578	m_pDragItem[i].hwndItem = m_pWindow->GetHWND();
	579	m_pDragItem[i].hstrType = hStrType;
	580	m_pDragItem[i].hstrRMF = hStrRMF;
	581	m_pDragItem[i].hstrContainerName = hStrContainer;
	582	m_pDragItem[i].fsControl = 0;
	583	m_pDragItem[i].fsSupportedOps = DO_COPYABLE \| DO_MOVEABLE \| DO_LINKABLE;
	584	m_pDragItem[i].hstrSourceName = ::DrgAddStrHandle((PSZ)pzBuffer);
	585	m_pDragItem[i].hstrTargetName = m_pDragItem[i].hstrSourceName;
	586	m_pDragItem[i].ulItemID = i;
	587	::DrgSetDragitem( m_pDragInfo
	588	,&m_pDragItem[i]
	589	,sizeof(DRAGITEM)
	590	,0
	591	);
	592	}
	593	delete [] pzBuffer;
	594	delete [] m_pDragItem;
	595	} // end of wxDropSource::Init
	596
	597	#endif //wxUSE_DRAG_AND_DROP