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