src/mac/carbon/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   m_exitOnFrameDelete = 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 ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
1381     {
1382         wxKeyEvent event(wxEVT_KEY_DOWN);
1383
1384         event.m_shiftDown = ev->modifiers & shiftKey;
1385         event.m_controlDown = ev->modifiers & controlKey;
1386         event.m_altDown = ev->modifiers & optionKey;
1387         event.m_metaDown = ev->modifiers & cmdKey;
1388
1389         event.m_x = ev->where.h;
1390         event.m_y = ev->where.v;
1391         event.m_timeStamp = ev->when;
1392         wxWindow* focus = wxWindow::FindFocus() ;
1393         event.SetEventObject(focus);
1394
1395         if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
1396         {
1397             event.m_keyCode = WXK_CONTROL ;
1398             event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1399             focus->GetEventHandler()->ProcessEvent( event ) ;
1400         }
1401         if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
1402         {
1403             event.m_keyCode = WXK_SHIFT ;
1404             event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1405             focus->GetEventHandler()->ProcessEvent( event ) ;
1406         }
1407         if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
1408         {
1409             event.m_keyCode = WXK_ALT ;
1410             event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1411             focus->GetEventHandler()->ProcessEvent( event ) ;
1412         }
1413         s_lastModifiers = ev->modifiers ;
1414     }
1415 }
1416
1417 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1418 {
1419     EventRecord* ev = (EventRecord*) evr ;
1420     m_macCurrentEvent = ev ;
1421
1422     wxApp::sm_lastMessageTime = ev->when ;
1423
1424     switch (ev->what)
1425     {
1426         case mouseDown:
1427             MacHandleMouseDownEvent( ev ) ;
1428             if ( ev->modifiers & controlKey )
1429                 s_lastMouseDown = 2;
1430             else
1431                 s_lastMouseDown = 1;
1432             break;
1433         case mouseUp:
1434             if ( s_lastMouseDown == 2 )
1435             {
1436                 ev->modifiers |= controlKey ;
1437             }
1438             else
1439             {
1440                 ev->modifiers &= ~controlKey ;
1441             }
1442             MacHandleMouseUpEvent( ev ) ;
1443             s_lastMouseDown = 0;
1444             break;
1445         case activateEvt:
1446             MacHandleActivateEvent( ev ) ;
1447             break;
1448         case updateEvt:
1449             MacHandleUpdateEvent( ev ) ;
1450             break;
1451         case keyDown:
1452         case autoKey:
1453             MacHandleKeyDownEvent( ev ) ;
1454             break;
1455         case keyUp:
1456             MacHandleKeyUpEvent( ev ) ;
1457             break;
1458         case diskEvt:
1459             MacHandleDiskEvent( ev ) ;
1460             break;
1461         case osEvt:
1462             MacHandleOSEvent( ev ) ;
1463             break;
1464         case kHighLevelEvent:
1465             MacHandleHighLevelEvent( ev ) ;
1466             break;
1467         default:
1468             break;
1469     }
1470     wxMacProcessNotifierAndPendingEvents() ;
1471 }
1472
1473 void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
1474 {
1475     EventRecord* ev = (EventRecord*) evr ;
1476     ::AEProcessAppleEvent( ev ) ;
1477 }
1478
1479 bool s_macIsInModalLoop = false ;
1480
1481 void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
1482 {
1483     EventRecord* ev = (EventRecord*) evr ;
1484     wxToolTip::RemoveToolTips() ;
1485
1486     WindowRef window;
1487     WindowRef frontWindow = ::FrontNonFloatingWindow() ;
1488     WindowAttributes frontWindowAttributes = NULL ;
1489     if ( frontWindow )
1490         ::GetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
1491
1492     short windowPart = ::FindWindow(ev->where, &window);
1493     wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1494     if ( wxPendingDelete.Member(win) )
1495         return ;
1496
1497     BitMap screenBits;
1498     GetQDGlobalsScreenBits( &screenBits );
1499
1500     switch (windowPart)
1501     {
1502         case inMenuBar :
1503             if ( s_macIsInModalLoop )
1504             {
1505                 SysBeep ( 30 ) ;
1506             }
1507             else
1508             {
1509                 UInt32 menuresult = MenuSelect(ev->where) ;
1510                 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
1511                 s_lastMouseDown = 0;
1512             }
1513             break ;
1514 #if !TARGET_CARBON
1515         case inSysWindow :
1516             SystemClick( ev , window ) ;
1517             s_lastMouseDown = 0;
1518             break ;
1519 #endif
1520         case inDrag :
1521             if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
1522             {
1523                 SysBeep ( 30 ) ;
1524             }
1525             else
1526             {
1527                 DragWindow(window, ev->where, &screenBits.bounds);
1528                 if (win)
1529                 {
1530                     GrafPtr port ;
1531                     GetPort( &port ) ;
1532                     Point pt = { 0, 0 } ;
1533                     SetPortWindowPort(window) ;
1534                     LocalToGlobal( &pt ) ;
1535                     SetPort( port ) ;
1536                         win->SetSize( pt.h , pt.v , -1 ,
1537                             -1 , wxSIZE_USE_EXISTING);
1538                 }
1539                 s_lastMouseDown = 0;
1540             }
1541             break ;
1542         case inGoAway:
1543             if (TrackGoAway(window, ev->where))
1544             {
1545                 if ( win )
1546                     win->Close() ;
1547             }
1548             s_lastMouseDown = 0;
1549             break;
1550         case inGrow:
1551           {
1552                 int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
1553                 if (growResult != 0)
1554                 {
1555                     int newWidth = LoWord(growResult);
1556                     int newHeight = HiWord(growResult);
1557                     int oldWidth, oldHeight;
1558
1559
1560                     if (win)
1561                     {
1562                         win->GetSize(&oldWidth, &oldHeight);
1563                         if (newWidth == 0)
1564                             newWidth = oldWidth;
1565                         if (newHeight == 0)
1566                             newHeight = oldHeight;
1567                         win->SetSize( -1, -1 , newWidth, newHeight, wxSIZE_USE_EXISTING);
1568                     }
1569                 }
1570                 s_lastMouseDown = 0;
1571           }
1572             break;
1573         case inZoomIn:
1574         case inZoomOut:
1575                 if (TrackBox(window, ev->where, windowPart))
1576                 {
1577                     // TODO setup size event
1578                     ZoomWindow( window , windowPart , false ) ;
1579                     if (win)
1580                     {
1581                         Rect tempRect ;
1582                         GrafPtr port ;
1583                         GetPort( &port ) ;
1584                         Point pt = { 0, 0 } ;
1585                         SetPortWindowPort(window) ;
1586                         LocalToGlobal( &pt ) ;
1587                         SetPort( port ) ;
1588
1589                         GetWindowPortBounds(window, &tempRect ) ;
1590                         win->SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
1591                             tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
1592                     }
1593                 }
1594             s_lastMouseDown = 0;
1595             break;
1596         case inCollapseBox :
1597                 // TODO setup size event
1598             s_lastMouseDown = 0;
1599             break ;
1600
1601         case inContent :
1602                 {
1603                     GrafPtr port ;
1604                     GetPort( &port ) ;
1605                     SetPortWindowPort(window) ;
1606                     SetPort( port ) ;
1607                 }
1608                 if ( window != frontWindow && wxTheApp->s_captureWindow == NULL )
1609                 {
1610                     if ( s_macIsInModalLoop )
1611                     {
1612                         SysBeep ( 30 ) ;
1613                     }
1614                     else if ( UMAIsWindowFloating( window ) )
1615                     {
1616                         if ( win )
1617                             win->MacMouseDown( ev , windowPart ) ;
1618                     }
1619                     else
1620                     {
1621                         if ( win )
1622                             win->MacMouseDown( ev , windowPart ) ;
1623                         ::SelectWindow( window ) ;
1624                     }
1625                 }
1626                 else
1627                 {
1628                     if ( win )
1629                         win->MacMouseDown( ev , windowPart ) ;
1630                 }
1631             break ;
1632
1633         default:
1634             break;
1635     }
1636 }
1637
1638 void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
1639 {
1640     EventRecord* ev = (EventRecord*) evr ;
1641     WindowRef window;
1642
1643     short windowPart = inNoWindow ;
1644         if ( wxTheApp->s_captureWindow )
1645         {
1646                 window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
1647                 windowPart = inContent ;
1648         }
1649         else
1650         {
1651                 windowPart = ::FindWindow(ev->where, &window) ;
1652         }
1653
1654     switch (windowPart)
1655     {
1656         case inMenuBar :
1657             break ;
1658         case inSysWindow :
1659             break ;
1660         default:
1661             {
1662                 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1663                 if ( win )
1664                     win->MacMouseUp( ev , windowPart ) ;
1665             }
1666             break;
1667     }
1668 }
1669
1670 long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1671 long wxMacTranslateKey(unsigned char key, unsigned char code)
1672 {
1673     long retval = key ;
1674     switch (key)
1675     {
1676         case 0x01 :
1677                  retval = WXK_HOME;
1678           break;
1679         case 0x03 :
1680                  retval = WXK_RETURN;
1681           break;
1682         case 0x04 :
1683                  retval = WXK_END;
1684           break;
1685         case 0x05 :
1686                  retval = WXK_HELP;
1687           break;
1688         case 0x08 :
1689                  retval = WXK_BACK;
1690           break;
1691         case 0x09 :
1692                  retval = WXK_TAB;
1693           break;
1694         case 0x0b :
1695                  retval = WXK_PAGEUP;
1696           break;
1697         case 0x0c :
1698                  retval = WXK_PAGEDOWN;
1699           break;
1700         case 0x0d :
1701                  retval = WXK_RETURN;
1702           break;
1703             case 0x10 :
1704             {
1705                 switch( code )
1706                 {
1707                     case 0x7a :
1708                         retval = WXK_F1 ;
1709                         break;
1710                     case 0x78 :
1711                         retval = WXK_F2 ;
1712                         break;
1713                     case 0x63 :
1714                         retval = WXK_F3 ;
1715                         break;
1716                     case 0x76 :
1717                         retval = WXK_F4 ;
1718                         break;
1719                     case 0x60 :
1720                         retval = WXK_F5 ;
1721                         break;
1722                     case 0x61 :
1723                         retval = WXK_F6 ;
1724                         break;
1725                     case 0x62:
1726                         retval = WXK_F7 ;
1727                         break;
1728                     case 0x64 :
1729                         retval = WXK_F8 ;
1730                         break;
1731                     case 0x65 :
1732                         retval = WXK_F9 ;
1733                         break;
1734                     case 0x6D :
1735                         retval = WXK_F10 ;
1736                         break;
1737                     case 0x67 :
1738                         retval = WXK_F11 ;
1739                         break;
1740                     case 0x6F :
1741                         retval = WXK_F12 ;
1742                         break;
1743                     case 0x69 :
1744                         retval = WXK_F13 ;
1745                         break;
1746                     case 0x6B :
1747                         retval = WXK_F14 ;
1748                         break;
1749                     case 0x71 :
1750                         retval = WXK_F15 ;
1751                         break;
1752                 }
1753             }
1754             break ;
1755             case 0x1b :
1756                 retval = WXK_ESCAPE ;
1757             break ;
1758             case 0x1c :
1759                 retval = WXK_LEFT ;
1760             break ;
1761             case 0x1d :
1762                 retval = WXK_RIGHT ;
1763             break ;
1764             case 0x1e :
1765                 retval = WXK_UP ;
1766             break ;
1767             case 0x1f :
1768                 retval = WXK_DOWN ;
1769             break ;
1770             case 0x7F :
1771                 retval = WXK_DELETE ;
1772              default:
1773             break ;
1774      } // end switch
1775
1776     return retval;
1777 }
1778
1779 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
1780 {
1781     EventRecord* ev = (EventRecord*) evr ;
1782     wxToolTip::RemoveToolTips() ;
1783
1784     UInt32 menuresult = UMAMenuEvent(ev) ;
1785     if ( HiWord( menuresult ) )
1786     {
1787         if ( !s_macIsInModalLoop )
1788             MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1789     }
1790     else
1791     {
1792         short keycode ;
1793         short keychar ;
1794         keychar = short(ev->message & charCodeMask);
1795         keycode = short(ev->message & keyCodeMask) >> 8 ;
1796         wxWindow* focus = wxWindow::FindFocus() ;
1797         // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
1798         if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
1799         {
1800             keychar += 0x40 ;
1801         }
1802         long keyval = wxMacTranslateKey(keychar, keycode) ;
1803
1804         if ( MacSendKeyDownEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
1805         {
1806             // has not been handled -> perform default
1807             wxControl* control = wxDynamicCast( focus , wxControl ) ;
1808             if ( control &&  control->GetMacControl() != NULL )
1809             {
1810                 ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
1811             }
1812         }
1813     }
1814 }
1815
1816 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keyval , long modifiers , long when , short wherex , short wherey )
1817 {
1818     wxKeyEvent event(wxEVT_KEY_DOWN);
1819     bool handled = false ;
1820     event.m_shiftDown = modifiers & shiftKey;
1821     event.m_controlDown = modifiers & controlKey;
1822     event.m_altDown = modifiers & optionKey;
1823     event.m_metaDown = modifiers & cmdKey;
1824     event.m_keyCode = wxToupper(keyval );
1825
1826     event.m_x = wherex;
1827     event.m_y = wherey;
1828     event.m_timeStamp = when;
1829     event.SetEventObject(focus);
1830     handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1831     if ( handled && event.GetSkipped() )
1832         handled = false ;
1833     if ( !handled )
1834     {
1835 #if wxUSE_ACCEL
1836         if (!handled)
1837         {
1838             wxWindow *ancestor = focus;
1839             while (ancestor)
1840             {
1841                 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1842                 if (command != -1)
1843                 {
1844                     wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1845                     handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1846                     break;
1847                 }
1848                 if (ancestor->IsTopLevel())
1849                     break;
1850                 ancestor = ancestor->GetParent();
1851             }
1852         }
1853 #endif // wxUSE_ACCEL
1854     }
1855     if (!handled)
1856     {
1857         event.Skip( FALSE ) ;
1858         event.SetEventType( wxEVT_CHAR ) ;
1859         event.m_keyCode = keyval ;
1860
1861         handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1862         if ( handled && event.GetSkipped() )
1863             handled = false ;
1864     }
1865     if ( !handled &&
1866          (keyval == WXK_TAB) &&
1867 // CS: copied the change below from wxGTK
1868 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1869 //     have this style, yet choose not to process this particular TAB in which
1870 //     case TAB must still work as a navigational character
1871 #if 0
1872          (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1873 #endif
1874          (focus->GetParent()) &&
1875          (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1876     {
1877         wxNavigationKeyEvent new_event;
1878         new_event.SetEventObject( focus );
1879         new_event.SetDirection( !event.ShiftDown() );
1880         /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1881         new_event.SetWindowChange( event.ControlDown() );
1882         new_event.SetCurrentFocus( focus );
1883         handled = focus->GetEventHandler()->ProcessEvent( new_event );
1884         if ( handled && new_event.GetSkipped() )
1885             handled = false ;
1886     }
1887     // backdoor handler for default return and command escape
1888     if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1889     {
1890           // if window is not having a focus still testing for default enter or cancel
1891           // TODO add the UMA version for ActiveNonFloatingWindow
1892           wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1893           if ( focus )
1894           {
1895             if ( keyval == WXK_RETURN )
1896             {
1897                  wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1898                                                        wxButton);
1899                  if ( def && def->IsEnabled() )
1900                  {
1901                      wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1902                      event.SetEventObject(def);
1903                      def->Command(event);
1904                      return true ;
1905                 }
1906             }
1907             /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1908             else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1909             {
1910                   wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1911                   new_event.SetEventObject( focus );
1912                   handled = focus->GetEventHandler()->ProcessEvent( new_event );
1913             }
1914           }
1915     }
1916     return handled ;
1917 }
1918
1919
1920 void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
1921 {
1922     EventRecord* ev = (EventRecord*) evr ;
1923     wxToolTip::RemoveToolTips() ;
1924
1925     UInt32 menuresult = UMAMenuEvent(ev) ;
1926     if ( HiWord( menuresult ) )
1927     {
1928     }
1929     else
1930     {
1931         short keycode ;
1932         short keychar ;
1933         keychar = short(ev->message & charCodeMask);
1934         keycode = short(ev->message & keyCodeMask) >> 8 ;
1935         // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
1936         if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
1937         {
1938             keychar += 0x40 ;
1939         }
1940         long keyval = wxMacTranslateKey(keychar, keycode) ;
1941
1942         wxWindow* focus = wxWindow::FindFocus() ;
1943         bool handled = MacSendKeyUpEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
1944         // we don't have to do anything under classic here
1945     }
1946 }
1947
1948 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keyval , long modifiers , long when , short wherex , short wherey )
1949 {
1950     bool handled = false ;
1951     if ( focus )
1952     {
1953         wxKeyEvent event(wxEVT_KEY_UP);
1954         event.m_shiftDown = modifiers & shiftKey;
1955         event.m_controlDown = modifiers & controlKey;
1956         event.m_altDown = modifiers & optionKey;
1957         event.m_metaDown = modifiers & cmdKey;
1958         event.m_keyCode = wxToupper(keyval );
1959
1960         event.m_x = wherex;
1961         event.m_y = wherey;
1962         event.m_timeStamp = when;
1963         event.SetEventObject(focus);
1964         handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1965     }
1966     return handled ;
1967 }
1968 void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
1969 {
1970     EventRecord* ev = (EventRecord*) evr ;
1971     WindowRef window = (WindowRef) ev->message ;
1972     if ( window )
1973     {
1974         bool activate = (ev->modifiers & activeFlag ) ;
1975         WindowClass wclass ;
1976         ::GetWindowClass ( window , &wclass ) ;
1977         if ( wclass == kFloatingWindowClass )
1978         {
1979             // if it is a floater we activate/deactivate the front non-floating window instead
1980             window = ::FrontNonFloatingWindow() ;
1981         }
1982         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1983         if ( win )
1984             win->MacActivate( ev , activate ) ;
1985     }
1986 }
1987
1988 void wxApp::MacHandleUpdateEvent( WXEVENTREF evr )
1989 {
1990     EventRecord* ev = (EventRecord*) evr ;
1991     WindowRef window = (WindowRef) ev->message ;
1992     wxTopLevelWindowMac * win = wxFindWinFromMacWindow( window ) ;
1993     if ( win )
1994     {
1995         if ( !wxPendingDelete.Member(win) )
1996             win->MacUpdate( ev->when ) ;
1997     }
1998     else
1999     {
2000         // since there is no way of telling this foreign window to update itself
2001         // we have to invalidate the update region otherwise we keep getting the same
2002         // event over and over again
2003         BeginUpdate( window ) ;
2004         EndUpdate( window ) ;
2005     }
2006 }
2007
2008 void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
2009 {
2010     EventRecord* ev = (EventRecord*) evr ;
2011     if ( HiWord( ev->message ) != noErr )
2012   {
2013  #if !TARGET_CARBON
2014         OSErr err ;
2015         Point point ;
2016          SetPt( &point , 100 , 100 ) ;
2017
2018           err = DIBadMount( point , ev->message ) ;
2019         wxASSERT( err == noErr ) ;
2020 #endif
2021     }
2022 }
2023
2024 void wxApp::MacHandleOSEvent( WXEVENTREF evr )
2025 {
2026     EventRecord* ev = (EventRecord*) evr ;
2027     switch( ( ev->message & osEvtMessageMask ) >> 24 )
2028     {
2029         case suspendResumeMessage :
2030             {
2031                 bool isResuming = ev->message & resumeFlag ;
2032 #if !TARGET_CARBON
2033                 bool convertClipboard = ev->message & convertClipboardFlag ;
2034 #else
2035                 bool convertClipboard = false;
2036 #endif
2037                 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
2038                 if ( isResuming )
2039                 {
2040                     WindowRef oldFrontWindow = NULL ;
2041                     WindowRef newFrontWindow = NULL ;
2042
2043                     // in case we don't take care of activating ourselves, we have to synchronize
2044                     // our idea of the active window with the process manager's - which it already activated
2045
2046                     if ( !doesActivate )
2047                         oldFrontWindow = ::FrontNonFloatingWindow() ;
2048
2049                     MacResume( convertClipboard ) ;
2050
2051                     newFrontWindow = ::FrontNonFloatingWindow() ;
2052
2053                     if ( oldFrontWindow )
2054                     {
2055                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
2056                         if ( win )
2057                             win->MacActivate( ev , false ) ;
2058                     }
2059                     if ( newFrontWindow )
2060                     {
2061                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
2062                         if ( win )
2063                             win->MacActivate( ev , true ) ;
2064                     }
2065                 }
2066                 else
2067                 {
2068                     MacSuspend( convertClipboard ) ;
2069
2070                     // in case this suspending did close an active window, another one might
2071                     // have surfaced -> lets deactivate that one
2072
2073 /* TODO : find out what to do on systems < 10 , perhaps FrontNonFloatingWindow
2074                     WindowRef newActiveWindow = ::ActiveNonFloatingWindow() ;
2075                     if ( newActiveWindow )
2076                     {
2077                         wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
2078                         if ( win )
2079                             win->MacActivate( ev , false ) ;
2080                     }
2081 */
2082                 }
2083             }
2084             break ;
2085         case mouseMovedMessage :
2086             {
2087                 WindowRef window;
2088
2089                 wxWindow* currentMouseWindow = NULL ;
2090
2091                 wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
2092                                                  &currentMouseWindow ) ;
2093                 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
2094                 {
2095                     wxMouseEvent event ;
2096
2097                     bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
2098                     bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
2099
2100                     event.m_leftDown = isDown && !controlDown;
2101                     event.m_middleDown = FALSE;
2102                     event.m_rightDown = isDown && controlDown;
2103                     event.m_shiftDown = ev->modifiers & shiftKey;
2104                     event.m_controlDown = ev->modifiers & controlKey;
2105                     event.m_altDown = ev->modifiers & optionKey;
2106                     event.m_metaDown = ev->modifiers & cmdKey;
2107                     event.m_x = ev->where.h;
2108                     event.m_y = ev->where.v;
2109                     event.m_timeStamp = ev->when;
2110                     event.SetEventObject(this);
2111
2112                     if ( wxWindow::s_lastMouseWindow )
2113                     {
2114                         wxMouseEvent eventleave(event);
2115                         eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
2116                         wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
2117                         eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
2118
2119                         wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
2120                     }
2121                     if ( currentMouseWindow )
2122                     {
2123                         wxMouseEvent evententer(event);
2124                         evententer.SetEventType( wxEVT_ENTER_WINDOW );
2125                         currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
2126                         evententer.SetEventObject( currentMouseWindow ) ;
2127                         currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
2128                     }
2129                     wxWindow::s_lastMouseWindow = currentMouseWindow ;
2130                 }
2131
2132                 short windowPart = ::FindWindow(ev->where, &window);
2133
2134                 switch (windowPart)
2135                 {
2136                     // fixes for setting the cursor back from dominic mazzoni
2137                     case inMenuBar :
2138                         UMAShowArrowCursor();
2139                         break ;
2140                     case inSysWindow :
2141                         UMAShowArrowCursor();
2142                         break ;
2143                     default:
2144                         {
2145                             // if ( s_lastMouseDown == 0 )
2146                             //     ev->modifiers |= btnState ;
2147
2148                             // Calling GetNextEvent with a zero event mask will always
2149                             // pass back a null event. However, it fills the EventRecord
2150                             // with the state of the modifier keys. This is needed since
2151                             // the modifier state returned by WaitForNextEvent often is
2152                             // wrong mouse move events. The attempt above to correct this
2153                             // didn't always work (under OS X at least).
2154
2155                             EventRecord tmp;
2156                             ::GetNextEvent(0, &tmp);
2157                             ev->modifiers = tmp.modifiers;
2158
2159                             wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
2160                             if ( win )
2161                                 win->MacMouseMoved( ev , windowPart ) ;
2162                             else
2163                                 UMAShowArrowCursor();
2164
2165                         }
2166                         break;
2167                 }
2168             }
2169             break ;
2170
2171     }
2172 }
2173
2174 void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
2175 {
2176     if (macMenuId == 0)
2177          return; // no menu item selected
2178
2179     if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
2180     {
2181         #if ! TARGET_CARBON
2182         Str255        deskAccessoryName ;
2183         GrafPtr        savedPort ;
2184
2185         GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
2186         GetPort(&savedPort);
2187         OpenDeskAcc(deskAccessoryName);
2188         SetPort(savedPort);
2189         #endif
2190     }
2191     else
2192     {
2193         wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() )  ;
2194         if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
2195             wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
2196     }
2197     HiliteMenu(0);
2198 }
2199
2200 /*
2201 long wxApp::MacTranslateKey(char key, int mods)
2202 {
2203 }
2204
2205 void wxApp::MacAdjustCursor()
2206 {
2207 }
2208
2209 */
2210 /*
2211 void
2212 wxApp::macAdjustCursor()
2213 {
2214   if (ev->what != kHighLevelEvent)
2215   {
2216     wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
2217     if (theMacWxFrame)
2218     {
2219         if (!theMacWxFrame->MacAdjustCursor(ev->where))
2220         ::SetCursor(&(qd.arrow));
2221       }
2222   }
2223 }
2224 */