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 #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     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     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     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     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 ( 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
 694 int WXDLLEXPORT wxEntryInitGui()
 695 {
 696     return wxTheApp->OnInitGui();
 697 }
 698
 699
 700 void WXDLLEXPORT wxEntryCleanup()
 701 {
 702     wxApp::CleanUp();
 703 }
 704
 705
 706 int wxEntry( int argc, char *argv[] , bool enterLoop )
 707 {
 708     gCurrentResource = CurResFile() ;
 709 #ifdef __MWERKS__
 710 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 711     // This seems to be necessary since there are 'rogue'
 712     // objects present at this point (perhaps global objects?)
 713     // Setting a checkpoint will ignore them as far as the
 714     // memory checking facility is concerned.
 715     // Of course you may argue that memory allocated in globals should be
 716     // checked, but this is a reasonable compromise.
 717     wxDebugContext::SetCheckpoint();
 718 #endif
 719 #endif
 720     if (!wxEntryStart(argc, argv)) {
 721         return 0;
 722     }
 723    // create the application object or ensure that one already exists
 724     if (!wxTheApp)
 725     {
 726         // The app may have declared a global application object, but we recommend
 727         // the IMPLEMENT_APP macro is used instead, which sets an initializer
 728         // function for delayed, dynamic app object construction.
 729         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 730                      wxT("No initializer - use IMPLEMENT_APP macro.") );
 731
 732         wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
 733     }
 734
 735     wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
 736
 737 #ifndef __DARWIN__
 738     argc = 0 ; // currently we don't support files as parameters
 739 #endif
 740     // we could try to get the open apple events here to adjust argc and argv better
 741
 742     wxTheApp->argc = argc;
 743     wxTheApp->argv = argv;
 744
 745     // GUI-specific initialization, such as creating an app context.
 746     wxEntryInitGui();
 747
 748
 749     // Here frames insert themselves automatically
 750     // into wxTopLevelWindows by getting created
 751     // in OnInit().
 752
 753     int retValue = 0;
 754
 755     if ( wxTheApp->OnInit() )
 756     {
 757         if ( enterLoop )
 758         {
 759             retValue = wxTheApp->OnRun();
 760         }
 761         else
 762             // We want to initialize, but not run or exit immediately.
 763             return 1;
 764     }
 765     //else: app initialization failed, so we skipped OnRun()
 766
 767     wxWindow *topWindow = wxTheApp->GetTopWindow();
 768     if ( topWindow )
 769     {
 770         // Forcibly delete the window.
 771         if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 772                 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 773         {
 774             topWindow->Close(TRUE);
 775             wxTheApp->DeletePendingObjects();
 776         }
 777         else
 778         {
 779             delete topWindow;
 780             wxTheApp->SetTopWindow(NULL);
 781         }
 782     }
 783
 784     wxTheApp->OnExit();
 785
 786     wxEntryCleanup();
 787
 788     return retValue;
 789 }
 790
 791 // Static member initialization
 792 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 793
 794 wxApp::wxApp()
 795 {
 796   m_topWindow = NULL;
 797   wxTheApp = this;
 798
 799   m_wantDebugOutput = TRUE ;
 800
 801   argc = 0;
 802   argv = NULL;
 803
 804   m_printMode = wxPRINT_WINDOWS;
 805   m_exitOnFrameDelete = TRUE;
 806   m_auto3D = TRUE;
 807 }
 808
 809 bool wxApp::Initialized()
 810 {
 811   if (GetTopWindow())
 812     return TRUE;
 813   else
 814     return FALSE;
 815 }
 816
 817 int wxApp::MainLoop()
 818 {
 819   m_keepGoing = TRUE;
 820
 821   while (m_keepGoing)
 822   {
 823         MacDoOneEvent() ;
 824   }
 825
 826   return 0;
 827 }
 828
 829 // Returns TRUE if more time is needed.
 830 bool wxApp::ProcessIdle()
 831 {
 832     wxIdleEvent event;
 833     event.SetEventObject(this);
 834     ProcessEvent(event);
 835
 836     return event.MoreRequested();
 837 }
 838
 839 void wxApp::ExitMainLoop()
 840 {
 841   m_keepGoing = FALSE;
 842 }
 843
 844 // Is a message/event pending?
 845 bool wxApp::Pending()
 846 {
 847     EventRecord event ;
 848
 849   return EventAvail( everyEvent , &event ) ;
 850 }
 851
 852 // Dispatch a message.
 853 void wxApp::Dispatch()
 854 {
 855     MacDoOneEvent() ;
 856 }
 857
 858 void wxApp::OnIdle(wxIdleEvent& event)
 859 {
 860    static bool s_inOnIdle = FALSE;
 861
 862     // Avoid recursion (via ProcessEvent default case)
 863     if ( s_inOnIdle )
 864         return;
 865
 866
 867   s_inOnIdle = TRUE;
 868
 869   // 'Garbage' collection of windows deleted with Close().
 870   DeletePendingObjects();
 871
 872   // flush the logged messages if any
 873   wxLog *pLog = wxLog::GetActiveTarget();
 874   if ( pLog != NULL && pLog->HasPendingMessages() )
 875     pLog->Flush();
 876
 877   // Send OnIdle events to all windows
 878   bool needMore = SendIdleEvents();
 879
 880   if (needMore)
 881     event.RequestMore(TRUE);
 882
 883     // If they are pending events, we must process them: pending events are
 884     // either events to the threads other than main or events posted with
 885     // wxPostEvent() functions
 886     wxMacProcessNotifierAndPendingEvents();
 887
 888   s_inOnIdle = FALSE;
 889 }
 890
 891 void wxWakeUpIdle()
 892 {
 893     wxMacWakeUp() ;
 894 }
 895
 896 // Send idle event to all top-level windows
 897 bool wxApp::SendIdleEvents()
 898 {
 899     bool needMore = FALSE;
 900     wxNode* node = wxTopLevelWindows.First();
 901     while (node)
 902     {
 903         wxWindow* win = (wxWindow*) node->Data();
 904         if (SendIdleEvents(win))
 905             needMore = TRUE;
 906
 907         node = node->Next();
 908     }
 909     return needMore;
 910 }
 911
 912 // Send idle event to window and all subwindows
 913 bool wxApp::SendIdleEvents(wxWindow* win)
 914 {
 915     bool needMore = FALSE;
 916
 917     wxIdleEvent event;
 918     event.SetEventObject(win);
 919     win->ProcessEvent(event);
 920
 921     if (event.MoreRequested())
 922         needMore = TRUE;
 923
 924     wxNode* node = win->GetChildren().First();
 925     while (node)
 926     {
 927         wxWindow* win = (wxWindow*) node->Data();
 928         if (SendIdleEvents(win))
 929             needMore = TRUE;
 930
 931         node = node->Next();
 932     }
 933     return needMore ;
 934 }
 935
 936 void wxApp::DeletePendingObjects()
 937 {
 938   wxNode *node = wxPendingDelete.First();
 939   while (node)
 940   {
 941     wxObject *obj = (wxObject *)node->Data();
 942
 943     delete obj;
 944
 945     if (wxPendingDelete.Member(obj))
 946       delete node;
 947
 948     // Deleting one object may have deleted other pending
 949     // objects, so start from beginning of list again.
 950     node = wxPendingDelete.First();
 951   }
 952 }
 953
 954 wxIcon
 955 wxApp::GetStdIcon(int which) const
 956 {
 957     switch(which)
 958     {
 959         case wxICON_INFORMATION:
 960             return wxIcon("wxICON_INFO");
 961
 962         case wxICON_QUESTION:
 963             return wxIcon("wxICON_QUESTION");
 964
 965         case wxICON_EXCLAMATION:
 966             return wxIcon("wxICON_WARNING");
 967
 968         default:
 969             wxFAIL_MSG(wxT("requested non existent standard icon"));
 970             // still fall through
 971
 972         case wxICON_HAND:
 973             return wxIcon("wxICON_ERROR");
 974     }
 975 }
 976
 977 void wxExit()
 978 {
 979     wxLogError(_("Fatal error: exiting"));
 980
 981     wxApp::CleanUp();
 982     ::ExitToShell() ;
 983 }
 984
 985 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 986 {
 987     if (GetTopWindow())
 988         GetTopWindow()->Close(TRUE);
 989 }
 990
 991 // Default behaviour: close the application with prompts. The
 992 // user can veto the close, and therefore the end session.
 993 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 994 {
 995     if (GetTopWindow())
 996     {
 997         if (!GetTopWindow()->Close(!event.CanVeto()))
 998             event.Veto(TRUE);
 999     }
1000 }
1001
1002 extern "C" void wxCYield() ;
1003 void wxCYield()
1004 {
1005     wxYield() ;
1006 }
1007
1008 // Yield to other processes
1009
1010 bool wxApp::Yield(bool onlyIfNeeded)
1011 {
1012     static bool s_inYield = FALSE;
1013
1014     if (s_inYield)
1015     {
1016         if ( !onlyIfNeeded )
1017         {
1018             wxFAIL_MSG( wxT("wxYield called recursively" ) );
1019         }
1020
1021         return FALSE;
1022     }
1023
1024     s_inYield = TRUE;
1025
1026 #if wxUSE_THREADS
1027     YieldToAnyThread() ;
1028 #endif
1029     EventRecord event ;
1030
1031     long sleepTime = 1 ; //::GetCaretTime();
1032
1033     while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
1034     {
1035         wxTheApp->MacHandleOneEvent( &event );
1036         if ( event.what != kHighLevelEvent )
1037             SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
1038     }
1039
1040     wxMacProcessNotifierAndPendingEvents() ;
1041
1042     s_inYield = FALSE;
1043
1044     return TRUE;
1045 }
1046
1047 // platform specifics
1048
1049 void wxApp::MacSuspend( bool convertClipboard )
1050 {
1051     // we have to deactive the top level windows manually
1052
1053     wxNode* node = wxTopLevelWindows.First();
1054     while (node)
1055     {
1056         wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
1057         win->MacActivate( MacGetCurrentEvent() , false ) ;
1058
1059         node = node->Next();
1060     }
1061
1062      s_lastMouseDown = 0 ;
1063      if( convertClipboard )
1064      {
1065          MacConvertPrivateToPublicScrap() ;
1066      }
1067
1068      ::HideFloatingWindows() ;
1069 }
1070
1071 void wxApp::MacResume( bool convertClipboard )
1072 {
1073         s_lastMouseDown = 0 ;
1074         if( convertClipboard )
1075         {
1076             MacConvertPublicToPrivateScrap() ;
1077         }
1078
1079         ::ShowFloatingWindows() ;
1080 }
1081
1082 void wxApp::MacConvertPrivateToPublicScrap()
1083 {
1084 }
1085
1086 void wxApp::MacConvertPublicToPrivateScrap()
1087 {
1088 }
1089
1090 void wxApp::MacDoOneEvent()
1091 {
1092   EventRecord event ;
1093
1094     long sleepTime = 1; // GetCaretTime() / 4 ;
1095
1096     if (WaitNextEvent(everyEvent, &event, sleepTime, (RgnHandle) s_macCursorRgn))
1097     {
1098         MacHandleOneEvent( &event );
1099     }
1100     else
1101     {
1102         // idlers
1103         WindowPtr window = ::FrontWindow() ;
1104         if ( window )
1105             ::IdleControls( window ) ;
1106
1107         wxTheApp->ProcessIdle() ;
1108     }
1109     if ( event.what != kHighLevelEvent )
1110         SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
1111
1112     // repeaters
1113
1114     DeletePendingObjects() ;
1115     wxMacProcessNotifierAndPendingEvents() ;
1116 }
1117
1118 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1119 {
1120     EventRecord* ev = (EventRecord*) evr ;
1121     m_macCurrentEvent = ev ;
1122
1123     wxApp::sm_lastMessageTime = ev->when ;
1124
1125     switch (ev->what)
1126     {
1127         case mouseDown:
1128             MacHandleMouseDownEvent( ev ) ;
1129             if ( ev->modifiers & controlKey )
1130                 s_lastMouseDown = 2;
1131             else
1132                 s_lastMouseDown = 1;
1133             break;
1134         case mouseUp:
1135             if ( s_lastMouseDown == 2 )
1136             {
1137                 ev->modifiers |= controlKey ;
1138             }
1139             else
1140             {
1141                 ev->modifiers &= ~controlKey ;
1142             }
1143             MacHandleMouseUpEvent( ev ) ;
1144             s_lastMouseDown = 0;
1145             break;
1146         case activateEvt:
1147             MacHandleActivateEvent( ev ) ;
1148             break;
1149         case updateEvt:
1150             MacHandleUpdateEvent( ev ) ;
1151             break;
1152         case keyDown:
1153         case autoKey:
1154             MacHandleKeyDownEvent( ev ) ;
1155             break;
1156         case keyUp:
1157             MacHandleKeyUpEvent( ev ) ;
1158             break;
1159         case diskEvt:
1160             MacHandleDiskEvent( ev ) ;
1161             break;
1162         case osEvt:
1163             MacHandleOSEvent( ev ) ;
1164             break;
1165         case kHighLevelEvent:
1166             MacHandleHighLevelEvent( ev ) ;
1167             break;
1168         default:
1169             break;
1170     }
1171     wxMacProcessNotifierAndPendingEvents() ;
1172 }
1173
1174 void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
1175 {
1176     EventRecord* ev = (EventRecord*) evr ;
1177     ::AEProcessAppleEvent( ev ) ;
1178 }
1179
1180 bool s_macIsInModalLoop = false ;
1181
1182 void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
1183 {
1184     EventRecord* ev = (EventRecord*) evr ;
1185     wxToolTip::RemoveToolTips() ;
1186
1187     WindowRef window;
1188     WindowRef frontWindow = ::FrontNonFloatingWindow() ;
1189     WindowAttributes frontWindowAttributes = NULL ;
1190     if ( frontWindow )
1191         ::GetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
1192
1193     short windowPart = ::FindWindow(ev->where, &window);
1194     wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1195     if ( wxPendingDelete.Member(win) )
1196         return ;
1197
1198     BitMap screenBits;
1199     GetQDGlobalsScreenBits( &screenBits );
1200
1201     switch (windowPart)
1202     {
1203         case inMenuBar :
1204             if ( s_macIsInModalLoop )
1205             {
1206                 SysBeep ( 30 ) ;
1207             }
1208             else
1209             {
1210                 UInt32 menuresult = MenuSelect(ev->where) ;
1211                 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
1212                 s_lastMouseDown = 0;
1213             }
1214             break ;
1215 #if !TARGET_CARBON
1216         case inSysWindow :
1217             SystemClick( ev , window ) ;
1218             s_lastMouseDown = 0;
1219             break ;
1220 #endif
1221         case inDrag :
1222             if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
1223             {
1224                 SysBeep ( 30 ) ;
1225             }
1226             else
1227             {
1228                 DragWindow(window, ev->where, &screenBits.bounds);
1229                 if (win)
1230                 {
1231                     GrafPtr port ;
1232                     GetPort( &port ) ;
1233                     Point pt = { 0, 0 } ;
1234                     SetPortWindowPort(window) ;
1235                     LocalToGlobal( &pt ) ;
1236                     SetPort( port ) ;
1237                         win->SetSize( pt.h , pt.v , -1 ,
1238                             -1 , wxSIZE_USE_EXISTING);
1239                 }
1240                 s_lastMouseDown = 0;
1241             }
1242             break ;
1243         case inGoAway:
1244             if (TrackGoAway(window, ev->where))
1245             {
1246                 if ( win )
1247                     win->Close() ;
1248             }
1249             s_lastMouseDown = 0;
1250             break;
1251         case inGrow:
1252           {
1253                 int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
1254                 if (growResult != 0)
1255                 {
1256                     int newWidth = LoWord(growResult);
1257                     int newHeight = HiWord(growResult);
1258                     int oldWidth, oldHeight;
1259
1260
1261                     if (win)
1262                     {
1263                         win->GetSize(&oldWidth, &oldHeight);
1264                         if (newWidth == 0)
1265                             newWidth = oldWidth;
1266                         if (newHeight == 0)
1267                             newHeight = oldHeight;
1268                         win->SetSize( -1, -1, newWidth, newHeight, wxSIZE_USE_EXISTING);
1269                     }
1270                 }
1271                 s_lastMouseDown = 0;
1272           }
1273             break;
1274         case inZoomIn:
1275         case inZoomOut:
1276                 if (TrackBox(window, ev->where, windowPart))
1277                 {
1278                     // TODO setup size event
1279                     ZoomWindow( window , windowPart , false ) ;
1280                     if (win)
1281                     {
1282                         Rect tempRect ;
1283
1284                         GetWindowPortBounds(window, &tempRect ) ;
1285                         win->SetSize( -1, -1, tempRect.right-tempRect.left ,
1286                             tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
1287                     }
1288                 }
1289             s_lastMouseDown = 0;
1290             break;
1291         case inCollapseBox :
1292                 // TODO setup size event
1293             s_lastMouseDown = 0;
1294             break ;
1295
1296         case inContent :
1297                 {
1298                     GrafPtr port ;
1299                     GetPort( &port ) ;
1300                     SetPortWindowPort(window) ;
1301                     SetPort( port ) ;
1302                 }
1303                 if ( window != frontWindow && wxTheApp->s_captureWindow == NULL )
1304                 {
1305                     if ( s_macIsInModalLoop )
1306                     {
1307                         SysBeep ( 30 ) ;
1308                     }
1309                     else if ( UMAIsWindowFloating( window ) )
1310                     {
1311                         if ( win )
1312                             win->MacMouseDown( ev , windowPart ) ;
1313                     }
1314                     else
1315                     {
1316                         if ( win )
1317                             win->MacMouseDown( ev , windowPart ) ;
1318                         ::SelectWindow( window ) ;
1319                     }
1320                 }
1321                 else
1322                 {
1323                     if ( win )
1324                         win->MacMouseDown( ev , windowPart ) ;
1325                 }
1326             break ;
1327
1328         default:
1329             break;
1330     }
1331 }
1332
1333 void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
1334 {
1335     EventRecord* ev = (EventRecord*) evr ;
1336     WindowRef window;
1337
1338     short windowPart = inNoWindow ;
1339         if ( wxTheApp->s_captureWindow )
1340         {
1341                 window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
1342                 windowPart = inContent ;
1343         }
1344         else
1345         {
1346                 windowPart = ::FindWindow(ev->where, &window) ;
1347         }
1348
1349     switch (windowPart)
1350     {
1351         case inMenuBar :
1352             break ;
1353         case inSysWindow :
1354             break ;
1355         default:
1356             {
1357                 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1358                 if ( win )
1359                     win->MacMouseUp( ev , windowPart ) ;
1360             }
1361             break;
1362     }
1363 }
1364
1365 long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1366 long wxMacTranslateKey(unsigned char key, unsigned char code)
1367 {
1368     long retval = key ;
1369     switch (key)
1370     {
1371         case 0x01 :
1372                  retval = WXK_HOME;
1373           break;
1374         case 0x03 :
1375                  retval = WXK_RETURN;
1376           break;
1377         case 0x04 :
1378                  retval = WXK_END;
1379           break;
1380         case 0x05 :
1381                  retval = WXK_HELP;
1382           break;
1383         case 0x08 :
1384                  retval = WXK_BACK;
1385           break;
1386         case 0x09 :
1387                  retval = WXK_TAB;
1388           break;
1389         case 0x0b :
1390                  retval = WXK_PAGEUP;
1391           break;
1392         case 0x0c :
1393                  retval = WXK_PAGEDOWN;
1394           break;
1395         case 0x0d :
1396                  retval = WXK_RETURN;
1397           break;
1398             case 0x10 :
1399             {
1400                 switch( code )
1401                 {
1402                     case 0x7a :
1403                         retval = WXK_F1 ;
1404                         break;
1405                     case 0x78 :
1406                         retval = WXK_F2 ;
1407                         break;
1408                     case 0x63 :
1409                         retval = WXK_F3 ;
1410                         break;
1411                     case 0x76 :
1412                         retval = WXK_F4 ;
1413                         break;
1414                     case 0x60 :
1415                         retval = WXK_F5 ;
1416                         break;
1417                     case 0x61 :
1418                         retval = WXK_F6 ;
1419                         break;
1420                     case 0x62:
1421                         retval = WXK_F7 ;
1422                         break;
1423                     case 0x64 :
1424                         retval = WXK_F8 ;
1425                         break;
1426                     case 0x65 :
1427                         retval = WXK_F9 ;
1428                         break;
1429                     case 0x6D :
1430                         retval = WXK_F10 ;
1431                         break;
1432                     case 0x67 :
1433                         retval = WXK_F11 ;
1434                         break;
1435                     case 0x6F :
1436                         retval = WXK_F12 ;
1437                         break;
1438                     case 0x69 :
1439                         retval = WXK_F13 ;
1440                         break;
1441                     case 0x6B :
1442                         retval = WXK_F14 ;
1443                         break;
1444                     case 0x71 :
1445                         retval = WXK_F15 ;
1446                         break;
1447                 }
1448             }
1449             break ;
1450             case 0x1b :
1451                 retval = WXK_ESCAPE ;
1452             break ;
1453             case 0x1c :
1454                 retval = WXK_LEFT ;
1455             break ;
1456             case 0x1d :
1457                 retval = WXK_RIGHT ;
1458             break ;
1459             case 0x1e :
1460                 retval = WXK_UP ;
1461             break ;
1462             case 0x1f :
1463                 retval = WXK_DOWN ;
1464             break ;
1465             case 0x7F :
1466                 retval = WXK_DELETE ;
1467              default:
1468             break ;
1469      } // end switch
1470
1471     return retval;
1472 }
1473
1474 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
1475 {
1476     EventRecord* ev = (EventRecord*) evr ;
1477     wxToolTip::RemoveToolTips() ;
1478
1479     UInt32 menuresult = UMAMenuEvent(ev) ;
1480     if ( HiWord( menuresult ) )
1481     {
1482         if ( !s_macIsInModalLoop )
1483         MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1484     }
1485     else
1486     {
1487         short keycode ;
1488         short keychar ;
1489         keychar = short(ev->message & charCodeMask);
1490         keycode = short(ev->message & keyCodeMask) >> 8 ;
1491         long keyval = wxMacTranslateKey(keychar, keycode) ;
1492         bool handled = false ;
1493         wxWindow* focus = wxWindow::FindFocus() ;
1494         if ( focus )
1495         {
1496
1497             wxKeyEvent event(wxEVT_KEY_DOWN);
1498             event.m_shiftDown = ev->modifiers & shiftKey;
1499             event.m_controlDown = ev->modifiers & controlKey;
1500             event.m_altDown = ev->modifiers & optionKey;
1501             event.m_metaDown = ev->modifiers & cmdKey;
1502             event.m_keyCode = keyval;
1503             event.m_x = ev->where.h;
1504             event.m_y = ev->where.v;
1505             event.m_timeStamp = ev->when;
1506             event.SetEventObject(focus);
1507             handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1508             if ( !handled )
1509             {
1510                 #if wxUSE_ACCEL
1511                 if (!handled)
1512                 {
1513                     wxWindow *ancestor = focus;
1514                     /*
1515                     while (ancestor)
1516                     {
1517                         int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1518                         if (command != -1)
1519                         {
1520                             wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1521                             handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1522                             break;
1523                         }
1524                         if (ancestor->m_isFrame)
1525                             break;
1526                         ancestor = ancestor->GetParent();
1527                     }
1528                     */
1529                 }
1530                 #endif // wxUSE_ACCEL
1531             }
1532             if (!handled)
1533             {
1534                 wxKeyEvent event(wxEVT_CHAR);
1535                 event.m_shiftDown = ev->modifiers & shiftKey;
1536                 event.m_controlDown = ev->modifiers & controlKey;
1537                 event.m_altDown = ev->modifiers & optionKey;
1538                 event.m_metaDown = ev->modifiers & cmdKey;
1539                 event.m_keyCode = keyval;
1540                 event.m_x = ev->where.h;
1541                 event.m_y = ev->where.v;
1542                 event.m_timeStamp = ev->when;
1543                 event.SetEventObject(focus);
1544                 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1545             }
1546             if ( !handled &&
1547                  (keyval == WXK_TAB) &&
1548                  (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1549                  (focus->GetParent()) &&
1550                  (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1551             {
1552                 wxNavigationKeyEvent new_event;
1553                 new_event.SetEventObject( focus );
1554                 new_event.SetDirection( !event.ShiftDown() );
1555                 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1556                 new_event.SetWindowChange( event.ControlDown() );
1557                 new_event.SetCurrentFocus( focus );
1558                 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1559             }
1560         }
1561         if ( !handled )
1562         {
1563             // if window is not having a focus still testing for default enter or cancel
1564             // TODO add the UMA version for ActiveNonFloatingWindow
1565           focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1566           if ( focus )
1567           {
1568             if ( keyval == WXK_RETURN )
1569             {
1570                  wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1571                                                        wxButton);
1572                  if ( def && def->IsEnabled() )
1573                  {
1574                      wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1575                      event.SetEventObject(def);
1576                      def->Command(event);
1577                      return ;
1578                 }
1579             }
1580             /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1581             else if (keyval == WXK_ESCAPE || (keyval == '.' && ev->modifiers & cmdKey ) )
1582             {
1583                   wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1584                   new_event.SetEventObject( focus );
1585                   handled = focus->GetEventHandler()->ProcessEvent( new_event );
1586             }
1587           }
1588         }
1589     }
1590 }
1591
1592 void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
1593 {
1594     EventRecord* ev = (EventRecord*) evr ;
1595     wxToolTip::RemoveToolTips() ;
1596
1597     UInt32 menuresult = UMAMenuEvent(ev) ;
1598     if ( HiWord( menuresult ) )
1599     {
1600     }
1601     else
1602     {
1603         short keycode ;
1604         short keychar ;
1605         keychar = short(ev->message & charCodeMask);
1606         keycode = short(ev->message & keyCodeMask) >> 8 ;
1607
1608         wxWindow* focus = wxWindow::FindFocus() ;
1609         if ( focus )
1610         {
1611             long keyval = wxMacTranslateKey(keychar, keycode) ;
1612
1613             wxKeyEvent event(wxEVT_KEY_UP);
1614             event.m_shiftDown = ev->modifiers & shiftKey;
1615             event.m_controlDown = ev->modifiers & controlKey;
1616             event.m_altDown = ev->modifiers & optionKey;
1617             event.m_metaDown = ev->modifiers & cmdKey;
1618             event.m_keyCode = keyval;
1619             event.m_x = ev->where.h;
1620             event.m_y = ev->where.v;
1621             event.m_timeStamp = ev->when;
1622             event.SetEventObject(focus);
1623             bool handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1624         }
1625     }
1626 }
1627
1628 void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
1629 {
1630     EventRecord* ev = (EventRecord*) evr ;
1631     WindowRef window = (WindowRef) ev->message ;
1632     if ( window )
1633     {
1634         bool activate = (ev->modifiers & activeFlag ) ;
1635         WindowClass wclass ;
1636         ::GetWindowClass ( window , &wclass ) ;
1637         if ( wclass == kFloatingWindowClass )
1638         {
1639             // if it is a floater we activate/deactivate the front non-floating window instead
1640             window = ::FrontNonFloatingWindow() ;
1641         }
1642         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1643         if ( win )
1644             win->MacActivate( ev , activate ) ;
1645     }
1646 }
1647
1648 void wxApp::MacHandleUpdateEvent( WXEVENTREF evr )
1649 {
1650     EventRecord* ev = (EventRecord*) evr ;
1651     WindowRef window = (WindowRef) ev->message ;
1652     wxTopLevelWindowMac * win = wxFindWinFromMacWindow( window ) ;
1653     if ( win )
1654     {
1655         if ( !wxPendingDelete.Member(win) )
1656             win->MacUpdate( ev->when ) ;
1657     }
1658     else
1659     {
1660         // since there is no way of telling this foreign window to update itself
1661         // we have to invalidate the update region otherwise we keep getting the same
1662         // event over and over again
1663         BeginUpdate( window ) ;
1664         EndUpdate( window ) ;
1665     }
1666 }
1667
1668 void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
1669 {
1670     EventRecord* ev = (EventRecord*) evr ;
1671     if ( HiWord( ev->message ) != noErr )
1672   {
1673  #if !TARGET_CARBON
1674         OSErr err ;
1675         Point point ;
1676          SetPt( &point , 100 , 100 ) ;
1677
1678           err = DIBadMount( point , ev->message ) ;
1679         wxASSERT( err == noErr ) ;
1680 #endif
1681     }
1682 }
1683
1684 void wxApp::MacHandleOSEvent( WXEVENTREF evr )
1685 {
1686     EventRecord* ev = (EventRecord*) evr ;
1687     switch( ( ev->message & osEvtMessageMask ) >> 24 )
1688     {
1689         case suspendResumeMessage :
1690             {
1691                 bool isResuming = ev->message & resumeFlag ;
1692 #if !TARGET_CARBON
1693                 bool convertClipboard = ev->message & convertClipboardFlag ;
1694 #else
1695                 bool convertClipboard = false;
1696 #endif
1697                 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
1698                 if ( isResuming )
1699                 {
1700                     WindowRef oldFrontWindow = NULL ;
1701                     WindowRef newFrontWindow = NULL ;
1702
1703                     // in case we don't take care of activating ourselves, we have to synchronize
1704                     // our idea of the active window with the process manager's - which it already activated
1705
1706                     if ( !doesActivate )
1707                         oldFrontWindow = ::FrontNonFloatingWindow() ;
1708
1709                     MacResume( convertClipboard ) ;
1710
1711                     newFrontWindow = ::FrontNonFloatingWindow() ;
1712
1713                     if ( oldFrontWindow )
1714                     {
1715                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
1716                         if ( win )
1717                             win->MacActivate( ev , false ) ;
1718                     }
1719                     if ( newFrontWindow )
1720                     {
1721                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
1722                         if ( win )
1723                             win->MacActivate( ev , true ) ;
1724                     }
1725                 }
1726                 else
1727                 {
1728                     MacSuspend( convertClipboard ) ;
1729
1730                     // in case this suspending did close an active window, another one might
1731                     // have surfaced -> lets deactivate that one
1732
1733 /* TODO : find out what to do on systems < 10 , perhaps FrontNonFloatingWindow
1734                     WindowRef newActiveWindow = ::ActiveNonFloatingWindow() ;
1735                     if ( newActiveWindow )
1736                     {
1737                         wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
1738                         if ( win )
1739                             win->MacActivate( ev , false ) ;
1740                     }
1741 */
1742                 }
1743             }
1744             break ;
1745         case mouseMovedMessage :
1746             {
1747                 WindowRef window;
1748
1749                 wxWindow* currentMouseWindow = NULL ;
1750
1751                 wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
1752                                                  &currentMouseWindow ) ;
1753                 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
1754                 {
1755                     wxMouseEvent event ;
1756
1757                     bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
1758                     bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
1759
1760                     event.m_leftDown = isDown && !controlDown;
1761                     event.m_middleDown = FALSE;
1762                     event.m_rightDown = isDown && controlDown;
1763                     event.m_shiftDown = ev->modifiers & shiftKey;
1764                     event.m_controlDown = ev->modifiers & controlKey;
1765                     event.m_altDown = ev->modifiers & optionKey;
1766                     event.m_metaDown = ev->modifiers & cmdKey;
1767                     event.m_x = ev->where.h;
1768                     event.m_y = ev->where.v;
1769                     event.m_timeStamp = ev->when;
1770                     event.SetEventObject(this);
1771
1772                     if ( wxWindow::s_lastMouseWindow )
1773                     {
1774                         wxMouseEvent eventleave(event);
1775                         eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
1776                         wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
1777
1778                         wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
1779                     }
1780                     if ( currentMouseWindow )
1781                     {
1782                         wxMouseEvent evententer(event);
1783                         evententer.SetEventType( wxEVT_ENTER_WINDOW );
1784                         currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
1785
1786                         currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
1787                     }
1788                     wxWindow::s_lastMouseWindow = currentMouseWindow ;
1789                 }
1790
1791                 short windowPart = ::FindWindow(ev->where, &window);
1792
1793                 switch (windowPart)
1794                 {
1795                     // fixes for setting the cursor back from dominic mazzoni
1796                     case inMenuBar :
1797                         UMAShowArrowCursor();
1798                         break ;
1799                     case inSysWindow :
1800                         UMAShowArrowCursor();
1801                         break ;
1802                     default:
1803                         {
1804                             // if ( s_lastMouseDown == 0 )
1805                             //     ev->modifiers |= btnState ;
1806
1807                             // Calling GetNextEvent with a zero event mask will always
1808                             // pass back a null event. However, it fills the EventRecord
1809                             // with the state of the modifier keys. This is needed since
1810                             // the modifier state returned by WaitForNextEvent often is
1811                             // wrong mouse move events. The attempt above to correct this
1812                             // didn't always work (under OS X at least).
1813
1814                             EventRecord tmp;
1815                             ::GetNextEvent(0, &tmp);
1816                             ev->modifiers = tmp.modifiers;
1817
1818                             wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1819                             if ( win )
1820                                 win->MacMouseMoved( ev , windowPart ) ;
1821                             else
1822                                 UMAShowArrowCursor();
1823
1824                         }
1825                         break;
1826                 }
1827             }
1828             break ;
1829
1830     }
1831 }
1832
1833 void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
1834 {
1835     if (macMenuId == 0)
1836          return; // no menu item selected
1837
1838     if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
1839     {
1840         #if ! TARGET_CARBON
1841         Str255        deskAccessoryName ;
1842         GrafPtr        savedPort ;
1843
1844         GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
1845         GetPort(&savedPort);
1846         OpenDeskAcc(deskAccessoryName);
1847         SetPort(savedPort);
1848         #endif
1849     }
1850     else
1851     {
1852         wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() )  ;
1853         if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
1854             wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
1855     }
1856     HiliteMenu(0);
1857 }
1858
1859 /*
1860 long wxApp::MacTranslateKey(char key, int mods)
1861 {
1862 }
1863
1864 void wxApp::MacAdjustCursor()
1865 {
1866 }
1867
1868 */
1869 /*
1870 void
1871 wxApp::macAdjustCursor()
1872 {
1873   if (ev->what != kHighLevelEvent)
1874   {
1875     wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
1876     if (theMacWxFrame)
1877     {
1878         if (!theMacWxFrame->MacAdjustCursor(ev->where))
1879         ::SetCursor(&(qd.arrow));
1880       }
1881   }
1882 }
1883 */