src/mac/carbon/dnd.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        dnd.cpp
// Purpose:     wxDropTarget, wxDropSource implementations
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Stefan Csomor
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#if wxUSE_DRAG_AND_DROP

#include "wx/dnd.h"
#include "wx/window.h"
#include "wx/toplevel.h"
#include "wx/app.h"
#include "wx/gdicmn.h"
#include "wx/mac/private.h"

#ifndef __DARWIN__
    #include <Scrap.h>
#endif


// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------

typedef struct
{
    wxWindow *m_currentTargetWindow;
    wxDropTarget *m_currentTarget;
    wxDropSource *m_currentSource;
}
MacTrackingGlobals;

MacTrackingGlobals gTrackingGlobals;

void wxMacEnsureTrackingHandlersInstalled();

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

wxDropTarget::wxDropTarget( wxDataObject *data )
            : wxDropTargetBase( data )
{
    wxMacEnsureTrackingHandlersInstalled();
}

wxDragResult wxDropTarget::OnDragOver(
    wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
    wxDragResult def )
{
    return CurrentDragHasSupportedFormat() ? def : wxDragNone;
}

bool wxDropTarget::OnDrop( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) )
{
    if (m_dataObject == NULL)
        return false;

    return CurrentDragHasSupportedFormat();
}

wxDragResult wxDropTarget::OnData(
    wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
    wxDragResult def )
{
    if (m_dataObject == NULL)
        return wxDragNone;

    if (!CurrentDragHasSupportedFormat())
        return wxDragNone;

    return GetData() ? def : wxDragNone;
}

bool wxDropTarget::CurrentDragHasSupportedFormat()
{
    bool supported = false;

    if ( gTrackingGlobals.m_currentSource != NULL )
    {
        wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject();

        if ( data )
        {
            size_t formatcount = data->GetFormatCount();
            wxDataFormat *array = new wxDataFormat[formatcount];
            data->GetAllFormats( array );
            for (size_t i = 0; !supported && i < formatcount; i++)
            {
                wxDataFormat format = array[i];
                if ( m_dataObject->IsSupported( format ) )
                {
                    supported = true;
                    break;
                }
            }

            delete [] array;
        }
    }

    if ( !supported )
    {
        UInt16 items;
        OSErr result;
        ItemReference theItem;
        FlavorType theType;
        UInt16 flavors = 0;

        CountDragItems( (DragReference)m_currentDrag, &items );
        for (UInt16 index = 1; index <= items && !supported; ++index)
        {
            flavors = 0;
            GetDragItemReferenceNumber( (DragReference)m_currentDrag, index, &theItem );
            CountDragItemFlavors( (DragReference)m_currentDrag, theItem, &flavors );

            for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
            {
                result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
                if ( m_dataObject->IsSupportedFormat( wxDataFormat( theType ) ) )
                {
                    supported = true;
                    break;
                }
            }
        }
    }

    return supported;
}

bool wxDropTarget::GetData()
{
    if (m_dataObject == NULL)
        return false;

    if ( !CurrentDragHasSupportedFormat() )
        return false;

    bool transferred = false;
    if ( gTrackingGlobals.m_currentSource != NULL )
    {
        wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject();

        if (data != NULL)
        {
            size_t formatcount = data->GetFormatCount();
            wxDataFormat *array = new wxDataFormat[formatcount];
            data->GetAllFormats( array );
            for (size_t i = 0; !transferred && i < formatcount; i++)
            {
                wxDataFormat format = array[i];
                if ( m_dataObject->IsSupported( format ) )
                {
                    int size = data->GetDataSize( format );
                    transferred = true;

                    if (size == 0)
                    {
                        m_dataObject->SetData( format, 0, 0 );
                    }
                    else
                    {
                        char *d = new char[size];
                        data->GetDataHere( format, (void*)d );
                        m_dataObject->SetData( format, size, d );
                        delete [] d;
                    }
                }
            }

            delete [] array;
        }
    }

    if ( !transferred )
    {
        UInt16 items;
        OSErr result;
        ItemReference theItem;
        FlavorType theType;
        FlavorFlags theFlags;
        UInt16 flavors;
        bool firstFileAdded = false;

        wxString filenamesPassed ;

        CountDragItems( (DragReference)m_currentDrag, &items );
        for (UInt16 index = 1; index <= items; ++index)
        {
            flavors = 0;
            GetDragItemReferenceNumber( (DragReference)m_currentDrag, index, &theItem );
            CountDragItemFlavors( (DragReference)m_currentDrag, theItem, &flavors );
            wxDataFormat preferredFormat = m_dataObject->GetPreferredFormat( wxDataObject::Set );
            bool hasPreferredFormat = false;

            for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
            {
                result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
                wxDataFormat format( theType );
                if ( preferredFormat == format )
                {
                    hasPreferredFormat = true;
                    break;
                }
            }

            for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
            {
                result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
                wxDataFormat format( theType );
                if ( (hasPreferredFormat && format == preferredFormat)
                    || (!hasPreferredFormat && m_dataObject->IsSupportedFormat( format )))
                {
                    result = GetFlavorFlags( (DragReference)m_currentDrag, theItem, theType, &theFlags );
                    if (result == noErr)
                    {
                        Size dataSize;
                        Ptr theData;

                        GetFlavorDataSize( (DragReference)m_currentDrag, theItem, theType, &dataSize );
                        if ( theType == kScrapFlavorTypeText )
                        {
                            // this increment is only valid for allocating:
                            // on the next GetFlavorData call it is reset again to the original value
                            dataSize++;
                        }
                        else if ( theType == kScrapFlavorTypeUnicode )
                        {
                            // this increment is only valid for allocating:
                            // on the next GetFlavorData call it is reset again to the original value
                            dataSize++;
                            dataSize++;
                        }

                        if (dataSize > 0)
                            theData = new char[dataSize];
                        else
                            theData = NULL;

                        GetFlavorData( (DragReference)m_currentDrag, theItem, theType, (void*) theData, &dataSize, 0L );
                        switch (theType)
                        {
                        case kScrapFlavorTypeText:
                            theData[dataSize] = 0;
                            m_dataObject->SetData( wxDataFormat(wxDF_TEXT), dataSize, theData );
                            break;

#if wxUSE_UNICODE
                        case kScrapFlavorTypeUnicode:
                            theData[dataSize + 0] =
                            theData[dataSize + 1] = 0;
                            m_dataObject->SetData( wxDataFormat(wxDF_UNICODETEXT), dataSize, theData );
                            break;
#endif

                        case kDragFlavorTypeHFS:
                            {
                                if (theData != NULL)
                                {
                                    HFSFlavor* theFile = (HFSFlavor*) theData;
                                    wxString name = wxMacFSSpec2MacFilename( &theFile->fileSpec );

                                    if (!name.IsEmpty())
                                        filenamesPassed += name + wxT("\n");
                                }
                            }
                            break;

                        default:
                            m_dataObject->SetData( format, dataSize, theData );
                            break;
                        }

                        delete [] theData;
                    }
                    break;
                }
            }
        }
        if ( filenamesPassed.Len() > 0 )
        {
            wxCharBuffer buf = filenamesPassed.fn_str();
            m_dataObject->SetData( wxDataFormat( wxDF_FILENAME ) , strlen( buf ) , (const char*) buf );
        }
    }

    return true;
}

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

