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