]> 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
Don't hide the window in its dtor in wxGTK.
[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 // Mac OS X passes a process serial number command line argument when
823 // the application is launched from the Finder. This argument must be
824 // removed from the command line arguments before being handled by the
825 // application (otherwise applications would need to handle it)
826 if ( argc > 1 )
827 {
828 static const wxChar *ARG_PSN = wxT("-psn_");
829 if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 )
830 {
831 // remove this argument
832 --argc;
833 memmove(argv + 1, argv + 2, argc * sizeof(wxChar*));
834 }
835 }
836
837 /*
838 Cocoa supports -Key value options which set the user defaults key "Key"
839 to the value "value" Some of them are very handy for debugging like
840 -NSShowAllViews YES. Cocoa picks these up from the real argv so
841 our removal of them from the wx copy of it does not affect Cocoa's
842 ability to see them.
843
844 We basically just assume that any "-NS" option and its following
845 argument needs to be removed from argv. We hope that user code does
846 not expect to see -NS options and indeed it's probably a safe bet
847 since most user code accepting options is probably using the
848 double-dash GNU-style syntax.
849 */
850 for(int i=1; i < argc; ++i)
851 {
852 static const wxChar *ARG_NS = wxT("-NS");
853 if( wxStrncmp(argv[i], ARG_NS, wxStrlen(ARG_NS)) == 0 )
854 {
855 // Only eat this option if it has an argument
856 if( (i + 1) < argc )
857 {
858 memmove(argv + i, argv + i + 2, (argc-i-1)*sizeof(wxChar*));
859 argc -= 2;
860 // drop back one position so the next run through the loop
861 // reprocesses the argument at our current index.
862 --i;
863 }
864 }
865 }
866
867 if ( !wxAppBase::Initialize(argc, argv) )
868 return false;
869
870 #if wxUSE_INTL
871 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
872 #endif
873
874 // these might be the startup dirs, set them to the 'usual' dir containing the app bundle
875 wxString startupCwd = wxGetCwd() ;
876 if ( startupCwd == wxT("/") || startupCwd.Right(15) == wxT("/Contents/MacOS") )
877 {
878 CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle() ) ;
879 CFURLRef urlParent = CFURLCreateCopyDeletingLastPathComponent( kCFAllocatorDefault , url ) ;
880 CFRelease( url ) ;
881 CFStringRef path = CFURLCopyFileSystemPath ( urlParent , kCFURLPOSIXPathStyle ) ;
882 CFRelease( urlParent ) ;
883 wxString cwd = wxCFStringRef(path).AsString(wxLocale::GetSystemEncoding());
884 wxSetWorkingDirectory( cwd ) ;
885 }
886
887 return true;
888 }
889
890 #if wxOSX_USE_CARBON
891 bool wxApp::CallOnInit()
892 {
893 wxMacAutoreleasePool autoreleasepool;
894 return OnInit();
895 }
896 #endif
897
898 bool wxApp::OnInitGui()
899 {
900 if ( !wxAppBase::OnInitGui() )
901 return false ;
902
903 if ( !DoInitGui() )
904 return false;
905
906 return true ;
907 }
908
909 bool wxApp::ProcessIdle()
910 {
911 wxMacAutoreleasePool autoreleasepool;
912 return wxAppBase::ProcessIdle();
913 }
914
915 int wxApp::OnRun()
916 {
917 wxMacAutoreleasePool pool;
918 return wxAppBase::OnRun();
919 }
920
921 #if wxOSX_USE_CARBON
922 bool wxApp::DoInitGui()
923 {
924 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
925 if (!sm_isEmbedded)
926 {
927 InstallApplicationEventHandler(
928 GetwxMacAppEventHandlerUPP(),
929 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
930 }
931
932 if (!sm_isEmbedded)
933 {
934 sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
935 sGURLHandler = NewAEEventHandlerUPP(AEHandleGURL) ;
936 sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
937 sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
938 sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
939 sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
940
941 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
942 sODocHandler , 0 , FALSE ) ;
943 AEInstallEventHandler( kInternetEventClass, kAEGetURL,
944 sGURLHandler , 0 , FALSE ) ;
945 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
946 sOAppHandler , 0 , FALSE ) ;
947 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
948 sPDocHandler , 0 , FALSE ) ;
949 AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
950 sRAppHandler , 0 , FALSE ) ;
951 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
952 sQuitHandler , 0 , FALSE ) ;
953 }
954
955 if ( !wxMacInitCocoa() )
956 return false;
957
958 return true;
959 }
960
961 void wxApp::DoCleanUp()
962 {
963 if (!sm_isEmbedded)
964 RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
965
966 if (!sm_isEmbedded)
967 {
968 AERemoveEventHandler( kCoreEventClass , kAEOpenDocuments ,
969 sODocHandler , FALSE ) ;
970 AERemoveEventHandler( kInternetEventClass, kAEGetURL,
971 sGURLHandler , FALSE ) ;
972 AERemoveEventHandler( kCoreEventClass , kAEOpenApplication ,
973 sOAppHandler , FALSE ) ;
974 AERemoveEventHandler( kCoreEventClass , kAEPrintDocuments ,
975 sPDocHandler , FALSE ) ;
976 AERemoveEventHandler( kCoreEventClass , kAEReopenApplication ,
977 sRAppHandler , FALSE ) ;
978 AERemoveEventHandler( kCoreEventClass , kAEQuitApplication ,
979 sQuitHandler , FALSE ) ;
980
981 DisposeAEEventHandlerUPP( sODocHandler ) ;
982 DisposeAEEventHandlerUPP( sGURLHandler ) ;
983 DisposeAEEventHandlerUPP( sOAppHandler ) ;
984 DisposeAEEventHandlerUPP( sPDocHandler ) ;
985 DisposeAEEventHandlerUPP( sRAppHandler ) ;
986 DisposeAEEventHandlerUPP( sQuitHandler ) ;
987 }
988 }
989
990 #endif
991
992 void wxApp::CleanUp()
993 {
994 wxMacAutoreleasePool autoreleasepool;
995 #if wxUSE_TOOLTIPS
996 wxToolTip::RemoveToolTips() ;
997 #endif
998
999 DoCleanUp();
1000
1001 wxAppBase::CleanUp();
1002 }
1003
1004 //----------------------------------------------------------------------
1005 // misc initialization stuff
1006 //----------------------------------------------------------------------
1007
1008 wxApp::wxApp()
1009 {
1010 m_printMode = wxPRINT_WINDOWS;
1011
1012 m_macCurrentEvent = NULL ;
1013 m_macCurrentEventHandlerCallRef = NULL ;
1014 m_macPool = new wxMacAutoreleasePool();
1015 }
1016
1017 wxApp::~wxApp()
1018 {
1019 if (m_macPool)
1020 delete m_macPool;
1021 }
1022
1023 CFMutableArrayRef GetAutoReleaseArray()
1024 {
1025 static CFMutableArrayRef array = 0;
1026 if ( array == 0)
1027 array= CFArrayCreateMutable(kCFAllocatorDefault,0,&kCFTypeArrayCallBacks);
1028 return array;
1029 }
1030
1031 void wxApp::MacAddToAutorelease( void* cfrefobj )
1032 {
1033 CFArrayAppendValue( GetAutoReleaseArray(), cfrefobj );
1034 }
1035
1036 void wxApp::MacReleaseAutoreleasePool()
1037 {
1038 if (m_macPool)
1039 delete m_macPool;
1040 m_macPool = new wxMacAutoreleasePool();
1041 }
1042
1043 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
1044 {
1045 // If they are pending events, we must process them: pending events are
1046 // either events to the threads other than main or events posted with
1047 // wxPostEvent() functions
1048 #ifndef __WXUNIVERSAL__
1049 #if wxUSE_MENUS
1050 if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1051 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1052 #endif
1053 #endif
1054 CFArrayRemoveAllValues( GetAutoReleaseArray() );
1055 }
1056
1057 void wxApp::WakeUpIdle()
1058 {
1059 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
1060
1061 if ( loop )
1062 loop->WakeUp();
1063 }
1064
1065 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1066 {
1067 if (GetTopWindow())
1068 GetTopWindow()->Close(true);
1069 }
1070
1071 // Default behaviour: close the application with prompts. The
1072 // user can veto the close, and therefore the end session.
1073 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1074 {
1075 if ( !wxDialog::OSXHasModalDialogsOpen() )
1076 {
1077 if (GetTopWindow())
1078 {
1079 if (!GetTopWindow()->Close(!event.CanVeto()))
1080 event.Veto(true);
1081 }
1082 }
1083 else
1084 {
1085 event.Veto(true);
1086 }
1087 }
1088
1089 extern "C" void wxCYield() ;
1090 void wxCYield()
1091 {
1092 wxYield() ;
1093 }
1094
1095 // virtual
1096 void wxApp::MacHandleUnhandledEvent( WXEVENTREF WXUNUSED(evr) )
1097 {
1098 // Override to process unhandled events as you please
1099 }
1100
1101 #if wxOSX_USE_COCOA_OR_CARBON
1102
1103 CGKeyCode wxCharCodeWXToOSX(wxKeyCode code)
1104 {
1105 CGKeyCode keycode;
1106
1107 switch (code)
1108 {
1109 // Clang warns about switch values not of the same type as (enumerated)
1110 // switch controlling expression. This is generally useful but here we
1111 // really want to be able to use letters and digits without making them
1112 // part of wxKeyCode enum.
1113 #ifdef __clang__
1114 #pragma clang diagnostic push
1115 #pragma clang diagnostic ignored "-Wswitch"
1116 #endif // __clang__
1117
1118 case 'a': case 'A': keycode = kVK_ANSI_A; break;
1119 case 'b': case 'B': keycode = kVK_ANSI_B; break;
1120 case 'c': case 'C': keycode = kVK_ANSI_C; break;
1121 case 'd': case 'D': keycode = kVK_ANSI_D; break;
1122 case 'e': case 'E': keycode = kVK_ANSI_E; break;
1123 case 'f': case 'F': keycode = kVK_ANSI_F; break;
1124 case 'g': case 'G': keycode = kVK_ANSI_G; break;
1125 case 'h': case 'H': keycode = kVK_ANSI_H; break;
1126 case 'i': case 'I': keycode = kVK_ANSI_I; break;
1127 case 'j': case 'J': keycode = kVK_ANSI_J; break;
1128 case 'k': case 'K': keycode = kVK_ANSI_K; break;
1129 case 'l': case 'L': keycode = kVK_ANSI_L; break;
1130 case 'm': case 'M': keycode = kVK_ANSI_M; break;
1131 case 'n': case 'N': keycode = kVK_ANSI_N; break;
1132 case 'o': case 'O': keycode = kVK_ANSI_O; break;
1133 case 'p': case 'P': keycode = kVK_ANSI_P; break;
1134 case 'q': case 'Q': keycode = kVK_ANSI_Q; break;
1135 case 'r': case 'R': keycode = kVK_ANSI_R; break;
1136 case 's': case 'S': keycode = kVK_ANSI_S; break;
1137 case 't': case 'T': keycode = kVK_ANSI_T; break;
1138 case 'u': case 'U': keycode = kVK_ANSI_U; break;
1139 case 'v': case 'V': keycode = kVK_ANSI_V; break;
1140 case 'w': case 'W': keycode = kVK_ANSI_W; break;
1141 case 'x': case 'X': keycode = kVK_ANSI_X; break;
1142 case 'y': case 'Y': keycode = kVK_ANSI_Y; break;
1143 case 'z': case 'Z': keycode = kVK_ANSI_Z; break;
1144
1145 case '0': keycode = kVK_ANSI_0; break;
1146 case '1': keycode = kVK_ANSI_1; break;
1147 case '2': keycode = kVK_ANSI_2; break;
1148 case '3': keycode = kVK_ANSI_3; break;
1149 case '4': keycode = kVK_ANSI_4; break;
1150 case '5': keycode = kVK_ANSI_5; break;
1151 case '6': keycode = kVK_ANSI_6; break;
1152 case '7': keycode = kVK_ANSI_7; break;
1153 case '8': keycode = kVK_ANSI_8; break;
1154 case '9': keycode = kVK_ANSI_9; break;
1155
1156 #ifdef __clang__
1157 #pragma clang diagnostic pop
1158 #endif // __clang__
1159
1160 case WXK_BACK: keycode = kVK_Delete; break;
1161 case WXK_TAB: keycode = kVK_Tab; break;
1162 case WXK_RETURN: keycode = kVK_Return; break;
1163 case WXK_ESCAPE: keycode = kVK_Escape; break;
1164 case WXK_SPACE: keycode = kVK_Space; break;
1165 case WXK_DELETE: keycode = kVK_ForwardDelete; break;
1166
1167 case WXK_SHIFT: keycode = kVK_Shift; break;
1168 case WXK_ALT: keycode = kVK_Option; break;
1169 case WXK_RAW_CONTROL: keycode = kVK_Control; break;
1170 case WXK_CONTROL: keycode = kVK_Command; break;
1171
1172 case WXK_CAPITAL: keycode = kVK_CapsLock; break;
1173 case WXK_END: keycode = kVK_End; break;
1174 case WXK_HOME: keycode = kVK_Home; break;
1175 case WXK_LEFT: keycode = kVK_LeftArrow; break;
1176 case WXK_UP: keycode = kVK_UpArrow; break;
1177 case WXK_RIGHT: keycode = kVK_RightArrow; break;
1178 case WXK_DOWN: keycode = kVK_DownArrow; break;
1179
1180 case WXK_HELP: keycode = kVK_Help; break;
1181
1182
1183 case WXK_NUMPAD0: keycode = kVK_ANSI_Keypad0; break;
1184 case WXK_NUMPAD1: keycode = kVK_ANSI_Keypad1; break;
1185 case WXK_NUMPAD2: keycode = kVK_ANSI_Keypad2; break;
1186 case WXK_NUMPAD3: keycode = kVK_ANSI_Keypad3; break;
1187 case WXK_NUMPAD4: keycode = kVK_ANSI_Keypad4; break;
1188 case WXK_NUMPAD5: keycode = kVK_ANSI_Keypad5; break;
1189 case WXK_NUMPAD6: keycode = kVK_ANSI_Keypad6; break;
1190 case WXK_NUMPAD7: keycode = kVK_ANSI_Keypad7; break;
1191 case WXK_NUMPAD8: keycode = kVK_ANSI_Keypad8; break;
1192 case WXK_NUMPAD9: keycode = kVK_ANSI_Keypad9; break;
1193 case WXK_F1: keycode = kVK_F1; break;
1194 case WXK_F2: keycode = kVK_F2; break;
1195 case WXK_F3: keycode = kVK_F3; break;
1196 case WXK_F4: keycode = kVK_F4; break;
1197 case WXK_F5: keycode = kVK_F5; break;
1198 case WXK_F6: keycode = kVK_F6; break;
1199 case WXK_F7: keycode = kVK_F7; break;
1200 case WXK_F8: keycode = kVK_F8; break;
1201 case WXK_F9: keycode = kVK_F9; break;
1202 case WXK_F10: keycode = kVK_F10; break;
1203 case WXK_F11: keycode = kVK_F11; break;
1204 case WXK_F12: keycode = kVK_F12; break;
1205 case WXK_F13: keycode = kVK_F13; break;
1206 case WXK_F14: keycode = kVK_F14; break;
1207 case WXK_F15: keycode = kVK_F15; break;
1208 case WXK_F16: keycode = kVK_F16; break;
1209 case WXK_F17: keycode = kVK_F17; break;
1210 case WXK_F18: keycode = kVK_F18; break;
1211 case WXK_F19: keycode = kVK_F19; break;
1212 case WXK_F20: keycode = kVK_F20; break;
1213
1214 case WXK_PAGEUP: keycode = kVK_PageUp; break;
1215 case WXK_PAGEDOWN: keycode = kVK_PageDown; break;
1216
1217 case WXK_NUMPAD_DELETE: keycode = kVK_ANSI_KeypadClear; break;
1218 case WXK_NUMPAD_EQUAL: keycode = kVK_ANSI_KeypadEquals; break;
1219 case WXK_NUMPAD_MULTIPLY: keycode = kVK_ANSI_KeypadMultiply; break;
1220 case WXK_NUMPAD_ADD: keycode = kVK_ANSI_KeypadPlus; break;
1221 case WXK_NUMPAD_SUBTRACT: keycode = kVK_ANSI_KeypadMinus; break;
1222 case WXK_NUMPAD_DECIMAL: keycode = kVK_ANSI_KeypadDecimal; break;
1223 case WXK_NUMPAD_DIVIDE: keycode = kVK_ANSI_KeypadDivide; break;
1224
1225 default:
1226 wxLogDebug( "Unrecognised keycode %d", code );
1227 keycode = static_cast<CGKeyCode>(-1);
1228 }
1229
1230 return keycode;
1231 }
1232
1233 long wxMacTranslateKey(unsigned char key, unsigned char code)
1234 {
1235 long retval = key ;
1236 switch (key)
1237 {
1238 case kHomeCharCode :
1239 retval = WXK_HOME;
1240 break;
1241
1242 case kEnterCharCode :
1243 retval = WXK_RETURN;
1244 break;
1245 case kEndCharCode :
1246 retval = WXK_END;
1247 break;
1248
1249 case kHelpCharCode :
1250 retval = WXK_HELP;
1251 break;
1252
1253 case kBackspaceCharCode :
1254 retval = WXK_BACK;
1255 break;
1256
1257 case kTabCharCode :
1258 retval = WXK_TAB;
1259 break;
1260
1261 case kPageUpCharCode :
1262 retval = WXK_PAGEUP;
1263 break;
1264
1265 case kPageDownCharCode :
1266 retval = WXK_PAGEDOWN;
1267 break;
1268
1269 case kReturnCharCode :
1270 retval = WXK_RETURN;
1271 break;
1272
1273 case kFunctionKeyCharCode :
1274 {
1275 switch ( code )
1276 {
1277 case 0x7a :
1278 retval = WXK_F1 ;
1279 break;
1280
1281 case 0x78 :
1282 retval = WXK_F2 ;
1283 break;
1284
1285 case 0x63 :
1286 retval = WXK_F3 ;
1287 break;
1288
1289 case 0x76 :
1290 retval = WXK_F4 ;
1291 break;
1292
1293 case 0x60 :
1294 retval = WXK_F5 ;
1295 break;
1296
1297 case 0x61 :
1298 retval = WXK_F6 ;
1299 break;
1300
1301 case 0x62:
1302 retval = WXK_F7 ;
1303 break;
1304
1305 case 0x64 :
1306 retval = WXK_F8 ;
1307 break;
1308
1309 case 0x65 :
1310 retval = WXK_F9 ;
1311 break;
1312
1313 case 0x6D :
1314 retval = WXK_F10 ;
1315 break;
1316
1317 case 0x67 :
1318 retval = WXK_F11 ;
1319 break;
1320
1321 case 0x6F :
1322 retval = WXK_F12 ;
1323 break;
1324
1325 case 0x69 :
1326 retval = WXK_F13 ;
1327 break;
1328
1329 case 0x6B :
1330 retval = WXK_F14 ;
1331 break;
1332
1333 case 0x71 :
1334 retval = WXK_F15 ;
1335 break;
1336
1337 default:
1338 break;
1339 }
1340 }
1341 break ;
1342
1343 case kEscapeCharCode :
1344 retval = WXK_ESCAPE ;
1345 break ;
1346
1347 case kLeftArrowCharCode :
1348 retval = WXK_LEFT ;
1349 break ;
1350
1351 case kRightArrowCharCode :
1352 retval = WXK_RIGHT ;
1353 break ;
1354
1355 case kUpArrowCharCode :
1356 retval = WXK_UP ;
1357 break ;
1358
1359 case kDownArrowCharCode :
1360 retval = WXK_DOWN ;
1361 break ;
1362
1363 case kDeleteCharCode :
1364 retval = WXK_DELETE ;
1365 break ;
1366
1367 default:
1368 break ;
1369 } // end switch
1370
1371 return retval;
1372 }
1373
1374 int wxMacKeyCodeToModifier(wxKeyCode key)
1375 {
1376 switch (key)
1377 {
1378 case WXK_START:
1379 case WXK_MENU:
1380 case WXK_COMMAND:
1381 return cmdKey;
1382
1383 case WXK_SHIFT:
1384 return shiftKey;
1385
1386 case WXK_CAPITAL:
1387 return alphaLock;
1388
1389 case WXK_ALT:
1390 return optionKey;
1391
1392 case WXK_RAW_CONTROL:
1393 return controlKey;
1394
1395 default:
1396 return 0;
1397 }
1398 }
1399 #endif
1400
1401 #if wxOSX_USE_COCOA && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
1402
1403 // defined in utils.mm
1404
1405 #elif wxOSX_USE_COCOA_OR_CARBON
1406
1407 wxMouseState wxGetMouseState()
1408 {
1409 wxMouseState ms;
1410
1411 wxPoint pt = wxGetMousePosition();
1412 ms.SetX(pt.x);
1413 ms.SetY(pt.y);
1414
1415 UInt32 buttons = GetCurrentButtonState();
1416 ms.SetLeftDown( (buttons & 0x01) != 0 );
1417 ms.SetMiddleDown( (buttons & 0x04) != 0 );
1418 ms.SetRightDown( (buttons & 0x02) != 0 );
1419
1420 UInt32 modifiers = GetCurrentKeyModifiers();
1421 ms.SetRawControlDown(modifiers & controlKey);
1422 ms.SetShiftDown(modifiers & shiftKey);
1423 ms.SetAltDown(modifiers & optionKey);
1424 ms.SetControlDown(modifiers & cmdKey);
1425
1426 return ms;
1427 }
1428
1429 #endif
1430
1431 // TODO : once the new key/char handling is tested, move all the code to wxWindow
1432
1433 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1434 {
1435 if ( !focus )
1436 return false ;
1437
1438 wxKeyEvent event(wxEVT_KEY_DOWN) ;
1439 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1440
1441 return focus->OSXHandleKeyEvent(event);
1442 }
1443
1444 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1445 {
1446 if ( !focus )
1447 return false ;
1448
1449 wxKeyEvent event( wxEVT_KEY_UP ) ;
1450 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1451
1452 return focus->OSXHandleKeyEvent(event) ;
1453 }
1454
1455 bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1456 {
1457 if ( !focus )
1458 return false ;
1459 wxKeyEvent event(wxEVT_CHAR) ;
1460 MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
1461
1462 bool handled = false ;
1463
1464 #if wxOSX_USE_CARBON
1465 long keyval = event.m_keyCode ;
1466
1467 {
1468 wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
1469 handled = focus->HandleWindowEvent( eventCharHook );
1470 if ( handled && eventCharHook.IsNextEventAllowed() )
1471 handled = false ;
1472 }
1473
1474 if ( !handled )
1475 {
1476 handled = focus->HandleWindowEvent( event ) ;
1477 }
1478
1479 if ( !handled && (keyval == WXK_TAB) )
1480 {
1481 wxWindow* iter = focus->GetParent() ;
1482 while ( iter && !handled )
1483 {
1484 if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
1485 {
1486 wxNavigationKeyEvent new_event;
1487 new_event.SetEventObject( focus );
1488 new_event.SetDirection( !event.ShiftDown() );
1489 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1490 new_event.SetWindowChange( event.ControlDown() );
1491 new_event.SetCurrentFocus( focus );
1492 handled = focus->GetParent()->HandleWindowEvent( new_event );
1493 if ( handled && new_event.GetSkipped() )
1494 handled = false ;
1495 }
1496
1497 iter = iter->GetParent() ;
1498 }
1499 }
1500
1501 // backdoor handler for default return and command escape
1502 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->AcceptsFocus() ) )
1503 {
1504 // if window is not having a focus still testing for default enter or cancel
1505 // TODO: add the UMA version for ActiveNonFloatingWindow
1506 #ifndef __LP64__
1507 wxWindow* focus = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) FrontWindow() ) ;
1508 if ( focus )
1509 {
1510 if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
1511 {
1512 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(focus), wxTopLevelWindow);
1513 if ( tlw && tlw->GetDefaultItem() )
1514 {
1515 wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
1516 if ( def && def->IsEnabled() )
1517 {
1518 wxCommandEvent event(wxEVT_BUTTON, def->GetId() );
1519 event.SetEventObject(def);
1520 def->Command(event);
1521
1522 return true ;
1523 }
1524 }
1525 }
1526 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1527 {
1528 // generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
1529 wxCommandEvent new_event(wxEVT_BUTTON,wxID_CANCEL);
1530 new_event.SetEventObject( focus );
1531 handled = focus->HandleWindowEvent( new_event );
1532 }
1533 }
1534 #endif
1535 }
1536 #endif
1537 return handled ;
1538 }
1539
1540 // This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
1541 void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
1542 {
1543 #if wxOSX_USE_COCOA_OR_CARBON
1544
1545 short keycode, keychar ;
1546
1547 keychar = short(keymessage & charCodeMask);
1548 keycode = short(keymessage & keyCodeMask) >> 8 ;
1549 if ( !(event.GetEventType() == wxEVT_CHAR) && (modifiers & (controlKey | shiftKey | optionKey) ) )
1550 {
1551 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1552 // and look at the character after
1553 #ifdef __LP64__
1554 // TODO new implementation using TextInputSources
1555 #else
1556 UInt32 state = 0;
1557 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey | shiftKey | optionKey))) | keycode, &state);
1558 keychar = short(keyInfo & charCodeMask);
1559 #endif
1560 }
1561
1562 long keyval = wxMacTranslateKey(keychar, keycode) ;
1563 if ( keyval == keychar && ( event.GetEventType() == wxEVT_KEY_UP || event.GetEventType() == wxEVT_KEY_DOWN ) )
1564 keyval = wxToupper( keyval ) ;
1565
1566 // Check for NUMPAD keys. For KEY_UP/DOWN events we need to use the
1567 // WXK_NUMPAD constants, but for the CHAR event we want to use the
1568 // standard ascii values
1569 if ( event.GetEventType() != wxEVT_CHAR )
1570 {
1571 if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
1572 {
1573 keyval = (keyval - '0') + WXK_NUMPAD0;
1574 }
1575 else if (keycode >= 65 && keycode <= 81)
1576 {
1577 switch (keycode)
1578 {
1579 case 76 :
1580 keyval = WXK_NUMPAD_ENTER;
1581 break;
1582
1583 case 81:
1584 keyval = WXK_NUMPAD_EQUAL;
1585 break;
1586
1587 case 67:
1588 keyval = WXK_NUMPAD_MULTIPLY;
1589 break;
1590
1591 case 75:
1592 keyval = WXK_NUMPAD_DIVIDE;
1593 break;
1594
1595 case 78:
1596 keyval = WXK_NUMPAD_SUBTRACT;
1597 break;
1598
1599 case 69:
1600 keyval = WXK_NUMPAD_ADD;
1601 break;
1602
1603 case 65:
1604 keyval = WXK_NUMPAD_DECIMAL;
1605 break;
1606 default:
1607 break;
1608 }
1609 }
1610 }
1611
1612 event.m_shiftDown = modifiers & shiftKey;
1613 event.m_rawControlDown = modifiers & controlKey;
1614 event.m_altDown = modifiers & optionKey;
1615 event.m_controlDown = modifiers & cmdKey;
1616 event.m_keyCode = keyval ;
1617 #if wxUSE_UNICODE
1618 event.m_uniChar = uniChar ;
1619 #endif
1620
1621 event.m_rawCode = keymessage;
1622 event.m_rawFlags = modifiers;
1623 event.SetTimestamp(when);
1624 event.SetEventObject(focus);
1625 #else
1626 wxUnusedVar(event);
1627 wxUnusedVar(focus);
1628 wxUnusedVar(keymessage);
1629 wxUnusedVar(modifiers);
1630 wxUnusedVar(when);
1631 wxUnusedVar(uniChar);
1632 #endif
1633 }
1634
1635
1636 void wxApp::MacHideApp()
1637 {
1638 #if wxOSX_USE_CARBON
1639 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
1640 HICommand command;
1641 memset( &command, 0 , sizeof(command) );
1642 command.commandID = kHICommandHide ;
1643 event.SetParameter<HICommand>(kEventParamDirectObject, command );
1644 SendEventToApplication( event );
1645 #endif
1646 }
wxWidgets (Impactor)