]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/app.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Make mouse capture checking asserts stronger and more detailed.
[wxWidgets.git] / src / osx / carbon / app.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/app.cpp
3 // Purpose: wxApp
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // Copyright: (c) Stefan Csomor
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 #include "wx/wxprec.h"
12
13 #include "wx/app.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/intl.h"
17 #include "wx/log.h"
18 #include "wx/utils.h"
19 #include "wx/window.h"
20 #include "wx/frame.h"
21 #include "wx/dc.h"
22 #include "wx/button.h"
23 #include "wx/menu.h"
24 #include "wx/pen.h"
25 #include "wx/brush.h"
26 #include "wx/palette.h"
27 #include "wx/icon.h"
28 #include "wx/cursor.h"
29 #include "wx/dialog.h"
30 #include "wx/msgdlg.h"
31 #include "wx/textctrl.h"
32 #include "wx/memory.h"
33 #include "wx/gdicmn.h"
34 #include "wx/module.h"
35 #endif
36
37 #include "wx/tooltip.h"
38 #include "wx/docview.h"
39 #include "wx/filename.h"
40 #include "wx/link.h"
41 #include "wx/thread.h"
42 #include "wx/evtloop.h"
43
44 #include <string.h>
45
46 // mac
47 #if wxOSX_USE_CARBON
48 #include "wx/osx/uma.h"
49 #else
50 #include "wx/osx/private.h"
51 #endif
52
53 #if defined(WXMAKINGDLL_CORE)
54 # include <mach-o/dyld.h>
55 #endif
56
57 // Keep linker from discarding wxStockGDIMac
58 wxFORCE_LINK_MODULE(gdiobj)
59
60 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
61 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
62 EVT_IDLE(wxApp::OnIdle)
63 EVT_END_SESSION(wxApp::OnEndSession)
64 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
65 END_EVENT_TABLE()
66
67
68 // platform specific static variables
69 static const short kwxMacAppleMenuId = 1 ;
70
71 wxWindow* wxApp::s_captureWindow = NULL ;
72 long wxApp::s_lastModifiers = 0 ;
73
74 long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
75 long wxApp::s_macPreferencesMenuItemId = wxID_PREFERENCES ;
76 long wxApp::s_macExitMenuItemId = wxID_EXIT ;
77 wxString wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
78
79 bool wxApp::sm_isEmbedded = false; // Normally we're not a plugin
80
81 #if wxOSX_USE_CARBON
82
83 //----------------------------------------------------------------------
84 // Core Apple Event Support
85 //----------------------------------------------------------------------
86
87 AEEventHandlerUPP sODocHandler = NULL ;
88 AEEventHandlerUPP sGURLHandler = NULL ;
89 AEEventHandlerUPP sOAppHandler = NULL ;
90 AEEventHandlerUPP sPDocHandler = NULL ;
91 AEEventHandlerUPP sRAppHandler = NULL ;
92 AEEventHandlerUPP sQuitHandler = NULL ;
93
94 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
95 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
96 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
97 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
98 pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
99 pascal OSErr AEHandleGURL( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
100
101 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
102 {
103 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
104 }
105
106 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
107 {
108 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
109 }
110
111 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
112 {
113 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
114 }
115
116 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
117 {
118 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
119 }
120
121 pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
122 {
123 return wxTheApp->MacHandleAERApp( (AppleEvent*) event , reply) ;
124 }
125
126 pascal OSErr AEHandleGURL( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
127 {
128 return wxTheApp->MacHandleAEGURL((WXEVENTREF *)event , reply) ;
129 }
130
131
132 // AEODoc Calls MacOpenFiles with all of the files passed
133
134 short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
135 {
136 AEDescList docList;
137 AEKeyword keywd;
138 DescType returnedType;
139 Size actualSize;
140 long itemsInList;
141 OSErr err;
142 short i;
143
144 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
145 if (err != noErr)
146 return err;
147
148 err = AECountItems(&docList, &itemsInList);
149 if (err != noErr)
150 return err;
151
152 ProcessSerialNumber PSN ;
153 PSN.highLongOfPSN = 0 ;
154 PSN.lowLongOfPSN = kCurrentProcess ;
155 SetFrontProcess( &PSN ) ;
156
157 wxString fName ;
158 FSRef theRef ;
159
160 wxArrayString fileNames;
161 for (i = 1; i <= itemsInList; i++)
162 {
163 err = AEGetNthPtr(
164 &docList, i, typeFSRef, &keywd, &returnedType,
165 (Ptr)&theRef, sizeof(theRef), &actualSize);
166
167 if ( err != noErr)
168 return err;
169
170 fName = wxMacFSRefToPath( &theRef ) ;
171
172 fileNames.Add(fName);
173 }
174
175 MacOpenFiles(fileNames);
176
177 return noErr;
178 }
179
180 // AEODoc Calls MacOpenURL on the url passed
181
182 short wxApp::MacHandleAEGURL(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
183 {
184 DescType returnedType;
185 Size actualSize;
186 char url[255];
187 OSErr err = AEGetParamPtr((AppleEvent *)event, keyDirectObject, typeChar,
188 &returnedType, url, sizeof(url)-1,
189 &actualSize);
190 if (err != noErr)
191 return err;
192
193 url[actualSize] = '\0'; // Terminate the C string
194
195 ProcessSerialNumber PSN ;
196 PSN.highLongOfPSN = 0 ;
197 PSN.lowLongOfPSN = kCurrentProcess ;
198 SetFrontProcess( &PSN ) ;
199
200 MacOpenURL(wxString(url, wxConvUTF8));
201
202 return noErr;
203 }
204
205 // AEPDoc Calls MacPrintFile on each of the files passed
206
207 short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
208 {
209 AEDescList docList;
210 AEKeyword keywd;
211 DescType returnedType;
212 Size actualSize;
213 long itemsInList;
214 OSErr err;
215 short i;
216
217 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
218 if (err != noErr)
219 return err;
220
221 err = AECountItems(&docList, &itemsInList);
222 if (err != noErr)
223 return err;
224
225 ProcessSerialNumber PSN ;
226 PSN.highLongOfPSN = 0 ;
227 PSN.lowLongOfPSN = kCurrentProcess ;
228 SetFrontProcess( &PSN ) ;
229
230 wxString fName ;
231 FSRef theRef ;
232
233 for (i = 1; i <= itemsInList; i++)
234 {
235 err = AEGetNthPtr(
236 &docList, i, typeFSRef, &keywd, &returnedType,
237 (Ptr)&theRef, sizeof(theRef), &actualSize);
238
239 if ( err != noErr)
240 return err;
241
242 fName = wxMacFSRefToPath( &theRef ) ;
243
244 MacPrintFile(fName);
245 }
246
247 return noErr;
248 }
249
250 // AEOApp calls MacNewFile
251
252 short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
253 {
254 MacNewFile() ;
255 return noErr ;
256 }
257
258 // AEQuit attempts to quit the application
259
260 short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
261 {
262 wxCloseEvent event;
263 wxTheApp->OnQueryEndSession(event);
264 if ( !event.GetVeto() )
265 {
266 wxCloseEvent event;
267 wxTheApp->OnEndSession(event);
268 }
269 return noErr ;
270 }
271
272 // AEROApp calls MacReopenApp
273
274 short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
275 {
276 MacReopenApp() ;
277
278 return noErr ;
279 }
280
281 #endif
282
283 //----------------------------------------------------------------------
284 // Support Routines linking the Mac...File Calls to the Document Manager
285 //----------------------------------------------------------------------
286
287 void wxApp::MacOpenFiles(const wxArrayString & fileNames )
288 {
289 size_t i;
290 const size_t fileCount = fileNames.GetCount();
291 for (i = 0; i < fileCount; i++)
292 {
293 MacOpenFile(fileNames[i]);
294 }
295 }
296
297 void wxApp::MacOpenFile(const wxString & fileName )
298 {
299 #if wxUSE_DOC_VIEW_ARCHITECTURE
300 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
301 if ( dm )
302 dm->CreateDocument(fileName , wxDOC_SILENT ) ;
303 #endif
304 }
305
306 void wxApp::MacOpenURL(const wxString & WXUNUSED(url) )
307 {
308 }
309
310 void wxApp::MacPrintFile(const wxString & fileName )
311 {
312 #if wxUSE_DOC_VIEW_ARCHITECTURE
313
314 #if wxUSE_PRINTING_ARCHITECTURE
315 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
316 if ( dm )
317 {
318 wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
319 if ( doc )
320 {
321 wxView* view = doc->GetFirstView() ;
322 if ( view )
323 {
324 wxPrintout *printout = view->OnCreatePrintout();
325 if (printout)
326 {
327 wxPrinter printer;
328 printer.Print(view->GetFrame(), printout, true);
329 delete printout;
330 }
331 }
332
333 if (doc->Close())
334 {
335 doc->DeleteAllViews();
336 dm->RemoveDocument(doc) ;
337 }
338 }
339 }
340 #endif //print
341
342 #endif //docview
343 }
344
345
346
347 void wxApp::MacNewFile()
348 {
349 }
350
351 void wxApp::MacReopenApp()
352 {
353 // HIG says :
354 // if there is no open window -> create a new one
355 // if all windows are hidden -> show the first
356 // if some windows are not hidden -> do nothing
357
358 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
359 if ( !node )
360 {
361 MacNewFile() ;
362 }
363 else
364 {
365 wxTopLevelWindow* firstIconized = NULL ;
366 wxTopLevelWindow* firstHidden = NULL ;
367 while (node)
368 {
369 wxTopLevelWindow* win = (wxTopLevelWindow*) node->GetData();
370 if ( !win->IsShown() )
371 {
372 // make sure we don't show 'virtual toplevel windows' like wxTaskBarIconWindow
373 if ( firstHidden == NULL && ( wxDynamicCast( win, wxFrame ) || wxDynamicCast( win, wxDialog ) ) )
374 firstHidden = win ;
375 }
376 else if ( win->IsIconized() )
377 {
378 if ( firstIconized == NULL )
379 firstIconized = win ;
380 }
381 else
382 {
383 // we do have a visible, non-iconized toplevelwindow -> do nothing
384 return;
385 }
386
387 node = node->GetNext();
388 }
389
390 if ( firstIconized )
391 firstIconized->Iconize( false ) ;
392
393 // showing hidden windows is not really always a good solution, also non-modal dialogs when closed end up
394 // as hidden tlws, we don't want to reshow those, so let's just reopen the minimized a.k.a. iconized tlws
395 // unless we find a regression ...
396 #if 0
397 else if ( firstHidden )
398 firstHidden->Show( true );
399 #endif
400 }
401 }
402
403 #if wxOSX_USE_COCOA_OR_IPHONE
404 void wxApp::OSXOnWillFinishLaunching()
405 {
406 #if wxOSX_USE_IPHONE
407 m_onInitResult = OnInit();
408 #endif
409 }
410
411 void wxApp::OSXOnDidFinishLaunching()
412 {
413 }
414
415 void wxApp::OSXOnWillTerminate()
416 {
417 wxCloseEvent event;
418 event.SetCanVeto(false);
419 wxTheApp->OnEndSession(event);
420 }
421
422 bool wxApp::OSXOnShouldTerminate()
423 {
424 wxCloseEvent event;
425 wxTheApp->OnQueryEndSession(event);
426 return !event.GetVeto();
427 }
428 #endif
429
430 //----------------------------------------------------------------------
431 // Macintosh CommandID support - converting between native and wx IDs
432 //----------------------------------------------------------------------
433
434 // if no native match they just return the passed-in id
435
436 #if wxOSX_USE_CARBON
437
438 struct IdPair
439 {
440 UInt32 macId ;
441 int wxId ;
442 } ;
443
444 IdPair gCommandIds [] =
445 {
446 { kHICommandCut , wxID_CUT } ,
447 { kHICommandCopy , wxID_COPY } ,
448 { kHICommandPaste , wxID_PASTE } ,
449 { kHICommandSelectAll , wxID_SELECTALL } ,
450 { kHICommandClear , wxID_CLEAR } ,
451 { kHICommandUndo , wxID_UNDO } ,
452 { kHICommandRedo , wxID_REDO } ,
453 } ;
454
455 int wxMacCommandToId( UInt32 macCommandId )
456 {
457 int wxid = 0 ;
458
459 switch ( macCommandId )
460 {
461 case kHICommandPreferences :
462 wxid = wxApp::s_macPreferencesMenuItemId ;
463 break ;
464
465 case kHICommandQuit :
466 wxid = wxApp::s_macExitMenuItemId ;
467 break ;
468
469 case kHICommandAbout :
470 wxid = wxApp::s_macAboutMenuItemId ;
471 break ;
472
473 default :
474 {
475 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
476 {
477 if ( gCommandIds[i].macId == macCommandId )
478 {
479 wxid = gCommandIds[i].wxId ;
480 break ;
481 }
482 }
483 }
484 break ;
485 }
486
487 if ( wxid == 0 )
488 wxid = (int) macCommandId ;
489
490 return wxid ;
491 }
492
493 UInt32 wxIdToMacCommand( int wxId )
494 {
495 UInt32 macId = 0 ;
496
497 if ( wxId == wxApp::s_macPreferencesMenuItemId )
498 macId = kHICommandPreferences ;
499 else if (wxId == wxApp::s_macExitMenuItemId)
500 macId = kHICommandQuit ;
501 else if (wxId == wxApp::s_macAboutMenuItemId)
502 macId = kHICommandAbout ;
503 else
504 {
505 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
506 {
507 if ( gCommandIds[i].wxId == wxId )
508 {
509 macId = gCommandIds[i].macId ;
510 break ;
511 }
512 }
513 }
514
515 if ( macId == 0 )
516 macId = (int) wxId ;
517
518 return macId ;
519 }
520
521 wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
522 {
523 wxMenu* itemMenu = NULL ;
524 #ifndef __WXUNIVERSAL__
525 int id = 0 ;
526
527 // for 'standard' commands which don't have a wx-menu
528 if ( command.commandID == kHICommandPreferences || command.commandID == kHICommandQuit || command.commandID == kHICommandAbout )
529 {
530 id = wxMacCommandToId( command.commandID ) ;
531
532 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
533 if ( mbar )
534 item = mbar->FindItem( id , &itemMenu ) ;
535 }
536 else if ( command.commandID != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
537 {
538 id = wxMacCommandToId( command.commandID ) ;
539 // make sure it is one of our own menus, or of the 'synthetic' apple and help menus , otherwise don't touch
540 MenuItemIndex firstUserHelpMenuItem ;
541 static MenuHandle helpMenuHandle = NULL ;
542 if ( helpMenuHandle == NULL )
543 {
544 if ( UMAGetHelpMenuDontCreate( &helpMenuHandle , &firstUserHelpMenuItem) != noErr )
545 helpMenuHandle = NULL ;
546 }
547
548 // is it part of the application or the Help menu, then look for the id directly
549 if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
550 ( helpMenuHandle != NULL && command.menu.menuRef == helpMenuHandle ) ||
551 wxMenuBar::MacGetWindowMenuHMenu() != NULL && command.menu.menuRef == wxMenuBar::MacGetWindowMenuHMenu() )
552 {
553 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
554 if ( mbar )
555 item = mbar->FindItem( id , &itemMenu ) ;
556 }
557 else
558 {
559 URefCon refCon = 0 ;
560
561 GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
562 itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
563 if ( itemMenu != NULL && refCon != 0)
564 item = (wxMenuItem*) refCon;
565 }
566 }
567 #endif
568 return itemMenu ;
569 }
570
571 #endif
572
573 //----------------------------------------------------------------------
574 // Carbon Event Handler
575 //----------------------------------------------------------------------
576
577 #if wxOSX_USE_CARBON
578
579 static const EventTypeSpec eventList[] =
580 {
581 { kEventClassCommand, kEventProcessCommand } ,
582 { kEventClassCommand, kEventCommandUpdateStatus } ,
583
584 { kEventClassMenu, kEventMenuOpening },
585 { kEventClassMenu, kEventMenuClosed },
586 { kEventClassMenu, kEventMenuTargetItem },
587
588 { kEventClassApplication , kEventAppActivated } ,
589 { kEventClassApplication , kEventAppDeactivated } ,
590 // handling the quit event is not recommended by apple
591 // rather using the quit apple event - which we do
592
593 { kEventClassAppleEvent , kEventAppleEvent } ,
594
595 { kEventClassMouse , kEventMouseDown } ,
596 { kEventClassMouse , kEventMouseMoved } ,
597 { kEventClassMouse , kEventMouseUp } ,
598 { kEventClassMouse , kEventMouseDragged } ,
599 { 'WXMC' , 'WXMC' }
600 } ;
601
602 static pascal OSStatus
603 wxMacAppMenuEventHandler( EventHandlerCallRef WXUNUSED(handler),
604 EventRef event,
605 void *WXUNUSED(data) )
606 {
607 wxMacCarbonEvent cEvent( event ) ;
608 MenuRef menuRef = cEvent.GetParameter<MenuRef>(kEventParamDirectObject) ;
609 #ifndef __WXUNIVERSAL__
610 wxMenu* menu = wxFindMenuFromMacMenu( menuRef ) ;
611
612 if ( menu )
613 {
614 switch (GetEventKind(event))
615 {
616 case kEventMenuOpening:
617 menu->HandleMenuOpened();
618 break;
619
620 case kEventMenuClosed:
621 menu->HandleMenuClosed();
622 break;
623
624 case kEventMenuTargetItem:
625 {
626 HICommand command ;
627
628 command.menu.menuRef = menuRef;
629 command.menu.menuItemIndex = cEvent.GetParameter<MenuItemIndex>(kEventParamMenuItemIndex,typeMenuItemIndex) ;
630 command.commandID = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
631 if (command.commandID != 0)
632 {
633 wxMenuItem* item = NULL ;
634 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
635 if ( itemMenu && item )
636 itemMenu->HandleMenuItemHighlighted( item );
637 }
638 }
639 break;
640
641 default:
642 wxFAIL_MSG(wxT("Unexpected menu event kind"));
643 break;
644 }
645
646 }
647 #endif
648 return eventNotHandledErr;
649 }
650
651 static pascal OSStatus
652 wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
653 EventRef event ,
654 void *WXUNUSED(data) )
655 {
656 OSStatus result = eventNotHandledErr ;
657
658 HICommand command ;
659
660 wxMacCarbonEvent cEvent( event ) ;
661 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
662
663 wxMenuItem* item = NULL ;
664 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
665
666 if ( item )
667 {
668 wxASSERT( itemMenu != NULL ) ;
669
670 switch ( cEvent.GetKind() )
671 {
672 case kEventProcessCommand :
673 if ( itemMenu->HandleCommandProcess( item ) )
674 result = noErr;
675 break ;
676
677 case kEventCommandUpdateStatus:
678 if ( itemMenu->HandleCommandUpdateStatus( item ) )
679 result = noErr;
680 break ;
681
682 default :
683 break ;
684 }
685 }
686 return result ;
687 }
688
689 static pascal OSStatus
690 wxMacAppApplicationEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
691 EventRef event ,
692 void *WXUNUSED(data) )
693 {
694 OSStatus result = eventNotHandledErr ;
695 switch ( GetEventKind( event ) )
696 {
697 case kEventAppActivated :
698 if ( wxTheApp )
699 wxTheApp->SetActive( true , NULL ) ;
700 result = noErr ;
701 break ;
702
703 case kEventAppDeactivated :
704 if ( wxTheApp )
705 wxTheApp->SetActive( false , NULL ) ;
706 result = noErr ;
707 break ;
708
709 default :
710 break ;
711 }
712
713 return result ;
714 }
715
716 pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
717 {
718 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
719 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
720 wxTheApp->MacSetCurrentEvent( event , handler ) ;
721
722 OSStatus result = eventNotHandledErr ;
723 switch ( GetEventClass( event ) )
724 {
725 #ifndef __LP64__
726 case kEventClassCommand :
727 result = wxMacAppCommandEventHandler( handler , event , data ) ;
728 break ;
729 #endif
730 case kEventClassApplication :
731 result = wxMacAppApplicationEventHandler( handler , event , data ) ;
732 break ;
733 #ifndef __LP64__
734 case kEventClassMenu :
735 result = wxMacAppMenuEventHandler( handler , event , data ) ;
736 break ;
737
738 case kEventClassMouse :
739 {
740 wxMacCarbonEvent cEvent( event ) ;
741
742 WindowRef window ;
743 Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
744 ::FindWindow(screenMouseLocation, &window);
745 // only send this event in case it had not already been sent to a tlw, as we get
746 // double events otherwise (in case event.skip) was called
747 if ( window == NULL )
748 result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
749 }
750 break ;
751 #endif
752 case kEventClassAppleEvent :
753 result = AEProcessEvent(event);
754 break ;
755
756 default :
757 break ;
758 }
759
760 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
761
762 return result ;
763 }
764
765 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
766 #endif
767
768 #if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
769
770 pascal static void
771 wxMacAssertOutputHandler(OSType WXUNUSED(componentSignature),
772 UInt32 WXUNUSED(options),
773 const char *assertionString,
774 const char *exceptionLabelString,
775 const char *errorString,
776 const char *fileName,
777 long lineNumber,
778 void *value,
779 ConstStr255Param WXUNUSED(outputMsg))
780 {
781 // flow into assert handling
782 wxString fileNameStr ;
783 wxString assertionStr ;
784 wxString exceptionStr ;
785 wxString errorStr ;
786
787 #if wxUSE_UNICODE
788 fileNameStr = wxString(fileName, wxConvLocal);
789 assertionStr = wxString(assertionString, wxConvLocal);
790 exceptionStr = wxString((exceptionLabelString!=0) ? exceptionLabelString : "", wxConvLocal) ;
791 errorStr = wxString((errorString!=0) ? errorString : "", wxConvLocal) ;
792 #else
793 fileNameStr = fileName;
794 assertionStr = assertionString;
795 exceptionStr = (exceptionLabelString!=0) ? exceptionLabelString : "" ;
796 errorStr = (errorString!=0) ? errorString : "" ;
797 #endif
798
799 #if 1
800 // flow into log
801 wxLogDebug( wxT("AssertMacros: %s %s %s file: %s, line: %ld (value %p)\n"),
802 assertionStr.c_str() ,
803 exceptionStr.c_str() ,
804 errorStr.c_str(),
805 fileNameStr.c_str(), lineNumber ,
806 value ) ;
807 #else
808
809 wxOnAssert(fileNameStr, lineNumber , assertionStr ,
810 wxString::Format( wxT("%s %s value (%p)") , exceptionStr, errorStr , value ) ) ;
811 #endif
812 }
813
814 #endif // wxDEBUG_LEVEL
815
816 bool wxApp::Initialize(int& argc, wxChar **argv)
817 {
818 // Mac-specific
819
820 #if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
821 InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
822 #endif
823
824 // Mac OS X passes a process serial number command line argument when
825 // the application is launched from the Finder. This argument must be
826 // removed from the command line arguments before being handled by the
827 // application (otherwise applications would need to handle it)
828 if ( argc > 1 )
829 {
830 static const wxChar *ARG_PSN = wxT("-psn_");
831 if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 )
832 {
833 // remove this argument
834 --argc;
835 memmove(argv + 1, argv + 2, argc * sizeof(wxChar*));
836 }
837 }
838
839 /*
840 Cocoa supports -Key value options which set the user defaults key "Key"
841 to the value "value" Some of them are very handy for debugging like
842 -NSShowAllViews YES. Cocoa picks these up from the real argv so
843 our removal of them from the wx copy of it does not affect Cocoa's
844 ability to see them.
845
846 We basically just assume that any "-NS" option and its following
847 argument needs to be removed from argv. We hope that user code does
848 not expect to see -NS options and indeed it's probably a safe bet
849 since most user code accepting options is probably using the
850 double-dash GNU-style syntax.
851 */
852 for(int i=1; i < argc; ++i)
853 {
854 static const wxChar *ARG_NS = wxT("-NS");
855 if( wxStrncmp(argv[i], ARG_NS, wxStrlen(ARG_NS)) == 0 )
856 {
857 // Only eat this option if it has an argument
858 if( (i + 1) < argc )
859 {
860 memmove(argv + i, argv + i + 2, (argc-i-1)*sizeof(wxChar*));
861 argc -= 2;
862 // drop back one position so the next run through the loop
863 // reprocesses the argument at our current index.
864 --i;
865 }
866 }
867 }
868
869 if ( !wxAppBase::Initialize(argc, argv) )
870 return false;
871
872 #if wxUSE_INTL
873 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
874 #endif
875
876 // these might be the startup dirs, set them to the 'usual' dir containing the app bundle
877 wxString startupCwd = wxGetCwd() ;
878 if ( startupCwd == wxT("/") || startupCwd.Right(15) == wxT("/Contents/MacOS") )
879 {
880 CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle() ) ;
881 CFURLRef urlParent = CFURLCreateCopyDeletingLastPathComponent( kCFAllocatorDefault , url ) ;
882 CFRelease( url ) ;
883 CFStringRef path = CFURLCopyFileSystemPath ( urlParent , kCFURLPOSIXPathStyle ) ;
884 CFRelease( urlParent ) ;
885 wxString cwd = wxCFStringRef(path).AsString(wxLocale::GetSystemEncoding());
886 wxSetWorkingDirectory( cwd ) ;
887 }
888
889 return true;
890 }
891
892 #if wxOSX_USE_CARBON
893 bool wxApp::CallOnInit()
894 {
895 wxMacAutoreleasePool autoreleasepool;
896 return OnInit();
897 }
898 #endif
899
900 bool wxApp::OnInitGui()
901 {
902 if ( !wxAppBase::OnInitGui() )
903 return false ;
904
905 if ( !DoInitGui() )
906 return false;
907
908 return true ;
909 }
910
911 bool wxApp::ProcessIdle()
912 {
913 wxMacAutoreleasePool autoreleasepool;
914 return wxAppBase::ProcessIdle();
915 }
916
917 int wxApp::OnRun()
918 {
919 wxMacAutoreleasePool pool;
920 return wxAppBase::OnRun();
921 }
922
923 #if wxOSX_USE_CARBON
924 bool wxApp::DoInitGui()
925 {
926 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
927 if (!sm_isEmbedded)
928 {
929 InstallApplicationEventHandler(
930 GetwxMacAppEventHandlerUPP(),
931 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
932 }
933
934 if (!sm_isEmbedded)
935 {
936 sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
937 sGURLHandler = NewAEEventHandlerUPP(AEHandleGURL) ;
938 sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
939 sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
940 sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
941 sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
942
943 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
944 sODocHandler , 0 , FALSE ) ;
945 AEInstallEventHandler( kInternetEventClass, kAEGetURL,
946 sGURLHandler , 0 , FALSE ) ;
947 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
948 sOAppHandler , 0 , FALSE ) ;
949 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
950 sPDocHandler , 0 , FALSE ) ;
951 AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
952 sRAppHandler , 0 , FALSE ) ;
953 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
954 sQuitHandler , 0 , FALSE ) ;
955 }
956
957 if ( !wxMacInitCocoa() )
958 return false;
959
960 return true;
961 }
962
963 void wxApp::DoCleanUp()
964 {
965 if (!sm_isEmbedded)
966 RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
967
968 if (!sm_isEmbedded)
969 {
970 AERemoveEventHandler( kCoreEventClass , kAEOpenDocuments ,
971 sODocHandler , FALSE ) ;
972 AERemoveEventHandler( kInternetEventClass, kAEGetURL,
973 sGURLHandler , FALSE ) ;
974 AERemoveEventHandler( kCoreEventClass , kAEOpenApplication ,
975 sOAppHandler , FALSE ) ;
976 AERemoveEventHandler( kCoreEventClass , kAEPrintDocuments ,
977 sPDocHandler , FALSE ) ;
978 AERemoveEventHandler( kCoreEventClass , kAEReopenApplication ,
979 sRAppHandler , FALSE ) ;
980 AERemoveEventHandler( kCoreEventClass , kAEQuitApplication ,
981 sQuitHandler , FALSE ) ;
982
983 DisposeAEEventHandlerUPP( sODocHandler ) ;
984 DisposeAEEventHandlerUPP( sGURLHandler ) ;
985 DisposeAEEventHandlerUPP( sOAppHandler ) ;
986 DisposeAEEventHandlerUPP( sPDocHandler ) ;
987 DisposeAEEventHandlerUPP( sRAppHandler ) ;
988 DisposeAEEventHandlerUPP( sQuitHandler ) ;
989 }
990 }
991
992 #endif
993
994 void wxApp::CleanUp()
995 {
996 wxMacAutoreleasePool autoreleasepool;
997 #if wxUSE_TOOLTIPS
998 wxToolTip::RemoveToolTips() ;
999 #endif
1000
1001 DoCleanUp();
1002
1003 wxAppBase::CleanUp();
1004 }
1005
1006 //----------------------------------------------------------------------
1007 // misc initialization stuff
1008 //----------------------------------------------------------------------
1009
1010 wxApp::wxApp()
1011 {
1012 m_printMode = wxPRINT_WINDOWS;
1013
1014 m_macCurrentEvent = NULL ;
1015 m_macCurrentEventHandlerCallRef = NULL ;
1016 m_macPool = new wxMacAutoreleasePool();
1017 }
1018
1019 wxApp::~wxApp()
1020 {
1021 if (m_macPool)
1022 delete m_macPool;
1023 }
1024
1025 CFMutableArrayRef GetAutoReleaseArray()
1026 {
1027 static CFMutableArrayRef array = 0;
1028 if ( array == 0)
1029 array= CFArrayCreateMutable(kCFAllocatorDefault,0,&kCFTypeArrayCallBacks);
1030 return array;
1031 }
1032
1033 void wxApp::MacAddToAutorelease( void* cfrefobj )
1034 {
1035 CFArrayAppendValue( GetAutoReleaseArray(), cfrefobj );
1036 }
1037
1038 void wxApp::MacReleaseAutoreleasePool()
1039 {
1040 if (m_macPool)
1041 delete m_macPool;
1042 m_macPool = new wxMacAutoreleasePool();
1043 }
1044
1045 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
1046 {
1047 // If they are pending events, we must process them: pending events are
1048 // either events to the threads other than main or events posted with
1049 // wxPostEvent() functions
1050 #ifndef __WXUNIVERSAL__
1051 #if wxUSE_MENUS
1052 if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1053 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1054 #endif
1055 #endif
1056 CFArrayRemoveAllValues( GetAutoReleaseArray() );
1057 }
1058
1059 void wxApp::WakeUpIdle()
1060 {
1061 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
1062
1063 if ( loop )
1064 loop->WakeUp();
1065 }
1066
1067 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1068 {
1069 if (GetTopWindow())
1070 GetTopWindow()->Close(true);
1071 }
1072
1073 // Default behaviour: close the application with prompts. The
1074 // user can veto the close, and therefore the end session.
1075 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1076 {
1077 if ( !wxDialog::OSXHasModalDialogsOpen() )
1078 {
1079 if (GetTopWindow())
1080 {
1081 if (!GetTopWindow()->Close(!event.CanVeto()))
1082 event.Veto(true);
1083 }
1084 }
1085 else
1086 {
1087 event.Veto(true);
1088 }
1089 }
1090
1091 extern "C" void wxCYield() ;
1092 void wxCYield()
1093 {
1094 wxYield() ;
1095 }
1096
1097 // virtual
1098 void wxApp::MacHandleUnhandledEvent( WXEVENTREF WXUNUSED(evr) )
1099 {
1100 // Override to process unhandled events as you please
1101 }
1102
1103 #if wxOSX_USE_COCOA_OR_CARBON
1104
1105 CGKeyCode wxCharCodeWXToOSX(wxKeyCode code)
1106 {
1107 CGKeyCode keycode;
1108
1109 switch (code)
1110 {
1111 // Clang warns about switch values not of the same type as (enumerated)
1112 // switch controlling expression. This is generally useful but here we
1113 // really want to be able to use letters and digits without making them
1114 // part of wxKeyCode enum.
1115 #ifdef __clang__
1116 #pragma clang diagnostic push
1117 #pragma clang diagnostic ignored "-Wswitch"
1118 #endif // __clang__
1119
1120 case 'a': case 'A': keycode = kVK_ANSI_A; break;
1121 case 'b': case 'B': keycode = kVK_ANSI_B; break;
1122 case 'c': case 'C': keycode = kVK_ANSI_C; break;
1123 case 'd': case 'D': keycode = kVK_ANSI_D; break;
1124 case 'e': case 'E': keycode = kVK_ANSI_E; break;
1125 case 'f': case 'F': keycode = kVK_ANSI_F; break;
1126 case 'g': case 'G': keycode = kVK_ANSI_G; break;
1127 case 'h': case 'H': keycode = kVK_ANSI_H; break;
1128 case 'i': case 'I': keycode = kVK_ANSI_I; break;
1129 case 'j': case 'J': keycode = kVK_ANSI_J; break;
1130 case 'k': case 'K': keycode = kVK_ANSI_K; break;
1131 case 'l': case 'L': keycode = kVK_ANSI_L; break;
1132 case 'm': case 'M': keycode = kVK_ANSI_M; break;
1133 case 'n': case 'N': keycode = kVK_ANSI_N; break;
1134 case 'o': case 'O': keycode = kVK_ANSI_O; break;
1135 case 'p': case 'P': keycode = kVK_ANSI_P; break;
1136 case 'q': case 'Q': keycode = kVK_ANSI_Q; break;
1137 case 'r': case 'R': keycode = kVK_ANSI_R; break;
1138 case 's': case 'S': keycode = kVK_ANSI_S; break;
1139 case 't': case 'T': keycode = kVK_ANSI_T; break;
1140 case 'u': case 'U': keycode = kVK_ANSI_U; break;
1141 case 'v': case 'V': keycode = kVK_ANSI_V; break;
1142 case 'w': case 'W': keycode = kVK_ANSI_W; break;
1143 case 'x': case 'X': keycode = kVK_ANSI_X; break;
1144 case 'y': case 'Y': keycode = kVK_ANSI_Y; break;
1145 case 'z': case 'Z': keycode = kVK_ANSI_Z; break;
1146
1147 case '0': keycode = kVK_ANSI_0; break;
1148 case '1': keycode = kVK_ANSI_1; break;
1149 case '2': keycode = kVK_ANSI_2; break;
1150 case '3': keycode = kVK_ANSI_3; break;
1151 case '4': keycode = kVK_ANSI_4; break;
1152 case '5': keycode = kVK_ANSI_5; break;
1153 case '6': keycode = kVK_ANSI_6; break;
1154 case '7': keycode = kVK_ANSI_7; break;
1155 case '8': keycode = kVK_ANSI_8; break;
1156 case '9': keycode = kVK_ANSI_9; break;
1157
1158 #ifdef __clang__
1159 #pragma clang diagnostic pop
1160 #endif // __clang__
1161
1162 case WXK_BACK: keycode = kVK_Delete; break;
1163 case WXK_TAB: keycode = kVK_Tab; break;
1164 case WXK_RETURN: keycode = kVK_Return; break;
1165 case WXK_ESCAPE: keycode = kVK_Escape; break;
1166 case WXK_SPACE: keycode = kVK_Space; break;
1167 case WXK_DELETE: keycode = kVK_ForwardDelete; break;
1168
1169 case WXK_SHIFT: keycode = kVK_Shift; break;
1170 case WXK_ALT: keycode = kVK_Option; break;
1171 case WXK_RAW_CONTROL: keycode = kVK_Control; break;
1172 case WXK_CONTROL: keycode = kVK_Command; break;
1173
1174 case WXK_CAPITAL: keycode = kVK_CapsLock; break;
1175 case WXK_END: keycode = kVK_End; break;
1176 case WXK_HOME: keycode = kVK_Home; break;
1177 case WXK_LEFT: keycode = kVK_LeftArrow; break;
1178 case WXK_UP: keycode = kVK_UpArrow; break;
1179 case WXK_RIGHT: keycode = kVK_RightArrow; break;
1180 case WXK_DOWN: keycode = kVK_DownArrow; break;
1181
1182 case WXK_HELP: keycode = kVK_Help; break;
1183
1184
1185 case WXK_NUMPAD0: keycode = kVK_ANSI_Keypad0; break;
1186 case WXK_NUMPAD1: keycode = kVK_ANSI_Keypad1; break;
1187 case WXK_NUMPAD2: keycode = kVK_ANSI_Keypad2; break;
1188 case WXK_NUMPAD3: keycode = kVK_ANSI_Keypad3; break;
1189 case WXK_NUMPAD4: keycode = kVK_ANSI_Keypad4; break;
1190 case WXK_NUMPAD5: keycode = kVK_ANSI_Keypad5; break;
1191 case WXK_NUMPAD6: keycode = kVK_ANSI_Keypad6; break;
1192 case WXK_NUMPAD7: keycode = kVK_ANSI_Keypad7; break;
1193 case WXK_NUMPAD8: keycode = kVK_ANSI_Keypad8; break;
1194 case WXK_NUMPAD9: keycode = kVK_ANSI_Keypad9; break;
1195 case WXK_F1: keycode = kVK_F1; break;
1196 case WXK_F2: keycode = kVK_F2; break;
1197 case WXK_F3: keycode = kVK_F3; break;
1198 case WXK_F4: keycode = kVK_F4; break;
1199 case WXK_F5: keycode = kVK_F5; break;
1200 case WXK_F6: keycode = kVK_F6; break;
1201 case WXK_F7: keycode = kVK_F7; break;
1202 case WXK_F8: keycode = kVK_F8; break;
1203 case WXK_F9: keycode = kVK_F9; break;
1204 case WXK_F10: keycode = kVK_F10; break;
1205 case WXK_F11: keycode = kVK_F11; break;
1206 case WXK_F12: keycode = kVK_F12; break;
1207 case WXK_F13: keycode = kVK_F13; break;
1208 case WXK_F14: keycode = kVK_F14; break;
1209 case WXK_F15: keycode = kVK_F15; break;
1210 case WXK_F16: keycode = kVK_F16; break;
1211 case WXK_F17: keycode = kVK_F17; break;
1212 case WXK_F18: keycode = kVK_F18; break;
1213 case WXK_F19: keycode = kVK_F19; break;
1214 case WXK_F20: keycode = kVK_F20; break;
1215
1216 case WXK_PAGEUP: keycode = kVK_PageUp; break;
1217 case WXK_PAGEDOWN: keycode = kVK_PageDown; break;
1218
1219 case WXK_NUMPAD_DELETE: keycode = kVK_ANSI_KeypadClear; break;
1220 case WXK_NUMPAD_EQUAL: keycode = kVK_ANSI_KeypadEquals; break;
1221 case WXK_NUMPAD_MULTIPLY: keycode = kVK_ANSI_KeypadMultiply; break;
1222 case WXK_NUMPAD_ADD: keycode = kVK_ANSI_KeypadPlus; break;
1223 case WXK_NUMPAD_SUBTRACT: keycode = kVK_ANSI_KeypadMinus; break;
1224 case WXK_NUMPAD_DECIMAL: keycode = kVK_ANSI_KeypadDecimal; break;
1225 case WXK_NUMPAD_DIVIDE: keycode = kVK_ANSI_KeypadDivide; break;
1226
1227 default:
1228 wxLogDebug( "Unrecognised keycode %d", code );
1229 keycode = static_cast<CGKeyCode>(-1);
1230 }
1231
1232 return keycode;
1233 }
1234
1235 long wxMacTranslateKey(unsigned char key, unsigned char code)
1236 {
1237 long retval = key ;
1238 switch (key)
1239 {
1240 case kHomeCharCode :
1241 retval = WXK_HOME;
1242 break;
1243
1244 case kEnterCharCode :
1245 retval = WXK_RETURN;
1246 break;
1247 case kEndCharCode :
1248 retval = WXK_END;
1249 break;
1250
1251 case kHelpCharCode :
1252 retval = WXK_HELP;
1253 break;
1254
1255 case kBackspaceCharCode :
1256 retval = WXK_BACK;
1257 break;
1258
1259 case kTabCharCode :
1260 retval = WXK_TAB;
1261 break;
1262
1263 case kPageUpCharCode :
1264 retval = WXK_PAGEUP;
1265 break;
1266
1267 case kPageDownCharCode :
1268 retval = WXK_PAGEDOWN;
1269 break;
1270
1271 case kReturnCharCode :
1272 retval = WXK_RETURN;
1273 break;
1274
1275 case kFunctionKeyCharCode :
1276 {
1277 switch ( code )
1278 {
1279 case 0x7a :
1280 retval = WXK_F1 ;
1281 break;
1282
1283 case 0x78 :
1284 retval = WXK_F2 ;
1285 break;
1286
1287 case 0x63 :
1288 retval = WXK_F3 ;
1289 break;
1290
1291 case 0x76 :
1292 retval = WXK_F4 ;
1293 break;
1294
1295 case 0x60 :
1296 retval = WXK_F5 ;
1297 break;
1298
1299 case 0x61 :
1300 retval = WXK_F6 ;
1301 break;
1302
1303 case 0x62:
1304 retval = WXK_F7 ;
1305 break;
1306
1307 case 0x64 :
1308 retval = WXK_F8 ;
1309 break;
1310
1311 case 0x65 :
1312 retval = WXK_F9 ;
1313 break;
1314
1315 case 0x6D :
1316 retval = WXK_F10 ;
1317 break;
1318
1319 case 0x67 :
1320 retval = WXK_F11 ;
1321 break;
1322
1323 case 0x6F :
1324 retval = WXK_F12 ;
1325 break;
1326
1327 case 0x69 :
1328 retval = WXK_F13 ;
1329 break;
1330
1331 case 0x6B :
1332 retval = WXK_F14 ;
1333 break;
1334
1335 case 0x71 :
1336 retval = WXK_F15 ;
1337 break;
1338
1339 default:
1340 break;
1341 }
1342 }
1343 break ;
1344
1345 case kEscapeCharCode :
1346 retval = WXK_ESCAPE ;
1347 break ;
1348
1349 case kLeftArrowCharCode :
1350 retval = WXK_LEFT ;
1351 break ;
1352
1353 case kRightArrowCharCode :
1354 retval = WXK_RIGHT ;
1355 break ;
1356
1357 case kUpArrowCharCode :
1358 retval = WXK_UP ;
1359 break ;
1360
1361 case kDownArrowCharCode :
1362 retval = WXK_DOWN ;
1363 break ;
1364
1365 case kDeleteCharCode :
1366 retval = WXK_DELETE ;
1367 break ;
1368
1369 default:
1370 break ;
1371 } // end switch
1372
1373 return retval;
1374 }
1375
1376 int wxMacKeyCodeToModifier(wxKeyCode key)
1377 {
1378 switch (key)
1379 {
1380 case WXK_START:
1381 case WXK_MENU:
1382 case WXK_COMMAND:
1383 return cmdKey;
1384
1385 case WXK_SHIFT:
1386 return shiftKey;
1387
1388 case WXK_CAPITAL:
1389 return alphaLock;
1390
1391 case WXK_ALT:
1392 return optionKey;
1393
1394 case WXK_RAW_CONTROL:
1395 return controlKey;
1396
1397 default:
1398 return 0;
1399 }
1400 }
1401 #endif
1402
1403 #if wxOSX_USE_COCOA && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
1404
1405 // defined in utils.mm
1406
1407 #elif wxOSX_USE_COCOA_OR_CARBON
1408
1409 wxMouseState wxGetMouseState()
1410 {
1411 wxMouseState ms;
1412
1413 wxPoint pt = wxGetMousePosition();
1414 ms.SetX(pt.x);
1415 ms.SetY(pt.y);
1416
1417 UInt32 buttons = GetCurrentButtonState();
1418 ms.SetLeftDown( (buttons & 0x01) != 0 );
1419 ms.SetMiddleDown( (buttons & 0x04) != 0 );
1420 ms.SetRightDown( (buttons & 0x02) != 0 );
1421
1422 UInt32 modifiers = GetCurrentKeyModifiers();
1423 ms.SetRawControlDown(modifiers & controlKey);
1424 ms.SetShiftDown(modifiers & shiftKey);
1425 ms.SetAltDown(modifiers & optionKey);
1426 ms.SetControlDown(modifiers & cmdKey);
1427
1428 return ms;
1429 }
1430
1431 #endif
1432
1433 // TODO : once the new key/char handling is tested, move all the code to wxWindow
1434
1435 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1436 {
1437 if ( !focus )
1438 return false ;
1439
1440 wxKeyEvent event(wxEVT_KEY_DOWN) ;
1441 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1442
1443 return focus->OSXHandleKeyEvent(event);
1444 }
1445
1446 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1447 {
1448 if ( !focus )
1449 return false ;
1450
1451 wxKeyEvent event( wxEVT_KEY_UP ) ;
1452 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1453
1454 return focus->OSXHandleKeyEvent(event) ;
1455 }
1456
1457 bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1458 {
1459 if ( !focus )
1460 return false ;
1461 wxKeyEvent event(wxEVT_CHAR) ;
1462 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1463
1464 bool handled = false ;
1465
1466 #if wxOSX_USE_CARBON
1467 long keyval = event.m_keyCode ;
1468
1469 {
1470 wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
1471 handled = focus->HandleWindowEvent( eventCharHook );
1472 if ( handled && eventCharHook.IsNextEventAllowed() )
1473 handled = false ;
1474 }
1475
1476 if ( !handled )
1477 {
1478 handled = focus->HandleWindowEvent( event ) ;
1479 }
1480
1481 if ( !handled && (keyval == WXK_TAB) )
1482 {
1483 wxWindow* iter = focus->GetParent() ;
1484 while ( iter && !handled )
1485 {
1486 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1487 {
1488 wxNavigationKeyEvent new_event;
1489 new_event.SetEventObject( focus );
1490 new_event.SetDirection( !event.ShiftDown() );
1491 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1492 new_event.SetWindowChange( event.ControlDown() );
1493 new_event.SetCurrentFocus( focus );
1494 handled = focus->GetParent()->HandleWindowEvent( new_event );
1495 if ( handled && new_event.GetSkipped() )
1496 handled = false ;
1497 }
1498
1499 iter = iter->GetParent() ;
1500 }
1501 }
1502
1503 // backdoor handler for default return and command escape
1504 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->AcceptsFocus() ) )
1505 {
1506 // if window is not having a focus still testing for default enter or cancel
1507 // TODO: add the UMA version for ActiveNonFloatingWindow
1508 #ifndef __LP64__
1509 wxWindow* focus = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) FrontWindow() ) ;
1510 if ( focus )
1511 {
1512 if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
1513 {
1514 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(focus), wxTopLevelWindow);
1515 if ( tlw && tlw->GetDefaultItem() )
1516 {
1517 wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
1518 if ( def && def->IsEnabled() )
1519 {
1520 wxCommandEvent event(wxEVT_BUTTON, def->GetId() );
1521 event.SetEventObject(def);
1522 def->Command(event);
1523
1524 return true ;
1525 }
1526 }
1527 }
1528 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1529 {
1530 // generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
1531 wxCommandEvent new_event(wxEVT_BUTTON,wxID_CANCEL);
1532 new_event.SetEventObject( focus );
1533 handled = focus->HandleWindowEvent( new_event );
1534 }
1535 }
1536 #endif
1537 }
1538 #endif
1539 return handled ;
1540 }
1541
1542 // This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
1543 void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1544 {
1545 #if wxOSX_USE_COCOA_OR_CARBON
1546
1547 short keycode, keychar ;
1548
1549 keychar = short(keymessage & charCodeMask);
1550 keycode = short(keymessage & keyCodeMask) >> 8 ;
1551 if ( !(event.GetEventType() == wxEVT_CHAR) && (modifiers & (controlKey | shiftKey | optionKey) ) )
1552 {
1553 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1554 // and look at the character after
1555 #ifdef __LP64__
1556 // TODO new implementation using TextInputSources
1557 #else
1558 UInt32 state = 0;
1559 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey | shiftKey | optionKey))) | keycode, &state);
1560 keychar = short(keyInfo & charCodeMask);
1561 #endif
1562 }
1563
1564 long keyval = wxMacTranslateKey(keychar, keycode) ;
1565 if ( keyval == keychar && ( event.GetEventType() == wxEVT_KEY_UP || event.GetEventType() == wxEVT_KEY_DOWN ) )
1566 keyval = wxToupper( keyval ) ;
1567
1568 // Check for NUMPAD keys. For KEY_UP/DOWN events we need to use the
1569 // WXK_NUMPAD constants, but for the CHAR event we want to use the
1570 // standard ascii values
1571 if ( event.GetEventType() != wxEVT_CHAR )
1572 {
1573 if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
1574 {
1575 keyval = (keyval - '0') + WXK_NUMPAD0;
1576 }
1577 else if (keycode >= 65 && keycode <= 81)
1578 {
1579 switch (keycode)
1580 {
1581 case 76 :
1582 keyval = WXK_NUMPAD_ENTER;
1583 break;
1584
1585 case 81:
1586 keyval = WXK_NUMPAD_EQUAL;
1587 break;
1588
1589 case 67:
1590 keyval = WXK_NUMPAD_MULTIPLY;
1591 break;
1592
1593 case 75:
1594 keyval = WXK_NUMPAD_DIVIDE;
1595 break;
1596
1597 case 78:
1598 keyval = WXK_NUMPAD_SUBTRACT;
1599 break;
1600
1601 case 69:
1602 keyval = WXK_NUMPAD_ADD;
1603 break;
1604
1605 case 65:
1606 keyval = WXK_NUMPAD_DECIMAL;
1607 break;
1608 default:
1609 break;
1610 }
1611 }
1612 }
1613
1614 event.m_shiftDown = modifiers & shiftKey;
1615 event.m_rawControlDown = modifiers & controlKey;
1616 event.m_altDown = modifiers & optionKey;
1617 event.m_controlDown = modifiers & cmdKey;
1618 event.m_keyCode = keyval ;
1619 #if wxUSE_UNICODE
1620 event.m_uniChar = uniChar ;
1621 #endif
1622
1623 event.m_rawCode = keymessage;
1624 event.m_rawFlags = modifiers;
1625 event.SetTimestamp(when);
1626 event.SetEventObject(focus);
1627 #else
1628 wxUnusedVar(event);
1629 wxUnusedVar(focus);
1630 wxUnusedVar(keymessage);
1631 wxUnusedVar(modifiers);
1632 wxUnusedVar(when);
1633 wxUnusedVar(uniChar);
1634 #endif
1635 }
1636
1637
1638 void wxApp::MacHideApp()
1639 {
1640 #if wxOSX_USE_CARBON
1641 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
1642 HICommand command;
1643 memset( &command, 0 , sizeof(command) );
1644 command.commandID = kHICommandHide ;
1645 event.SetParameter<HICommand>(kEventParamDirectObject, command );
1646 SendEventToApplication( event );
1647 #endif
1648 }
wxWidgets (Impactor)