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