]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/app.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
VC 7.1 warning fix
[wxWidgets.git] / src / mac / app.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: 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#ifdef __GNUG__
13#pragma implementation "app.h"
14#endif
15
16#include "wx/defs.h"
17
18#include "wx/window.h"
19#include "wx/frame.h"
20#include "wx/button.h"
21#include "wx/app.h"
22#include "wx/utils.h"
23#include "wx/gdicmn.h"
24#include "wx/pen.h"
25#include "wx/brush.h"
26#include "wx/cursor.h"
27#include "wx/intl.h"
28#include "wx/icon.h"
29#include "wx/palette.h"
30#include "wx/dc.h"
31#include "wx/dialog.h"
32#include "wx/msgdlg.h"
33#include "wx/log.h"
34#include "wx/module.h"
35#include "wx/memory.h"
36#include "wx/tooltip.h"
37#include "wx/textctrl.h"
38#include "wx/menu.h"
39#include "wx/docview.h"
40
41#include <string.h>
42
43// mac
44
45#ifndef __DARWIN__
46 #if __option(profile)
47 #include <profiler.h>
48 #endif
49#endif
50
51#include "apprsrc.h"
52
53#include "wx/mac/uma.h"
54#include "wx/mac/macnotfy.h"
55
56#ifdef __DARWIN__
57# include <CoreServices/CoreServices.h>
58# if defined(WXMAKINGDLL)
59# include <mach-o/dyld.h>
60# endif
61#else
62# include <Sound.h>
63# include <Threads.h>
64# include <ToolUtils.h>
65# include <DiskInit.h>
66# include <Devices.h>
67#endif
68
69extern wxList wxPendingDelete;
70extern wxList *wxWinMacWindowList;
71extern wxList *wxWinMacControlList;
72
73// statics for implementation
74
75static bool s_inYield = FALSE;
76static bool s_inOnIdle = FALSE;
77
78#if TARGET_CARBON
79static bool s_inReceiveEvent = FALSE ;
80static EventTime sleepTime = kEventDurationNoWait ;
81#else
82static long sleepTime = 0 ;
83#endif
84
85#if !USE_SHARED_LIBRARY
86IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
87BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
88 EVT_IDLE(wxApp::OnIdle)
89 EVT_END_SESSION(wxApp::OnEndSession)
90 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
91END_EVENT_TABLE()
92#endif
93
94
95const short kMacMinHeap = (29 * 1024) ;
96// platform specific static variables
97
98const short kwxMacMenuBarResource = 1 ;
99const short kwxMacAppleMenuId = 1 ;
100
101WXHRGN wxApp::s_macCursorRgn = NULL;
102wxWindow* wxApp::s_captureWindow = NULL ;
103int wxApp::s_lastMouseDown = 0 ;
104long wxApp::sm_lastMessageTime = 0;
105long wxApp::s_lastModifiers = 0 ;
106
107
108bool wxApp::s_macDefaultEncodingIsPC = true ;
109bool wxApp::s_macSupportPCMenuShortcuts = true ;
110long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
111long wxApp::s_macPreferencesMenuItemId = 0 ;
112long wxApp::s_macExitMenuItemId = wxID_EXIT ;
113wxString wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
114
115//----------------------------------------------------------------------
116// Core Apple Event Support
117//----------------------------------------------------------------------
118
119pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
120pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
121pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
122pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
123
124pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
125{
126 return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
127}
128
129pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
130{
131 return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
132}
133
134pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
135{
136 return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
137}
138
139pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
140{
141 return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
142}
143
144// AEODoc Calls MacOpenFile on each of the files passed
145
146short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
147{
148 AEDescList docList;
149 AEKeyword keywd;
150 DescType returnedType;
151 Size actualSize;
152 long itemsInList;
153 FSSpec theSpec;
154 OSErr err;
155 short i;
156 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
157 if (err != noErr)
158 return err;
159
160 err = AECountItems(&docList, &itemsInList);
161 if (err != noErr)
162 return err;
163
164 ProcessSerialNumber PSN ;
165 PSN.highLongOfPSN = 0 ;
166 PSN.lowLongOfPSN = kCurrentProcess ;
167 SetFrontProcess( &PSN ) ;
168
169 for (i = 1; i <= itemsInList; i++) {
170 AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
171 (Ptr) & theSpec, sizeof(theSpec), &actualSize);
172 wxString fName = wxMacFSSpec2MacFilename(&theSpec);
173 MacOpenFile(fName);
174 }
175 return noErr;
176}
177
178// AEPDoc Calls MacPrintFile on each of the files passed
179
180short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
181{
182 AEDescList docList;
183 AEKeyword keywd;
184 DescType returnedType;
185 Size actualSize;
186 long itemsInList;
187 FSSpec theSpec;
188 OSErr err;
189 short i;
190 err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
191 if (err != noErr)
192 return err;
193
194 err = AECountItems(&docList, &itemsInList);
195 if (err != noErr)
196 return err;
197
198 ProcessSerialNumber PSN ;
199 PSN.highLongOfPSN = 0 ;
200 PSN.lowLongOfPSN = kCurrentProcess ;
201 SetFrontProcess( &PSN ) ;
202
203 for (i = 1; i <= itemsInList; i++) {
204 AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
205 (Ptr) & theSpec, sizeof(theSpec), &actualSize);
206 wxString fName = wxMacFSSpec2MacFilename(&theSpec);
207 MacPrintFile(fName);
208 }
209 return noErr;
210}
211
212// AEOApp calls MacNewFile
213
214short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
215{
216 MacNewFile() ;
217 return noErr ;
218}
219
220// AEQuit attempts to quit the application
221
222short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
223{
224 /* wxWindow* win = GetTopWindow() ;
225 if ( win )
226 {
227 win->Close(TRUE ) ;
228 }
229 else
230 */
231 {
232 ExitMainLoop() ;
233 }
234 return noErr ;
235}
236
237//----------------------------------------------------------------------
238// Support Routines linking the Mac...File Calls to the Document Manager
239//----------------------------------------------------------------------
240
241void wxApp::MacOpenFile(const wxString & fileName )
242{
243 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
244 if ( dm )
245 dm->CreateDocument(fileName , wxDOC_SILENT ) ;
246}
247
248void wxApp::MacPrintFile(const wxString & fileName )
249{
250 wxDocManager* dm = wxDocManager::GetDocumentManager() ;
251 if ( dm )
252 {
253 wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
254 if ( doc )
255 {
256 wxView* view = doc->GetFirstView() ;
257 if( view )
258 {
259 wxPrintout *printout = view->OnCreatePrintout();
260 if (printout)
261 {
262 wxPrinter printer;
263 printer.Print(view->GetFrame(), printout, TRUE);
264 delete printout;
265 }
266 }
267 if (doc->Close())
268 {
269 doc->DeleteAllViews();
270 dm->RemoveDocument(doc) ;
271 }
272 }
273 }
274}
275
276void wxApp::MacNewFile()
277{
278}
279
280//----------------------------------------------------------------------
281// Carbon Event Handler
282//----------------------------------------------------------------------
283
284#if TARGET_CARBON
285
286 static const EventTypeSpec eventList[] =
287 {
288 { kEventClassCommand, kEventProcessCommand } ,
289 { kEventClassCommand, kEventCommandUpdateStatus } ,
290
291 { kEventClassApplication , kEventAppActivated } ,
292 { kEventClassApplication , kEventAppDeactivated } ,
293 // handling the quit event is not recommended by apple
294 // rather using the quit apple event - which we do
295
296 { kEventClassAppleEvent , kEventAppleEvent } ,
297
298 { kEventClassMouse , kEventMouseDown } ,
299 { 'WXMC' , 'WXMC' }
300 } ;
301
302static pascal OSStatus MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
303{
304 return eventNotHandledErr ;
305}
306
307// due to the rather low-level event API of wxWindows, we cannot use RunApplicationEventLoop
308// but have to use ReceiveNextEvent dealing with events manually, therefore we also have
309// deal with clicks in the menu bar explicitely
310
311static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
312{
313 OSStatus result = eventNotHandledErr ;
314
315 switch( GetEventKind(event) )
316 {
317 case kEventMouseDown :
318 {
319 Point point ;
320 WindowRef window ;
321
322 GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
323 sizeof( Point ), NULL, &point );
324 short windowPart = ::FindWindow(point, &window);
325
326 if ( windowPart == inMenuBar )
327 {
328 MenuSelect( point ) ;
329 result = noErr ;
330 }
331 }
332 break ;
333 }
334
335 return result ;
336}
337
338static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
339{
340 OSStatus result = eventNotHandledErr ;
341
342 HICommand command ;
343
344 GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL,
345 sizeof( HICommand ), NULL, &command );
346
347 MenuCommand id = command.commandID ;
348 if ( id == kHICommandPreferences )
349 id = wxApp::s_macPreferencesMenuItemId ;
350
351 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
352 wxMenu* menu = NULL ;
353 wxMenuItem* item = NULL ;
354
355 if ( mbar )
356 item = mbar->FindItem( id , &menu ) ;
357
358 if ( item == NULL || menu == NULL || mbar == NULL )
359 return result ;
360
361 switch( GetEventKind( event ) )
362 {
363 case kEventProcessCommand :
364 {
365 if (item->IsCheckable())
366 {
367 item->Check( !item->IsChecked() ) ;
368 }
369
370 menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
371 result = noErr ;
372 }
373 break ;
374 case kEventCommandUpdateStatus:
375 // eventually trigger an updateui round
376 result = noErr ;
377 break ;
378 default :
379 break ;
380 }
381
382 return result ;
383}
384
385static pascal OSStatus ApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
386{
387 OSStatus result = eventNotHandledErr ;
388 switch ( GetEventKind( event ) )
389 {
390 case kEventAppActivated :
391 {
392 if ( wxTheApp )
393 wxTheApp->MacResume( true ) ;
394 result = noErr ;
395 }
396 break ;
397 case kEventAppDeactivated :
398 {
399 if ( wxTheApp )
400 wxTheApp->MacSuspend( true ) ;
401 result = noErr ;
402 }
403 break ;
404 default :
405 break ;
406 }
407 return result ;
408}
409
410pascal OSStatus wxAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
411{
412 OSStatus result = eventNotHandledErr ;
413 switch( GetEventClass( event ) )
414 {
415 case kEventClassCommand :
416 result = CommandEventHandler( handler , event , data ) ;
417 break ;
418 case kEventClassApplication :
419 result = ApplicationEventHandler( handler , event , data ) ;
420 break ;
421 case kEventClassMenu :
422 result = MenuEventHandler( handler , event , data ) ;
423 break ;
424 case kEventClassMouse :
425 result = MouseEventHandler( handler , event , data ) ;
426 break ;
427 case kEventClassAppleEvent :
428 {
429 EventRecord rec ;
430 wxMacConvertEventToRecord( event , &rec ) ;
431 result = AEProcessAppleEvent( &rec ) ;
432 }
433 break ;
434 default :
435 break ;
436 }
437
438 return result ;
439}
440
441DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler )
442
443#endif
444
445#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
446// we know it's there ;-)
447WXIMPORT char std::__throws_bad_alloc ;
448#endif
449
450bool wxApp::Initialize(int& argc, wxChar **argv)
451{
452 int error = 0 ;
453
454 // Mac-specific
455
456 UMAInitToolbox( 4 ) ;
457 SetEventMask( everyEvent ) ;
458 UMAShowWatchCursor() ;
459
460#if defined(WXMAKINGDLL) && defined(__DARWIN__)
461 // open shared library resources from here since we don't have
462 // __wxinitialize in Mach-O shared libraries
463 wxStAppResource::OpenSharedLibraryResource(NULL);
464#endif
465
466#ifndef __DARWIN__
467 // test the minimal configuration necessary
468
469# if !TARGET_CARBON
470 long theSystem ;
471 long theMachine;
472
473 if (Gestalt(gestaltMachineType, &theMachine) != noErr)
474 {
475 error = kMacSTRWrongMachine;
476 }
477 else if (theMachine < gestaltMacPlus)
478 {
479 error = kMacSTRWrongMachine;
480 }
481 else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
482 {
483 error = kMacSTROldSystem ;
484 }
485 else if ( theSystem < 0x0860 )
486 {
487 error = kMacSTROldSystem ;
488 }
489 else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
490 {
491 error = kMacSTRSmallSize;
492 }
493# endif
494 /*
495 else
496 {
497 if ( !UMAHasAppearance() )
498 {
499 error = kMacSTRNoPre8Yet ;
500 }
501 }
502 */
503#endif
504
505 // if we encountered any problems so far, give the error code and exit immediately
506
507 if ( error )
508 {
509 wxStAppResource resload ;
510 short itemHit;
511 Str255 message;
512
513 GetIndString(message, 128, error);
514 UMAShowArrowCursor() ;
515 ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
516 itemHit = Alert(128, nil);
517 return FALSE ;
518 }
519
520#ifndef __DARWIN__
521# if __option(profile)
522 ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
523# endif
524#endif
525
526#ifndef __DARWIN__
527 // now avoid exceptions thrown for new (bad_alloc)
528 // FIXME CS for some changes outside wxMac does not compile anymore
529#if 0
530 std::__throws_bad_alloc = 0 ;
531#endif
532
533#endif
534 wxMacSetupConverters() ;
535
536 s_macCursorRgn = ::NewRgn() ;
537
538 // Mac OS X passes a process serial number command line argument when
539 // the application is launched from the Finder. This argument must be
540 // removed from the command line arguments before being handled by the
541 // application (otherwise applications would need to handle it)
542 if ( argc > 1 )
543 {
544 static const wxChar *ARG_PSN = _T("-psn_");
545 if ( wxStrncmp(argv[1], ARG_PSN, sizeof(ARG_PSN) - 1) == 0 )
546 {
547 // remove this argument
548 memmove(argv, argv + 1, argc--);
549 }
550 }
551
552 if ( !wxAppBase::Initialize(argc, argv) )
553 return false;
554
555 wxWinMacWindowList = new wxList(wxKEY_INTEGER);
556 wxWinMacControlList = new wxList(wxKEY_INTEGER);
557
558 wxMacCreateNotifierTable() ;
559
560 UMAShowArrowCursor() ;
561
562 return true;
563}
564
565bool wxApp::OnInitGui()
566{
567 if( !wxAppBase::OnInitGui() )
568 return false ;
569
570#if TARGET_CARBON
571 InstallStandardEventHandler( GetApplicationEventTarget() ) ;
572
573 InstallApplicationEventHandler(
574 GetwxAppEventHandlerUPP(),
575 GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
576#endif
577
578#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
579 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
580 NewAEEventHandlerUPP(AEHandleODoc) ,
581 0 , FALSE ) ;
582 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
583 NewAEEventHandlerUPP(AEHandleOApp) ,
584 0 , FALSE ) ;
585 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
586 NewAEEventHandlerUPP(AEHandlePDoc) ,
587 0 , FALSE ) ;
588 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
589 NewAEEventHandlerUPP(AEHandleQuit) ,
590 0 , FALSE ) ;
591#else
592 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
593 NewAEEventHandlerProc(AEHandleODoc) ,
594 0 , FALSE ) ;
595 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
596 NewAEEventHandlerProc(AEHandleOApp) ,
597 0 , FALSE ) ;
598 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
599 NewAEEventHandlerProc(AEHandlePDoc) ,
600 0 , FALSE ) ;
601 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
602 NewAEEventHandlerProc(AEHandleQuit) ,
603 0 , FALSE ) ;
604#endif
605
606 return TRUE ;
607}
608
609void wxApp::CleanUp()
610{
611 wxToolTip::RemoveToolTips() ;
612
613 // One last chance for pending objects to be cleaned up
614 wxTheApp->DeletePendingObjects();
615
616 wxMacDestroyNotifierTable() ;
617
618 delete wxWinMacWindowList ;
619 wxWinMacWindowList = NULL;
620
621 delete wxWinMacControlList ;
622 wxWinMacControlList = NULL;
623
624#ifndef __DARWIN__
625# if __option(profile)
626 ProfilerDump( (StringPtr)"\papp.prof" ) ;
627 ProfilerTerm() ;
628# endif
629#endif
630
631#if defined(WXMAKINGDLL) && defined(__DARWIN__)
632 // close shared library resources from here since we don't have
633 // __wxterminate in Mach-O shared libraries
634 wxStAppResource::CloseSharedLibraryResource();
635#endif
636 wxMacCleanupConverters() ;
637
638 UMACleanupToolbox() ;
639 if (s_macCursorRgn) {
640 ::DisposeRgn((RgnHandle)s_macCursorRgn);
641 }
642
643 #if 0
644 TerminateAE() ;
645 #endif
646
647 wxAppBase::CleanUp();
648}
649
650//----------------------------------------------------------------------
651// misc initialization stuff
652//----------------------------------------------------------------------
653
654// extern variable for shared library resource id
655// need to be able to find it with NSLookupAndBindSymbol
656short gSharedLibraryResource = kResFileNotOpened ;
657
658#if defined(WXMAKINGDLL) && defined(__DARWIN__)
659CFBundleRef gSharedLibraryBundle = NULL;
660#endif /* WXMAKINGDLL && __DARWIN__ */
661
662wxStAppResource::wxStAppResource()
663{
664 m_currentRefNum = CurResFile() ;
665 if ( gSharedLibraryResource != kResFileNotOpened )
666 {
667 UseResFile( gSharedLibraryResource ) ;
668 }
669}
670
671wxStAppResource::~wxStAppResource()
672{
673 if ( m_currentRefNum != kResFileNotOpened )
674 {
675 UseResFile( m_currentRefNum ) ;
676 }
677}
678
679void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
680{
681 gSharedLibraryResource = kResFileNotOpened;
682
683#ifdef WXMAKINGDLL
684 if ( initBlock != NULL ) {
685 const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
686 FSSpec *fileSpec = NULL;
687
688 if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
689 fileSpec = theInitBlock->fragLocator.u.onDisk.fileSpec;
690 }
691 else if (theInitBlock->fragLocator.where == kResourceCFragLocator) {
692 fileSpec = theInitBlock->fragLocator.u.inSegs.fileSpec;
693 }
694
695 if (fileSpec != NULL) {
696 gSharedLibraryResource = FSpOpenResFile(fileSpec, fsRdPerm);
697 }
698 }
699 else {
700#ifdef __DARWIN__
701 // Open the shared library resource file if it is not yet open
702 NSSymbol theSymbol;
703 NSModule theModule;
704 const char *theLibPath;
705
706 gSharedLibraryBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
707 if (gSharedLibraryBundle != NULL) {
708 // wxWindows has been bundled into a framework
709 // load the framework resources
710
711 gSharedLibraryResource = CFBundleOpenBundleResourceMap(gSharedLibraryBundle);
712 }
713 else {
714 // wxWindows is a simple dynamic shared library
715 // load the resources from the data fork of a separate resource file
716 char *theResPath;
717 char *theName;
718 char *theExt;
719 FSRef theResRef;
720 OSErr theErr = noErr;
721
722 // get the library path
723 theSymbol = NSLookupAndBindSymbol("_gSharedLibraryResource");
724 theModule = NSModuleForSymbol(theSymbol);
725 theLibPath = NSLibraryNameForModule(theModule);
726
727 // if we call wxLogDebug from here then, as wxTheApp hasn't been
728 // created yet when we're called from wxApp::Initialize(), wxLog
729 // is going to create a default stderr-based log target instead of
730 // the expected normal GUI one -- don't do it, if we really want
731 // to see this message just use fprintf() here
732#if 0
733 wxLogDebug( wxT("wxMac library installation name is '%s'"),
734 theLibPath );
735#endif
736
737 // allocate copy to replace .dylib.* extension with .rsrc
738 theResPath = strdup(theLibPath);
739 if (theResPath != NULL) {
740 theName = strrchr(theResPath, '/');
741 if (theName == NULL) {
742 // no directory elements in path
743 theName = theResPath;
744 }
745 // find ".dylib" shared library extension
746 theExt = strstr(theName, ".dylib");
747 // overwrite extension with ".rsrc"
748 strcpy(theExt, ".rsrc");
749
750#if 0
751 wxLogDebug( wxT("wxMac resources file name is '%s'"),
752 theResPath );
753#endif
754
755 theErr = FSPathMakeRef((UInt8 *) theResPath, &theResRef, false);
756 if (theErr != noErr) {
757 // try in current directory (using name only)
758 theErr = FSPathMakeRef((UInt8 *) theName, &theResRef, false);
759 }
760
761 // open the resource file
762 if (theErr == noErr) {
763 theErr = FSOpenResourceFile( &theResRef, 0, NULL, fsRdPerm,
764 &gSharedLibraryResource);
765 }
766 if (theErr != noErr) {
767#ifdef __WXDEBUG__
768 fprintf(stderr,
769 wxT("unable to open wxMac resource file '%s'\n"),
770 theResPath );
771#endif // __WXDEBUG__
772 }
773
774 // free duplicated resource file path
775 free(theResPath);
776 }
777 }
778#endif /* __DARWIN__ */
779 }
780#endif /* WXMAKINGDLL */
781}
782
783void wxStAppResource::CloseSharedLibraryResource()
784{
785#ifdef WXMAKINGDLL
786 // Close the shared library resource file
787 if (gSharedLibraryResource != kResFileNotOpened) {
788#ifdef __DARWIN__
789 if (gSharedLibraryBundle != NULL) {
790 CFBundleCloseBundleResourceMap(gSharedLibraryBundle,
791 gSharedLibraryResource);
792 gSharedLibraryBundle = NULL;
793 }
794 else
795#endif /* __DARWIN__ */
796 {
797 CloseResFile(gSharedLibraryResource);
798 }
799 gSharedLibraryResource = kResFileNotOpened;
800 }
801#endif /* WXMAKINGDLL */
802}
803
804#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
805
806// for shared libraries we have to manually get the correct resource
807// ref num upon initializing and releasing when terminating, therefore
808// the __wxinitialize and __wxterminate must be used
809
810extern "C" {
811 void __sinit(void); /* (generated by linker) */
812 pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
813 pascal void __terminate(void);
814}
815
816pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
817{
818 wxStAppResource::OpenSharedLibraryResource( theInitBlock ) ;
819 return __initialize( theInitBlock ) ;
820}
821
822pascal void __wxterminate(void)
823{
824 wxStAppResource::CloseSharedLibraryResource() ;
825 __terminate() ;
826}
827
828#endif /* WXMAKINGDLL && !__DARWIN__ */
829
830#if TARGET_CARBON
831
832bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
833{
834 bool converted = ConvertEventRefToEventRecord( event,rec) ;
835 OSStatus err = noErr ;
836 if ( !converted )
837 {
838 switch( GetEventClass( event ) )
839 {
840 case kEventClassKeyboard :
841 {
842 converted = true ;
843 switch( GetEventKind(event) )
844 {
845 case kEventRawKeyDown :
846 rec->what = keyDown ;
847 break ;
848 case kEventRawKeyRepeat :
849 rec->what = autoKey ;
850 break ;
851 case kEventRawKeyUp :
852 rec->what = keyUp ;
853 break ;
854 case kEventRawKeyModifiersChanged :
855 rec->what = nullEvent ;
856 break ;
857 default :
858 converted = false ;
859 break ;
860 }
861 if ( converted )
862 {
863 UInt32 keyCode ;
864 unsigned char charCode ;
865 UInt32 modifiers ;
866 GetMouse( &rec->where) ;
867
868 err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
869 err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
870 err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
871 rec->modifiers = modifiers ;
872 rec->message = (keyCode << 8 ) + charCode ;
873 }
874 }
875 break ;
876 case kEventClassTextInput :
877 {
878 switch( GetEventKind( event ) )
879 {
880 case kEventTextInputUnicodeForKeyEvent :
881 {
882 EventRef rawEvent ;
883 err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
884 converted = true ;
885 {
886 UInt32 keyCode ;
887 unsigned char charCode ;
888 UInt32 modifiers ;
889 GetMouse( &rec->where) ;
890 rec->what = keyDown ;
891 err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
892 err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
893 err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
894 rec->modifiers = modifiers ;
895 rec->message = (keyCode << 8 ) + charCode ;
896 }
897 }
898 break ;
899 default :
900 break ;
901 }
902 }
903 break ;
904 }
905 }
906
907 return converted ;
908}
909
910/*
911pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
912{
913 OSStatus result = eventNotHandledErr ;
914
915 EventRecord rec ;
916 switch ( GetEventClass( event ) )
917 {
918 case kEventClassKeyboard :
919 if ( wxMacConvertEventToRecord( event , &rec ) )
920 {
921 wxTheApp->MacHandleModifierEvents( &rec ) ;
922 wxTheApp->MacHandleOneEvent( &rec ) ;
923 result = noErr ;
924 }
925 break ;
926 case kEventClassTextInput :
927 if ( wxMacConvertEventToRecord( event , &rec ) )
928 {
929 wxTheApp->MacHandleModifierEvents( &rec ) ;
930 wxTheApp->MacHandleOneEvent( &rec ) ;
931 result = noErr ;
932 }
933 break ;
934 default :
935 break ;
936 }
937 return result ;
938}
939*/
940#endif
941
942wxApp::wxApp()
943{
944 m_topWindow = NULL;
945 wxTheApp = this;
946
947 argc = 0;
948 argv = NULL;
949
950 m_printMode = wxPRINT_WINDOWS;
951 m_auto3D = TRUE;
952}
953
954bool wxApp::Initialized()
955{
956 if (GetTopWindow())
957 return TRUE;
958 else
959 return FALSE;
960}
961
962int wxApp::MainLoop()
963{
964 m_keepGoing = TRUE;
965
966 while (m_keepGoing)
967 {
968 MacDoOneEvent() ;
969 }
970
971 return 0;
972}
973
974void wxApp::ExitMainLoop()
975{
976 m_keepGoing = FALSE;
977}
978
979// Is a message/event pending?
980bool wxApp::Pending()
981{
982#if TARGET_CARBON
983 return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
984#else
985 EventRecord event ;
986
987 return EventAvail( everyEvent , &event ) ;
988#endif
989}
990
991// Dispatch a message.
992void wxApp::Dispatch()
993{
994 MacDoOneEvent() ;
995}
996
997void wxApp::OnIdle(wxIdleEvent& event)
998{
999 // Avoid recursion (via ProcessEvent default case)
1000 if ( s_inOnIdle )
1001 return;
1002
1003
1004 s_inOnIdle = TRUE;
1005
1006 // 'Garbage' collection of windows deleted with Close().
1007 DeletePendingObjects();
1008
1009 // flush the logged messages if any
1010 wxLog *pLog = wxLog::GetActiveTarget();
1011 if ( pLog != NULL && pLog->HasPendingMessages() )
1012 pLog->Flush();
1013
1014 // Send OnIdle events to all windows
1015 bool needMore = SendIdleEvents();
1016
1017 if (needMore)
1018 event.RequestMore(TRUE);
1019
1020 // If they are pending events, we must process them: pending events are
1021 // either events to the threads other than main or events posted with
1022 // wxPostEvent() functions
1023 wxMacProcessNotifierAndPendingEvents();
1024
1025 s_inOnIdle = FALSE;
1026 if(!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
1027 wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
1028}
1029
1030void wxApp::WakeUpIdle()
1031{
1032 wxMacWakeUp() ;
1033}
1034
1035void wxApp::Exit()
1036{
1037 wxApp::CleanUp();
1038 ::ExitToShell() ;
1039}
1040
1041void 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.
1049void wxApp::OnQueryEndSession(wxCloseEvent& event)
1050{
1051 if (GetTopWindow())
1052 {
1053 if (!GetTopWindow()->Close(!event.CanVeto()))
1054 event.Veto(TRUE);
1055 }
1056}
1057
1058extern "C" void wxCYield() ;
1059void wxCYield()
1060{
1061 wxYield() ;
1062}
1063
1064// Yield to other processes
1065
1066bool wxApp::Yield(bool onlyIfNeeded)
1067{
1068 if (s_inYield)
1069 {
1070 if ( !onlyIfNeeded )
1071 {
1072 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1073 }
1074
1075 return FALSE;
1076 }
1077
1078 s_inYield = TRUE;
1079
1080#if wxUSE_THREADS
1081 YieldToAnyThread() ;
1082#endif
1083 // by definition yield should handle all non-processed events
1084#if TARGET_CARBON
1085 EventRef theEvent;
1086
1087 OSStatus status = noErr ;
1088 do
1089 {
1090 s_inReceiveEvent = true ;
1091 status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
1092 s_inReceiveEvent = false ;
1093
1094 if ( status == eventLoopTimedOutErr )
1095 {
1096 // make sure next time the event loop will trigger idle events
1097 sleepTime = kEventDurationNoWait ;
1098 }
1099 else if ( status == eventLoopQuitErr )
1100 {
1101 // according to QA1061 this may also occur when a WakeUp Process
1102 // is executed
1103 }
1104 else
1105 {
1106 MacHandleOneEvent( theEvent ) ;
1107 ReleaseEvent(theEvent);
1108 }
1109 } while( status == noErr ) ;
1110#else
1111 EventRecord event ;
1112
1113 // having a larger value here leads to large performance slowdowns
1114 // so we cannot give background apps more processor time here
1115 // we do so however having a large sleep value in the main event loop
1116 sleepTime = 0 ;
1117
1118 while ( !IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
1119 {
1120 MacHandleModifierEvents( &event ) ;
1121 MacHandleOneEvent( &event );
1122 if ( event.what != kHighLevelEvent )
1123 SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v , event.where.h + 1 , event.where.v + 1 ) ;
1124 }
1125 MacHandleModifierEvents( &event ) ;
1126#endif
1127
1128 wxMacProcessNotifierAndPendingEvents() ;
1129 s_inYield = FALSE;
1130
1131 return TRUE;
1132}
1133
1134// platform specifics
1135
1136void wxApp::MacSuspend( bool convertClipboard )
1137{
1138#if !TARGET_CARBON
1139 // we have to deactive the top level windows manually
1140
1141 wxWindowListNode* node = wxTopLevelWindows.GetFirst();
1142 while (node)
1143 {
1144 wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
1145#if TARGET_CARBON
1146#if 0 // having problems right now with that
1147 if (!win->HasFlag(wxSTAY_ON_TOP))
1148#endif
1149#endif
1150 win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
1151
1152 node = node->GetNext();
1153 }
1154
1155 ::HideFloatingWindows() ;
1156#endif
1157 s_lastMouseDown = 0 ;
1158
1159 if( convertClipboard )
1160 {
1161 MacConvertPrivateToPublicScrap() ;
1162 }
1163}
1164
1165extern wxList wxModalDialogs;
1166
1167void wxApp::MacResume( bool convertClipboard )
1168{
1169 s_lastMouseDown = 0 ;
1170 if( convertClipboard )
1171 {
1172 MacConvertPublicToPrivateScrap() ;
1173 }
1174
1175#if !TARGET_CARBON
1176 ::ShowFloatingWindows() ;
1177 // raise modal dialogs in case a non modal window was selected to activate the app
1178
1179 wxNode* node = wxModalDialogs.GetFirst();
1180 while (node)
1181 {
1182 wxDialog* dialog = (wxDialog *) node->GetData();
1183 dialog->Raise();
1184
1185 node = node->GetNext();
1186 }
1187#endif
1188}
1189
1190void wxApp::MacConvertPrivateToPublicScrap()
1191{
1192}
1193
1194void wxApp::MacConvertPublicToPrivateScrap()
1195{
1196}
1197
1198void wxApp::MacDoOneEvent()
1199{
1200#if TARGET_CARBON
1201 EventRef theEvent;
1202
1203 s_inReceiveEvent = true ;
1204 OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
1205 s_inReceiveEvent = false ;
1206 if ( status == eventLoopTimedOutErr )
1207 {
1208 if ( wxTheApp->ProcessIdle() )
1209 sleepTime = kEventDurationNoWait ;
1210 else
1211 sleepTime = kEventDurationForever ;
1212 }
1213 else if ( status == eventLoopQuitErr )
1214 {
1215 // according to QA1061 this may also occur when a WakeUp Process
1216 // is executed
1217 }
1218 else
1219 {
1220 MacHandleOneEvent( theEvent ) ;
1221 ReleaseEvent(theEvent);
1222 sleepTime = kEventDurationNoWait ;
1223 }
1224#else
1225 EventRecord event ;
1226
1227 EventMask eventMask = everyEvent ;
1228
1229 if (WaitNextEvent(eventMask, &event, sleepTime, (RgnHandle) s_macCursorRgn))
1230 {
1231 MacHandleModifierEvents( &event ) ;
1232 MacHandleOneEvent( &event );
1233 }
1234 else
1235 {
1236 MacHandleModifierEvents( &event ) ;
1237 // idlers
1238 WindowPtr window = ::FrontWindow() ;
1239 if ( window )
1240 ::IdleControls( window ) ;
1241
1242 if ( wxTheApp->ProcessIdle() )
1243 sleepTime = 0 ;
1244 else
1245 sleepTime = GetCaretTime() / 2 ;
1246 }
1247 if ( event.what != kHighLevelEvent )
1248 SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v , event.where.h + 1 , event.where.v + 1 ) ;
1249#endif
1250 // repeaters
1251
1252 DeletePendingObjects() ;
1253 wxMacProcessNotifierAndPendingEvents() ;
1254}
1255
1256void wxApp::MacHandleOneEvent( WXEVENTREF evr )
1257{
1258#if TARGET_CARBON
1259 EventTargetRef theTarget;
1260 theTarget = GetEventDispatcherTarget();
1261 m_macCurrentEvent = evr ;
1262 SendEventToEventTarget ((EventRef) evr , theTarget);
1263#else
1264 EventRecord* ev = (EventRecord*) evr ;
1265 m_macCurrentEvent = ev ;
1266
1267 wxApp::sm_lastMessageTime = ev->when ;
1268
1269 switch (ev->what)
1270 {
1271 case mouseDown:
1272 MacHandleMouseDownEvent( ev ) ;
1273 if ( ev->modifiers & controlKey )
1274 s_lastMouseDown = 2;
1275 else
1276 s_lastMouseDown = 1;
1277 break;
1278 case mouseUp:
1279 if ( s_lastMouseDown == 2 )
1280 {
1281 ev->modifiers |= controlKey ;
1282 }
1283 else
1284 {
1285 ev->modifiers &= ~controlKey ;
1286 }
1287 MacHandleMouseUpEvent( ev ) ;
1288 s_lastMouseDown = 0;
1289 break;
1290 case activateEvt:
1291 MacHandleActivateEvent( ev ) ;
1292 break;
1293 case updateEvt:
1294 MacHandleUpdateEvent( ev ) ;
1295 break;
1296 case keyDown:
1297 case autoKey:
1298 MacHandleKeyDownEvent( ev ) ;
1299 break;
1300 case keyUp:
1301 MacHandleKeyUpEvent( ev ) ;
1302 break;
1303 case diskEvt:
1304 MacHandleDiskEvent( ev ) ;
1305 break;
1306 case osEvt:
1307 MacHandleOSEvent( ev ) ;
1308 break;
1309 case kHighLevelEvent:
1310 MacHandleHighLevelEvent( ev ) ;
1311 break;
1312 default:
1313 break;
1314 }
1315#endif
1316 wxMacProcessNotifierAndPendingEvents() ;
1317}
1318
1319#if !TARGET_CARBON
1320bool s_macIsInModalLoop = false ;
1321
1322void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
1323{
1324 EventRecord* ev = (EventRecord*) evr ;
1325 if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
1326 {
1327 wxKeyEvent event(wxEVT_KEY_DOWN);
1328
1329 event.m_shiftDown = ev->modifiers & shiftKey;
1330 event.m_controlDown = ev->modifiers & controlKey;
1331 event.m_altDown = ev->modifiers & optionKey;
1332 event.m_metaDown = ev->modifiers & cmdKey;
1333
1334 event.m_x = ev->where.h;
1335 event.m_y = ev->where.v;
1336 event.m_timeStamp = ev->when;
1337 wxWindow* focus = wxWindow::FindFocus() ;
1338 event.SetEventObject(focus);
1339
1340 if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
1341 {
1342 event.m_keyCode = WXK_CONTROL ;
1343 event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1344 focus->GetEventHandler()->ProcessEvent( event ) ;
1345 }
1346 if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
1347 {
1348 event.m_keyCode = WXK_SHIFT ;
1349 event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1350 focus->GetEventHandler()->ProcessEvent( event ) ;
1351 }
1352 if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
1353 {
1354 event.m_keyCode = WXK_ALT ;
1355 event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
1356 focus->GetEventHandler()->ProcessEvent( event ) ;
1357 }
1358 s_lastModifiers = ev->modifiers ;
1359 }
1360}
1361
1362void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
1363{
1364 // we must avoid reentrancy problems when processing high level events eg printing
1365 bool former = s_inYield ;
1366 s_inYield = TRUE ;
1367 EventRecord* ev = (EventRecord*) evr ;
1368 ::AEProcessAppleEvent( ev ) ;
1369 s_inYield = former ;
1370}
1371
1372void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
1373{
1374 EventRecord* ev = (EventRecord*) evr ;
1375 wxToolTip::RemoveToolTips() ;
1376
1377 WindowRef window;
1378 WindowRef frontWindow = ::FrontNonFloatingWindow() ;
1379 WindowAttributes frontWindowAttributes = NULL ;
1380 if ( frontWindow )
1381 ::GetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
1382
1383 short windowPart = ::FindWindow(ev->where, &window);
1384 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1385 if ( wxPendingDelete.Member(win) )
1386 return ;
1387
1388 BitMap screenBits;
1389 GetQDGlobalsScreenBits( &screenBits );
1390
1391 switch (windowPart)
1392 {
1393 case inMenuBar :
1394 if ( s_macIsInModalLoop )
1395 {
1396 SysBeep ( 30 ) ;
1397 }
1398 else
1399 {
1400 UInt32 menuresult = MenuSelect(ev->where) ;
1401 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
1402 s_lastMouseDown = 0;
1403 }
1404 break ;
1405 case inSysWindow :
1406 SystemClick( ev , window ) ;
1407 s_lastMouseDown = 0;
1408 break ;
1409 case inDrag :
1410 if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
1411 {
1412 SysBeep ( 30 ) ;
1413 }
1414 else
1415 {
1416 DragWindow(window, ev->where, &screenBits.bounds);
1417 if (win)
1418 {
1419 GrafPtr port ;
1420 GetPort( &port ) ;
1421 Point pt = { 0, 0 } ;
1422 SetPortWindowPort(window) ;
1423 LocalToGlobal( &pt ) ;
1424 SetPort( port ) ;
1425 win->SetSize( pt.h , pt.v , -1 ,
1426 -1 , wxSIZE_USE_EXISTING);
1427 }
1428 s_lastMouseDown = 0;
1429 }
1430 break ;
1431 case inGoAway:
1432 if (TrackGoAway(window, ev->where))
1433 {
1434 if ( win )
1435 win->Close() ;
1436 }
1437 s_lastMouseDown = 0;
1438 break;
1439 case inGrow:
1440 {
1441 Rect newContentRect ;
1442 Rect constraintRect ;
1443 constraintRect.top = win->GetMinHeight() ;
1444 if ( constraintRect.top == -1 )
1445 constraintRect.top = 0 ;
1446 constraintRect.left = win->GetMinWidth() ;
1447 if ( constraintRect.left == -1 )
1448 constraintRect.left = 0 ;
1449 constraintRect.right = win->GetMaxWidth() ;
1450 if ( constraintRect.right == -1 )
1451 constraintRect.right = 32000 ;
1452 constraintRect.bottom = win->GetMaxHeight() ;
1453 if ( constraintRect.bottom == -1 )
1454 constraintRect.bottom = 32000 ;
1455
1456 Boolean growResult = ResizeWindow( window , ev->where ,
1457 &constraintRect , &newContentRect ) ;
1458 if ( growResult )
1459 {
1460 win->SetSize( newContentRect.left , newContentRect.top ,
1461 newContentRect.right - newContentRect.left ,
1462 newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
1463 }
1464 s_lastMouseDown = 0;
1465 }
1466 break;
1467 case inZoomIn:
1468 case inZoomOut:
1469 if (TrackBox(window, ev->where, windowPart))
1470 {
1471 // TODO setup size event
1472 ZoomWindow( window , windowPart , false ) ;
1473 if (win)
1474 {
1475 Rect tempRect ;
1476 GrafPtr port ;
1477 GetPort( &port ) ;
1478 Point pt = { 0, 0 } ;
1479 SetPortWindowPort(window) ;
1480 LocalToGlobal( &pt ) ;
1481 SetPort( port ) ;
1482
1483 GetWindowPortBounds(window, &tempRect ) ;
1484 win->SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
1485 tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
1486 }
1487 }
1488 s_lastMouseDown = 0;
1489 break;
1490 case inCollapseBox :
1491 // TODO setup size event
1492 s_lastMouseDown = 0;
1493 break ;
1494
1495 case inContent :
1496 {
1497 GrafPtr port ;
1498 GetPort( &port ) ;
1499 SetPortWindowPort(window) ;
1500 SetPort( port ) ;
1501 }
1502 if ( window != frontWindow && wxTheApp->s_captureWindow == NULL )
1503 {
1504 if ( s_macIsInModalLoop )
1505 {
1506 SysBeep ( 30 ) ;
1507 }
1508 else if ( UMAIsWindowFloating( window ) )
1509 {
1510 if ( win )
1511 win->MacMouseDown( ev , windowPart ) ;
1512 }
1513 else
1514 {
1515 if ( win )
1516 win->MacMouseDown( ev , windowPart ) ;
1517 ::SelectWindow( window ) ;
1518 }
1519 }
1520 else
1521 {
1522 if ( win )
1523 win->MacMouseDown( ev , windowPart ) ;
1524 }
1525 break ;
1526 default:
1527 break;
1528 }
1529}
1530
1531void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
1532{
1533 EventRecord* ev = (EventRecord*) evr ;
1534 WindowRef window;
1535
1536 short windowPart = inNoWindow ;
1537 if ( wxTheApp->s_captureWindow )
1538 {
1539 window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
1540 windowPart = inContent ;
1541 }
1542 else
1543 {
1544 windowPart = ::FindWindow(ev->where, &window) ;
1545 }
1546
1547 switch (windowPart)
1548 {
1549 case inMenuBar :
1550 break ;
1551 case inSysWindow :
1552 break ;
1553 default:
1554 {
1555 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1556 if ( win )
1557 win->MacMouseUp( ev , windowPart ) ;
1558 }
1559 break;
1560 }
1561}
1562
1563#endif
1564
1565long wxMacTranslateKey(unsigned char key, unsigned char code) ;
1566long wxMacTranslateKey(unsigned char key, unsigned char code)
1567{
1568 long retval = key ;
1569 switch (key)
1570 {
1571 case kHomeCharCode :
1572 retval = WXK_HOME;
1573 break;
1574 case kEnterCharCode :
1575 retval = WXK_RETURN;
1576 break;
1577 case kEndCharCode :
1578 retval = WXK_END;
1579 break;
1580 case kHelpCharCode :
1581 retval = WXK_HELP;
1582 break;
1583 case kBackspaceCharCode :
1584 retval = WXK_BACK;
1585 break;
1586 case kTabCharCode :
1587 retval = WXK_TAB;
1588 break;
1589 case kPageUpCharCode :
1590 retval = WXK_PAGEUP;
1591 break;
1592 case kPageDownCharCode :
1593 retval = WXK_PAGEDOWN;
1594 break;
1595 case kReturnCharCode :
1596 retval = WXK_RETURN;
1597 break;
1598 case kFunctionKeyCharCode :
1599 {
1600 switch( code )
1601 {
1602 case 0x7a :
1603 retval = WXK_F1 ;
1604 break;
1605 case 0x78 :
1606 retval = WXK_F2 ;
1607 break;
1608 case 0x63 :
1609 retval = WXK_F3 ;
1610 break;
1611 case 0x76 :
1612 retval = WXK_F4 ;
1613 break;
1614 case 0x60 :
1615 retval = WXK_F5 ;
1616 break;
1617 case 0x61 :
1618 retval = WXK_F6 ;
1619 break;
1620 case 0x62:
1621 retval = WXK_F7 ;
1622 break;
1623 case 0x64 :
1624 retval = WXK_F8 ;
1625 break;
1626 case 0x65 :
1627 retval = WXK_F9 ;
1628 break;
1629 case 0x6D :
1630 retval = WXK_F10 ;
1631 break;
1632 case 0x67 :
1633 retval = WXK_F11 ;
1634 break;
1635 case 0x6F :
1636 retval = WXK_F12 ;
1637 break;
1638 case 0x69 :
1639 retval = WXK_F13 ;
1640 break;
1641 case 0x6B :
1642 retval = WXK_F14 ;
1643 break;
1644 case 0x71 :
1645 retval = WXK_F15 ;
1646 break;
1647 }
1648 }
1649 break ;
1650 case kEscapeCharCode :
1651 retval = WXK_ESCAPE ;
1652 break ;
1653 case kLeftArrowCharCode :
1654 retval = WXK_LEFT ;
1655 break ;
1656 case kRightArrowCharCode :
1657 retval = WXK_RIGHT ;
1658 break ;
1659 case kUpArrowCharCode :
1660 retval = WXK_UP ;
1661 break ;
1662 case kDownArrowCharCode :
1663 retval = WXK_DOWN ;
1664 break ;
1665 case kDeleteCharCode :
1666 retval = WXK_DELETE ;
1667 default:
1668 break ;
1669 } // end switch
1670
1671 return retval;
1672}
1673
1674#if !TARGET_CARBON
1675void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
1676{
1677 EventRecord* ev = (EventRecord*) evr ;
1678 wxToolTip::RemoveToolTips() ;
1679
1680 UInt32 menuresult = UMAMenuEvent(ev) ;
1681 if ( HiWord( menuresult ) )
1682 {
1683 if ( !s_macIsInModalLoop )
1684 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1685 }
1686 else
1687 {
1688 wxWindow* focus = wxWindow::FindFocus() ;
1689
1690 if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
1691 {
1692 // has not been handled -> perform default
1693 wxControl* control = wxDynamicCast( focus , wxControl ) ;
1694 if ( control && control->GetMacControl() != NULL )
1695 {
1696 short keycode ;
1697 short keychar ;
1698 keychar = short(ev->message & charCodeMask);
1699 keycode = short(ev->message & keyCodeMask) >> 8 ;
1700 ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
1701 }
1702 }
1703 }
1704}
1705
1706void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
1707{
1708 EventRecord* ev = (EventRecord*) evr ;
1709 wxToolTip::RemoveToolTips() ;
1710
1711 UInt32 menuresult = UMAMenuEvent(ev) ;
1712 if ( HiWord( menuresult ) )
1713 {
1714 }
1715 else
1716 {
1717 MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
1718 }
1719}
1720
1721#endif
1722
1723bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1724{
1725 if ( !focus )
1726 return false ;
1727
1728 short keycode ;
1729 short keychar ;
1730 keychar = short(keymessage & charCodeMask);
1731 keycode = short(keymessage & keyCodeMask) >> 8 ;
1732
1733 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1734 {
1735 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1736 // and look at the character after
1737 UInt32 state = 0;
1738 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1739 keychar = short(keyInfo & charCodeMask);
1740 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1741 }
1742 long keyval = wxMacTranslateKey(keychar, keycode) ;
1743 long realkeyval = keyval ;
1744 if ( keyval == keychar )
1745 {
1746 // we are not on a special character combo -> pass the real os event-value to EVT_CHAR, but not to EVT_KEY (make upper first)
1747 realkeyval = short(keymessage & charCodeMask) ;
1748 keyval = wxToupper( keyval ) ;
1749 }
1750
1751 wxKeyEvent event(wxEVT_KEY_DOWN);
1752 bool handled = false ;
1753 event.m_shiftDown = modifiers & shiftKey;
1754 event.m_controlDown = modifiers & controlKey;
1755 event.m_altDown = modifiers & optionKey;
1756 event.m_metaDown = modifiers & cmdKey;
1757 event.m_keyCode = keyval ;
1758
1759 event.m_x = wherex;
1760 event.m_y = wherey;
1761 event.m_timeStamp = when;
1762 event.SetEventObject(focus);
1763 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1764 if ( handled && event.GetSkipped() )
1765 handled = false ;
1766 if ( !handled )
1767 {
1768#if wxUSE_ACCEL
1769 if (!handled)
1770 {
1771 wxWindow *ancestor = focus;
1772 while (ancestor)
1773 {
1774 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1775 if (command != -1)
1776 {
1777 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1778 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1779 break;
1780 }
1781 if (ancestor->IsTopLevel())
1782 break;
1783 ancestor = ancestor->GetParent();
1784 }
1785 }
1786#endif // wxUSE_ACCEL
1787 }
1788 if (!handled)
1789 {
1790 event.Skip( FALSE ) ;
1791 event.SetEventType( wxEVT_CHAR ) ;
1792 // raw value again
1793 event.m_keyCode = realkeyval ;
1794
1795 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1796 if ( handled && event.GetSkipped() )
1797 handled = false ;
1798 }
1799 if ( !handled &&
1800 (keyval == WXK_TAB) &&
1801// CS: copied the change below from wxGTK
1802// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1803// have this style, yet choose not to process this particular TAB in which
1804// case TAB must still work as a navigational character
1805#if 0
1806 (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1807#endif
1808 (focus->GetParent()) &&
1809 (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1810 {
1811 wxNavigationKeyEvent new_event;
1812 new_event.SetEventObject( focus );
1813 new_event.SetDirection( !event.ShiftDown() );
1814 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1815 new_event.SetWindowChange( event.ControlDown() );
1816 new_event.SetCurrentFocus( focus );
1817 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1818 if ( handled && new_event.GetSkipped() )
1819 handled = false ;
1820 }
1821 // backdoor handler for default return and command escape
1822 if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
1823 {
1824 // if window is not having a focus still testing for default enter or cancel
1825 // TODO add the UMA version for ActiveNonFloatingWindow
1826 wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
1827 if ( focus )
1828 {
1829 if ( keyval == WXK_RETURN )
1830 {
1831 wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
1832 wxButton);
1833 if ( def && def->IsEnabled() )
1834 {
1835 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1836 event.SetEventObject(def);
1837 def->Command(event);
1838 return true ;
1839 }
1840 }
1841 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1842 else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
1843 {
1844 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1845 new_event.SetEventObject( focus );
1846 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1847 }
1848 }
1849 }
1850 return handled ;
1851}
1852
1853bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
1854{
1855 if ( !focus )
1856 return false ;
1857
1858 short keycode ;
1859 short keychar ;
1860 keychar = short(keymessage & charCodeMask);
1861 keycode = short(keymessage & keyCodeMask) >> 8 ;
1862 if ( modifiers & ( controlKey|shiftKey|optionKey ) )
1863 {
1864 // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
1865 // and look at the character after
1866 UInt32 state = 0;
1867 UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
1868 keychar = short(keyInfo & charCodeMask);
1869 keycode = short(keyInfo & keyCodeMask) >> 8 ;
1870 }
1871 long keyval = wxMacTranslateKey(keychar, keycode) ;
1872
1873 if ( keyval == keychar )
1874 {
1875 keyval = wxToupper( keyval ) ;
1876 }
1877 bool handled = false ;
1878
1879 wxKeyEvent event(wxEVT_KEY_UP);
1880 event.m_shiftDown = modifiers & shiftKey;
1881 event.m_controlDown = modifiers & controlKey;
1882 event.m_altDown = modifiers & optionKey;
1883 event.m_metaDown = modifiers & cmdKey;
1884 event.m_keyCode = keyval ;
1885
1886 event.m_x = wherex;
1887 event.m_y = wherey;
1888 event.m_timeStamp = when;
1889 event.SetEventObject(focus);
1890 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1891
1892 return handled ;
1893}
1894
1895#if !TARGET_CARBON
1896void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
1897{
1898 EventRecord* ev = (EventRecord*) evr ;
1899 WindowRef window = (WindowRef) ev->message ;
1900 if ( window )
1901 {
1902 bool activate = (ev->modifiers & activeFlag ) ;
1903 WindowClass wclass ;
1904 ::GetWindowClass ( window , &wclass ) ;
1905 if ( wclass == kFloatingWindowClass )
1906 {
1907 // if it is a floater we activate/deactivate the front non-floating window instead
1908 window = ::FrontNonFloatingWindow() ;
1909 }
1910 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
1911 if ( win )
1912 win->MacActivate( ev->when , activate ) ;
1913 }
1914}
1915
1916void wxApp::MacHandleUpdateEvent( WXEVENTREF evr )
1917{
1918 EventRecord* ev = (EventRecord*) evr ;
1919 WindowRef window = (WindowRef) ev->message ;
1920 wxTopLevelWindowMac * win = wxFindWinFromMacWindow( window ) ;
1921 if ( win )
1922 {
1923 if ( !wxPendingDelete.Member(win) )
1924 win->MacUpdate( ev->when ) ;
1925 }
1926 else
1927 {
1928 // since there is no way of telling this foreign window to update itself
1929 // we have to invalidate the update region otherwise we keep getting the same
1930 // event over and over again
1931 BeginUpdate( window ) ;
1932 EndUpdate( window ) ;
1933 }
1934}
1935
1936void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
1937{
1938 EventRecord* ev = (EventRecord*) evr ;
1939 if ( HiWord( ev->message ) != noErr )
1940 {
1941 OSErr err ;
1942 Point point ;
1943 SetPt( &point , 100 , 100 ) ;
1944
1945 err = DIBadMount( point , ev->message ) ;
1946 wxASSERT( err == noErr ) ;
1947 }
1948}
1949
1950void wxApp::MacHandleOSEvent( WXEVENTREF evr )
1951{
1952 EventRecord* ev = (EventRecord*) evr ;
1953 switch( ( ev->message & osEvtMessageMask ) >> 24 )
1954 {
1955 case suspendResumeMessage :
1956 {
1957 bool isResuming = ev->message & resumeFlag ;
1958 bool convertClipboard = ev->message & convertClipboardFlag ;
1959
1960 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
1961 if ( isResuming )
1962 {
1963 WindowRef oldFrontWindow = NULL ;
1964 WindowRef newFrontWindow = NULL ;
1965
1966 // in case we don't take care of activating ourselves, we have to synchronize
1967 // our idea of the active window with the process manager's - which it already activated
1968
1969 if ( !doesActivate )
1970 oldFrontWindow = ::FrontNonFloatingWindow() ;
1971
1972 MacResume( convertClipboard ) ;
1973
1974 newFrontWindow = ::FrontNonFloatingWindow() ;
1975
1976 if ( oldFrontWindow )
1977 {
1978 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
1979 if ( win )
1980 win->MacActivate( ev->when , false ) ;
1981 }
1982 if ( newFrontWindow )
1983 {
1984 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
1985 if ( win )
1986 win->MacActivate( ev->when , true ) ;
1987 }
1988 }
1989 else
1990 {
1991 MacSuspend( convertClipboard ) ;
1992 }
1993 }
1994 break ;
1995 case mouseMovedMessage :
1996 {
1997 WindowRef window;
1998
1999 wxWindow* currentMouseWindow = NULL ;
2000
2001 if (s_captureWindow )
2002 {
2003 currentMouseWindow = s_captureWindow ;
2004 }
2005 else
2006 {
2007 wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
2008 &currentMouseWindow ) ;
2009 }
2010
2011 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
2012 {
2013 wxMouseEvent event ;
2014
2015 bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
2016 bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
2017
2018 event.m_leftDown = isDown && !controlDown;
2019 event.m_middleDown = FALSE;
2020 event.m_rightDown = isDown && controlDown;
2021 event.m_shiftDown = ev->modifiers & shiftKey;
2022 event.m_controlDown = ev->modifiers & controlKey;
2023 event.m_altDown = ev->modifiers & optionKey;
2024 event.m_metaDown = ev->modifiers & cmdKey;
2025 event.m_x = ev->where.h;
2026 event.m_y = ev->where.v;
2027 event.m_timeStamp = ev->when;
2028 event.SetEventObject(this);
2029
2030 if ( wxWindow::s_lastMouseWindow )
2031 {
2032 wxMouseEvent eventleave(event);
2033 eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
2034 wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
2035 eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
2036
2037 wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
2038 }
2039 if ( currentMouseWindow )
2040 {
2041 wxMouseEvent evententer(event);
2042 evententer.SetEventType( wxEVT_ENTER_WINDOW );
2043 currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
2044 evententer.SetEventObject( currentMouseWindow ) ;
2045 currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
2046 }
2047 wxWindow::s_lastMouseWindow = currentMouseWindow ;
2048 }
2049
2050 short windowPart = inNoWindow ;
2051
2052 if ( s_captureWindow )
2053 {
2054 window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
2055 windowPart = inContent ;
2056 }
2057 else
2058 {
2059 windowPart = ::FindWindow(ev->where, &window);
2060 }
2061
2062 switch (windowPart)
2063 {
2064 case inContent :
2065 {
2066 wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
2067 if ( win )
2068 win->MacMouseMoved( ev , windowPart ) ;
2069 else
2070 {
2071 if ( wxIsBusy() )
2072 {
2073 }
2074 else
2075 UMAShowArrowCursor();
2076 }
2077 }
2078 break;
2079 default :
2080 {
2081 if ( wxIsBusy() )
2082 {
2083 }
2084 else
2085 UMAShowArrowCursor();
2086 }
2087 break ;
2088 }
2089 }
2090 break ;
2091
2092 }
2093}
2094#endif
2095
2096void wxApp::MacHandleMenuCommand( wxUint32 id )
2097{
2098 wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
2099 wxFrame* frame = mbar->GetFrame();
2100 wxCHECK_RET( mbar != NULL && frame != NULL, wxT("error in menu item callback") );
2101 if ( frame )
2102 {
2103 frame->ProcessCommand(id);
2104 }
2105}
2106
2107#if !TARGET_CARBON
2108void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
2109{
2110 if (macMenuId == 0)
2111 return; // no menu item selected
2112
2113 if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
2114 {
2115 #if ! TARGET_CARBON
2116 Str255 deskAccessoryName ;
2117 GrafPtr savedPort ;
2118
2119 GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
2120 GetPort(&savedPort);
2121 OpenDeskAcc(deskAccessoryName);
2122 SetPort(savedPort);
2123 #endif
2124 }
2125 else
2126 {
2127 MenuCommand id ;
2128 GetMenuItemCommandID( GetMenuHandle(macMenuId) , macMenuItemNum , &id ) ;
2129 MacHandleMenuCommand( id ) ;
2130 }
2131 HiliteMenu(0);
2132}
2133#endif
wxWidgets (Impactor)