]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/app.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
added wxPowerEvent; moved power functions stubs to common/powercmn.cpp
[wxWidgets.git] / src / mac / carbon / app.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/mac/carbon/app.cpp
3// Purpose: wxApp
4// Author: Stefan Csomor
5// Modified by:
6// Created: 1998-01-01
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#include "wx/wxprec.h"
13
14#include "wx/app.h"
15
16#ifndef WX_PRECOMP
17 #include "wx/intl.h"
18 #include "wx/log.h"
19 #include "wx/utils.h"
20 #include "wx/window.h"
21 #include "wx/frame.h"
22 #include "wx/dc.h"
23 #include "wx/button.h"
24 #include "wx/menu.h"
25 #include "wx/pen.h"
26 #include "wx/brush.h"
27 #include "wx/palette.h"
28 #include "wx/icon.h"
29 #include "wx/cursor.h"
30 #include "wx/dialog.h"
31 #include "wx/msgdlg.h"
32#endif
33
34#include "wx/gdicmn.h"
35#include "wx/module.h"
36#include "wx/memory.h"
37#include "wx/tooltip.h"
38#include "wx/textctrl.h"
39#include "wx/docview.h"
40#include "wx/filename.h"
41
42#include <string.h>
43
44// mac
45
46#ifndef __DARWIN__
47 #if __option(profile)
48 #include <profiler.h>
49 #endif
50#endif
51
52// #include "apprsrc.h"
53
54#include "wx/mac/uma.h"
55#include "wx/mac/macnotfy.h"
56
57#ifdef __DARWIN__
58# include <CoreServices/CoreServices.h>
59# if defined(WXMAKINGDLL_CORE)
60# include <mach-o/dyld.h>
61# endif
62#else
63# include <Sound.h>
64# include <Threads.h>
65# include <ToolUtils.h>
66# include <DiskInit.h>
67# include <Devices.h>
68#endif
69
70#if wxUSE_THREADS
71extern size_t g_numberOfThreads;
72#endif
73
74// statics for implementation
75static bool s_inYield = false;
76static bool s_inReceiveEvent = false ;
77static EventTime sleepTime = kEventDurationNoWait ;
78
79
80IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
81BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
82 EVT_IDLE(wxApp::OnIdle)
83 EVT_END_SESSION(wxApp::OnEndSession)
84 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
85END_EVENT_TABLE()
86
87
88// platform specific static variables
89const short kMacMinHeap = (29 * 1024) ;
90const short kwxMacMenuBarResource = 1 ;
91const short kwxMacAppleMenuId = 1 ;
92
93WXHRGN wxApp::s_macCursorRgn = NULL;
94wxWindow* wxApp::s_captureWindow = NULL ;
95int wxApp::s_lastMouseDown = 0 ;
96long wxApp::sm_lastMessageTime = 0;
97long wxApp::s_lastModifiers = 0 ;
98
99bool wxApp::s_macSupportPCMenuShortcuts = true ;
100long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
101long wxApp::s_macPreferencesMenuItemId = wxID_PREFERENCES ;
102long wxApp::s_macExitMenuItemId = wxID_EXIT ;
103wxString wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
104
105bool wxApp::sm_isEmbedded = false; // Normally we're not a plugin
106
107//----------------------------------------------------------------------
108// Core Apple Event Support
109//----------------------------------------------------------------------
110
111pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
112pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
113pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
114pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
115pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
116
117pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
118{
119 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
120}
121
122pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
123{
124 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
125}
126
127pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
128{
129 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
130}
131
132pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
133{
134 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
135}
136
137pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
138{
139 return wxTheApp->MacHandleAERApp( (AppleEvent*) event , reply) ;
140}
141
142// AEODoc Calls MacOpenFile on each of the files passed
143
144short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
145{
146 AEDescList docList;
147 AEKeyword keywd;
148 DescType returnedType;
149 Size actualSize;
150 long itemsInList;
151 OSErr err;
152 short i;
153
154 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
155 if (err != noErr)
156 return err;
157
158 err = AECountItems(&docList, &itemsInList);
159 if (err != noErr)
160 return err;
161
162 ProcessSerialNumber PSN ;
163 PSN.highLongOfPSN = 0 ;
164 PSN.lowLongOfPSN = kCurrentProcess ;
165 SetFrontProcess( &PSN ) ;
166
167 wxString fName ;
168 FSRef theRef ;
169
170 for (i = 1; i <= itemsInList; i++)
171 {
172 AEGetNthPtr(
173 &docList, i, typeFSRef, &keywd, &returnedType,
174 (Ptr)&theRef, sizeof(theRef), &actualSize);
175 fName = wxMacFSRefToPath( &theRef ) ;
176
177 MacOpenFile(fName);
178 }
179
180 return noErr;
181}
182
183// AEPDoc Calls MacPrintFile on each of the files passed
184
185short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
186{
187 AEDescList docList;
188 AEKeyword keywd;
189 DescType returnedType;
190 Size actualSize;
191 long itemsInList;
192 OSErr err;
193 short i;
194
195 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
196 if (err != noErr)
197 return err;
198
199 err = AECountItems(&docList, &itemsInList);
200 if (err != noErr)
201 return err;
202
203 ProcessSerialNumber PSN ;
204 PSN.highLongOfPSN = 0 ;
205 PSN.lowLongOfPSN = kCurrentProcess ;
206 SetFrontProcess( &PSN ) ;
207
208 wxString fName ;
209 FSRef theRef ;
210
211 for (i = 1; i <= itemsInList; i++)
212 {
213 AEGetNthPtr(
214 &docList, i, typeFSRef, &keywd, &returnedType,
215 (Ptr)&theRef, sizeof(theRef), &actualSize);
216 fName = wxMacFSRefToPath( &theRef ) ;
217
218 MacPrintFile(fName);
219 }
220
221 return noErr;
222}
223
224// AEOApp calls MacNewFile
225
226short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
227{
228 MacNewFile() ;
229 return noErr ;
230}
231
232// AEQuit attempts to quit the application
233
234short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
235{
236 wxWindow* win = GetTopWindow() ;
237 if ( win )
238 {
239 wxCommandEvent exitEvent(wxEVT_COMMAND_MENU_SELECTED, s_macExitMenuItemId);
240 if (!win->ProcessEvent(exitEvent))
241 win->Close(true) ;
242 }
243 else
244 {
245 ExitMainLoop() ;
246 }
247
248 return noErr ;
249}
250
251// AEROApp calls MacReopenApp
252
253short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
254{
255 MacReopenApp() ;
256
257 return noErr ;
258}
259
260//----------------------------------------------------------------------
261// Support Routines linking the Mac...File Calls to the Document Manager
262//----------------------------------------------------------------------
263
264void wxApp::MacOpenFile(const wxString & fileName )
265{
266#if wxUSE_DOC_VIEW_ARCHITECTURE
267 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
268 if ( dm )
269 dm->CreateDocument(fileName , wxDOC_SILENT ) ;
270#endif
271}
272
273
274void wxApp::MacPrintFile(const wxString & fileName )
275{
276#if wxUSE_DOC_VIEW_ARCHITECTURE
277
278#if wxUSE_PRINTING_ARCHITECTURE
279 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
280 if ( dm )
281 {
282 wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
283 if ( doc )
284 {
285 wxView* view = doc->GetFirstView() ;
286 if ( view )
287 {
288 wxPrintout *printout = view->OnCreatePrintout();
289 if (printout)
290 {
291 wxPrinter printer;
292 printer.Print(view->GetFrame(), printout, true);
293 delete printout;
294 }
295 }
296
297 if (doc->Close())
298 {
299 doc->DeleteAllViews();
300 dm->RemoveDocument(doc) ;
301 }
302 }
303 }
304#endif //print
305
306#endif //docview
307}
308
309
310
311void wxApp::MacNewFile()
312{
313}
314
315void wxApp::MacReopenApp()
316{
317 // HIG says :
318 // if there is no open window -> create a new one
319 // if all windows are hidden -> show the first
320 // if some windows are not hidden -> do nothing
321
322 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
323 if ( node == NULL )
324 {
325 MacNewFile() ;
326 }
327 else
328 {
329 wxTopLevelWindow* firstIconized = NULL ;
330 while (node)
331 {
332 wxTopLevelWindow* win = (wxTopLevelWindow*) node->GetData();
333 if ( !win->IsIconized() )
334 {
335 firstIconized = NULL ;
336 break ;
337 }
338 else
339 {
340 if ( firstIconized == NULL )
341 firstIconized = win ;
342 }
343
344 node = node->GetNext();
345 }
346
347 if ( firstIconized )
348 firstIconized->Iconize( false ) ;
349 }
350}
351
352//----------------------------------------------------------------------
353// Macintosh CommandID support - converting between native and wx IDs
354//----------------------------------------------------------------------
355
356// if no native match they just return the passed-in id
357
358struct IdPair
359{
360 UInt32 macId ;
361 int wxId ;
362} ;
363
364IdPair gCommandIds [] =
365{
366 { kHICommandCut , wxID_CUT } ,
367 { kHICommandCopy , wxID_COPY } ,
368 { kHICommandPaste , wxID_PASTE } ,
369 { kHICommandSelectAll , wxID_SELECTALL } ,
370 { kHICommandClear , wxID_CLEAR } ,
371 { kHICommandUndo , wxID_UNDO } ,
372 { kHICommandRedo , wxID_REDO } ,
373} ;
374
375int wxMacCommandToId( UInt32 macCommandId )
376{
377 int wxid = 0 ;
378
379 switch ( macCommandId )
380 {
381 case kHICommandPreferences :
382 wxid = wxApp::s_macPreferencesMenuItemId ;
383 break ;
384
385 case kHICommandQuit :
386 wxid = wxApp::s_macExitMenuItemId ;
387 break ;
388
389 case kHICommandAbout :
390 wxid = wxApp::s_macAboutMenuItemId ;
391 break ;
392
393 default :
394 {
395 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
396 {
397 if ( gCommandIds[i].macId == macCommandId )
398 {
399 wxid = gCommandIds[i].wxId ;
400 break ;
401 }
402 }
403 }
404 break ;
405 }
406
407 if ( wxid == 0 )
408 wxid = (int) macCommandId ;
409
410 return wxid ;
411}
412
413UInt32 wxIdToMacCommand( int wxId )
414{
415 UInt32 macId = 0 ;
416
417 if ( wxId == wxApp::s_macPreferencesMenuItemId )
418 macId = kHICommandPreferences ;
419 else if (wxId == wxApp::s_macExitMenuItemId)
420 macId = kHICommandQuit ;
421 else if (wxId == wxApp::s_macAboutMenuItemId)
422 macId = kHICommandAbout ;
423 else
424 {
425 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
426 {
427 if ( gCommandIds[i].wxId == wxId )
428 {
429 macId = gCommandIds[i].macId ;
430 break ;
431 }
432 }
433 }
434
435 if ( macId == 0 )
436 macId = (int) wxId ;
437
438 return macId ;
439}
440
441wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
442{
443 wxMenu* itemMenu = NULL ;
444 int id = 0 ;
445
446 // for 'standard' commands which don't have a wx-menu
447 if ( command.commandID == kHICommandPreferences || command.commandID == kHICommandQuit || command.commandID == kHICommandAbout )
448 {
449 id = wxMacCommandToId( command.commandID ) ;
450
451 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
452 if ( mbar )
453 item = mbar->FindItem( id , &itemMenu ) ;
454 }
455 else if ( command.commandID != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
456 {
457 id = wxMacCommandToId( command.commandID ) ;
458 // make sure it is one of our own menus, or of the 'synthetic' apple and help menus , otherwise don't touch
459 MenuItemIndex firstUserHelpMenuItem ;
460 static MenuHandle mh = NULL ;
461 if ( mh == NULL )
462 {
463 if ( UMAGetHelpMenu( &mh , &firstUserHelpMenuItem) != noErr )
464 mh = NULL ;
465 }
466
467 // is it part of the application or the Help menu, then look for the id directly
468 if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
469 ( mh != NULL && command.menu.menuRef == mh ) )
470 {
471 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
472 if ( mbar )
473 item = mbar->FindItem( id , &itemMenu ) ;
474 }
475 else
476 {
477 UInt32 refCon ;
478
479 GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
480 itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
481 if ( itemMenu != NULL )
482 item = (wxMenuItem*) refCon ;
483 }
484 }
485
486 return itemMenu ;
487}
488
489//----------------------------------------------------------------------
490// Carbon Event Handler
491//----------------------------------------------------------------------
492
493static const EventTypeSpec eventList[] =
494{
495 { kEventClassCommand, kEventProcessCommand } ,
496 { kEventClassCommand, kEventCommandUpdateStatus } ,
497
498 { kEventClassMenu, kEventMenuOpening },
499 { kEventClassMenu, kEventMenuClosed },
500 { kEventClassMenu, kEventMenuTargetItem },
501
502 { kEventClassApplication , kEventAppActivated } ,
503 { kEventClassApplication , kEventAppDeactivated } ,
504 // handling the quit event is not recommended by apple
505 // rather using the quit apple event - which we do
506
507 { kEventClassAppleEvent , kEventAppleEvent } ,
508
509 { kEventClassMouse , kEventMouseDown } ,
510 { kEventClassMouse , kEventMouseMoved } ,
511 { kEventClassMouse , kEventMouseUp } ,
512 { kEventClassMouse , kEventMouseDragged } ,
513 { 'WXMC' , 'WXMC' }
514} ;
515
516static pascal OSStatus
517wxMacAppMenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
518{
519 wxMacCarbonEvent cEvent( event ) ;
520 MenuRef menuRef = cEvent.GetParameter<MenuRef>(kEventParamDirectObject) ;
521 wxMenu* menu = wxFindMenuFromMacMenu( menuRef ) ;
522
523 if ( menu )
524 {
525 wxEventType type=0;
526 MenuCommand cmd=0;
527 switch (GetEventKind(event))
528 {
529 case kEventMenuOpening:
530 type = wxEVT_MENU_OPEN;
531 break;
532
533 case kEventMenuClosed:
534 type = wxEVT_MENU_CLOSE;
535 break;
536
537 case kEventMenuTargetItem:
538 cmd = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
539 if (cmd != 0)
540 type = wxEVT_MENU_HIGHLIGHT;
541 break;
542
543 default:
544 wxFAIL_MSG(wxT("Unexpected menu event kind"));
545 break;
546 }
547
548 if ( type )
549 {
550 wxMenuEvent wxevent(type, cmd, menu);
551 wxevent.SetEventObject(menu);
552
553 wxEvtHandler* handler = menu->GetEventHandler();
554 if (handler && handler->ProcessEvent(wxevent))
555 {
556 // handled
557 }
558 else
559 {
560 wxWindow *win = menu->GetInvokingWindow();
561 if (win)
562 win->GetEventHandler()->ProcessEvent(wxevent);
563 }
564 }
565 }
566
567 return eventNotHandledErr;
568}
569
570static pascal OSStatus wxMacAppCommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
571{
572 OSStatus result = eventNotHandledErr ;
573
574 HICommand command ;
575
576 wxMacCarbonEvent cEvent( event ) ;
577 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
578
579 wxMenuItem* item = NULL ;
580 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
581 int id = wxMacCommandToId( command.commandID ) ;
582
583 if ( item )
584 {
585 wxASSERT( itemMenu != NULL ) ;
586
587 switch ( cEvent.GetKind() )
588 {
589 case kEventProcessCommand :
590 {
591 if (item->IsCheckable())
592 item->Check( !item->IsChecked() ) ;
593
594 if ( itemMenu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) )
595 result = noErr ;
596 }
597 break ;
598
599 case kEventCommandUpdateStatus:
600 {
601 wxUpdateUIEvent event(id);
602 event.SetEventObject( itemMenu );
603
604 bool processed = false;
605
606 // Try the menu's event handler
607 {
608 wxEvtHandler *handler = itemMenu->GetEventHandler();
609 if ( handler )
610 processed = handler->ProcessEvent(event);
611 }
612
613 // Try the window the menu was popped up from
614 // (and up through the hierarchy)
615 if ( !processed )
616 {
617 const wxMenuBase *menu = itemMenu;
618 while ( menu )
619 {
620 wxWindow *win = menu->GetInvokingWindow();
621 if ( win )
622 {
623 processed = win->GetEventHandler()->ProcessEvent(event);
624 break;
625 }
626
627 menu = menu->GetParent();
628 }
629 }
630
631 if ( processed )
632 {
633 // if anything changed, update the changed attribute
634 if (event.GetSetText())
635 itemMenu->SetLabel(id, event.GetText());
636 if (event.GetSetChecked())
637 itemMenu->Check(id, event.GetChecked());
638 if (event.GetSetEnabled())
639 itemMenu->Enable(id, event.GetEnabled());
640
641 result = noErr ;
642 }
643 }
644 break ;
645
646 default :
647 break ;
648 }
649 }
650 return result ;
651}
652
653static pascal OSStatus wxMacAppApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
654{
655 OSStatus result = eventNotHandledErr ;
656 switch ( GetEventKind( event ) )
657 {
658 case kEventAppActivated :
659 if ( wxTheApp )
660 wxTheApp->SetActive( true , NULL ) ;
661 result = noErr ;
662 break ;
663
664 case kEventAppDeactivated :
665 if ( wxTheApp )
666 wxTheApp->SetActive( false , NULL ) ;
667 result = noErr ;
668 break ;
669
670 default :
671 break ;
672 }
673
674 return result ;
675}
676
677pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
678{
679 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
680 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
681 wxTheApp->MacSetCurrentEvent( event , handler ) ;
682
683 OSStatus result = eventNotHandledErr ;
684 switch ( GetEventClass( event ) )
685 {
686 case kEventClassCommand :
687 result = wxMacAppCommandEventHandler( handler , event , data ) ;
688 break ;
689
690 case kEventClassApplication :
691 result = wxMacAppApplicationEventHandler( handler , event , data ) ;
692 break ;
693
694 case kEventClassMenu :
695 result = wxMacAppMenuEventHandler( handler , event , data ) ;
696 break ;
697
698 case kEventClassMouse :
699 {
700 wxMacCarbonEvent cEvent( event ) ;
701
702 WindowRef window ;
703 Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
704 ::FindWindow(screenMouseLocation, &window);
705 // only send this event in case it had not already been sent to a tlw, as we get
706 // double events otherwise (in case event.skip) was called
707 if ( window == NULL )
708 result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
709 }
710 break ;
711
712 case kEventClassAppleEvent :
713 {
714 EventRecord rec ;
715
716 wxMacConvertEventToRecord( event , &rec ) ;
717 result = AEProcessAppleEvent( &rec ) ;
718 }
719 break ;
720
721 default :
722 break ;
723 }
724
725 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
726
727 return result ;
728}
729
730DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
731
732#ifdef __WXDEBUG__
733
734pascal static void wxMacAssertOutputHandler(OSType componentSignature, UInt32 options,
735 const char *assertionString, const char *exceptionLabelString,
736 const char *errorString, const char *fileName, long lineNumber, void *value, ConstStr255Param outputMsg)
737{
738 // flow into assert handling
739 wxString fileNameStr ;
740 wxString assertionStr ;
741 wxString exceptionStr ;
742 wxString errorStr ;
743
744#if wxUSE_UNICODE
745 fileNameStr = wxString(fileName, wxConvLocal);
746 assertionStr = wxString(assertionString, wxConvLocal);
747 exceptionStr = wxString((exceptionLabelString!=0) ? exceptionLabelString : "", wxConvLocal) ;
748 errorStr = wxString((errorString!=0) ? errorString : "", wxConvLocal) ;
749#else
750 fileNameStr = fileName;
751 assertionStr = assertionString;
752 exceptionStr = (exceptionLabelString!=0) ? exceptionLabelString : "" ;
753 errorStr = (errorString!=0) ? errorString : "" ;
754#endif
755
756#if 1
757 // flow into log
758 wxLogDebug( wxT("AssertMacros: %s %s %s file: %s, line: %ld (value %p)\n"),
759 assertionStr.c_str() ,
760 exceptionStr.c_str() ,
761 errorStr.c_str(),
762 fileNameStr.c_str(), lineNumber ,
763 value ) ;
764#else
765
766 wxOnAssert(fileNameStr, lineNumber , assertionStr ,
767 wxString::Format( wxT("%s %s value (%p)") , exceptionStr, errorStr , value ) ) ;
768#endif
769}
770
771#endif //__WXDEBUG__
772
773#ifdef __WXMAC_OSX__
774extern "C"
775{
776 // m_macEventPosted run loop source callback:
777 void macPostedEventCallback(void *unused);
778}
779
780void macPostedEventCallback(void *unused)
781{
782 wxTheApp->ProcessPendingEvents();
783}
784#endif
785
786bool wxApp::Initialize(int& argc, wxChar **argv)
787{
788 // Mac-specific
789
790#ifdef __WXDEBUG__
791 InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
792#endif
793
794 UMAInitToolbox( 4, sm_isEmbedded ) ;
795 SetEventMask( everyEvent ) ;
796 UMAShowWatchCursor() ;
797
798#ifndef __DARWIN__
799# if __option(profile)
800 ProfilerInit( collectDetailed, bestTimeBase , 40000 , 50 ) ;
801# endif
802#endif
803
804#ifndef __DARWIN__
805 // now avoid exceptions thrown for new (bad_alloc)
806 // FIXME CS for some changes outside wxMac does not compile anymore
807#if 0
808 std::__throws_bad_alloc = 0 ;
809#endif
810
811#endif
812
813 s_macCursorRgn = ::NewRgn() ;
814
815 // Mac OS X passes a process serial number command line argument when
816 // the application is launched from the Finder. This argument must be
817 // removed from the command line arguments before being handled by the
818 // application (otherwise applications would need to handle it)
819 if ( argc > 1 )
820 {
821 static const wxChar *ARG_PSN = _T("-psn_");
822 if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 )
823 {
824 // remove this argument
825 --argc;
826 memmove(argv + 1, argv + 2, argc * sizeof(char *));
827 }
828 }
829
830 if ( !wxAppBase::Initialize(argc, argv) )
831 return false;
832
833#if wxUSE_INTL
834 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
835#endif
836
837#if TARGET_API_MAC_OSX
838 // these might be the startup dirs, set them to the 'usual' dir containing the app bundle
839 wxString startupCwd = wxGetCwd() ;
840 if ( startupCwd == wxT("/") || startupCwd.Right(15) == wxT("/Contents/MacOS") )
841 {
842 CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle() ) ;
843 CFURLRef urlParent = CFURLCreateCopyDeletingLastPathComponent( kCFAllocatorDefault , url ) ;
844 CFRelease( url ) ;
845 CFStringRef path = CFURLCopyFileSystemPath ( urlParent , kCFURLPOSIXPathStyle ) ;
846 CFRelease( urlParent ) ;
847 wxString cwd = wxMacCFStringHolder(path).AsString(wxLocale::GetSystemEncoding());
848 wxSetWorkingDirectory( cwd ) ;
849 }
850#endif
851
852 wxMacCreateNotifierTable() ;
853
854#ifdef __WXMAC_OSX__
855 /* connect posted events to common-mode run loop so that wxPostEvent events
856 are handled even while we're in the menu or on a scrollbar */
857 CFRunLoopSourceContext event_posted_context = {0};
858 event_posted_context.perform = macPostedEventCallback;
859 m_macEventPosted = CFRunLoopSourceCreate(NULL,0,&event_posted_context);
860 CFRunLoopAddSource(CFRunLoopGetCurrent(), m_macEventPosted, kCFRunLoopCommonModes);
861#endif
862
863 UMAShowArrowCursor() ;
864
865 return true;
866}
867
868AEEventHandlerUPP sODocHandler = NULL ;
869AEEventHandlerUPP sOAppHandler = NULL ;
870AEEventHandlerUPP sPDocHandler = NULL ;
871AEEventHandlerUPP sRAppHandler = NULL ;
872AEEventHandlerUPP sQuitHandler = NULL ;
873
874bool wxApp::OnInitGui()
875{
876 if ( !wxAppBase::OnInitGui() )
877 return false ;
878
879 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
880
881 if (!sm_isEmbedded)
882 {
883 InstallApplicationEventHandler(
884 GetwxMacAppEventHandlerUPP(),
885 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
886 }
887
888 if (!sm_isEmbedded)
889 {
890 sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
891 sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
892 sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
893 sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
894 sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
895
896 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
897 sODocHandler , 0 , FALSE ) ;
898 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
899 sOAppHandler , 0 , FALSE ) ;
900 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
901 sPDocHandler , 0 , FALSE ) ;
902 AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
903 sRAppHandler , 0 , FALSE ) ;
904 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
905 sQuitHandler , 0 , FALSE ) ;
906 }
907
908 return true ;
909}
910
911void wxApp::CleanUp()
912{
913#if wxUSE_TOOLTIPS
914 wxToolTip::RemoveToolTips() ;
915#endif
916
917#ifdef __WXMAC_OSX__
918 if (m_macEventPosted)
919 CFRelease(m_macEventPosted);
920 m_macEventPosted = NULL;
921#endif
922
923 // One last chance for pending objects to be cleaned up
924 wxTheApp->DeletePendingObjects();
925
926 wxMacDestroyNotifierTable() ;
927
928#ifndef __DARWIN__
929# if __option(profile)
930 ProfilerDump( (StringPtr)"\papp.prof" ) ;
931 ProfilerTerm() ;
932# endif
933#endif
934
935 UMACleanupToolbox() ;
936 if (s_macCursorRgn)
937 ::DisposeRgn((RgnHandle)s_macCursorRgn);
938
939 if (!sm_isEmbedded)
940 RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
941
942 if (!sm_isEmbedded)
943 {
944 AERemoveEventHandler( kCoreEventClass , kAEOpenDocuments ,
945 sODocHandler , FALSE ) ;
946 AERemoveEventHandler( kCoreEventClass , kAEOpenApplication ,
947 sOAppHandler , FALSE ) ;
948 AERemoveEventHandler( kCoreEventClass , kAEPrintDocuments ,
949 sPDocHandler , FALSE ) ;
950 AERemoveEventHandler( kCoreEventClass , kAEReopenApplication ,
951 sRAppHandler , FALSE ) ;
952 AERemoveEventHandler( kCoreEventClass , kAEQuitApplication ,
953 sQuitHandler , FALSE ) ;
954
955 DisposeAEEventHandlerUPP( sODocHandler ) ;
956 DisposeAEEventHandlerUPP( sOAppHandler ) ;
957 DisposeAEEventHandlerUPP( sPDocHandler ) ;
958 DisposeAEEventHandlerUPP( sRAppHandler ) ;
959 DisposeAEEventHandlerUPP( sQuitHandler ) ;
960 }
961
962 wxAppBase::CleanUp();
963}
964
965//----------------------------------------------------------------------
966// misc initialization stuff
967//----------------------------------------------------------------------
968
969#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)
970
971// for shared libraries we have to manually get the correct resource
972// ref num upon initializing and releasing when terminating, therefore
973// the __wxinitialize and __wxterminate must be used
974
975extern "C"
976{
977 void __sinit(void); // (generated by linker)
978 pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
979 pascal void __terminate(void);
980}
981
982pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
983{
984 return __initialize( theInitBlock ) ;
985}
986
987pascal void __wxterminate(void)
988{
989 __terminate() ;
990}
991
992#endif /* WXMAKINGDLL_CORE && !__DARWIN__ */
993
994bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
995{
996 OSStatus err = noErr ;
997 bool converted = ConvertEventRefToEventRecord( event, rec) ;
998
999 if ( !converted )
1000 {
1001 switch ( GetEventClass( event ) )
1002 {
1003 case kEventClassKeyboard :
1004 {
1005 converted = true ;
1006 switch ( GetEventKind(event) )
1007 {
1008 case kEventRawKeyDown :
1009 rec->what = keyDown ;
1010 break ;
1011
1012 case kEventRawKeyRepeat :
1013 rec->what = autoKey ;
1014 break ;
1015
1016 case kEventRawKeyUp :
1017 rec->what = keyUp ;
1018 break ;
1019
1020 case kEventRawKeyModifiersChanged :
1021 rec->what = nullEvent ;
1022 break ;
1023
1024 default :
1025 converted = false ;
1026 break ;
1027 }
1028
1029 if ( converted )
1030 {
1031 UInt32 keyCode ;
1032 unsigned char charCode ;
1033 UInt32 modifiers ;
1034 GetMouse( &rec->where) ;
1035
1036 err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
1037 err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
1038 err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
1039 rec->modifiers = modifiers ;
1040 rec->message = (keyCode << 8 ) + charCode ;
1041 }
1042 }
1043 break ;
1044
1045 case kEventClassTextInput :
1046 {
1047 switch ( GetEventKind( event ) )
1048 {
1049 case kEventTextInputUnicodeForKeyEvent :
1050 {
1051 EventRef rawEvent ;
1052 err = GetEventParameter(
1053 event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL,
1054 sizeof(rawEvent), NULL, &rawEvent ) ;
1055 converted = true ;
1056
1057 {
1058 UInt32 keyCode, modifiers;
1059 unsigned char charCode ;
1060
1061 GetMouse( &rec->where) ;
1062 rec->what = keyDown ;
1063 err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
1064 err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
1065 err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
1066 rec->modifiers = modifiers ;
1067 rec->message = (keyCode << 8 ) + charCode ;
1068 }
1069 }
1070 break ;
1071
1072 default :
1073 break ;
1074 }
1075 }
1076 break ;
1077
1078 default :
1079 break ;
1080 }
1081 }
1082
1083 return converted ;
1084}
1085
1086wxApp::wxApp()
1087{
1088 m_printMode = wxPRINT_WINDOWS;
1089
1090 m_macCurrentEvent = NULL ;
1091 m_macCurrentEventHandlerCallRef = NULL ;
1092
1093#ifdef __WXMAC_OSX__
1094 m_macEventPosted = NULL ;
1095#endif
1096}
1097
1098void wxApp::OnIdle(wxIdleEvent& event)
1099{
1100 wxAppBase::OnIdle(event);
1101
1102 // If they are pending events, we must process them: pending events are
1103 // either events to the threads other than main or events posted with
1104 // wxPostEvent() functions
1105 wxMacProcessNotifierAndPendingEvents();
1106
1107 if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1108 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1109}
1110
1111void wxApp::WakeUpIdle()
1112{
1113#ifdef __WXMAC_OSX__
1114 if (m_macEventPosted)
1115 {
1116 CFRunLoopSourceSignal(m_macEventPosted);
1117 }
1118#endif
1119
1120 wxMacWakeUp() ;
1121}
1122
1123void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1124{
1125 if (GetTopWindow())
1126 GetTopWindow()->Close(true);
1127}
1128
1129// Default behaviour: close the application with prompts. The
1130// user can veto the close, and therefore the end session.
1131void wxApp::OnQueryEndSession(wxCloseEvent& event)
1132{
1133 if (GetTopWindow())
1134 {
1135 if (!GetTopWindow()->Close(!event.CanVeto()))
1136 event.Veto(true);
1137 }
1138}
1139
1140extern "C" void wxCYield() ;
1141void wxCYield()
1142{
1143 wxYield() ;
1144}
1145
1146// Yield to other processes
1147
1148bool wxApp::Yield(bool onlyIfNeeded)
1149{
1150 if (s_inYield)
1151 {
1152 if ( !onlyIfNeeded )
1153 {
1154 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1155 }
1156
1157 return false;
1158 }
1159
1160 s_inYield = true;
1161
1162 // by definition yield should handle all non-processed events
1163
1164 EventRef theEvent;
1165
1166 OSStatus status = noErr ;
1167
1168 while ( status == noErr )
1169 {
1170 s_inReceiveEvent = true ;
1171 status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
1172 s_inReceiveEvent = false ;
1173
1174 if ( status == eventLoopTimedOutErr )
1175 {
1176 // make sure next time the event loop will trigger idle events
1177 sleepTime = kEventDurationNoWait ;
1178 }
1179 else if ( status == eventLoopQuitErr )
1180 {
1181 // according to QA1061 this may also occur when a WakeUp Process
1182 // is executed
1183 }
1184 else
1185 {
1186 MacHandleOneEvent( theEvent ) ;
1187 ReleaseEvent(theEvent);
1188 }
1189 }
1190
1191 wxMacProcessNotifierAndPendingEvents() ;
1192 s_inYield = false;
1193
1194 return true;
1195}
1196
1197void wxApp::MacDoOneEvent()
1198{
1199 EventRef theEvent;
1200
1201 s_inReceiveEvent = true ;
1202 OSStatus status = ReceiveNextEvent(0, NULL, sleepTime, true, &theEvent) ;
1203 s_inReceiveEvent = false ;
1204
1205 switch (status)
1206 {
1207 case eventLoopTimedOutErr :
1208 if ( wxTheApp->ProcessIdle() )
1209 sleepTime = kEventDurationNoWait ;
1210 else
1211 sleepTime = kEventDurationSecond;
1212 break;
1213
1214 case eventLoopQuitErr :
1215 // according to QA1061 this may also occur
1216 // when a WakeUp Process is executed
1217 break;
1218
1219 default:
1220 MacHandleOneEvent( theEvent ) ;
1221 ReleaseEvent( theEvent );
1222 sleepTime = kEventDurationNoWait ;
1223 break;
1224 }
1225 // repeaters
1226
1227 DeletePendingObjects() ;
1228 wxMacProcessNotifierAndPendingEvents() ;
1229}
1230
1231// virtual
1232void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
1233{
1234 // Override to process unhandled events as you please
1235}
1236
1237void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1238{
1239 EventTargetRef theTarget;
1240 theTarget = GetEventDispatcherTarget();
1241 m_macCurrentEvent = evr ;
1242
1243 OSStatus status = SendEventToEventTarget((EventRef) evr , theTarget);
1244 if (status == eventNotHandledErr)
1245 MacHandleUnhandledEvent(evr);
1246
1247 wxMacProcessNotifierAndPendingEvents() ;
1248
1249#if wxUSE_THREADS
1250 wxMutexGuiLeaveOrEnter();
1251#endif // wxUSE_THREADS
1252}
1253
1254long wxMacTranslateKey(unsigned char key, unsigned char code)
1255{
1256 long retval = key ;
1257 switch (key)
1258 {
1259 case kHomeCharCode :
1260 retval = WXK_HOME;
1261 break;
1262
1263 case kEnterCharCode :
1264 retval = WXK_RETURN;
1265 break;
1266 case kEndCharCode :
1267 retval = WXK_END;
1268 break;
1269
1270 case kHelpCharCode :
1271 retval = WXK_HELP;
1272 break;
1273
1274 case kBackspaceCharCode :
1275 retval = WXK_BACK;
1276 break;
1277
1278 case kTabCharCode :
1279 retval = WXK_TAB;
1280 break;
1281
1282 case kPageUpCharCode :
1283 retval = WXK_PAGEUP;
1284 break;
1285
1286 case kPageDownCharCode :
1287 retval = WXK_PAGEDOWN;
1288 break;
1289
1290 case kReturnCharCode :
1291 retval = WXK_RETURN;
1292 break;
1293
1294 case kFunctionKeyCharCode :
1295 {
1296 switch ( code )
1297 {
1298 case 0x7a :
1299 retval = WXK_F1 ;
1300 break;
1301
1302 case 0x78 :
1303 retval = WXK_F2 ;
1304 break;
1305
1306 case 0x63 :
1307 retval = WXK_F3 ;
1308 break;
1309
1310 case 0x76 :
1311 retval = WXK_F4 ;
1312 break;
1313
1314 case 0x60 :
1315 retval = WXK_F5 ;
1316 break;
1317
1318 case 0x61 :
1319 retval = WXK_F6 ;
1320 break;
1321
1322 case 0x62:
1323 retval = WXK_F7 ;
1324 break;
1325
1326 case 0x64 :
1327 retval = WXK_F8 ;
1328 break;
1329
1330 case 0x65 :
1331 retval = WXK_F9 ;
1332 break;
1333
1334 case 0x6D :
1335 retval = WXK_F10 ;
1336 break;
1337
1338 case 0x67 :
1339 retval = WXK_F11 ;
1340 break;
1341
1342 case 0x6F :
1343 retval = WXK_F12 ;
1344 break;
1345
1346 case 0x69 :
1347 retval = WXK_F13 ;
1348 break;
1349
1350 case 0x6B :
1351 retval = WXK_F14 ;
1352 break;
1353
1354 case 0x71 :
1355 retval = WXK_F15 ;
1356 break;
1357
1358 default:
1359 break;
1360 }
1361 }
1362 break ;
1363
1364 case kEscapeCharCode :
1365 retval = WXK_ESCAPE ;
1366 break ;
1367
1368 case kLeftArrowCharCode :
1369 retval = WXK_LEFT ;
1370 break ;
1371
1372 case kRightArrowCharCode :
1373 retval = WXK_RIGHT ;
1374 break ;
1375
1376 case kUpArrowCharCode :
1377 retval = WXK_UP ;
1378 break ;
1379
1380 case kDownArrowCharCode :
1381 retval = WXK_DOWN ;
1382 break ;
1383
1384 case kDeleteCharCode :
1385 retval = WXK_DELETE ;
1386 break ;
1387
1388 default:
1389 break ;
1390 } // end switch
1391
1392 return retval;
1393}
1394
1395int wxMacKeyCodeToModifier(wxKeyCode key)
1396{
1397 switch (key)
1398 {
1399 case WXK_START:
1400 case WXK_MENU:
1401 return cmdKey;
1402
1403 case WXK_SHIFT:
1404 return shiftKey;
1405
1406 case WXK_CAPITAL:
1407 return alphaLock;
1408
1409 case WXK_ALT:
1410 return optionKey;
1411
1412 case WXK_CONTROL:
1413 return controlKey;
1414
1415 default:
1416 return 0;
1417 }
1418}
1419
1420#ifndef __DARWIN__
1421bool wxGetKeyState(wxKeyCode key) //virtual key code if < 10.2.x, else see below
1422{
1423 wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
1424 WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
1425
1426//if OS X > 10.2 (i.e. 10.2.x)
1427//a known apple bug prevents the system from determining led
1428//states with GetKeys... can only determine caps lock led
1429 return !!(GetCurrentKeyModifiers() & wxMacKeyCodeToModifier(key));
1430//else
1431// KeyMapByteArray keymap;
1432// GetKeys((BigEndianLong*)keymap);
1433// return !!(BitTst(keymap, (sizeof(KeyMapByteArray)*8) - iKey));
1434}
1435#endif
1436
1437
1438wxMouseState wxGetMouseState()
1439{
1440 wxMouseState ms;
1441
1442 wxPoint pt = wxGetMousePosition();
1443 ms.SetX(pt.x);
1444 ms.SetY(pt.y);
1445
1446#if TARGET_API_MAC_OSX
1447 UInt32 buttons = GetCurrentButtonState();
1448 ms.SetLeftDown( (buttons & 0x01) != 0 );
1449 ms.SetMiddleDown( (buttons & 0x04) != 0 );
1450 ms.SetRightDown( (buttons & 0x02) != 0 );
1451#else
1452 ms.SetLeftDown( Button() );
1453 ms.SetMiddleDown( 0 );
1454 ms.SetRightDown( 0 );
1455#endif
1456
1457 UInt32 modifiers = GetCurrentKeyModifiers();
1458 ms.SetControlDown(modifiers & controlKey);
1459 ms.SetShiftDown(modifiers & shiftKey);
1460 ms.SetAltDown(modifiers & optionKey);
1461 ms.SetMetaDown(modifiers & cmdKey);
1462
1463 return ms;
1464}
1465
1466// TODO : once the new key/char handling is tested, move all the code to wxWindow
1467
1468bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
1469{
1470 if ( !focus )
1471 return false ;
1472
1473 bool handled;
1474 wxKeyEvent event(wxEVT_KEY_DOWN) ;
1475 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
1476
1477 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1478 if ( handled && event.GetSkipped() )
1479 handled = false ;
1480
1481#if wxUSE_ACCEL
1482 if ( !handled )
1483 {
1484 wxWindow *ancestor = focus;
1485 while (ancestor)
1486 {
1487 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1488 if (command != -1)
1489 {
1490 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1491 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1492 break;
1493 }
1494
1495 if (ancestor->IsTopLevel())
1496 break;
1497
1498 ancestor = ancestor->GetParent();
1499 }
1500 }
1501#endif // wxUSE_ACCEL
1502
1503 return handled ;
1504}
1505
1506bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
1507{
1508 if ( !focus )
1509 return false ;
1510
1511 bool handled;
1512 wxKeyEvent event( wxEVT_KEY_UP ) ;
1513 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
1514 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1515
1516 return handled ;
1517}
1518
1519bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
1520{
1521 if ( !focus )
1522 return false ;
1523
1524 wxKeyEvent event(wxEVT_CHAR) ;
1525 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
1526 long keyval = event.m_keyCode ;
1527
1528 bool handled = false ;
1529
1530 wxTopLevelWindowMac *tlw = focus->MacGetTopLevelWindow() ;
1531
1532 if (tlw)
1533 {
1534 event.SetEventType( wxEVT_CHAR_HOOK );
1535 handled = tlw->GetEventHandler()->ProcessEvent( event );
1536 if ( handled && event.GetSkipped() )
1537 handled = false ;
1538 }
1539
1540 if ( !handled )
1541 {
1542 event.SetEventType( wxEVT_CHAR );
1543 event.Skip( false ) ;
1544 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1545 }
1546
1547 if ( !handled && (keyval == WXK_TAB) )
1548 {
1549 wxWindow* iter = focus->GetParent() ;
1550 while ( iter && !handled )
1551 {
1552 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1553 {
1554 wxNavigationKeyEvent new_event;
1555 new_event.SetEventObject( focus );
1556 new_event.SetDirection( !event.ShiftDown() );
1557 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1558 new_event.SetWindowChange( event.ControlDown() );
1559 new_event.SetCurrentFocus( focus );
1560 handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1561 if ( handled && new_event.GetSkipped() )
1562 handled = false ;
1563 }
1564
1565 iter = iter->GetParent() ;
1566 }
1567 }
1568
1569 // backdoor handler for default return and command escape
1570 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1571 {
1572 // if window is not having a focus still testing for default enter or cancel
1573 // TODO: add the UMA version for ActiveNonFloatingWindow
1574 wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1575 if ( focus )
1576 {
1577 if ( keyval == WXK_RETURN )
1578 {
1579 wxButton *def = wxDynamicCast(focus->GetDefaultItem(), wxButton);
1580 if ( def && def->IsEnabled() )
1581 {
1582 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1583 event.SetEventObject(def);
1584 def->Command(event);
1585
1586 return true ;
1587 }
1588 }
1589 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1590 {
1591 // generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
1592 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1593 new_event.SetEventObject( focus );
1594 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1595 }
1596 }
1597 }
1598 return handled ;
1599}
1600
1601// This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
1602void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
1603{
1604 short keycode, keychar ;
1605
1606 keychar = short(keymessage & charCodeMask);
1607 keycode = short(keymessage & keyCodeMask) >> 8 ;
1608 if ( !(event.GetEventType() == wxEVT_CHAR) && (modifiers & (controlKey | shiftKey | optionKey) ) )
1609 {
1610 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1611 // and look at the character after
1612 UInt32 state = 0;
1613 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey | shiftKey | optionKey))) | keycode, &state);
1614 keychar = short(keyInfo & charCodeMask);
1615 }
1616
1617 long keyval = wxMacTranslateKey(keychar, keycode) ;
1618 if ( keyval == keychar && ( event.GetEventType() == wxEVT_KEY_UP || event.GetEventType() == wxEVT_KEY_DOWN ) )
1619 keyval = wxToupper( keyval ) ;
1620
1621 // Check for NUMPAD keys
1622 if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
1623 {
1624 keyval = (keyval - '0') + WXK_NUMPAD0;
1625 }
1626 else if (keycode >= 67 && keycode <= 81)
1627 {
1628 switch (keycode)
1629 {
1630 case 76 :
1631 keyval = WXK_NUMPAD_ENTER;
1632 break;
1633
1634 case 81:
1635 keyval = WXK_NUMPAD_EQUAL;
1636 break;
1637
1638 case 67:
1639 keyval = WXK_NUMPAD_MULTIPLY;
1640 break;
1641
1642 case 75:
1643 keyval = WXK_NUMPAD_DIVIDE;
1644 break;
1645
1646 case 78:
1647 keyval = WXK_NUMPAD_SUBTRACT;
1648 break;
1649
1650 case 69:
1651 keyval = WXK_NUMPAD_ADD;
1652 break;
1653
1654 case 65:
1655 keyval = WXK_NUMPAD_DECIMAL;
1656 break;
1657
1658 default:
1659 break;
1660 } // end switch
1661 }
1662
1663 event.m_shiftDown = modifiers & shiftKey;
1664 event.m_controlDown = modifiers & controlKey;
1665 event.m_altDown = modifiers & optionKey;
1666 event.m_metaDown = modifiers & cmdKey;
1667 event.m_keyCode = keyval ;
1668#if wxUSE_UNICODE
1669 event.m_uniChar = uniChar ;
1670#endif
1671
1672 event.m_rawCode = keymessage;
1673 event.m_rawFlags = modifiers;
1674 event.m_x = wherex;
1675 event.m_y = wherey;
1676 event.SetTimestamp(when);
1677 event.SetEventObject(focus);
1678}
wxWidgets (Impactor)