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