]> 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
Expose the Apple menu so it can be setup manually.
[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 m_onInitResult = OnInit();
407 }
408
409 void wxApp::OSXOnDidFinishLaunching()
410 {
411 }
412
413 void wxApp::OSXOnWillTerminate()
414 {
415 wxCloseEvent event;
416 event.SetCanVeto(false);
417 wxTheApp->OnEndSession(event);
418 }
419
420 bool wxApp::OSXOnShouldTerminate()
421 {
422 wxCloseEvent event;
423 wxTheApp->OnQueryEndSession(event);
424 return !event.GetVeto();
425 }
426 #endif
427
428 //----------------------------------------------------------------------
429 // Macintosh CommandID support - converting between native and wx IDs
430 //----------------------------------------------------------------------
431
432 // if no native match they just return the passed-in id
433
434 #if wxOSX_USE_CARBON
435
436 struct IdPair
437 {
438 UInt32 macId ;
439 int wxId ;
440 } ;
441
442 IdPair gCommandIds [] =
443 {
444 { kHICommandCut , wxID_CUT } ,
445 { kHICommandCopy , wxID_COPY } ,
446 { kHICommandPaste , wxID_PASTE } ,
447 { kHICommandSelectAll , wxID_SELECTALL } ,
448 { kHICommandClear , wxID_CLEAR } ,
449 { kHICommandUndo , wxID_UNDO } ,
450 { kHICommandRedo , wxID_REDO } ,
451 } ;
452
453 int wxMacCommandToId( UInt32 macCommandId )
454 {
455 int wxid = 0 ;
456
457 switch ( macCommandId )
458 {
459 case kHICommandPreferences :
460 wxid = wxApp::s_macPreferencesMenuItemId ;
461 break ;
462
463 case kHICommandQuit :
464 wxid = wxApp::s_macExitMenuItemId ;
465 break ;
466
467 case kHICommandAbout :
468 wxid = wxApp::s_macAboutMenuItemId ;
469 break ;
470
471 default :
472 {
473 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
474 {
475 if ( gCommandIds[i].macId == macCommandId )
476 {
477 wxid = gCommandIds[i].wxId ;
478 break ;
479 }
480 }
481 }
482 break ;
483 }
484
485 if ( wxid == 0 )
486 wxid = (int) macCommandId ;
487
488 return wxid ;
489 }
490
491 UInt32 wxIdToMacCommand( int wxId )
492 {
493 UInt32 macId = 0 ;
494
495 if ( wxId == wxApp::s_macPreferencesMenuItemId )
496 macId = kHICommandPreferences ;
497 else if (wxId == wxApp::s_macExitMenuItemId)
498 macId = kHICommandQuit ;
499 else if (wxId == wxApp::s_macAboutMenuItemId)
500 macId = kHICommandAbout ;
501 else
502 {
503 for ( size_t i = 0 ; i < WXSIZEOF(gCommandIds) ; ++i )
504 {
505 if ( gCommandIds[i].wxId == wxId )
506 {
507 macId = gCommandIds[i].macId ;
508 break ;
509 }
510 }
511 }
512
513 if ( macId == 0 )
514 macId = (int) wxId ;
515
516 return macId ;
517 }
518
519 wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
520 {
521 wxMenu* itemMenu = NULL ;
522 #ifndef __WXUNIVERSAL__
523 int id = 0 ;
524
525 // for 'standard' commands which don't have a wx-menu
526 if ( command.commandID == kHICommandPreferences || command.commandID == kHICommandQuit || command.commandID == kHICommandAbout )
527 {
528 id = wxMacCommandToId( command.commandID ) ;
529
530 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
531 if ( mbar )
532 item = mbar->FindItem( id , &itemMenu ) ;
533 }
534 else if ( command.commandID != 0 && command.menu.menuRef != 0 && command.menu.menuItemIndex != 0 )
535 {
536 id = wxMacCommandToId( command.commandID ) ;
537 // make sure it is one of our own menus, or of the 'synthetic' apple and help menus , otherwise don't touch
538 MenuItemIndex firstUserHelpMenuItem ;
539 static MenuHandle helpMenuHandle = NULL ;
540 if ( helpMenuHandle == NULL )
541 {
542 if ( UMAGetHelpMenuDontCreate( &helpMenuHandle , &firstUserHelpMenuItem) != noErr )
543 helpMenuHandle = NULL ;
544 }
545
546 // is it part of the application or the Help menu, then look for the id directly
547 if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
548 ( helpMenuHandle != NULL && command.menu.menuRef == helpMenuHandle ) ||
549 wxMenuBar::MacGetWindowMenuHMenu() != NULL && command.menu.menuRef == wxMenuBar::MacGetWindowMenuHMenu() )
550 {
551 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
552 if ( mbar )
553 item = mbar->FindItem( id , &itemMenu ) ;
554 }
555 else
556 {
557 URefCon refCon = 0 ;
558
559 GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
560 itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
561 if ( itemMenu != NULL && refCon != 0)
562 item = (wxMenuItem*) refCon;
563 }
564 }
565 #endif
566 return itemMenu ;
567 }
568
569 #endif
570
571 //----------------------------------------------------------------------
572 // Carbon Event Handler
573 //----------------------------------------------------------------------
574
575 #if wxOSX_USE_CARBON
576
577 static const EventTypeSpec eventList[] =
578 {
579 { kEventClassCommand, kEventProcessCommand } ,
580 { kEventClassCommand, kEventCommandUpdateStatus } ,
581
582 { kEventClassMenu, kEventMenuOpening },
583 { kEventClassMenu, kEventMenuClosed },
584 { kEventClassMenu, kEventMenuTargetItem },
585
586 { kEventClassApplication , kEventAppActivated } ,
587 { kEventClassApplication , kEventAppDeactivated } ,
588 // handling the quit event is not recommended by apple
589 // rather using the quit apple event - which we do
590
591 { kEventClassAppleEvent , kEventAppleEvent } ,
592
593 { kEventClassMouse , kEventMouseDown } ,
594 { kEventClassMouse , kEventMouseMoved } ,
595 { kEventClassMouse , kEventMouseUp } ,
596 { kEventClassMouse , kEventMouseDragged } ,
597 { 'WXMC' , 'WXMC' }
598 } ;
599
600 static pascal OSStatus
601 wxMacAppMenuEventHandler( EventHandlerCallRef WXUNUSED(handler),
602 EventRef event,
603 void *WXUNUSED(data) )
604 {
605 wxMacCarbonEvent cEvent( event ) ;
606 MenuRef menuRef = cEvent.GetParameter<MenuRef>(kEventParamDirectObject) ;
607 #ifndef __WXUNIVERSAL__
608 wxMenu* menu = wxFindMenuFromMacMenu( menuRef ) ;
609
610 if ( menu )
611 {
612 switch (GetEventKind(event))
613 {
614 case kEventMenuOpening:
615 menu->HandleMenuOpened();
616 break;
617
618 case kEventMenuClosed:
619 menu->HandleMenuClosed();
620 break;
621
622 case kEventMenuTargetItem:
623 {
624 HICommand command ;
625
626 command.menu.menuRef = menuRef;
627 command.menu.menuItemIndex = cEvent.GetParameter<MenuItemIndex>(kEventParamMenuItemIndex,typeMenuItemIndex) ;
628 command.commandID = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
629 if (command.commandID != 0)
630 {
631 wxMenuItem* item = NULL ;
632 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
633 if ( itemMenu && item )
634 itemMenu->HandleMenuItemHighlighted( item );
635 }
636 }
637 break;
638
639 default:
640 wxFAIL_MSG(wxT("Unexpected menu event kind"));
641 break;
642 }
643
644 }
645 #endif
646 return eventNotHandledErr;
647 }
648
649 static pascal OSStatus
650 wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
651 EventRef event ,
652 void *WXUNUSED(data) )
653 {
654 OSStatus result = eventNotHandledErr ;
655
656 HICommand command ;
657
658 wxMacCarbonEvent cEvent( event ) ;
659 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
660
661 wxMenuItem* item = NULL ;
662 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
663
664 if ( item )
665 {
666 wxASSERT( itemMenu != NULL ) ;
667
668 switch ( cEvent.GetKind() )
669 {
670 case kEventProcessCommand :
671 if ( itemMenu->HandleCommandProcess( item ) )
672 result = noErr;
673 break ;
674
675 case kEventCommandUpdateStatus:
676 if ( itemMenu->HandleCommandUpdateStatus( item ) )
677 result = noErr;
678 break ;
679
680 default :
681 break ;
682 }
683 }
684 return result ;
685 }
686
687 static pascal OSStatus
688 wxMacAppApplicationEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
689 EventRef event ,
690 void *WXUNUSED(data) )
691 {
692 OSStatus result = eventNotHandledErr ;
693 switch ( GetEventKind( event ) )
694 {
695 case kEventAppActivated :
696 if ( wxTheApp )
697 wxTheApp->SetActive( true , NULL ) ;
698 result = noErr ;
699 break ;
700
701 case kEventAppDeactivated :
702 if ( wxTheApp )
703 wxTheApp->SetActive( false , NULL ) ;
704 result = noErr ;
705 break ;
706
707 default :
708 break ;
709 }
710
711 return result ;
712 }
713
714 pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
715 {
716 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
717 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
718 wxTheApp->MacSetCurrentEvent( event , handler ) ;
719
720 OSStatus result = eventNotHandledErr ;
721 switch ( GetEventClass( event ) )
722 {
723 #ifndef __LP64__
724 case kEventClassCommand :
725 result = wxMacAppCommandEventHandler( handler , event , data ) ;
726 break ;
727 #endif
728 case kEventClassApplication :
729 result = wxMacAppApplicationEventHandler( handler , event , data ) ;
730 break ;
731 #ifndef __LP64__
732 case kEventClassMenu :
733 result = wxMacAppMenuEventHandler( handler , event , data ) ;
734 break ;
735
736 case kEventClassMouse :
737 {
738 wxMacCarbonEvent cEvent( event ) ;
739
740 WindowRef window ;
741 Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
742 ::FindWindow(screenMouseLocation, &window);
743 // only send this event in case it had not already been sent to a tlw, as we get
744 // double events otherwise (in case event.skip) was called
745 if ( window == NULL )
746 result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
747 }
748 break ;
749 #endif
750 case kEventClassAppleEvent :
751 result = AEProcessEvent(event);
752 break ;
753
754 default :
755 break ;
756 }
757
758 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
759
760 return result ;
761 }
762
763 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
764 #endif
765
766 #if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
767
768 pascal static void
769 wxMacAssertOutputHandler(OSType WXUNUSED(componentSignature),
770 UInt32 WXUNUSED(options),
771 const char *assertionString,
772 const char *exceptionLabelString,
773 const char *errorString,
774 const char *fileName,
775 long lineNumber,
776 void *value,
777 ConstStr255Param WXUNUSED(outputMsg))
778 {
779 // flow into assert handling
780 wxString fileNameStr ;
781 wxString assertionStr ;
782 wxString exceptionStr ;
783 wxString errorStr ;
784
785 #if wxUSE_UNICODE
786 fileNameStr = wxString(fileName, wxConvLocal);
787 assertionStr = wxString(assertionString, wxConvLocal);
788 exceptionStr = wxString((exceptionLabelString!=0) ? exceptionLabelString : "", wxConvLocal) ;
789 errorStr = wxString((errorString!=0) ? errorString : "", wxConvLocal) ;
790 #else
791 fileNameStr = fileName;
792 assertionStr = assertionString;
793 exceptionStr = (exceptionLabelString!=0) ? exceptionLabelString : "" ;
794 errorStr = (errorString!=0) ? errorString : "" ;
795 #endif
796
797 #if 1
798 // flow into log
799 wxLogDebug( wxT("AssertMacros: %s %s %s file: %s, line: %ld (value %p)\n"),
800 assertionStr.c_str() ,
801 exceptionStr.c_str() ,
802 errorStr.c_str(),
803 fileNameStr.c_str(), lineNumber ,
804 value ) ;
805 #else
806
807 wxOnAssert(fileNameStr, lineNumber , assertionStr ,
808 wxString::Format( wxT("%s %s value (%p)") , exceptionStr, errorStr , value ) ) ;
809 #endif
810 }
811
812 #endif // wxDEBUG_LEVEL
813
814 bool wxApp::Initialize(int& argc, wxChar **argv)
815 {
816 // Mac-specific
817
818 #if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
819 InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
820 #endif
821
822 /*
823 Cocoa supports -Key value options which set the user defaults key "Key"
824 to the value "value" Some of them are very handy for debugging like
825 -NSShowAllViews YES. Cocoa picks these up from the real argv so
826 our removal of them from the wx copy of it does not affect Cocoa's
827 ability to see them.
828
829 We basically just assume that any "-NS" option and its following
830 argument needs to be removed from argv. We hope that user code does
831 not expect to see -NS options and indeed it's probably a safe bet
832 since most user code accepting options is probably using the
833 double-dash GNU-style syntax.
834 */
835 for(int i=1; i < argc; ++i)
836 {
837 static const wxChar *ARG_NS = wxT("-NS");
838 if( wxStrncmp(argv[i], ARG_NS, wxStrlen(ARG_NS)) == 0 )
839 {
840 // Only eat this option if it has an argument
841 if( (i + 1) < argc )
842 {
843 memmove(argv + i, argv + i + 2, (argc-i-1)*sizeof(wxChar*));
844 argc -= 2;
845 // drop back one position so the next run through the loop
846 // reprocesses the argument at our current index.
847 --i;
848 }
849 }
850 }
851
852 if ( !wxAppBase::Initialize(argc, argv) )
853 return false;
854
855 #if wxUSE_INTL
856 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
857 #endif
858
859 // these might be the startup dirs, set them to the 'usual' dir containing the app bundle
860 wxString startupCwd = wxGetCwd() ;
861 if ( startupCwd == wxT("/") || startupCwd.Right(15) == wxT("/Contents/MacOS") )
862 {
863 CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle() ) ;
864 CFURLRef urlParent = CFURLCreateCopyDeletingLastPathComponent( kCFAllocatorDefault , url ) ;
865 CFRelease( url ) ;
866 CFStringRef path = CFURLCopyFileSystemPath ( urlParent , kCFURLPOSIXPathStyle ) ;
867 CFRelease( urlParent ) ;
868 wxString cwd = wxCFStringRef(path).AsString(wxLocale::GetSystemEncoding());
869 wxSetWorkingDirectory( cwd ) ;
870 }
871
872 return true;
873 }
874
875 #if wxOSX_USE_CARBON
876 bool wxApp::CallOnInit()
877 {
878 wxMacAutoreleasePool autoreleasepool;
879 return OnInit();
880 }
881 #endif
882
883 bool wxApp::OnInitGui()
884 {
885 if ( !wxAppBase::OnInitGui() )
886 return false ;
887
888 if ( !DoInitGui() )
889 return false;
890
891 return true ;
892 }
893
894 bool wxApp::ProcessIdle()
895 {
896 wxMacAutoreleasePool autoreleasepool;
897 return wxAppBase::ProcessIdle();
898 }
899
900 int wxApp::OnRun()
901 {
902 wxMacAutoreleasePool pool;
903 return wxAppBase::OnRun();
904 }
905
906 #if wxOSX_USE_CARBON
907 bool wxApp::DoInitGui()
908 {
909 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
910 if (!sm_isEmbedded)
911 {
912 InstallApplicationEventHandler(
913 GetwxMacAppEventHandlerUPP(),
914 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
915 }
916
917 if (!sm_isEmbedded)
918 {
919 sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
920 sGURLHandler = NewAEEventHandlerUPP(AEHandleGURL) ;
921 sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
922 sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
923 sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
924 sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
925
926 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
927 sODocHandler , 0 , FALSE ) ;
928 AEInstallEventHandler( kInternetEventClass, kAEGetURL,
929 sGURLHandler , 0 , FALSE ) ;
930 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
931 sOAppHandler , 0 , FALSE ) ;
932 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
933 sPDocHandler , 0 , FALSE ) ;
934 AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
935 sRAppHandler , 0 , FALSE ) ;
936 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
937 sQuitHandler , 0 , FALSE ) ;
938 }
939
940 if ( !wxMacInitCocoa() )
941 return false;
942
943 return true;
944 }
945
946 void wxApp::DoCleanUp()
947 {
948 if (!sm_isEmbedded)
949 RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
950
951 if (!sm_isEmbedded)
952 {
953 AERemoveEventHandler( kCoreEventClass , kAEOpenDocuments ,
954 sODocHandler , FALSE ) ;
955 AERemoveEventHandler( kInternetEventClass, kAEGetURL,
956 sGURLHandler , FALSE ) ;
957 AERemoveEventHandler( kCoreEventClass , kAEOpenApplication ,
958 sOAppHandler , FALSE ) ;
959 AERemoveEventHandler( kCoreEventClass , kAEPrintDocuments ,
960 sPDocHandler , FALSE ) ;
961 AERemoveEventHandler( kCoreEventClass , kAEReopenApplication ,
962 sRAppHandler , FALSE ) ;
963 AERemoveEventHandler( kCoreEventClass , kAEQuitApplication ,
964 sQuitHandler , FALSE ) ;
965
966 DisposeAEEventHandlerUPP( sODocHandler ) ;
967 DisposeAEEventHandlerUPP( sGURLHandler ) ;
968 DisposeAEEventHandlerUPP( sOAppHandler ) ;
969 DisposeAEEventHandlerUPP( sPDocHandler ) ;
970 DisposeAEEventHandlerUPP( sRAppHandler ) ;
971 DisposeAEEventHandlerUPP( sQuitHandler ) ;
972 }
973 }
974
975 #endif
976
977 void wxApp::CleanUp()
978 {
979 wxMacAutoreleasePool autoreleasepool;
980 #if wxUSE_TOOLTIPS
981 wxToolTip::RemoveToolTips() ;
982 #endif
983
984 DoCleanUp();
985
986 wxAppBase::CleanUp();
987 }
988
989 //----------------------------------------------------------------------
990 // misc initialization stuff
991 //----------------------------------------------------------------------
992
993 wxApp::wxApp()
994 {
995 m_printMode = wxPRINT_WINDOWS;
996
997 m_macCurrentEvent = NULL ;
998 m_macCurrentEventHandlerCallRef = NULL ;
999 m_macPool = new wxMacAutoreleasePool();
1000 }
1001
1002 wxApp::~wxApp()
1003 {
1004 if (m_macPool)
1005 delete m_macPool;
1006 }
1007
1008 CFMutableArrayRef GetAutoReleaseArray()
1009 {
1010 static CFMutableArrayRef array = 0;
1011 if ( array == 0)
1012 array= CFArrayCreateMutable(kCFAllocatorDefault,0,&kCFTypeArrayCallBacks);
1013 return array;
1014 }
1015
1016 void wxApp::MacAddToAutorelease( void* cfrefobj )
1017 {
1018 CFArrayAppendValue( GetAutoReleaseArray(), cfrefobj );
1019 }
1020
1021 void wxApp::MacReleaseAutoreleasePool()
1022 {
1023 if (m_macPool)
1024 delete m_macPool;
1025 m_macPool = new wxMacAutoreleasePool();
1026 }
1027
1028 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
1029 {
1030 // If they are pending events, we must process them: pending events are
1031 // either events to the threads other than main or events posted with
1032 // wxPostEvent() functions
1033 #ifndef __WXUNIVERSAL__
1034 #if wxUSE_MENUS
1035 if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1036 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1037 #endif
1038 #endif
1039 CFArrayRemoveAllValues( GetAutoReleaseArray() );
1040 }
1041
1042 void wxApp::WakeUpIdle()
1043 {
1044 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
1045
1046 if ( loop )
1047 loop->WakeUp();
1048 }
1049
1050 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1051 {
1052 if (GetTopWindow())
1053 GetTopWindow()->Close(true);
1054 }
1055
1056 // Default behaviour: close the application with prompts. The
1057 // user can veto the close, and therefore the end session.
1058 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1059 {
1060 if ( !wxDialog::OSXHasModalDialogsOpen() )
1061 {
1062 if (GetTopWindow())
1063 {
1064 if (!GetTopWindow()->Close(!event.CanVeto()))
1065 event.Veto(true);
1066 }
1067 }
1068 else
1069 {
1070 event.Veto(true);
1071 }
1072 }
1073
1074 extern "C" void wxCYield() ;
1075 void wxCYield()
1076 {
1077 wxYield() ;
1078 }
1079
1080 // virtual
1081 void wxApp::MacHandleUnhandledEvent( WXEVENTREF WXUNUSED(evr) )
1082 {
1083 // Override to process unhandled events as you please
1084 }
1085
1086 #if wxOSX_USE_COCOA_OR_CARBON
1087
1088 CGKeyCode wxCharCodeWXToOSX(wxKeyCode code)
1089 {
1090 CGKeyCode keycode;
1091
1092 switch (code)
1093 {
1094 // Clang warns about switch values not of the same type as (enumerated)
1095 // switch controlling expression. This is generally useful but here we
1096 // really want to be able to use letters and digits without making them
1097 // part of wxKeyCode enum.
1098 #ifdef __clang__
1099 #pragma clang diagnostic push
1100 #pragma clang diagnostic ignored "-Wswitch"
1101 #endif // __clang__
1102
1103 case 'a': case 'A': keycode = kVK_ANSI_A; break;
1104 case 'b': case 'B': keycode = kVK_ANSI_B; break;
1105 case 'c': case 'C': keycode = kVK_ANSI_C; break;
1106 case 'd': case 'D': keycode = kVK_ANSI_D; break;
1107 case 'e': case 'E': keycode = kVK_ANSI_E; break;
1108 case 'f': case 'F': keycode = kVK_ANSI_F; break;
1109 case 'g': case 'G': keycode = kVK_ANSI_G; break;
1110 case 'h': case 'H': keycode = kVK_ANSI_H; break;
1111 case 'i': case 'I': keycode = kVK_ANSI_I; break;
1112 case 'j': case 'J': keycode = kVK_ANSI_J; break;
1113 case 'k': case 'K': keycode = kVK_ANSI_K; break;
1114 case 'l': case 'L': keycode = kVK_ANSI_L; break;
1115 case 'm': case 'M': keycode = kVK_ANSI_M; break;
1116 case 'n': case 'N': keycode = kVK_ANSI_N; break;
1117 case 'o': case 'O': keycode = kVK_ANSI_O; break;
1118 case 'p': case 'P': keycode = kVK_ANSI_P; break;
1119 case 'q': case 'Q': keycode = kVK_ANSI_Q; break;
1120 case 'r': case 'R': keycode = kVK_ANSI_R; break;
1121 case 's': case 'S': keycode = kVK_ANSI_S; break;
1122 case 't': case 'T': keycode = kVK_ANSI_T; break;
1123 case 'u': case 'U': keycode = kVK_ANSI_U; break;
1124 case 'v': case 'V': keycode = kVK_ANSI_V; break;
1125 case 'w': case 'W': keycode = kVK_ANSI_W; break;
1126 case 'x': case 'X': keycode = kVK_ANSI_X; break;
1127 case 'y': case 'Y': keycode = kVK_ANSI_Y; break;
1128 case 'z': case 'Z': keycode = kVK_ANSI_Z; break;
1129
1130 case '0': keycode = kVK_ANSI_0; break;
1131 case '1': keycode = kVK_ANSI_1; break;
1132 case '2': keycode = kVK_ANSI_2; break;
1133 case '3': keycode = kVK_ANSI_3; break;
1134 case '4': keycode = kVK_ANSI_4; break;
1135 case '5': keycode = kVK_ANSI_5; break;
1136 case '6': keycode = kVK_ANSI_6; break;
1137 case '7': keycode = kVK_ANSI_7; break;
1138 case '8': keycode = kVK_ANSI_8; break;
1139 case '9': keycode = kVK_ANSI_9; break;
1140
1141 #ifdef __clang__
1142 #pragma clang diagnostic pop
1143 #endif // __clang__
1144
1145 case WXK_BACK: keycode = kVK_Delete; break;
1146 case WXK_TAB: keycode = kVK_Tab; break;
1147 case WXK_RETURN: keycode = kVK_Return; break;
1148 case WXK_ESCAPE: keycode = kVK_Escape; break;
1149 case WXK_SPACE: keycode = kVK_Space; break;
1150 case WXK_DELETE: keycode = kVK_ForwardDelete; break;
1151
1152 case WXK_SHIFT: keycode = kVK_Shift; break;
1153 case WXK_ALT: keycode = kVK_Option; break;
1154 case WXK_RAW_CONTROL: keycode = kVK_Control; break;
1155 case WXK_CONTROL: keycode = kVK_Command; break;
1156
1157 case WXK_CAPITAL: keycode = kVK_CapsLock; break;
1158 case WXK_END: keycode = kVK_End; break;
1159 case WXK_HOME: keycode = kVK_Home; break;
1160 case WXK_LEFT: keycode = kVK_LeftArrow; break;
1161 case WXK_UP: keycode = kVK_UpArrow; break;
1162 case WXK_RIGHT: keycode = kVK_RightArrow; break;
1163 case WXK_DOWN: keycode = kVK_DownArrow; break;
1164
1165 case WXK_HELP: keycode = kVK_Help; break;
1166
1167
1168 case WXK_NUMPAD0: keycode = kVK_ANSI_Keypad0; break;
1169 case WXK_NUMPAD1: keycode = kVK_ANSI_Keypad1; break;
1170 case WXK_NUMPAD2: keycode = kVK_ANSI_Keypad2; break;
1171 case WXK_NUMPAD3: keycode = kVK_ANSI_Keypad3; break;
1172 case WXK_NUMPAD4: keycode = kVK_ANSI_Keypad4; break;
1173 case WXK_NUMPAD5: keycode = kVK_ANSI_Keypad5; break;
1174 case WXK_NUMPAD6: keycode = kVK_ANSI_Keypad6; break;
1175 case WXK_NUMPAD7: keycode = kVK_ANSI_Keypad7; break;
1176 case WXK_NUMPAD8: keycode = kVK_ANSI_Keypad8; break;
1177 case WXK_NUMPAD9: keycode = kVK_ANSI_Keypad9; break;
1178 case WXK_F1: keycode = kVK_F1; break;
1179 case WXK_F2: keycode = kVK_F2; break;
1180 case WXK_F3: keycode = kVK_F3; break;
1181 case WXK_F4: keycode = kVK_F4; break;
1182 case WXK_F5: keycode = kVK_F5; break;
1183 case WXK_F6: keycode = kVK_F6; break;
1184 case WXK_F7: keycode = kVK_F7; break;
1185 case WXK_F8: keycode = kVK_F8; break;
1186 case WXK_F9: keycode = kVK_F9; break;
1187 case WXK_F10: keycode = kVK_F10; break;
1188 case WXK_F11: keycode = kVK_F11; break;
1189 case WXK_F12: keycode = kVK_F12; break;
1190 case WXK_F13: keycode = kVK_F13; break;
1191 case WXK_F14: keycode = kVK_F14; break;
1192 case WXK_F15: keycode = kVK_F15; break;
1193 case WXK_F16: keycode = kVK_F16; break;
1194 case WXK_F17: keycode = kVK_F17; break;
1195 case WXK_F18: keycode = kVK_F18; break;
1196 case WXK_F19: keycode = kVK_F19; break;
1197 case WXK_F20: keycode = kVK_F20; break;
1198
1199 case WXK_PAGEUP: keycode = kVK_PageUp; break;
1200 case WXK_PAGEDOWN: keycode = kVK_PageDown; break;
1201
1202 case WXK_NUMPAD_DELETE: keycode = kVK_ANSI_KeypadClear; break;
1203 case WXK_NUMPAD_EQUAL: keycode = kVK_ANSI_KeypadEquals; break;
1204 case WXK_NUMPAD_MULTIPLY: keycode = kVK_ANSI_KeypadMultiply; break;
1205 case WXK_NUMPAD_ADD: keycode = kVK_ANSI_KeypadPlus; break;
1206 case WXK_NUMPAD_SUBTRACT: keycode = kVK_ANSI_KeypadMinus; break;
1207 case WXK_NUMPAD_DECIMAL: keycode = kVK_ANSI_KeypadDecimal; break;
1208 case WXK_NUMPAD_DIVIDE: keycode = kVK_ANSI_KeypadDivide; break;
1209
1210 default:
1211 wxLogDebug( "Unrecognised keycode %d", code );
1212 keycode = static_cast<CGKeyCode>(-1);
1213 }
1214
1215 return keycode;
1216 }
1217
1218 long wxMacTranslateKey(unsigned char key, unsigned char code)
1219 {
1220 long retval = key ;
1221 switch (key)
1222 {
1223 case kHomeCharCode :
1224 retval = WXK_HOME;
1225 break;
1226
1227 case kEnterCharCode :
1228 retval = WXK_RETURN;
1229 break;
1230 case kEndCharCode :
1231 retval = WXK_END;
1232 break;
1233
1234 case kHelpCharCode :
1235 retval = WXK_HELP;
1236 break;
1237
1238 case kBackspaceCharCode :
1239 retval = WXK_BACK;
1240 break;
1241
1242 case kTabCharCode :
1243 retval = WXK_TAB;
1244 break;
1245
1246 case kPageUpCharCode :
1247 retval = WXK_PAGEUP;
1248 break;
1249
1250 case kPageDownCharCode :
1251 retval = WXK_PAGEDOWN;
1252 break;
1253
1254 case kReturnCharCode :
1255 retval = WXK_RETURN;
1256 break;
1257
1258 case kFunctionKeyCharCode :
1259 {
1260 switch ( code )
1261 {
1262 case 0x7a :
1263 retval = WXK_F1 ;
1264 break;
1265
1266 case 0x78 :
1267 retval = WXK_F2 ;
1268 break;
1269
1270 case 0x63 :
1271 retval = WXK_F3 ;
1272 break;
1273
1274 case 0x76 :
1275 retval = WXK_F4 ;
1276 break;
1277
1278 case 0x60 :
1279 retval = WXK_F5 ;
1280 break;
1281
1282 case 0x61 :
1283 retval = WXK_F6 ;
1284 break;
1285
1286 case 0x62:
1287 retval = WXK_F7 ;
1288 break;
1289
1290 case 0x64 :
1291 retval = WXK_F8 ;
1292 break;
1293
1294 case 0x65 :
1295 retval = WXK_F9 ;
1296 break;
1297
1298 case 0x6D :
1299 retval = WXK_F10 ;
1300 break;
1301
1302 case 0x67 :
1303 retval = WXK_F11 ;
1304 break;
1305
1306 case 0x6F :
1307 retval = WXK_F12 ;
1308 break;
1309
1310 case 0x69 :
1311 retval = WXK_F13 ;
1312 break;
1313
1314 case 0x6B :
1315 retval = WXK_F14 ;
1316 break;
1317
1318 case 0x71 :
1319 retval = WXK_F15 ;
1320 break;
1321
1322 default:
1323 break;
1324 }
1325 }
1326 break ;
1327
1328 case kEscapeCharCode :
1329 retval = WXK_ESCAPE ;
1330 break ;
1331
1332 case kLeftArrowCharCode :
1333 retval = WXK_LEFT ;
1334 break ;
1335
1336 case kRightArrowCharCode :
1337 retval = WXK_RIGHT ;
1338 break ;
1339
1340 case kUpArrowCharCode :
1341 retval = WXK_UP ;
1342 break ;
1343
1344 case kDownArrowCharCode :
1345 retval = WXK_DOWN ;
1346 break ;
1347
1348 case kDeleteCharCode :
1349 retval = WXK_DELETE ;
1350 break ;
1351
1352 default:
1353 break ;
1354 } // end switch
1355
1356 return retval;
1357 }
1358
1359 int wxMacKeyCodeToModifier(wxKeyCode key)
1360 {
1361 switch (key)
1362 {
1363 case WXK_START:
1364 case WXK_MENU:
1365 case WXK_COMMAND:
1366 return cmdKey;
1367
1368 case WXK_SHIFT:
1369 return shiftKey;
1370
1371 case WXK_CAPITAL:
1372 return alphaLock;
1373
1374 case WXK_ALT:
1375 return optionKey;
1376
1377 case WXK_RAW_CONTROL:
1378 return controlKey;
1379
1380 default:
1381 return 0;
1382 }
1383 }
1384 #endif
1385
1386 #if wxOSX_USE_COCOA && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
1387
1388 // defined in utils.mm
1389
1390 #elif wxOSX_USE_COCOA_OR_CARBON
1391
1392 wxMouseState wxGetMouseState()
1393 {
1394 wxMouseState ms;
1395
1396 wxPoint pt = wxGetMousePosition();
1397 ms.SetX(pt.x);
1398 ms.SetY(pt.y);
1399
1400 UInt32 buttons = GetCurrentButtonState();
1401 ms.SetLeftDown( (buttons & 0x01) != 0 );
1402 ms.SetMiddleDown( (buttons & 0x04) != 0 );
1403 ms.SetRightDown( (buttons & 0x02) != 0 );
1404
1405 UInt32 modifiers = GetCurrentKeyModifiers();
1406 ms.SetRawControlDown(modifiers & controlKey);
1407 ms.SetShiftDown(modifiers & shiftKey);
1408 ms.SetAltDown(modifiers & optionKey);
1409 ms.SetControlDown(modifiers & cmdKey);
1410
1411 return ms;
1412 }
1413
1414 #endif
1415
1416 // TODO : once the new key/char handling is tested, move all the code to wxWindow
1417
1418 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1419 {
1420 if ( !focus )
1421 return false ;
1422
1423 wxKeyEvent event(wxEVT_KEY_DOWN) ;
1424 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1425
1426 return focus->OSXHandleKeyEvent(event);
1427 }
1428
1429 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1430 {
1431 if ( !focus )
1432 return false ;
1433
1434 wxKeyEvent event( wxEVT_KEY_UP ) ;
1435 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1436
1437 return focus->OSXHandleKeyEvent(event) ;
1438 }
1439
1440 bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1441 {
1442 if ( !focus )
1443 return false ;
1444 wxKeyEvent event(wxEVT_CHAR) ;
1445 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1446
1447 bool handled = false ;
1448
1449 #if wxOSX_USE_CARBON
1450 long keyval = event.m_keyCode ;
1451
1452 {
1453 wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
1454 handled = focus->HandleWindowEvent( eventCharHook );
1455 if ( handled && eventCharHook.IsNextEventAllowed() )
1456 handled = false ;
1457 }
1458
1459 if ( !handled )
1460 {
1461 handled = focus->HandleWindowEvent( event ) ;
1462 }
1463
1464 if ( !handled && (keyval == WXK_TAB) )
1465 {
1466 wxWindow* iter = focus->GetParent() ;
1467 while ( iter && !handled )
1468 {
1469 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1470 {
1471 wxNavigationKeyEvent new_event;
1472 new_event.SetEventObject( focus );
1473 new_event.SetDirection( !event.ShiftDown() );
1474 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1475 new_event.SetWindowChange( event.ControlDown() );
1476 new_event.SetCurrentFocus( focus );
1477 handled = focus->GetParent()->HandleWindowEvent( new_event );
1478 if ( handled && new_event.GetSkipped() )
1479 handled = false ;
1480 }
1481
1482 iter = iter->GetParent() ;
1483 }
1484 }
1485
1486 // backdoor handler for default return and command escape
1487 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->AcceptsFocus() ) )
1488 {
1489 // if window is not having a focus still testing for default enter or cancel
1490 // TODO: add the UMA version for ActiveNonFloatingWindow
1491 #ifndef __LP64__
1492 wxWindow* focus = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) FrontWindow() ) ;
1493 if ( focus )
1494 {
1495 if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
1496 {
1497 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(focus), wxTopLevelWindow);
1498 if ( tlw && tlw->GetDefaultItem() )
1499 {
1500 wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
1501 if ( def && def->IsEnabled() )
1502 {
1503 wxCommandEvent event(wxEVT_BUTTON, def->GetId() );
1504 event.SetEventObject(def);
1505 def->Command(event);
1506
1507 return true ;
1508 }
1509 }
1510 }
1511 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1512 {
1513 // generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
1514 wxCommandEvent new_event(wxEVT_BUTTON,wxID_CANCEL);
1515 new_event.SetEventObject( focus );
1516 handled = focus->HandleWindowEvent( new_event );
1517 }
1518 }
1519 #endif
1520 }
1521 #endif
1522 return handled ;
1523 }
1524
1525 // This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
1526 void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1527 {
1528 #if wxOSX_USE_COCOA_OR_CARBON
1529
1530 short keycode, keychar ;
1531
1532 keychar = short(keymessage & charCodeMask);
1533 keycode = short(keymessage & keyCodeMask) >> 8 ;
1534 if ( !(event.GetEventType() == wxEVT_CHAR) && (modifiers & (controlKey | shiftKey | optionKey) ) )
1535 {
1536 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1537 // and look at the character after
1538 #ifdef __LP64__
1539 // TODO new implementation using TextInputSources
1540 #else
1541 UInt32 state = 0;
1542 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey | shiftKey | optionKey))) | keycode, &state);
1543 keychar = short(keyInfo & charCodeMask);
1544 #endif
1545 }
1546
1547 long keyval = wxMacTranslateKey(keychar, keycode) ;
1548 if ( keyval == keychar && ( event.GetEventType() == wxEVT_KEY_UP || event.GetEventType() == wxEVT_KEY_DOWN ) )
1549 keyval = wxToupper( keyval ) ;
1550
1551 // Check for NUMPAD keys. For KEY_UP/DOWN events we need to use the
1552 // WXK_NUMPAD constants, but for the CHAR event we want to use the
1553 // standard ascii values
1554 if ( event.GetEventType() != wxEVT_CHAR )
1555 {
1556 if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
1557 {
1558 keyval = (keyval - '0') + WXK_NUMPAD0;
1559 }
1560 else if (keycode >= 65 && keycode <= 81)
1561 {
1562 switch (keycode)
1563 {
1564 case 76 :
1565 keyval = WXK_NUMPAD_ENTER;
1566 break;
1567
1568 case 81:
1569 keyval = WXK_NUMPAD_EQUAL;
1570 break;
1571
1572 case 67:
1573 keyval = WXK_NUMPAD_MULTIPLY;
1574 break;
1575
1576 case 75:
1577 keyval = WXK_NUMPAD_DIVIDE;
1578 break;
1579
1580 case 78:
1581 keyval = WXK_NUMPAD_SUBTRACT;
1582 break;
1583
1584 case 69:
1585 keyval = WXK_NUMPAD_ADD;
1586 break;
1587
1588 case 65:
1589 keyval = WXK_NUMPAD_DECIMAL;
1590 break;
1591 default:
1592 break;
1593 }
1594 }
1595 }
1596
1597 event.m_shiftDown = modifiers & shiftKey;
1598 event.m_rawControlDown = modifiers & controlKey;
1599 event.m_altDown = modifiers & optionKey;
1600 event.m_controlDown = modifiers & cmdKey;
1601 event.m_keyCode = keyval ;
1602 #if wxUSE_UNICODE
1603 event.m_uniChar = uniChar ;
1604 #endif
1605
1606 event.m_rawCode = keymessage;
1607 event.m_rawFlags = modifiers;
1608 event.SetTimestamp(when);
1609 event.SetEventObject(focus);
1610 #else
1611 wxUnusedVar(event);
1612 wxUnusedVar(focus);
1613 wxUnusedVar(keymessage);
1614 wxUnusedVar(modifiers);
1615 wxUnusedVar(when);
1616 wxUnusedVar(uniChar);
1617 #endif
1618 }
1619
1620
1621 void wxApp::MacHideApp()
1622 {
1623 #if wxOSX_USE_CARBON
1624 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
1625 HICommand command;
1626 memset( &command, 0 , sizeof(command) );
1627 command.commandID = kHICommandHide ;
1628 event.SetParameter<HICommand>(kEventParamDirectObject, command );
1629 SendEventToApplication( event );
1630 #endif
1631 }
wxWidgets (Impactor)