]> 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
fixing repositioning problem for statusbar
[wxWidgets.git] / src / mac / carbon / app.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: app.cpp
3// Purpose: wxApp
4// Author: Stefan Csomor
5// Modified by:
6// Created: 1998-01-01
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
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#include "wx/docview.h"
40#include "wx/filename.h"
41
42#include <string.h>
43
44// mac
45
46#ifndef __DARWIN__
47 #if __option(profile)
48 #include <profiler.h>
49 #endif
50#endif
51
52// #include "apprsrc.h"
53
54#include "wx/mac/uma.h"
55#include "wx/mac/macnotfy.h"
56
57#ifdef __DARWIN__
58# include <CoreServices/CoreServices.h>
59# if defined(WXMAKINGDLL_CORE)
60# include <mach-o/dyld.h>
61# endif
62#else
63# include <Sound.h>
64# include <Threads.h>
65# include <ToolUtils.h>
66# include <DiskInit.h>
67# include <Devices.h>
68#endif
69
70extern wxList wxPendingDelete;
71
72// set wxMAC_USE_RAEL to 1 if RunApplicationEventLoop should be used
73// if 0 the lower level CarbonEventLoop will be used
74// on the long run RAEL should replace the low level event loop
75// we will have to clean up event handling to make sure we don't
76// miss handling of things like pending events etc
77// perhaps we will also have to pipe events through an ueber-event-handler
78// to make sure we have one place to do all these house-keeping functions
79
80#define wxMAC_USE_RAEL 0
81
82#if wxUSE_THREADS
83extern size_t g_numberOfThreads;
84#endif // wxUSE_THREADS
85
86// statics for implementation
87
88static bool s_inYield = FALSE;
89
90static bool s_inReceiveEvent = FALSE ;
91static EventTime sleepTime = kEventDurationNoWait ;
92
93#if !USE_SHARED_LIBRARY
94IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
95BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
96 EVT_IDLE(wxApp::OnIdle)
97 EVT_END_SESSION(wxApp::OnEndSession)
98 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
99END_EVENT_TABLE()
100#endif
101
102
103const short kMacMinHeap = (29 * 1024) ;
104// platform specific static variables
105
106const short kwxMacMenuBarResource = 1 ;
107const short kwxMacAppleMenuId = 1 ;
108
109WXHRGN wxApp::s_macCursorRgn = NULL;
110wxWindow* wxApp::s_captureWindow = NULL ;
111int wxApp::s_lastMouseDown = 0 ;
112long wxApp::sm_lastMessageTime = 0;
113long wxApp::s_lastModifiers = 0 ;
114
115
116bool wxApp::s_macSupportPCMenuShortcuts = true ;
117long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
118long wxApp::s_macPreferencesMenuItemId = wxID_PREFERENCES ;
119long wxApp::s_macExitMenuItemId = wxID_EXIT ;
120wxString wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
121
122// Normally we're not a plugin
123bool wxApp::sm_isEmbedded = false;
124//----------------------------------------------------------------------
125// Core Apple Event Support
126//----------------------------------------------------------------------
127
128pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
129pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
130pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
131pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
132pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
133
134pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
135{
136 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
137}
138
139pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
140{
141 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
142}
143
144pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
145{
146 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
147}
148
149pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
150{
151 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
152}
153
154pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
155{
156 return wxTheApp->MacHandleAERApp( (AppleEvent*) event , reply) ;
157}
158
159// AEODoc Calls MacOpenFile on each of the files passed
160
161short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
162{
163 AEDescList docList;
164 AEKeyword keywd;
165 DescType returnedType;
166 Size actualSize;
167 long itemsInList;
168 OSErr err;
169 short i;
170 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
171 if (err != noErr)
172 return err;
173
174 err = AECountItems(&docList, &itemsInList);
175 if (err != noErr)
176 return err;
177
178 ProcessSerialNumber PSN ;
179 PSN.highLongOfPSN = 0 ;
180 PSN.lowLongOfPSN = kCurrentProcess ;
181 SetFrontProcess( &PSN ) ;
182
183 for (i = 1; i <= itemsInList; i++)
184 {
185 wxString fName ;
186
187 FSRef theRef ;
188 AEGetNthPtr(&docList, i, typeFSRef, &keywd, &returnedType,
189 (Ptr) & theRef, sizeof(theRef), &actualSize);
190 fName = wxMacFSRefToPath( &theRef ) ;
191
192 MacOpenFile(fName);
193 }
194 return noErr;
195}
196
197// AEPDoc Calls MacPrintFile on each of the files passed
198
199short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
200{
201 AEDescList docList;
202 AEKeyword keywd;
203 DescType returnedType;
204 Size actualSize;
205 long itemsInList;
206 OSErr err;
207 short i;
208 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
209 if (err != noErr)
210 return err;
211
212 err = AECountItems(&docList, &itemsInList);
213 if (err != noErr)
214 return err;
215
216 ProcessSerialNumber PSN ;
217 PSN.highLongOfPSN = 0 ;
218 PSN.lowLongOfPSN = kCurrentProcess ;
219 SetFrontProcess( &PSN ) ;
220
221 for (i = 1; i <= itemsInList; i++) {
222 wxString fName ;
223
224 FSRef theRef ;
225 AEGetNthPtr(&docList, i, typeFSRef, &keywd, &returnedType,
226 (Ptr) & theRef, sizeof(theRef), &actualSize);
227 fName = wxMacFSRefToPath( &theRef ) ;
228
229 MacPrintFile(fName);
230 }
231 return noErr;
232}
233
234// AEOApp calls MacNewFile
235
236short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
237{
238 MacNewFile() ;
239 return noErr ;
240}
241
242// AEQuit attempts to quit the application
243
244short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
245{
246 wxWindow* win = GetTopWindow() ;
247 if ( win )
248 {
249 wxCommandEvent exitEvent(wxEVT_COMMAND_MENU_SELECTED, s_macExitMenuItemId);
250 if (!win->ProcessEvent(exitEvent))
251 win->Close(TRUE ) ;
252 }
253 else
254 {
255 ExitMainLoop() ;
256 }
257 return noErr ;
258}
259
260// AEROApp calls MacReopenApp
261
262short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
263{
264 MacReopenApp() ;
265 return noErr ;
266}
267
268
269//----------------------------------------------------------------------
270// Support Routines linking the Mac...File Calls to the Document Manager
271//----------------------------------------------------------------------
272
273void wxApp::MacOpenFile(const wxString & fileName )
274{
275 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
276 if ( dm )
277 dm->CreateDocument(fileName , wxDOC_SILENT ) ;
278}
279
280void wxApp::MacPrintFile(const wxString & fileName )
281{
282 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
283 if ( dm )
284 {
285 wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
286 if ( doc )
287 {
288 wxView* view = doc->GetFirstView() ;
289 if( view )
290 {
291 wxPrintout *printout = view->OnCreatePrintout();
292 if (printout)
293 {
294 wxPrinter printer;
295 printer.Print(view->GetFrame(), printout, TRUE);
296 delete printout;
297 }
298 }
299 if (doc->Close())
300 {
301 doc->DeleteAllViews();
302 dm->RemoveDocument(doc) ;
303 }
304 }
305 }
306}
307
308void wxApp::MacNewFile()
309{
310}
311
312void wxApp::MacReopenApp()
313{
314 // HIG says :
315 // if there is no open window -> create a new one
316 // if all windows are hidden -> show the first
317 // if some windows are not hidden -> do nothing
318
319 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
320 if ( node == NULL )
321 {
322 MacNewFile() ;
323 }
324 else
325 {
326 wxTopLevelWindow* firstIconized = NULL ;
327 while (node)
328 {
329 wxTopLevelWindow* win = (wxTopLevelWindow*) node->GetData();
330 if ( win->IsIconized() == false )
331 {
332 firstIconized = NULL ;
333 break ;
334 }
335 else
336 {
337 if ( firstIconized == NULL )
338 firstIconized = win ;
339 }
340 node = node->GetNext();
341 }
342 if ( firstIconized )
343 firstIconized->Iconize( false ) ;
344 }
345}
346
347//----------------------------------------------------------------------
348// Carbon Event Handler
349//----------------------------------------------------------------------
350
351static const EventTypeSpec eventList[] =
352{
353 { kEventClassCommand, kEventProcessCommand } ,
354 { kEventClassCommand, kEventCommandUpdateStatus } ,
355
356 { kEventClassMenu, kEventMenuOpening },
357 { kEventClassMenu, kEventMenuClosed },
358 { kEventClassMenu, kEventMenuTargetItem },
359
360 { kEventClassApplication , kEventAppActivated } ,
361 { kEventClassApplication , kEventAppDeactivated } ,
362 // handling the quit event is not recommended by apple
363 // rather using the quit apple event - which we do
364
365 { kEventClassAppleEvent , kEventAppleEvent } ,
366
367 { kEventClassMouse , kEventMouseDown } ,
368 { kEventClassMouse , kEventMouseMoved } ,
369 { kEventClassMouse , kEventMouseUp } ,
370 { kEventClassMouse , kEventMouseDragged } ,
371 { 'WXMC' , 'WXMC' }
372} ;
373
374static pascal OSStatus
375wxMacAppMenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
376{
377 wxMacCarbonEvent cEvent( event ) ;
378 MenuRef menuRef = cEvent.GetParameter<MenuRef>(kEventParamDirectObject) ;
379 wxMenu* menu = wxFindMenuFromMacMenu( menuRef ) ;
380
381 if ( menu )
382 {
383 wxEventType type=0;
384 MenuCommand cmd=0;
385 switch (GetEventKind(event))
386 {
387 case kEventMenuOpening:
388 type = wxEVT_MENU_OPEN;
389 break;
390 case kEventMenuClosed:
391 type = wxEVT_MENU_CLOSE;
392 break;
393 case kEventMenuTargetItem:
394 cmd = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
395 if (cmd != 0)
396 type = wxEVT_MENU_HIGHLIGHT;
397 break;
398 default:
399 wxFAIL_MSG(wxT("Unexpected menu event kind"));
400 break;
401 }
402
403 if ( type )
404 {
405 wxMenuEvent wxevent(type, cmd);
406 wxevent.SetEventObject(menu);
407
408 wxEvtHandler* handler = menu->GetEventHandler();
409 if (handler && handler->ProcessEvent(wxevent))
410 {
411 // handled
412 }
413 else
414 {
415 wxWindow *win = menu->GetInvokingWindow();
416 if (win)
417 win->GetEventHandler()->ProcessEvent(wxevent);
418 }
419 }
420 }
421
422 return eventNotHandledErr;
423}
424
425static pascal OSStatus wxMacAppCommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
426{
427 OSStatus result = eventNotHandledErr ;
428
429 HICommand command ;
430
431 wxMacCarbonEvent cEvent( event ) ;
432 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
433
434 wxMenuItem* item = NULL ;
435 MenuCommand id = command.commandID ;
436 // for items we don't really control
437 if ( id == kHICommandPreferences )
438 {
439 id = wxApp::s_macPreferencesMenuItemId ;
440
441 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
442 if ( mbar )
443 {
444 wxMenu* menu = NULL ;
445 item = mbar->FindItem( id , &menu ) ;
446 }
447 }
448 else if ( id != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
449 {
450 GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , (UInt32*) &item ) ;
451 }
452
453 if ( item )
454 {
455 switch( cEvent.GetKind() )
456 {
457 case kEventProcessCommand :
458 {
459 if (item->IsCheckable())
460 {
461 item->Check( !item->IsChecked() ) ;
462 }
463
464 item->GetMenu()->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
465 result = noErr ;
466 }
467 break ;
468 case kEventCommandUpdateStatus:
469 // eventually trigger an updateui round
470 result = noErr ;
471 break ;
472 default :
473 break ;
474 }
475 }
476 return result ;
477}
478
479static pascal OSStatus wxMacAppApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
480{
481 OSStatus result = eventNotHandledErr ;
482 switch ( GetEventKind( event ) )
483 {
484 case kEventAppActivated :
485 {
486 if ( wxTheApp )
487 wxTheApp->SetActive( true , NULL ) ;
488 result = noErr ;
489 }
490 break ;
491 case kEventAppDeactivated :
492 {
493 if ( wxTheApp )
494 wxTheApp->SetActive( false , NULL ) ;
495 result = noErr ;
496 }
497 break ;
498 default :
499 break ;
500 }
501 return result ;
502}
503
504pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
505{
506 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
507 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
508 wxTheApp->MacSetCurrentEvent( event , handler ) ;
509
510 OSStatus result = eventNotHandledErr ;
511 switch( GetEventClass( event ) )
512 {
513 case kEventClassCommand :
514 result = wxMacAppCommandEventHandler( handler , event , data ) ;
515 break ;
516 case kEventClassApplication :
517 result = wxMacAppApplicationEventHandler( handler , event , data ) ;
518 break ;
519 case kEventClassMenu :
520 result = wxMacAppMenuEventHandler( handler , event , data ) ;
521 break ;
522 case kEventClassMouse :
523 result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
524 break ;
525 case kEventClassAppleEvent :
526 {
527 EventRecord rec ;
528 wxMacConvertEventToRecord( event , &rec ) ;
529 result = AEProcessAppleEvent( &rec ) ;
530 }
531 break ;
532 default :
533 break ;
534 }
535
536 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
537
538 return result ;
539}
540
541DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
542
543#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)
544// we know it's there ;-)
545WXIMPORT char std::__throws_bad_alloc ;
546#endif
547
548pascal static void wxMacAssertOutputHandler(OSType componentSignature, UInt32 options,
549 const char *assertionString, const char *exceptionLabelString,
550 const char *errorString, const char *fileName, long lineNumber, void *value, ConstStr255Param outputMsg)
551{
552 // flow into assert handling
553 wxString fileNameStr ;
554 wxString assertionStr ;
555 wxString exceptionStr ;
556 wxString errorStr ;
557#if wxUSE_UNICODE
558 fileNameStr = wxString(fileName, wxConvLocal);
559 assertionStr = wxString(assertionString, wxConvLocal);
560 exceptionStr = wxString((exceptionLabelString!=0) ? exceptionLabelString : "", wxConvLocal) ;
561 errorStr = wxString((errorString!=0) ? errorString : "", wxConvLocal) ;
562#else
563 fileNameStr = fileName;
564 assertionStr = assertionString;
565 exceptionStr = (exceptionLabelString!=0) ? exceptionLabelString : "" ;
566 errorStr = (errorString!=0) ? errorString : "" ;
567#endif
568
569#if 1
570 // flow into log
571 wxLogDebug( wxT("AssertMacros: %s %s %s file: %s, line: %ld (value %p)\n"),
572 assertionStr.c_str() ,
573 exceptionStr.c_str() ,
574 errorStr.c_str(),
575 fileNameStr.c_str(), lineNumber ,
576 value ) ;
577#else
578
579 wxOnAssert(fileNameStr, lineNumber , assertionStr ,
580 wxString::Format( wxT("%s %s value (%p)") ,exceptionStr, errorStr , value ) ) ;
581#endif
582}
583
584bool wxApp::Initialize(int& argc, wxChar **argv)
585{
586 // Mac-specific
587
588#if __WXDEBUG__
589 InstallDebugAssertOutputHandler ( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
590#endif
591 UMAInitToolbox( 4, sm_isEmbedded ) ;
592 SetEventMask( everyEvent ) ;
593 UMAShowWatchCursor() ;
594
595#ifndef __DARWIN__
596# if __option(profile)
597 ProfilerInit( collectDetailed, bestTimeBase , 40000 , 50 ) ;
598# endif
599#endif
600
601#ifndef __DARWIN__
602 // now avoid exceptions thrown for new (bad_alloc)
603 // FIXME CS for some changes outside wxMac does not compile anymore
604#if 0
605 std::__throws_bad_alloc = 0 ;
606#endif
607
608#endif
609
610 s_macCursorRgn = ::NewRgn() ;
611
612 // Mac OS X passes a process serial number command line argument when
613 // the application is launched from the Finder. This argument must be
614 // removed from the command line arguments before being handled by the
615 // application (otherwise applications would need to handle it)
616 if ( argc > 1 )
617 {
618 static const wxChar *ARG_PSN = _T("-psn_");
619 if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 )
620 {
621 // remove this argument
622 --argc;
623 memmove(argv + 1, argv + 2, argc * sizeof(char *));
624 }
625 }
626
627 if ( !wxAppBase::Initialize(argc, argv) )
628 return false;
629
630#if wxUSE_INTL
631 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
632#endif
633
634#if TARGET_API_MAC_OSX
635 // these might be the startup dirs, set them to the 'usual' dir containing the app bundle
636 wxString startupCwd = wxGetCwd() ;
637 if ( startupCwd == wxT("/") || startupCwd.Right(15) == wxT("/Contents/MacOS") )
638 {
639 CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle() ) ;
640 CFURLRef urlParent = CFURLCreateCopyDeletingLastPathComponent( kCFAllocatorDefault , url ) ;
641 CFRelease( url ) ;
642 CFStringRef path = CFURLCopyFileSystemPath ( urlParent , kCFURLPOSIXPathStyle ) ;
643 CFRelease( urlParent ) ;
644 wxString cwd = wxMacCFStringHolder(path).AsString(wxLocale::GetSystemEncoding());
645 wxSetWorkingDirectory( cwd ) ;
646 }
647#endif
648
649 wxMacCreateNotifierTable() ;
650
651 UMAShowArrowCursor() ;
652
653 return true;
654}
655
656bool wxApp::OnInitGui()
657{
658 if( !wxAppBase::OnInitGui() )
659 return false ;
660
661 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
662
663 if (!sm_isEmbedded)
664 {
665 InstallApplicationEventHandler(
666 GetwxMacAppEventHandlerUPP(),
667 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
668 }
669
670 if (!sm_isEmbedded)
671 {
672 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
673 NewAEEventHandlerUPP(AEHandleODoc) ,
674 0 , FALSE ) ;
675 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
676 NewAEEventHandlerUPP(AEHandleOApp) ,
677 0 , FALSE ) ;
678 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
679 NewAEEventHandlerUPP(AEHandlePDoc) ,
680 0 , FALSE ) ;
681 AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
682 NewAEEventHandlerUPP(AEHandleRApp) ,
683 0 , FALSE ) ;
684 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
685 NewAEEventHandlerUPP(AEHandleQuit) ,
686 0 , FALSE ) ;
687 }
688
689 return TRUE ;
690}
691
692void wxApp::CleanUp()
693{
694 wxToolTip::RemoveToolTips() ;
695
696 // One last chance for pending objects to be cleaned up
697 wxTheApp->DeletePendingObjects();
698
699 wxMacDestroyNotifierTable() ;
700
701#ifndef __DARWIN__
702# if __option(profile)
703 ProfilerDump( (StringPtr)"\papp.prof" ) ;
704 ProfilerTerm() ;
705# endif
706#endif
707
708 UMACleanupToolbox() ;
709 if (s_macCursorRgn) {
710 ::DisposeRgn((RgnHandle)s_macCursorRgn);
711 }
712
713 #if 0
714 TerminateAE() ;
715 #endif
716
717 wxAppBase::CleanUp();
718}
719
720//----------------------------------------------------------------------
721// misc initialization stuff
722//----------------------------------------------------------------------
723
724#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)
725
726// for shared libraries we have to manually get the correct resource
727// ref num upon initializing and releasing when terminating, therefore
728// the __wxinitialize and __wxterminate must be used
729
730extern "C" {
731 void __sinit(void); /* (generated by linker) */
732 pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
733 pascal void __terminate(void);
734}
735
736pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
737{
738 return __initialize( theInitBlock ) ;
739}
740
741pascal void __wxterminate(void)
742{
743 __terminate() ;
744}
745
746#endif /* WXMAKINGDLL_CORE && !__DARWIN__ */
747
748bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
749{
750 bool converted = ConvertEventRefToEventRecord( event,rec) ;
751 OSStatus err = noErr ;
752 if ( !converted )
753 {
754 switch( GetEventClass( event ) )
755 {
756 case kEventClassKeyboard :
757 {
758 converted = true ;
759 switch( GetEventKind(event) )
760 {
761 case kEventRawKeyDown :
762 rec->what = keyDown ;
763 break ;
764 case kEventRawKeyRepeat :
765 rec->what = autoKey ;
766 break ;
767 case kEventRawKeyUp :
768 rec->what = keyUp ;
769 break ;
770 case kEventRawKeyModifiersChanged :
771 rec->what = nullEvent ;
772 break ;
773 default :
774 converted = false ;
775 break ;
776 }
777 if ( converted )
778 {
779 UInt32 keyCode ;
780 unsigned char charCode ;
781 UInt32 modifiers ;
782 GetMouse( &rec->where) ;
783
784 err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
785 err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
786 err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
787 rec->modifiers = modifiers ;
788 rec->message = (keyCode << 8 ) + charCode ;
789 }
790 }
791 break ;
792 case kEventClassTextInput :
793 {
794 switch( GetEventKind( event ) )
795 {
796 case kEventTextInputUnicodeForKeyEvent :
797 {
798 EventRef rawEvent ;
799 err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
800 converted = true ;
801 {
802 UInt32 keyCode ;
803 unsigned char charCode ;
804 UInt32 modifiers ;
805 GetMouse( &rec->where) ;
806 rec->what = keyDown ;
807 err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
808 err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
809 err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
810 rec->modifiers = modifiers ;
811 rec->message = (keyCode << 8 ) + charCode ;
812 }
813 }
814 break ;
815 default :
816 break ;
817 }
818 }
819 break ;
820 }
821 }
822
823 return converted ;
824}
825
826wxApp::wxApp()
827{
828 m_printMode = wxPRINT_WINDOWS;
829
830 m_macCurrentEvent = NULL ;
831 m_macCurrentEventHandlerCallRef = NULL ;
832}
833
834int wxApp::MainLoop()
835{
836 m_keepGoing = TRUE;
837#if wxMAC_USE_RAEL
838 RunApplicationEventLoop() ;
839#else
840 while (m_keepGoing)
841 {
842 MacDoOneEvent() ;
843 }
844#endif
845 return 0;
846}
847
848void wxApp::ExitMainLoop()
849{
850 m_keepGoing = FALSE;
851#if wxMAC_USE_RAEL
852 QuitApplicationEventLoop() ;
853#endif
854}
855
856// Is a message/event pending?
857bool wxApp::Pending()
858{
859 // without the receive event (with pull param = false ) nothing is ever reported
860 EventRef theEvent;
861 ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &theEvent);
862 return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
863}
864
865// Dispatch a message.
866bool wxApp::Dispatch()
867{
868 MacDoOneEvent() ;
869
870 return true;
871}
872
873void wxApp::OnIdle(wxIdleEvent& event)
874{
875 wxAppBase::OnIdle(event);
876
877 // If they are pending events, we must process them: pending events are
878 // either events to the threads other than main or events posted with
879 // wxPostEvent() functions
880 wxMacProcessNotifierAndPendingEvents();
881
882 if(!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
883 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
884}
885
886void wxApp::WakeUpIdle()
887{
888 wxMacWakeUp() ;
889}
890
891void wxApp::Exit()
892{
893 wxApp::CleanUp();
894 ::ExitToShell() ;
895}
896
897void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
898{
899 if (GetTopWindow())
900 GetTopWindow()->Close(TRUE);
901}
902
903// Default behaviour: close the application with prompts. The
904// user can veto the close, and therefore the end session.
905void wxApp::OnQueryEndSession(wxCloseEvent& event)
906{
907 if (GetTopWindow())
908 {
909 if (!GetTopWindow()->Close(!event.CanVeto()))
910 event.Veto(TRUE);
911 }
912}
913
914extern "C" void wxCYield() ;
915void wxCYield()
916{
917 wxYield() ;
918}
919
920// Yield to other processes
921
922bool wxApp::Yield(bool onlyIfNeeded)
923{
924 if (s_inYield)
925 {
926 if ( !onlyIfNeeded )
927 {
928 wxFAIL_MSG( wxT("wxYield called recursively" ) );
929 }
930
931 return FALSE;
932 }
933
934 s_inYield = TRUE;
935
936 // by definition yield should handle all non-processed events
937
938 EventRef theEvent;
939
940 OSStatus status = noErr ;
941 do
942 {
943 s_inReceiveEvent = true ;
944 status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
945 s_inReceiveEvent = false ;
946
947 if ( status == eventLoopTimedOutErr )
948 {
949 // make sure next time the event loop will trigger idle events
950 sleepTime = kEventDurationNoWait ;
951 }
952 else if ( status == eventLoopQuitErr )
953 {
954 // according to QA1061 this may also occur when a WakeUp Process
955 // is executed
956 }
957 else
958 {
959 MacHandleOneEvent( theEvent ) ;
960 ReleaseEvent(theEvent);
961 }
962 } while( status == noErr ) ;
963
964 wxMacProcessNotifierAndPendingEvents() ;
965 s_inYield = FALSE;
966
967 return TRUE;
968}
969
970void wxApp::MacDoOneEvent()
971{
972 EventRef theEvent;
973
974 s_inReceiveEvent = true ;
975 OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
976 s_inReceiveEvent = false ;
977 if ( status == eventLoopTimedOutErr )
978 {
979 if ( wxTheApp->ProcessIdle() )
980 sleepTime = kEventDurationNoWait ;
981 else
982 sleepTime = kEventDurationSecond;
983 }
984 else if ( status == eventLoopQuitErr )
985 {
986 // according to QA1061 this may also occur when a WakeUp Process
987 // is executed
988 }
989 else
990 {
991 MacHandleOneEvent( theEvent ) ;
992 ReleaseEvent(theEvent);
993 sleepTime = kEventDurationNoWait ;
994 }
995 // repeaters
996
997 DeletePendingObjects() ;
998 wxMacProcessNotifierAndPendingEvents() ;
999}
1000
1001/*virtual*/ void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
1002{
1003 // Override to process unhandled events as you please
1004}
1005
1006void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1007{
1008 EventTargetRef theTarget;
1009 theTarget = GetEventDispatcherTarget();
1010 m_macCurrentEvent = evr ;
1011 OSStatus status = SendEventToEventTarget ((EventRef) evr , theTarget);
1012 if(status == eventNotHandledErr)
1013 {
1014 MacHandleUnhandledEvent(evr);
1015 }
1016 wxMacProcessNotifierAndPendingEvents() ;
1017#if wxUSE_THREADS
1018 wxMutexGuiLeaveOrEnter();
1019#endif // wxUSE_THREADS
1020}
1021
1022long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1023long wxMacTranslateKey(unsigned char key, unsigned char code)
1024{
1025 long retval = key ;
1026 switch (key)
1027 {
1028 case kHomeCharCode :
1029 retval = WXK_HOME;
1030 break;
1031 case kEnterCharCode :
1032 retval = WXK_RETURN;
1033 break;
1034 case kEndCharCode :
1035 retval = WXK_END;
1036 break;
1037 case kHelpCharCode :
1038 retval = WXK_HELP;
1039 break;
1040 case kBackspaceCharCode :
1041 retval = WXK_BACK;
1042 break;
1043 case kTabCharCode :
1044 retval = WXK_TAB;
1045 break;
1046 case kPageUpCharCode :
1047 retval = WXK_PAGEUP;
1048 break;
1049 case kPageDownCharCode :
1050 retval = WXK_PAGEDOWN;
1051 break;
1052 case kReturnCharCode :
1053 retval = WXK_RETURN;
1054 break;
1055 case kFunctionKeyCharCode :
1056 {
1057 switch( code )
1058 {
1059 case 0x7a :
1060 retval = WXK_F1 ;
1061 break;
1062 case 0x78 :
1063 retval = WXK_F2 ;
1064 break;
1065 case 0x63 :
1066 retval = WXK_F3 ;
1067 break;
1068 case 0x76 :
1069 retval = WXK_F4 ;
1070 break;
1071 case 0x60 :
1072 retval = WXK_F5 ;
1073 break;
1074 case 0x61 :
1075 retval = WXK_F6 ;
1076 break;
1077 case 0x62:
1078 retval = WXK_F7 ;
1079 break;
1080 case 0x64 :
1081 retval = WXK_F8 ;
1082 break;
1083 case 0x65 :
1084 retval = WXK_F9 ;
1085 break;
1086 case 0x6D :
1087 retval = WXK_F10 ;
1088 break;
1089 case 0x67 :
1090 retval = WXK_F11 ;
1091 break;
1092 case 0x6F :
1093 retval = WXK_F12 ;
1094 break;
1095 case 0x69 :
1096 retval = WXK_F13 ;
1097 break;
1098 case 0x6B :
1099 retval = WXK_F14 ;
1100 break;
1101 case 0x71 :
1102 retval = WXK_F15 ;
1103 break;
1104 }
1105 }
1106 break ;
1107 case kEscapeCharCode :
1108 retval = WXK_ESCAPE ;
1109 break ;
1110 case kLeftArrowCharCode :
1111 retval = WXK_LEFT ;
1112 break ;
1113 case kRightArrowCharCode :
1114 retval = WXK_RIGHT ;
1115 break ;
1116 case kUpArrowCharCode :
1117 retval = WXK_UP ;
1118 break ;
1119 case kDownArrowCharCode :
1120 retval = WXK_DOWN ;
1121 break ;
1122 case kDeleteCharCode :
1123 retval = WXK_DELETE ;
1124 default:
1125 break ;
1126 } // end switch
1127
1128 return retval;
1129}
1130
1131int wxMacKeyCodeToModifier(wxKeyCode key)
1132{
1133 switch (key)
1134 {
1135 case WXK_START:
1136 case WXK_MENU:
1137 return cmdKey;
1138
1139 case WXK_SHIFT:
1140 return shiftKey;
1141
1142 case WXK_CAPITAL:
1143 return alphaLock;
1144
1145 case WXK_ALT:
1146 return optionKey;
1147
1148 case WXK_CONTROL:
1149 return controlKey;
1150
1151 default:
1152 return 0;
1153 }
1154}
1155
1156bool wxGetKeyState(wxKeyCode key) //virtual key code if < 10.2.x, else see below
1157{
1158//#ifdef __DARWIN__
1159// wxHIDKeyboard keyboard;
1160// return keyboard.IsActive(key);
1161//#else
1162// TODO: Have it use HID Manager on OSX...
1163//if OS X > 10.2 (i.e. 10.2.x)
1164//a known apple bug prevents the system from determining led
1165//states with GetKeys... can only determine caps lock led
1166 return !!(GetCurrentKeyModifiers() & wxMacKeyCodeToModifier(key));
1167//else
1168// KeyMapByteArray keymap;
1169// GetKeys((BigEndianLong*)keymap);
1170// return !!(BitTst(keymap, (sizeof(KeyMapByteArray)*8) - iKey));
1171//#endif
1172}
1173
1174
1175bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1176{
1177 if ( !focus )
1178 return false ;
1179
1180 short keycode ;
1181 short keychar ;
1182 keychar = short(keymessage & charCodeMask);
1183 keycode = short(keymessage & keyCodeMask) >> 8 ;
1184
1185 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1186 {
1187 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1188 // and look at the character after
1189 UInt32 state = 0;
1190 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1191 keychar = short(keyInfo & charCodeMask);
1192 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1193 }
1194 long keyval = wxMacTranslateKey(keychar, keycode) ;
1195 long realkeyval = keyval ;
1196 if ( keyval == keychar )
1197 {
1198 // 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)
1199 realkeyval = short(keymessage & charCodeMask) ;
1200 keyval = wxToupper( keyval ) ;
1201 }
1202
1203 wxKeyEvent event(wxEVT_KEY_DOWN);
1204 bool handled = false ;
1205 event.m_shiftDown = modifiers & shiftKey;
1206 event.m_controlDown = modifiers & controlKey;
1207 event.m_altDown = modifiers & optionKey;
1208 event.m_metaDown = modifiers & cmdKey;
1209 event.m_keyCode = keyval ;
1210
1211 event.m_x = wherex;
1212 event.m_y = wherey;
1213 event.m_timeStamp = when;
1214 event.SetEventObject(focus);
1215 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1216 if ( handled && event.GetSkipped() )
1217 handled = false ;
1218 if ( !handled )
1219 {
1220#if wxUSE_ACCEL
1221 if (!handled)
1222 {
1223 wxWindow *ancestor = focus;
1224 while (ancestor)
1225 {
1226 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1227 if (command != -1)
1228 {
1229 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1230 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1231 break;
1232 }
1233 if (ancestor->IsTopLevel())
1234 break;
1235 ancestor = ancestor->GetParent();
1236 }
1237 }
1238#endif // wxUSE_ACCEL
1239 }
1240 if (!handled)
1241 {
1242 event.Skip( FALSE ) ;
1243 event.SetEventType( wxEVT_CHAR ) ;
1244 // raw value again
1245 event.m_keyCode = realkeyval ;
1246
1247 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1248 if ( handled && event.GetSkipped() )
1249 handled = false ;
1250 }
1251 if ( !handled && (keyval == WXK_TAB) )
1252 {
1253 wxWindow* iter = focus->GetParent() ;
1254 while( iter && !handled )
1255 {
1256 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1257 {
1258 wxNavigationKeyEvent new_event;
1259 new_event.SetEventObject( focus );
1260 new_event.SetDirection( !event.ShiftDown() );
1261 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1262 new_event.SetWindowChange( event.ControlDown() );
1263 new_event.SetCurrentFocus( focus );
1264 handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1265 if ( handled && new_event.GetSkipped() )
1266 handled = false ;
1267 }
1268 iter = iter->GetParent() ;
1269 }
1270 }
1271 // backdoor handler for default return and command escape
1272 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1273 {
1274 // if window is not having a focus still testing for default enter or cancel
1275 // TODO add the UMA version for ActiveNonFloatingWindow
1276 wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1277 if ( focus )
1278 {
1279 if ( keyval == WXK_RETURN )
1280 {
1281 wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1282 wxButton);
1283 if ( def && def->IsEnabled() )
1284 {
1285 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1286 event.SetEventObject(def);
1287 def->Command(event);
1288 return true ;
1289 }
1290 }
1291 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1292 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1293 {
1294 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1295 new_event.SetEventObject( focus );
1296 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1297 }
1298 }
1299 }
1300 return handled ;
1301}
1302
1303bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1304{
1305 if ( !focus )
1306 return false ;
1307
1308 short keycode ;
1309 short keychar ;
1310 keychar = short(keymessage & charCodeMask);
1311 keycode = short(keymessage & keyCodeMask) >> 8 ;
1312 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1313 {
1314 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1315 // and look at the character after
1316 UInt32 state = 0;
1317 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1318 keychar = short(keyInfo & charCodeMask);
1319 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1320 }
1321 long keyval = wxMacTranslateKey(keychar, keycode) ;
1322
1323 if ( keyval == keychar )
1324 {
1325 keyval = wxToupper( keyval ) ;
1326 }
1327 bool handled = false ;
1328
1329 wxKeyEvent event(wxEVT_KEY_UP);
1330 event.m_shiftDown = modifiers & shiftKey;
1331 event.m_controlDown = modifiers & controlKey;
1332 event.m_altDown = modifiers & optionKey;
1333 event.m_metaDown = modifiers & cmdKey;
1334 event.m_keyCode = keyval ;
1335
1336 event.m_x = wherex;
1337 event.m_y = wherey;
1338 event.m_timeStamp = when;
1339 event.SetEventObject(focus);
1340 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1341
1342 return handled ;
1343}
wxWidgets (Impactor)