src/mac/app.cpp

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