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