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