]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/app.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
clear the frame statusbar when the mouse leaves the toolbar or enters a tool without...
[wxWidgets.git] / src / mac / app.cpp
... / ...
CommitLineData
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
68extern char *wxBuffer;
69extern wxList wxPendingDelete;
70extern wxList *wxWinMacWindowList;
71extern wxList *wxWinMacControlList;
72
73wxApp *wxTheApp = NULL;
74
75#if !USE_SHARED_LIBRARY
76IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
77BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
78 EVT_IDLE(wxApp::OnIdle)
79 EVT_END_SESSION(wxApp::OnEndSession)
80 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
81END_EVENT_TABLE()
82#endif
83
84
85const short kMacMinHeap = (29 * 1024) ;
86// platform specific static variables
87
88const short kwxMacMenuBarResource = 1 ;
89const short kwxMacAppleMenuId = 1 ;
90
91WXHRGN wxApp::s_macCursorRgn = NULL;
92wxWindow* wxApp::s_captureWindow = NULL ;
93int wxApp::s_lastMouseDown = 0 ;
94long wxApp::sm_lastMessageTime = 0;
95
96bool wxApp::s_macDefaultEncodingIsPC = true ;
97bool wxApp::s_macSupportPCMenuShortcuts = true ;
98long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
99wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
100
101pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
102pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
103pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
104pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
105
106
107pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon )
108{
109 wxApp* app = (wxApp*) refcon ;
110 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
111}
112
113pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon )
114{
115 wxApp* app = (wxApp*) refcon ;
116 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
117}
118
119pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon )
120{
121 wxApp* app = (wxApp*) refcon ;
122 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
123}
124
125pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon )
126{
127 wxApp* app = (wxApp*) refcon ;
128 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
129}
130
131short 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
141short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF reply)
142{
143 return noErr ;
144}
145
146short wxApp::MacHandleAEOApp(const WXEVENTREF event , WXEVENTREF reply)
147{
148 return noErr ;
149}
150
151short 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
165char 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
172char 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
179void 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
214void 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
249void wxMacConvertFromPC( char * p )
250{
251 char *ptr = p ;
252 int len = strlen ( p ) ;
253
254 wxMacConvertFromPC( ptr , ptr , len ) ;
255}
256
257void 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
272void wxMacConvertFromPC( unsigned char *p )
273{
274 char *ptr = (char*) p + 1 ;
275 int len = p[0] ;
276
277 wxMacConvertFromPC( ptr , ptr , len ) ;
278}
279
280extern char *wxBuffer ;
281
282wxString 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
302void wxMacConvertToPC( char * p )
303{
304 char *ptr = p ;
305 int len = strlen ( p ) ;
306
307 wxMacConvertToPC( ptr , ptr , len ) ;
308}
309
310void wxMacConvertToPC( unsigned char *p )
311{
312 char *ptr = (char*) p + 1 ;
313 int len = p[0] ;
314
315 wxMacConvertToPC( ptr , ptr , len ) ;
316}
317
318wxString 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
338wxString 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
350wxString 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
365void 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 ;-)
379WXIMPORT char std::__throws_bad_alloc ;
380#endif
381#endif
382
383bool 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
537void 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
631short gCurrentResource = -1 ;
632
633wxStAppResource::wxStAppResource()
634{
635 m_currentRefNum = CurResFile() ;
636 if ( gCurrentResource != -1 )
637 {
638 UseResFile( gCurrentResource ) ;
639 }
640}
641
642wxStAppResource::~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
657extern "C" {
658#endif
659
660void __sinit(void); /* (generated by linker) */
661pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
662pascal void __terminate(void);
663
664#ifdef __cplusplus
665}
666#endif
667
668pascal 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
680pascal void __wxterminate(void)
681{
682 if (gCurrentResource != -1)
683 CloseResFile(gCurrentResource);
684 __terminate() ;
685}
686#endif
687
688int WXDLLEXPORT wxEntryStart( int argc, char *argv[] )
689{
690 return wxApp::Initialize();
691}
692
693
694int WXDLLEXPORT wxEntryInitGui()
695{
696 return wxTheApp->OnInitGui();
697}
698
699
700void WXDLLEXPORT wxEntryCleanup()
701{
702 wxApp::CleanUp();
703}
704
705
706int 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
792wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
793
794wxApp::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
811bool wxApp::Initialized()
812{
813 if (GetTopWindow())
814 return TRUE;
815 else
816 return FALSE;
817}
818
819int 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.
832bool wxApp::ProcessIdle()
833{
834 wxIdleEvent event;
835 event.SetEventObject(this);
836 ProcessEvent(event);
837
838 return event.MoreRequested();
839}
840
841void wxApp::ExitMainLoop()
842{
843 m_keepGoing = FALSE;
844}
845
846// Is a message/event pending?
847bool wxApp::Pending()
848{
849 EventRecord event ;
850
851 return EventAvail( everyEvent , &event ) ;
852}
853
854// Dispatch a message.
855void wxApp::Dispatch()
856{
857 MacDoOneEvent() ;
858}
859
860void 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
893void wxWakeUpIdle()
894{
895 wxMacWakeUp() ;
896}
897
898// Send idle event to all top-level windows
899bool 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
915bool 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
938void 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
956wxIcon
957wxApp::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
979void wxExit()
980{
981 wxLogError(_("Fatal error: exiting"));
982
983 wxApp::CleanUp();
984 ::ExitToShell() ;
985}
986
987void 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.
995void wxApp::OnQueryEndSession(wxCloseEvent& event)
996{
997 if (GetTopWindow())
998 {
999 if (!GetTopWindow()->Close(!event.CanVeto()))
1000 event.Veto(TRUE);
1001 }
1002}
1003
1004extern "C" void wxCYield() ;
1005void wxCYield()
1006{
1007 wxYield() ;
1008}
1009
1010// Yield to other processes
1011
1012bool 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
1051void 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
1073void wxApp::MacResume( bool convertClipboard )
1074{
1075 s_lastMouseDown = 0 ;
1076 if( convertClipboard )
1077 {
1078 MacConvertPublicToPrivateScrap() ;
1079 }
1080
1081 ::ShowFloatingWindows() ;
1082}
1083
1084void wxApp::MacConvertPrivateToPublicScrap()
1085{
1086}
1087
1088void wxApp::MacConvertPublicToPrivateScrap()
1089{
1090}
1091
1092void 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
1120void 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
1176void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
1177{
1178 EventRecord* ev = (EventRecord*) evr ;
1179 ::AEProcessAppleEvent( ev ) ;
1180}
1181
1182bool s_macIsInModalLoop = false ;
1183
1184void 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
1335void 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
1367long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1368long 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
1476void 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
1594void 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
1630void 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
1650void 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
1670void 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
1686void 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
1835void 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/*
1862long wxApp::MacTranslateKey(char key, int mods)
1863{
1864}
1865
1866void wxApp::MacAdjustCursor()
1867{
1868}
1869
1870*/
1871/*
1872void
1873wxApp::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*/
wxWidgets (Impactor)