AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

drag and drop implementation

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@13280 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Csomor 2001-12-31 16:37:42 +00:00
parent dbfc5b9763
commit a07c12126f
13 changed files with 1070 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mac/carbon/clipbrd.cpp
View File

@ -254,7 +254,7 @@ bool wxClipboard::AddData( wxDataObject *data )
wxMetafileDataObject* metaFileDataObject =
(wxMetafileDataObject*) data;
wxMetafile metaFile = metaFileDataObject->GetMetafile();
PicHandle pict = metaFile->GetHMETAFILE() ;
PicHandle pict = metaFile.GetHMETAFILE() ;
HLock( (Handle) pict ) ;
#if !TARGET_CARBON
err = PutScrap( GetHandleSize( (Handle) pict ) , 'PICT' , *pict ) ;

6
src/mac/carbon/dataobj.cpp
View File

@ -77,7 +77,7 @@ void wxDataFormat::SetType( wxDataFormatId Type )
else if (m_type == wxDF_BITMAP || m_type == wxDF_METAFILE )
m_format = 'PICT';
else if (m_type == wxDF_FILENAME)
m_format = 'SPEC';
m_format = kDragFlavorTypeHFS ;
else
{
wxFAIL_MSG( wxT("invalid dataformat") );
@ -105,7 +105,7 @@ void wxDataFormat::SetId( NativeFormat format )
if (m_format == 'PICT')
m_type = wxDF_BITMAP;
else
if (m_format == 'SPEC')
if (m_format == kDragFlavorTypeHFS )
m_type = wxDF_FILENAME;
else
m_type = wxDF_PRIVATE;
@ -198,7 +198,7 @@ bool wxFileDataObject::SetData(
, const void* pBuf
)
{
/* TODO */
m_filenames.Empty();
wxString sFile( (const char *)pBuf); /* char, not wxChar */

544
src/mac/carbon/dnd.cpp
View File

@ -24,77 +24,204 @@
// global
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMacEnsureTrackingHandlersInstalled() ;
typedef struct
{
wxWindow* m_currentTargetWindow ;
wxDropTarget* m_currentTarget ;
wxDropSource* m_currentSource ;
} MacTrackingGlobals ;
MacTrackingGlobals gTrackingGlobals ;
//----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------
//----------------------------------------------------------------------------
wxDropTarget::wxDropTarget()
wxDropTarget::wxDropTarget( wxDataObject *data )
: wxDropTargetBase( data )
{
};
wxDropTarget::~wxDropTarget()
{
};
// ----------------------------------------------------------------------------
// wxTextDropTarget
// ----------------------------------------------------------------------------
#ifndef __DARWIN__
bool wxTextDropTarget::OnDrop( wxCoord x, wxCoord y, const void *pData )
{
OnDropText( x, y, (const char*)pData );
return TRUE;
};
#endif
bool wxTextDropTarget::OnDropText( wxCoord x, wxCoord y, const wxString &psz )
{
printf( "Got dropped text: %s.\n", (char *)psz );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
};
#ifndef __DARWIN__
size_t wxTextDropTarget::GetFormatCount() const
{
return 1;
wxMacEnsureTrackingHandlersInstalled() ;
}
wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxDragResult wxDropTarget::OnDragOver( wxCoord WXUNUSED(x),
wxCoord WXUNUSED(y),
wxDragResult def )
{
return wxDF_TEXT;
}
#endif
// ----------------------------------------------------------------------------
// wxFileDropTarget
// ----------------------------------------------------------------------------
#ifndef __DARWIN__
bool wxFileDropTarget::OnDropFiles( wxCoord x, wxCoord y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] )
{
printf( "Got %d dropped files.\n", (int)nFiles );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
}
#endif
bool wxFileDropTarget::OnDrop(wxCoord x, wxCoord y, const wxArrayString& filenames)
{
return OnDropFiles(x, y, 1, &filenames);
return CurrentDragHasSupportedFormat() ? def : wxDragNone;
}
#ifndef __DARWIN__
size_t wxFileDropTarget::GetFormatCount() const
bool wxDropTarget::OnDrop( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) )
{
return 1;
if (!m_dataObject)
return FALSE;
return CurrentDragHasSupportedFormat() ;
}
wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxDragResult wxDropTarget::OnData( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
wxDragResult def )
{
return wxDF_FILENAME;
if (!m_dataObject)
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 )
{
int 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;
CountDragItems(m_currentDrag, &items);
for (UInt16 index = 1; index <= items && supported == false ; ++index)
{
ItemReference theItem;
FlavorType theType ;
UInt16 flavors = 0 ;
GetDragItemReferenceNumber(m_currentDrag, index, &theItem);
CountDragItemFlavors( m_currentDrag, theItem , &flavors ) ;
for ( UInt16 flavor = 1 ; flavor <= flavors ; ++flavor )
{
result = GetFlavorType(m_currentDrag, theItem, flavor , &theType);
if ( m_dataObject->IsSupportedFormat( wxDataFormat( theType ) ) )
{
supported = true ;
break ;
}
}
}
}
return supported ;
}
bool wxDropTarget::GetData()
{
if (!m_dataObject)
return FALSE;
if ( !CurrentDragHasSupportedFormat() )
return FALSE ;
bool transferred = false ;
if ( gTrackingGlobals.m_currentSource != NULL )
{
wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject() ;
if ( data )
{
int 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;
CountDragItems(m_currentDrag, &items);
for (UInt16 index = 1; index <= items; ++index)
{
ItemReference theItem;
FlavorType theType ;
UInt16 flavors = 0 ;
GetDragItemReferenceNumber(m_currentDrag, index, &theItem);
CountDragItemFlavors( m_currentDrag, theItem , &flavors ) ;
for ( UInt16 flavor = 1 ; flavor <= flavors ; ++flavor )
{
result = GetFlavorType(m_currentDrag, theItem, flavor , &theType);
wxDataFormat format(theType) ;
if ( m_dataObject->IsSupportedFormat( format ) )
{
FlavorFlags theFlags;
result = GetFlavorFlags(m_currentDrag, theItem, theType, &theFlags);
if (result == noErr)
{
Size dataSize ;
Ptr theData ;
GetFlavorDataSize(m_currentDrag, theItem, theType, &dataSize);
if ( theType == 'TEXT' )
dataSize++ ;
theData = new char[dataSize];
GetFlavorData(m_currentDrag, theItem, theType, (void*) theData, &dataSize, 0L);
if( theType == 'TEXT' )
{
theData[dataSize]=0 ;
if ( wxApp::s_macDefaultEncodingIsPC )
{
wxMacConvertToPC((char*)theData) ;
}
m_dataObject->SetData( format, dataSize, theData );
}
else if ( theType == kDragFlavorTypeHFS )
{
HFSFlavor* theFile = (HFSFlavor*) theData ;
wxString name = wxMacFSSpec2MacFilename( &theFile->fileSpec ) ;
m_dataObject->SetData( format , name.Length() + 1, name ) ;
}
else
{
m_dataObject->SetData( format, dataSize, theData );
}
delete[] theData;
}
break ;
}
}
}
}
return TRUE ;
}
#endif
//-------------------------------------------------------------------------
// wxDropSource
@ -103,39 +230,286 @@ wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
//-----------------------------------------------------------------------------
// drag request
wxDropSource::wxDropSource( wxWindow *win )
wxDropSource::wxDropSource(wxWindow *win,
const wxIcon &iconCopy,
const wxIcon &iconMove,
const wxIcon &iconNone)
{
// TODO
// m_window = win;
m_data = NULL;
wxMacEnsureTrackingHandlersInstalled() ;
m_window = win;
}
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
wxDropSource::wxDropSource(wxDataObject& data,
wxWindow *win,
const wxIcon &iconCopy,
const wxIcon &iconMove,
const wxIcon &iconNone)
{
// TODO
// m_window = win;
m_data = &data;
wxMacEnsureTrackingHandlersInstalled() ;
SetData( data );
m_window = win;
}
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
void wxDropSource::SetData( wxDataObject &data )
wxDropSource::~wxDropSource()
{
m_data = &data;
};
}
wxDropSource::~wxDropSource(void)
{
};
wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
{
// TODO
return wxDragError;
};
wxDragResult wxDropSource::DoDragDrop( bool allowMove )
{
wxASSERT_MSG( m_data, wxT("Drop source: no data") );
if (!m_data)
return (wxDragResult) wxDragNone;
if (m_data->GetFormatCount() == 0)
return (wxDragResult) wxDragNone;
OSErr result;
DragReference theDrag;
RgnHandle dragRegion;
if (result = NewDrag(&theDrag))
{
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 ( int 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' )
{
dataSize-- ;
if ( wxApp::s_macDefaultEncodingIsPC )
{
wxMacConvertFromPC((char*)dataPtr) ;
}
AddDragItemFlavor(theDrag, theItem, type , dataPtr, dataSize, 0);
}
else if (type == kDragFlavorTypeHFS )
{
HFSFlavor theFlavor ;
OSErr err = noErr;
CInfoPBRec cat;
wxMacFilename2FSSpec( dataPtr , &theFlavor.fileSpec ) ;
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 = wxTheApp->MacGetCurrentEvent() ;
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 ;
return wxDragCopy ;
}
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 )
{
OSErr result;
result = InstallTrackingHandler(NewDragTrackingHandlerUPP(wxMacWindowDragTrackingHandler), 0L,&gTrackingGlobals);
wxASSERT( result == noErr ) ;
result = InstallReceiveHandler(NewDragReceiveHandlerUPP(wxMacWindowDragReceiveHandler), 0L, &gTrackingGlobals);
wxASSERT( result == noErr ) ;
gTrackingGlobalsInstalled = true ;
}
}
pascal OSErr wxMacWindowDragTrackingHandler(DragTrackingMessage theMessage, WindowPtr theWindow,
void *handlerRefCon, DragReference theDrag)
{
MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*) handlerRefCon;
Point mouse, localMouse;
DragAttributes attributes;
RgnHandle hiliteRgn;
GetDragAttributes(theDrag, &attributes);
wxTopLevelWindowMac* toplevel = wxFindWinFromMacWindow( theWindow ) ;
switch(theMessage)
{
case kDragTrackingEnterHandler:
break;
case kDragTrackingLeaveHandler:
break;
case kDragTrackingEnterWindow:
trackingGlobals->m_currentTargetWindow = NULL ;
trackingGlobals->m_currentTarget = NULL ;
break;
case kDragTrackingInWindow:
if (toplevel == NULL)
break;
GetDragMouse(theDrag, &mouse, 0L);
localMouse = mouse;
GlobalToLocal(&localMouse);
// if (attributes & kDragHasLeftSenderWindow)
{
wxPoint point(localMouse.h , localMouse.v) ;
wxWindow *win = NULL ;
toplevel->MacGetWindowFromPointSub( point , &win ) ;
int localx , localy ;
localx = localMouse.h ;
localy = localMouse.v ;
//TODO : should we use client coordinates
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 ) ;
if ( trackingGlobals->m_currentTarget->OnEnter(
localx , localy , wxDragCopy ) != wxDragNone )
{
int x , y ;
x = y = 0 ;
win->MacWindowToRootWindow( &x , &y ) ;
RgnHandle hiliteRgn = NewRgn() ;
SetRectRgn( hiliteRgn , x , y , x+win->GetSize().x ,y+win->GetSize().y) ;
ShowDragHilite(theDrag, hiliteRgn, true);
DisposeRgn( hiliteRgn ) ;
}
}
}
}
else
{
if( trackingGlobals->m_currentTarget )
{
trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag ) ;
trackingGlobals->m_currentTarget->OnDragOver(
localx , localy , wxDragCopy ) ;
}
}
}
// MyTrackItemUnderMouse(localMouse, theWindow);
break;
case kDragTrackingLeaveWindow:
if (trackingGlobals->m_currentTarget)
{
trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag ) ;
trackingGlobals->m_currentTarget->OnLeave() ;
HideDragHilite(theDrag);
trackingGlobals->m_currentTarget = NULL ;
}
trackingGlobals->m_currentTargetWindow = NULL ;
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 ) )
{
trackingGlobals->m_currentTarget->OnData( localx , localy , wxDragCopy ) ;
}
}
return(noErr);
}
#endif

