1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Stefan Csomor
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "app.h"
18 #include "wx/window.h"
20 #include "wx/button.h"
23 #include "wx/gdicmn.h"
26 #include "wx/cursor.h"
29 #include "wx/palette.h"
31 #include "wx/dialog.h"
32 #include "wx/msgdlg.h"
34 #include "wx/module.h"
35 #include "wx/memory.h"
36 #include "wx/tooltip.h"
37 #include "wx/textctrl.h"
39 #include "wx/docview.h"
53 #include "wx/mac/uma.h"
54 #include "wx/mac/macnotfy.h"
57 # include <CoreServices/CoreServices.h>
58 # if defined(WXMAKINGDLL)
59 # include <mach-o/dyld.h>
64 # include <ToolUtils.h>
65 # include <DiskInit.h>
69 extern wxList wxPendingDelete
;
70 extern wxList
*wxWinMacWindowList
;
71 extern wxList
*wxWinMacControlList
;
73 // statics for implementation
75 static bool s_inYield
= FALSE
;
76 static bool s_inOnIdle
= FALSE
;
79 static bool s_inReceiveEvent
= FALSE
;
80 static EventTime sleepTime
= kEventDurationNoWait
;
82 static long sleepTime
= 0 ;
85 #if !USE_SHARED_LIBRARY
86 IMPLEMENT_DYNAMIC_CLASS(wxApp
, wxEvtHandler
)
87 BEGIN_EVENT_TABLE(wxApp
, wxEvtHandler
)
88 EVT_IDLE(wxApp::OnIdle
)
89 EVT_END_SESSION(wxApp::OnEndSession
)
90 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession
)
95 const short kMacMinHeap
= (29 * 1024) ;
96 // platform specific static variables
98 const short kwxMacMenuBarResource
= 1 ;
99 const short kwxMacAppleMenuId
= 1 ;
101 WXHRGN
wxApp::s_macCursorRgn
= NULL
;
102 wxWindow
* wxApp::s_captureWindow
= NULL
;
103 int wxApp::s_lastMouseDown
= 0 ;
104 long wxApp::sm_lastMessageTime
= 0;
105 long wxApp::s_lastModifiers
= 0 ;
108 bool wxApp::s_macDefaultEncodingIsPC
= true ;
109 bool wxApp::s_macSupportPCMenuShortcuts
= true ;
110 long wxApp::s_macAboutMenuItemId
= wxID_ABOUT
;
111 long wxApp::s_macPreferencesMenuItemId
= 0 ;
112 long wxApp::s_macExitMenuItemId
= wxID_EXIT
;
113 wxString
wxApp::s_macHelpMenuTitleName
= wxT("&Help") ;
115 //----------------------------------------------------------------------
116 // Core Apple Event Support
117 //----------------------------------------------------------------------
119 pascal OSErr
AEHandleODoc( const AppleEvent
*event
, AppleEvent
*reply
, long refcon
) ;
120 pascal OSErr
AEHandleOApp( const AppleEvent
*event
, AppleEvent
*reply
, long refcon
) ;
121 pascal OSErr
AEHandlePDoc( const AppleEvent
*event
, AppleEvent
*reply
, long refcon
) ;
122 pascal OSErr
AEHandleQuit( const AppleEvent
*event
, AppleEvent
*reply
, long refcon
) ;
124 pascal OSErr
AEHandleODoc( const AppleEvent
*event
, AppleEvent
*reply
, long WXUNUSED(refcon
) )
126 return wxTheApp
->MacHandleAEODoc( (AppleEvent
*) event
, reply
) ;
129 pascal OSErr
AEHandleOApp( const AppleEvent
*event
, AppleEvent
*reply
, long WXUNUSED(refcon
) )
131 return wxTheApp
->MacHandleAEOApp( (AppleEvent
*) event
, reply
) ;
134 pascal OSErr
AEHandlePDoc( const AppleEvent
*event
, AppleEvent
*reply
, long WXUNUSED(refcon
) )
136 return wxTheApp
->MacHandleAEPDoc( (AppleEvent
*) event
, reply
) ;
139 pascal OSErr
AEHandleQuit( const AppleEvent
*event
, AppleEvent
*reply
, long WXUNUSED(refcon
) )
141 return wxTheApp
->MacHandleAEQuit( (AppleEvent
*) event
, reply
) ;
144 // AEODoc Calls MacOpenFile on each of the files passed
146 short wxApp::MacHandleAEODoc(const WXEVENTREF event
, WXEVENTREF
WXUNUSED(reply
))
150 DescType returnedType
;
156 err
= AEGetParamDesc((AppleEvent
*)event
, keyDirectObject
, typeAEList
,&docList
);
160 err
= AECountItems(&docList
, &itemsInList
);
164 ProcessSerialNumber PSN
;
165 PSN
.highLongOfPSN
= 0 ;
166 PSN
.lowLongOfPSN
= kCurrentProcess
;
167 SetFrontProcess( &PSN
) ;
169 for (i
= 1; i
<= itemsInList
; i
++) {
170 AEGetNthPtr(&docList
, i
, typeFSS
, &keywd
, &returnedType
,
171 (Ptr
) & theSpec
, sizeof(theSpec
), &actualSize
);
172 wxString fName
= wxMacFSSpec2MacFilename(&theSpec
);
178 // AEPDoc Calls MacPrintFile on each of the files passed
180 short wxApp::MacHandleAEPDoc(const WXEVENTREF event
, WXEVENTREF
WXUNUSED(reply
))
184 DescType returnedType
;
190 err
= AEGetParamDesc((AppleEvent
*)event
, keyDirectObject
, typeAEList
,&docList
);
194 err
= AECountItems(&docList
, &itemsInList
);
198 ProcessSerialNumber PSN
;
199 PSN
.highLongOfPSN
= 0 ;
200 PSN
.lowLongOfPSN
= kCurrentProcess
;
201 SetFrontProcess( &PSN
) ;
203 for (i
= 1; i
<= itemsInList
; i
++) {
204 AEGetNthPtr(&docList
, i
, typeFSS
, &keywd
, &returnedType
,
205 (Ptr
) & theSpec
, sizeof(theSpec
), &actualSize
);
206 wxString fName
= wxMacFSSpec2MacFilename(&theSpec
);
212 // AEOApp calls MacNewFile
214 short wxApp::MacHandleAEOApp(const WXEVENTREF
WXUNUSED(event
) , WXEVENTREF
WXUNUSED(reply
))
220 // AEQuit attempts to quit the application
222 short wxApp::MacHandleAEQuit(const WXEVENTREF
WXUNUSED(event
) , WXEVENTREF
WXUNUSED(reply
))
224 /* wxWindow* win = GetTopWindow() ;
237 //----------------------------------------------------------------------
238 // Support Routines linking the Mac...File Calls to the Document Manager
239 //----------------------------------------------------------------------
241 void wxApp::MacOpenFile(const wxString
& fileName
)
243 wxDocManager
* dm
= wxDocManager::GetDocumentManager() ;
245 dm
->CreateDocument(fileName
, wxDOC_SILENT
) ;
248 void wxApp::MacPrintFile(const wxString
& fileName
)
250 wxDocManager
* dm
= wxDocManager::GetDocumentManager() ;
253 wxDocument
*doc
= dm
->CreateDocument(fileName
, wxDOC_SILENT
) ;
256 wxView
* view
= doc
->GetFirstView() ;
259 wxPrintout
*printout
= view
->OnCreatePrintout();
263 printer
.Print(view
->GetFrame(), printout
, TRUE
);
269 doc
->DeleteAllViews();
270 dm
->RemoveDocument(doc
) ;
276 void wxApp::MacNewFile()
280 //----------------------------------------------------------------------
281 // Carbon Event Handler
282 //----------------------------------------------------------------------
286 static const EventTypeSpec eventList
[] =
288 { kEventClassCommand
, kEventProcessCommand
} ,
289 { kEventClassCommand
, kEventCommandUpdateStatus
} ,
291 { kEventClassApplication
, kEventAppActivated
} ,
292 { kEventClassApplication
, kEventAppDeactivated
} ,
293 // handling the quit event is not recommended by apple
294 // rather using the quit apple event - which we do
296 { kEventClassAppleEvent
, kEventAppleEvent
} ,
298 { kEventClassMouse
, kEventMouseDown
} ,
302 static pascal OSStatus
MenuEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
304 return eventNotHandledErr
;
307 // due to the rather low-level event API of wxWindows, we cannot use RunApplicationEventLoop
308 // but have to use ReceiveNextEvent dealing with events manually, therefore we also have
309 // deal with clicks in the menu bar explicitely
311 static pascal OSStatus
MouseEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
313 OSStatus result
= eventNotHandledErr
;
315 switch( GetEventKind(event
) )
317 case kEventMouseDown
:
322 GetEventParameter( event
, kEventParamMouseLocation
, typeQDPoint
, NULL
,
323 sizeof( Point
), NULL
, &point
);
324 short windowPart
= ::FindWindow(point
, &window
);
326 if ( windowPart
== inMenuBar
)
328 MenuSelect( point
) ;
338 static pascal OSStatus
CommandEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
340 OSStatus result
= eventNotHandledErr
;
344 GetEventParameter( event
, kEventParamDirectObject
, typeHICommand
, NULL
,
345 sizeof( HICommand
), NULL
, &command
);
347 MenuCommand id
= command
.commandID
;
348 if ( id
== kHICommandPreferences
)
349 id
= wxApp::s_macPreferencesMenuItemId
;
351 wxMenuBar
* mbar
= wxMenuBar::MacGetInstalledMenuBar() ;
352 wxMenu
* menu
= NULL
;
353 wxMenuItem
* item
= NULL
;
356 item
= mbar
->FindItem( id
, &menu
) ;
358 if ( item
== NULL
|| menu
== NULL
|| mbar
== NULL
)
361 switch( GetEventKind( event
) )
363 case kEventProcessCommand
:
365 if (item
->IsCheckable())
367 item
->Check( !item
->IsChecked() ) ;
370 menu
->SendEvent( id
, item
->IsCheckable() ? item
->IsChecked() : -1 ) ;
374 case kEventCommandUpdateStatus
:
375 // eventually trigger an updateui round
385 static pascal OSStatus
ApplicationEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
387 OSStatus result
= eventNotHandledErr
;
388 switch ( GetEventKind( event
) )
390 case kEventAppActivated
:
393 wxTheApp
->MacResume( true ) ;
397 case kEventAppDeactivated
:
400 wxTheApp
->MacSuspend( true ) ;
410 pascal OSStatus
wxAppEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
412 OSStatus result
= eventNotHandledErr
;
413 switch( GetEventClass( event
) )
415 case kEventClassCommand
:
416 result
= CommandEventHandler( handler
, event
, data
) ;
418 case kEventClassApplication
:
419 result
= ApplicationEventHandler( handler
, event
, data
) ;
421 case kEventClassMenu
:
422 result
= MenuEventHandler( handler
, event
, data
) ;
424 case kEventClassMouse
:
425 result
= MouseEventHandler( handler
, event
, data
) ;
427 case kEventClassAppleEvent
:
430 wxMacConvertEventToRecord( event
, &rec
) ;
431 result
= AEProcessAppleEvent( &rec
) ;
441 DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler
)
445 #if defined(WXMAKINGDLL) && !defined(__DARWIN__)
446 // we know it's there ;-)
447 WXIMPORT
char std::__throws_bad_alloc
;
450 bool wxApp::Initialize(int& argc
, wxChar
**argv
)
456 UMAInitToolbox( 4 ) ;
457 SetEventMask( everyEvent
) ;
458 UMAShowWatchCursor() ;
460 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
461 // open shared library resources from here since we don't have
462 // __wxinitialize in Mach-O shared libraries
463 wxStAppResource::OpenSharedLibraryResource(NULL
);
467 // test the minimal configuration necessary
473 if (Gestalt(gestaltMachineType
, &theMachine
) != noErr
)
475 error
= kMacSTRWrongMachine
;
477 else if (theMachine
< gestaltMacPlus
)
479 error
= kMacSTRWrongMachine
;
481 else if (Gestalt(gestaltSystemVersion
, &theSystem
) != noErr
)
483 error
= kMacSTROldSystem
;
485 else if ( theSystem
< 0x0860 )
487 error
= kMacSTROldSystem
;
489 else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap
)
491 error
= kMacSTRSmallSize
;
497 if ( !UMAHasAppearance() )
499 error = kMacSTRNoPre8Yet ;
505 // if we encountered any problems so far, give the error code and exit immediately
509 wxStAppResource resload
;
513 GetIndString(message
, 128, error
);
514 UMAShowArrowCursor() ;
515 ParamText("\pFatal Error", message
, (ConstStr255Param
)"\p", (ConstStr255Param
)"\p");
516 itemHit
= Alert(128, nil
);
521 # if __option(profile)
522 ProfilerInit( collectDetailed
, bestTimeBase
, 20000 , 40 ) ;
527 // now avoid exceptions thrown for new (bad_alloc)
528 // FIXME CS for some changes outside wxMac does not compile anymore
530 std::__throws_bad_alloc
= 0 ;
534 wxMacSetupConverters() ;
536 s_macCursorRgn
= ::NewRgn() ;
538 // Mac OS X passes a process serial number command line argument when
539 // the application is launched from the Finder. This argument must be
540 // removed from the command line arguments before being handled by the
541 // application (otherwise applications would need to handle it)
544 static const wxChar
*ARG_PSN
= _T("-psn_");
545 if ( wxStrncmp(argv
[1], ARG_PSN
, sizeof(ARG_PSN
) - 1) == 0 )
547 // remove this argument
548 memmove(argv
, argv
+ 1, argc
--);
552 if ( !wxAppBase::Initialize(argc
, argv
) )
555 wxWinMacWindowList
= new wxList(wxKEY_INTEGER
);
556 wxWinMacControlList
= new wxList(wxKEY_INTEGER
);
558 wxMacCreateNotifierTable() ;
560 UMAShowArrowCursor() ;
565 bool wxApp::OnInitGui()
567 if( !wxAppBase::OnInitGui() )
571 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
573 InstallApplicationEventHandler(
574 GetwxAppEventHandlerUPP(),
575 GetEventTypeCount(eventList
), eventList
, wxTheApp
, (EventHandlerRef
*)&(wxTheApp
->m_macEventHandler
));
578 #if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
579 AEInstallEventHandler( kCoreEventClass
, kAEOpenDocuments
,
580 NewAEEventHandlerUPP(AEHandleODoc
) ,
582 AEInstallEventHandler( kCoreEventClass
, kAEOpenApplication
,
583 NewAEEventHandlerUPP(AEHandleOApp
) ,
585 AEInstallEventHandler( kCoreEventClass
, kAEPrintDocuments
,
586 NewAEEventHandlerUPP(AEHandlePDoc
) ,
588 AEInstallEventHandler( kCoreEventClass
, kAEQuitApplication
,
589 NewAEEventHandlerUPP(AEHandleQuit
) ,
592 AEInstallEventHandler( kCoreEventClass
, kAEOpenDocuments
,
593 NewAEEventHandlerProc(AEHandleODoc
) ,
595 AEInstallEventHandler( kCoreEventClass
, kAEOpenApplication
,
596 NewAEEventHandlerProc(AEHandleOApp
) ,
598 AEInstallEventHandler( kCoreEventClass
, kAEPrintDocuments
,
599 NewAEEventHandlerProc(AEHandlePDoc
) ,
601 AEInstallEventHandler( kCoreEventClass
, kAEQuitApplication
,
602 NewAEEventHandlerProc(AEHandleQuit
) ,
609 void wxApp::CleanUp()
611 wxToolTip::RemoveToolTips() ;
613 // One last chance for pending objects to be cleaned up
614 wxTheApp
->DeletePendingObjects();
616 wxMacDestroyNotifierTable() ;
618 delete wxWinMacWindowList
;
619 wxWinMacWindowList
= NULL
;
621 delete wxWinMacControlList
;
622 wxWinMacControlList
= NULL
;
625 # if __option(profile)
626 ProfilerDump( (StringPtr
)"\papp.prof" ) ;
631 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
632 // close shared library resources from here since we don't have
633 // __wxterminate in Mach-O shared libraries
634 wxStAppResource::CloseSharedLibraryResource();
636 wxMacCleanupConverters() ;
638 UMACleanupToolbox() ;
639 if (s_macCursorRgn
) {
640 ::DisposeRgn((RgnHandle
)s_macCursorRgn
);
647 wxAppBase::CleanUp();
650 //----------------------------------------------------------------------
651 // misc initialization stuff
652 //----------------------------------------------------------------------
654 // extern variable for shared library resource id
655 // need to be able to find it with NSLookupAndBindSymbol
656 short gSharedLibraryResource
= kResFileNotOpened
;
658 #if defined(WXMAKINGDLL) && defined(__DARWIN__)
659 CFBundleRef gSharedLibraryBundle
= NULL
;
660 #endif /* WXMAKINGDLL && __DARWIN__ */
662 wxStAppResource::wxStAppResource()
664 m_currentRefNum
= CurResFile() ;
665 if ( gSharedLibraryResource
!= kResFileNotOpened
)
667 UseResFile( gSharedLibraryResource
) ;
671 wxStAppResource::~wxStAppResource()
673 if ( m_currentRefNum
!= kResFileNotOpened
)
675 UseResFile( m_currentRefNum
) ;
679 void wxStAppResource::OpenSharedLibraryResource(const void *initBlock
)
681 gSharedLibraryResource
= kResFileNotOpened
;
684 if ( initBlock
!= NULL
) {
685 const CFragInitBlock
*theInitBlock
= (const CFragInitBlock
*)initBlock
;
686 FSSpec
*fileSpec
= NULL
;
688 if (theInitBlock
->fragLocator
.where
== kDataForkCFragLocator
) {
689 fileSpec
= theInitBlock
->fragLocator
.u
.onDisk
.fileSpec
;
691 else if (theInitBlock
->fragLocator
.where
== kResourceCFragLocator
) {
692 fileSpec
= theInitBlock
->fragLocator
.u
.inSegs
.fileSpec
;
695 if (fileSpec
!= NULL
) {
696 gSharedLibraryResource
= FSpOpenResFile(fileSpec
, fsRdPerm
);
701 // Open the shared library resource file if it is not yet open
704 const char *theLibPath
;
706 gSharedLibraryBundle
= CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
707 if (gSharedLibraryBundle
!= NULL
) {
708 // wxWindows has been bundled into a framework
709 // load the framework resources
711 gSharedLibraryResource
= CFBundleOpenBundleResourceMap(gSharedLibraryBundle
);
714 // wxWindows is a simple dynamic shared library
715 // load the resources from the data fork of a separate resource file
720 OSErr theErr
= noErr
;
722 // get the library path
723 theSymbol
= NSLookupAndBindSymbol("_gSharedLibraryResource");
724 theModule
= NSModuleForSymbol(theSymbol
);
725 theLibPath
= NSLibraryNameForModule(theModule
);
727 // if we call wxLogDebug from here then, as wxTheApp hasn't been
728 // created yet when we're called from wxApp::Initialize(), wxLog
729 // is going to create a default stderr-based log target instead of
730 // the expected normal GUI one -- don't do it, if we really want
731 // to see this message just use fprintf() here
733 wxLogDebug( wxT("wxMac library installation name is '%s'"),
737 // allocate copy to replace .dylib.* extension with .rsrc
738 theResPath
= strdup(theLibPath
);
739 if (theResPath
!= NULL
) {
740 theName
= strrchr(theResPath
, '/');
741 if (theName
== NULL
) {
742 // no directory elements in path
743 theName
= theResPath
;
745 // find ".dylib" shared library extension
746 theExt
= strstr(theName
, ".dylib");
747 // overwrite extension with ".rsrc"
748 strcpy(theExt
, ".rsrc");
751 wxLogDebug( wxT("wxMac resources file name is '%s'"),
755 theErr
= FSPathMakeRef((UInt8
*) theResPath
, &theResRef
, false);
756 if (theErr
!= noErr
) {
757 // try in current directory (using name only)
758 theErr
= FSPathMakeRef((UInt8
*) theName
, &theResRef
, false);
761 // open the resource file
762 if (theErr
== noErr
) {
763 theErr
= FSOpenResourceFile( &theResRef
, 0, NULL
, fsRdPerm
,
764 &gSharedLibraryResource
);
766 if (theErr
!= noErr
) {
769 wxT("unable to open wxMac resource file '%s'\n"),
771 #endif // __WXDEBUG__
774 // free duplicated resource file path
778 #endif /* __DARWIN__ */
780 #endif /* WXMAKINGDLL */
783 void wxStAppResource::CloseSharedLibraryResource()
786 // Close the shared library resource file
787 if (gSharedLibraryResource
!= kResFileNotOpened
) {
789 if (gSharedLibraryBundle
!= NULL
) {
790 CFBundleCloseBundleResourceMap(gSharedLibraryBundle
,
791 gSharedLibraryResource
);
792 gSharedLibraryBundle
= NULL
;
795 #endif /* __DARWIN__ */
797 CloseResFile(gSharedLibraryResource
);
799 gSharedLibraryResource
= kResFileNotOpened
;
801 #endif /* WXMAKINGDLL */
804 #if defined(WXMAKINGDLL) && !defined(__DARWIN__)
806 // for shared libraries we have to manually get the correct resource
807 // ref num upon initializing and releasing when terminating, therefore
808 // the __wxinitialize and __wxterminate must be used
811 void __sinit(void); /* (generated by linker) */
812 pascal OSErr
__initialize(const CFragInitBlock
*theInitBlock
);
813 pascal void __terminate(void);
816 pascal OSErr
__wxinitialize(const CFragInitBlock
*theInitBlock
)
818 wxStAppResource::OpenSharedLibraryResource( theInitBlock
) ;
819 return __initialize( theInitBlock
) ;
822 pascal void __wxterminate(void)
824 wxStAppResource::CloseSharedLibraryResource() ;
828 #endif /* WXMAKINGDLL && !__DARWIN__ */
832 bool wxMacConvertEventToRecord( EventRef event
, EventRecord
*rec
)
834 bool converted
= ConvertEventRefToEventRecord( event
,rec
) ;
835 OSStatus err
= noErr
;
838 switch( GetEventClass( event
) )
840 case kEventClassKeyboard
:
843 switch( GetEventKind(event
) )
845 case kEventRawKeyDown
:
846 rec
->what
= keyDown
;
848 case kEventRawKeyRepeat
:
849 rec
->what
= autoKey
;
851 case kEventRawKeyUp
:
854 case kEventRawKeyModifiersChanged
:
855 rec
->what
= nullEvent
;
864 unsigned char charCode
;
866 GetMouse( &rec
->where
) ;
868 err
= GetEventParameter(event
, kEventParamKeyModifiers
, typeUInt32
, NULL
, 4, NULL
, &modifiers
);
869 err
= GetEventParameter(event
, kEventParamKeyCode
, typeUInt32
, NULL
, 4, NULL
, &keyCode
);
870 err
= GetEventParameter(event
, kEventParamKeyMacCharCodes
, typeChar
, NULL
, 1, NULL
, &charCode
);
871 rec
->modifiers
= modifiers
;
872 rec
->message
= (keyCode
<< 8 ) + charCode
;
876 case kEventClassTextInput
:
878 switch( GetEventKind( event
) )
880 case kEventTextInputUnicodeForKeyEvent
:
883 err
= GetEventParameter( event
, kEventParamTextInputSendKeyboardEvent
,typeEventRef
,NULL
,sizeof(rawEvent
),NULL
,&rawEvent
) ;
887 unsigned char charCode
;
889 GetMouse( &rec
->where
) ;
890 rec
->what
= keyDown
;
891 err
= GetEventParameter(rawEvent
, kEventParamKeyModifiers
, typeUInt32
, NULL
, 4, NULL
, &modifiers
);
892 err
= GetEventParameter(rawEvent
, kEventParamKeyCode
, typeUInt32
, NULL
, 4, NULL
, &keyCode
);
893 err
= GetEventParameter(rawEvent
, kEventParamKeyMacCharCodes
, typeChar
, NULL
, 1, NULL
, &charCode
);
894 rec
->modifiers
= modifiers
;
895 rec
->message
= (keyCode
<< 8 ) + charCode
;
911 pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
913 OSStatus result = eventNotHandledErr ;
916 switch ( GetEventClass( event ) )
918 case kEventClassKeyboard :
919 if ( wxMacConvertEventToRecord( event , &rec ) )
921 wxTheApp->MacHandleModifierEvents( &rec ) ;
922 wxTheApp->MacHandleOneEvent( &rec ) ;
926 case kEventClassTextInput :
927 if ( wxMacConvertEventToRecord( event , &rec ) )
929 wxTheApp->MacHandleModifierEvents( &rec ) ;
930 wxTheApp->MacHandleOneEvent( &rec ) ;
950 m_printMode
= wxPRINT_WINDOWS
;
954 bool wxApp::Initialized()
962 int wxApp::MainLoop()
974 // Returns TRUE if more time is needed.
975 bool wxApp::ProcessIdle()
978 event
.SetEventObject(this);
981 wxUpdateUIEvent::ResetUpdateTime();
983 return event
.MoreRequested();
986 void wxApp::ExitMainLoop()
991 // Is a message/event pending?
992 bool wxApp::Pending()
995 return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
999 return EventAvail( everyEvent
, &event
) ;
1003 // Dispatch a message.
1004 void wxApp::Dispatch()
1009 void wxApp::OnIdle(wxIdleEvent
& event
)
1011 // Avoid recursion (via ProcessEvent default case)
1018 // 'Garbage' collection of windows deleted with Close().
1019 DeletePendingObjects();
1021 // flush the logged messages if any
1022 wxLog
*pLog
= wxLog::GetActiveTarget();
1023 if ( pLog
!= NULL
&& pLog
->HasPendingMessages() )
1026 // Send OnIdle events to all windows
1027 bool needMore
= SendIdleEvents();
1030 event
.RequestMore(TRUE
);
1032 // If they are pending events, we must process them: pending events are
1033 // either events to the threads other than main or events posted with
1034 // wxPostEvent() functions
1035 wxMacProcessNotifierAndPendingEvents();
1038 if(!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1039 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1042 void wxApp::WakeUpIdle()
1047 // Send idle event to all top-level windows
1048 bool wxApp::SendIdleEvents()
1050 bool needMore
= FALSE
;
1051 wxWindowListNode
* node
= wxTopLevelWindows
.GetFirst();
1054 wxWindow
* win
= node
->GetData();
1055 if (SendIdleEvents(win
))
1058 node
= node
->GetNext();
1063 // Send idle event to window and all subwindows
1064 bool wxApp::SendIdleEvents(wxWindow
* win
)
1066 bool needMore
= FALSE
;
1069 event
.SetEventObject(win
);
1070 win
->ProcessEvent(event
);
1072 if (event
.MoreRequested())
1075 wxWindowListNode
* node
= win
->GetChildren().GetFirst();
1078 wxWindow
* win
= node
->GetData();
1079 if (SendIdleEvents(win
))
1082 node
= node
->GetNext();
1093 void wxApp::OnEndSession(wxCloseEvent
& WXUNUSED(event
))
1096 GetTopWindow()->Close(TRUE
);
1099 // Default behaviour: close the application with prompts. The
1100 // user can veto the close, and therefore the end session.
1101 void wxApp::OnQueryEndSession(wxCloseEvent
& event
)
1105 if (!GetTopWindow()->Close(!event
.CanVeto()))
1110 extern "C" void wxCYield() ;
1116 // Yield to other processes
1118 bool wxApp::Yield(bool onlyIfNeeded
)
1122 if ( !onlyIfNeeded
)
1124 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1133 YieldToAnyThread() ;
1135 // by definition yield should handle all non-processed events
1139 OSStatus status
= noErr
;
1142 s_inReceiveEvent
= true ;
1143 status
= ReceiveNextEvent(0, NULL
,kEventDurationNoWait
,true,&theEvent
) ;
1144 s_inReceiveEvent
= false ;
1146 if ( status
== eventLoopTimedOutErr
)
1148 // make sure next time the event loop will trigger idle events
1149 sleepTime
= kEventDurationNoWait
;
1151 else if ( status
== eventLoopQuitErr
)
1153 // according to QA1061 this may also occur when a WakeUp Process
1158 MacHandleOneEvent( theEvent
) ;
1159 ReleaseEvent(theEvent
);
1161 } while( status
== noErr
) ;
1165 // having a larger value here leads to large performance slowdowns
1166 // so we cannot give background apps more processor time here
1167 // we do so however having a large sleep value in the main event loop
1170 while ( !IsExiting() && WaitNextEvent(everyEvent
, &event
,sleepTime
, (RgnHandle
) wxApp::s_macCursorRgn
))
1172 MacHandleModifierEvents( &event
) ;
1173 MacHandleOneEvent( &event
);
1174 if ( event
.what
!= kHighLevelEvent
)
1175 SetRectRgn( (RgnHandle
) wxApp::s_macCursorRgn
, event
.where
.h
, event
.where
.v
, event
.where
.h
+ 1 , event
.where
.v
+ 1 ) ;
1177 MacHandleModifierEvents( &event
) ;
1180 wxMacProcessNotifierAndPendingEvents() ;
1186 // platform specifics
1188 void wxApp::MacSuspend( bool convertClipboard
)
1191 // we have to deactive the top level windows manually
1193 wxWindowListNode
* node
= wxTopLevelWindows
.GetFirst();
1196 wxTopLevelWindow
* win
= (wxTopLevelWindow
*) node
->Data();
1198 #if 0 // having problems right now with that
1199 if (!win
->HasFlag(wxSTAY_ON_TOP
))
1202 win
->MacActivate( ((EventRecord
*) MacGetCurrentEvent())->when
, false ) ;
1204 node
= node
->GetNext();
1207 ::HideFloatingWindows() ;
1209 s_lastMouseDown
= 0 ;
1211 if( convertClipboard
)
1213 MacConvertPrivateToPublicScrap() ;
1217 extern wxList wxModalDialogs
;
1219 void wxApp::MacResume( bool convertClipboard
)
1221 s_lastMouseDown
= 0 ;
1222 if( convertClipboard
)
1224 MacConvertPublicToPrivateScrap() ;
1228 ::ShowFloatingWindows() ;
1229 // raise modal dialogs in case a non modal window was selected to activate the app
1231 wxNode
* node
= wxModalDialogs
.GetFirst();
1234 wxDialog
* dialog
= (wxDialog
*) node
->GetData();
1237 node
= node
->GetNext();
1242 void wxApp::MacConvertPrivateToPublicScrap()
1246 void wxApp::MacConvertPublicToPrivateScrap()
1250 void wxApp::MacDoOneEvent()
1255 s_inReceiveEvent
= true ;
1256 OSStatus status
= ReceiveNextEvent(0, NULL
,sleepTime
,true,&theEvent
) ;
1257 s_inReceiveEvent
= false ;
1258 if ( status
== eventLoopTimedOutErr
)
1260 if ( wxTheApp
->ProcessIdle() )
1261 sleepTime
= kEventDurationNoWait
;
1263 sleepTime
= kEventDurationForever
;
1265 else if ( status
== eventLoopQuitErr
)
1267 // according to QA1061 this may also occur when a WakeUp Process
1272 MacHandleOneEvent( theEvent
) ;
1273 ReleaseEvent(theEvent
);
1274 sleepTime
= kEventDurationNoWait
;
1279 EventMask eventMask
= everyEvent
;
1281 if (WaitNextEvent(eventMask
, &event
, sleepTime
, (RgnHandle
) s_macCursorRgn
))
1283 MacHandleModifierEvents( &event
) ;
1284 MacHandleOneEvent( &event
);
1288 MacHandleModifierEvents( &event
) ;
1290 WindowPtr window
= ::FrontWindow() ;
1292 ::IdleControls( window
) ;
1294 if ( wxTheApp
->ProcessIdle() )
1297 sleepTime
= GetCaretTime() / 2 ;
1299 if ( event
.what
!= kHighLevelEvent
)
1300 SetRectRgn( (RgnHandle
) s_macCursorRgn
, event
.where
.h
, event
.where
.v
, event
.where
.h
+ 1 , event
.where
.v
+ 1 ) ;
1304 DeletePendingObjects() ;
1305 wxMacProcessNotifierAndPendingEvents() ;
1308 void wxApp::MacHandleOneEvent( WXEVENTREF evr
)
1311 EventTargetRef theTarget
;
1312 theTarget
= GetEventDispatcherTarget();
1313 m_macCurrentEvent
= evr
;
1314 SendEventToEventTarget ((EventRef
) evr
, theTarget
);
1316 EventRecord
* ev
= (EventRecord
*) evr
;
1317 m_macCurrentEvent
= ev
;
1319 wxApp::sm_lastMessageTime
= ev
->when
;
1324 MacHandleMouseDownEvent( ev
) ;
1325 if ( ev
->modifiers
& controlKey
)
1326 s_lastMouseDown
= 2;
1328 s_lastMouseDown
= 1;
1331 if ( s_lastMouseDown
== 2 )
1333 ev
->modifiers
|= controlKey
;
1337 ev
->modifiers
&= ~controlKey
;
1339 MacHandleMouseUpEvent( ev
) ;
1340 s_lastMouseDown
= 0;
1343 MacHandleActivateEvent( ev
) ;
1346 MacHandleUpdateEvent( ev
) ;
1350 MacHandleKeyDownEvent( ev
) ;
1353 MacHandleKeyUpEvent( ev
) ;
1356 MacHandleDiskEvent( ev
) ;
1359 MacHandleOSEvent( ev
) ;
1361 case kHighLevelEvent
:
1362 MacHandleHighLevelEvent( ev
) ;
1368 wxMacProcessNotifierAndPendingEvents() ;
1372 bool s_macIsInModalLoop
= false ;
1374 void wxApp::MacHandleModifierEvents( WXEVENTREF evr
)
1376 EventRecord
* ev
= (EventRecord
*) evr
;
1377 if ( ev
->modifiers
!= s_lastModifiers
&& wxWindow::FindFocus() != NULL
)
1379 wxKeyEvent
event(wxEVT_KEY_DOWN
);
1381 event
.m_shiftDown
= ev
->modifiers
& shiftKey
;
1382 event
.m_controlDown
= ev
->modifiers
& controlKey
;
1383 event
.m_altDown
= ev
->modifiers
& optionKey
;
1384 event
.m_metaDown
= ev
->modifiers
& cmdKey
;
1386 event
.m_x
= ev
->where
.h
;
1387 event
.m_y
= ev
->where
.v
;
1388 event
.m_timeStamp
= ev
->when
;
1389 wxWindow
* focus
= wxWindow::FindFocus() ;
1390 event
.SetEventObject(focus
);
1392 if ( (ev
->modifiers
^ s_lastModifiers
) & controlKey
)
1394 event
.m_keyCode
= WXK_CONTROL
;
1395 event
.SetEventType( ( ev
->modifiers
& controlKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
1396 focus
->GetEventHandler()->ProcessEvent( event
) ;
1398 if ( (ev
->modifiers
^ s_lastModifiers
) & shiftKey
)
1400 event
.m_keyCode
= WXK_SHIFT
;
1401 event
.SetEventType( ( ev
->modifiers
& shiftKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
1402 focus
->GetEventHandler()->ProcessEvent( event
) ;
1404 if ( (ev
->modifiers
^ s_lastModifiers
) & optionKey
)
1406 event
.m_keyCode
= WXK_ALT
;
1407 event
.SetEventType( ( ev
->modifiers
& optionKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
1408 focus
->GetEventHandler()->ProcessEvent( event
) ;
1410 s_lastModifiers
= ev
->modifiers
;
1414 void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr
)
1416 // we must avoid reentrancy problems when processing high level events eg printing
1417 bool former
= s_inYield
;
1419 EventRecord
* ev
= (EventRecord
*) evr
;
1420 ::AEProcessAppleEvent( ev
) ;
1421 s_inYield
= former
;
1424 void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr
)
1426 EventRecord
* ev
= (EventRecord
*) evr
;
1427 wxToolTip::RemoveToolTips() ;
1430 WindowRef frontWindow
= ::FrontNonFloatingWindow() ;
1431 WindowAttributes frontWindowAttributes
= NULL
;
1433 ::GetWindowAttributes( frontWindow
, &frontWindowAttributes
) ;
1435 short windowPart
= ::FindWindow(ev
->where
, &window
);
1436 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( window
) ;
1437 if ( wxPendingDelete
.Member(win
) )
1441 GetQDGlobalsScreenBits( &screenBits
);
1446 if ( s_macIsInModalLoop
)
1452 UInt32 menuresult
= MenuSelect(ev
->where
) ;
1453 MacHandleMenuSelect( HiWord( menuresult
) , LoWord( menuresult
) );
1454 s_lastMouseDown
= 0;
1458 SystemClick( ev
, window
) ;
1459 s_lastMouseDown
= 0;
1462 if ( window
!= frontWindow
&& s_macIsInModalLoop
&& !(ev
->modifiers
& cmdKey
) )
1468 DragWindow(window
, ev
->where
, &screenBits
.bounds
);
1473 Point pt
= { 0, 0 } ;
1474 SetPortWindowPort(window
) ;
1475 LocalToGlobal( &pt
) ;
1477 win
->SetSize( pt
.h
, pt
.v
, -1 ,
1478 -1 , wxSIZE_USE_EXISTING
);
1480 s_lastMouseDown
= 0;
1484 if (TrackGoAway(window
, ev
->where
))
1489 s_lastMouseDown
= 0;
1493 Rect newContentRect
;
1494 Rect constraintRect
;
1495 constraintRect
.top
= win
->GetMinHeight() ;
1496 if ( constraintRect
.top
== -1 )
1497 constraintRect
.top
= 0 ;
1498 constraintRect
.left
= win
->GetMinWidth() ;
1499 if ( constraintRect
.left
== -1 )
1500 constraintRect
.left
= 0 ;
1501 constraintRect
.right
= win
->GetMaxWidth() ;
1502 if ( constraintRect
.right
== -1 )
1503 constraintRect
.right
= 32000 ;
1504 constraintRect
.bottom
= win
->GetMaxHeight() ;
1505 if ( constraintRect
.bottom
== -1 )
1506 constraintRect
.bottom
= 32000 ;
1508 Boolean growResult
= ResizeWindow( window
, ev
->where
,
1509 &constraintRect
, &newContentRect
) ;
1512 win
->SetSize( newContentRect
.left
, newContentRect
.top
,
1513 newContentRect
.right
- newContentRect
.left
,
1514 newContentRect
.bottom
- newContentRect
.top
, wxSIZE_USE_EXISTING
);
1516 s_lastMouseDown
= 0;
1521 if (TrackBox(window
, ev
->where
, windowPart
))
1523 // TODO setup size event
1524 ZoomWindow( window
, windowPart
, false ) ;
1530 Point pt
= { 0, 0 } ;
1531 SetPortWindowPort(window
) ;
1532 LocalToGlobal( &pt
) ;
1535 GetWindowPortBounds(window
, &tempRect
) ;
1536 win
->SetSize( pt
.h
, pt
.v
, tempRect
.right
-tempRect
.left
,
1537 tempRect
.bottom
-tempRect
.top
, wxSIZE_USE_EXISTING
);
1540 s_lastMouseDown
= 0;
1542 case inCollapseBox
:
1543 // TODO setup size event
1544 s_lastMouseDown
= 0;
1551 SetPortWindowPort(window
) ;
1554 if ( window
!= frontWindow
&& wxTheApp
->s_captureWindow
== NULL
)
1556 if ( s_macIsInModalLoop
)
1560 else if ( UMAIsWindowFloating( window
) )
1563 win
->MacMouseDown( ev
, windowPart
) ;
1568 win
->MacMouseDown( ev
, windowPart
) ;
1569 ::SelectWindow( window
) ;
1575 win
->MacMouseDown( ev
, windowPart
) ;
1583 void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr
)
1585 EventRecord
* ev
= (EventRecord
*) evr
;
1588 short windowPart
= inNoWindow
;
1589 if ( wxTheApp
->s_captureWindow
)
1591 window
= (WindowRef
) s_captureWindow
->MacGetRootWindow() ;
1592 windowPart
= inContent
;
1596 windowPart
= ::FindWindow(ev
->where
, &window
) ;
1607 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( window
) ;
1609 win
->MacMouseUp( ev
, windowPart
) ;
1617 long wxMacTranslateKey(unsigned char key
, unsigned char code
) ;
1618 long wxMacTranslateKey(unsigned char key
, unsigned char code
)
1623 case kHomeCharCode
:
1626 case kEnterCharCode
:
1627 retval
= WXK_RETURN
;
1632 case kHelpCharCode
:
1635 case kBackspaceCharCode
:
1641 case kPageUpCharCode
:
1642 retval
= WXK_PAGEUP
;
1644 case kPageDownCharCode
:
1645 retval
= WXK_PAGEDOWN
;
1647 case kReturnCharCode
:
1648 retval
= WXK_RETURN
;
1650 case kFunctionKeyCharCode
:
1702 case kEscapeCharCode
:
1703 retval
= WXK_ESCAPE
;
1705 case kLeftArrowCharCode
:
1708 case kRightArrowCharCode
:
1709 retval
= WXK_RIGHT
;
1711 case kUpArrowCharCode
:
1714 case kDownArrowCharCode
:
1717 case kDeleteCharCode
:
1718 retval
= WXK_DELETE
;
1727 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr
)
1729 EventRecord
* ev
= (EventRecord
*) evr
;
1730 wxToolTip::RemoveToolTips() ;
1732 UInt32 menuresult
= UMAMenuEvent(ev
) ;
1733 if ( HiWord( menuresult
) )
1735 if ( !s_macIsInModalLoop
)
1736 MacHandleMenuSelect( HiWord( menuresult
) , LoWord( menuresult
) ) ;
1740 wxWindow
* focus
= wxWindow::FindFocus() ;
1742 if ( MacSendKeyDownEvent( focus
, ev
->message
, ev
->modifiers
, ev
->when
, ev
->where
.h
, ev
->where
.v
) == false )
1744 // has not been handled -> perform default
1745 wxControl
* control
= wxDynamicCast( focus
, wxControl
) ;
1746 if ( control
&& control
->GetMacControl() != NULL
)
1750 keychar
= short(ev
->message
& charCodeMask
);
1751 keycode
= short(ev
->message
& keyCodeMask
) >> 8 ;
1752 ::HandleControlKey( (ControlHandle
) control
->GetMacControl() , keycode
, keychar
, ev
->modifiers
) ;
1758 void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr
)
1760 EventRecord
* ev
= (EventRecord
*) evr
;
1761 wxToolTip::RemoveToolTips() ;
1763 UInt32 menuresult
= UMAMenuEvent(ev
) ;
1764 if ( HiWord( menuresult
) )
1769 MacSendKeyUpEvent( wxWindow::FindFocus() , ev
->message
, ev
->modifiers
, ev
->when
, ev
->where
.h
, ev
->where
.v
) ;
1775 bool wxApp::MacSendKeyDownEvent( wxWindow
* focus
, long keymessage
, long modifiers
, long when
, short wherex
, short wherey
)
1782 keychar
= short(keymessage
& charCodeMask
);
1783 keycode
= short(keymessage
& keyCodeMask
) >> 8 ;
1785 if ( modifiers
& ( controlKey
|shiftKey
|optionKey
) )
1787 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1788 // and look at the character after
1790 UInt32 keyInfo
= KeyTranslate((Ptr
)GetScriptManagerVariable(smKCHRCache
), ( modifiers
& (~(controlKey
|shiftKey
|optionKey
))) | keycode
, &state
);
1791 keychar
= short(keyInfo
& charCodeMask
);
1792 keycode
= short(keyInfo
& keyCodeMask
) >> 8 ;
1794 long keyval
= wxMacTranslateKey(keychar
, keycode
) ;
1795 long realkeyval
= keyval
;
1796 if ( keyval
== keychar
)
1798 // 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)
1799 realkeyval
= short(keymessage
& charCodeMask
) ;
1800 keyval
= wxToupper( keyval
) ;
1803 wxKeyEvent
event(wxEVT_KEY_DOWN
);
1804 bool handled
= false ;
1805 event
.m_shiftDown
= modifiers
& shiftKey
;
1806 event
.m_controlDown
= modifiers
& controlKey
;
1807 event
.m_altDown
= modifiers
& optionKey
;
1808 event
.m_metaDown
= modifiers
& cmdKey
;
1809 event
.m_keyCode
= keyval
;
1813 event
.m_timeStamp
= when
;
1814 event
.SetEventObject(focus
);
1815 handled
= focus
->GetEventHandler()->ProcessEvent( event
) ;
1816 if ( handled
&& event
.GetSkipped() )
1823 wxWindow
*ancestor
= focus
;
1826 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1829 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1830 handled
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1833 if (ancestor
->IsTopLevel())
1835 ancestor
= ancestor
->GetParent();
1838 #endif // wxUSE_ACCEL
1842 event
.Skip( FALSE
) ;
1843 event
.SetEventType( wxEVT_CHAR
) ;
1845 event
.m_keyCode
= realkeyval
;
1847 handled
= focus
->GetEventHandler()->ProcessEvent( event
) ;
1848 if ( handled
&& event
.GetSkipped() )
1852 (keyval
== WXK_TAB
) &&
1853 // CS: copied the change below from wxGTK
1854 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1855 // have this style, yet choose not to process this particular TAB in which
1856 // case TAB must still work as a navigational character
1858 (!focus
->HasFlag(wxTE_PROCESS_TAB
)) &&
1860 (focus
->GetParent()) &&
1861 (focus
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1863 wxNavigationKeyEvent new_event
;
1864 new_event
.SetEventObject( focus
);
1865 new_event
.SetDirection( !event
.ShiftDown() );
1866 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1867 new_event
.SetWindowChange( event
.ControlDown() );
1868 new_event
.SetCurrentFocus( focus
);
1869 handled
= focus
->GetEventHandler()->ProcessEvent( new_event
);
1870 if ( handled
&& new_event
.GetSkipped() )
1873 // backdoor handler for default return and command escape
1874 if ( !handled
&& (!focus
->IsKindOf(CLASSINFO(wxControl
) ) || !focus
->MacCanFocus() ) )
1876 // if window is not having a focus still testing for default enter or cancel
1877 // TODO add the UMA version for ActiveNonFloatingWindow
1878 wxWindow
* focus
= wxFindWinFromMacWindow( FrontWindow() ) ;
1881 if ( keyval
== WXK_RETURN
)
1883 wxButton
*def
= wxDynamicCast(focus
->GetDefaultItem(),
1885 if ( def
&& def
->IsEnabled() )
1887 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, def
->GetId() );
1888 event
.SetEventObject(def
);
1889 def
->Command(event
);
1893 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1894 else if (keyval
== WXK_ESCAPE
|| (keyval
== '.' && modifiers
& cmdKey
) )
1896 wxCommandEvent
new_event(wxEVT_COMMAND_BUTTON_CLICKED
,wxID_CANCEL
);
1897 new_event
.SetEventObject( focus
);
1898 handled
= focus
->GetEventHandler()->ProcessEvent( new_event
);
1905 bool wxApp::MacSendKeyUpEvent( wxWindow
* focus
, long keymessage
, long modifiers
, long when
, short wherex
, short wherey
)
1912 keychar
= short(keymessage
& charCodeMask
);
1913 keycode
= short(keymessage
& keyCodeMask
) >> 8 ;
1914 if ( modifiers
& ( controlKey
|shiftKey
|optionKey
) )
1916 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1917 // and look at the character after
1919 UInt32 keyInfo
= KeyTranslate((Ptr
)GetScriptManagerVariable(smKCHRCache
), ( modifiers
& (~(controlKey
|shiftKey
|optionKey
))) | keycode
, &state
);
1920 keychar
= short(keyInfo
& charCodeMask
);
1921 keycode
= short(keyInfo
& keyCodeMask
) >> 8 ;
1923 long keyval
= wxMacTranslateKey(keychar
, keycode
) ;
1925 if ( keyval
== keychar
)
1927 keyval
= wxToupper( keyval
) ;
1929 bool handled
= false ;
1931 wxKeyEvent
event(wxEVT_KEY_UP
);
1932 event
.m_shiftDown
= modifiers
& shiftKey
;
1933 event
.m_controlDown
= modifiers
& controlKey
;
1934 event
.m_altDown
= modifiers
& optionKey
;
1935 event
.m_metaDown
= modifiers
& cmdKey
;
1936 event
.m_keyCode
= keyval
;
1940 event
.m_timeStamp
= when
;
1941 event
.SetEventObject(focus
);
1942 handled
= focus
->GetEventHandler()->ProcessEvent( event
) ;
1948 void wxApp::MacHandleActivateEvent( WXEVENTREF evr
)
1950 EventRecord
* ev
= (EventRecord
*) evr
;
1951 WindowRef window
= (WindowRef
) ev
->message
;
1954 bool activate
= (ev
->modifiers
& activeFlag
) ;
1955 WindowClass wclass
;
1956 ::GetWindowClass ( window
, &wclass
) ;
1957 if ( wclass
== kFloatingWindowClass
)
1959 // if it is a floater we activate/deactivate the front non-floating window instead
1960 window
= ::FrontNonFloatingWindow() ;
1962 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( window
) ;
1964 win
->MacActivate( ev
->when
, activate
) ;
1968 void wxApp::MacHandleUpdateEvent( WXEVENTREF evr
)
1970 EventRecord
* ev
= (EventRecord
*) evr
;
1971 WindowRef window
= (WindowRef
) ev
->message
;
1972 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( window
) ;
1975 if ( !wxPendingDelete
.Member(win
) )
1976 win
->MacUpdate( ev
->when
) ;
1980 // since there is no way of telling this foreign window to update itself
1981 // we have to invalidate the update region otherwise we keep getting the same
1982 // event over and over again
1983 BeginUpdate( window
) ;
1984 EndUpdate( window
) ;
1988 void wxApp::MacHandleDiskEvent( WXEVENTREF evr
)
1990 EventRecord
* ev
= (EventRecord
*) evr
;
1991 if ( HiWord( ev
->message
) != noErr
)
1995 SetPt( &point
, 100 , 100 ) ;
1997 err
= DIBadMount( point
, ev
->message
) ;
1998 wxASSERT( err
== noErr
) ;
2002 void wxApp::MacHandleOSEvent( WXEVENTREF evr
)
2004 EventRecord
* ev
= (EventRecord
*) evr
;
2005 switch( ( ev
->message
& osEvtMessageMask
) >> 24 )
2007 case suspendResumeMessage
:
2009 bool isResuming
= ev
->message
& resumeFlag
;
2010 bool convertClipboard
= ev
->message
& convertClipboardFlag
;
2012 bool doesActivate
= UMAGetProcessModeDoesActivateOnFGSwitch() ;
2015 WindowRef oldFrontWindow
= NULL
;
2016 WindowRef newFrontWindow
= NULL
;
2018 // in case we don't take care of activating ourselves, we have to synchronize
2019 // our idea of the active window with the process manager's - which it already activated
2021 if ( !doesActivate
)
2022 oldFrontWindow
= ::FrontNonFloatingWindow() ;
2024 MacResume( convertClipboard
) ;
2026 newFrontWindow
= ::FrontNonFloatingWindow() ;
2028 if ( oldFrontWindow
)
2030 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( oldFrontWindow
) ;
2032 win
->MacActivate( ev
->when
, false ) ;
2034 if ( newFrontWindow
)
2036 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( newFrontWindow
) ;
2038 win
->MacActivate( ev
->when
, true ) ;
2043 MacSuspend( convertClipboard
) ;
2047 case mouseMovedMessage
:
2051 wxWindow
* currentMouseWindow
= NULL
;
2053 if (s_captureWindow
)
2055 currentMouseWindow
= s_captureWindow
;
2059 wxWindow::MacGetWindowFromPoint( wxPoint( ev
->where
.h
, ev
->where
.v
) ,
2060 ¤tMouseWindow
) ;
2063 if ( currentMouseWindow
!= wxWindow::s_lastMouseWindow
)
2065 wxMouseEvent event
;
2067 bool isDown
= !(ev
->modifiers
& btnState
) ; // 1 is for up
2068 bool controlDown
= ev
->modifiers
& controlKey
; // for simulating right mouse
2070 event
.m_leftDown
= isDown
&& !controlDown
;
2071 event
.m_middleDown
= FALSE
;
2072 event
.m_rightDown
= isDown
&& controlDown
;
2073 event
.m_shiftDown
= ev
->modifiers
& shiftKey
;
2074 event
.m_controlDown
= ev
->modifiers
& controlKey
;
2075 event
.m_altDown
= ev
->modifiers
& optionKey
;
2076 event
.m_metaDown
= ev
->modifiers
& cmdKey
;
2077 event
.m_x
= ev
->where
.h
;
2078 event
.m_y
= ev
->where
.v
;
2079 event
.m_timeStamp
= ev
->when
;
2080 event
.SetEventObject(this);
2082 if ( wxWindow::s_lastMouseWindow
)
2084 wxMouseEvent
eventleave(event
);
2085 eventleave
.SetEventType( wxEVT_LEAVE_WINDOW
);
2086 wxWindow::s_lastMouseWindow
->ScreenToClient( &eventleave
.m_x
, &eventleave
.m_y
);
2087 eventleave
.SetEventObject( wxWindow::s_lastMouseWindow
) ;
2089 wxWindow::s_lastMouseWindow
->GetEventHandler()->ProcessEvent(eventleave
);
2091 if ( currentMouseWindow
)
2093 wxMouseEvent
evententer(event
);
2094 evententer
.SetEventType( wxEVT_ENTER_WINDOW
);
2095 currentMouseWindow
->ScreenToClient( &evententer
.m_x
, &evententer
.m_y
);
2096 evententer
.SetEventObject( currentMouseWindow
) ;
2097 currentMouseWindow
->GetEventHandler()->ProcessEvent(evententer
);
2099 wxWindow::s_lastMouseWindow
= currentMouseWindow
;
2102 short windowPart
= inNoWindow
;
2104 if ( s_captureWindow
)
2106 window
= (WindowRef
) s_captureWindow
->MacGetRootWindow() ;
2107 windowPart
= inContent
;
2111 windowPart
= ::FindWindow(ev
->where
, &window
);
2118 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow( window
) ;
2120 win
->MacMouseMoved( ev
, windowPart
) ;
2127 UMAShowArrowCursor();
2137 UMAShowArrowCursor();
2148 void wxApp::MacHandleMenuCommand( wxUint32 id
)
2150 wxMenuBar
* mbar
= wxMenuBar::MacGetInstalledMenuBar() ;
2151 wxFrame
* frame
= mbar
->GetFrame();
2152 wxCHECK_RET( mbar
!= NULL
&& frame
!= NULL
, wxT("error in menu item callback") );
2155 frame
->ProcessCommand(id
);
2160 void wxApp::MacHandleMenuSelect( int macMenuId
, int macMenuItemNum
)
2163 return; // no menu item selected
2165 if (macMenuId
== kwxMacAppleMenuId
&& macMenuItemNum
> 1)
2168 Str255 deskAccessoryName
;
2171 GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId
), macMenuItemNum
, deskAccessoryName
);
2172 GetPort(&savedPort
);
2173 OpenDeskAcc(deskAccessoryName
);
2180 GetMenuItemCommandID( GetMenuHandle(macMenuId
) , macMenuItemNum
, &id
) ;
2181 MacHandleMenuCommand( id
) ;