//-----------------------------------------------------------------------------
// drag request

wxDropSource::wxDropSource(wxWindow *win,
                           const wxCursor &cursorCopy,
                           const wxCursor &cursorMove,
                           const wxCursor &cursorStop)
            : wxDropSourceBase(cursorCopy, cursorMove, cursorStop)
{
    wxMacEnsureTrackingHandlersInstalled();

    m_window = win;
}

wxDropSource::wxDropSource(wxDataObject& data,
                           wxWindow *win,
                           const wxCursor &cursorCopy,
                           const wxCursor &cursorMove,
                           const wxCursor &cursorStop)
            : wxDropSourceBase(cursorCopy, cursorMove, cursorStop)
{
    wxMacEnsureTrackingHandlersInstalled();

    SetData( data );
    m_window = win;
}

wxDropSource::~wxDropSource()
{
}

wxDragResult wxDropSource::DoDragDrop(int flags)
{
    wxASSERT_MSG( m_data, wxT("Drop source: no data") );

    if (!m_data)
        return (wxDragResult) wxDragNone;
    if (m_data->GetFormatCount() == 0)
        return (wxDragResult) wxDragNone;

    OSStatus result;
    DragReference theDrag;
    RgnHandle dragRegion;
    if ((result = NewDrag(&theDrag)) != noErr)
        return wxDragNone;

    // add data to drag
    size_t formatCount = m_data->GetFormatCount();
    wxDataFormat *formats = new wxDataFormat[formatCount];
    m_data->GetAllFormats( formats );
    ItemReference theItem = 1;

    for ( size_t i = 0; i < formatCount; ++i )
    {
        size_t dataSize = m_data->GetDataSize( formats[i] );
        Ptr dataPtr = new char[dataSize];
        m_data->GetDataHere( formats[i], dataPtr );
        OSType type = formats[i].GetFormatId();
        if ( type == 'TEXT' || type == 'utxt' )
        {
            if ( dataSize > 0 )
                dataSize--;
            dataPtr[ dataSize ] = 0;
            if ( type == 'utxt' )
            {
                if ( dataSize > 0 )
                    dataSize--;
                dataPtr[ dataSize ] = 0;
            }

            AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
        }
        else if (type == kDragFlavorTypeHFS )
        {
            HFSFlavor  theFlavor;
            OSErr err = noErr;
            CInfoPBRec cat;

            wxMacFilename2FSSpec( wxString( dataPtr, *wxConvCurrent ), &theFlavor.fileSpec );

            memset( &cat, 0, sizeof(cat) );
            cat.hFileInfo.ioNamePtr = theFlavor.fileSpec.name;
            cat.hFileInfo.ioVRefNum = theFlavor.fileSpec.vRefNum;
            cat.hFileInfo.ioDirID = theFlavor.fileSpec.parID;
            cat.hFileInfo.ioFDirIndex = 0;
            err = PBGetCatInfoSync( &cat );
            if (err == noErr)
            {
                theFlavor.fdFlags = cat.hFileInfo.ioFlFndrInfo.fdFlags;
                if (theFlavor.fileSpec.parID == fsRtParID)
                {
                    theFlavor.fileCreator = 'MACS';
                    theFlavor.fileType = 'disk';
                }
                else if ((cat.hFileInfo.ioFlAttrib & ioDirMask) != 0)
                {
                    theFlavor.fileCreator = 'MACS';
                    theFlavor.fileType = 'fold';
                }
                else
                {
                    theFlavor.fileCreator = cat.hFileInfo.ioFlFndrInfo.fdCreator;
                    theFlavor.fileType = cat.hFileInfo.ioFlFndrInfo.fdType;
                }

                AddDragItemFlavor( theDrag, theItem, type, &theFlavor, sizeof(theFlavor), 0 );
            }
        }
        else
        {
            AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
        }

        delete [] dataPtr;
    }

    delete [] formats;

    dragRegion = NewRgn();
    RgnHandle tempRgn = NewRgn();

    EventRecord* ev = NULL;

#if !TARGET_CARBON // TODO
    ev = (EventRecord*) wxTheApp->MacGetCurrentEvent();
#else
    EventRecord rec;
    ev = &rec;
    wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent(), &rec );
