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