31
src/mac/carbon/metafile.cpp
View File

@ -92,10 +92,13 @@ bool wxMetaFile::SetClipboard(int width, int height)
if (!alreadyOpen)
{
wxTheClipboard->Open();
if (!wxTheClipboard->Clear()) return FALSE;
wxTheClipboard->Clear();
}
bool success = wxSetClipboardData(wxDF_METAFILE, this, width,height);
if (!alreadyOpen) wxCloseClipboard();
wxDataObject *data =
new wxMetafileDataObject( *this) ;
bool success = wxTheClipboard->SetData(data);
if (!alreadyOpen)
wxTheClipboard->Close();
return (bool) success;
#endif
return TRUE ;
@ -184,4 +187,26 @@ wxMetaFile *wxMetaFileDC::Close()
return m_metaFile;
}
#if wxUSE_DATAOBJ
size_t wxMetafileDataObject::GetDataSize() const
{
return GetHandleSize( (Handle) (*((wxMetafile*)&m_metafile)).GetHMETAFILE() ) ;
}
bool wxMetafileDataObject::GetDataHere(void *buf) const
{
memcpy( buf , (*(*((wxMetafile*)&m_metafile)).GetHMETAFILE()) ,
GetHandleSize( (Handle) (*((wxMetafile*)&m_metafile)).GetHMETAFILE() ) ) ;
return true ;
}
bool wxMetafileDataObject::SetData(size_t len, const void *buf)
{
Handle handle = (Handle) m_metafile.GetHMETAFILE() ;
SetHandleSize( handle , len ) ;
memcpy( *handle , buf , len ) ;
return true ;
}
#endif
#endif