#endif

    const short dragRegionOuterBoundary = 10;
    const short dragRegionInnerBoundary = 9;

    SetRectRgn(
        dragRegion,
        ev->where.h - dragRegionOuterBoundary,
        ev->where.v  - dragRegionOuterBoundary,
        ev->where.h + dragRegionOuterBoundary,
        ev->where.v + dragRegionOuterBoundary );

    SetRectRgn(
        tempRgn,
        ev->where.h - dragRegionInnerBoundary,
        ev->where.v - dragRegionInnerBoundary,
        ev->where.h + dragRegionInnerBoundary,
        ev->where.v + dragRegionInnerBoundary );

    DiffRgn( dragRegion, tempRgn, dragRegion );
    DisposeRgn( tempRgn );

    // TODO: work with promises in order to return data
    // only when drag was successfully completed

    gTrackingGlobals.m_currentSource = this;
    result = TrackDrag( theDrag, ev, dragRegion );
    DisposeRgn( dragRegion );
    DisposeDrag( theDrag );
    gTrackingGlobals.m_currentSource = NULL;

    bool optionDown = GetCurrentKeyModifiers() & optionKey;
    wxDragResult dndresult = wxDragCopy;
    if ( flags != wxDrag_CopyOnly )
        // on mac the option key is always the indication for copy
        dndresult = optionDown ? wxDragCopy : wxDragMove;

    return dndresult;
}

bool wxDropSource::MacInstallDefaultCursor(wxDragResult effect)
{
    const wxCursor& cursor = GetCursor(effect);
    bool result = cursor.Ok();

    if ( result )
        cursor.MacInstall();

    return result;
}

bool gTrackingGlobalsInstalled = false;

// passing the globals via refcon is not needed by the CFM and later architectures anymore
// but I'll leave it in there, just in case...

pascal OSErr wxMacWindowDragTrackingHandler(
    DragTrackingMessage theMessage, WindowPtr theWindow,
    void *handlerRefCon, DragReference theDrag );
pascal OSErr wxMacWindowDragReceiveHandler(
    WindowPtr theWindow, void *handlerRefCon,
    DragReference theDrag );

void wxMacEnsureTrackingHandlersInstalled()
{
    if ( !gTrackingGlobalsInstalled )
    {
        OSStatus err;

        err = InstallTrackingHandler( NewDragTrackingHandlerUPP(wxMacWindowDragTrackingHandler), 0L, &gTrackingGlobals );
        verify_noerr( err );

        err = InstallReceiveHandler( NewDragReceiveHandlerUPP(wxMacWindowDragReceiveHandler), 0L, &gTrackingGlobals );
        verify_noerr( err );

        gTrackingGlobalsInstalled = true;
    }
}

