]> 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
scaling for 24x24 and 64x64 sizes
[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 wxToolTip::RemoveToolTips() ;
721
722 // One last chance for pending objects to be cleaned up
723 wxTheApp->DeletePendingObjects();
724
725 wxMacDestroyNotifierTable() ;
726
727#ifndef __DARWIN__
728# if __option(profile)
729 ProfilerDump( (StringPtr)"\papp.prof" ) ;
730 ProfilerTerm() ;
731# endif
732#endif
733
734 UMACleanupToolbox() ;
735 if (s_macCursorRgn) {
736 ::DisposeRgn((RgnHandle)s_macCursorRgn);
737 }
738
739 #if 0
740 TerminateAE() ;
741 #endif
742
743 wxAppBase::CleanUp();
744}
745
746//----------------------------------------------------------------------
747// misc initialization stuff
748//----------------------------------------------------------------------
749
750#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)
751
752// for shared libraries we have to manually get the correct resource
753// ref num upon initializing and releasing when terminating, therefore
754// the __wxinitialize and __wxterminate must be used
755
756extern "C" {
757 void __sinit(void); /* (generated by linker) */
758 pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
759 pascal void __terminate(void);
760}
761
762pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
763{
764 return __initialize( theInitBlock ) ;
765}
766
767pascal void __wxterminate(void)
768{
769 __terminate() ;
770}
771
772#endif /* WXMAKINGDLL_CORE && !__DARWIN__ */
773
774bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
775{
776 bool converted = ConvertEventRefToEventRecord( event,rec) ;
777 OSStatus err = noErr ;
778 if ( !converted )
779 {
780 switch( GetEventClass( event ) )
781 {
782 case kEventClassKeyboard :
783 {
784 converted = true ;
785 switch( GetEventKind(event) )
786 {
787 case kEventRawKeyDown :
788 rec->what = keyDown ;
789 break ;
790 case kEventRawKeyRepeat :
791 rec->what = autoKey ;
792 break ;
793 case kEventRawKeyUp :
794 rec->what = keyUp ;
795 break ;
796 case kEventRawKeyModifiersChanged :
797 rec->what = nullEvent ;
798 break ;
799 default :
800 converted = false ;
801 break ;
802 }
803 if ( converted )
804 {
805 UInt32 keyCode ;
806 unsigned char charCode ;
807 UInt32 modifiers ;
808 GetMouse( &rec->where) ;
809
810 err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
811 err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
812 err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
813 rec->modifiers = modifiers ;
814 rec->message = (keyCode << 8 ) + charCode ;
815 }
816 }
817 break ;
818 case kEventClassTextInput :
819 {
820 switch( GetEventKind( event ) )
821 {
822 case kEventTextInputUnicodeForKeyEvent :
823 {
824 EventRef rawEvent ;
825 err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
826 converted = true ;
827 {
828 UInt32 keyCode ;
829 unsigned char charCode ;
830 UInt32 modifiers ;
831 GetMouse( &rec->where) ;
832 rec->what = keyDown ;
833 err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
834 err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
835 err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
836 rec->modifiers = modifiers ;
837 rec->message = (keyCode << 8 ) + charCode ;
838 }
839 }
840 break ;
841 default :
842 break ;
843 }
844 }
845 break ;
846 }
847 }
848
849 return converted ;
850}
851
852wxApp::wxApp()
853{
854 m_printMode = wxPRINT_WINDOWS;
855
856 m_macCurrentEvent = NULL ;
857 m_macCurrentEventHandlerCallRef = NULL ;
858}
859
860int wxApp::MainLoop()
861{
862 m_keepGoing = TRUE;
863#if wxMAC_USE_RAEL
864 RunApplicationEventLoop() ;
865#else
866 while (m_keepGoing)
867 {
868 MacDoOneEvent() ;
869 }
870#endif
871 return 0;
872}
873
874void wxApp::ExitMainLoop()
875{
876 m_keepGoing = FALSE;
877#if wxMAC_USE_RAEL
878 QuitApplicationEventLoop() ;
879#endif
880}
881
882// Is a message/event pending?
883bool wxApp::Pending()
884{
885 // without the receive event (with pull param = false ) nothing is ever reported
886 EventRef theEvent;
887 ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &theEvent);
888 return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
889}
890
891// Dispatch a message.
892bool wxApp::Dispatch()
893{
894 MacDoOneEvent() ;
895
896 return true;
897}
898
899void wxApp::OnIdle(wxIdleEvent& event)
900{
901 wxAppBase::OnIdle(event);
902
903 // If they are pending events, we must process them: pending events are
904 // either events to the threads other than main or events posted with
905 // wxPostEvent() functions
906 wxMacProcessNotifierAndPendingEvents();
907
908 if(!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
909 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
910}
911
912void wxApp::WakeUpIdle()
913{
914 wxMacWakeUp() ;
915}
916
917void wxApp::Exit()
918{
919 wxApp::CleanUp();
920 ::ExitToShell() ;
921}
922
923void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
924{
925 if (GetTopWindow())
926 GetTopWindow()->Close(TRUE);
927}
928
929// Default behaviour: close the application with prompts. The
930// user can veto the close, and therefore the end session.
931void wxApp::OnQueryEndSession(wxCloseEvent& event)
932{
933 if (GetTopWindow())
934 {
935 if (!GetTopWindow()->Close(!event.CanVeto()))
936 event.Veto(TRUE);
937 }
938}
939
940extern "C" void wxCYield() ;
941void wxCYield()
942{
943 wxYield() ;
944}
945
946// Yield to other processes
947
948bool wxApp::Yield(bool onlyIfNeeded)
949{
950 if (s_inYield)
951 {
952 if ( !onlyIfNeeded )
953 {
954 wxFAIL_MSG( wxT("wxYield called recursively" ) );
955 }
956
957 return FALSE;
958 }
959
960 s_inYield = TRUE;
961
962 // by definition yield should handle all non-processed events
963
964 EventRef theEvent;
965
966 OSStatus status = noErr ;
967 do
968 {
969 s_inReceiveEvent = true ;
970 status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
971 s_inReceiveEvent = false ;
972
973 if ( status == eventLoopTimedOutErr )
974 {
975 // make sure next time the event loop will trigger idle events
976 sleepTime = kEventDurationNoWait ;
977 }
978 else if ( status == eventLoopQuitErr )
979 {
980 // according to QA1061 this may also occur when a WakeUp Process
981 // is executed
982 }
983 else
984 {
985 MacHandleOneEvent( theEvent ) ;
986 ReleaseEvent(theEvent);
987 }
988 } while( status == noErr ) ;
989
990 wxMacProcessNotifierAndPendingEvents() ;
991 s_inYield = FALSE;
992
993 return TRUE;
994}
995
996void wxApp::MacDoOneEvent()
997{
998 EventRef theEvent;
999
1000 s_inReceiveEvent = true ;
1001 OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
1002 s_inReceiveEvent = false ;
1003 if ( status == eventLoopTimedOutErr )
1004 {
1005 if ( wxTheApp->ProcessIdle() )
1006 sleepTime = kEventDurationNoWait ;
1007 else
1008 sleepTime = kEventDurationSecond;
1009 }
1010 else if ( status == eventLoopQuitErr )
1011 {
1012 // according to QA1061 this may also occur when a WakeUp Process
1013 // is executed
1014 }
1015 else
1016 {
1017 MacHandleOneEvent( theEvent ) ;
1018 ReleaseEvent(theEvent);
1019 sleepTime = kEventDurationNoWait ;
1020 }
1021 // repeaters
1022
1023 DeletePendingObjects() ;
1024 wxMacProcessNotifierAndPendingEvents() ;
1025}
1026
1027/*virtual*/ void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
1028{
1029 // Override to process unhandled events as you please
1030}
1031
1032void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1033{
1034 EventTargetRef theTarget;
1035 theTarget = GetEventDispatcherTarget();
1036 m_macCurrentEvent = evr ;
1037 OSStatus status = SendEventToEventTarget ((EventRef) evr , theTarget);
1038 if(status == eventNotHandledErr)
1039 {
1040 MacHandleUnhandledEvent(evr);
1041 }
1042 wxMacProcessNotifierAndPendingEvents() ;
1043#if wxUSE_THREADS
1044 wxMutexGuiLeaveOrEnter();
1045#endif // wxUSE_THREADS
1046}
1047
1048long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1049long wxMacTranslateKey(unsigned char key, unsigned char code)
1050{
1051 long retval = key ;
1052 switch (key)
1053 {
1054 case kHomeCharCode :
1055 retval = WXK_HOME;
1056 break;
1057 case kEnterCharCode :
1058 retval = WXK_RETURN;
1059 break;
1060 case kEndCharCode :
1061 retval = WXK_END;
1062 break;
1063 case kHelpCharCode :
1064 retval = WXK_HELP;
1065 break;
1066 case kBackspaceCharCode :
1067 retval = WXK_BACK;
1068 break;
1069 case kTabCharCode :
1070 retval = WXK_TAB;
1071 break;
1072 case kPageUpCharCode :
1073 retval = WXK_PAGEUP;
1074 break;
1075 case kPageDownCharCode :
1076 retval = WXK_PAGEDOWN;
1077 break;
1078 case kReturnCharCode :
1079 retval = WXK_RETURN;
1080 break;
1081 case kFunctionKeyCharCode :
1082 {
1083 switch( code )
1084 {
1085 case 0x7a :
1086 retval = WXK_F1 ;
1087 break;
1088 case 0x78 :
1089 retval = WXK_F2 ;
1090 break;
1091 case 0x63 :
1092 retval = WXK_F3 ;
1093 break;
1094 case 0x76 :
1095 retval = WXK_F4 ;
1096 break;
1097 case 0x60 :
1098 retval = WXK_F5 ;
1099 break;
1100 case 0x61 :
1101 retval = WXK_F6 ;
1102 break;
1103 case 0x62:
1104 retval = WXK_F7 ;
1105 break;
1106 case 0x64 :
1107 retval = WXK_F8 ;
1108 break;
1109 case 0x65 :
1110 retval = WXK_F9 ;
1111 break;
1112 case 0x6D :
1113 retval = WXK_F10 ;
1114 break;
1115 case 0x67 :
1116 retval = WXK_F11 ;
1117 break;
1118 case 0x6F :
1119 retval = WXK_F12 ;
1120 break;
1121 case 0x69 :
1122 retval = WXK_F13 ;
1123 break;
1124 case 0x6B :
1125 retval = WXK_F14 ;
1126 break;
1127 case 0x71 :
1128 retval = WXK_F15 ;
1129 break;
1130 }
1131 }
1132 break ;
1133 case kEscapeCharCode :
1134 retval = WXK_ESCAPE ;
1135 break ;
1136 case kLeftArrowCharCode :
1137 retval = WXK_LEFT ;
1138 break ;
1139 case kRightArrowCharCode :
1140 retval = WXK_RIGHT ;
1141 break ;
1142 case kUpArrowCharCode :
1143 retval = WXK_UP ;
1144 break ;
1145 case kDownArrowCharCode :
1146 retval = WXK_DOWN ;
1147 break ;
1148 case kDeleteCharCode :
1149 retval = WXK_DELETE ;
1150 default:
1151 break ;
1152 } // end switch
1153
1154 return retval;
1155}
1156
1157int wxMacKeyCodeToModifier(wxKeyCode key)
1158{
1159 switch (key)
1160 {
1161 case WXK_START:
1162 case WXK_MENU:
1163 return cmdKey;
1164
1165 case WXK_SHIFT:
1166 return shiftKey;
1167
1168 case WXK_CAPITAL:
1169 return alphaLock;
1170
1171 case WXK_ALT:
1172 return optionKey;
1173
1174 case WXK_CONTROL:
1175 return controlKey;
1176
1177 default:
1178 return 0;
1179 }
1180}
1181
1182#ifndef __DARWIN__
1183bool wxGetKeyState(wxKeyCode key) //virtual key code if < 10.2.x, else see below
1184{
1185//if OS X > 10.2 (i.e. 10.2.x)
1186//a known apple bug prevents the system from determining led
1187//states with GetKeys... can only determine caps lock led
1188 return !!(GetCurrentKeyModifiers() & wxMacKeyCodeToModifier(key));
1189//else
1190// KeyMapByteArray keymap;
1191// GetKeys((BigEndianLong*)keymap);
1192// return !!(BitTst(keymap, (sizeof(KeyMapByteArray)*8) - iKey));
1193}
1194#endif
1195
1196
1197bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1198{
1199 if ( !focus )
1200 return false ;
1201
1202 short keycode ;
1203 short keychar ;
1204 keychar = short(keymessage & charCodeMask);
1205 keycode = short(keymessage & keyCodeMask) >> 8 ;
1206
1207 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1208 {
1209 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1210 // and look at the character after
1211 UInt32 state = 0;
1212 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1213 keychar = short(keyInfo & charCodeMask);
1214 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1215 }
1216 long keyval = wxMacTranslateKey(keychar, keycode) ;
1217 long realkeyval = keyval ;
1218 if ( keyval == keychar )
1219 {
1220 // 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)
1221 realkeyval = short(keymessage & charCodeMask) ;
1222 keyval = wxToupper( keyval ) ;
1223 }
1224
1225 wxKeyEvent event(wxEVT_KEY_DOWN);
1226 bool handled = false ;
1227 event.m_shiftDown = modifiers & shiftKey;
1228 event.m_controlDown = modifiers & controlKey;
1229 event.m_altDown = modifiers & optionKey;
1230 event.m_metaDown = modifiers & cmdKey;
1231 event.m_keyCode = keyval ;
1232
1233 event.m_x = wherex;
1234 event.m_y = wherey;
1235 event.SetTimestamp(when);
1236 event.SetEventObject(focus);
1237 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1238 if ( handled && event.GetSkipped() )
1239 handled = false ;
1240 if ( !handled )
1241 {
1242#if wxUSE_ACCEL
1243 if (!handled)
1244 {
1245 wxWindow *ancestor = focus;
1246 while (ancestor)
1247 {
1248 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1249 if (command != -1)
1250 {
1251 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1252 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1253 break;
1254 }
1255 if (ancestor->IsTopLevel())
1256 break;
1257 ancestor = ancestor->GetParent();
1258 }
1259 }
1260#endif // wxUSE_ACCEL
1261 }
1262 if (!handled)
1263 {
1264 wxTopLevelWindowMac *tlw = focus->MacGetTopLevelWindow() ;
1265
1266 if (tlw)
1267 {
1268 event.Skip( FALSE ) ;
1269 event.SetEventType( wxEVT_CHAR_HOOK );
1270 // raw value again
1271 event.m_keyCode = realkeyval ;
1272
1273 handled = tlw->GetEventHandler()->ProcessEvent( event );
1274 if ( handled && event.GetSkipped() )
1275 handled = false ;
1276 }
1277 }
1278
1279 if ( !handled )
1280 {
1281 event.Skip( FALSE ) ;
1282 event.SetEventType( wxEVT_CHAR ) ;
1283 // raw value again
1284 event.m_keyCode = realkeyval ;
1285
1286 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1287 if ( handled && event.GetSkipped() )
1288 handled = false ;
1289 }
1290 if ( !handled && (keyval == WXK_TAB) )
1291 {
1292 wxWindow* iter = focus->GetParent() ;
1293 while( iter && !handled )
1294 {
1295 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1296 {
1297 wxNavigationKeyEvent new_event;
1298 new_event.SetEventObject( focus );
1299 new_event.SetDirection( !event.ShiftDown() );
1300 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1301 new_event.SetWindowChange( event.ControlDown() );
1302 new_event.SetCurrentFocus( focus );
1303 handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1304 if ( handled && new_event.GetSkipped() )
1305 handled = false ;
1306 }
1307 iter = iter->GetParent() ;
1308 }
1309 }
1310 // backdoor handler for default return and command escape
1311 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1312 {
1313 // if window is not having a focus still testing for default enter or cancel
1314 // TODO add the UMA version for ActiveNonFloatingWindow
1315 wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1316 if ( focus )
1317 {
1318 if ( keyval == WXK_RETURN )
1319 {
1320 wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1321 wxButton);
1322 if ( def && def->IsEnabled() )
1323 {
1324 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1325 event.SetEventObject(def);
1326 def->Command(event);
1327 return true ;
1328 }
1329 }
1330 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1331 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1332 {
1333 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1334 new_event.SetEventObject( focus );
1335 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1336 }
1337 }
1338 }
1339 return handled ;
1340}
1341
1342bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1343{
1344 if ( !focus )
1345 return false ;
1346
1347 short keycode ;
1348 short keychar ;
1349 keychar = short(keymessage & charCodeMask);
1350 keycode = short(keymessage & keyCodeMask) >> 8 ;
1351 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1352 {
1353 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1354 // and look at the character after
1355 UInt32 state = 0;
1356 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1357 keychar = short(keyInfo & charCodeMask);
1358 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1359 }
1360 long keyval = wxMacTranslateKey(keychar, keycode) ;
1361
1362 if ( keyval == keychar )
1363 {
1364 keyval = wxToupper( keyval ) ;
1365 }
1366 bool handled = false ;
1367
1368 wxKeyEvent event(wxEVT_KEY_UP);
1369 event.m_shiftDown = modifiers & shiftKey;
1370 event.m_controlDown = modifiers & controlKey;
1371 event.m_altDown = modifiers & optionKey;
1372 event.m_metaDown = modifiers & cmdKey;
1373 event.m_keyCode = keyval ;
1374
1375 event.m_x = wherex;
1376 event.m_y = wherey;
1377 event.SetTimestamp(when);
1378 event.SetEventObject(focus);
1379 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1380
1381 return handled ;
1382}
wxWidgets (Impactor)