2
src/mac/carbon/toplevel.cpp
View File

@ -40,6 +40,7 @@
#include "wx/mac/uma.h"
#include "wx/mac/aga.h"
#include "wx/tooltip.h"
#include "wx/dnd.h"
#define wxMAC_DEBUG_REDRAW 0
#ifndef wxMAC_DEBUG_REDRAW
@ -680,3 +681,4 @@ void wxTopLevelWindowMac::MacInvalidate( const Rect * rect, bool eraseBackground
#endif
SetPort( formerPort ) ;
}

73
src/mac/carbon/window.cpp
View File

@ -120,10 +120,6 @@ void wxWindowMac::Init()
m_hScrollBar = NULL ;
m_vScrollBar = NULL ;
#if wxUSE_DRAG_AND_DROP
m_pDropTarget = NULL;
#endif
}
// Destructor
@ -273,12 +269,12 @@ void wxWindowMac::ReleaseMouse()
void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
{
if ( m_pDropTarget != 0 ) {
delete m_pDropTarget;
if ( m_dropTarget != 0 ) {
delete m_dropTarget;
}
m_pDropTarget = pDropTarget;
if ( m_pDropTarget != 0 )
m_dropTarget = pDropTarget;
if ( m_dropTarget != 0 )
{
// TODO
}
@ -1300,16 +1296,28 @@ wxWindowMac* wxWindowMac::s_lastMouseWindow = NULL ;
bool wxWindowMac::MacGetWindowFromPointSub( const wxPoint &point , wxWindowMac** outWin )
{
if ((point.x < m_x) || (point.y < m_y) ||
(point.x > (m_x + m_width)) || (point.y > (m_y + m_height)))
return FALSE;
if ( IsTopLevel() )
{
if ((point.x < 0) || (point.y < 0) ||
(point.x > (m_width)) || (point.y > (m_height)))
return FALSE;
}
else
{
if ((point.x < m_x) || (point.y < m_y) ||
(point.x > (m_x + m_width)) || (point.y > (m_y + m_height)))
return FALSE;
}
WindowRef window = MacGetRootWindow() ;
wxPoint newPoint( point ) ;
newPoint.x -= m_x;
newPoint.y -= m_y;
if ( !IsTopLevel() )
{
newPoint.x -= m_x;
newPoint.y -= m_y;
}
for (wxNode *node = GetChildren().First(); node; node = node->Next())
{
@ -1332,13 +1340,13 @@ bool wxWindowMac::MacGetWindowFromPoint( const wxPoint &screenpoint , wxWindowMa
Point pt = { screenpoint.y , screenpoint.x } ;
if ( ::FindWindow( pt , &window ) == 3 )
{
wxPoint point( screenpoint ) ;
wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
{
win->ScreenToClient( point ) ;
wxPoint point( screenpoint ) ;
wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
{
point = win->ScreenToClient( point ) ;
return win->MacGetWindowFromPointSub( point , outWin ) ;
}
}
}
return FALSE ;
}
@ -1442,19 +1450,22 @@ const wxRegion& wxWindowMac::MacGetVisibleRegion()
DiffRgn( visRgn , tempRgn , visRgn ) ;
}
wxWindow* parent = GetParent() ;
while( parent )
if ( !IsTopLevel() )
{
wxSize size = parent->GetSize() ;
int x , y ;
x = y = 0 ;
parent->MacWindowToRootWindow( &x, &y ) ;
MacRootWindowToWindow( &x , &y ) ;
SetRectRgn( tempRgn , x , y , x + size.x , y + size.y ) ;
SectRgn( visRgn , tempRgn , visRgn ) ;
if ( parent->IsTopLevel() )
break ;
parent = parent->GetParent() ;
wxWindow* parent = GetParent() ;
while( parent )
{
wxSize size = parent->GetSize() ;
int x , y ;
x = y = 0 ;
parent->MacWindowToRootWindow( &x, &y ) ;
MacRootWindowToWindow( &x , &y ) ;
SetRectRgn( tempRgn , x , y , x + size.x , y + size.y ) ;
SectRgn( visRgn , tempRgn , visRgn ) ;
if ( parent->IsTopLevel() )
break ;
parent = parent->GetParent() ;
}
}
if ( GetWindowStyle() & wxCLIP_CHILDREN )
{

2
src/mac/clipbrd.cpp
View File

@ -254,7 +254,7 @@ bool wxClipboard::AddData( wxDataObject *data )
wxMetafileDataObject* metaFileDataObject =
(wxMetafileDataObject*) data;
wxMetafile metaFile = metaFileDataObject->GetMetafile();
PicHandle pict = metaFile->GetHMETAFILE() ;
PicHandle pict = metaFile.GetHMETAFILE() ;
HLock( (Handle) pict ) ;
#if !TARGET_CARBON
err = PutScrap( GetHandleSize( (Handle) pict ) , 'PICT' , *pict ) ;

6
src/mac/dataobj.cpp
View File

@ -77,7 +77,7 @@ void wxDataFormat::SetType( wxDataFormatId Type )
else if (m_type == wxDF_BITMAP || m_type == wxDF_METAFILE )
m_format = 'PICT';
else if (m_type == wxDF_FILENAME)
m_format = 'SPEC';
m_format = kDragFlavorTypeHFS ;
else
{
wxFAIL_MSG( wxT("invalid dataformat") );
@ -105,7 +105,7 @@ void wxDataFormat::SetId( NativeFormat format )
if (m_format == 'PICT')
m_type = wxDF_BITMAP;
else
if (m_format == 'SPEC')
if (m_format == kDragFlavorTypeHFS )
m_type = wxDF_FILENAME;
else
m_type = wxDF_PRIVATE;
@ -198,7 +198,7 @@ bool wxFileDataObject::SetData(
, const void* pBuf
)
{
/* TODO */
m_filenames.Empty();
wxString sFile( (const char *)pBuf); /* char, not wxChar */

544
src/mac/dnd.cpp
View File

@ -24,77 +24,204 @@
// global
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void wxMacEnsureTrackingHandlersInstalled() ;
typedef struct
{
wxWindow* m_currentTargetWindow ;
wxDropTarget* m_currentTarget ;
wxDropSource* m_currentSource ;
} MacTrackingGlobals ;
MacTrackingGlobals gTrackingGlobals ;
//----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------
//----------------------------------------------------------------------------
wxDropTarget::wxDropTarget()
wxDropTarget::wxDropTarget( wxDataObject *data )
: wxDropTargetBase( data )
{
};
wxDropTarget::~wxDropTarget()
{
};
// ----------------------------------------------------------------------------
// wxTextDropTarget
// ----------------------------------------------------------------------------
#ifndef __DARWIN__
bool wxTextDropTarget::OnDrop( wxCoord x, wxCoord y, const void *pData )
{
OnDropText( x, y, (const char*)pData );
return TRUE;
};
#endif
bool wxTextDropTarget::OnDropText( wxCoord x, wxCoord y, const wxString &psz )
{
printf( "Got dropped text: %s.\n", (char *)psz );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
};
#ifndef __DARWIN__
size_t wxTextDropTarget::GetFormatCount() const
{
return 1;
wxMacEnsureTrackingHandlersInstalled() ;
}
wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxDragResult wxDropTarget::OnDragOver( wxCoord WXUNUSED(x),
wxCoord WXUNUSED(y),
wxDragResult def )
{
return wxDF_TEXT;
}
#endif
// ----------------------------------------------------------------------------
// wxFileDropTarget
// ----------------------------------------------------------------------------
#ifndef __DARWIN__
bool wxFileDropTarget::OnDropFiles( wxCoord x, wxCoord y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] )
{
printf( "Got %d dropped files.\n", (int)nFiles );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
}
#endif
bool wxFileDropTarget::OnDrop(wxCoord x, wxCoord y, const wxArrayString& filenames)
{
return OnDropFiles(x, y, 1, &filenames);
return CurrentDragHasSupportedFormat() ? def : wxDragNone;
}
#ifndef __DARWIN__
size_t wxFileDropTarget::GetFormatCount() const
bool wxDropTarget::OnDrop( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) )
{
return 1;
if (!m_dataObject)
return FALSE;
return CurrentDragHasSupportedFormat() ;
}
wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxDragResult wxDropTarget::OnData( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
wxDragResult def )
{
return wxDF_FILENAME;
if (!m_dataObject)
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 )
{
int 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;
CountDragItems(m_currentDrag, &items);
for (UInt16 index = 1; index <= items && supported == false ; ++index)
{
ItemReference theItem;
FlavorType theType ;
UInt16 flavors = 0 ;
GetDragItemReferenceNumber(m_currentDrag, index, &theItem);
CountDragItemFlavors( m_currentDrag, theItem , &flavors ) ;
for ( UInt16 flavor = 1 ; flavor <= flavors ; ++flavor )
{
result = GetFlavorType(m_currentDrag, theItem, flavor , &theType);
if ( m_dataObject->IsSupportedFormat( wxDataFormat( theType ) ) )
{
supported = true ;
break ;
}
}
}
}
return supported ;
}
bool wxDropTarget::GetData()
{
if (!m_dataObject)
return FALSE;
if ( !CurrentDragHasSupportedFormat() )
return FALSE ;
bool transferred = false ;
if ( gTrackingGlobals.m_currentSource != NULL )
{
wxDataObject* data = gTrackingGlobals.m_currentSource->GetDataObject() ;
if ( data )
{
int 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;
CountDragItems(m_currentDrag, &items);
for (UInt16 index = 1; index <= items; ++index)
{
ItemReference theItem;
FlavorType theType ;
UInt16 flavors = 0 ;
GetDragItemReferenceNumber(m_currentDrag, index, &theItem);
CountDragItemFlavors( m_currentDrag, theItem , &flavors ) ;
for ( UInt16 flavor = 1 ; flavor <= flavors ; ++flavor )
{
result = GetFlavorType(m_currentDrag, theItem, flavor , &theType);
wxDataFormat format(theType) ;
if ( m_dataObject->IsSupportedFormat( format ) )
{
FlavorFlags theFlags;
result = GetFlavorFlags(m_currentDrag, theItem, theType, &theFlags);
if (result == noErr)
{
Size dataSize ;
Ptr theData ;
GetFlavorDataSize(m_currentDrag, theItem, theType, &dataSize);
if ( theType == 'TEXT' )
dataSize++ ;
theData = new char[dataSize];
GetFlavorData(m_currentDrag, theItem, theType, (void*) theData, &dataSize, 0L);
if( theType == 'TEXT' )
{
theData[dataSize]=0 ;
if ( wxApp::s_macDefaultEncodingIsPC )
{
wxMacConvertToPC((char*)theData) ;
}
m_dataObject->SetData( format, dataSize, theData );
}
else if ( theType == kDragFlavorTypeHFS )
{
HFSFlavor* theFile = (HFSFlavor*) theData ;
wxString name = wxMacFSSpec2MacFilename( &theFile->fileSpec ) ;
m_dataObject->SetData( format , name.Length() + 1, name ) ;
}
else
{
m_dataObject->SetData( format, dataSize, theData );
}
delete[] theData;
}
break ;
}
}
}
}
return TRUE ;
}
#endif
//-------------------------------------------------------------------------
// wxDropSource
@ -103,39 +230,286 @@ wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
//-----------------------------------------------------------------------------
// drag request
wxDropSource::wxDropSource( wxWindow *win )
wxDropSource::wxDropSource(wxWindow *win,
const wxIcon &iconCopy,
const wxIcon &iconMove,
const wxIcon &iconNone)
{
// TODO
// m_window = win;
m_data = NULL;
wxMacEnsureTrackingHandlersInstalled() ;
m_window = win;
}
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
wxDropSource::wxDropSource(wxDataObject& data,
wxWindow *win,
const wxIcon &iconCopy,
const wxIcon &iconMove,
const wxIcon &iconNone)
{
// TODO
// m_window = win;
m_data = &data;
wxMacEnsureTrackingHandlersInstalled() ;
SetData( data );
m_window = win;
}
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
void wxDropSource::SetData( wxDataObject &data )
wxDropSource::~wxDropSource()
{
m_data = &data;
};
}
wxDropSource::~wxDropSource(void)
{
};
wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
{
// TODO
return wxDragError;
};
wxDragResult wxDropSource::DoDragDrop( bool allowMove )
{
wxASSERT_MSG( m_data, wxT("Drop source: no data") );
if (!m_data)
return (wxDragResult) wxDragNone;
if (m_data->GetFormatCount() == 0)
return (wxDragResult) wxDragNone;
OSErr result;
DragReference theDrag;
RgnHandle dragRegion;
if (result = NewDrag(&theDrag))
{
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 ( int 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' )
{
dataSize-- ;
if ( wxApp::s_macDefaultEncodingIsPC )
{
wxMacConvertFromPC((char*)dataPtr) ;
}
AddDragItemFlavor(theDrag, theItem, type , dataPtr, dataSize, 0);
}
else if (type == kDragFlavorTypeHFS )
{
HFSFlavor theFlavor ;
OSErr err = noErr;
CInfoPBRec cat;
wxMacFilename2FSSpec( dataPtr , &theFlavor.fileSpec ) ;
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 = wxTheApp->MacGetCurrentEvent() ;
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 ;
return wxDragCopy ;
}
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 )
{
OSErr result;
result = InstallTrackingHandler(NewDragTrackingHandlerUPP(wxMacWindowDragTrackingHandler), 0L,&gTrackingGlobals);
wxASSERT( result == noErr ) ;
result = InstallReceiveHandler(NewDragReceiveHandlerUPP(wxMacWindowDragReceiveHandler), 0L, &gTrackingGlobals);
wxASSERT( result == noErr ) ;
gTrackingGlobalsInstalled = true ;
}
}
pascal OSErr wxMacWindowDragTrackingHandler(DragTrackingMessage theMessage, WindowPtr theWindow,
void *handlerRefCon, DragReference theDrag)
{
MacTrackingGlobals* trackingGlobals = (MacTrackingGlobals*) handlerRefCon;
Point mouse, localMouse;
DragAttributes attributes;
RgnHandle hiliteRgn;
GetDragAttributes(theDrag, &attributes);
wxTopLevelWindowMac* toplevel = wxFindWinFromMacWindow( theWindow ) ;
switch(theMessage)
{
case kDragTrackingEnterHandler:
break;
case kDragTrackingLeaveHandler:
break;
case kDragTrackingEnterWindow:
trackingGlobals->m_currentTargetWindow = NULL ;
trackingGlobals->m_currentTarget = NULL ;
break;
case kDragTrackingInWindow:
if (toplevel == NULL)
break;
GetDragMouse(theDrag, &mouse, 0L);
localMouse = mouse;
GlobalToLocal(&localMouse);
// if (attributes & kDragHasLeftSenderWindow)
{
wxPoint point(localMouse.h , localMouse.v) ;
wxWindow *win = NULL ;
toplevel->MacGetWindowFromPointSub( point , &win ) ;
int localx , localy ;
localx = localMouse.h ;
localy = localMouse.v ;
//TODO : should we use client coordinates
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 ) ;
if ( trackingGlobals->m_currentTarget->OnEnter(
localx , localy , wxDragCopy ) != wxDragNone )
{
int x , y ;
x = y = 0 ;
win->MacWindowToRootWindow( &x , &y ) ;
RgnHandle hiliteRgn = NewRgn() ;
SetRectRgn( hiliteRgn , x , y , x+win->GetSize().x ,y+win->GetSize().y) ;
ShowDragHilite(theDrag, hiliteRgn, true);
DisposeRgn( hiliteRgn ) ;
}
}
}
}
else
{
if( trackingGlobals->m_currentTarget )
{
trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag ) ;
trackingGlobals->m_currentTarget->OnDragOver(
localx , localy , wxDragCopy ) ;
}
}
}
// MyTrackItemUnderMouse(localMouse, theWindow);
break;
case kDragTrackingLeaveWindow:
if (trackingGlobals->m_currentTarget)
{
trackingGlobals->m_currentTarget->SetCurrentDrag( theDrag ) ;
trackingGlobals->m_currentTarget->OnLeave() ;
HideDragHilite(theDrag);
trackingGlobals->m_currentTarget = NULL ;
}
trackingGlobals->m_currentTargetWindow = NULL ;
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 ) )
{
trackingGlobals->m_currentTarget->OnData( localx , localy , wxDragCopy ) ;
}
}
return(noErr);
}
#endif

