// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "app.h"
-#endif
-
#include "wx/wxprec.h"
#include "wx/window.h"
extern wxList wxPendingDelete;
-// set wxMAC_USE_RAEL to 1 if RunApplicationEventLoop should be used
-// if 0 the lower level CarbonEventLoop will be used
-// on the long run RAEL should replace the low level event loop
-// we will have to clean up event handling to make sure we don't
-// miss handling of things like pending events etc
-// perhaps we will also have to pipe events through an ueber-event-handler
-// to make sure we have one place to do all these house-keeping functions
-
-#define wxMAC_USE_RAEL 0
-
#if wxUSE_THREADS
extern size_t g_numberOfThreads;
-#endif // wxUSE_THREADS
+#endif
// statics for implementation
-
static bool s_inYield = false;
-
static bool s_inReceiveEvent = false ;
static EventTime sleepTime = kEventDurationNoWait ;
+
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
END_EVENT_TABLE()
-const short kMacMinHeap = (29 * 1024) ;
// platform specific static variables
-
+const short kMacMinHeap = (29 * 1024) ;
const short kwxMacMenuBarResource = 1 ;
const short kwxMacAppleMenuId = 1 ;
long wxApp::sm_lastMessageTime = 0;
long wxApp::s_lastModifiers = 0 ;
-
bool wxApp::s_macSupportPCMenuShortcuts = true ;
long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
long wxApp::s_macPreferencesMenuItemId = wxID_PREFERENCES ;
long wxApp::s_macExitMenuItemId = wxID_EXIT ;
wxString wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
-// Normally we're not a plugin
-bool wxApp::sm_isEmbedded = false;
+bool wxApp::sm_isEmbedded = false; // Normally we're not a plugin
+
//----------------------------------------------------------------------
// Core Apple Event Support
//----------------------------------------------------------------------
long itemsInList;
OSErr err;
short i;
+
err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
if (err != noErr)
return err;
PSN.lowLongOfPSN = kCurrentProcess ;
SetFrontProcess( &PSN ) ;
+ wxString fName ;
+ FSRef theRef ;
+
for (i = 1; i <= itemsInList; i++)
{
- wxString fName ;
-
- FSRef theRef ;
- AEGetNthPtr(&docList, i, typeFSRef, &keywd, &returnedType,
- (Ptr) & theRef, sizeof(theRef), &actualSize);
+ AEGetNthPtr(
+ &docList, i, typeFSRef, &keywd, &returnedType,
+ (Ptr)&theRef, sizeof(theRef), &actualSize);
fName = wxMacFSRefToPath( &theRef ) ;
MacOpenFile(fName);
}
+
return noErr;
}
long itemsInList;
OSErr err;
short i;
+
err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
if (err != noErr)
return err;
PSN.lowLongOfPSN = kCurrentProcess ;
SetFrontProcess( &PSN ) ;
- for (i = 1; i <= itemsInList; i++) {
- wxString fName ;
+ wxString fName ;
+ FSRef theRef ;
- FSRef theRef ;
- AEGetNthPtr(&docList, i, typeFSRef, &keywd, &returnedType,
- (Ptr) & theRef, sizeof(theRef), &actualSize);
+ for (i = 1; i <= itemsInList; i++)
+ {
+ AEGetNthPtr(
+ &docList, i, typeFSRef, &keywd, &returnedType,
+ (Ptr)&theRef, sizeof(theRef), &actualSize);
fName = wxMacFSRefToPath( &theRef ) ;
MacPrintFile(fName);
}
+
return noErr;
}
{
ExitMainLoop() ;
}
+
return noErr ;
}
short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
MacReopenApp() ;
+
return noErr ;
}
-
-
//----------------------------------------------------------------------
// Support Routines linking the Mac...File Calls to the Document Manager
//----------------------------------------------------------------------
if ( doc )
{
wxView* view = doc->GetFirstView() ;
- if( view )
+ if ( view )
{
wxPrintout *printout = view->OnCreatePrintout();
if (printout)
delete printout;
}
}
+
if (doc->Close())
{
doc->DeleteAllViews();
while (node)
{
wxTopLevelWindow* win = (wxTopLevelWindow*) node->GetData();
- if ( win->IsIconized() == false )
+ if ( !win->IsIconized() )
{
firstIconized = NULL ;
break ;
if ( firstIconized == NULL )
firstIconized = win ;
}
+
node = node->GetNext();
}
+
if ( firstIconized )
firstIconized->Iconize( false ) ;
}
}
+//----------------------------------------------------------------------
+// Macintosh CommandID support - converting between native and wx IDs
+//----------------------------------------------------------------------
+
+// if no native match they just return the passed-in id
+
+struct IdPair
+{
+ UInt32 macId ;
+ int wxId ;
+} ;
+
+IdPair gCommandIds [] =
+{
+ { kHICommandCut , wxID_CUT } ,
+ { kHICommandCopy , wxID_COPY } ,
+ { kHICommandPaste , wxID_PASTE } ,
+ { kHICommandSelectAll , wxID_SELECTALL } ,
+ { kHICommandClear , wxID_CLEAR } ,
+ { kHICommandUndo , wxID_UNDO } ,
+ { kHICommandRedo , wxID_REDO } ,
+} ;
+
+int wxMacCommandToId( UInt32 macCommandId )
+{
+ int wxid = 0 ;
+
+ switch ( macCommandId )
+ {
+ case kHICommandPreferences :
+ wxid = wxApp::s_macPreferencesMenuItemId ;
+ break ;
+
+ case kHICommandQuit :
+ wxid = wxApp::s_macExitMenuItemId ;
+ break ;
+
+ case kHICommandAbout :
+ wxid = wxApp::s_macAboutMenuItemId ;
+ break ;
+
+ default :
+ {
+ for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
+ {
+ if ( gCommandIds[i].macId == macCommandId )
+ {
+ wxid = gCommandIds[i].wxId ;
+ break ;
+ }
+ }
+ }
+ break ;
+ }
+
+ if ( wxid == 0 )
+ wxid = (int) macCommandId ;
+
+ return wxid ;
+}
+
+UInt32 wxIdToMacCommand( int wxId )
+{
+ UInt32 macId = 0 ;
+
+ if ( wxId == wxApp::s_macPreferencesMenuItemId )
+ macId = kHICommandPreferences ;
+ else if (wxId == wxApp::s_macExitMenuItemId)
+ macId = kHICommandQuit ;
+ else if (wxId == wxApp::s_macAboutMenuItemId)
+ macId = kHICommandAbout ;
+ else
+ {
+ for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
+ {
+ if ( gCommandIds[i].wxId == wxId )
+ {
+ macId = gCommandIds[i].macId ;
+ break ;
+ }
+ }
+ }
+
+ if ( macId == 0 )
+ macId = (int) wxId ;
+
+ return macId ;
+}
+
+wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
+{
+ wxMenu* itemMenu = NULL ;
+ int id = 0 ;
+
+ // for 'standard' commands which don't have a wx-menu
+ if ( command.commandID == kHICommandPreferences || command.commandID == kHICommandQuit || command.commandID == kHICommandAbout )
+ {
+ id = wxMacCommandToId( command.commandID ) ;
+
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ if ( mbar )
+ item = mbar->FindItem( id , &itemMenu ) ;
+ }
+ else if ( command.commandID != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
+ {
+ id = wxMacCommandToId( command.commandID ) ;
+ // make sure it is one of our own menus, or of the 'synthetic' apple and help menus , otherwise don't touch
+ MenuItemIndex firstUserHelpMenuItem ;
+ static MenuHandle mh = NULL ;
+ if ( mh == NULL )
+ {
+ if ( UMAGetHelpMenu( &mh , &firstUserHelpMenuItem) != noErr )
+ mh = NULL ;
+ }
+
+ // is it part of the application or the Help menu, then look for the id directly
+ if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
+ ( mh != NULL && command.menu.menuRef == mh ) )
+ {
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ if ( mbar )
+ item = mbar->FindItem( id , &itemMenu ) ;
+ }
+ else
+ {
+ UInt32 refCon ;
+
+ GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
+ itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
+ if ( itemMenu != NULL )
+ item = (wxMenuItem*) refCon ;
+ }
+ }
+
+ return itemMenu ;
+}
+
//----------------------------------------------------------------------
// Carbon Event Handler
//----------------------------------------------------------------------
case kEventMenuOpening:
type = wxEVT_MENU_OPEN;
break;
+
case kEventMenuClosed:
type = wxEVT_MENU_CLOSE;
break;
+
case kEventMenuTargetItem:
cmd = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
if (cmd != 0)
type = wxEVT_MENU_HIGHLIGHT;
break;
+
default:
wxFAIL_MSG(wxT("Unexpected menu event kind"));
break;
cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
wxMenuItem* item = NULL ;
- MenuCommand id = command.commandID ;
- // for items we don't really control
- if ( id == kHICommandPreferences )
- {
- id = wxApp::s_macPreferencesMenuItemId ;
-
- wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
- if ( mbar )
- {
- wxMenu* menu = NULL ;
- item = mbar->FindItem( id , &menu ) ;
- }
- }
- else if ( id != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
- {
- GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , (UInt32*) &item ) ;
- }
+ wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
+ int id = wxMacCommandToId( command.commandID ) ;
if ( item )
{
- switch( cEvent.GetKind() )
- {
- case kEventProcessCommand :
- {
+ wxASSERT( itemMenu != NULL ) ;
+
+ switch ( cEvent.GetKind() )
+ {
+ case kEventProcessCommand :
+ {
if (item->IsCheckable())
- {
item->Check( !item->IsChecked() ) ;
- }
- item->GetMenu()->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
- result = noErr ;
+ if ( itemMenu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) )
+ result = noErr ;
}
break ;
+
case kEventCommandUpdateStatus:
- // eventually trigger an updateui round
- result = noErr ;
+ {
+ wxUpdateUIEvent event(id);
+ event.SetEventObject( itemMenu );
+
+ bool processed = false;
+
+ // Try the menu's event handler
+ {
+ wxEvtHandler *handler = itemMenu->GetEventHandler();
+ if ( handler )
+ processed = handler->ProcessEvent(event);
+ }
+
+ // Try the window the menu was popped up from
+ // (and up through the hierarchy)
+ if ( !processed )
+ {
+ const wxMenuBase *menu = itemMenu;
+ while ( menu )
+ {
+ wxWindow *win = menu->GetInvokingWindow();
+ if ( win )
+ {
+ processed = win->GetEventHandler()->ProcessEvent(event);
+ break;
+ }
+
+ menu = menu->GetParent();
+ }
+ }
+
+ if ( processed )
+ {
+ // if anything changed, update the changed attribute
+ if (event.GetSetText())
+ itemMenu->SetLabel(id, event.GetText());
+ if (event.GetSetChecked())
+ itemMenu->Check(id, event.GetChecked());
+ if (event.GetSetEnabled())
+ itemMenu->Enable(id, event.GetEnabled());
+
+ result = noErr ;
+ }
+ }
break ;
+
default :
break ;
}
switch ( GetEventKind( event ) )
{
case kEventAppActivated :
- {
- if ( wxTheApp )
- wxTheApp->SetActive( true , NULL ) ;
- result = noErr ;
- }
+ if ( wxTheApp )
+ wxTheApp->SetActive( true , NULL ) ;
+ result = noErr ;
break ;
+
case kEventAppDeactivated :
- {
- if ( wxTheApp )
- wxTheApp->SetActive( false , NULL ) ;
- result = noErr ;
- }
+ if ( wxTheApp )
+ wxTheApp->SetActive( false , NULL ) ;
+ result = noErr ;
break ;
+
default :
break ;
}
+
return result ;
}
wxTheApp->MacSetCurrentEvent( event , handler ) ;
OSStatus result = eventNotHandledErr ;
- switch( GetEventClass( event ) )
+ switch ( GetEventClass( event ) )
{
case kEventClassCommand :
result = wxMacAppCommandEventHandler( handler , event , data ) ;
break ;
+
case kEventClassApplication :
result = wxMacAppApplicationEventHandler( handler , event , data ) ;
break ;
+
case kEventClassMenu :
result = wxMacAppMenuEventHandler( handler , event , data ) ;
break ;
+
case kEventClassMouse :
{
wxMacCarbonEvent cEvent( event ) ;
result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
}
break ;
+
case kEventClassAppleEvent :
{
EventRecord rec ;
+
wxMacConvertEventToRecord( event , &rec ) ;
result = AEProcessAppleEvent( &rec ) ;
}
break ;
+
default :
break ;
}
WXIMPORT char std::__throws_bad_alloc ;
#endif
-#if __WXDEBUG__
+#ifdef __WXDEBUG__
pascal static void wxMacAssertOutputHandler(OSType componentSignature, UInt32 options,
const char *assertionString, const char *exceptionLabelString,
wxString assertionStr ;
wxString exceptionStr ;
wxString errorStr ;
+
#if wxUSE_UNICODE
fileNameStr = wxString(fileName, wxConvLocal);
assertionStr = wxString(assertionString, wxConvLocal);
#else
wxOnAssert(fileNameStr, lineNumber , assertionStr ,
- wxString::Format( wxT("%s %s value (%p)") ,exceptionStr, errorStr , value ) ) ;
+ wxString::Format( wxT("%s %s value (%p)") , exceptionStr, errorStr , value ) ) ;
#endif
}
#endif //__WXDEBUG__
#ifdef __WXMAC_OSX__
-extern "C" {
- /* m_macEventPosted run loop source callback: */
+extern "C"
+{
+ // m_macEventPosted run loop source callback:
void macPostedEventCallback(void *unused);
}
-void macPostedEventCallback(void *unused) {
- wxTheApp->ProcessPendingEvents(); }
+void macPostedEventCallback(void *unused)
+{
+ wxTheApp->ProcessPendingEvents();
+}
#endif
bool wxApp::Initialize(int& argc, wxChar **argv)
{
// Mac-specific
-#if __WXDEBUG__
- InstallDebugAssertOutputHandler ( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
+#ifdef __WXDEBUG__
+ InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
#endif
+
UMAInitToolbox( 4, sm_isEmbedded ) ;
SetEventMask( everyEvent ) ;
UMAShowWatchCursor() ;
bool wxApp::OnInitGui()
{
- if( !wxAppBase::OnInitGui() )
+ if ( !wxAppBase::OnInitGui() )
return false ;
InstallStandardEventHandler( GetApplicationEventTarget() ) ;
#ifdef __WXMAC_OSX__
if (m_macEventPosted)
- {
CFRelease(m_macEventPosted);
- }
m_macEventPosted = NULL;
#endif
#endif
UMACleanupToolbox() ;
- if (s_macCursorRgn) {
+ if (s_macCursorRgn)
::DisposeRgn((RgnHandle)s_macCursorRgn);
- }
if (!sm_isEmbedded)
- {
RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
- }
if (!sm_isEmbedded)
{
// ref num upon initializing and releasing when terminating, therefore
// the __wxinitialize and __wxterminate must be used
-extern "C" {
- void __sinit(void); /* (generated by linker) */
+extern "C"
+{
+ void __sinit(void); // (generated by linker)
pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
pascal void __terminate(void);
}
bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
{
- bool converted = ConvertEventRefToEventRecord( event,rec) ;
OSStatus err = noErr ;
+ bool converted = ConvertEventRefToEventRecord( event, rec) ;
+
if ( !converted )
{
- switch( GetEventClass( event ) )
+ switch ( GetEventClass( event ) )
{
case kEventClassKeyboard :
{
converted = true ;
- switch( GetEventKind(event) )
+ 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 ;
}
}
break ;
+
case kEventClassTextInput :
{
- switch( GetEventKind( event ) )
+ switch ( GetEventKind( event ) )
{
case kEventTextInputUnicodeForKeyEvent :
{
EventRef rawEvent ;
- err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
+ err = GetEventParameter(
+ event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL,
+ sizeof(rawEvent), NULL, &rawEvent ) ;
converted = true ;
+
{
- UInt32 keyCode ;
+ UInt32 keyCode, modifiers;
unsigned char charCode ;
- UInt32 modifiers ;
+
GetMouse( &rec->where) ;
rec->what = keyDown ;
err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
rec->message = (keyCode << 8 ) + charCode ;
}
}
- break ;
+ break ;
+
default :
break ;
}
}
break ;
+
+ default :
+ break ;
}
}
m_macCurrentEvent = NULL ;
m_macCurrentEventHandlerCallRef = NULL ;
+
#ifdef __WXMAC_OSX__
m_macEventPosted = NULL ;
#endif
}
-int wxApp::MainLoop()
-{
- m_keepGoing = true;
-#if wxMAC_USE_RAEL
- RunApplicationEventLoop() ;
-#else
- while (m_keepGoing)
- {
- MacDoOneEvent() ;
- }
-#endif
- return 0;
-}
-
-void wxApp::ExitMainLoop()
-{
- m_keepGoing = false;
-#if wxMAC_USE_RAEL
- QuitApplicationEventLoop() ;
-#endif
-}
-
-// Is a message/event pending?
-bool wxApp::Pending()
-{
- // without the receive event (with pull param = false ) nothing is ever reported
- EventRef theEvent;
- ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &theEvent);
- return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
-}
-
-// Dispatch a message.
-bool wxApp::Dispatch()
-{
- MacDoOneEvent() ;
-
- return true;
-}
-
void wxApp::OnIdle(wxIdleEvent& event)
{
wxAppBase::OnIdle(event);
// wxPostEvent() functions
wxMacProcessNotifierAndPendingEvents();
- if(!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
+ if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
}
CFRunLoopSourceSignal(m_macEventPosted);
}
#endif
- wxMacWakeUp() ;
-}
-void wxApp::Exit()
-{
- wxApp::CleanUp();
- ::ExitToShell() ;
+ wxMacWakeUp() ;
}
void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
EventRef theEvent;
OSStatus status = noErr ;
- do
+
+ while ( status == noErr )
{
s_inReceiveEvent = true ;
status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
MacHandleOneEvent( theEvent ) ;
ReleaseEvent(theEvent);
}
- } while( status == noErr ) ;
+ }
wxMacProcessNotifierAndPendingEvents() ;
s_inYield = false;
EventRef theEvent;
s_inReceiveEvent = true ;
- OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
+ OSStatus status = ReceiveNextEvent(0, NULL, sleepTime, true, &theEvent) ;
s_inReceiveEvent = false ;
- if ( status == eventLoopTimedOutErr )
+
+ switch (status)
{
- if ( wxTheApp->ProcessIdle() )
+ case eventLoopTimedOutErr :
+ if ( wxTheApp->ProcessIdle() )
+ sleepTime = kEventDurationNoWait ;
+ else
+ sleepTime = kEventDurationSecond;
+ break;
+
+ case eventLoopQuitErr :
+ // according to QA1061 this may also occur
+ // when a WakeUp Process is executed
+ break;
+
+ default:
+ MacHandleOneEvent( theEvent ) ;
+ ReleaseEvent( theEvent );
sleepTime = kEventDurationNoWait ;
- else
- sleepTime = kEventDurationSecond;
- }
- else if ( status == eventLoopQuitErr )
- {
- // according to QA1061 this may also occur when a WakeUp Process
- // is executed
- }
- else
- {
- MacHandleOneEvent( theEvent ) ;
- ReleaseEvent(theEvent);
- sleepTime = kEventDurationNoWait ;
+ break;
}
// repeaters
wxMacProcessNotifierAndPendingEvents() ;
}
-/*virtual*/ void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
+// virtual
+void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
{
// Override to process unhandled events as you please
}
EventTargetRef theTarget;
theTarget = GetEventDispatcherTarget();
m_macCurrentEvent = evr ;
- OSStatus status = SendEventToEventTarget ((EventRef) evr , theTarget);
- if(status == eventNotHandledErr)
- {
+
+ OSStatus status = SendEventToEventTarget((EventRef) evr , theTarget);
+ if (status == eventNotHandledErr)
MacHandleUnhandledEvent(evr);
- }
+
wxMacProcessNotifierAndPendingEvents() ;
+
#if wxUSE_THREADS
wxMutexGuiLeaveOrEnter();
#endif // wxUSE_THREADS
case kFunctionKeyCharCode :
{
- switch( code )
+ switch ( code )
{
case 0x7a :
retval = WXK_F1 ;
break;
+
case 0x78 :
retval = WXK_F2 ;
break;
+
case 0x63 :
retval = WXK_F3 ;
break;
+
case 0x76 :
retval = WXK_F4 ;
break;
+
case 0x60 :
retval = WXK_F5 ;
break;
+
case 0x61 :
retval = WXK_F6 ;
break;
+
case 0x62:
retval = WXK_F7 ;
break;
+
case 0x64 :
retval = WXK_F8 ;
break;
+
case 0x65 :
retval = WXK_F9 ;
break;
+
case 0x6D :
retval = WXK_F10 ;
break;
+
case 0x67 :
retval = WXK_F11 ;
break;
+
case 0x6F :
retval = WXK_F12 ;
break;
+
case 0x69 :
retval = WXK_F13 ;
break;
+
case 0x6B :
retval = WXK_F14 ;
break;
+
case 0x71 :
retval = WXK_F15 ;
break;
+
+ default:
+ break;
}
}
break ;
#endif
-bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
+wxMouseState wxGetMouseState()
+{
+ wxMouseState ms;
+
+ wxPoint pt = wxGetMousePosition();
+ ms.SetX(pt.x);
+ ms.SetY(pt.y);
+
+ UInt32 buttons = GetCurrentButtonState();
+ ms.SetLeftDown( (buttons & 0x01) != 0 );
+ ms.SetMiddleDown( (buttons & 0x04) != 0 );
+ ms.SetRightDown( (buttons & 0x02) != 0 );
+
+ UInt32 modifiers = GetCurrentKeyModifiers();
+ ms.SetControlDown(modifiers & controlKey);
+ ms.SetShiftDown(modifiers & shiftKey);
+ ms.SetAltDown(modifiers & optionKey);
+ ms.SetMetaDown(modifiers & cmdKey);
+
+ return ms;
+}
+
+
+bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
{
if ( !focus )
return false ;
UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
keychar = short(keyInfo & charCodeMask);
}
+
long keyval = wxMacTranslateKey(keychar, keycode) ;
long realkeyval = keyval ;
if ( keyval == keychar )
case 76 :
keyval = WXK_NUMPAD_ENTER;
break;
+
case 81:
keyval = WXK_NUMPAD_EQUAL;
break;
+
case 67:
keyval = WXK_NUMPAD_MULTIPLY;
break;
+
case 75:
keyval = WXK_NUMPAD_DIVIDE;
break;
+
case 78:
keyval = WXK_NUMPAD_SUBTRACT;
break;
+
case 69:
keyval = WXK_NUMPAD_ADD;
break;
+
case 65:
keyval = WXK_NUMPAD_DECIMAL;
break;
+
+ default:
+ break;
} // end switch
}
event.m_altDown = modifiers & optionKey;
event.m_metaDown = modifiers & cmdKey;
event.m_keyCode = keyval ;
+
#if wxUSE_UNICODE
event.m_uniChar = uniChar ;
#endif
+
event.m_rawCode = keymessage;
event.m_rawFlags = modifiers;
event.m_x = wherex;
handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
break;
}
+
if (ancestor->IsTopLevel())
break;
+
ancestor = ancestor->GetParent();
}
}
{
event.Skip( false ) ;
event.SetEventType( wxEVT_CHAR ) ;
+
// raw value again
event.m_keyCode = realkeyval ;
if ( handled && event.GetSkipped() )
handled = false ;
}
+
if ( !handled && (keyval == WXK_TAB) )
{
wxWindow* iter = focus->GetParent() ;
- while( iter && !handled )
+ while ( iter && !handled )
{
if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
{
if ( handled && new_event.GetSkipped() )
handled = false ;
}
+
iter = iter->GetParent() ;
}
}
+
// 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 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 )
{
- wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
- wxButton);
- if ( def && def->IsEnabled() )
- {
- wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
- event.SetEventObject(def);
- def->Command(event);
- return true ;
- }
+ wxButton *def = wxDynamicCast(focus->GetDefaultItem(), wxButton);
+ if ( def && def->IsEnabled() )
+ {
+ wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
+ event.SetEventObject(def);
+ def->Command(event);
+
+ return true ;
+ }
}
- /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
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 );
+ // generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
+ wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
+ new_event.SetEventObject( focus );
+ handled = focus->GetEventHandler()->ProcessEvent( new_event );
}
- }
+ }
}
+
return handled ;
}
-bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
+bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
{
if ( !focus )
return false ;
- short keycode ;
- short keychar ;
+ short keycode, keychar ;
+
keychar = short(keymessage & charCodeMask);
keycode = short(keymessage & keyCodeMask) >> 8 ;
- if ( modifiers & ( controlKey|shiftKey|optionKey ) )
+ 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);
+ UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey | shiftKey | optionKey))) | keycode, &state);
keychar = short(keyInfo & charCodeMask);
}
- long keyval = wxMacTranslateKey(keychar, keycode) ;
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
if ( keyval == keychar )
- {
keyval = wxToupper( keyval ) ;
- }
// Check for NUMPAD keys
if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
{
- keyval = keyval - '0' + WXK_NUMPAD0;
+ keyval = (keyval - '0') + WXK_NUMPAD0;
}
else if (keycode >= 67 && keycode <= 81)
{
case 76 :
keyval = WXK_NUMPAD_ENTER;
break;
+
case 81:
keyval = WXK_NUMPAD_EQUAL;
break;
+
case 67:
keyval = WXK_NUMPAD_MULTIPLY;
break;
+
case 75:
keyval = WXK_NUMPAD_DIVIDE;
break;
+
case 78:
keyval = WXK_NUMPAD_SUBTRACT;
break;
+
case 69:
keyval = WXK_NUMPAD_ADD;
break;
+
case 65:
keyval = WXK_NUMPAD_DECIMAL;
break;
+
+ default:
+ break;
} // end switch
}
projects / wxWidgets.git / blobdiff