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