31
src/mac/metafile.cpp
View File

@ -92,10 +92,13 @@ bool wxMetaFile::SetClipboard(int width, int height)
if (!alreadyOpen)
{
wxTheClipboard->Open();
if (!wxTheClipboard->Clear()) return FALSE;
wxTheClipboard->Clear();
}
bool success = wxSetClipboardData(wxDF_METAFILE, this, width,height);
if (!alreadyOpen) wxCloseClipboard();
wxDataObject *data =
new wxMetafileDataObject( *this) ;
bool success = wxTheClipboard->SetData(data);
if (!alreadyOpen)
wxTheClipboard->Close();
return (bool) success;
#endif
return TRUE ;
@ -184,4 +187,26 @@ wxMetaFile *wxMetaFileDC::Close()
return m_metaFile;
}
#if wxUSE_DATAOBJ
size_t wxMetafileDataObject::GetDataSize() const
{
return GetHandleSize( (Handle) (*((wxMetafile*)&m_metafile)).GetHMETAFILE() ) ;
}
bool wxMetafileDataObject::GetDataHere(void *buf) const
{
memcpy( buf , (*(*((wxMetafile*)&m_metafile)).GetHMETAFILE()) ,
GetHandleSize( (Handle) (*((wxMetafile*)&m_metafile)).GetHMETAFILE() ) ) ;
return true ;
}
bool wxMetafileDataObject::SetData(size_t len, const void *buf)
{
Handle handle = (Handle) m_metafile.GetHMETAFILE() ;
SetHandleSize( handle , len ) ;
memcpy( *handle , buf , len ) ;
return true ;
}
#endif
#endif

