]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/app.cpp
projects / wxWidgets.git / blob
? search:


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