src/mac/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        app.cpp
   3 // Purpose:     wxApp
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "app.h"
  14 #endif
  15
  16 #include "wx/defs.h"
  17
  18 #include "wx/window.h"
  19 #include "wx/frame.h"
  20 #include "wx/button.h"
  21 #include "wx/app.h"
  22 #include "wx/utils.h"
  23 #include "wx/gdicmn.h"
  24 #include "wx/pen.h"
  25 #include "wx/brush.h"
  26 #include "wx/cursor.h"
  27 #include "wx/intl.h"
  28 #include "wx/icon.h"
  29 #include "wx/palette.h"
  30 #include "wx/dc.h"
  31 #include "wx/dialog.h"
  32 #include "wx/msgdlg.h"
  33 #include "wx/log.h"
  34 #include "wx/module.h"
  35 #include "wx/memory.h"
  36 #include "wx/tooltip.h"
  37 #include "wx/textctrl.h"
  38 #include "wx/menu.h"
  39 #if wxUSE_WX_RESOURCES
  40 #  include "wx/resource.h"
  41 #endif
  42
  43 #include <string.h>
  44
  45 // mac
  46
  47 #ifndef __DARWIN__
  48   #if __option(profile)
  49     #include <profiler.h>
  50   #endif
  51 #endif
  52
  53 #include "apprsrc.h"
  54
  55 #include "wx/mac/uma.h"
  56 #include "wx/mac/macnotfy.h"
  57
  58 #ifdef __DARWIN__
  59 #  include <CoreServices/CoreServices.h>
  60 #  if defined(WXMAKINGDLL)
  61 #    include <mach-o/dyld.h>
  62 #  endif
  63 #else
  64 #  include <Sound.h>
  65 #  include <Threads.h>
  66 #  include <ToolUtils.h>
  67 #  include <DiskInit.h>
  68 #  include <Devices.h>
  69 #endif
  70
  71 extern char *wxBuffer;
  72 extern wxList wxPendingDelete;
  73 extern wxList *wxWinMacWindowList;
  74 extern wxList *wxWinMacControlList;
  75
  76 wxApp *wxTheApp = NULL;
  77
  78 #if !USE_SHARED_LIBRARY
  79 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
  80 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
  81     EVT_IDLE(wxApp::OnIdle)
  82         EVT_END_SESSION(wxApp::OnEndSession)
  83         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
  84 END_EVENT_TABLE()
  85 #endif
  86
  87
  88 const short    kMacMinHeap = (29 * 1024) ;
  89 // platform specific static variables
  90
  91 const short kwxMacMenuBarResource = 1 ;
  92 const short kwxMacAppleMenuId = 1 ;
  93
  94 WXHRGN    wxApp::s_macCursorRgn = NULL;
  95 wxWindow* wxApp::s_captureWindow = NULL ;
  96 int       wxApp::s_lastMouseDown = 0 ;
  97 long      wxApp::sm_lastMessageTime = 0;
  98 long      wxApp::s_lastModifiers = 0 ;
  99
 100
 101 bool      wxApp::s_macDefaultEncodingIsPC = true ;
 102 bool      wxApp::s_macSupportPCMenuShortcuts = true ;
 103 long      wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
 104 wxString  wxApp::s_macHelpMenuTitleName = "&Help" ;
 105
 106 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 107 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 108 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 109 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 110
 111
 112 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 113 {
 114     // GD: UNUSED wxApp* app = (wxApp*) refcon ;
 115     return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
 116 }
 117
 118 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 119 {
 120     // GD: UNUSED wxApp* app = (wxApp*) refcon ;
 121     return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
 122 }
 123
 124 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 125 {
 126     // GD: UNUSED wxApp* app = (wxApp*) refcon ;
 127     return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
 128 }
 129
 130 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 131 {
 132     // GD: UNUSED wxApp* app = (wxApp*) refcon ;
 133     return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
 134 }
 135
 136 short wxApp::MacHandleAEODoc(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 137 {
 138     SysBeep(40) ;
 139     ProcessSerialNumber PSN ;
 140     PSN.highLongOfPSN = 0 ;
 141     PSN.lowLongOfPSN = kCurrentProcess ;
 142     SetFrontProcess( &PSN ) ;
 143     return noErr ;
 144 }
 145
 146 short wxApp::MacHandleAEPDoc(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 147 {
 148     return noErr ;
 149 }
 150
 151 short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 152 {
 153     return noErr ;
 154 }
 155
 156 short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 157 {
 158     wxWindow* win = GetTopWindow() ;
 159     if ( win )
 160     {
 161         win->Close(TRUE ) ;
 162     }
 163     else
 164     {
 165         ExitMainLoop() ;
 166     }
 167     return noErr ;
 168 }
 169
 170 char StringMac[] =  "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
 171                     "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
 172                     "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
 173                     "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
 174                     "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
 175                     "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
 176
 177 char StringANSI[] = "\x0a\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
 178                     "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
 179                     "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
 180                     "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
 181                     "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
 182                     "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
 183
 184 void wxMacConvertFromPC( const char *from , char *to , int len )
 185 {
 186     char *c ;
 187     if ( from == to )
 188     {
 189         for( int i = 0 ; i < len ; ++ i )
 190         {
 191             c = strchr( StringANSI , *from ) ;
 192             if ( c != NULL )
 193             {
 194                 *to = StringMac[ c - StringANSI] ;
 195             }
 196             ++to ;
 197             ++from ;
 198         }
 199     }
 200     else
 201     {
 202         for( int i = 0 ; i < len ; ++ i )
 203         {
 204             c = strchr( StringANSI , *from ) ;
 205             if ( c != NULL )
 206             {
 207                 *to = StringMac[ c - StringANSI] ;
 208             }
 209             else
 210             {
 211                 *to = *from ;
 212             }
 213             ++to ;
 214             ++from ;
 215         }
 216     }
 217 }
 218
 219 void wxMacConvertToPC( const char *from , char *to , int len )
 220 {
 221     char *c ;
 222     if ( from == to )
 223     {
 224         for( int i = 0 ; i < len ; ++ i )
 225         {
 226             c = strchr( StringMac , *from ) ;
 227             if ( c != NULL )
 228             {
 229                 *to = StringANSI[ c - StringMac] ;
 230             }
 231             ++to ;
 232             ++from ;
 233         }
 234     }
 235     else
 236     {
 237         for( int i = 0 ; i < len ; ++ i )
 238         {
 239             c = strchr( StringMac , *from ) ;
 240             if ( c != NULL )
 241             {
 242                 *to = StringANSI[ c - StringMac] ;
 243             }
 244             else
 245             {
 246                 *to = *from ;
 247             }
 248             ++to ;
 249             ++from ;
 250         }
 251     }
 252 }
 253
 254 void wxMacConvertFromPC( char * p )
 255 {
 256     char *ptr = p ;
 257     int len = strlen ( p ) ;
 258
 259     wxMacConvertFromPC( ptr , ptr , len ) ;
 260 }
 261
 262 void wxMacConvertFromPCForControls( char * p )
 263 {
 264     char *ptr = p ;
 265     int len = strlen ( p ) ;
 266
 267     wxMacConvertFromPC( ptr , ptr , len ) ;
 268     for ( unsigned int i = 0 ; i < strlen ( ptr ) ; i++ )
 269     {
 270         if ( ptr[i] == '&' && ptr[i]+1 != ' ' )
 271         {
 272             memmove( &ptr[i] , &ptr[i+1] , strlen( &ptr[i+1] ) + 1) ;
 273         }
 274     }
 275 }
 276
 277 void wxMacConvertFromPC( unsigned char *p )
 278 {
 279     char *ptr = (char*) p + 1 ;
 280     int len = p[0] ;
 281
 282     wxMacConvertFromPC( ptr , ptr , len ) ;
 283 }
 284
 285 extern char *wxBuffer ;
 286
 287 wxString wxMacMakeMacStringFromPC( const char * p )
 288 {
 289     const char *ptr = p ;
 290     int len = strlen ( p ) ;
 291     char *buf = wxBuffer ;
 292
 293     if ( len >= BUFSIZ + 512 )
 294     {
 295         buf = new char [len+1] ;
 296     }
 297
 298     wxMacConvertFromPC( ptr , buf , len ) ;
 299     buf[len] = 0 ;
 300     wxString result( buf ) ;
 301     if ( buf != wxBuffer )
 302         delete buf ;
 303     return result ;
 304 }
 305
 306
 307 void wxMacConvertToPC( char * p )
 308 {
 309     char *ptr = p ;
 310     int len = strlen ( p ) ;
 311
 312     wxMacConvertToPC( ptr , ptr , len ) ;
 313 }
 314
 315 void wxMacConvertToPC( unsigned char *p )
 316 {
 317     char *ptr = (char*) p + 1 ;
 318     int len = p[0] ;
 319
 320     wxMacConvertToPC( ptr , ptr , len ) ;
 321 }
 322
 323 wxString wxMacMakePCStringFromMac( const char * p )
 324 {
 325     const char *ptr = p ;
 326     int len = strlen ( p ) ;
 327     char *buf = wxBuffer ;
 328
 329     if ( len >= BUFSIZ + 512 )
 330     {
 331         buf = new char [len+1] ;
 332     }
 333
 334     wxMacConvertToPC( ptr , buf , len ) ;
 335     buf[len] = 0 ;
 336
 337     wxString result( buf ) ;
 338     if ( buf != wxBuffer )
 339         delete buf ;
 340     return result ;
 341 }
 342
 343 wxString wxMacMakeStringFromMacString( const char* from , bool mac2pcEncoding )
 344 {
 345     if (mac2pcEncoding)
 346     {
 347       return wxMacMakePCStringFromMac( from ) ;
 348     }
 349     else
 350     {
 351       return wxString( from ) ;
 352     }
 353 }
 354
 355 wxString wxMacMakeStringFromPascal( StringPtr from , bool mac2pcEncoding )
 356 {
 357   // this is safe since a pascal string can never be larger than 256 bytes
 358   char s[256] ;
 359   CopyPascalStringToC( from , s ) ;
 360     if (mac2pcEncoding)
 361     {
 362       return wxMacMakePCStringFromMac( s ) ;
 363     }
 364     else
 365     {
 366       return wxString( s ) ;
 367     }
 368 }
 369
 370 void wxMacStringToPascal( const char * from , StringPtr to , bool pc2macEncoding )
 371 {
 372     if (pc2macEncoding)
 373     {
 374       CopyCStringToPascal( wxMacMakeMacStringFromPC( from ) , to ) ;
 375     }
 376     else
 377     {
 378       CopyCStringToPascal( from , to ) ;
 379     }
 380 }
 381
 382 #if defined(WXMAKINGDLL) && !defined(__DARWIN__)
 383 // we know it's there ;-)
 384 WXIMPORT char std::__throws_bad_alloc ;
 385 #endif
 386
 387 bool wxApp::Initialize()
 388 {
 389     int error = 0 ;
 390
 391     // Mac-specific
 392
 393     UMAInitToolbox( 4 ) ;
 394     SetEventMask( everyEvent ) ;
 395     UMAShowWatchCursor() ;
 396
 397 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
 398     // open shared library resources from here since we don't have
 399     //   __wxinitialize in Mach-O shared libraries
 400     wxStAppResource::OpenSharedLibraryResource(NULL);
 401 #endif
 402
 403 #if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
 404     AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
 405                            NewAEEventHandlerUPP(AEHandleODoc) ,
 406                            (long) wxTheApp , FALSE ) ;
 407     AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
 408                            NewAEEventHandlerUPP(AEHandleOApp) ,
 409                            (long) wxTheApp , FALSE ) ;
 410     AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
 411                            NewAEEventHandlerUPP(AEHandlePDoc) ,
 412                            (long) wxTheApp , FALSE ) ;
 413     AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
 414                            NewAEEventHandlerUPP(AEHandleQuit) ,
 415                            (long) wxTheApp , FALSE ) ;
 416 #else
 417     AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
 418                            NewAEEventHandlerProc(AEHandleODoc) ,
 419                            (long) wxTheApp , FALSE ) ;
 420     AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
 421                            NewAEEventHandlerProc(AEHandleOApp) ,
 422                            (long) wxTheApp , FALSE ) ;
 423     AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
 424                            NewAEEventHandlerProc(AEHandlePDoc) ,
 425                            (long) wxTheApp , FALSE ) ;
 426     AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
 427                            NewAEEventHandlerProc(AEHandleQuit) ,
 428                            (long) wxTheApp , FALSE ) ;
 429 #endif
 430
 431 #ifndef __DARWIN__
 432     // test the minimal configuration necessary
 433
 434 #  if !TARGET_CARBON
 435     long theSystem ;
 436     long theMachine;
 437
 438     if (Gestalt(gestaltMachineType, &theMachine) != noErr)
 439     {
 440         error = kMacSTRWrongMachine;
 441     }
 442     else if (theMachine < gestaltMacPlus)
 443     {
 444         error = kMacSTRWrongMachine;
 445     }
 446     else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
 447     {
 448         error = kMacSTROldSystem  ;
 449     }
 450     else if ( theSystem < 0x0860 )
 451     {
 452         error = kMacSTROldSystem  ;
 453     }
 454     else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
 455     {
 456         error = kMacSTRSmallSize;
 457     }
 458 #  endif
 459     /*
 460     else
 461     {
 462         if ( !UMAHasAppearance() )
 463         {
 464             error = kMacSTRNoPre8Yet ;
 465         }
 466     }
 467     */
 468 #endif
 469
 470     // if we encountered any problems so far, give the error code and exit immediately
 471
 472   if ( error )
 473   {
 474         wxStAppResource resload ;
 475         short itemHit;
 476         Str255 message;
 477
 478         GetIndString(message, 128, error);
 479         UMAShowArrowCursor() ;
 480         ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
 481         itemHit = Alert(128, nil);
 482       return FALSE ;
 483   }
 484
 485 #ifndef __DARWIN__
 486 #  if __option(profile)
 487     ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
 488 #  endif
 489 #endif
 490
 491 #ifndef __DARWIN__
 492     // now avoid exceptions thrown for new (bad_alloc)
 493     std::__throws_bad_alloc = FALSE ;
 494 #endif
 495
 496     s_macCursorRgn = ::NewRgn() ;
 497
 498     wxBuffer = new char[BUFSIZ + 512];
 499
 500     wxClassInfo::InitializeClasses();
 501
 502 #if wxUSE_RESOURCES
 503 //    wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
 504 #endif
 505
 506 #if wxUSE_THREADS
 507     wxPendingEventsLocker = new wxCriticalSection;
 508 #endif
 509
 510     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 511     wxTheColourDatabase->Initialize();
 512
 513 #ifdef __WXDEBUG__
 514 #if wxUSE_LOG
 515     // flush the logged messages if any and install a 'safer' log target: the
 516     // default one (wxLogGui) can't be used after the resources are freed just
 517     // below and the user suppliedo ne might be even more unsafe (using any
 518     // wxWindows GUI function is unsafe starting from now)
 519     wxLog::DontCreateOnDemand();
 520
 521     // this will flush the old messages if any
 522     delete wxLog::SetActiveTarget(new wxLogStderr);
 523 #endif // wxUSE_LOG
 524 #endif
 525
 526   wxWinMacWindowList = new wxList(wxKEY_INTEGER);
 527   wxWinMacControlList = new wxList(wxKEY_INTEGER);
 528
 529   wxInitializeStockLists();
 530   wxInitializeStockObjects();
 531
 532 #if wxUSE_WX_RESOURCES
 533   wxInitializeResourceSystem();
 534 #endif
 535
 536   wxBitmap::InitStandardHandlers();
 537
 538   wxModule::RegisterModules();
 539   if (!wxModule::InitializeModules()) {
 540      return FALSE;
 541   }
 542
 543   wxMacCreateNotifierTable() ;
 544
 545
 546   UMAShowArrowCursor() ;
 547
 548   return TRUE;
 549 }
 550
 551 void wxApp::CleanUp()
 552 {
 553     wxToolTip::RemoveToolTips() ;
 554 #if wxUSE_LOG
 555     // flush the logged messages if any and install a 'safer' log target: the
 556     // default one (wxLogGui) can't be used after the resources are freed just
 557     // below and the user suppliedo ne might be even more unsafe (using any
 558     // wxWindows GUI function is unsafe starting from now)
 559     wxLog::DontCreateOnDemand();
 560
 561     // this will flush the old messages if any
 562     delete wxLog::SetActiveTarget(new wxLogStderr);
 563 #endif // wxUSE_LOG
 564
 565     // One last chance for pending objects to be cleaned up
 566     wxTheApp->DeletePendingObjects();
 567
 568     wxModule::CleanUpModules();
 569
 570 #if wxUSE_WX_RESOURCES
 571     wxCleanUpResourceSystem();
 572 #endif
 573
 574     wxDeleteStockObjects() ;
 575
 576     // Destroy all GDI lists, etc.
 577     wxDeleteStockLists();
 578
 579     delete wxTheColourDatabase;
 580     wxTheColourDatabase = NULL;
 581
 582     wxBitmap::CleanUpHandlers();
 583
 584     delete[] wxBuffer;
 585     wxBuffer = NULL;
 586
 587     wxMacDestroyNotifierTable() ;
 588     if (wxWinMacWindowList) {
 589         delete wxWinMacWindowList ;
 590     }
 591     if (wxWinMacControlList) {
 592         delete wxWinMacControlList ;
 593     }
 594     delete wxPendingEvents;
 595
 596 #if wxUSE_THREADS
 597     delete wxPendingEventsLocker;
 598     // If we don't do the following, we get an apparent memory leak.
 599     ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
 600 #endif
 601
 602     wxClassInfo::CleanUpClasses();
 603
 604 #ifndef __DARWIN__
 605 #  if __option(profile)
 606     ProfilerDump( "\papp.prof" ) ;
 607     ProfilerTerm() ;
 608 #  endif
 609 #endif
 610
 611     delete wxTheApp;
 612     wxTheApp = NULL;
 613
 614 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 615     // At this point we want to check if there are any memory
 616     // blocks that aren't part of the wxDebugContext itself,
 617     // as a special case. Then when dumping we need to ignore
 618     // wxDebugContext, too.
 619     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 620     {
 621         wxLogDebug(wxT("There were memory leaks."));
 622         wxDebugContext::Dump();
 623         wxDebugContext::PrintStatistics();
 624     }
 625     //  wxDebugContext::SetStream(NULL, NULL);
 626 #endif
 627
 628 #if wxUSE_LOG
 629     // do it as the very last thing because everything else can log messages
 630     delete wxLog::SetActiveTarget(NULL);
 631 #endif // wxUSE_LOG
 632
 633 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
 634     // close shared library resources from here since we don't have
 635     //   __wxterminate in Mach-O shared libraries
 636     wxStAppResource::CloseSharedLibraryResource();
 637 #endif
 638
 639     UMACleanupToolbox() ;
 640     if (s_macCursorRgn) {
 641         ::DisposeRgn((RgnHandle)s_macCursorRgn);
 642     }
 643
 644     #if 0
 645         TerminateAE() ;
 646     #endif
 647 }
 648
 649 //----------------------------------------------------------------------
 650 // wxEntry
 651 //----------------------------------------------------------------------
 652
 653 // extern variable for shared library resource id
 654 // need to be able to find it with NSLookupAndBindSymbol
 655 short gSharedLibraryResource = kResFileNotOpened ;
 656
 657 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
 658 CFBundleRef gSharedLibraryBundle = NULL;
 659 #endif /* WXMAKINGDLL && __DARWIN__ */
 660
 661 wxStAppResource::wxStAppResource()
 662 {
 663     m_currentRefNum = CurResFile() ;
 664     if ( gSharedLibraryResource != kResFileNotOpened )
 665     {
 666         UseResFile( gSharedLibraryResource ) ;
 667     }
 668 }
 669
 670 wxStAppResource::~wxStAppResource()
 671 {
 672     if ( m_currentRefNum != kResFileNotOpened )
 673     {
 674         UseResFile( m_currentRefNum ) ;
 675     }
 676 }
 677
 678 void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
 679 {
 680     gSharedLibraryResource = kResFileNotOpened;
 681
 682 #ifdef WXMAKINGDLL
 683     if ( initBlock != NULL ) {
 684         const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
 685         FSSpec *fileSpec = NULL;
 686
 687         if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
 688             fileSpec = theInitBlock->fragLocator.u.onDisk.fileSpec;
 689         }
 690         else if (theInitBlock->fragLocator.where == kResourceCFragLocator) {
 691             fileSpec = theInitBlock->fragLocator.u.inSegs.fileSpec;
 692         }
 693
 694         if (fileSpec != NULL) {
 695             gSharedLibraryResource =  FSpOpenResFile(fileSpec, fsRdPerm);
 696         }
 697     }
 698     else {
 699 #ifdef __DARWIN__
 700         // Open the shared library resource file if it is not yet open
 701         NSSymbol    theSymbol;
 702         NSModule    theModule;
 703         const char *theLibPath;
 704
 705         gSharedLibraryBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
 706         if (gSharedLibraryBundle != NULL) {
 707             // wxWindows has been bundled into a framework
 708             //   load the framework resources
 709
 710             gSharedLibraryResource = CFBundleOpenBundleResourceMap(gSharedLibraryBundle);
 711         }
 712         else {
 713             // wxWindows is a simple dynamic shared library
 714             //   load the resources from the data fork of a separate resource file
 715             char  *theResPath;
 716             char  *theName;
 717             char  *theExt;
 718             FSRef  theResRef;
 719             OSErr  theErr = noErr;
 720
 721             // get the library path
 722             theSymbol = NSLookupAndBindSymbol("_gSharedLibraryResource");
 723             theModule = NSModuleForSymbol(theSymbol);
 724             theLibPath = NSLibraryNameForModule(theModule);
 725
 726             // allocate copy to replace .dylib.* extension with .rsrc
 727             theResPath = strdup(theLibPath);
 728             if (theResPath != NULL) {
 729                 theName = strrchr(theResPath, '/');
 730                 if (theName == NULL) {
 731                     // no directory elements in path
 732                     theName = theResPath;
 733                 }
 734                 // find ".dylib" shared library extension
 735                 theExt = strstr(theName, ".dylib");
 736                 // overwrite extension with ".rsrc"
 737                 strcpy(theExt, ".rsrc");
 738
 739                 wxLogDebug( theResPath );
 740
 741                 theErr = FSPathMakeRef((UInt8 *) theResPath, &theResRef, false);
 742                 if (theErr != noErr) {
 743                     // try in current directory (using name only)
 744                     theErr = FSPathMakeRef((UInt8 *) theName, &theResRef, false);
 745                 }
 746
 747                 // free duplicated resource file path
 748                 free(theResPath);
 749
 750                 // open the resource file
 751                 if (theErr == noErr) {
 752                     theErr = FSOpenResourceFile( &theResRef, 0, NULL, fsRdPerm,
 753                                                  &gSharedLibraryResource);
 754                 }
 755             }
 756         }
 757 #endif /* __DARWIN__ */
 758     }
 759 #endif /* WXMAKINGDLL */
 760 }
 761
 762 void wxStAppResource::CloseSharedLibraryResource()
 763 {
 764 #ifdef WXMAKINGDLL
 765     // Close the shared library resource file
 766     if (gSharedLibraryResource != kResFileNotOpened) {
 767 #ifdef __DARWIN__
 768         if (gSharedLibraryBundle != NULL) {
 769             CFBundleCloseBundleResourceMap(gSharedLibraryBundle,
 770                                            gSharedLibraryResource);
 771             gSharedLibraryBundle = NULL;
 772         }
 773         else
 774 #endif /* __DARWIN__ */
 775         {
 776             CloseResFile(gSharedLibraryResource);
 777         }
 778         gSharedLibraryResource = kResFileNotOpened;
 779     }
 780 #endif /* WXMAKINGDLL */
 781 }
 782
 783 #if defined(WXMAKINGDLL) && !defined(__DARWIN__)
 784
 785 // for shared libraries we have to manually get the correct resource
 786 // ref num upon initializing and releasing when terminating, therefore
 787 // the __wxinitialize and __wxterminate must be used
 788
 789 extern "C" {
 790     void __sinit(void); /*      (generated by linker)   */
 791     pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
 792     pascal void __terminate(void);
 793 }
 794
 795 pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
 796 {
 797     wxStAppResource::OpenSharedLibraryResource( theInitBlock ) ;
 798     return __initialize( theInitBlock ) ;
 799 }
 800
 801 pascal void __wxterminate(void)
 802 {
 803     wxStAppResource::CloseSharedLibraryResource() ;
 804     __terminate() ;
 805 }
 806
 807 #endif /* WXMAKINGDLL && !__DARWIN__ */
 808
 809 int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char *WXUNUSED(argv)[] )
 810 {
 811     return wxApp::Initialize();
 812 }
 813
 814 int WXDLLEXPORT wxEntryInitGui()
 815 {
 816     return wxTheApp->OnInitGui();
 817 }
 818
 819 void WXDLLEXPORT wxEntryCleanup()
 820 {
 821     wxApp::CleanUp();
 822 }
 823
 824 int wxEntry( int argc, char *argv[] , bool enterLoop )
 825 {
 826 #ifdef __MWERKS__
 827 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 828     // This seems to be necessary since there are 'rogue'
 829     // objects present at this point (perhaps global objects?)
 830     // Setting a checkpoint will ignore them as far as the
 831     // memory checking facility is concerned.
 832     // Of course you may argue that memory allocated in globals should be
 833     // checked, but this is a reasonable compromise.
 834     wxDebugContext::SetCheckpoint();
 835 #endif
 836 #endif
 837     if (!wxEntryStart(argc, argv)) {
 838         return 0;
 839     }
 840    // create the application object or ensure that one already exists
 841     if (!wxTheApp)
 842     {
 843         // The app may have declared a global application object, but we recommend
 844         // the IMPLEMENT_APP macro is used instead, which sets an initializer
 845         // function for delayed, dynamic app object construction.
 846         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 847                      wxT("No initializer - use IMPLEMENT_APP macro.") );
 848
 849         wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
 850     }
 851
 852     wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
 853
 854 #ifdef __DARWIN__
 855     // Mac OS X passes a process serial number command line argument when
 856     // the application is launched from the Finder. This argument must be
 857     // removed from the command line arguments before being handled by the
 858     // application (otherwise applications would need to handle it)
 859
 860     if (argc > 1) {
 861         char theArg[6] = "";
 862         strncpy(theArg, argv[1], 5);
 863
 864         if (strcmp(theArg, "-psn_") == 0) {
 865             // assume the argument is always the only one and remove it
 866             --argc;
 867         }
 868     }
 869 #else
 870     argc = 0 ; // currently we don't support files as parameters
 871 #endif
 872     // we could try to get the open apple events here to adjust argc and argv better
 873
 874     wxTheApp->argc = argc;
 875     wxTheApp->argv = argv;
 876
 877     // GUI-specific initialization, such as creating an app context.
 878     wxEntryInitGui();
 879
 880     // Here frames insert themselves automatically
 881     // into wxTopLevelWindows by getting created
 882     // in OnInit().
 883
 884     int retValue = 0;
 885
 886     if ( wxTheApp->OnInit() )
 887     {
 888         if ( enterLoop )
 889         {
 890             retValue = wxTheApp->OnRun();
 891         }
 892         else
 893             // We want to initialize, but not run or exit immediately.
 894             return 1;
 895     }
 896     //else: app initialization failed, so we skipped OnRun()
 897
 898     wxWindow *topWindow = wxTheApp->GetTopWindow();
 899     if ( topWindow )
 900     {
 901         // Forcibly delete the window.
 902         if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 903                 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 904         {
 905             topWindow->Close(TRUE);
 906             wxTheApp->DeletePendingObjects();
 907         }
 908         else
 909         {
 910             delete topWindow;
 911             wxTheApp->SetTopWindow(NULL);
 912         }
 913     }
 914
 915     wxTheApp->OnExit();
 916
 917     wxEntryCleanup();
 918
 919     return retValue;
 920 }
 921
 922 #if TARGET_CARBON
 923
 924 bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
 925 {
 926     bool converted = ConvertEventRefToEventRecord( event,rec) ;
 927     OSStatus err = noErr ;
 928     if ( !converted )
 929     {
 930         switch( GetEventClass( event ) )
 931         {
 932             case kEventClassKeyboard :
 933             {
 934                 converted = true ;
 935                 switch( GetEventKind(event) )
 936                 {
 937                     case kEventRawKeyDown :
 938                         rec->what = keyDown ;
 939                         break ;
 940                     case kEventRawKeyRepeat :
 941                         rec->what = autoKey ;
 942                         break ;
 943                     case kEventRawKeyUp :
 944                         rec->what = keyUp ;
 945                         break ;
 946                     case kEventRawKeyModifiersChanged :
 947                         rec->what = nullEvent ;
 948                         break ;
 949                     default :
 950                         converted = false ;
 951                         break ;
 952                 }
 953                 if ( converted )
 954                 {
 955                     UInt32 keyCode ;
 956                     unsigned char charCode ;
 957                     UInt32 modifiers ;
 958                     GetMouse( &rec->where) ;
 959
 960                     err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
 961                     err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
 962                     err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
 963                     rec->modifiers = modifiers ;
 964                     rec->message = (keyCode << 8 ) + charCode ;
 965                 }
 966             }
 967             break ;
 968             case kEventClassTextInput :
 969             {
 970                 switch( GetEventKind( event ) )
 971                 {
 972                     case kEventTextInputUnicodeForKeyEvent :
 973                         {
 974                             EventRef rawEvent ;
 975                             err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
 976                             converted = true ;
 977                             {
 978                                 UInt32 keyCode ;
 979                                 unsigned char charCode ;
 980                                 UInt32 modifiers ;
 981                                 GetMouse( &rec->where) ;
 982                                 rec->what = keyDown ;
 983                                 err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
 984                                 err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
 985                                 err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
 986                                 rec->modifiers = modifiers ;
 987                                 rec->message = (keyCode << 8 ) + charCode ;
 988                             }
 989                        }
 990                         break ;
 991                     default :
 992                         break ;
 993                 }
 994             }
 995             break ;
 996         }
 997     }
 998
 999     return converted ;
1000 }
1001
1002 pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
1003 {
1004     OSStatus result = eventNotHandledErr ;
1005
1006     EventRecord rec ;
1007     switch ( GetEventClass( event ) )
1008     {
1009         case kEventClassKeyboard :
1010             if ( wxMacConvertEventToRecord( event , &rec ) )
1011             {
1012                 wxTheApp->MacHandleModifierEvents( &rec ) ;
1013                 wxTheApp->MacHandleOneEvent( &rec ) ;
1014                 result = noErr ;
1015             }
1016             break ;
1017         case kEventClassTextInput :
1018             if ( wxMacConvertEventToRecord( event , &rec ) )
1019             {
1020                 wxTheApp->MacHandleModifierEvents( &rec ) ;
1021                 wxTheApp->MacHandleOneEvent( &rec ) ;
1022                 result = noErr ;
1023             }
1024             break ;
1025         default :
1026             break ;
1027     }
1028     return result ;
1029 }
1030
1031 #endif
1032
1033 bool wxApp::OnInit()
1034 {
1035     if ( ! wxAppBase::OnInit() )
1036         return FALSE ;
1037
1038 #if 0 // TARGET_CARBON
1039         static const EventTypeSpec eventList[] =
1040         {
1041             { kEventClassKeyboard, kEventRawKeyDown } ,
1042             { kEventClassKeyboard, kEventRawKeyRepeat } ,
1043             { kEventClassKeyboard, kEventRawKeyUp } ,
1044             { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
1045
1046             { kEventClassTextInput , kEventTextInputUnicodeForKeyEvent } ,
1047         } ;
1048
1049         InstallApplicationEventHandler(NewEventHandlerUPP(wxMacApplicationEventHandler)
1050             , WXSIZEOF(eventList), eventList, this, NULL);
1051 #endif
1052     return TRUE ;
1053 }
1054 // Static member initialization
1055 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
1056
1057 wxApp::wxApp()
1058 {
1059   m_topWindow = NULL;
1060   wxTheApp = this;
1061
1062 #if WXWIN_COMPATIBILITY_2_2
1063   m_wantDebugOutput = TRUE;
1064 #endif
1065
1066   argc = 0;
1067   argv = NULL;
1068
1069   m_printMode = wxPRINT_WINDOWS;
1070   SetExitOnFrameDelete(TRUE);
1071   m_auto3D = TRUE;
1072 }
1073
1074 bool wxApp::Initialized()
1075 {
1076   if (GetTopWindow())
1077     return TRUE;
1078   else
1079     return FALSE;
1080 }
1081
1082 int wxApp::MainLoop()
1083 {
1084   m_keepGoing = TRUE;
1085
1086   while (m_keepGoing)
1087   {
1088         MacDoOneEvent() ;
1089   }
1090
1091   return 0;
1092 }
1093
1094 // Returns TRUE if more time is needed.
1095 bool wxApp::ProcessIdle()
1096 {
1097     wxIdleEvent event;
1098     event.SetEventObject(this);
1099     ProcessEvent(event);
1100
1101     return event.MoreRequested();
1102 }
1103
1104 void wxApp::ExitMainLoop()
1105 {
1106   m_keepGoing = FALSE;
1107 }
1108
1109 // Is a message/event pending?
1110 bool wxApp::Pending()
1111 {
1112     EventRecord event ;
1113
1114   return EventAvail( everyEvent , &event ) ;
1115 }
1116
1117 // Dispatch a message.
1118 void wxApp::Dispatch()
1119 {
1120     MacDoOneEvent() ;
1121 }
1122
1123 void wxApp::OnIdle(wxIdleEvent& event)
1124 {
1125    static bool s_inOnIdle = FALSE;
1126
1127     // Avoid recursion (via ProcessEvent default case)
1128     if ( s_inOnIdle )
1129         return;
1130
1131
1132   s_inOnIdle = TRUE;
1133
1134   // 'Garbage' collection of windows deleted with Close().
1135   DeletePendingObjects();
1136
1137   // flush the logged messages if any
1138   wxLog *pLog = wxLog::GetActiveTarget();
1139   if ( pLog != NULL && pLog->HasPendingMessages() )
1140     pLog->Flush();
1141
1142   // Send OnIdle events to all windows
1143   bool needMore = SendIdleEvents();
1144
1145   if (needMore)
1146     event.RequestMore(TRUE);
1147
1148     // If they are pending events, we must process them: pending events are
1149     // either events to the threads other than main or events posted with
1150     // wxPostEvent() functions
1151     wxMacProcessNotifierAndPendingEvents();
1152
1153   s_inOnIdle = FALSE;
1154 }
1155
1156 void wxWakeUpIdle()
1157 {
1158     wxMacWakeUp() ;
1159 }
1160
1161 // Send idle event to all top-level windows
1162 bool wxApp::SendIdleEvents()
1163 {
1164     bool needMore = FALSE;
1165     wxNode* node = wxTopLevelWindows.First();
1166     while (node)
1167     {
1168         wxWindow* win = (wxWindow*) node->Data();
1169         if (SendIdleEvents(win))
1170             needMore = TRUE;
1171
1172         node = node->Next();
1173     }
1174     return needMore;
1175 }
1176
1177 // Send idle event to window and all subwindows
1178 bool wxApp::SendIdleEvents(wxWindow* win)
1179 {
1180     bool needMore = FALSE;
1181
1182     wxIdleEvent event;
1183     event.SetEventObject(win);
1184     win->ProcessEvent(event);
1185
1186     if (event.MoreRequested())
1187         needMore = TRUE;
1188
1189     wxNode* node = win->GetChildren().First();
1190     while (node)
1191     {
1192         wxWindow* win = (wxWindow*) node->Data();
1193         if (SendIdleEvents(win))
1194             needMore = TRUE;
1195
1196         node = node->Next();
1197     }
1198     return needMore ;
1199 }
1200
1201 void wxApp::DeletePendingObjects()
1202 {
1203   wxNode *node = wxPendingDelete.First();
1204   while (node)
1205   {
1206     wxObject *obj = (wxObject *)node->Data();
1207
1208     delete obj;
1209
1210     if (wxPendingDelete.Member(obj))
1211       delete node;
1212
1213     // Deleting one object may have deleted other pending
1214     // objects, so start from beginning of list again.
1215     node = wxPendingDelete.First();
1216   }
1217 }
1218
1219 void wxExit()
1220 {
1221     wxLogError(_("Fatal error: exiting"));
1222
1223     wxApp::CleanUp();
1224     ::ExitToShell() ;
1225 }
1226
1227 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1228 {
1229     if (GetTopWindow())
1230         GetTopWindow()->Close(TRUE);
1231 }
1232
1233 // Default behaviour: close the application with prompts. The
1234 // user can veto the close, and therefore the end session.
1235 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1236 {
1237     if (GetTopWindow())
1238     {
1239         if (!GetTopWindow()->Close(!event.CanVeto()))
1240             event.Veto(TRUE);
1241     }
1242 }
1243
1244 extern "C" void wxCYield() ;
1245 void wxCYield()
1246 {
1247     wxYield() ;
1248 }
1249
1250 // Yield to other processes
1251
1252 bool wxApp::Yield(bool onlyIfNeeded)
1253 {
1254     static bool s_inYield = FALSE;
1255
1256     if (s_inYield)
1257     {
1258         if ( !onlyIfNeeded )
1259         {
1260             wxFAIL_MSG( wxT("wxYield called recursively" ) );
1261         }
1262
1263         return FALSE;
1264     }
1265
1266     s_inYield = TRUE;
1267
1268 #if wxUSE_THREADS
1269     YieldToAnyThread() ;
1270 #endif
1271     EventRecord event ;
1272
1273     long sleepTime = 1 ; //::GetCaretTime();
1274
1275     while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
1276     {
1277         wxTheApp->MacHandleModifierEvents( &event ) ;
1278         wxTheApp->MacHandleOneEvent( &event );
1279         if ( event.what != kHighLevelEvent )
1280             SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
1281     }
1282     wxTheApp->MacHandleModifierEvents( &event ) ;
1283
1284     wxMacProcessNotifierAndPendingEvents() ;
1285
1286     s_inYield = FALSE;
1287
1288     return TRUE;
1289 }
1290
1291 // platform specifics
1292
1293 void wxApp::MacSuspend( bool convertClipboard )
1294 {
1295     // we have to deactive the top level windows manually
1296
1297     wxNode* node = wxTopLevelWindows.First();
1298     while (node)
1299     {
1300         wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
1301         win->MacActivate( MacGetCurrentEvent() , false ) ;
1302
1303         node = node->Next();
1304     }
1305
1306     s_lastMouseDown = 0 ;
1307     if( convertClipboard )
1308     {
1309         MacConvertPrivateToPublicScrap() ;
1310     }
1311
1312     ::HideFloatingWindows() ;
1313 }
1314
1315 extern wxList wxModalDialogs;
1316
1317 void wxApp::MacResume( bool convertClipboard )
1318 {
1319     s_lastMouseDown = 0 ;
1320     if( convertClipboard )
1321     {
1322         MacConvertPublicToPrivateScrap() ;
1323     }
1324
1325     ::ShowFloatingWindows() ;
1326
1327     // raise modal dialogs in case a non modal window was selected to activate the app
1328
1329     wxNode* node = wxModalDialogs.First();
1330     while (node)
1331     {
1332         wxDialog* dialog = (wxDialog *) node->Data();
1333         dialog->Raise();
1334
1335         node = node->Next();
1336     }
1337 }
1338
1339 void wxApp::MacConvertPrivateToPublicScrap()
1340 {
1341 }
1342
1343 void wxApp::MacConvertPublicToPrivateScrap()
1344 {
1345 }
1346
1347 void wxApp::MacDoOneEvent()
1348 {
1349   EventRecord event ;
1350
1351     long sleepTime = 1; // GetCaretTime() / 4 ;
1352
1353     if (WaitNextEvent(everyEvent, &event, sleepTime, (RgnHandle) s_macCursorRgn))
1354     {
1355         MacHandleModifierEvents( &event ) ;
1356         MacHandleOneEvent( &event );
1357     }
1358     else
1359     {
1360         MacHandleModifierEvents( &event ) ;
1361         // idlers
1362         WindowPtr window = ::FrontWindow() ;
1363         if ( window )
1364             ::IdleControls( window ) ;
1365
1366         wxTheApp->ProcessIdle() ;
1367     }
1368     if ( event.what != kHighLevelEvent )
1369         SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
1370
1371     // repeaters
1372
1373     DeletePendingObjects() ;
1374     wxMacProcessNotifierAndPendingEvents() ;
1375 }
1376
1377 void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
1378 {
1379     EventRecord* ev = (EventRecord*) evr ;
1380 #if TARGET_CARBON
1381     if ( ev->what == mouseDown || ev->what == mouseUp || ev->what == activateEvt ||
1382         ev->what == keyDown || ev->what == autoKey || ev->what == keyUp || ev->what == nullEvent )
1383     {
1384         // in these cases the modifiers are already correctly setup by carbon
1385     }
1386     else
1387     {
1388         ev->modifiers = GetCurrentKeyModifiers() ;
1389     }
1390 #endif
1391     if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
1392     {
1393         wxKeyEvent event(wxEVT_KEY_DOWN);
1394
1395         event.m_shiftDown = ev->modifiers & shiftKey;
1396         event.m_controlDown = ev->modifiers & controlKey;
1397         event.m_altDown = ev->modifiers & optionKey;
1398         event.m_metaDown = ev->modifiers & cmdKey;
1399
1400         event.m_x = ev->where.h;
1401         event.m_y = ev->where.v;
1402         event.m_timeStamp = ev->when;
1403         wxWindow* focus = wxWindow::FindFocus() ;
1404         event.SetEventObject(focus);
1405
1406         if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
1407         {
1408             event.m_keyCode = WXK_CONTROL ;
1409             event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1410             focus->GetEventHandler()->ProcessEvent( event ) ;
1411         }
1412         if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
1413         {
1414             event.m_keyCode = WXK_SHIFT ;
1415             event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1416             focus->GetEventHandler()->ProcessEvent( event ) ;
1417         }
1418         if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
1419         {
1420             event.m_keyCode = WXK_ALT ;
1421             event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1422             focus->GetEventHandler()->ProcessEvent( event ) ;
1423         }
1424         s_lastModifiers = ev->modifiers ;
1425     }
1426 }
1427
1428 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1429 {
1430     EventRecord* ev = (EventRecord*) evr ;
1431     m_macCurrentEvent = ev ;
1432
1433     wxApp::sm_lastMessageTime = ev->when ;
1434
1435     switch (ev->what)
1436     {
1437         case mouseDown:
1438             MacHandleMouseDownEvent( ev ) ;
1439             if ( ev->modifiers & controlKey )
1440                 s_lastMouseDown = 2;
1441             else
1442                 s_lastMouseDown = 1;
1443             break;
1444         case mouseUp:
1445             if ( s_lastMouseDown == 2 )
1446             {
1447                 ev->modifiers |= controlKey ;
1448             }
1449             else
1450             {
1451                 ev->modifiers &= ~controlKey ;
1452             }
1453             MacHandleMouseUpEvent( ev ) ;
1454             s_lastMouseDown = 0;
1455             break;
1456         case activateEvt:
1457             MacHandleActivateEvent( ev ) ;
1458             break;
1459         case updateEvt:
1460             MacHandleUpdateEvent( ev ) ;
1461             break;
1462         case keyDown:
1463         case autoKey:
1464             MacHandleKeyDownEvent( ev ) ;
1465             break;
1466         case keyUp:
1467             MacHandleKeyUpEvent( ev ) ;
1468             break;
1469         case diskEvt:
1470             MacHandleDiskEvent( ev ) ;
1471             break;
1472         case osEvt:
1473             MacHandleOSEvent( ev ) ;
1474             break;
1475         case kHighLevelEvent:
1476             MacHandleHighLevelEvent( ev ) ;
1477             break;
1478         default:
1479             break;
1480     }
1481     wxMacProcessNotifierAndPendingEvents() ;
1482 }
1483
1484 void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
1485 {
1486     EventRecord* ev = (EventRecord*) evr ;
1487     ::AEProcessAppleEvent( ev ) ;
1488 }
1489
1490 bool s_macIsInModalLoop = false ;
1491
1492 void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
1493 {
1494     EventRecord* ev = (EventRecord*) evr ;
1495     wxToolTip::RemoveToolTips() ;
1496
1497     WindowRef window;
1498     WindowRef frontWindow = ::FrontNonFloatingWindow() ;
1499     WindowAttributes frontWindowAttributes = NULL ;
1500     if ( frontWindow )
1501         ::GetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
1502
1503     short windowPart = ::FindWindow(ev->where, &window);
1504     wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1505     if ( wxPendingDelete.Member(win) )
1506         return ;
1507
1508     BitMap screenBits;
1509     GetQDGlobalsScreenBits( &screenBits );
1510
1511     switch (windowPart)
1512     {
1513         case inMenuBar :
1514             if ( s_macIsInModalLoop )
1515             {
1516                 SysBeep ( 30 ) ;
1517             }
1518             else
1519             {
1520                 UInt32 menuresult = MenuSelect(ev->where) ;
1521                 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
1522                 s_lastMouseDown = 0;
1523             }
1524             break ;
1525 #if !TARGET_CARBON
1526         case inSysWindow :
1527             SystemClick( ev , window ) ;
1528             s_lastMouseDown = 0;
1529             break ;
1530 #endif
1531         case inDrag :
1532             if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
1533             {
1534                 SysBeep ( 30 ) ;
1535             }
1536             else
1537             {
1538                 DragWindow(window, ev->where, &screenBits.bounds);
1539                 if (win)
1540                 {
1541                     GrafPtr port ;
1542                     GetPort( &port ) ;
1543                     Point pt = { 0, 0 } ;
1544                     SetPortWindowPort(window) ;
1545                     LocalToGlobal( &pt ) ;
1546                     SetPort( port ) ;
1547                         win->SetSize( pt.h , pt.v , -1 ,
1548                             -1 , wxSIZE_USE_EXISTING);
1549                 }
1550                 s_lastMouseDown = 0;
1551             }
1552             break ;
1553         case inGoAway:
1554             if (TrackGoAway(window, ev->where))
1555             {
1556                 if ( win )
1557                     win->Close() ;
1558             }
1559             s_lastMouseDown = 0;
1560             break;
1561         case inGrow:
1562           {
1563                 int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
1564                 if (growResult != 0)
1565                 {
1566                     int newWidth = LoWord(growResult);
1567                     int newHeight = HiWord(growResult);
1568                     int oldWidth, oldHeight;
1569
1570
1571                     if (win)
1572                     {
1573                         win->GetSize(&oldWidth, &oldHeight);
1574                         if (newWidth == 0)
1575                             newWidth = oldWidth;
1576                         if (newHeight == 0)
1577                             newHeight = oldHeight;
1578                         win->SetSize( -1, -1 , newWidth, newHeight, wxSIZE_USE_EXISTING);
1579                     }
1580                 }
1581                 s_lastMouseDown = 0;
1582           }
1583             break;
1584         case inZoomIn:
1585         case inZoomOut:
1586                 if (TrackBox(window, ev->where, windowPart))
1587                 {
1588                     // TODO setup size event
1589                     ZoomWindow( window , windowPart , false ) ;
1590                     if (win)
1591                     {
1592                         Rect tempRect ;
1593                         GrafPtr port ;
1594                         GetPort( &port ) ;
1595                         Point pt = { 0, 0 } ;
1596                         SetPortWindowPort(window) ;
1597                         LocalToGlobal( &pt ) ;
1598                         SetPort( port ) ;
1599
1600                         GetWindowPortBounds(window, &tempRect ) ;
1601                         win->SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
1602                             tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
1603                     }
1604                 }
1605             s_lastMouseDown = 0;
1606             break;
1607         case inCollapseBox :
1608                 // TODO setup size event
1609             s_lastMouseDown = 0;
1610             break ;
1611
1612         case inContent :
1613                 {
1614                     GrafPtr port ;
1615                     GetPort( &port ) ;
1616                     SetPortWindowPort(window) ;
1617                     SetPort( port ) ;
1618                 }
1619                 if ( window != frontWindow && wxTheApp->s_captureWindow == NULL )
1620                 {
1621                     if ( s_macIsInModalLoop )
1622                     {
1623                         SysBeep ( 30 ) ;
1624                     }
1625                     else if ( UMAIsWindowFloating( window ) )
1626                     {
1627                         if ( win )
1628                             win->MacMouseDown( ev , windowPart ) ;
1629                     }
1630                     else
1631                     {
1632                         if ( win )
1633                             win->MacMouseDown( ev , windowPart ) ;
1634                         ::SelectWindow( window ) ;
1635                     }
1636                 }
1637                 else
1638                 {
1639                     if ( win )
1640                         win->MacMouseDown( ev , windowPart ) ;
1641                 }
1642             break ;
1643
1644         default:
1645             break;
1646     }
1647 }
1648
1649 void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
1650 {
1651     EventRecord* ev = (EventRecord*) evr ;
1652     WindowRef window;
1653
1654     short windowPart = inNoWindow ;
1655         if ( wxTheApp->s_captureWindow )
1656         {
1657                 window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
1658                 windowPart = inContent ;
1659         }
1660         else
1661         {
1662                 windowPart = ::FindWindow(ev->where, &window) ;
1663         }
1664
1665     switch (windowPart)
1666     {
1667         case inMenuBar :
1668             break ;
1669         case inSysWindow :
1670             break ;
1671         default:
1672             {
1673                 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1674                 if ( win )
1675                     win->MacMouseUp( ev , windowPart ) ;
1676             }
1677             break;
1678     }
1679 }
1680
1681 long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1682 long wxMacTranslateKey(unsigned char key, unsigned char code)
1683 {
1684     long retval = key ;
1685     switch (key)
1686     {
1687         case 0x01 :
1688                  retval = WXK_HOME;
1689           break;
1690         case 0x03 :
1691                  retval = WXK_RETURN;
1692           break;
1693         case 0x04 :
1694                  retval = WXK_END;
1695           break;
1696         case 0x05 :
1697                  retval = WXK_HELP;
1698           break;
1699         case 0x08 :
1700                  retval = WXK_BACK;
1701           break;
1702         case 0x09 :
1703                  retval = WXK_TAB;
1704           break;
1705         case 0x0b :
1706                  retval = WXK_PAGEUP;
1707           break;
1708         case 0x0c :
1709                  retval = WXK_PAGEDOWN;
1710           break;
1711         case 0x0d :
1712                  retval = WXK_RETURN;
1713           break;
1714             case 0x10 :
1715             {
1716                 switch( code )
1717                 {
1718                     case 0x7a :
1719                         retval = WXK_F1 ;
1720                         break;
1721                     case 0x78 :
1722                         retval = WXK_F2 ;
1723                         break;
1724                     case 0x63 :
1725                         retval = WXK_F3 ;
1726                         break;
1727                     case 0x76 :
1728                         retval = WXK_F4 ;
1729                         break;
1730                     case 0x60 :
1731                         retval = WXK_F5 ;
1732                         break;
1733                     case 0x61 :
1734                         retval = WXK_F6 ;
1735                         break;
1736                     case 0x62:
1737                         retval = WXK_F7 ;
1738                         break;
1739                     case 0x64 :
1740                         retval = WXK_F8 ;
1741                         break;
1742                     case 0x65 :
1743                         retval = WXK_F9 ;
1744                         break;
1745                     case 0x6D :
1746                         retval = WXK_F10 ;
1747                         break;
1748                     case 0x67 :
1749                         retval = WXK_F11 ;
1750                         break;
1751                     case 0x6F :
1752                         retval = WXK_F12 ;
1753                         break;
1754                     case 0x69 :
1755                         retval = WXK_F13 ;
1756                         break;
1757                     case 0x6B :
1758                         retval = WXK_F14 ;
1759                         break;
1760                     case 0x71 :
1761                         retval = WXK_F15 ;
1762                         break;
1763                 }
1764             }
1765             break ;
1766             case 0x1b :
1767                 retval = WXK_ESCAPE ;
1768             break ;
1769             case 0x1c :
1770                 retval = WXK_LEFT ;
1771             break ;
1772             case 0x1d :
1773                 retval = WXK_RIGHT ;
1774             break ;
1775             case 0x1e :
1776                 retval = WXK_UP ;
1777             break ;
1778             case 0x1f :
1779                 retval = WXK_DOWN ;
1780             break ;
1781             case 0x7F :
1782                 retval = WXK_DELETE ;
1783              default:
1784             break ;
1785      } // end switch
1786
1787     return retval;
1788 }
1789
1790 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
1791 {
1792     EventRecord* ev = (EventRecord*) evr ;
1793     wxToolTip::RemoveToolTips() ;
1794
1795     UInt32 menuresult = UMAMenuEvent(ev) ;
1796     if ( HiWord( menuresult ) )
1797     {
1798         if ( !s_macIsInModalLoop )
1799             MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1800     }
1801     else
1802     {
1803         short keycode ;
1804         short keychar ;
1805         keychar = short(ev->message & charCodeMask);
1806         keycode = short(ev->message & keyCodeMask) >> 8 ;
1807         wxWindow* focus = wxWindow::FindFocus() ;
1808         // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
1809         if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
1810         {
1811             keychar += 0x40 ;
1812         }
1813         long keyval = wxMacTranslateKey(keychar, keycode) ;
1814
1815         if ( MacSendKeyDownEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
1816         {
1817             // has not been handled -> perform default
1818             wxControl* control = wxDynamicCast( focus , wxControl ) ;
1819             if ( control &&  control->GetMacControl() != NULL )
1820             {
1821                 ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
1822             }
1823         }
1824     }
1825 }
1826
1827 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keyval , long modifiers , long when , short wherex , short wherey )
1828 {
1829     wxKeyEvent event(wxEVT_KEY_DOWN);
1830     bool handled = false ;
1831     event.m_shiftDown = modifiers & shiftKey;
1832     event.m_controlDown = modifiers & controlKey;
1833     event.m_altDown = modifiers & optionKey;
1834     event.m_metaDown = modifiers & cmdKey;
1835     event.m_keyCode = wxToupper(keyval );
1836
1837     event.m_x = wherex;
1838     event.m_y = wherey;
1839     event.m_timeStamp = when;
1840     event.SetEventObject(focus);
1841     handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1842     if ( handled && event.GetSkipped() )
1843         handled = false ;
1844     if ( !handled )
1845     {
1846 #if wxUSE_ACCEL
1847         if (!handled)
1848         {
1849             wxWindow *ancestor = focus;
1850             while (ancestor)
1851             {
1852                 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1853                 if (command != -1)
1854                 {
1855                     wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1856                     handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1857                     break;
1858                 }
1859                 if (ancestor->IsTopLevel())
1860                     break;
1861                 ancestor = ancestor->GetParent();
1862             }
1863         }
1864 #endif // wxUSE_ACCEL
1865     }
1866     if (!handled)
1867     {
1868         event.Skip( FALSE ) ;
1869         event.SetEventType( wxEVT_CHAR ) ;
1870         event.m_keyCode = keyval ;
1871
1872         handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1873         if ( handled && event.GetSkipped() )
1874             handled = false ;
1875     }
1876     if ( !handled &&
1877          (keyval == WXK_TAB) &&
1878 // CS: copied the change below from wxGTK
1879 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1880 //     have this style, yet choose not to process this particular TAB in which
1881 //     case TAB must still work as a navigational character
1882 #if 0
1883          (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1884 #endif
1885          (focus->GetParent()) &&
1886          (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1887     {
1888         wxNavigationKeyEvent new_event;
1889         new_event.SetEventObject( focus );
1890         new_event.SetDirection( !event.ShiftDown() );
1891         /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1892         new_event.SetWindowChange( event.ControlDown() );
1893         new_event.SetCurrentFocus( focus );
1894         handled = focus->GetEventHandler()->ProcessEvent( new_event );
1895         if ( handled && new_event.GetSkipped() )
1896             handled = false ;
1897     }
1898     // backdoor handler for default return and command escape
1899     if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1900     {
1901           // if window is not having a focus still testing for default enter or cancel
1902           // TODO add the UMA version for ActiveNonFloatingWindow
1903           wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1904           if ( focus )
1905           {
1906             if ( keyval == WXK_RETURN )
1907             {
1908                  wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1909                                                        wxButton);
1910                  if ( def && def->IsEnabled() )
1911                  {
1912                      wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1913                      event.SetEventObject(def);
1914                      def->Command(event);
1915                      return true ;
1916                 }
1917             }
1918             /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1919             else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1920             {
1921                   wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1922                   new_event.SetEventObject( focus );
1923                   handled = focus->GetEventHandler()->ProcessEvent( new_event );
1924             }
1925           }
1926     }
1927     return handled ;
1928 }
1929
1930
1931 void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
1932 {
1933     EventRecord* ev = (EventRecord*) evr ;
1934     wxToolTip::RemoveToolTips() ;
1935
1936     UInt32 menuresult = UMAMenuEvent(ev) ;
1937     if ( HiWord( menuresult ) )
1938     {
1939     }
1940     else
1941     {
1942         short keycode ;
1943         short keychar ;
1944         keychar = short(ev->message & charCodeMask);
1945         keycode = short(ev->message & keyCodeMask) >> 8 ;
1946         // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
1947         if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
1948         {
1949             keychar += 0x40 ;
1950         }
1951         long keyval = wxMacTranslateKey(keychar, keycode) ;
1952
1953         wxWindow* focus = wxWindow::FindFocus() ;
1954         bool handled = MacSendKeyUpEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
1955         // we don't have to do anything under classic here
1956     }
1957 }
1958
1959 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keyval , long modifiers , long when , short wherex , short wherey )
1960 {
1961     bool handled = false ;
1962     if ( focus )
1963     {
1964         wxKeyEvent event(wxEVT_KEY_UP);
1965         event.m_shiftDown = modifiers & shiftKey;
1966         event.m_controlDown = modifiers & controlKey;
1967         event.m_altDown = modifiers & optionKey;
1968         event.m_metaDown = modifiers & cmdKey;
1969         event.m_keyCode = wxToupper(keyval );
1970
1971         event.m_x = wherex;
1972         event.m_y = wherey;
1973         event.m_timeStamp = when;
1974         event.SetEventObject(focus);
1975         handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1976     }
1977     return handled ;
1978 }
1979 void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
1980 {
1981     EventRecord* ev = (EventRecord*) evr ;
1982     WindowRef window = (WindowRef) ev->message ;
1983     if ( window )
1984     {
1985         bool activate = (ev->modifiers & activeFlag ) ;
1986         WindowClass wclass ;
1987         ::GetWindowClass ( window , &wclass ) ;
1988         if ( wclass == kFloatingWindowClass )
1989         {
1990             // if it is a floater we activate/deactivate the front non-floating window instead
1991             window = ::FrontNonFloatingWindow() ;
1992         }
1993         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1994         if ( win )
1995             win->MacActivate( ev , activate ) ;
1996     }
1997 }
1998
1999 void wxApp::MacHandleUpdateEvent( WXEVENTREF evr )
2000 {
2001     EventRecord* ev = (EventRecord*) evr ;
2002     WindowRef window = (WindowRef) ev->message ;
2003     wxTopLevelWindowMac * win = wxFindWinFromMacWindow( window ) ;
2004     if ( win )
2005     {
2006         if ( !wxPendingDelete.Member(win) )
2007             win->MacUpdate( ev->when ) ;
2008     }
2009     else
2010     {
2011         // since there is no way of telling this foreign window to update itself
2012         // we have to invalidate the update region otherwise we keep getting the same
2013         // event over and over again
2014         BeginUpdate( window ) ;
2015         EndUpdate( window ) ;
2016     }
2017 }
2018
2019 void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
2020 {
2021     EventRecord* ev = (EventRecord*) evr ;
2022     if ( HiWord( ev->message ) != noErr )
2023   {
2024  #if !TARGET_CARBON
2025         OSErr err ;
2026         Point point ;
2027          SetPt( &point , 100 , 100 ) ;
2028
2029           err = DIBadMount( point , ev->message ) ;
2030         wxASSERT( err == noErr ) ;
2031 #endif
2032     }
2033 }
2034
2035 void wxApp::MacHandleOSEvent( WXEVENTREF evr )
2036 {
2037     EventRecord* ev = (EventRecord*) evr ;
2038     switch( ( ev->message & osEvtMessageMask ) >> 24 )
2039     {
2040         case suspendResumeMessage :
2041             {
2042                 bool isResuming = ev->message & resumeFlag ;
2043 #if !TARGET_CARBON
2044                 bool convertClipboard = ev->message & convertClipboardFlag ;
2045 #else
2046                 bool convertClipboard = false;
2047 #endif
2048                 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
2049                 if ( isResuming )
2050                 {
2051                     WindowRef oldFrontWindow = NULL ;
2052                     WindowRef newFrontWindow = NULL ;
2053
2054                     // in case we don't take care of activating ourselves, we have to synchronize
2055                     // our idea of the active window with the process manager's - which it already activated
2056
2057                     if ( !doesActivate )
2058                         oldFrontWindow = ::FrontNonFloatingWindow() ;
2059
2060                     MacResume( convertClipboard ) ;
2061
2062                     newFrontWindow = ::FrontNonFloatingWindow() ;
2063
2064                     if ( oldFrontWindow )
2065                     {
2066                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
2067                         if ( win )
2068                             win->MacActivate( ev , false ) ;
2069                     }
2070                     if ( newFrontWindow )
2071                     {
2072                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
2073                         if ( win )
2074                             win->MacActivate( ev , true ) ;
2075                     }
2076                 }
2077                 else
2078                 {
2079                     MacSuspend( convertClipboard ) ;
2080
2081                     // in case this suspending did close an active window, another one might
2082                     // have surfaced -> lets deactivate that one
2083
2084 /* TODO : find out what to do on systems < 10 , perhaps FrontNonFloatingWindow
2085                     WindowRef newActiveWindow = ::ActiveNonFloatingWindow() ;
2086                     if ( newActiveWindow )
2087                     {
2088                         wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
2089                         if ( win )
2090                             win->MacActivate( ev , false ) ;
2091                     }
2092 */
2093                 }
2094             }
2095             break ;
2096         case mouseMovedMessage :
2097             {
2098                 WindowRef window;
2099
2100                 wxWindow* currentMouseWindow = NULL ;
2101
2102                 wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
2103                                                  &currentMouseWindow ) ;
2104                 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
2105                 {
2106                     wxMouseEvent event ;
2107
2108                     bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
2109                     bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
2110
2111                     event.m_leftDown = isDown && !controlDown;
2112                     event.m_middleDown = FALSE;
2113                     event.m_rightDown = isDown && controlDown;
2114                     event.m_shiftDown = ev->modifiers & shiftKey;
2115                     event.m_controlDown = ev->modifiers & controlKey;
2116                     event.m_altDown = ev->modifiers & optionKey;
2117                     event.m_metaDown = ev->modifiers & cmdKey;
2118                     event.m_x = ev->where.h;
2119                     event.m_y = ev->where.v;
2120                     event.m_timeStamp = ev->when;
2121                     event.SetEventObject(this);
2122
2123                     if ( wxWindow::s_lastMouseWindow )
2124                     {
2125                         wxMouseEvent eventleave(event);
2126                         eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
2127                         wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
2128                         eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
2129
2130                         wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
2131                     }
2132                     if ( currentMouseWindow )
2133                     {
2134                         wxMouseEvent evententer(event);
2135                         evententer.SetEventType( wxEVT_ENTER_WINDOW );
2136                         currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
2137                         evententer.SetEventObject( currentMouseWindow ) ;
2138                         currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
2139                     }
2140                     wxWindow::s_lastMouseWindow = currentMouseWindow ;
2141                 }
2142
2143                 short windowPart = ::FindWindow(ev->where, &window);
2144
2145                 switch (windowPart)
2146                 {
2147                     // fixes for setting the cursor back from dominic mazzoni
2148                     case inMenuBar :
2149                         UMAShowArrowCursor();
2150                         break ;
2151                     case inSysWindow :
2152                         UMAShowArrowCursor();
2153                         break ;
2154                     default:
2155                         {
2156                             wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
2157                             if ( win )
2158                                 win->MacMouseMoved( ev , windowPart ) ;
2159                             else
2160                                 UMAShowArrowCursor();
2161
2162                         }
2163                         break;
2164                 }
2165             }
2166             break ;
2167
2168     }
2169 }
2170
2171 void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
2172 {
2173     if (macMenuId == 0)
2174          return; // no menu item selected
2175
2176     if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
2177     {
2178         #if ! TARGET_CARBON
2179         Str255        deskAccessoryName ;
2180         GrafPtr        savedPort ;
2181
2182         GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
2183         GetPort(&savedPort);
2184         OpenDeskAcc(deskAccessoryName);
2185         SetPort(savedPort);
2186         #endif
2187     }
2188     else
2189     {
2190         wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() )  ;
2191         if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
2192             wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
2193     }
2194     HiliteMenu(0);
2195 }
2196
2197 /*
2198 long wxApp::MacTranslateKey(char key, int mods)
2199 {
2200 }
2201
2202 void wxApp::MacAdjustCursor()
2203 {
2204 }
2205
2206 */
2207 /*
2208 void
2209 wxApp::macAdjustCursor()
2210 {
2211   if (ev->what != kHighLevelEvent)
2212   {
2213     wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
2214     if (theMacWxFrame)
2215     {
2216         if (!theMacWxFrame->MacAdjustCursor(ev->where))
2217         ::SetCursor(&(qd.arrow));
2218       }
2219   }
2220 }
2221 */