]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/app.cpp
projects / wxWidgets.git / blob
? search:


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