src/mac/carbon/dnd.cpp

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