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