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