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