2
src/mac/toplevel.cpp
View File

@ -40,6 +40,7 @@
#include "wx/mac/uma.h"
#include "wx/mac/aga.h"
#include "wx/tooltip.h"
#include "wx/dnd.h"
#define wxMAC_DEBUG_REDRAW 0
#ifndef wxMAC_DEBUG_REDRAW
@ -680,3 +681,4 @@ void wxTopLevelWindowMac::MacInvalidate( const Rect * rect, bool eraseBackground
#endif
SetPort( formerPort ) ;
}

73
src/mac/window.cpp
View File

@ -120,10 +120,6 @@ void wxWindowMac::Init()
m_hScrollBar = NULL ;
m_vScrollBar = NULL ;
#if wxUSE_DRAG_AND_DROP
m_pDropTarget = NULL;
#endif
}
// Destructor
@ -273,12 +269,12 @@ void wxWindowMac::ReleaseMouse()
void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
{
if ( m_pDropTarget != 0 ) {
delete m_pDropTarget;
if ( m_dropTarget != 0 ) {
delete m_dropTarget;
}
m_pDropTarget = pDropTarget;
if ( m_pDropTarget != 0 )
m_dropTarget = pDropTarget;
if ( m_dropTarget != 0 )
{
// TODO
}
@ -1300,16 +1296,28 @@ wxWindowMac* wxWindowMac::s_lastMouseWindow = NULL ;
bool wxWindowMac::MacGetWindowFromPointSub( const wxPoint &point , wxWindowMac** outWin )
{
if ((point.x < m_x) || (point.y < m_y) ||
(point.x > (m_x + m_width)) || (point.y > (m_y + m_height)))
return FALSE;
if ( IsTopLevel() )
{
if ((point.x < 0) || (point.y < 0) ||
(point.x > (m_width)) || (point.y > (m_height)))
return FALSE;
}
else
{
if ((point.x < m_x) || (point.y < m_y) ||
(point.x > (m_x + m_width)) || (point.y > (m_y + m_height)))
return FALSE;
}
WindowRef window = MacGetRootWindow() ;
wxPoint newPoint( point ) ;
newPoint.x -= m_x;
newPoint.y -= m_y;
if ( !IsTopLevel() )
{
newPoint.x -= m_x;
newPoint.y -= m_y;
}
for (wxNode *node = GetChildren().First(); node; node = node->Next())
{
@ -1332,13 +1340,13 @@ bool wxWindowMac::MacGetWindowFromPoint( const wxPoint &screenpoint , wxWindowMa
Point pt = { screenpoint.y , screenpoint.x } ;
if ( ::FindWindow( pt , &window ) == 3 )
{
wxPoint point( screenpoint ) ;
wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
{
win->ScreenToClient( point ) ;
wxPoint point( screenpoint ) ;
wxWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
{
point = win->ScreenToClient( point ) ;
return win->MacGetWindowFromPointSub( point , outWin ) ;
}
}
}
return FALSE ;
}
@ -1442,19 +1450,22 @@ const wxRegion& wxWindowMac::MacGetVisibleRegion()
DiffRgn( visRgn , tempRgn , visRgn ) ;
}
wxWindow* parent = GetParent() ;
while( parent )
if ( !IsTopLevel() )
{
wxSize size = parent->GetSize() ;
int x , y ;
x = y = 0 ;
parent->MacWindowToRootWindow( &x, &y ) ;
MacRootWindowToWindow( &x , &y ) ;
SetRectRgn( tempRgn , x , y , x + size.x , y + size.y ) ;
SectRgn( visRgn , tempRgn , visRgn ) ;
if ( parent->IsTopLevel() )
break ;
parent = parent->GetParent() ;
wxWindow* parent = GetParent() ;
while( parent )
{
wxSize size = parent->GetSize() ;
int x , y ;
x = y = 0 ;
parent->MacWindowToRootWindow( &x, &y ) ;
MacRootWindowToWindow( &x , &y ) ;
SetRectRgn( tempRgn , x , y , x + size.x , y + size.y ) ;
SectRgn( visRgn , tempRgn , visRgn ) ;
if ( parent->IsTopLevel() )
break ;
parent = parent->GetParent() ;
}
}
if ( GetWindowStyle() & wxCLIP_CHILDREN )
{

BIN
src/makemac7.mcp
View File

Binary file not shown.