]> 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
Some minor clean-ups to the wxScrolledWindow code.
[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/window.h"
17#include "wx/frame.h"
18#include "wx/app.h"
19#include "wx/utils.h"
20#include "wx/gdicmn.h"
21#include "wx/pen.h"
22#include "wx/brush.h"
23#include "wx/cursor.h"
24#include "wx/intl.h"
25#include "wx/icon.h"
26#include "wx/palette.h"
27#include "wx/dc.h"
28#include "wx/dialog.h"
29#include "wx/msgdlg.h"
30#include "wx/log.h"
31#include "wx/module.h"
32#include "wx/memory.h"
33#include "wx/tooltip.h"
34#include "wx/menu.h"
35#if wxUSE_WX_RESOURCES
36#include "wx/resource.h"
37#endif
38
39#include <string.h>
40
41// mac
42
43#ifndef __UNIX__
44 #if __option(profile)
45 #include <profiler.h>
46 #endif
47#endif
48
49#include "apprsrc.h"
50
51#include "wx/mac/uma.h"
52#include "wx/mac/macnotfy.h"
53
54#if wxUSE_SOCKETS
55 #ifdef __APPLE__
56 #include <CoreServices/CoreServices.h>
57 #else
58 #include <OpenTransport.h>
59 #include <OpenTptInternet.h>
60 #endif
61#endif
62
63extern char *wxBuffer;
64extern wxList wxPendingDelete;
65extern wxList *wxWinMacWindowList;
66extern wxList *wxWinMacControlList;
67
68wxApp *wxTheApp = NULL;
69
70#if !USE_SHARED_LIBRARY
71IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
72BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
73 EVT_IDLE(wxApp::OnIdle)
74 EVT_END_SESSION(wxApp::OnEndSession)
75 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
76END_EVENT_TABLE()
77#endif
78
79
80const short kMacMinHeap = (29 * 1024) ;
81// platform specific static variables
82
83const short kwxMacMenuBarResource = 1 ;
84const short kwxMacAppleMenuId = 1 ;
85
86RgnHandle wxApp::s_macCursorRgn = NULL;
87wxWindow* wxApp::s_captureWindow = NULL ;
88int wxApp::s_lastMouseDown = 0 ;
89long wxApp::sm_lastMessageTime = 0;
90
91#ifdef __WXMAC__
92
93bool wxApp::s_macDefaultEncodingIsPC = true ;
94bool wxApp::s_macSupportPCMenuShortcuts = true ;
95long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
96wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
97
98#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
99pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon )
100#else
101pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
102#endif
103{
104 wxApp* app = (wxApp*) refcon ;
105 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
106}
107
108#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
109pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon )
110#else
111pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
112#endif
113{
114 wxApp* app = (wxApp*) refcon ;
115 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
116}
117
118#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
119pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon )
120#else
121pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
122#endif
123{
124 wxApp* app = (wxApp*) refcon ;
125 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
126}
127
128#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
129pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon )
130#else
131pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
132#endif
133{
134 wxApp* app = (wxApp*) refcon ;
135 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
136}
137
138OSErr wxApp::MacHandleAEODoc(const AppleEvent *event , AppleEvent *reply)
139{
140 ProcessSerialNumber PSN ;
141 PSN.highLongOfPSN = 0 ;
142 PSN.lowLongOfPSN = kCurrentProcess ;
143 SetFrontProcess( &PSN ) ;
144 return noErr ;
145}
146
147OSErr wxApp::MacHandleAEPDoc(const AppleEvent *event , AppleEvent *reply)
148{
149 return noErr ;
150}
151
152OSErr wxApp::MacHandleAEOApp(const AppleEvent *event , AppleEvent *reply)
153{
154 return noErr ;
155}
156
157OSErr wxApp::MacHandleAEQuit(const AppleEvent *event , AppleEvent *reply)
158{
159 wxWindow* win = GetTopWindow() ;
160 if ( win )
161 {
162 win->Close(TRUE ) ;
163 }
164 else
165 {
166 ExitMainLoop() ;
167 }
168 return noErr ;
169}
170
171char StringMac[] = "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
172 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
173 "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
174 "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
175 "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
176 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
177
178char StringANSI[] = "\x0a\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
179 "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
180 "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
181 "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
182 "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
183 "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
184
185void wxMacConvertFromPC( const char *from , char *to , int len )
186{
187 char *c ;
188 if ( from == to )
189 {
190 for( int i = 0 ; i < len ; ++ i )
191 {
192 c = strchr( StringANSI , *from ) ;
193 if ( c != NULL )
194 {
195 *to = StringMac[ c - StringANSI] ;
196 }
197 ++to ;
198 ++from ;
199 }
200 }
201 else
202 {
203 for( int i = 0 ; i < len ; ++ i )
204 {
205 c = strchr( StringANSI , *from ) ;
206 if ( c != NULL )
207 {
208 *to = StringMac[ c - StringANSI] ;
209 }
210 else
211 {
212 *to = *from ;
213 }
214 ++to ;
215 ++from ;
216 }
217 }
218}
219
220void wxMacConvertToPC( const char *from , char *to , int len )
221{
222 char *c ;
223 if ( from == to )
224 {
225 for( int i = 0 ; i < len ; ++ i )
226 {
227 c = strchr( StringMac , *from ) ;
228 if ( c != NULL )
229 {
230 *to = StringANSI[ c - StringMac] ;
231 }
232 ++to ;
233 ++from ;
234 }
235 }
236 else
237 {
238 for( int i = 0 ; i < len ; ++ i )
239 {
240 c = strchr( StringMac , *from ) ;
241 if ( c != NULL )
242 {
243 *to = StringANSI[ c - StringMac] ;
244 }
245 else
246 {
247 *to = *from ;
248 }
249 ++to ;
250 ++from ;
251 }
252 }
253}
254
255void wxMacConvertFromPC( char * p )
256{
257 char *ptr = p ;
258 int len = strlen ( p ) ;
259
260 wxMacConvertFromPC( ptr , ptr , len ) ;
261}
262
263void wxMacConvertFromPCForControls( char * p )
264{
265 char *ptr = p ;
266 int len = strlen ( p ) ;
267
268 wxMacConvertFromPC( ptr , ptr , len ) ;
269 for ( int i = 0 ; i < strlen ( ptr ) ; i++ )
270 {
271 if ( ptr[i] == '&' && ptr[i]+1 != ' ' )
272 {
273 memmove( &ptr[i] , &ptr[i+1] , strlen( &ptr[i+1] ) + 1) ;
274 }
275 }
276}
277
278void wxMacConvertFromPC( unsigned char *p )
279{
280 char *ptr = (char*) p + 1 ;
281 int len = p[0] ;
282
283 wxMacConvertFromPC( ptr , ptr , len ) ;
284}
285
286extern char *wxBuffer ;
287
288wxString wxMacMakeMacStringFromPC( const char * p )
289{
290 const char *ptr = p ;
291 int len = strlen ( p ) ;
292 char *buf = wxBuffer ;
293
294 if ( len >= BUFSIZ + 512 )
295 {
296 buf = new char [len+1] ;
297 }
298
299 wxMacConvertFromPC( ptr , buf , len ) ;
300 buf[len] = 0 ;
301 wxString result( buf ) ;
302 if ( buf != wxBuffer )
303 delete buf ;
304 return result ;
305}
306
307
308void wxMacConvertToPC( char * p )
309{
310 char *ptr = p ;
311 int len = strlen ( p ) ;
312
313 wxMacConvertToPC( ptr , ptr , len ) ;
314}
315
316void wxMacConvertToPC( unsigned char *p )
317{
318 char *ptr = (char*) p + 1 ;
319 int len = p[0] ;
320
321 wxMacConvertToPC( ptr , ptr , len ) ;
322}
323
324wxString wxMacMakePCStringFromMac( const char * p )
325{
326 const char *ptr = p ;
327 int len = strlen ( p ) ;
328 char *buf = wxBuffer ;
329
330 if ( len >= BUFSIZ + 512 )
331 {
332 buf = new char [len+1] ;
333 }
334
335 wxMacConvertToPC( ptr , buf , len ) ;
336 buf[len] = 0 ;
337
338 wxString result( buf ) ;
339 if ( buf != wxBuffer )
340 delete buf ;
341 return result ;
342}
343
344#endif
345
346bool wxApp::Initialize()
347{
348 int error = 0 ;
349
350 // Mac-specific
351
352 UMAInitToolbox( 4 ) ;
353 UMAShowWatchCursor() ;
354
355#ifdef __UNIX__
356 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , AEHandleODoc ,
357 (long) wxTheApp , FALSE ) ;
358 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , AEHandleOApp ,
359 (long) wxTheApp , FALSE ) ;
360 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , AEHandlePDoc ,
361 (long) wxTheApp , FALSE ) ;
362 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , AEHandleQuit ,
363 (long) wxTheApp , FALSE ) ;
364#else
365 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , NewAEEventHandlerProc(AEHandleODoc) ,
366 (long) wxTheApp , FALSE ) ;
367 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , NewAEEventHandlerProc(AEHandleOApp) ,
368 (long) wxTheApp , FALSE ) ;
369 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , NewAEEventHandlerProc(AEHandlePDoc) ,
370 (long) wxTheApp , FALSE ) ;
371 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , NewAEEventHandlerProc(AEHandleQuit) ,
372 (long) wxTheApp , FALSE ) ;
373#endif
374
375
376#ifndef __UNIX__
377 // test the minimal configuration necessary
378
379 #if !TARGET_CARBON
380 long theSystem ;
381 long theMachine;
382
383 if (Gestalt(gestaltMachineType, &theMachine) != noErr)
384 {
385 error = kMacSTRWrongMachine;
386 }
387 else if (theMachine < gestaltMacPlus)
388 {
389 error = kMacSTRWrongMachine;
390 }
391 else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
392 {
393 error = kMacSTROldSystem ;
394 }
395 else if ( theSystem < 0x0750 )
396 {
397 error = kMacSTROldSystem ;
398 }
399 else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
400 {
401 error = kMacSTRSmallSize;
402 }
403 #endif
404 /*
405 else
406 {
407 if ( !UMAHasAppearance() )
408 {
409 error = kMacSTRNoPre8Yet ;
410 }
411 }
412 */
413#endif
414
415 // if we encountered any problems so far, give the error code and exit immediately
416
417 if ( error )
418 {
419 short itemHit;
420 Str255 message;
421
422 GetIndString(message, 128, error);
423 UMAShowArrowCursor() ;
424 ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
425 itemHit = Alert(128, nil);
426 return FALSE ;
427 }
428
429#ifndef __UNIX__
430 #if __option(profile)
431 ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
432 #endif
433#endif
434
435 // now avoid exceptions thrown for new (bad_alloc)
436
437#ifndef __UNIX__
438 std::__throws_bad_alloc = FALSE ;
439#endif
440
441 s_macCursorRgn = ::NewRgn() ;
442
443#ifdef __WXMSW__
444 wxBuffer = new char[1500];
445#else
446 wxBuffer = new char[BUFSIZ + 512];
447#endif
448
449 wxClassInfo::InitializeClasses();
450
451#if wxUSE_RESOURCES
452// wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
453#endif
454
455#if wxUSE_THREADS
456 wxPendingEventsLocker = new wxCriticalSection;
457#endif
458 wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
459 wxTheColourDatabase->Initialize();
460
461 wxInitializeStockLists();
462 wxInitializeStockObjects();
463
464#if wxUSE_WX_RESOURCES
465 wxInitializeResourceSystem();
466#endif
467
468 wxBitmap::InitStandardHandlers();
469
470 wxModule::RegisterModules();
471 if (!wxModule::InitializeModules()) {
472 return FALSE;
473 }
474
475 wxWinMacWindowList = new wxList(wxKEY_INTEGER);
476 wxWinMacControlList = new wxList(wxKEY_INTEGER);
477
478 wxMacCreateNotifierTable() ;
479
480 UMAShowArrowCursor() ;
481
482 return TRUE;
483}
484
485void wxApp::CleanUp()
486{
487#if wxUSE_LOG
488 // flush the logged messages if any and install a 'safer' log target: the
489 // default one (wxLogGui) can't be used after the resources are freed just
490 // below and the user suppliedo ne might be even more unsafe (using any
491 // wxWindows GUI function is unsafe starting from now)
492 wxLog::DontCreateOnDemand();
493
494 // this will flush the old messages if any
495 delete wxLog::SetActiveTarget(new wxLogStderr);
496#endif // wxUSE_LOG
497
498 // One last chance for pending objects to be cleaned up
499 wxTheApp->DeletePendingObjects();
500
501 wxModule::CleanUpModules();
502
503#if wxUSE_WX_RESOURCES
504 wxCleanUpResourceSystem();
505#endif
506
507 wxDeleteStockObjects() ;
508
509 // Destroy all GDI lists, etc.
510 wxDeleteStockLists();
511
512 delete wxTheColourDatabase;
513 wxTheColourDatabase = NULL;
514
515 wxBitmap::CleanUpHandlers();
516
517 delete[] wxBuffer;
518 wxBuffer = NULL;
519
520 wxMacDestroyNotifierTable() ;
521 if (wxWinMacWindowList)
522 delete wxWinMacWindowList ;
523
524 delete wxPendingEvents;
525#if wxUSE_THREADS
526 delete wxPendingEventsLocker;
527 // If we don't do the following, we get an apparent memory leak.
528 ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
529#endif
530
531 wxClassInfo::CleanUpClasses();
532
533#ifndef __UNIX__
534 #if __option(profile)
535 ProfilerDump( "\papp.prof" ) ;
536 ProfilerTerm() ;
537 #endif
538#endif
539
540 delete wxTheApp;
541 wxTheApp = NULL;
542
543#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
544 // At this point we want to check if there are any memory
545 // blocks that aren't part of the wxDebugContext itself,
546 // as a special case. Then when dumping we need to ignore
547 // wxDebugContext, too.
548 if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
549 {
550 wxLogDebug(wxT("There were memory leaks."));
551 wxDebugContext::Dump();
552 wxDebugContext::PrintStatistics();
553 }
554 // wxDebugContext::SetStream(NULL, NULL);
555#endif
556
557#if wxUSE_LOG
558 // do it as the very last thing because everything else can log messages
559 delete wxLog::SetActiveTarget(NULL);
560#endif // wxUSE_LOG
561
562 UMACleanupToolbox() ;
563 if (s_macCursorRgn)
564 ::DisposeRgn(s_macCursorRgn);
565
566 #if 0
567 TerminateAE() ;
568 #endif
569}
570
571int wxEntry( int argc, char *argv[] , bool enterLoop )
572{
573#ifdef __MWERKS__
574#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
575 // This seems to be necessary since there are 'rogue'
576 // objects present at this point (perhaps global objects?)
577 // Setting a checkpoint will ignore them as far as the
578 // memory checking facility is concerned.
579 // Of course you may argue that memory allocated in globals should be
580 // checked, but this is a reasonable compromise.
581 wxDebugContext::SetCheckpoint();
582#endif
583#endif
584 if (!wxApp::Initialize()) {
585 return 0;
586 }
587 // create the application object or ensure that one already exists
588 if (!wxTheApp)
589 {
590 // The app may have declared a global application object, but we recommend
591 // the IMPLEMENT_APP macro is used instead, which sets an initializer
592 // function for delayed, dynamic app object construction.
593 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
594 wxT("No initializer - use IMPLEMENT_APP macro.") );
595
596 wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
597 }
598
599 wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
600
601#ifdef __WXMAC__
602 argc = 0 ; // currently we don't support files as parameters
603#endif
604
605 wxTheApp->argc = argc;
606 wxTheApp->argv = argv;
607
608 // GUI-specific initialization, such as creating an app context.
609 wxTheApp->OnInitGui();
610
611 // we could try to get the open apple events here to adjust argc and argv better
612
613
614 // Here frames insert themselves automatically
615 // into wxTopLevelWindows by getting created
616 // in OnInit().
617
618 int retValue = 0;
619
620 if ( wxTheApp->OnInit() )
621 {
622 if ( enterLoop )
623 {
624 retValue = wxTheApp->OnRun();
625 }
626 else
627 // We want to initialize, but not run or exit immediately.
628 return 1;
629 }
630 //else: app initialization failed, so we skipped OnRun()
631
632 wxWindow *topWindow = wxTheApp->GetTopWindow();
633 if ( topWindow )
634 {
635 // Forcibly delete the window.
636 if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
637 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
638 {
639 topWindow->Close(TRUE);
640 wxTheApp->DeletePendingObjects();
641 }
642 else
643 {
644 delete topWindow;
645 wxTheApp->SetTopWindow(NULL);
646 }
647 }
648
649 wxTheApp->OnExit();
650
651 wxApp::CleanUp();
652
653 return retValue;
654}
655
656// Static member initialization
657wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
658
659wxApp::wxApp()
660{
661 m_topWindow = NULL;
662 wxTheApp = this;
663
664 m_wantDebugOutput = TRUE ;
665
666 argc = 0;
667 argv = NULL;
668
669 m_printMode = wxPRINT_WINDOWS;
670 m_exitOnFrameDelete = TRUE;
671 m_auto3D = TRUE;
672}
673
674bool wxApp::Initialized()
675{
676 if (GetTopWindow())
677 return TRUE;
678 else
679 return FALSE;
680}
681
682int wxApp::MainLoop()
683{
684 m_keepGoing = TRUE;
685
686 while (m_keepGoing)
687 {
688 MacDoOneEvent() ;
689 }
690
691 return 0;
692}
693
694// Returns TRUE if more time is needed.
695bool wxApp::ProcessIdle()
696{
697 wxIdleEvent event;
698 event.SetEventObject(this);
699 ProcessEvent(event);
700
701 return event.MoreRequested();
702}
703
704void wxApp::ExitMainLoop()
705{
706 m_keepGoing = FALSE;
707}
708
709// Is a message/event pending?
710bool wxApp::Pending()
711{
712 EventRecord event ;
713
714 return EventAvail( everyEvent , &event ) ;
715}
716
717// Dispatch a message.
718void wxApp::Dispatch()
719{
720 MacDoOneEvent() ;
721}
722
723void wxApp::OnIdle(wxIdleEvent& event)
724{
725 static bool s_inOnIdle = FALSE;
726
727 // Avoid recursion (via ProcessEvent default case)
728 if ( s_inOnIdle )
729 return;
730
731
732 s_inOnIdle = TRUE;
733
734 // 'Garbage' collection of windows deleted with Close().
735 DeletePendingObjects();
736
737 // flush the logged messages if any
738 wxLog *pLog = wxLog::GetActiveTarget();
739 if ( pLog != NULL && pLog->HasPendingMessages() )
740 pLog->Flush();
741
742 // Send OnIdle events to all windows
743 bool needMore = SendIdleEvents();
744
745 if (needMore)
746 event.RequestMore(TRUE);
747
748 // If they are pending events, we must process them: pending events are
749 // either events to the threads other than main or events posted with
750 // wxPostEvent() functions
751 wxMacProcessNotifierAndPendingEvents();
752
753 s_inOnIdle = FALSE;
754}
755
756void wxWakeUpIdle()
757{
758 wxMacWakeUp() ;
759}
760
761// Send idle event to all top-level windows
762bool wxApp::SendIdleEvents()
763{
764 bool needMore = FALSE;
765 wxNode* node = wxTopLevelWindows.First();
766 while (node)
767 {
768 wxWindow* win = (wxWindow*) node->Data();
769 if (SendIdleEvents(win))
770 needMore = TRUE;
771
772 node = node->Next();
773 }
774 return needMore;
775}
776
777// Send idle event to window and all subwindows
778bool wxApp::SendIdleEvents(wxWindow* win)
779{
780 bool needMore = FALSE;
781
782 wxIdleEvent event;
783 event.SetEventObject(win);
784 win->ProcessEvent(event);
785
786 if (event.MoreRequested())
787 needMore = TRUE;
788
789 wxNode* node = win->GetChildren().First();
790 while (node)
791 {
792 wxWindow* win = (wxWindow*) node->Data();
793 if (SendIdleEvents(win))
794 needMore = TRUE;
795
796 node = node->Next();
797 }
798 return needMore ;
799}
800
801void wxApp::DeletePendingObjects()
802{
803 wxNode *node = wxPendingDelete.First();
804 while (node)
805 {
806 wxObject *obj = (wxObject *)node->Data();
807
808 delete obj;
809
810 if (wxPendingDelete.Member(obj))
811 delete node;
812
813 // Deleting one object may have deleted other pending
814 // objects, so start from beginning of list again.
815 node = wxPendingDelete.First();
816 }
817}
818
819wxIcon
820wxApp::GetStdIcon(int which) const
821{
822 switch(which)
823 {
824 case wxICON_INFORMATION:
825 return wxIcon("wxICON_INFO");
826
827 case wxICON_QUESTION:
828 return wxIcon("wxICON_QUESTION");
829
830 case wxICON_EXCLAMATION:
831 return wxIcon("wxICON_WARNING");
832
833 default:
834 wxFAIL_MSG(wxT("requested non existent standard icon"));
835 // still fall through
836
837 case wxICON_HAND:
838 return wxIcon("wxICON_ERROR");
839 }
840}
841
842void wxExit()
843{
844 wxLogError(_("Fatal error: exiting"));
845
846 wxApp::CleanUp();
847 ::ExitToShell() ;
848}
849
850void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
851{
852 if (GetTopWindow())
853 GetTopWindow()->Close(TRUE);
854}
855
856// Default behaviour: close the application with prompts. The
857// user can veto the close, and therefore the end session.
858void wxApp::OnQueryEndSession(wxCloseEvent& event)
859{
860 if (GetTopWindow())
861 {
862 if (!GetTopWindow()->Close(!event.CanVeto()))
863 event.Veto(TRUE);
864 }
865}
866
867extern "C" void wxCYield() ;
868void wxCYield()
869{
870 wxYield() ;
871}
872
873// Yield to other processes
874
875static bool gs_inYield = FALSE;
876
877bool wxYield()
878{
879#ifdef __WXDEBUG__
880 if (gs_inYield)
881 wxFAIL_MSG( wxT("wxYield called recursively" ) );
882#endif
883
884 gs_inYield = TRUE;
885
886#if wxUSE_THREADS
887 YieldToAnyThread() ;
888#endif
889 EventRecord event ;
890
891 long sleepTime = 0 ; //::GetCaretTime();
892
893 while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, wxApp::s_macCursorRgn))
894 {
895 wxTheApp->MacHandleOneEvent( &event );
896 }
897
898 wxMacProcessNotifierAndPendingEvents() ;
899
900 gs_inYield = FALSE;
901
902 return TRUE;
903}
904
905// Yield to incoming messages; but fail silently if recursion is detected.
906bool wxYieldIfNeeded()
907{
908 if (gs_inYield)
909 return FALSE;
910
911 return wxYield();
912}
913
914// platform specifics
915
916void wxApp::MacSuspend( bool convertClipboard )
917{
918 // we have to deactive the window manually
919
920 wxWindow* window = GetTopWindow() ;
921 if ( window )
922 window->MacActivate( MacGetCurrentEvent() , false ) ;
923
924 s_lastMouseDown = 0 ;
925 if( convertClipboard )
926 {
927 MacConvertPrivateToPublicScrap() ;
928 }
929
930 UMAHideFloatingWindows() ;
931}
932
933void wxApp::MacResume( bool convertClipboard )
934{
935 s_lastMouseDown = 0 ;
936 if( convertClipboard )
937 {
938 MacConvertPublicToPrivateScrap() ;
939 }
940
941 UMAShowFloatingWindows() ;
942}
943
944void wxApp::MacConvertPrivateToPublicScrap()
945{
946}
947
948void wxApp::MacConvertPublicToPrivateScrap()
949{
950}
951
952void wxApp::MacDoOneEvent()
953{
954 EventRecord event ;
955
956 long sleepTime = ::GetCaretTime();
957
958 if (WaitNextEvent(everyEvent, &event,sleepTime, s_macCursorRgn))
959 {
960 MacHandleOneEvent( &event );
961 }
962 else
963 {
964 // idlers
965 WindowPtr window = UMAFrontWindow() ;
966 if ( window )
967 UMAIdleControls( window ) ;
968
969 wxTheApp->ProcessIdle() ;
970 }
971 if ( event.what != kHighLevelEvent )
972 SetRectRgn( s_macCursorRgn , event.where.h - 1 , event.where.v - 1, event.where.h + 1 , event.where.v + 1 ) ;
973
974 // repeaters
975
976 wxMacProcessNotifierAndPendingEvents() ;
977}
978
979void wxApp::MacHandleOneEvent( EventRecord *ev )
980{
981 m_macCurrentEvent = ev ;
982
983 wxApp::sm_lastMessageTime = ev->when ;
984
985 switch (ev->what)
986 {
987 case mouseDown:
988 MacHandleMouseDownEvent( ev ) ;
989 if ( ev->modifiers & controlKey )
990 s_lastMouseDown = 2;
991 else
992 s_lastMouseDown = 1;
993 break;
994 case mouseUp:
995 if ( s_lastMouseDown == 2 )
996 {
997 ev->modifiers |= controlKey ;
998 }
999 else
1000 {
1001 ev->modifiers &= ~controlKey ;
1002 }
1003 MacHandleMouseUpEvent( ev ) ;
1004 s_lastMouseDown = 0;
1005 break;
1006 case activateEvt:
1007 MacHandleActivateEvent( ev ) ;
1008 break;
1009 case updateEvt:
1010 MacHandleUpdateEvent( ev ) ;
1011 break;
1012 case keyDown:
1013 case autoKey:
1014 MacHandleKeyDownEvent( ev ) ;
1015 break;
1016 case keyUp:
1017 MacHandleKeyUpEvent( ev ) ;
1018 break;
1019 case diskEvt:
1020 MacHandleDiskEvent( ev ) ;
1021 break;
1022 case osEvt:
1023 MacHandleOSEvent( ev ) ;
1024 break;
1025 case kHighLevelEvent:
1026 MacHandleHighLevelEvent( ev ) ;
1027 break;
1028 default:
1029 break;
1030 }
1031 wxMacProcessNotifierAndPendingEvents() ;
1032}
1033
1034void wxApp::MacHandleHighLevelEvent( EventRecord *ev )
1035{
1036 ::AEProcessAppleEvent( ev ) ;
1037}
1038
1039bool s_macIsInModalLoop = false ;
1040
1041void wxApp::MacHandleMouseDownEvent( EventRecord *ev )
1042{
1043 wxToolTip::RemoveToolTips() ;
1044
1045 WindowRef window;
1046 WindowRef frontWindow = UMAFrontNonFloatingWindow() ;
1047 WindowAttributes frontWindowAttributes = NULL ;
1048 if ( frontWindow )
1049 UMAGetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
1050
1051 short windowPart = ::FindWindow(ev->where, &window);
1052 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1053
1054 BitMap screenBits;
1055 GetQDGlobalsScreenBits( &screenBits );
1056
1057 switch (windowPart)
1058 {
1059 case inMenuBar :
1060 if ( s_macIsInModalLoop )
1061 {
1062 SysBeep ( 30 ) ;
1063 }
1064 else
1065 {
1066 UInt32 menuresult = MenuSelect(ev->where) ;
1067 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
1068 s_lastMouseDown = 0;
1069 }
1070 break ;
1071#if !TARGET_CARBON
1072 case inSysWindow :
1073 SystemClick( ev , window ) ;
1074 s_lastMouseDown = 0;
1075 break ;
1076#endif
1077 case inDrag :
1078 if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
1079 {
1080 SysBeep ( 30 ) ;
1081 }
1082 else
1083 {
1084 DragWindow(window, ev->where, &screenBits.bounds);
1085 if (win)
1086 {
1087 GrafPtr port ;
1088 GetPort( &port ) ;
1089 Point pt = { 0, 0 } ;
1090 #if TARGET_CARBON
1091 SetPort( GetWindowPort(window) ) ;
1092 #else
1093 SetPort( (window) ) ;
1094 #endif
1095 SetOrigin( 0 , 0 ) ;
1096 LocalToGlobal( &pt ) ;
1097 SetPort( port ) ;
1098 win->SetSize( pt.h , pt.v , -1 ,
1099 -1 , wxSIZE_USE_EXISTING);
1100 }
1101 s_lastMouseDown = 0;
1102 }
1103 break ;
1104 case inGoAway:
1105 if (TrackGoAway(window, ev->where))
1106 {
1107 if ( win )
1108 win->Close() ;
1109 }
1110 s_lastMouseDown = 0;
1111 break;
1112 case inGrow:
1113 {
1114 int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
1115 if (growResult != 0)
1116 {
1117 int newWidth = LoWord(growResult);
1118 int newHeight = HiWord(growResult);
1119 int oldWidth, oldHeight;
1120
1121
1122 if (win)
1123 {
1124 win->GetSize(&oldWidth, &oldHeight);
1125 if (newWidth == 0)
1126 newWidth = oldWidth;
1127 if (newHeight == 0)
1128 newHeight = oldHeight;
1129 win->SetSize( -1, -1, newWidth, newHeight, wxSIZE_USE_EXISTING);
1130 }
1131 }
1132 s_lastMouseDown = 0;
1133 }
1134 break;
1135 case inZoomIn:
1136 case inZoomOut:
1137 if (TrackBox(window, ev->where, windowPart))
1138 {
1139 // TODO setup size event
1140 ZoomWindow( window , windowPart , false ) ;
1141 if (win)
1142 {
1143 Rect tempRect ;
1144
1145 GetWindowPortBounds(window, &tempRect ) ;
1146 win->SetSize( -1, -1, tempRect.right-tempRect.left ,
1147 tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
1148 }
1149 }
1150 s_lastMouseDown = 0;
1151 break;
1152 case inCollapseBox :
1153 // TODO setup size event
1154 s_lastMouseDown = 0;
1155 break ;
1156
1157 case inContent :
1158 {
1159 GrafPtr port ;
1160 GetPort( &port ) ;
1161 #if TARGET_CARBON
1162 SetPort( GetWindowPort(window) ) ;
1163 #else
1164 SetPort( (window) ) ;
1165 #endif
1166 SetOrigin( 0 , 0 ) ;
1167 SetPort( port ) ;
1168 }
1169 if ( window != frontWindow )
1170 {
1171 if ( s_macIsInModalLoop )
1172 {
1173 SysBeep ( 30 ) ;
1174 }
1175 else if ( UMAIsWindowFloating( window ) )
1176 {
1177 if ( win )
1178 win->MacMouseDown( ev , windowPart ) ;
1179 }
1180 else
1181 {
1182 UMASelectWindow( window ) ;
1183 }
1184 }
1185 else
1186 {
1187 if ( win )
1188 win->MacMouseDown( ev , windowPart ) ;
1189 }
1190 break ;
1191
1192 default:
1193 break;
1194 }
1195}
1196
1197void wxApp::MacHandleMouseUpEvent( EventRecord *ev )
1198{
1199 WindowRef window;
1200
1201 short windowPart = ::FindWindow(ev->where, &window);
1202
1203 switch (windowPart)
1204 {
1205 case inMenuBar :
1206 break ;
1207 case inSysWindow :
1208 break ;
1209 default:
1210 {
1211 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1212 if ( win )
1213 win->MacMouseUp( ev , windowPart ) ;
1214 }
1215 break;
1216 }
1217}
1218
1219long wxMacTranslateKey(unsigned char key, unsigned char code)
1220{
1221 long retval = key ;
1222 switch (key)
1223 {
1224 case 0x01 :
1225 retval = WXK_HOME;
1226 break;
1227 case 0x03 :
1228 retval = WXK_RETURN;
1229 break;
1230 case 0x04 :
1231 retval = WXK_END;
1232 break;
1233 case 0x05 :
1234 retval = WXK_HELP;
1235 break;
1236 case 0x08 :
1237 retval = WXK_BACK;
1238 break;
1239 case 0x09 :
1240 retval = WXK_TAB;
1241 break;
1242 case 0x0b :
1243 retval = WXK_PAGEUP;
1244 break;
1245 case 0x0c :
1246 retval = WXK_PAGEDOWN;
1247 break;
1248 case 0x0d :
1249 retval = WXK_RETURN;
1250 break;
1251 case 0x10 :
1252 {
1253 switch( code )
1254 {
1255 case 0x7a :
1256 retval = WXK_F1 ;
1257 break;
1258 case 0x78 :
1259 retval = WXK_F2 ;
1260 break;
1261 case 0x63 :
1262 retval = WXK_F3 ;
1263 break;
1264 case 0x76 :
1265 retval = WXK_F4 ;
1266 break;
1267 case 0x60 :
1268 retval = WXK_F5 ;
1269 break;
1270 case 0x61 :
1271 retval = WXK_F6 ;
1272 break;
1273 case 0x62:
1274 retval = WXK_F7 ;
1275 break;
1276 case 0x64 :
1277 retval = WXK_F8 ;
1278 break;
1279 case 0x65 :
1280 retval = WXK_F9 ;
1281 break;
1282 case 0x6D :
1283 retval = WXK_F10 ;
1284 break;
1285 case 0x67 :
1286 retval = WXK_F11 ;
1287 break;
1288 case 0x6F :
1289 retval = WXK_F12 ;
1290 break;
1291 case 0x69 :
1292 retval = WXK_F13 ;
1293 break;
1294 case 0x6B :
1295 retval = WXK_F14 ;
1296 break;
1297 case 0x71 :
1298 retval = WXK_F15 ;
1299 break;
1300 }
1301 }
1302 break ;
1303 case 0x1b :
1304 retval = WXK_ESCAPE ;
1305 break ;
1306 case 0x1c :
1307 retval = WXK_LEFT ;
1308 break ;
1309 case 0x1d :
1310 retval = WXK_RIGHT ;
1311 break ;
1312 case 0x1e :
1313 retval = WXK_UP ;
1314 break ;
1315 case 0x1f :
1316 retval = WXK_DOWN ;
1317 break ;
1318 case 0x7F :
1319 retval = WXK_DELETE ;
1320 default:
1321 break ;
1322 } // end switch
1323
1324 return retval;
1325}
1326
1327void wxApp::MacHandleKeyDownEvent( EventRecord *ev )
1328{
1329 wxToolTip::RemoveToolTips() ;
1330
1331 UInt32 menuresult = UMAMenuEvent(ev) ;
1332 if ( HiWord( menuresult ) )
1333 {
1334 if ( !s_macIsInModalLoop )
1335 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1336 }
1337 else
1338 {
1339 short keycode ;
1340 short keychar ;
1341 keychar = short(ev->message & charCodeMask);
1342 keycode = short(ev->message & keyCodeMask) >> 8 ;
1343
1344 wxWindow* focus = wxWindow::FindFocus() ;
1345 if ( focus )
1346 {
1347 long keyval = wxMacTranslateKey(keychar, keycode) ;
1348
1349 wxKeyEvent event(wxEVT_KEY_DOWN);
1350 event.m_shiftDown = ev->modifiers & shiftKey;
1351 event.m_controlDown = ev->modifiers & controlKey;
1352 event.m_altDown = ev->modifiers & optionKey;
1353 event.m_metaDown = ev->modifiers & cmdKey;
1354 event.m_keyCode = keyval;
1355 event.m_x = ev->where.h;
1356 event.m_y = ev->where.v;
1357 event.m_timeStamp = ev->when;
1358 event.SetEventObject(focus);
1359 bool handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1360 if ( !handled )
1361 {
1362 #if wxUSE_ACCEL
1363 if (!handled)
1364 {
1365 wxWindow *ancestor = focus;
1366 /*
1367 while (ancestor)
1368 {
1369 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1370 if (command != -1)
1371 {
1372 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1373 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1374 break;
1375 }
1376 if (ancestor->m_isFrame)
1377 break;
1378 ancestor = ancestor->GetParent();
1379 }
1380 */
1381 }
1382 #endif // wxUSE_ACCEL
1383 }
1384 if (!handled)
1385 {
1386 wxKeyEvent event(wxEVT_CHAR);
1387 event.m_shiftDown = ev->modifiers & shiftKey;
1388 event.m_controlDown = ev->modifiers & controlKey;
1389 event.m_altDown = ev->modifiers & optionKey;
1390 event.m_metaDown = ev->modifiers & cmdKey;
1391 event.m_keyCode = keyval;
1392 event.m_x = ev->where.h;
1393 event.m_y = ev->where.v;
1394 event.m_timeStamp = ev->when;
1395 event.SetEventObject(focus);
1396 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1397 }
1398 if ( !handled &&
1399 (keyval == WXK_TAB) &&
1400 (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1401 (focus->GetParent()) &&
1402 (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1403 {
1404 wxNavigationKeyEvent new_event;
1405 new_event.SetEventObject( focus );
1406 new_event.SetDirection( !event.ShiftDown() );
1407 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1408 new_event.SetWindowChange( event.ControlDown() );
1409 new_event.SetCurrentFocus( focus );
1410 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1411 }
1412 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1413 if ( (!handled) &&
1414 (keyval == '.' && event.ControlDown() ) )
1415 {
1416 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1417 new_event.SetEventObject( focus );
1418 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1419 }
1420 }
1421 }
1422}
1423
1424void wxApp::MacHandleKeyUpEvent( EventRecord *ev )
1425{
1426 // nothing to do
1427}
1428
1429void wxApp::MacHandleActivateEvent( EventRecord *ev )
1430{
1431 WindowRef window = (WindowRef) ev->message ;
1432 if ( window )
1433 {
1434 bool activate = (ev->modifiers & activeFlag ) ;
1435 WindowClass wclass ;
1436 UMAGetWindowClass ( window , &wclass ) ;
1437 if ( wclass == kFloatingWindowClass )
1438 {
1439 // if it is a floater we activate/deactivate the front non-floating window instead
1440 window = UMAFrontNonFloatingWindow() ;
1441 }
1442 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1443 if ( win )
1444 win->MacActivate( ev , activate ) ;
1445 }
1446}
1447
1448void wxApp::MacHandleUpdateEvent( EventRecord *ev )
1449{
1450 WindowRef window = (WindowRef) ev->message ;
1451 wxWindow * win = wxFindWinFromMacWindow( window ) ;
1452 if ( win )
1453 {
1454 win->MacUpdate( ev ) ;
1455 }
1456 else
1457 {
1458 // since there is no way of telling this foreign window to update itself
1459 // we have to invalidate the update region otherwise we keep getting the same
1460 // event over and over again
1461 BeginUpdate( window ) ;
1462 EndUpdate( window ) ;
1463 }
1464}
1465
1466void wxApp::MacHandleDiskEvent( EventRecord *ev )
1467{
1468 if ( HiWord( ev->message ) != noErr )
1469 {
1470 #if !TARGET_CARBON
1471 OSErr err ;
1472 Point point ;
1473 SetPt( &point , 100 , 100 ) ;
1474
1475 err = DIBadMount( point , ev->message ) ;
1476 wxASSERT( err == noErr ) ;
1477#endif
1478 }
1479}
1480
1481void wxApp::MacHandleOSEvent( EventRecord *ev )
1482{
1483 switch( ( ev->message & osEvtMessageMask ) >> 24 )
1484 {
1485 case suspendResumeMessage :
1486 {
1487 bool isResuming = ev->message & resumeFlag ;
1488#if !TARGET_CARBON
1489 bool convertClipboard = ev->message & convertClipboardFlag ;
1490#else
1491 bool convertClipboard = false;
1492#endif
1493 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
1494 if ( isResuming )
1495 {
1496 WindowRef oldFrontWindow = NULL ;
1497 WindowRef newFrontWindow = NULL ;
1498
1499 // in case we don't take care of activating ourselves, we have to synchronize
1500 // our idea of the active window with the process manager's - which it already activated
1501
1502 if ( !doesActivate )
1503 oldFrontWindow = UMAFrontNonFloatingWindow() ;
1504
1505 MacResume( convertClipboard ) ;
1506
1507 newFrontWindow = UMAFrontNonFloatingWindow() ;
1508
1509 if ( oldFrontWindow )
1510 {
1511 wxWindow* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
1512 if ( win )
1513 win->MacActivate( ev , false ) ;
1514 }
1515 if ( newFrontWindow )
1516 {
1517 wxWindow* win = wxFindWinFromMacWindow( newFrontWindow ) ;
1518 if ( win )
1519 win->MacActivate( ev , true ) ;
1520 }
1521 }
1522 else
1523 {
1524 MacSuspend( convertClipboard ) ;
1525
1526 // in case this suspending did close an active window, another one might
1527 // have surfaced -> lets deactivate that one
1528
1529 WindowRef newActiveWindow = UMAGetActiveNonFloatingWindow() ;
1530 if ( newActiveWindow )
1531 {
1532 wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
1533 if ( win )
1534 win->MacActivate( ev , false ) ;
1535 }
1536 }
1537 }
1538 break ;
1539 case mouseMovedMessage :
1540 {
1541 WindowRef window;
1542
1543 wxWindow* currentMouseWindow = NULL ;
1544
1545 wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
1546 &currentMouseWindow ) ;
1547
1548 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
1549 {
1550 wxMouseEvent event ;
1551
1552 bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
1553 bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
1554
1555 event.m_leftDown = isDown && !controlDown;
1556 event.m_middleDown = FALSE;
1557 event.m_rightDown = isDown && controlDown;
1558 event.m_shiftDown = ev->modifiers & shiftKey;
1559 event.m_controlDown = ev->modifiers & controlKey;
1560 event.m_altDown = ev->modifiers & optionKey;
1561 event.m_metaDown = ev->modifiers & cmdKey;
1562 event.m_x = ev->where.h;
1563 event.m_y = ev->where.v;
1564 event.m_timeStamp = ev->when;
1565 event.SetEventObject(this);
1566
1567 if ( wxWindow::s_lastMouseWindow )
1568 {
1569 wxMouseEvent eventleave(event ) ;
1570 eventleave.SetEventType( wxEVT_LEAVE_WINDOW ) ;
1571 wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
1572 }
1573 if ( currentMouseWindow )
1574 {
1575 wxMouseEvent evententer(event ) ;
1576 evententer.SetEventType( wxEVT_ENTER_WINDOW ) ;
1577 currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
1578 }
1579 wxWindow::s_lastMouseWindow = currentMouseWindow ;
1580 }
1581
1582 short windowPart = ::FindWindow(ev->where, &window);
1583
1584 switch (windowPart)
1585 {
1586 // fixes for setting the cursor back from dominic mazzoni
1587 case inMenuBar :
1588 UMAShowArrowCursor();
1589 break ;
1590 case inSysWindow :
1591 UMAShowArrowCursor();
1592 break ;
1593 default:
1594 {
1595 if ( s_lastMouseDown == 0 )
1596 ev->modifiers |= btnState ;
1597
1598 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1599 if ( win )
1600 win->MacMouseMoved( ev , windowPart ) ;
1601 else
1602 UMAShowArrowCursor();
1603
1604 }
1605 break;
1606 }
1607 }
1608 break ;
1609
1610 }
1611}
1612
1613void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
1614{
1615 if (macMenuId == 0)
1616 return; // no menu item selected
1617
1618 if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
1619 {
1620 #if ! TARGET_CARBON
1621 Str255 deskAccessoryName ;
1622 GrafPtr savedPort ;
1623
1624 GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
1625 GetPort(&savedPort);
1626 OpenDeskAcc(deskAccessoryName);
1627 SetPort(savedPort);
1628 #endif
1629 }
1630 else
1631 {
1632 wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() ) ;
1633 if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
1634 wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
1635 }
1636 HiliteMenu(0);
1637}
1638
1639/*
1640long wxApp::MacTranslateKey(char key, int mods)
1641{
1642}
1643
1644void wxApp::MacAdjustCursor()
1645{
1646}
1647
1648*/
1649/*
1650void
1651wxApp::macAdjustCursor()
1652{
1653 if (ev->what != kHighLevelEvent)
1654 {
1655 wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
1656 if (theMacWxFrame)
1657 {
1658 if (!theMacWxFrame->MacAdjustCursor(ev->where))
1659 ::SetCursor(&(qd.arrow));
1660 }
1661 }
1662}
1663*/
wxWidgets (Impactor)