pascal OSErr wxMacWindowDragTrackingHandler(
    DragTrackingMessage theMessage, WindowPtr theWindow,
    void *handlerRefCon, DragReference theDrag )
{
    MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*) handlerRefCon;

    Point mouse, localMouse;
    DragAttributes attributes;

    GetDragAttributes( theDrag, &attributes );

    wxTopLevelWindowMac* toplevel = wxFindWinFromMacWindow( theWindow );

    bool optionDown = GetCurrentKeyModifiers() & optionKey;
    wxDragResult result = optionDown ? wxDragCopy : wxDragMove;

    switch (theMessage)
    {
        case kDragTrackingEnterHandler:
        case kDragTrackingLeaveHandler:
            break;

        case kDragTrackingEnterWindow:
            if (trackingGlobals != NULL)
            {
                trackingGlobals->m_currentTargetWindow = NULL;
                trackingGlobals->m_currentTarget = NULL;
            }
            break;

        case kDragTrackingInWindow:
            if (trackingGlobals == NULL)
                break;
            if (toplevel == NULL)
                break;

            GetDragMouse( theDrag, &mouse, 0L );
            localMouse = mouse;
            GlobalToLocal( &localMouse );

            {
                wxWindow *win = NULL;
                ControlPartCode controlPart;
                ControlRef control = wxMacFindControlUnderMouse(
                    toplevel, localMouse, theWindow, &controlPart );
                if ( control )
                    win = wxFindControlFromMacControl( control );
                else
                    win = toplevel;

                int localx, localy;
                localx = localMouse.h;
                localy = localMouse.v;

                if ( win )
                    win->MacRootWindowToWindow( &localx, &localy );
                if ( win != trackingGlobals->m_currentTargetWindow )
                {
                    if ( trackingGlobals->m_currentTargetWindow )
                    {
                        // this window is left
                        if ( trackingGlobals->m_currentTarget )
                        {
                            HideDragHilite( theDrag );
                            trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
                            trackingGlobals->m_currentTarget->OnLeave();
                            trackingGlobals->m_currentTarget = NULL;
                            trackingGlobals->m_currentTargetWindow = NULL;
                        }
                    }

                    if ( win )
                    {
                        // this window is entered
                        trackingGlobals->m_currentTargetWindow = win;
                        trackingGlobals->m_currentTarget = win->GetDropTarget();
                        {
                            if ( trackingGlobals->m_currentTarget )
                            {
                                trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
                                result = trackingGlobals->m_currentTarget->OnEnter( localx, localy, result );
                            }

                            if ( result != wxDragNone )
                            {
                                int x, y;

                                x = y = 0;
                                win->MacWindowToRootWindow( &x, &y );
                                RgnHandle hiliteRgn = NewRgn();
                                Rect r = { y, x, y + win->GetSize().y, x + win->GetSize().x };
                                RectRgn( hiliteRgn, &r );
                                ShowDragHilite( theDrag, hiliteRgn, true );
                                DisposeRgn( hiliteRgn );
                            }
                        }
                    }
                }
                else
                {
                    if ( trackingGlobals->m_currentTarget )
                    {
                        trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
                        trackingGlobals->m_currentTarget->OnDragOver( localx, localy, result );
                    }
                }

                // set cursor for OnEnter and OnDragOver
                if ( trackingGlobals->m_currentSource && !trackingGlobals->m_currentSource->GiveFeedback( result ) )
                {
                  if ( !trackingGlobals->m_currentSource->MacInstallDefaultCursor( result ) )
                  {
                      switch ( result )
                      {
                          case wxDragCopy:
                              {
                                  wxCursor cursor(wxCURSOR_COPY_ARROW);
                                  cursor.MacInstall();
                              }
                              break;

                          case wxDragMove:
                              {
                                  wxCursor cursor(wxCURSOR_ARROW);
                                  cursor.MacInstall();
                              }
                              break;

                          case wxDragNone:
                              {
                                  wxCursor cursor(wxCURSOR_NO_ENTRY);
                                  cursor.MacInstall();
                              }
                              break;

                          case wxDragError:
                          case wxDragLink:
                          case wxDragCancel:
                          default:
                              // put these here to make gcc happy
                              ;
                      }
                   }
                }
            }
            break;

        case kDragTrackingLeaveWindow:
            if (trackingGlobals == NULL)
                break;

            if (trackingGlobals->m_currentTarget)
            {
                trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
                trackingGlobals->m_currentTarget->OnLeave();
                HideDragHilite( theDrag );
                trackingGlobals->m_currentTarget = NULL;
            }
            trackingGlobals->m_currentTargetWindow = NULL;
            break;

        default:
            break;
    }

    return noErr;
}

pascal OSErr wxMacWindowDragReceiveHandler(
    WindowPtr theWindow,
    void *handlerRefCon,
    DragReference theDrag)
{
    MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*)handlerRefCon;
    if ( trackingGlobals->m_currentTarget )
    {
        Point mouse, localMouse;
        int localx, localy;

        trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
        GetDragMouse( theDrag, &mouse, 0L );
        localMouse = mouse;
        GlobalToLocal( &localMouse );
        localx = localMouse.h;
        localy = localMouse.v;

        // TODO : should we use client coordinates?
        if ( trackingGlobals->m_currentTargetWindow )
            trackingGlobals->m_currentTargetWindow->MacRootWindowToWindow( &localx, &localy );
        if ( trackingGlobals->m_currentTarget->OnDrop( localx, localy ) )
        {
            bool optionDown = GetCurrentKeyModifiers() & optionKey;
            wxDragResult result = optionDown ? wxDragCopy : wxDragMove;
            trackingGlobals->m_currentTarget->OnData( localx, localy, result );
        }
    }

    return noErr;
}

