src/os2/dnd.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/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
///////////////////////////////////////////////////////////////////////////////

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

#if wxUSE_DRAG_AND_DROP

#include "wx/dnd.h"

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/window.h"
    #include "wx/gdicmn.h"
#endif

#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 = wxT("DRM_OS2FILE");
                sFormat    = wxT("DRF_TEXT");
                break;

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

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

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

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

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

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

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

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

            case wxDF_PRIVATE:
                sMechanism = wxT("DRM_OBJECT");
                sFormat    = wxT("DRF_UNKNOWN");
                break;
        }
        for (i = 0; i < ulItems; i++)
        {
            pDragItem = ::DrgQueryDragitemPtr(pDataSource, i);
            if (::DrgVerifyRMF(pDragItem, sMechanism.c_str(), 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* WXUNUSED(pWin) )
{
    Init();
} // end of wxDropSource::wxDropSource

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