#ifdef __DARWIN__
# include <CoreServices/CoreServices.h>
+# if defined(WXMAKINGDLL)
+# include <mach-o/dyld.h>
+# endif
#else
# include <Sound.h>
# include <Threads.h>
const short kwxMacMenuBarResource = 1 ;
const short kwxMacAppleMenuId = 1 ;
-WXHRGN wxApp::s_macCursorRgn = NULL;
-wxWindow* wxApp::s_captureWindow = NULL ;
-int wxApp::s_lastMouseDown = 0 ;
-long wxApp::sm_lastMessageTime = 0;
+WXHRGN wxApp::s_macCursorRgn = NULL;
+wxWindow* wxApp::s_captureWindow = NULL ;
+int wxApp::s_lastMouseDown = 0 ;
+long wxApp::sm_lastMessageTime = 0;
+long wxApp::s_lastModifiers = 0 ;
-bool wxApp::s_macDefaultEncodingIsPC = true ;
-bool wxApp::s_macSupportPCMenuShortcuts = true ;
-long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
-wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
+
+bool wxApp::s_macDefaultEncodingIsPC = true ;
+bool wxApp::s_macSupportPCMenuShortcuts = true ;
+long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
+wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
-pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon )
+pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
// GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
}
-pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon )
+pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
// GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
}
-pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon )
+pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
// GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
}
-pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon )
+pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
// GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
}
-short wxApp::MacHandleAEODoc(const WXEVENTREF event , WXEVENTREF reply)
+// new virtual public method in wxApp
+void wxApp::MacOpenFile(const wxString & WXUNUSED(fileName) )
+{
+}
+
+void wxApp::MacPrintFile(const wxString & WXUNUSED(fileName) )
+{
+}
+
+void wxApp::MacNewFile()
+{
+}
+
+// new implementation, which parses the event and calls
+// MacOpenFile on each of the files it's passed
+short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
{
- SysBeep(40) ;
+ AEDescList docList;
+ AEKeyword keywd;
+ DescType returnedType;
+ Size actualSize;
+ long itemsInList;
+ FSSpec theSpec;
+ OSErr err;
+ short i;
+ err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
+ if (err != noErr)
+ return err;
+
+ err = AECountItems(&docList, &itemsInList);
+ if (err != noErr)
+ return err;
+
ProcessSerialNumber PSN ;
PSN.highLongOfPSN = 0 ;
PSN.lowLongOfPSN = kCurrentProcess ;
SetFrontProcess( &PSN ) ;
- return noErr ;
-}
-
-short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF reply)
-{
- return noErr ;
+
+ for (i = 1; i <= itemsInList; i++) {
+ AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
+ (Ptr) & theSpec, sizeof(theSpec), &actualSize);
+ wxString fName = wxMacFSSpec2MacFilename(&theSpec);
+ MacOpenFile(fName);
+ }
+ return noErr;
+}
+
+short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
+{
+ AEDescList docList;
+ AEKeyword keywd;
+ DescType returnedType;
+ Size actualSize;
+ long itemsInList;
+ FSSpec theSpec;
+ OSErr err;
+ short i;
+ err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
+ if (err != noErr)
+ return err;
+
+ err = AECountItems(&docList, &itemsInList);
+ if (err != noErr)
+ return err;
+
+ ProcessSerialNumber PSN ;
+ PSN.highLongOfPSN = 0 ;
+ PSN.lowLongOfPSN = kCurrentProcess ;
+ SetFrontProcess( &PSN ) ;
+
+ for (i = 1; i <= itemsInList; i++) {
+ AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
+ (Ptr) & theSpec, sizeof(theSpec), &actualSize);
+ wxString fName = wxMacFSSpec2MacFilename(&theSpec);
+ MacPrintFile(fName);
+ }
+ return noErr;
}
-short wxApp::MacHandleAEOApp(const WXEVENTREF event , WXEVENTREF reply)
+short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
+ MacNewFile() ;
return noErr ;
}
-short wxApp::MacHandleAEQuit(const WXEVENTREF event , WXEVENTREF reply)
+short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
wxWindow* win = GetTopWindow() ;
if ( win )
CopyCStringToPascal( from , to ) ;
}
}
-#ifdef WXMAKINGDLL
-#ifndef __DARWIN__
+
+#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
// we know it's there ;-)
WXIMPORT char std::__throws_bad_alloc ;
#endif
-#endif
bool wxApp::Initialize()
{
- int error = 0 ;
+ int error = 0 ;
- // Mac-specific
+ // Mac-specific
- UMAInitToolbox( 4 ) ;
- SetEventMask( everyEvent ) ;
+ UMAInitToolbox( 4 ) ;
+ SetEventMask( everyEvent ) ;
UMAShowWatchCursor() ;
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+ // open shared library resources from here since we don't have
+ // __wxinitialize in Mach-O shared libraries
+ wxStAppResource::OpenSharedLibraryResource(NULL);
+#endif
+
#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
- AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , NewAEEventHandlerUPP(AEHandleODoc) ,
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerUPP(AEHandleODoc) ,
(long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , NewAEEventHandlerUPP(AEHandleOApp) ,
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerUPP(AEHandleOApp) ,
(long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , NewAEEventHandlerUPP(AEHandlePDoc) ,
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerUPP(AEHandlePDoc) ,
(long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , NewAEEventHandlerUPP(AEHandleQuit) ,
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerUPP(AEHandleQuit) ,
(long) wxTheApp , FALSE ) ;
#else
- AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , NewAEEventHandlerProc(AEHandleODoc) ,
- (long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , NewAEEventHandlerProc(AEHandleOApp) ,
- (long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , NewAEEventHandlerProc(AEHandlePDoc) ,
- (long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , NewAEEventHandlerProc(AEHandleQuit) ,
- (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerProc(AEHandleODoc) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerProc(AEHandleOApp) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerProc(AEHandlePDoc) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerProc(AEHandleQuit) ,
+ (long) wxTheApp , FALSE ) ;
#endif
-
#ifndef __DARWIN__
- // test the minimal configuration necessary
+ // test the minimal configuration necessary
- #if !TARGET_CARBON
+# if !TARGET_CARBON
long theSystem ;
long theMachine;
{
error = kMacSTRSmallSize;
}
- #endif
+# endif
/*
else
{
}
#ifndef __DARWIN__
- #if __option(profile)
+# if __option(profile)
ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
- #endif
+# endif
#endif
- // now avoid exceptions thrown for new (bad_alloc)
-
#ifndef __DARWIN__
- std::__throws_bad_alloc = FALSE ;
+ // now avoid exceptions thrown for new (bad_alloc)
+ std::__throws_bad_alloc = FALSE ;
#endif
s_macCursorRgn = ::NewRgn() ;
-#ifdef __WXMSW__
- wxBuffer = new char[1500];
-#else
- wxBuffer = new char[BUFSIZ + 512];
-#endif
+ wxBuffer = new char[BUFSIZ + 512];
- wxClassInfo::InitializeClasses();
+ wxClassInfo::InitializeClasses();
#if wxUSE_RESOURCES
// wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
#if wxUSE_THREADS
wxPendingEventsLocker = new wxCriticalSection;
#endif
- wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
- wxTheColourDatabase->Initialize();
+
+ wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+ wxTheColourDatabase->Initialize();
#ifdef __WXDEBUG__
#if wxUSE_LOG
wxMacCreateNotifierTable() ;
+
UMAShowArrowCursor() ;
return TRUE;
// One last chance for pending objects to be cleaned up
wxTheApp->DeletePendingObjects();
- wxModule::CleanUpModules();
+ wxModule::CleanUpModules();
#if wxUSE_WX_RESOURCES
- wxCleanUpResourceSystem();
+ wxCleanUpResourceSystem();
#endif
- wxDeleteStockObjects() ;
+ wxDeleteStockObjects() ;
// Destroy all GDI lists, etc.
wxDeleteStockLists();
- delete wxTheColourDatabase;
- wxTheColourDatabase = NULL;
-
- wxBitmap::CleanUpHandlers();
+ delete wxTheColourDatabase;
+ wxTheColourDatabase = NULL;
- delete[] wxBuffer;
- wxBuffer = NULL;
+ wxBitmap::CleanUpHandlers();
- wxMacDestroyNotifierTable() ;
- if (wxWinMacWindowList)
- delete wxWinMacWindowList ;
-
- if (wxWinMacControlList)
- delete wxWinMacControlList ;
+ delete[] wxBuffer;
+ wxBuffer = NULL;
+ wxMacDestroyNotifierTable() ;
+ if (wxWinMacWindowList) {
+ delete wxWinMacWindowList ;
+ }
+ if (wxWinMacControlList) {
+ delete wxWinMacControlList ;
+ }
delete wxPendingEvents;
+
#if wxUSE_THREADS
delete wxPendingEventsLocker;
// If we don't do the following, we get an apparent memory leak.
((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
#endif
- wxClassInfo::CleanUpClasses();
+ wxClassInfo::CleanUpClasses();
#ifndef __DARWIN__
- #if __option(profile)
- ProfilerDump( "\papp.prof" ) ;
- ProfilerTerm() ;
- #endif
+# if __option(profile)
+ ProfilerDump( "\papp.prof" ) ;
+ ProfilerTerm() ;
+# endif
#endif
- delete wxTheApp;
- wxTheApp = NULL;
+ delete wxTheApp;
+ wxTheApp = NULL;
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
// At this point we want to check if there are any memory
delete wxLog::SetActiveTarget(NULL);
#endif // wxUSE_LOG
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+ // close shared library resources from here since we don't have
+ // __wxterminate in Mach-O shared libraries
+ wxStAppResource::CloseSharedLibraryResource();
+#endif
+
UMACleanupToolbox() ;
- if (s_macCursorRgn)
+ if (s_macCursorRgn) {
::DisposeRgn((RgnHandle)s_macCursorRgn);
+ }
#if 0
TerminateAE() ;
// wxEntry
//----------------------------------------------------------------------
-short gCurrentResource = -1 ;
+// extern variable for shared library resource id
+// need to be able to find it with NSLookupAndBindSymbol
+short gSharedLibraryResource = kResFileNotOpened ;
+
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+CFBundleRef gSharedLibraryBundle = NULL;
+#endif /* WXMAKINGDLL && __DARWIN__ */
wxStAppResource::wxStAppResource()
{
m_currentRefNum = CurResFile() ;
- if ( gCurrentResource != -1 )
+ if ( gSharedLibraryResource != kResFileNotOpened )
{
- UseResFile( gCurrentResource ) ;
+ UseResFile( gSharedLibraryResource ) ;
}
}
wxStAppResource::~wxStAppResource()
{
- if ( m_currentRefNum != -1 )
+ if ( m_currentRefNum != kResFileNotOpened )
{
UseResFile( m_currentRefNum ) ;
}
}
+void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
+{
+ gSharedLibraryResource = kResFileNotOpened;
+
#ifdef WXMAKINGDLL
+ if ( initBlock != NULL ) {
+ const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
+ FSSpec *fileSpec = NULL;
-// for shared libraries we have to manually get the correct resource ref num upon
-// initializing and releasing when terminating, therefore the __wxinitialize and __wxterminate
-// must be used
+ if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
+ fileSpec = theInitBlock->fragLocator.u.onDisk.fileSpec;
+ }
+ else if (theInitBlock->fragLocator.where == kResourceCFragLocator) {
+ fileSpec = theInitBlock->fragLocator.u.inSegs.fileSpec;
+ }
-#ifdef __cplusplus
-extern "C" {
-#endif
+ if (fileSpec != NULL) {
+ gSharedLibraryResource = FSpOpenResFile(fileSpec, fsRdPerm);
+ }
+ }
+ else {
+#ifdef __DARWIN__
+ // Open the shared library resource file if it is not yet open
+ NSSymbol theSymbol;
+ NSModule theModule;
+ const char *theLibPath;
-void __sinit(void); /* (generated by linker) */
-pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
-pascal void __terminate(void);
+ gSharedLibraryBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
+ if (gSharedLibraryBundle != NULL) {
+ // wxWindows has been bundled into a framework
+ // load the framework resources
-#ifdef __cplusplus
+ gSharedLibraryResource = CFBundleOpenBundleResourceMap(gSharedLibraryBundle);
+ }
+ else {
+ // wxWindows is a simple dynamic shared library
+ // load the resources from the data fork of a separate resource file
+ char *theResPath;
+ char *theName;
+ char *theExt;
+ FSRef theResRef;
+ OSErr theErr = noErr;
+
+ // get the library path
+ theSymbol = NSLookupAndBindSymbol("_gSharedLibraryResource");
+ theModule = NSModuleForSymbol(theSymbol);
+ theLibPath = NSLibraryNameForModule(theModule);
+
+ // allocate copy to replace .dylib.* extension with .rsrc
+ theResPath = strdup(theLibPath);
+ if (theResPath != NULL) {
+ theName = strrchr(theResPath, '/');
+ if (theName == NULL) {
+ // no directory elements in path
+ theName = theResPath;
+ }
+ // find ".dylib" shared library extension
+ theExt = strstr(theName, ".dylib");
+ // overwrite extension with ".rsrc"
+ strcpy(theExt, ".rsrc");
+
+ wxLogDebug( theResPath );
+
+ theErr = FSPathMakeRef((UInt8 *) theResPath, &theResRef, false);
+ if (theErr != noErr) {
+ // try in current directory (using name only)
+ theErr = FSPathMakeRef((UInt8 *) theName, &theResRef, false);
+ }
+
+ // free duplicated resource file path
+ free(theResPath);
+
+ // open the resource file
+ if (theErr == noErr) {
+ theErr = FSOpenResourceFile( &theResRef, 0, NULL, fsRdPerm,
+ &gSharedLibraryResource);
+ }
+ }
+ }
+#endif /* __DARWIN__ */
+ }
+#endif /* WXMAKINGDLL */
+}
+
+void wxStAppResource::CloseSharedLibraryResource()
+{
+#ifdef WXMAKINGDLL
+ // Close the shared library resource file
+ if (gSharedLibraryResource != kResFileNotOpened) {
+#ifdef __DARWIN__
+ if (gSharedLibraryBundle != NULL) {
+ CFBundleCloseBundleResourceMap(gSharedLibraryBundle,
+ gSharedLibraryResource);
+ gSharedLibraryBundle = NULL;
+ }
+ else
+#endif /* __DARWIN__ */
+ {
+ CloseResFile(gSharedLibraryResource);
+ }
+ gSharedLibraryResource = kResFileNotOpened;
+ }
+#endif /* WXMAKINGDLL */
+}
+
+#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
+
+// for shared libraries we have to manually get the correct resource
+// ref num upon initializing and releasing when terminating, therefore
+// the __wxinitialize and __wxterminate must be used
+
+extern "C" {
+ void __sinit(void); /* (generated by linker) */
+ pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
+ pascal void __terminate(void);
}
-#endif
pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
{
- gCurrentResource = -1;
-
- if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
- gCurrentResource =
- FSpOpenResFile(theInitBlock->fragLocator.u.onDisk.fileSpec,
- fsRdPerm);
- }
- return __initialize( theInitBlock ) ;
+ wxStAppResource::OpenSharedLibraryResource( theInitBlock ) ;
+ return __initialize( theInitBlock ) ;
}
pascal void __wxterminate(void)
{
- if (gCurrentResource != -1)
- CloseResFile(gCurrentResource);
+ wxStAppResource::CloseSharedLibraryResource() ;
__terminate() ;
}
-#endif
-int WXDLLEXPORT wxEntryStart( int argc, char *argv[] )
+#endif /* WXMAKINGDLL && !__DARWIN__ */
+
+int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char *WXUNUSED(argv)[] )
{
return wxApp::Initialize();
}
int wxEntry( int argc, char *argv[] , bool enterLoop )
{
- gCurrentResource = CurResFile() ;
#ifdef __MWERKS__
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
// This seems to be necessary since there are 'rogue'
// application (otherwise applications would need to handle it)
if (argc > 1) {
- char buf[6] = "";
- strncpy(buf, argv[1], 5);
-
- if (strcmp(buf, "-psn_") == 0) {
+ char theArg[6] = "";
+ strncpy(theArg, argv[1], 5);
+
+ if (strcmp(theArg, "-psn_") == 0) {
// assume the argument is always the only one and remove it
--argc;
}
- }
+ }
#else
argc = 0 ; // currently we don't support files as parameters
#endif
return retValue;
}
+#if TARGET_CARBON
+
+bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
+{
+ bool converted = ConvertEventRefToEventRecord( event,rec) ;
+ OSStatus err = noErr ;
+ if ( !converted )
+ {
+ switch( GetEventClass( event ) )
+ {
+ case kEventClassKeyboard :
+ {
+ converted = true ;
+ switch( GetEventKind(event) )
+ {
+ case kEventRawKeyDown :
+ rec->what = keyDown ;
+ break ;
+ case kEventRawKeyRepeat :
+ rec->what = autoKey ;
+ break ;
+ case kEventRawKeyUp :
+ rec->what = keyUp ;
+ break ;
+ case kEventRawKeyModifiersChanged :
+ rec->what = nullEvent ;
+ break ;
+ default :
+ converted = false ;
+ break ;
+ }
+ if ( converted )
+ {
+ UInt32 keyCode ;
+ unsigned char charCode ;
+ UInt32 modifiers ;
+ GetMouse( &rec->where) ;
+
+ err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
+ err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
+ err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
+ rec->modifiers = modifiers ;
+ rec->message = (keyCode << 8 ) + charCode ;
+ }
+ }
+ break ;
+ case kEventClassTextInput :
+ {
+ switch( GetEventKind( event ) )
+ {
+ case kEventTextInputUnicodeForKeyEvent :
+ {
+ EventRef rawEvent ;
+ err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
+ converted = true ;
+ {
+ UInt32 keyCode ;
+ unsigned char charCode ;
+ UInt32 modifiers ;
+ GetMouse( &rec->where) ;
+ rec->what = keyDown ;
+ err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
+ err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
+ err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
+ rec->modifiers = modifiers ;
+ rec->message = (keyCode << 8 ) + charCode ;
+ }
+ }
+ break ;
+ default :
+ break ;
+ }
+ }
+ break ;
+ }
+ }
+
+ return converted ;
+}
+
+pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+
+ EventRecord rec ;
+ switch ( GetEventClass( event ) )
+ {
+ case kEventClassKeyboard :
+ if ( wxMacConvertEventToRecord( event , &rec ) )
+ {
+ wxTheApp->MacHandleModifierEvents( &rec ) ;
+ wxTheApp->MacHandleOneEvent( &rec ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventClassTextInput :
+ if ( wxMacConvertEventToRecord( event , &rec ) )
+ {
+ wxTheApp->MacHandleModifierEvents( &rec ) ;
+ wxTheApp->MacHandleOneEvent( &rec ) ;
+ result = noErr ;
+ }
+ break ;
+ default :
+ break ;
+ }
+ return result ;
+}
+
+#endif
+
+bool wxApp::OnInit()
+{
+ if ( ! wxAppBase::OnInit() )
+ return FALSE ;
+
+#if 0 // TARGET_CARBON
+ static const EventTypeSpec eventList[] =
+ {
+ { kEventClassKeyboard, kEventRawKeyDown } ,
+ { kEventClassKeyboard, kEventRawKeyRepeat } ,
+ { kEventClassKeyboard, kEventRawKeyUp } ,
+ { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
+
+ { kEventClassTextInput , kEventTextInputUnicodeForKeyEvent } ,
+ } ;
+
+ InstallApplicationEventHandler(NewEventHandlerUPP(wxMacApplicationEventHandler)
+ , WXSIZEOF(eventList), eventList, this, NULL);
+#endif
+ return TRUE ;
+}
// Static member initialization
wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
argv = NULL;
m_printMode = wxPRINT_WINDOWS;
- m_exitOnFrameDelete = TRUE;
m_auto3D = TRUE;
}
while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
{
+ wxTheApp->MacHandleModifierEvents( &event ) ;
wxTheApp->MacHandleOneEvent( &event );
if ( event.what != kHighLevelEvent )
SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v , event.where.h + 1 , event.where.v + 1 ) ;
}
+ wxTheApp->MacHandleModifierEvents( &event ) ;
wxMacProcessNotifierAndPendingEvents() ;
node = node->Next();
}
- s_lastMouseDown = 0 ;
- if( convertClipboard )
- {
- MacConvertPrivateToPublicScrap() ;
- }
+ s_lastMouseDown = 0 ;
+ if( convertClipboard )
+ {
+ MacConvertPrivateToPublicScrap() ;
+ }
- ::HideFloatingWindows() ;
+ ::HideFloatingWindows() ;
}
+extern wxList wxModalDialogs;
+
void wxApp::MacResume( bool convertClipboard )
{
- s_lastMouseDown = 0 ;
- if( convertClipboard )
- {
- MacConvertPublicToPrivateScrap() ;
- }
+ s_lastMouseDown = 0 ;
+ if( convertClipboard )
+ {
+ MacConvertPublicToPrivateScrap() ;
+ }
- ::ShowFloatingWindows() ;
+ ::ShowFloatingWindows() ;
+
+ // raise modal dialogs in case a non modal window was selected to activate the app
+
+ wxNode* node = wxModalDialogs.First();
+ while (node)
+ {
+ wxDialog* dialog = (wxDialog *) node->Data();
+ dialog->Raise();
+
+ node = node->Next();
+ }
}
void wxApp::MacConvertPrivateToPublicScrap()
if (WaitNextEvent(everyEvent, &event, sleepTime, (RgnHandle) s_macCursorRgn))
{
+ MacHandleModifierEvents( &event ) ;
MacHandleOneEvent( &event );
}
else
{
+ MacHandleModifierEvents( &event ) ;
// idlers
WindowPtr window = ::FrontWindow() ;
if ( window )
wxMacProcessNotifierAndPendingEvents() ;
}
+void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+#if TARGET_CARBON
+ if ( ev->what == mouseDown || ev->what == mouseUp || ev->what == activateEvt ||
+ ev->what == keyDown || ev->what == autoKey || ev->what == keyUp || ev->what == nullEvent )
+ {
+ // in these cases the modifiers are already correctly setup by carbon
+ }
+ else
+ {
+ EventRecord nev ;
+ WaitNextEvent( 0 , &nev , 0 , NULL ) ;
+ ev->modifiers = nev.modifiers ;
+ // KeyModifiers unfortunately don't include btnState...
+// ev->modifiers = GetCurrentKeyModifiers() ;
+ }
+#endif
+ if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
+ {
+ wxKeyEvent event(wxEVT_KEY_DOWN);
+
+ event.m_shiftDown = ev->modifiers & shiftKey;
+ event.m_controlDown = ev->modifiers & controlKey;
+ event.m_altDown = ev->modifiers & optionKey;
+ event.m_metaDown = ev->modifiers & cmdKey;
+
+ event.m_x = ev->where.h;
+ event.m_y = ev->where.v;
+ event.m_timeStamp = ev->when;
+ wxWindow* focus = wxWindow::FindFocus() ;
+ event.SetEventObject(focus);
+
+ if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
+ {
+ event.m_keyCode = WXK_CONTROL ;
+ event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
+ {
+ event.m_keyCode = WXK_SHIFT ;
+ event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
+ {
+ event.m_keyCode = WXK_ALT ;
+ event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ s_lastModifiers = ev->modifiers ;
+ }
+}
+
void wxApp::MacHandleOneEvent( WXEVENTREF evr )
{
EventRecord* ev = (EventRecord*) evr ;
newWidth = oldWidth;
if (newHeight == 0)
newHeight = oldHeight;
- win->SetSize( -1, -1, newWidth, newHeight, wxSIZE_USE_EXISTING);
+ win->SetSize( -1, -1 , newWidth, newHeight, wxSIZE_USE_EXISTING);
}
}
s_lastMouseDown = 0;
if (win)
{
Rect tempRect ;
+ GrafPtr port ;
+ GetPort( &port ) ;
+ Point pt = { 0, 0 } ;
+ SetPortWindowPort(window) ;
+ LocalToGlobal( &pt ) ;
+ SetPort( port ) ;
GetWindowPortBounds(window, &tempRect ) ;
- win->SetSize( -1, -1, tempRect.right-tempRect.left ,
+ win->SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
}
}
{
window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
windowPart = inContent ;
- }
+ }
else
{
windowPart = ::FindWindow(ev->where, &window) ;
long retval = key ;
switch (key)
{
- case 0x01 :
+ case kHomeCharCode :
retval = WXK_HOME;
break;
- case 0x03 :
+ case kEnterCharCode :
retval = WXK_RETURN;
break;
- case 0x04 :
+ case kEndCharCode :
retval = WXK_END;
break;
- case 0x05 :
+ case kHelpCharCode :
retval = WXK_HELP;
break;
- case 0x08 :
+ case kBackspaceCharCode :
retval = WXK_BACK;
break;
- case 0x09 :
+ case kTabCharCode :
retval = WXK_TAB;
break;
- case 0x0b :
+ case kPageUpCharCode :
retval = WXK_PAGEUP;
break;
- case 0x0c :
+ case kPageDownCharCode :
retval = WXK_PAGEDOWN;
break;
- case 0x0d :
+ case kReturnCharCode :
retval = WXK_RETURN;
break;
- case 0x10 :
+ case kFunctionKeyCharCode :
{
switch( code )
{
}
}
break ;
- case 0x1b :
+ case kEscapeCharCode :
retval = WXK_ESCAPE ;
break ;
- case 0x1c :
+ case kLeftArrowCharCode :
retval = WXK_LEFT ;
break ;
- case 0x1d :
+ case kRightArrowCharCode :
retval = WXK_RIGHT ;
break ;
- case 0x1e :
+ case kUpArrowCharCode :
retval = WXK_UP ;
break ;
- case 0x1f :
+ case kDownArrowCharCode :
retval = WXK_DOWN ;
break ;
- case 0x7F :
+ case kDeleteCharCode :
retval = WXK_DELETE ;
default:
break ;
if ( HiWord( menuresult ) )
{
if ( !s_macIsInModalLoop )
- MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
}
else
{
- short keycode ;
- short keychar ;
- keychar = short(ev->message & charCodeMask);
- keycode = short(ev->message & keyCodeMask) >> 8 ;
- long keyval = wxMacTranslateKey(keychar, keycode) ;
- bool handled = false ;
- wxWindow* focus = wxWindow::FindFocus() ;
- if ( focus )
+ wxWindow* focus = wxWindow::FindFocus() ;
+
+ if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
{
-
- wxKeyEvent event(wxEVT_KEY_DOWN);
- event.m_shiftDown = ev->modifiers & shiftKey;
- event.m_controlDown = ev->modifiers & controlKey;
- event.m_altDown = ev->modifiers & optionKey;
- event.m_metaDown = ev->modifiers & cmdKey;
- event.m_keyCode = keyval;
- event.m_x = ev->where.h;
- event.m_y = ev->where.v;
- event.m_timeStamp = ev->when;
- event.SetEventObject(focus);
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
- if ( !handled )
+ // has not been handled -> perform default
+ wxControl* control = wxDynamicCast( focus , wxControl ) ;
+ if ( control && control->GetMacControl() != NULL )
{
+ short keycode ;
+ short keychar ;
+ keychar = short(ev->message & charCodeMask);
+ keycode = short(ev->message & keyCodeMask) >> 8 ;
+ ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
+ }
+ }
+ }
+}
+
+bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
+{
+ if ( !focus )
+ return false ;
+
+ short keycode ;
+ short keychar ;
+ keychar = short(keymessage & charCodeMask);
+ keycode = short(keymessage & keyCodeMask) >> 8 ;
+
+ if ( modifiers & ( controlKey|shiftKey|optionKey ) )
+ {
+ // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
+ // and look at the character after
+ UInt32 state = 0;
+ UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
+ keychar = short(keyInfo & charCodeMask);
+ keycode = short(keyInfo & keyCodeMask) >> 8 ;
+ }
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
+ long realkeyval = keyval ;
+ if ( keyval == keychar )
+ {
+ // 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)
+ realkeyval = short(keymessage & charCodeMask) ;
+ keyval = wxToupper( keyval ) ;
+ }
+
+ wxKeyEvent event(wxEVT_KEY_DOWN);
+ bool handled = false ;
+ event.m_shiftDown = modifiers & shiftKey;
+ event.m_controlDown = modifiers & controlKey;
+ event.m_altDown = modifiers & optionKey;
+ event.m_metaDown = modifiers & cmdKey;
+ event.m_keyCode = keyval ;
+
+ event.m_x = wherex;
+ event.m_y = wherey;
+ event.m_timeStamp = when;
+ event.SetEventObject(focus);
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ if ( handled && event.GetSkipped() )
+ handled = false ;
+ if ( !handled )
+ {
#if wxUSE_ACCEL
- if (!handled)
+ if (!handled)
+ {
+ wxWindow *ancestor = focus;
+ while (ancestor)
+ {
+ int command = ancestor->GetAcceleratorTable()->GetCommand( event );
+ if (command != -1)
{
- /*
- wxWindow *ancestor = focus;
- while (ancestor)
- {
- int command = ancestor->GetAcceleratorTable()->GetCommand( event );
- if (command != -1)
- {
- wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
- break;
- }
- if (ancestor->m_isFrame)
- break;
- ancestor = ancestor->GetParent();
- }
- */
+ wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
+ handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ break;
}
-#endif // wxUSE_ACCEL
- }
- if (!handled)
- {
- wxKeyEvent event(wxEVT_CHAR);
- event.m_shiftDown = ev->modifiers & shiftKey;
- event.m_controlDown = ev->modifiers & controlKey;
- event.m_altDown = ev->modifiers & optionKey;
- event.m_metaDown = ev->modifiers & cmdKey;
- event.m_keyCode = keyval;
- event.m_x = ev->where.h;
- event.m_y = ev->where.v;
- event.m_timeStamp = ev->when;
- event.SetEventObject(focus);
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
- }
- if ( !handled &&
- (keyval == WXK_TAB) &&
- (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
- (focus->GetParent()) &&
- (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
- {
- wxNavigationKeyEvent new_event;
- new_event.SetEventObject( focus );
- new_event.SetDirection( !event.ShiftDown() );
- /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
- new_event.SetWindowChange( event.ControlDown() );
- new_event.SetCurrentFocus( focus );
- handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ if (ancestor->IsTopLevel())
+ break;
+ ancestor = ancestor->GetParent();
}
}
- if ( !handled )
- {
- // if window is not having a focus still testing for default enter or cancel
- // TODO add the UMA version for ActiveNonFloatingWindow
- focus = wxFindWinFromMacWindow( FrontWindow() ) ;
+#endif // wxUSE_ACCEL
+ }
+ if (!handled)
+ {
+ event.Skip( FALSE ) ;
+ event.SetEventType( wxEVT_CHAR ) ;
+ // raw value again
+ event.m_keyCode = realkeyval ;
+
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ if ( handled && event.GetSkipped() )
+ handled = false ;
+ }
+ if ( !handled &&
+ (keyval == WXK_TAB) &&
+// CS: copied the change below from wxGTK
+// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
+// have this style, yet choose not to process this particular TAB in which
+// case TAB must still work as a navigational character
+#if 0
+ (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
+#endif
+ (focus->GetParent()) &&
+ (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
+ {
+ wxNavigationKeyEvent new_event;
+ new_event.SetEventObject( focus );
+ new_event.SetDirection( !event.ShiftDown() );
+ /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
+ new_event.SetWindowChange( event.ControlDown() );
+ new_event.SetCurrentFocus( focus );
+ handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ if ( handled && new_event.GetSkipped() )
+ handled = false ;
+ }
+ // backdoor handler for default return and command escape
+ if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
+ {
+ // if window is not having a focus still testing for default enter or cancel
+ // TODO add the UMA version for ActiveNonFloatingWindow
+ wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
if ( focus )
{
if ( keyval == WXK_RETURN )
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
- return ;
+ return true ;
}
}
/* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
- else if (keyval == WXK_ESCAPE || (keyval == '.' && ev->modifiers & cmdKey ) )
+ else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
{
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( focus );
handled = focus->GetEventHandler()->ProcessEvent( new_event );
}
}
- }
}
+ return handled ;
}
+
void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
{
EventRecord* ev = (EventRecord*) evr ;
}
else
{
- short keycode ;
- short keychar ;
- keychar = short(ev->message & charCodeMask);
- keycode = short(ev->message & keyCodeMask) >> 8 ;
-
- wxWindow* focus = wxWindow::FindFocus() ;
- if ( focus )
- {
- long keyval = wxMacTranslateKey(keychar, keycode) ;
-
- wxKeyEvent event(wxEVT_KEY_UP);
- event.m_shiftDown = ev->modifiers & shiftKey;
- event.m_controlDown = ev->modifiers & controlKey;
- event.m_altDown = ev->modifiers & optionKey;
- event.m_metaDown = ev->modifiers & cmdKey;
- event.m_keyCode = keyval;
- event.m_x = ev->where.h;
- event.m_y = ev->where.v;
- event.m_timeStamp = ev->when;
- event.SetEventObject(focus);
- bool handled = focus->GetEventHandler()->ProcessEvent( event ) ;
- }
+ MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
}
}
+bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
+{
+ if ( !focus )
+ return false ;
+
+ short keycode ;
+ short keychar ;
+ keychar = short(keymessage & charCodeMask);
+ keycode = short(keymessage & keyCodeMask) >> 8 ;
+ if ( modifiers & ( controlKey|shiftKey|optionKey ) )
+ {
+ // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
+ // and look at the character after
+ UInt32 state = 0;
+ UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
+ keychar = short(keyInfo & charCodeMask);
+ keycode = short(keyInfo & keyCodeMask) >> 8 ;
+ }
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
+
+ if ( keyval == keychar )
+ {
+ keyval = wxToupper( keyval ) ;
+ }
+ bool handled = false ;
+
+ wxKeyEvent event(wxEVT_KEY_UP);
+ event.m_shiftDown = modifiers & shiftKey;
+ event.m_controlDown = modifiers & controlKey;
+ event.m_altDown = modifiers & optionKey;
+ event.m_metaDown = modifiers & cmdKey;
+ event.m_keyCode = keyval ;
+
+ event.m_x = wherex;
+ event.m_y = wherey;
+ event.m_timeStamp = when;
+ event.SetEventObject(focus);
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+
+ return handled ;
+}
void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
{
EventRecord* ev = (EventRecord*) evr ;
wxWindow* currentMouseWindow = NULL ;
- wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
- ¤tMouseWindow ) ;
+ if (s_captureWindow )
+ {
+ currentMouseWindow = s_captureWindow ;
+ }
+ else
+ {
+ wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
+ ¤tMouseWindow ) ;
+ }
+
if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
{
wxMouseEvent event ;
event.m_y = ev->where.v;
event.m_timeStamp = ev->when;
event.SetEventObject(this);
-
+
if ( wxWindow::s_lastMouseWindow )
{
wxMouseEvent eventleave(event);
eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
-
+
wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
}
if ( currentMouseWindow )
wxWindow::s_lastMouseWindow = currentMouseWindow ;
}
- short windowPart = ::FindWindow(ev->where, &window);
-
+ short windowPart = inNoWindow ;
+
+ if ( s_captureWindow )
+ {
+ window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
+ windowPart = inContent ;
+ }
+ else
+ {
+ windowPart = ::FindWindow(ev->where, &window);
+ }
+
switch (windowPart)
{
- // fixes for setting the cursor back from dominic mazzoni
- case inMenuBar :
- UMAShowArrowCursor();
- break ;
- case inSysWindow :
- UMAShowArrowCursor();
- break ;
- default:
+ case inContent :
{
- // if ( s_lastMouseDown == 0 )
- // ev->modifiers |= btnState ;
-
- // Calling GetNextEvent with a zero event mask will always
- // pass back a null event. However, it fills the EventRecord
- // with the state of the modifier keys. This is needed since
- // the modifier state returned by WaitForNextEvent often is
- // wrong mouse move events. The attempt above to correct this
- // didn't always work (under OS X at least).
-
- EventRecord tmp;
- ::GetNextEvent(0, &tmp);
- ev->modifiers = tmp.modifiers;
-
wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
win->MacMouseMoved( ev , windowPart ) ;
else
- UMAShowArrowCursor();
-
+ {
+ if ( wxIsBusy() )
+ {
+ }
+ else
+ UMAShowArrowCursor();
+ }
}
break;
+ default :
+ {
+ if ( wxIsBusy() )
+ {
+ }
+ else
+ UMAShowArrowCursor();
+ }
+ break ;
}
}
break ;
projects / wxWidgets.git / blobdiff