#endif
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: dnd.cpp
	3	// Purpose: wxDropTarget, wxDropSource implementations
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 1998-01-01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Stefan Csomor
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#include "wx/wxprec.h"
	13
	14	#if wxUSE_DRAG_AND_DROP
	15
	16	#include "wx/dnd.h"
	17	#include "wx/window.h"
	18	#include "wx/toplevel.h"
	19	#include "wx/app.h"
	20	#include "wx/gdicmn.h"
	21	#include "wx/mac/private.h"
	22
	23	#ifndef __DARWIN__
	24	#include <Scrap.h>
	25	#endif
	26
	27
	28	// ----------------------------------------------------------------------------
	29	// globals
	30	// ----------------------------------------------------------------------------
	31
	32	typedef struct
	33	{
	34	wxWindow *m_currentTargetWindow;
	35	wxDropTarget *m_currentTarget;
	36	wxDropSource *m_currentSource;
	37	}
	38	MacTrackingGlobals;
	39
	40	MacTrackingGlobals gTrackingGlobals;
	41
	42	void wxMacEnsureTrackingHandlersInstalled();
	43
	44	//----------------------------------------------------------------------------
	45	// wxDropTarget
	46	//----------------------------------------------------------------------------
	47
	48	wxDropTarget::wxDropTarget( wxDataObject *data )
	49	: wxDropTargetBase( data )
	50	{
	51	wxMacEnsureTrackingHandlersInstalled();
	52	}
	53
	54	wxDragResult wxDropTarget::OnDragOver(
	55	wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
	56	wxDragResult def )
	57	{
	58	return CurrentDragHasSupportedFormat() ? def : wxDragNone;
	59	}
	60
	61	bool wxDropTarget::OnDrop( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) )
	62	{
	63	if (m_dataObject == NULL)
	64	return false;
	65
	66	return CurrentDragHasSupportedFormat();
	67	}
	68
	69	wxDragResult wxDropTarget::OnData(
	70	wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
	71	wxDragResult def )
	72	{
	73	if (m_dataObject == NULL)
	74	return wxDragNone;
	75
	76	if (!CurrentDragHasSupportedFormat())
	77	return wxDragNone;
	78
	79	return GetData() ? def : wxDragNone;
	80	}
	81
	82	bool wxDropTarget::CurrentDragHasSupportedFormat()
	83	{
	84	bool supported = false;
	85
	86	if ( gTrackingGlobals.m_currentSource != NULL )
	87	{
	88	wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject();
	89
	90	if ( data )
	91	{
	92	size_t formatcount = data->GetFormatCount();
	93	wxDataFormat *array = new wxDataFormat[formatcount];
	94	data->GetAllFormats( array );
	95	for (size_t i = 0; !supported && i < formatcount; i++)
	96	{
	97	wxDataFormat format = array[i];
	98	if ( m_dataObject->IsSupported( format ) )
	99	{
	100	supported = true;
	101	break;
	102	}
	103	}
	104
	105	delete [] array;
	106	}
	107	}
	108
	109	if ( !supported )
	110	{
	111	UInt16 items;
	112	OSErr result;
	113	ItemReference theItem;
	114	FlavorType theType;
	115	UInt16 flavors = 0;
	116
	117	CountDragItems( (DragReference)m_currentDrag, &items );
	118	for (UInt16 index = 1; index <= items && !supported; ++index)
	119	{
	120	flavors = 0;
	121	GetDragItemReferenceNumber( (DragReference)m_currentDrag, index, &theItem );
	122	CountDragItemFlavors( (DragReference)m_currentDrag, theItem, &flavors );
	123
	124	for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
	125	{
	126	result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
	127	if ( m_dataObject->IsSupportedFormat( wxDataFormat( theType ) ) )
	128	{
	129	supported = true;
	130	break;
	131	}
	132	}
	133	}
	134	}
	135
	136	return supported;
	137	}
	138
	139	bool wxDropTarget::GetData()
	140	{
	141	if (m_dataObject == NULL)
	142	return false;
	143
	144	if ( !CurrentDragHasSupportedFormat() )
	145	return false;
	146
	147	bool transferred = false;
	148	if ( gTrackingGlobals.m_currentSource != NULL )
	149	{
	150	wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject();
	151
	152	if (data != NULL)
	153	{
	154	size_t formatcount = data->GetFormatCount();
	155	wxDataFormat *array = new wxDataFormat[formatcount];
	156	data->GetAllFormats( array );
	157	for (size_t i = 0; !transferred && i < formatcount; i++)
	158	{
	159	wxDataFormat format = array[i];
	160	if ( m_dataObject->IsSupported( format ) )
	161	{
	162	int size = data->GetDataSize( format );
	163	transferred = true;
	164
	165	if (size == 0)
	166	{
	167	m_dataObject->SetData( format, 0, 0 );
	168	}
	169	else
	170	{
	171	char *d = new char[size];
	172	data->GetDataHere( format, (void*)d );
	173	m_dataObject->SetData( format, size, d );
	174	delete [] d;
	175	}
	176	}
	177	}
	178
	179	delete [] array;
	180	}
	181	}
	182
	183	if ( !transferred )
	184	{
	185	UInt16 items;
	186	OSErr result;
	187	ItemReference theItem;
	188	FlavorType theType;
	189	FlavorFlags theFlags;
	190	UInt16 flavors;
	191	bool firstFileAdded = false;
	192
	193	wxString filenamesPassed ;
	194
	195	CountDragItems( (DragReference)m_currentDrag, &items );
	196	for (UInt16 index = 1; index <= items; ++index)
	197	{
	198	flavors = 0;
	199	GetDragItemReferenceNumber( (DragReference)m_currentDrag, index, &theItem );
	200	CountDragItemFlavors( (DragReference)m_currentDrag, theItem, &flavors );
	201	wxDataFormat preferredFormat = m_dataObject->GetPreferredFormat( wxDataObject::Set );
	202	bool hasPreferredFormat = false;
	203
	204	for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
	205	{
	206	result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
	207	wxDataFormat format( theType );
	208	if ( preferredFormat == format )
	209	{
	210	hasPreferredFormat = true;
	211	break;
	212	}
	213	}
	214
	215	for ( UInt16 flavor = 1; flavor <= flavors; ++flavor )
	216	{
	217	result = GetFlavorType( (DragReference)m_currentDrag, theItem, flavor, &theType );
	218	wxDataFormat format( theType );
	219	if ( (hasPreferredFormat && format == preferredFormat)
	220	\|\| (!hasPreferredFormat && m_dataObject->IsSupportedFormat( format )))
	221	{
	222	result = GetFlavorFlags( (DragReference)m_currentDrag, theItem, theType, &theFlags );
	223	if (result == noErr)
	224	{
	225	Size dataSize;
	226	Ptr theData;
	227
	228	GetFlavorDataSize( (DragReference)m_currentDrag, theItem, theType, &dataSize );
	229	if ( theType == kScrapFlavorTypeText )
	230	{
	231	// this increment is only valid for allocating:
	232	// on the next GetFlavorData call it is reset again to the original value
	233	dataSize++;
	234	}
	235	else if ( theType == kScrapFlavorTypeUnicode )
	236	{
	237	// this increment is only valid for allocating:
	238	// on the next GetFlavorData call it is reset again to the original value
	239	dataSize++;
	240	dataSize++;
	241	}
	242
	243	if (dataSize > 0)
	244	theData = new char[dataSize];
	245	else
	246	theData = NULL;
	247
	248	GetFlavorData( (DragReference)m_currentDrag, theItem, theType, (void*) theData, &dataSize, 0L );
	249	switch (theType)
	250	{
	251	case kScrapFlavorTypeText:
	252	theData[dataSize] = 0;
	253	m_dataObject->SetData( wxDataFormat(wxDF_TEXT), dataSize, theData );
	254	break;
	255
	256	#if wxUSE_UNICODE
	257	case kScrapFlavorTypeUnicode:
	258	theData[dataSize + 0] =
	259	theData[dataSize + 1] = 0;
	260	m_dataObject->SetData( wxDataFormat(wxDF_UNICODETEXT), dataSize, theData );
	261	break;
	262	#endif
	263
	264	case kDragFlavorTypeHFS:
	265	{
	266	if (theData != NULL)
	267	{
	268	HFSFlavor* theFile = (HFSFlavor*) theData;
	269	wxString name = wxMacFSSpec2MacFilename( &theFile->fileSpec );
	270
	271	if (!name.IsEmpty())
	272	filenamesPassed += name + wxT("\n");
	273	}
	274	}
	275	break;
	276
	277	default:
	278	m_dataObject->SetData( format, dataSize, theData );
	279	break;
	280	}
	281
	282	delete [] theData;
	283	}
	284	break;
	285	}
	286	}
	287	}
	288	if ( filenamesPassed.Len() > 0 )
	289	{
	290	wxCharBuffer buf = filenamesPassed.fn_str();
	291	m_dataObject->SetData( wxDataFormat( wxDF_FILENAME ) , strlen( buf ) , (const char*) buf );
	292	}
	293	}
	294
	295	return true;
	296	}
	297
	298	//-------------------------------------------------------------------------
	299	// wxDropSource
	300	//-------------------------------------------------------------------------
	301
	302	//-----------------------------------------------------------------------------
	303	// drag request
	304
	305	wxDropSource::wxDropSource(wxWindow *win,
	306	const wxCursor &cursorCopy,
	307	const wxCursor &cursorMove,
	308	const wxCursor &cursorStop)
	309	: wxDropSourceBase(cursorCopy, cursorMove, cursorStop)
	310	{
	311	wxMacEnsureTrackingHandlersInstalled();
	312
	313	m_window = win;
	314	}
	315
	316	wxDropSource::wxDropSource(wxDataObject& data,
	317	wxWindow *win,
	318	const wxCursor &cursorCopy,
	319	const wxCursor &cursorMove,
	320	const wxCursor &cursorStop)
	321	: wxDropSourceBase(cursorCopy, cursorMove, cursorStop)
	322	{
	323	wxMacEnsureTrackingHandlersInstalled();
	324
	325	SetData( data );
	326	m_window = win;
	327	}
	328
	329	wxDropSource::~wxDropSource()
	330	{
	331	}
	332
	333	wxDragResult wxDropSource::DoDragDrop(int flags)
	334	{
	335	wxASSERT_MSG( m_data, wxT("Drop source: no data") );
	336
	337	if (!m_data)
	338	return (wxDragResult) wxDragNone;
	339	if (m_data->GetFormatCount() == 0)
	340	return (wxDragResult) wxDragNone;
	341
	342	OSStatus result;
	343	DragReference theDrag;
	344	RgnHandle dragRegion;
	345	if ((result = NewDrag(&theDrag)) != noErr)
	346	return wxDragNone;
	347
	348	// add data to drag
	349	size_t formatCount = m_data->GetFormatCount();
	350	wxDataFormat *formats = new wxDataFormat[formatCount];
	351	m_data->GetAllFormats( formats );
	352	ItemReference theItem = 1;
	353
	354	for ( size_t i = 0; i < formatCount; ++i )
	355	{
	356	size_t dataSize = m_data->GetDataSize( formats[i] );
	357	Ptr dataPtr = new char[dataSize];
	358	m_data->GetDataHere( formats[i], dataPtr );
	359	OSType type = formats[i].GetFormatId();
	360	if ( type == 'TEXT' \|\| type == 'utxt' )
	361	{
	362	if ( dataSize > 0 )
	363	dataSize--;
	364	dataPtr[ dataSize ] = 0;
	365	if ( type == 'utxt' )
	366	{
	367	if ( dataSize > 0 )
	368	dataSize--;
	369	dataPtr[ dataSize ] = 0;
	370	}
	371
	372	AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
	373	}
	374	else if (type == kDragFlavorTypeHFS )
	375	{
	376	HFSFlavor theFlavor;
	377	OSErr err = noErr;
	378	CInfoPBRec cat;
	379
	380	wxMacFilename2FSSpec( wxString( dataPtr, *wxConvCurrent ), &theFlavor.fileSpec );
	381
	382	memset( &cat, 0, sizeof(cat) );
	383	cat.hFileInfo.ioNamePtr = theFlavor.fileSpec.name;
	384	cat.hFileInfo.ioVRefNum = theFlavor.fileSpec.vRefNum;
	385	cat.hFileInfo.ioDirID = theFlavor.fileSpec.parID;
	386	cat.hFileInfo.ioFDirIndex = 0;
	387	err = PBGetCatInfoSync( &cat );
	388	if (err == noErr)
	389	{
	390	theFlavor.fdFlags = cat.hFileInfo.ioFlFndrInfo.fdFlags;
	391	if (theFlavor.fileSpec.parID == fsRtParID)
	392	{
	393	theFlavor.fileCreator = 'MACS';
	394	theFlavor.fileType = 'disk';
	395	}
	396	else if ((cat.hFileInfo.ioFlAttrib & ioDirMask) != 0)
	397	{
	398	theFlavor.fileCreator = 'MACS';
	399	theFlavor.fileType = 'fold';
	400	}
	401	else
	402	{
	403	theFlavor.fileCreator = cat.hFileInfo.ioFlFndrInfo.fdCreator;
	404	theFlavor.fileType = cat.hFileInfo.ioFlFndrInfo.fdType;
	405	}
	406
	407	AddDragItemFlavor( theDrag, theItem, type, &theFlavor, sizeof(theFlavor), 0 );
	408	}
	409	}
	410	else
	411	{
	412	AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
	413	}
	414
	415	delete [] dataPtr;
	416	}
	417
	418	delete [] formats;
	419
	420	dragRegion = NewRgn();
	421	RgnHandle tempRgn = NewRgn();
	422
	423	EventRecord* ev = NULL;
	424
	425	#if !TARGET_CARBON // TODO
	426	ev = (EventRecord*) wxTheApp->MacGetCurrentEvent();
	427	#else
	428	EventRecord rec;
	429	ev = &rec;
	430	wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent(), &rec );
	431	#endif
	432
	433	const short dragRegionOuterBoundary = 10;
	434	const short dragRegionInnerBoundary = 9;
	435
	436	SetRectRgn(
	437	dragRegion,
	438	ev->where.h - dragRegionOuterBoundary,
	439	ev->where.v - dragRegionOuterBoundary,
	440	ev->where.h + dragRegionOuterBoundary,
	441	ev->where.v + dragRegionOuterBoundary );
	442
	443	SetRectRgn(
	444	tempRgn,
	445	ev->where.h - dragRegionInnerBoundary,
	446	ev->where.v - dragRegionInnerBoundary,
	447	ev->where.h + dragRegionInnerBoundary,
	448	ev->where.v + dragRegionInnerBoundary );
	449
	450	DiffRgn( dragRegion, tempRgn, dragRegion );
	451	DisposeRgn( tempRgn );
	452
	453	// TODO: work with promises in order to return data
	454	// only when drag was successfully completed
	455
	456	gTrackingGlobals.m_currentSource = this;
	457	result = TrackDrag( theDrag, ev, dragRegion );
	458	DisposeRgn( dragRegion );
	459	DisposeDrag( theDrag );
	460	gTrackingGlobals.m_currentSource = NULL;
	461
	462	bool optionDown = GetCurrentKeyModifiers() & optionKey;
	463	wxDragResult dndresult = wxDragCopy;
	464	if ( flags != wxDrag_CopyOnly )
	465	// on mac the option key is always the indication for copy
	466	dndresult = optionDown ? wxDragCopy : wxDragMove;
	467
	468	return dndresult;
	469	}
	470
	471	bool wxDropSource::MacInstallDefaultCursor(wxDragResult effect)
	472	{
	473	const wxCursor& cursor = GetCursor(effect);
	474	bool result = cursor.Ok();
	475
	476	if ( result )
	477	cursor.MacInstall();
	478
	479	return result;
	480	}
	481
	482	bool gTrackingGlobalsInstalled = false;
	483
	484	// passing the globals via refcon is not needed by the CFM and later architectures anymore
	485	// but I'll leave it in there, just in case...
	486
	487	pascal OSErr wxMacWindowDragTrackingHandler(
	488	DragTrackingMessage theMessage, WindowPtr theWindow,
	489	void *handlerRefCon, DragReference theDrag );
	490	pascal OSErr wxMacWindowDragReceiveHandler(
	491	WindowPtr theWindow, void *handlerRefCon,
	492	DragReference theDrag );
	493
	494	void wxMacEnsureTrackingHandlersInstalled()
	495	{
	496	if ( !gTrackingGlobalsInstalled )
	497	{
	498	OSStatus err;
	499
	500	err = InstallTrackingHandler( NewDragTrackingHandlerUPP(wxMacWindowDragTrackingHandler), 0L, &gTrackingGlobals );
	501	verify_noerr( err );
	502
	503	err = InstallReceiveHandler( NewDragReceiveHandlerUPP(wxMacWindowDragReceiveHandler), 0L, &gTrackingGlobals );
	504	verify_noerr( err );
	505
	506	gTrackingGlobalsInstalled = true;
	507	}
	508	}
	509
	510	pascal OSErr wxMacWindowDragTrackingHandler(
	511	DragTrackingMessage theMessage, WindowPtr theWindow,
	512	void *handlerRefCon, DragReference theDrag )
	513	{
	514	MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*) handlerRefCon;
	515
	516	Point mouse, localMouse;
	517	DragAttributes attributes;
	518
	519	GetDragAttributes( theDrag, &attributes );
	520
	521	wxTopLevelWindowMac* toplevel = wxFindWinFromMacWindow( theWindow );
	522
	523	bool optionDown = GetCurrentKeyModifiers() & optionKey;
	524	wxDragResult result = optionDown ? wxDragCopy : wxDragMove;
	525
	526	switch (theMessage)
	527	{
	528	case kDragTrackingEnterHandler:
	529	case kDragTrackingLeaveHandler:
	530	break;
	531
	532	case kDragTrackingEnterWindow:
	533	if (trackingGlobals != NULL)
	534	{
	535	trackingGlobals->m_currentTargetWindow = NULL;
	536	trackingGlobals->m_currentTarget = NULL;
	537	}
	538	break;
	539
	540	case kDragTrackingInWindow:
	541	if (trackingGlobals == NULL)
	542	break;
	543	if (toplevel == NULL)
	544	break;
	545
	546	GetDragMouse( theDrag, &mouse, 0L );
	547	localMouse = mouse;
	548	GlobalToLocal( &localMouse );
	549
	550	{
	551	wxWindow *win = NULL;
	552	ControlPartCode controlPart;
	553	ControlRef control = wxMacFindControlUnderMouse(
	554	toplevel, localMouse, theWindow, &controlPart );
	555	if ( control )
	556	win = wxFindControlFromMacControl( control );
	557	else
	558	win = toplevel;
	559
	560	int localx, localy;
	561	localx = localMouse.h;
	562	localy = localMouse.v;
	563
	564	if ( win )
	565	win->MacRootWindowToWindow( &localx, &localy );
	566	if ( win != trackingGlobals->m_currentTargetWindow )
	567	{
	568	if ( trackingGlobals->m_currentTargetWindow )
	569	{
	570	// this window is left
	571	if ( trackingGlobals->m_currentTarget )
	572	{
	573	HideDragHilite( theDrag );
	574	trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
	575	trackingGlobals->m_currentTarget->OnLeave();
	576	trackingGlobals->m_currentTarget = NULL;
	577	trackingGlobals->m_currentTargetWindow = NULL;
	578	}
	579	}
	580
	581	if ( win )
	582	{
	583	// this window is entered
	584	trackingGlobals->m_currentTargetWindow = win;
	585	trackingGlobals->m_currentTarget = win->GetDropTarget();
	586	{
	587	if ( trackingGlobals->m_currentTarget )
	588	{
	589	trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
	590	result = trackingGlobals->m_currentTarget->OnEnter( localx, localy, result );
	591	}
	592
	593	if ( result != wxDragNone )
	594	{
	595	int x, y;
	596
	597	x = y = 0;
	598	win->MacWindowToRootWindow( &x, &y );
	599	RgnHandle hiliteRgn = NewRgn();
	600	Rect r = { y, x, y + win->GetSize().y, x + win->GetSize().x };
	601	RectRgn( hiliteRgn, &r );
	602	ShowDragHilite( theDrag, hiliteRgn, true );
	603	DisposeRgn( hiliteRgn );
	604	}
	605	}
	606	}
	607	}
	608	else
	609	{
	610	if ( trackingGlobals->m_currentTarget )
	611	{
	612	trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
	613	trackingGlobals->m_currentTarget->OnDragOver( localx, localy, result );
	614	}
	615	}
	616
	617	// set cursor for OnEnter and OnDragOver
	618	if ( trackingGlobals->m_currentSource && !trackingGlobals->m_currentSource->GiveFeedback( result ) )
	619	{
	620	if ( !trackingGlobals->m_currentSource->MacInstallDefaultCursor( result ) )
	621	{
	622	switch ( result )
	623	{
	624	case wxDragCopy:
	625	{
	626	wxCursor cursor(wxCURSOR_COPY_ARROW);
	627	cursor.MacInstall();
	628	}
	629	break;
	630
	631	case wxDragMove:
	632	{
	633	wxCursor cursor(wxCURSOR_ARROW);
	634	cursor.MacInstall();
	635	}
	636	break;
	637
	638	case wxDragNone:
	639	{
	640	wxCursor cursor(wxCURSOR_NO_ENTRY);
	641	cursor.MacInstall();
	642	}
	643	break;
	644
	645	case wxDragError:
	646	case wxDragLink:
	647	case wxDragCancel:
	648	default:
	649	// put these here to make gcc happy
	650	;
	651	}
	652	}
	653	}
	654	}
	655	break;
	656
	657	case kDragTrackingLeaveWindow:
	658	if (trackingGlobals == NULL)
	659	break;
	660
	661	if (trackingGlobals->m_currentTarget)
	662	{
	663	trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
	664	trackingGlobals->m_currentTarget->OnLeave();
	665	HideDragHilite( theDrag );
	666	trackingGlobals->m_currentTarget = NULL;
	667	}
	668	trackingGlobals->m_currentTargetWindow = NULL;
	669	break;
	670
	671	default:
	672	break;
	673	}
	674
	675	return noErr;
	676	}
	677
	678	pascal OSErr wxMacWindowDragReceiveHandler(
	679	WindowPtr theWindow,
	680	void *handlerRefCon,
	681	DragReference theDrag)
	682	{
	683	MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*)handlerRefCon;
	684	if ( trackingGlobals->m_currentTarget )
	685	{
	686	Point mouse, localMouse;
	687	int localx, localy;
	688
	689	trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag );
	690	GetDragMouse( theDrag, &mouse, 0L );
	691	localMouse = mouse;
	692	GlobalToLocal( &localMouse );
	693	localx = localMouse.h;
	694	localy = localMouse.v;
	695
	696	// TODO : should we use client coordinates?
	697	if ( trackingGlobals->m_currentTargetWindow )
	698	trackingGlobals->m_currentTargetWindow->MacRootWindowToWindow( &localx, &localy );
	699	if ( trackingGlobals->m_currentTarget->OnDrop( localx, localy ) )
	700	{
	701	bool optionDown = GetCurrentKeyModifiers() & optionKey;
	702	wxDragResult result = optionDown ? wxDragCopy : wxDragMove;
	703	trackingGlobals->m_currentTarget->OnData( localx, localy, result );
	704	}
	705	}
	706
	707	return noErr;
	708	}
	709
	710	#endif