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