#include "wx/tooltip.h"
#include "wx/textctrl.h"
#include "wx/menu.h"
+#include "wx/docview.h"
+
#if wxUSE_WX_RESOURCES
# include "wx/resource.h"
#endif
extern wxList *wxWinMacWindowList;
extern wxList *wxWinMacControlList;
+static bool s_inYield = FALSE;
+
wxApp *wxTheApp = NULL;
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
- EVT_END_SESSION(wxApp::OnEndSession)
- EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
+ EVT_END_SESSION(wxApp::OnEndSession)
+ EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
END_EVENT_TABLE()
#endif
bool wxApp::s_macDefaultEncodingIsPC = true ;
bool wxApp::s_macSupportPCMenuShortcuts = true ;
long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
+long wxApp::s_macPreferencesMenuItemId = 0 ;
+long wxApp::s_macExitMenuItemId = wxID_EXIT ;
wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
+//----------------------------------------------------------------------
+// Core Apple Event Support
+//----------------------------------------------------------------------
+
pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
pascal OSErr AEHandlePDoc( 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 WXUNUSED(refcon) )
{
- // GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
}
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 WXUNUSED(refcon) )
{
- // GD: UNUSED wxApp* app = (wxApp*) refcon ;
return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
}
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 WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
+// AEODoc Calls MacOpenFile on each of the files 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 ;
+
+ 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;
+}
+
+// AEPDoc Calls MacPrintFile on each of the files passed
+
+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::MacHandleAEPDoc(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
-{
- return noErr ;
-}
+// AEOApp calls MacNewFile
short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
+ MacNewFile() ;
return noErr ;
}
+// AEQuit attempts to quite the application
+
short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
wxWindow* win = GetTopWindow() ;
return noErr ;
}
+//----------------------------------------------------------------------
+// Support Routines linking the Mac...File Calls to the Document Manager
+//----------------------------------------------------------------------
+
+void wxApp::MacOpenFile(const wxString & fileName )
+{
+ wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+ if ( dm )
+ dm->CreateDocument(fileName , wxDOC_SILENT ) ;
+}
+
+void wxApp::MacPrintFile(const wxString & fileName )
+{
+ wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+ if ( dm )
+ {
+ wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
+ if ( doc )
+ {
+ wxView* view = doc->GetFirstView() ;
+ if( view )
+ {
+ wxPrintout *printout = view->OnCreatePrintout();
+ if (printout)
+ {
+ wxPrinter printer;
+ printer.Print(view->GetFrame(), printout, TRUE);
+ delete printout;
+ }
+ }
+ if (doc->Close())
+ {
+ doc->DeleteAllViews();
+ dm->RemoveDocument(doc) ;
+ }
+ }
+ }
+}
+
+void wxApp::MacNewFile()
+{
+}
+
char StringMac[] = "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
"\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
}
}
+//----------------------------------------------------------------------
+// Carbon Event Handler
+//----------------------------------------------------------------------
+
+#if TARGET_CARBON
+
+ static const EventTypeSpec eventList[] =
+ {
+ { kEventClassCommand, kEventProcessCommand } ,
+ { kEventClassCommand, kEventCommandUpdateStatus } ,
+ { kEventClassApplication , kEventAppActivated } ,
+ { kEventClassApplication , kEventAppDeactivated } ,
+ } ;
+
+static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+
+ HICommand command ;
+
+ GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL,
+ sizeof( HICommand ), NULL, &command );
+
+ MenuCommand id = command.commandID ;
+ if ( id == kHICommandPreferences )
+ id = wxApp::s_macPreferencesMenuItemId ;
+
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ wxMenu* menu = NULL ;
+ wxMenuItem* item = NULL ;
+
+ if ( mbar )
+ item = mbar->FindItem( id , &menu ) ;
+
+ if ( item == NULL || menu == NULL || mbar == NULL )
+ return result ;
+
+ switch( GetEventKind( event ) )
+ {
+ case kEventProcessCommand :
+ {
+ if (item->IsCheckable())
+ {
+ item->Check( !item->IsChecked() ) ;
+ }
+
+ menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventCommandUpdateStatus:
+ // eventually trigger an updateui round
+ result = noErr ;
+ break ;
+ default :
+ break ;
+ }
+
+ return result ;
+}
+
+static pascal OSStatus ApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+ switch ( GetEventKind( event ) )
+ {
+ case kEventAppActivated :
+ {
+ wxTheApp->MacResume( true ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventAppDeactivated :
+ {
+ wxTheApp->MacSuspend( true ) ;
+ result = noErr ;
+ }
+ break ;
+ default :
+ break ;
+ }
+ return result ;
+}
+
+pascal OSStatus wxAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+ switch( GetEventClass( event ) )
+ {
+ case kEventClassCommand :
+ result = CommandEventHandler( handler , event , data ) ;
+ break ;
+ case kEventClassApplication :
+ result = ApplicationEventHandler( handler , event , data ) ;
+ break ;
+
+ default :
+ break ;
+ }
+
+ return result ;
+}
+
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler )
+
+#endif
+
#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
// we know it's there ;-)
WXIMPORT char std::__throws_bad_alloc ;
// __wxinitialize in Mach-O shared libraries
wxStAppResource::OpenSharedLibraryResource(NULL);
#endif
-
-#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
- AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
- NewAEEventHandlerUPP(AEHandleODoc) ,
- (long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
- NewAEEventHandlerUPP(AEHandleOApp) ,
- (long) wxTheApp , FALSE ) ;
- AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
- NewAEEventHandlerUPP(AEHandlePDoc) ,
- (long) wxTheApp , FALSE ) ;
- 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 ) ;
-#endif
#ifndef __DARWIN__
// test the minimal configuration necessary
#ifndef __DARWIN__
// now avoid exceptions thrown for new (bad_alloc)
- std::__throws_bad_alloc = FALSE ;
+ // FIXME CS for some changes outside wxMac does not compile anymore
+#if 0
+ std::__throws_bad_alloc = 0 ;
+#endif
+
#endif
s_macCursorRgn = ::NewRgn() ;
wxBuffer = new char[BUFSIZ + 512];
-
+
wxClassInfo::InitializeClasses();
#if wxUSE_RESOURCES
#if wxUSE_THREADS
wxPendingEventsLocker = new wxCriticalSection;
#endif
-
+
wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
wxTheColourDatabase->Initialize();
wxMacCreateNotifierTable() ;
-
UMAShowArrowCursor() ;
return TRUE;
}
+bool wxApp::OnInitGui()
+{
+ if( !wxAppBase::OnInitGui() )
+ return false ;
+
+#if TARGET_CARBON
+ InstallApplicationEventHandler(
+ GetwxAppEventHandlerUPP(),
+ GetEventTypeCount(eventList), eventList, wxTheApp, &((EventHandlerRef)wxTheApp->m_macEventHandler));
+#endif
+
+#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerUPP(AEHandleODoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerUPP(AEHandleOApp) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerUPP(AEHandlePDoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerUPP(AEHandleQuit) ,
+ 0 , FALSE ) ;
+#else
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerProc(AEHandleODoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerProc(AEHandleOApp) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerProc(AEHandlePDoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerProc(AEHandleQuit) ,
+ 0 , FALSE ) ;
+#endif
+
+ return TRUE ;
+}
+
void wxApp::CleanUp()
{
wxToolTip::RemoveToolTips() ;
delete wxWinMacControlList ;
}
delete wxPendingEvents;
-
+
#if wxUSE_THREADS
delete wxPendingEventsLocker;
// If we don't do the following, we get an apparent memory leak.
// __wxterminate in Mach-O shared libraries
wxStAppResource::CloseSharedLibraryResource();
#endif
-
+
UMACleanupToolbox() ;
if (s_macCursorRgn) {
::DisposeRgn((RgnHandle)s_macCursorRgn);
}
-
+
#if 0
TerminateAE() ;
#endif
if ( initBlock != NULL ) {
const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
FSSpec *fileSpec = NULL;
-
+
if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
fileSpec = theInitBlock->fragLocator.u.onDisk.fileSpec;
}
else if (theInitBlock->fragLocator.where == kResourceCFragLocator) {
fileSpec = theInitBlock->fragLocator.u.inSegs.fileSpec;
}
-
+
if (fileSpec != NULL) {
gSharedLibraryResource = FSpOpenResFile(fileSpec, fsRdPerm);
}
NSSymbol theSymbol;
NSModule theModule;
const char *theLibPath;
-
+
gSharedLibraryBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
if (gSharedLibraryBundle != NULL) {
// wxWindows has been bundled into a framework
// load the framework resources
-
+
gSharedLibraryResource = CFBundleOpenBundleResourceMap(gSharedLibraryBundle);
}
else {
char *theExt;
FSRef theResRef;
OSErr theErr = noErr;
-
+
// get the library path
theSymbol = NSLookupAndBindSymbol("_gSharedLibraryResource");
theModule = NSModuleForSymbol(theSymbol);
theLibPath = NSLibraryNameForModule(theModule);
+ wxLogDebug( wxT("wxMac library installation name is '%s'"),
+ theLibPath );
+
// allocate copy to replace .dylib.* extension with .rsrc
theResPath = strdup(theLibPath);
if (theResPath != NULL) {
theExt = strstr(theName, ".dylib");
// overwrite extension with ".rsrc"
strcpy(theExt, ".rsrc");
-
- wxLogDebug( theResPath );
+
+ wxLogDebug( wxT("wxMac resources file name is '%s'"),
+ 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);
}
+ if (theErr != noErr) {
+ wxLogDebug( wxT("unable to open wxMac resource file '%s'"),
+ theResPath );
+ }
+
+ // free duplicated resource file path
+ free(theResPath);
}
}
#endif /* __DARWIN__ */
CloseResFile(gSharedLibraryResource);
}
gSharedLibraryResource = kResFileNotOpened;
- }
+ }
#endif /* WXMAKINGDLL */
}
// application (otherwise applications would need to handle it)
if (argc > 1) {
- char theArg[6] = "";
- strncpy(theArg, argv[1], 5);
-
- if (strcmp(theArg, "-psn_") == 0) {
+ if (strncmp(argv[1], "-psn_", 5) == 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
case kEventClassKeyboard :
{
converted = true ;
- switch( GetEventKind(event) )
+ switch( GetEventKind(event) )
{
case kEventRawKeyDown :
rec->what = keyDown ;
break ;
}
}
-
+
return converted ;
}
+/*
pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
OSStatus result = eventNotHandledErr ;
-
+
EventRecord rec ;
switch ( GetEventClass( event ) )
{
}
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;
}
int wxApp::MainLoop()
{
- m_keepGoing = TRUE;
+ m_keepGoing = TRUE;
- while (m_keepGoing)
- {
- MacDoOneEvent() ;
- }
+ while (m_keepGoing)
+ {
+ MacDoOneEvent() ;
+ }
- return 0;
+ return 0;
}
// Returns TRUE if more time is needed.
bool wxApp::Yield(bool onlyIfNeeded)
{
- static bool s_inYield = FALSE;
-
if (s_inYield)
{
if ( !onlyIfNeeded )
void wxApp::MacSuspend( bool convertClipboard )
{
+#if !TARGET_CARBON
// we have to deactive the top level windows manually
wxNode* node = wxTopLevelWindows.First();
while (node)
{
wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
- win->MacActivate( MacGetCurrentEvent() , false ) ;
+ win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
node = node->Next();
}
-
+
+ ::HideFloatingWindows() ;
+#endif
s_lastMouseDown = 0 ;
+
if( convertClipboard )
{
MacConvertPrivateToPublicScrap() ;
}
-
- ::HideFloatingWindows() ;
}
extern wxList wxModalDialogs;
{
MacConvertPublicToPrivateScrap() ;
}
-
+
+#if !TARGET_CARBON
::ShowFloatingWindows() ;
-
// raise modal dialogs in case a non modal window was selected to activate the app
wxNode* node = wxModalDialogs.First();
{
wxDialog* dialog = (wxDialog *) node->Data();
dialog->Raise();
-
+
node = node->Next();
}
+#endif
}
void wxApp::MacConvertPrivateToPublicScrap()
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 == kHighLevelEvent ||
+ 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_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 ) ;
+ 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 ) ;
+ 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 ) ;
+ event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
focus->GetEventHandler()->ProcessEvent( event ) ;
}
s_lastModifiers = ev->modifiers ;
else
s_lastMouseDown = 1;
break;
+#if !TARGET_CARBON
case mouseUp:
if ( s_lastMouseDown == 2 )
{
case updateEvt:
MacHandleUpdateEvent( ev ) ;
break;
+#endif
case keyDown:
case autoKey:
MacHandleKeyDownEvent( ev ) ;
case keyUp:
MacHandleKeyUpEvent( ev ) ;
break;
+#if !TARGET_CARBON
case diskEvt:
MacHandleDiskEvent( ev ) ;
break;
case osEvt:
MacHandleOSEvent( ev ) ;
break;
+#endif
case kHighLevelEvent:
MacHandleHighLevelEvent( ev ) ;
break;
void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
{
+ // we must avoid reentrancy problems when processing high level events eg printing
+ bool former = s_inYield ;
+ s_inYield = TRUE ;
EventRecord* ev = (EventRecord*) evr ;
::AEProcessAppleEvent( ev ) ;
+ s_inYield = former ;
}
bool s_macIsInModalLoop = false ;
else
{
UInt32 menuresult = MenuSelect(ev->where) ;
- MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
+#if !TARGET_CARBON
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
+#endif
s_lastMouseDown = 0;
}
break ;
SystemClick( ev , window ) ;
s_lastMouseDown = 0;
break ;
-#endif
case inDrag :
if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
{
break;
case inGrow:
{
- int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
- if (growResult != 0)
+ Rect newContentRect ;
+ Rect constraintRect ;
+ constraintRect.top = win->GetMinHeight() ;
+ if ( constraintRect.top == -1 )
+ constraintRect.top = 0 ;
+ constraintRect.left = win->GetMinWidth() ;
+ if ( constraintRect.left == -1 )
+ constraintRect.left = 0 ;
+ constraintRect.right = win->GetMaxWidth() ;
+ if ( constraintRect.right == -1 )
+ constraintRect.right = 32000 ;
+ constraintRect.bottom = win->GetMaxHeight() ;
+ if ( constraintRect.bottom == -1 )
+ constraintRect.bottom = 32000 ;
+
+ Boolean growResult = ResizeWindow( window , ev->where ,
+ &constraintRect , &newContentRect ) ;
+ if ( growResult )
{
- int newWidth = LoWord(growResult);
- int newHeight = HiWord(growResult);
- int oldWidth, oldHeight;
-
-
- if (win)
- {
- win->GetSize(&oldWidth, &oldHeight);
- if (newWidth == 0)
- newWidth = oldWidth;
- if (newHeight == 0)
- newHeight = oldHeight;
- win->SetSize( -1, -1 , newWidth, newHeight, wxSIZE_USE_EXISTING);
- }
+ win->SetSize( newContentRect.left , newContentRect.top ,
+ newContentRect.right - newContentRect.left ,
+ newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
}
s_lastMouseDown = 0;
}
win->MacMouseDown( ev , windowPart ) ;
}
break ;
-
+#endif
default:
break;
}
}
+#if !TARGET_CARBON
+
void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
{
EventRecord* ev = (EventRecord*) evr ;
{
window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
windowPart = inContent ;
- }
+ }
else
{
windowPart = ::FindWindow(ev->where, &window) ;
}
}
+#endif
+
long wxMacTranslateKey(unsigned char key, unsigned char code) ;
long wxMacTranslateKey(unsigned char key, unsigned char code)
{
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 ;
EventRecord* ev = (EventRecord*) evr ;
wxToolTip::RemoveToolTips() ;
+#if !TARGET_CARBON
UInt32 menuresult = UMAMenuEvent(ev) ;
if ( HiWord( menuresult ) )
{
MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
}
else
+#endif
{
- short keycode ;
- short keychar ;
- keychar = short(ev->message & charCodeMask);
- keycode = short(ev->message & keyCodeMask) >> 8 ;
- wxWindow* focus = wxWindow::FindFocus() ;
- // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
- if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
- {
- keychar += 0x40 ;
- }
- long keyval = wxMacTranslateKey(keychar, keycode) ;
-
- if ( MacSendKeyDownEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
+ wxWindow* focus = wxWindow::FindFocus() ;
+
+ if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
{
// 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 keyval , long modifiers , long when , short wherex , short wherey )
+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 = wxToupper(keyval );
+ event.m_keyCode = keyval ;
event.m_x = wherex;
event.m_y = wherey;
{
event.Skip( FALSE ) ;
event.SetEventType( wxEVT_CHAR ) ;
- event.m_keyCode = keyval ;
+ // raw value again
+ event.m_keyCode = realkeyval ;
handled = focus->GetEventHandler()->ProcessEvent( event ) ;
if ( handled && event.GetSkipped() )
}
else
{
- short keycode ;
- short keychar ;
- keychar = short(ev->message & charCodeMask);
- keycode = short(ev->message & keyCodeMask) >> 8 ;
- // it is wxWindows Convention to have Ctrl Key Combinations at ASCII char value
- if ( (ev->modifiers & controlKey) && keychar >= 0 && keychar < 0x20 )
- {
- keychar += 0x40 ;
- }
- long keyval = wxMacTranslateKey(keychar, keycode) ;
-
- wxWindow* focus = wxWindow::FindFocus() ;
- bool handled = MacSendKeyUpEvent( focus , keyval , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
- // we don't have to do anything under classic here
+ MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
}
}
-bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keyval , long modifiers , long when , short wherex , short wherey )
+bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
{
- bool handled = false ;
- if ( focus )
- {
- 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 = wxToupper(keyval );
-
- event.m_x = wherex;
- event.m_y = wherey;
- event.m_timeStamp = when;
- event.SetEventObject(focus);
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ 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 ;
}
+#if !TARGET_CARBON
void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
{
EventRecord* ev = (EventRecord*) evr ;
}
wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
if ( win )
- win->MacActivate( ev , activate ) ;
+ win->MacActivate( ev->when , activate ) ;
}
}
EventRecord* ev = (EventRecord*) evr ;
if ( HiWord( ev->message ) != noErr )
{
- #if !TARGET_CARBON
OSErr err ;
Point point ;
SetPt( &point , 100 , 100 ) ;
err = DIBadMount( point , ev->message ) ;
wxASSERT( err == noErr ) ;
-#endif
}
}
case suspendResumeMessage :
{
bool isResuming = ev->message & resumeFlag ;
-#if !TARGET_CARBON
bool convertClipboard = ev->message & convertClipboardFlag ;
-#else
- bool convertClipboard = false;
-#endif
+
bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
if ( isResuming )
{
{
wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
if ( win )
- win->MacActivate( ev , false ) ;
+ win->MacActivate( ev->when , false ) ;
}
if ( newFrontWindow )
{
wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
if ( win )
- win->MacActivate( ev , true ) ;
+ win->MacActivate( ev->when , true ) ;
}
}
else
{
MacSuspend( convertClipboard ) ;
-
- // in case this suspending did close an active window, another one might
- // have surfaced -> lets deactivate that one
-
-/* TODO : find out what to do on systems < 10 , perhaps FrontNonFloatingWindow
- WindowRef newActiveWindow = ::ActiveNonFloatingWindow() ;
- if ( newActiveWindow )
- {
- wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
- if ( win )
- win->MacActivate( ev , false ) ;
- }
-*/
}
}
break ;
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 ;
}
}
+#endif
+void wxApp::MacHandleMenuCommand( wxUint32 id )
+{
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ wxMenu* menu = NULL ;
+ wxMenuItem* item = NULL ;
+ if ( mbar )
+ {
+ item = mbar->FindItem( id , &menu ) ;
+ }
+ wxCHECK_RET( item != NULL && menu != NULL && mbar != NULL, wxT("error in menu item callback") );
+
+ if (item->IsCheckable())
+ {
+ item->Check( !item->IsChecked() ) ;
+ }
+
+ menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+}
+
+#if !TARGET_CARBON
void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
{
if (macMenuId == 0)
}
else
{
- wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() ) ;
- if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
- wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
+ MenuCommand id ;
+ GetMenuItemCommandID( GetMenuHandle(macMenuId) , macMenuItemNum , &id ) ;
+ MacHandleMenuCommand( id ) ;
}
HiliteMenu(0);
}
-
-/*
-long wxApp::MacTranslateKey(char key, int mods)
-{
-}
-
-void wxApp::MacAdjustCursor()
-{
-}
-
-*/
-/*
-void
-wxApp::macAdjustCursor()
-{
- if (ev->what != kHighLevelEvent)
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- if (!theMacWxFrame->MacAdjustCursor(ev->where))
- ::SetCursor(&(qd.arrow));
- }
- }
-}
-*/
+#endif
\ No newline at end of file
projects / wxWidgets.git / blobdiff