]> git.saurik.com Git - wxWidgets.git/blob - src/mac/app.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
??
[wxWidgets.git] / src / mac / app.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: app.cpp
3 // Purpose: wxApp
4 // Author: AUTHOR
5 // Modified by:
6 // Created: ??/??/98
7 // RCS-ID: $Id$
8 // Copyright: (c) AUTHOR
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "app.h"
14 #endif
15
16 #include "wx/frame.h"
17 #include "wx/app.h"
18 #include "wx/utils.h"
19 #include "wx/gdicmn.h"
20 #include "wx/pen.h"
21 #include "wx/brush.h"
22 #include "wx/cursor.h"
23 #include "wx/icon.h"
24 #include "wx/palette.h"
25 #include "wx/dc.h"
26 #include "wx/dialog.h"
27 #include "wx/msgdlg.h"
28 #include "wx/log.h"
29 #include "wx/module.h"
30 #include "wx/memory.h"
31
32 #if wxUSE_WX_RESOURCES
33 #include "wx/resource.h"
34 #endif
35
36 #include <string.h>
37
38 // mac
39
40 #if __option(profile)
41 #include <profiler.h>
42 #endif
43
44 #include "apprsrc.h"
45
46 #include <wx/mac/uma.h>
47
48 extern char *wxBuffer;
49 extern wxList wxPendingDelete;
50 extern wxList *wxWinMacWindowList;
51 extern wxList *wxWinMacControlList;
52
53 wxApp *wxTheApp = NULL;
54
55 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
56 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
57 EVT_IDLE(wxApp::OnIdle)
58 END_EVENT_TABLE()
59
60
61 const short kMacMinHeap = (29 * 1024) ;
62 // platform specific static variables
63
64 const short kwxMacMenuBarResource = 1 ;
65 const short kwxMacAppleMenuId = 1 ;
66
67 RgnHandle wxApp::s_macCursorRgn = NULL;
68 wxWindow* wxApp::s_captureWindow = NULL ;
69 int wxApp::s_lastMouseDown = 0 ;
70 long wxApp::sm_lastMessageTime = 0;
71
72 #ifdef __WXMAC__
73
74 bool wxApp::s_macDefaultEncodingIsPC = true ;
75 bool wxApp::s_macSupportPCMenuShortcuts = true ;
76 long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
77 wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
78
79 OSErr AEHandleODoc( AppleEvent *event , AppleEvent *reply , long refcon )
80 {
81 wxApp* app = (wxApp*) refcon ;
82 return wxTheApp->MacHandleAEODoc( event , reply) ;
83 }
84
85 OSErr AEHandleOApp( AppleEvent *event , AppleEvent *reply , long refcon )
86 {
87 wxApp* app = (wxApp*) refcon ;
88 return wxTheApp->MacHandleAEOApp( event , reply ) ;
89 }
90
91 OSErr AEHandlePDoc( AppleEvent *event , AppleEvent *reply , long refcon )
92 {
93 wxApp* app = (wxApp*) refcon ;
94 return wxTheApp->MacHandleAEPDoc( event , reply ) ;
95 }
96
97 OSErr AEHandleQuit( AppleEvent *event , AppleEvent *reply , long refcon )
98 {
99 wxApp* app = (wxApp*) refcon ;
100 return wxTheApp->MacHandleAEQuit( event , reply) ;
101 }
102
103 OSErr wxApp::MacHandleAEODoc(AppleEvent *event , AppleEvent *reply)
104 {
105 ProcessSerialNumber PSN ;
106 PSN.highLongOfPSN = 0 ;
107 PSN.lowLongOfPSN = kCurrentProcess ;
108 SetFrontProcess( &PSN ) ;
109 return noErr ;
110 }
111
112 OSErr wxApp::MacHandleAEPDoc(AppleEvent *event , AppleEvent *reply)
113 {
114 return noErr ;
115 }
116
117 OSErr wxApp::MacHandleAEOApp(AppleEvent *event , AppleEvent *reply)
118 {
119 return noErr ;
120 }
121
122 OSErr wxApp::MacHandleAEQuit(AppleEvent *event , AppleEvent *reply)
123 {
124 wxWindow* win = GetTopWindow() ;
125 if ( win )
126 {
127 win->Close(TRUE ) ;
128 }
129 else
130 {
131 ExitMainLoop() ;
132 }
133 return noErr ;
134 }
135
136 char StringMac[] = "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
137 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
138 "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
139 "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
140 "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
141 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
142
143 char StringANSI[] = "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
144 "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
145 "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
146 "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
147 "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
148 "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
149
150 void wxMacConvertFromPC( const char *from , char *to , int len )
151 {
152 char *c ;
153 if ( from == to )
154 {
155 for( int i = 0 ; i < len ; ++ i )
156 {
157 c = strchr( StringANSI , *from ) ;
158 if ( c != NULL )
159 {
160 *to = StringMac[ c - StringANSI] ;
161 }
162 ++to ;
163 ++from ;
164 }
165 }
166 else
167 {
168 for( int i = 0 ; i < len ; ++ i )
169 {
170 c = strchr( StringANSI , *from ) ;
171 if ( c != NULL )
172 {
173 *to = StringMac[ c - StringANSI] ;
174 }
175 else
176 {
177 *to = *from ;
178 }
179 ++to ;
180 ++from ;
181 }
182 }
183 }
184
185 void wxMacConvertToPC( const char *from , char *to , int len )
186 {
187 char *c ;
188 if ( from == to )
189 {
190 for( int i = 0 ; i < len ; ++ i )
191 {
192 c = strchr( StringMac , *from ) ;
193 if ( c != NULL )
194 {
195 *to = StringANSI[ c - StringMac] ;
196 }
197 ++to ;
198 ++from ;
199 }
200 }
201 else
202 {
203 for( int i = 0 ; i < len ; ++ i )
204 {
205 c = strchr( StringMac , *from ) ;
206 if ( c != NULL )
207 {
208 *to = StringANSI[ c - StringMac] ;
209 }
210 else
211 {
212 *to = *from ;
213 }
214 ++to ;
215 ++from ;
216 }
217 }
218 }
219
220 void wxMacConvertFromPC( char * p )
221 {
222 char *ptr = p ;
223 int len = strlen ( p ) ;
224
225 wxMacConvertFromPC( ptr , ptr , len ) ;
226 }
227
228 void wxMacConvertFromPCForControls( char * p )
229 {
230 char *ptr = p ;
231 int len = strlen ( p ) ;
232
233 wxMacConvertFromPC( ptr , ptr , len ) ;
234 for ( int i = 0 ; i < strlen ( ptr ) ; i++ )
235 {
236 if ( ptr[i] == '&' && ptr[i]+1 != ' ' )
237 {
238 memmove( &ptr[i] , &ptr[i+1] , strlen( &ptr[i+1] ) + 1) ;
239 }
240 }
241 }
242
243 void wxMacConvertFromPC( unsigned char *p )
244 {
245 char *ptr = (char*) p + 1 ;
246 int len = p[0] ;
247
248 wxMacConvertFromPC( ptr , ptr , len ) ;
249 }
250
251 extern char *wxBuffer ;
252
253 wxString wxMacMakeMacStringFromPC( const char * p )
254 {
255 const char *ptr = p ;
256 int len = strlen ( p ) ;
257 char *buf = wxBuffer ;
258
259 if ( len >= BUFSIZ + 512 )
260 {
261 buf = new char [len+1] ;
262 }
263
264 wxMacConvertFromPC( ptr , buf , len ) ;
265 buf[len] = 0 ;
266 wxString result( buf ) ;
267 if ( buf != wxBuffer )
268 delete buf ;
269 return result ;
270 }
271
272
273 void wxMacConvertToPC( char * p )
274 {
275 char *ptr = p ;
276 int len = strlen ( p ) ;
277
278 wxMacConvertToPC( ptr , ptr , len ) ;
279 }
280
281 void wxMacConvertToPC( unsigned char *p )
282 {
283 char *ptr = (char*) p + 1 ;
284 int len = p[0] ;
285
286 wxMacConvertToPC( ptr , ptr , len ) ;
287 }
288
289 wxString wxMacMakePCStringFromMac( const char * p )
290 {
291 const char *ptr = p ;
292 int len = strlen ( p ) ;
293 char *buf = wxBuffer ;
294
295 if ( len >= BUFSIZ + 512 )
296 {
297 buf = new char [len+1] ;
298 }
299
300 wxMacConvertToPC( ptr , buf , len ) ;
301 buf[len] = 0 ;
302
303 wxString result( buf ) ;
304 if ( buf != wxBuffer )
305 delete buf ;
306 return result ;
307 }
308
309 #endif
310
311 bool wxApp::Initialize()
312 {
313 int error = 0 ;
314
315 // Mac-specific
316
317 UMAInitToolbox( 4 ) ;
318 UMAShowWatchCursor() ;
319
320 AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , NewAEEventHandlerProc(AEHandleODoc) , (long) wxTheApp , FALSE ) ;
321 AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , NewAEEventHandlerProc(AEHandleOApp) , (long) wxTheApp , FALSE ) ;
322 AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , NewAEEventHandlerProc(AEHandlePDoc) , (long) wxTheApp , FALSE ) ;
323 AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , NewAEEventHandlerProc(AEHandleQuit) , (long) wxTheApp , FALSE ) ;
324 #if 0
325 GUSISetup(GUSIwithInternetSockets);
326 #endif
327
328
329 // test the minimal configuration necessary
330
331 long theSystem ;
332 long theMachine;
333
334 if (Gestalt(gestaltMachineType, &theMachine) != noErr)
335 {
336 error = kMacSTRWrongMachine;
337 }
338 else if (theMachine < gestaltMacPlus)
339 {
340 error = kMacSTRWrongMachine;
341 }
342 else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
343 {
344 error = kMacSTROldSystem ;
345 }
346 else if ( theSystem < 0x0750 )
347 {
348 error = kMacSTROldSystem ;
349 }
350 #if !TARGET_CARBON
351 else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
352 {
353 error = kMacSTRSmallSize;
354 }
355 #endif
356 /*
357 else
358 {
359 if ( !UMAHasAppearance() )
360 {
361 error = kMacSTRNoPre8Yet ;
362 }
363 }
364 */
365
366 // if we encountered any problems so far, give the error code and exit immediately
367
368 if ( error )
369 {
370 short itemHit;
371 Str255 message;
372
373 GetIndString(message, 128, error);
374 UMAShowArrowCursor() ;
375 ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
376 itemHit = Alert(128, nil);
377 return FALSE ;
378 }
379
380 #if __option(profile)
381 ProfilerInit( collectDetailed, bestTimeBase , 20000 , 30 ) ;
382 #endif
383
384 // now avoid exceptions thrown for new (bad_alloc)
385
386 std::__throws_bad_alloc = FALSE ;
387
388 s_macCursorRgn = ::NewRgn() ;
389
390 #ifdef __WXMSW__
391 wxBuffer = new char[1500];
392 #else
393 wxBuffer = new char[BUFSIZ + 512];
394 #endif
395
396 /* No longer used
397 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
398
399 streambuf* sBuf = new wxDebugStreamBuf;
400 ostream* oStr = new ostream(sBuf) ;
401 wxDebugContext::SetStream(oStr, sBuf);
402 #endif
403 */
404
405 wxClassInfo::InitializeClasses();
406
407 wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
408 wxTheColourDatabase->Initialize();
409
410 wxInitializeStockLists();
411 wxInitializeStockObjects();
412
413 #if wxUSE_WX_RESOURCES
414 wxInitializeResourceSystem();
415 #endif
416
417 wxBitmap::InitStandardHandlers();
418
419 wxModule::RegisterModules();
420 if (!wxModule::InitializeModules())
421 return FALSE;
422
423 wxWinMacWindowList = new wxList(wxKEY_INTEGER);
424 wxWinMacControlList = new wxList(wxKEY_INTEGER);
425
426 UMAShowArrowCursor() ;
427
428 return TRUE;
429 }
430
431 void wxApp::CleanUp()
432 {
433 wxModule::CleanUpModules();
434
435 #if wxUSE_WX_RESOURCES
436 wxCleanUpResourceSystem();
437 #endif
438
439 wxDeleteStockObjects() ;
440
441 // Destroy all GDI lists, etc.
442
443 delete wxTheBrushList;
444 wxTheBrushList = NULL;
445
446 delete wxThePenList;
447 wxThePenList = NULL;
448
449 delete wxTheFontList;
450 wxTheFontList = NULL;
451
452 delete wxTheBitmapList;
453 wxTheBitmapList = NULL;
454
455 delete wxTheColourDatabase;
456 wxTheColourDatabase = NULL;
457
458 wxBitmap::CleanUpHandlers();
459
460 delete[] wxBuffer;
461 wxBuffer = NULL;
462
463 if (wxWinMacWindowList)
464 delete wxWinMacWindowList ;
465
466 wxClassInfo::CleanUpClasses();
467
468 #if __option(profile)
469 ProfilerDump( "\papp.prof" ) ;
470 ProfilerTerm() ;
471 #endif
472
473 delete wxTheApp;
474 wxTheApp = NULL;
475
476 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
477 // At this point we want to check if there are any memory
478 // blocks that aren't part of the wxDebugContext itself,
479 // as a special case. Then when dumping we need to ignore
480 // wxDebugContext, too.
481 if (wxDebugContext::CountObjectsLeft() > 0)
482 {
483 wxTrace("There were memory leaks.\n");
484 wxDebugContext::Dump();
485 wxDebugContext::PrintStatistics();
486 }
487 // wxDebugContext::SetStream(NULL, NULL);
488 #endif
489
490 // do it as the very last thing because everything else can log messages
491 wxLog::DontCreateOnDemand();
492 // do it as the very last thing because everything else can log messages
493 delete wxLog::SetActiveTarget(NULL);
494
495 ::PrClose() ;
496 if (s_macCursorRgn)
497 ::DisposeRgn(s_macCursorRgn);
498 #if 0
499 TerminateAE() ;
500 #endif
501 }
502
503 int wxEntry( int argc, char *argv[] )
504 {
505 #ifdef __MWERKS__
506 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
507 // This seems to be necessary since there are 'rogue'
508 // objects present at this point (perhaps global objects?)
509 // Setting a checkpoint will ignore them as far as the
510 // memory checking facility is concerned.
511 // Of course you may argue that memory allocated in globals should be
512 // checked, but this is a reasonable compromise.
513 wxDebugContext::SetCheckpoint();
514 #endif
515 #endif
516 if (!wxApp::Initialize())
517 return FALSE;
518 if (!wxTheApp)
519 {
520 if (!wxApp::GetInitializerFunction())
521 {
522 printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
523 return 0;
524 };
525
526 wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
527 };
528
529 if (!wxTheApp)
530 {
531 printf( "wxWindows error: wxTheApp == NULL\n" );
532 return 0;
533 };
534
535 #ifdef __WXMAC__
536 argc = 1 ; // currently we don't support files as parameters
537 #endif
538
539 wxTheApp->argc = argc;
540 wxTheApp->argv = argv;
541
542 // GUI-specific initialization, such as creating an app context.
543 wxTheApp->OnInitGui();
544
545 // we could try to get the open apple events here to adjust argc and argv better
546
547
548 // Here frames insert themselves automatically
549 // into wxTopLevelWindows by getting created
550 // in OnInit().
551
552 if (!wxTheApp->OnInit()) return 0;
553
554 int retValue = 0;
555
556 if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
557
558 if (wxTheApp->GetTopWindow())
559 {
560 delete wxTheApp->GetTopWindow();
561 wxTheApp->SetTopWindow(NULL);
562 }
563
564 wxTheApp->DeletePendingObjects();
565
566 wxTheApp->OnExit();
567
568 wxApp::CleanUp();
569
570 return retValue;
571 };
572
573 // Static member initialization
574 wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
575
576 wxApp::wxApp()
577 {
578 m_topWindow = NULL;
579 wxTheApp = this;
580 m_className = "";
581 m_wantDebugOutput = TRUE ;
582 m_appName = "";
583 argc = 0;
584 argv = NULL;
585
586 m_printMode = wxPRINT_WINDOWS;
587
588 m_exitOnFrameDelete = TRUE;
589 m_auto3D = TRUE;
590 }
591
592 bool wxApp::Initialized()
593 {
594 if (GetTopWindow())
595 return TRUE;
596 else
597 return FALSE;
598 }
599
600 int wxApp::MainLoop()
601 {
602 m_keepGoing = TRUE;
603
604 while (m_keepGoing)
605 {
606 MacDoOneEvent() ;
607 }
608
609 return 0;
610 }
611
612 // Returns TRUE if more time is needed.
613 bool wxApp::ProcessIdle()
614 {
615 wxIdleEvent event;
616 event.SetEventObject(this);
617 ProcessEvent(event);
618
619 return event.MoreRequested();
620 }
621
622 void wxApp::ExitMainLoop()
623 {
624 m_keepGoing = FALSE;
625 }
626
627 // Is a message/event pending?
628 bool wxApp::Pending()
629 {
630 EventRecord event ;
631
632 return EventAvail( everyEvent , &event ) ;
633 }
634
635 // Dispatch a message.
636 void wxApp::Dispatch()
637 {
638 MacDoOneEvent() ;
639 }
640
641 void wxApp::OnIdle(wxIdleEvent& event)
642 {
643 static bool inOnIdle = FALSE;
644
645 // Avoid recursion (via ProcessEvent default case)
646 if (inOnIdle)
647 return;
648
649 inOnIdle = TRUE;
650
651 // 'Garbage' collection of windows deleted with Close().
652 DeletePendingObjects();
653
654 // flush the logged messages if any
655 wxLog *pLog = wxLog::GetActiveTarget();
656 if ( pLog != NULL && pLog->HasPendingMessages() )
657 pLog->Flush();
658
659 // Send OnIdle events to all windows
660 bool needMore = SendIdleEvents();
661
662 if (needMore)
663 event.RequestMore(TRUE);
664
665 inOnIdle = FALSE;
666 }
667
668 void wxWakeUpIdle()
669 {
670 // **** please implement me! ****
671 // Wake up the idle handler processor, even if it is in another thread...
672 }
673
674 // Send idle event to all top-level windows
675 bool wxApp::SendIdleEvents()
676 {
677 bool needMore = FALSE;
678 wxNode* node = wxTopLevelWindows.First();
679 while (node)
680 {
681 wxWindow* win = (wxWindow*) node->Data();
682 if (SendIdleEvents(win))
683 needMore = TRUE;
684
685 node = node->Next();
686 }
687 return needMore;
688 }
689
690 // Send idle event to window and all subwindows
691 bool wxApp::SendIdleEvents(wxWindow* win)
692 {
693 bool needMore = FALSE;
694
695 wxIdleEvent event;
696 event.SetEventObject(win);
697 win->ProcessEvent(event);
698
699 if (event.MoreRequested())
700 needMore = TRUE;
701
702 wxNode* node = win->GetChildren().First();
703 while (node)
704 {
705 wxWindow* win = (wxWindow*) node->Data();
706 if (SendIdleEvents(win))
707 needMore = TRUE;
708
709 node = node->Next();
710 }
711 return needMore ;
712 }
713
714 void wxApp::DeletePendingObjects()
715 {
716 wxNode *node = wxPendingDelete.First();
717 while (node)
718 {
719 wxObject *obj = (wxObject *)node->Data();
720
721 delete obj;
722
723 if (wxPendingDelete.Member(obj))
724 delete node;
725
726 // Deleting one object may have deleted other pending
727 // objects, so start from beginning of list again.
728 node = wxPendingDelete.First();
729 }
730 }
731
732 wxLog* wxApp::CreateLogTarget()
733 {
734 return new wxLogGui;
735 }
736
737 wxWindow* wxApp::GetTopWindow() const
738 {
739 if (m_topWindow)
740 return m_topWindow;
741 else if (wxTopLevelWindows.Number() > 0)
742 return (wxWindow*) wxTopLevelWindows.First()->Data();
743 else
744 return NULL;
745 }
746
747 void wxExit()
748 {
749 wxApp::CleanUp();
750 ::ExitToShell() ;
751 }
752
753 // Yield to other processes
754 bool wxYield()
755 {
756 // YieldToAnyThread() ;
757 SystemTask() ;
758 return TRUE;
759 }
760
761 // platform specifics
762
763 void wxApp::MacSuspend( bool convertClipboard )
764 {
765 s_lastMouseDown = 0 ;
766 if( convertClipboard )
767 {
768 MacConvertPrivateToPublicScrap() ;
769 }
770
771 UMAHideFloatingWindows() ;
772 }
773
774 void wxApp::MacResume( bool convertClipboard )
775 {
776 s_lastMouseDown = 0 ;
777 if( convertClipboard )
778 {
779 MacConvertPublicToPrivateScrap() ;
780 }
781
782 UMAShowFloatingWindows() ;
783 }
784
785 void wxApp::MacConvertPrivateToPublicScrap()
786 {
787 ::ZeroScrap();
788 ::TEToScrap();
789 }
790
791 void wxApp::MacConvertPublicToPrivateScrap()
792 {
793 ::TEFromScrap() ;
794 }
795
796 void wxApp::MacDoOneEvent()
797 {
798 EventRecord event ;
799
800 long sleepTime = ::GetCaretTime();
801
802 if (WaitNextEvent(everyEvent, &event,sleepTime, s_macCursorRgn))
803 {
804 MacHandleOneEvent( &event );
805 }
806 else
807 {
808 // idlers
809 WindowPtr window = UMAFrontWindow() ;
810 if ( window )
811 UMAIdleControls( window ) ;
812
813 wxTheApp->ProcessIdle() ;
814 }
815 if ( event.what != kHighLevelEvent )
816 SetRectRgn( s_macCursorRgn , event.where.h - 1 , event.where.v - 1, event.where.h + 1 , event.where.v + 1 ) ;
817
818 // repeaters
819
820 #if 0
821 wxMacProcessSocketEvents() ;
822 #endif
823 }
824
825 void wxApp::MacHandleOneEvent( EventRecord *ev )
826 {
827 m_macCurrentEvent = ev ;
828
829 wxApp::sm_lastMessageTime = ev->when ;
830
831 switch (ev->what)
832 {
833 case mouseDown:
834 MacHandleMouseDownEvent( ev ) ;
835 if ( ev->modifiers & controlKey )
836 s_lastMouseDown = 2;
837 else
838 s_lastMouseDown = 1;
839 break;
840 case mouseUp:
841 if ( s_lastMouseDown == 2 )
842 {
843 ev->modifiers |= controlKey ;
844 }
845 else
846 {
847 ev->modifiers &= ~controlKey ;
848 }
849 MacHandleMouseUpEvent( ev ) ;
850 s_lastMouseDown = 0;
851 break;
852 case activateEvt:
853 MacHandleActivateEvent( ev ) ;
854 break;
855 case updateEvt:
856 MacHandleUpdateEvent( ev ) ;
857 break;
858 case keyDown:
859 case autoKey:
860 MacHandleKeyDownEvent( ev ) ;
861 break;
862 case keyUp:
863 MacHandleKeyUpEvent( ev ) ;
864 break;
865 case diskEvt:
866 MacHandleDiskEvent( ev ) ;
867 break;
868 case osEvt:
869 MacHandleOSEvent( ev ) ;
870 break;
871 case kHighLevelEvent:
872 MacHandleHighLevelEvent( ev ) ;
873 break;
874 default:
875 break;
876 }
877 }
878
879 void wxApp::MacHandleHighLevelEvent( EventRecord *ev )
880 {
881 ::AEProcessAppleEvent( ev ) ;
882 }
883
884 bool s_macIsInModalLoop = false ;
885
886 void wxApp::MacHandleMouseDownEvent( EventRecord *ev )
887 {
888 WindowRef window;
889 WindowRef frontWindow = UMAFrontNonFloatingWindow() ;
890 WindowAttributes frontWindowAttributes = NULL ;
891 if ( frontWindow )
892 UMAGetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
893
894 short windowPart = ::FindWindow(ev->where, &window);
895 wxWindow* win = wxFindWinFromMacWindow( window ) ;
896
897 switch (windowPart)
898 {
899 case inMenuBar :
900 if ( s_macIsInModalLoop )
901 {
902 SysBeep ( 30 ) ;
903 }
904 else
905 {
906 UInt32 menuresult = MenuSelect(ev->where) ;
907 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
908 s_lastMouseDown = 0;
909 }
910 break ;
911 case inSysWindow :
912 SystemClick( ev , window ) ;
913 s_lastMouseDown = 0;
914 break ;
915 case inDrag :
916 if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
917 {
918 SysBeep ( 30 ) ;
919 }
920 else
921 {
922 DragWindow(window, ev->where, &qd.screenBits.bounds);
923 if (win)
924 {
925 GrafPtr port ;
926 GetPort( &port ) ;
927 Point pt = { 0, 0 } ;
928 SetPort( window ) ;
929 SetOrigin( 0 , 0 ) ;
930 LocalToGlobal( &pt ) ;
931 SetPort( port ) ;
932 win->SetSize( pt.h , pt.v , -1 ,
933 -1 , wxSIZE_USE_EXISTING);
934 }
935 s_lastMouseDown = 0;
936 }
937 break ;
938 case inGoAway:
939 if (TrackGoAway(window, ev->where))
940 {
941 if ( win )
942 win->Close() ;
943 }
944 s_lastMouseDown = 0;
945 break;
946 case inGrow:
947 int growResult = GrowWindow(window , ev->where, &qd.screenBits.bounds);
948 if (growResult != 0)
949 {
950 int newWidth = LoWord(growResult);
951 int newHeight = HiWord(growResult);
952 int oldWidth, oldHeight;
953
954 win->GetSize(&oldWidth, &oldHeight);
955 if (newWidth == 0)
956 newWidth = oldWidth;
957 if (newHeight == 0)
958 newHeight = oldHeight;
959
960 if (win)
961 win->SetSize( -1, -1, newWidth, newHeight, wxSIZE_USE_EXISTING);
962 }
963 s_lastMouseDown = 0;
964 break;
965 case inZoomIn:
966 case inZoomOut:
967 if (TrackBox(window, ev->where, windowPart))
968 {
969 // TODO setup size event
970 ZoomWindow( window , windowPart , false ) ;
971 if (win)
972 win->SetSize( -1, -1, window->portRect.right-window->portRect.left ,
973 window->portRect.bottom-window->portRect.top, wxSIZE_USE_EXISTING);
974 }
975 s_lastMouseDown = 0;
976 break;
977 case inCollapseBox :
978 // TODO setup size event
979 s_lastMouseDown = 0;
980 break ;
981
982 case inContent :
983 if ( window != frontWindow )
984 {
985 if ( s_macIsInModalLoop )
986 {
987 SysBeep ( 30 ) ;
988 }
989 else if ( UMAIsWindowFloating( window ) )
990 {
991 if ( win )
992 win->MacMouseDown( ev , windowPart ) ;
993 }
994 else
995 {
996 UMASelectWindow( window ) ;
997 }
998 }
999 else
1000 {
1001 if ( win )
1002 win->MacMouseDown( ev , windowPart ) ;
1003 }
1004 break ;
1005
1006 default:
1007 break;
1008 }
1009 }
1010
1011 void wxApp::MacHandleMouseUpEvent( EventRecord *ev )
1012 {
1013 WindowRef window;
1014
1015 short windowPart = ::FindWindow(ev->where, &window);
1016
1017 switch (windowPart)
1018 {
1019 case inMenuBar :
1020 break ;
1021 case inSysWindow :
1022 break ;
1023 default:
1024 {
1025 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1026 if ( win )
1027 win->MacMouseUp( ev , windowPart ) ;
1028 }
1029 break;
1030 }
1031 }
1032
1033 long wxMacTranslateKey(unsigned char key, unsigned char code)
1034 {
1035 long retval = key ;
1036 switch (key)
1037 {
1038 case 0x01 :
1039 retval = WXK_HOME;
1040 break;
1041 case 0x03 :
1042 retval = WXK_RETURN;
1043 break;
1044 case 0x04 :
1045 retval = WXK_END;
1046 break;
1047 case 0x05 :
1048 retval = WXK_HELP;
1049 break;
1050 case 0x08 :
1051 retval = WXK_BACK;
1052 break;
1053 case 0x09 :
1054 retval = WXK_TAB;
1055 break;
1056 case 0x0b :
1057 retval = WXK_PAGEUP;
1058 break;
1059 case 0x0c :
1060 retval = WXK_PAGEDOWN;
1061 break;
1062 case 0x0d :
1063 retval = WXK_RETURN;
1064 break;
1065 case 0x10 :
1066 {
1067 switch( code )
1068 {
1069 case 0x7a :
1070 retval = WXK_F1 ;
1071 break;
1072 case 0x78 :
1073 retval = WXK_F2 ;
1074 break;
1075 case 0x63 :
1076 retval = WXK_F3 ;
1077 break;
1078 case 0x76 :
1079 retval = WXK_F4 ;
1080 break;
1081 case 0x60 :
1082 retval = WXK_F5 ;
1083 break;
1084 case 0x61 :
1085 retval = WXK_F6 ;
1086 break;
1087 case 0x62:
1088 retval = WXK_F7 ;
1089 break;
1090 case 0x64 :
1091 retval = WXK_F8 ;
1092 break;
1093 case 0x65 :
1094 retval = WXK_F9 ;
1095 break;
1096 case 0x6D :
1097 retval = WXK_F10 ;
1098 break;
1099 case 0x67 :
1100 retval = WXK_F11 ;
1101 break;
1102 case 0x6F :
1103 retval = WXK_F12 ;
1104 break;
1105 case 0x69 :
1106 retval = WXK_F13 ;
1107 break;
1108 case 0x6B :
1109 retval = WXK_F14 ;
1110 break;
1111 case 0x71 :
1112 retval = WXK_F15 ;
1113 break;
1114 }
1115 }
1116 break ;
1117 case 0x1b :
1118 retval = WXK_ESCAPE ;
1119 break ;
1120 case 0x1c :
1121 retval = WXK_LEFT ;
1122 break ;
1123 case 0x1d :
1124 retval = WXK_RIGHT ;
1125 break ;
1126 case 0x1e :
1127 retval = WXK_UP ;
1128 break ;
1129 case 0x1f :
1130 retval = WXK_DOWN ;
1131 break ;
1132 case 0x7F :
1133 retval = WXK_DELETE ;
1134 default:
1135 break ;
1136 } // end switch
1137
1138 return retval;
1139 }
1140
1141 void wxApp::MacHandleKeyDownEvent( EventRecord *ev )
1142 {
1143 UInt32 menuresult = UMAMenuEvent(ev) ;
1144 if ( HiWord( menuresult ) )
1145 MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
1146 else
1147 {
1148 short keycode ;
1149 short keychar ;
1150 keychar = short(ev->message & charCodeMask);
1151 keycode = short(ev->message & keyCodeMask) >> 8 ;
1152
1153 wxWindow* focus = wxWindow::FindFocus() ;
1154 if ( focus )
1155 {
1156 long keyval = wxMacTranslateKey(keychar, keycode) ;
1157
1158 wxKeyEvent event(wxEVT_KEY_DOWN);
1159 event.m_shiftDown = ev->modifiers & shiftKey;
1160 event.m_controlDown = ev->modifiers & controlKey;
1161 event.m_altDown = ev->modifiers & optionKey;
1162 event.m_metaDown = ev->modifiers & cmdKey;
1163 event.m_keyCode = keyval;
1164 event.m_x = ev->where.h;
1165 event.m_y = ev->where.v;
1166 event.m_timeStamp = ev->when;
1167 event.SetEventObject(focus);
1168 bool handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1169 if ( !handled )
1170 {
1171 #if wxUSE_ACCEL
1172 if (!handled)
1173 {
1174 wxWindow *ancestor = focus;
1175 /*
1176 while (ancestor)
1177 {
1178 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1179 if (command != -1)
1180 {
1181 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1182 handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
1183 break;
1184 }
1185 if (ancestor->m_isFrame)
1186 break;
1187 ancestor = ancestor->GetParent();
1188 }
1189 */
1190 }
1191 #endif // wxUSE_ACCEL
1192 }
1193 if (!handled)
1194 {
1195 wxKeyEvent event(wxEVT_CHAR);
1196 event.m_shiftDown = ev->modifiers & shiftKey;
1197 event.m_controlDown = ev->modifiers & controlKey;
1198 event.m_altDown = ev->modifiers & optionKey;
1199 event.m_metaDown = ev->modifiers & cmdKey;
1200 event.m_keyCode = keyval;
1201 event.m_x = ev->where.h;
1202 event.m_y = ev->where.v;
1203 event.m_timeStamp = ev->when;
1204 event.SetEventObject(focus);
1205 handled = focus->GetEventHandler()->ProcessEvent( event ) ;
1206 }
1207 if ( !handled &&
1208 (keyval == WXK_TAB) &&
1209 (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
1210 (focus->GetParent()) &&
1211 (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1212 {
1213 wxNavigationKeyEvent new_event;
1214 new_event.SetEventObject( focus );
1215 new_event.SetDirection( !event.ShiftDown() );
1216 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
1217 new_event.SetWindowChange( event.ControlDown() );
1218 new_event.SetCurrentFocus( focus );
1219 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1220 }
1221 /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
1222 if ( (!handled) &&
1223 (keyval == '.' && event.ControlDown() ) )
1224 {
1225 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1226 new_event.SetEventObject( focus );
1227 handled = focus->GetEventHandler()->ProcessEvent( new_event );
1228 }
1229 }
1230 }
1231 }
1232
1233 void wxApp::MacHandleKeyUpEvent( EventRecord *ev )
1234 {
1235 // nothing to do
1236 }
1237
1238 void wxApp::MacHandleActivateEvent( EventRecord *ev )
1239 {
1240 WindowRef window = (WindowRef) ev->message ;
1241 if ( window )
1242 {
1243 bool activate = (ev->modifiers & activeFlag ) ;
1244 WindowClass wclass ;
1245 UMAGetWindowClass ( window , &wclass ) ;
1246 if ( wclass == kFloatingWindowClass )
1247 {
1248 // if it is a floater we activate/deactivate the front non-floating window instead
1249 window = UMAFrontNonFloatingWindow() ;
1250 }
1251 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1252 if ( win )
1253 win->MacActivate( ev , activate ) ;
1254 }
1255 }
1256
1257 void wxApp::MacHandleUpdateEvent( EventRecord *ev )
1258 {
1259 WindowRef window = (WindowRef) ev->message ;
1260 wxWindow * win = wxFindWinFromMacWindow( window ) ;
1261 if ( win )
1262 {
1263 win->MacUpdate( ev ) ;
1264 }
1265 }
1266
1267 void wxApp::MacHandleDiskEvent( EventRecord *ev )
1268 {
1269 if ( HiWord( ev->message ) != noErr )
1270 {
1271 OSErr err ;
1272 Point point ;
1273 SetPt( &point , 100 , 100 ) ;
1274
1275 err = DIBadMount( point , ev->message ) ;
1276 wxASSERT( err == noErr ) ;
1277 }
1278 }
1279
1280 void wxApp::MacHandleOSEvent( EventRecord *ev )
1281 {
1282 switch( ( ev->message & osEvtMessageMask ) >> 24 )
1283 {
1284 case suspendResumeMessage :
1285 {
1286 bool isResuming = ev->message & resumeFlag ;
1287 bool convertClipboard = ev->message & convertClipboardFlag ;
1288 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
1289 if ( isResuming )
1290 {
1291 WindowRef oldFrontWindow = NULL ;
1292 WindowRef newFrontWindow = NULL ;
1293
1294 // in case we don't take care of activating ourselves, we have to synchronize
1295 // our idea of the active window with the process manager's - which it already activated
1296
1297 if ( !doesActivate )
1298 oldFrontWindow = UMAFrontNonFloatingWindow() ;
1299
1300 MacResume( convertClipboard ) ;
1301
1302 newFrontWindow = UMAFrontNonFloatingWindow() ;
1303
1304 if ( oldFrontWindow )
1305 {
1306 wxWindow* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
1307 if ( win )
1308 win->MacActivate( ev , false ) ;
1309 }
1310 if ( newFrontWindow )
1311 {
1312 wxWindow* win = wxFindWinFromMacWindow( newFrontWindow ) ;
1313 if ( win )
1314 win->MacActivate( ev , true ) ;
1315 }
1316 }
1317 else
1318 {
1319 MacSuspend( convertClipboard ) ;
1320
1321 // in case this suspending did close an active window, another one might
1322 // have surfaced -> lets deactivate that one
1323
1324 WindowRef newActiveWindow = UMAGetActiveNonFloatingWindow() ;
1325 if ( newActiveWindow )
1326 {
1327 wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
1328 if ( win )
1329 win->MacActivate( ev , false ) ;
1330 }
1331 }
1332 }
1333 break ;
1334 case mouseMovedMessage :
1335 {
1336 WindowRef window;
1337
1338 wxWindow* currentMouseWindow = NULL ;
1339
1340 MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) , &currentMouseWindow ) ;
1341
1342 if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
1343 {
1344 wxMouseEvent event ;
1345
1346 bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
1347 bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
1348
1349 event.m_leftDown = isDown && !controlDown;
1350 event.m_middleDown = FALSE;
1351 event.m_rightDown = isDown && controlDown;
1352 event.m_shiftDown = ev->modifiers & shiftKey;
1353 event.m_controlDown = ev->modifiers & controlKey;
1354 event.m_altDown = ev->modifiers & optionKey;
1355 event.m_metaDown = ev->modifiers & cmdKey;
1356 event.m_x = ev->where.h;
1357 event.m_y = ev->where.v;
1358 event.m_timeStamp = ev->when;
1359 event.SetEventObject(this);
1360
1361 if ( wxWindow::s_lastMouseWindow )
1362 {
1363 wxMouseEvent eventleave(event ) ;
1364 eventleave.SetEventType( wxEVT_LEAVE_WINDOW ) ;
1365 wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
1366 }
1367 if ( currentMouseWindow )
1368 {
1369 wxMouseEvent evententer(event ) ;
1370 evententer.SetEventType( wxEVT_ENTER_WINDOW ) ;
1371 currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
1372 }
1373 wxWindow::s_lastMouseWindow = currentMouseWindow ;
1374 }
1375
1376 short windowPart = ::FindWindow(ev->where, &window);
1377
1378 switch (windowPart)
1379 {
1380 case inMenuBar :
1381 break ;
1382 case inSysWindow :
1383 break ;
1384 default:
1385 {
1386 if ( s_lastMouseDown == 0 )
1387 ev->modifiers |= btnState ;
1388
1389 wxWindow* win = wxFindWinFromMacWindow( window ) ;
1390 if ( win )
1391 win->MacMouseMoved( ev , windowPart ) ;
1392 }
1393 break;
1394 }
1395 }
1396 break ;
1397
1398 }
1399 }
1400
1401 void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
1402 {
1403 if (macMenuId == 0)
1404 return; // no menu item selected
1405
1406 if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
1407 {
1408 #if ! TARGET_CARBON
1409 Str255 deskAccessoryName ;
1410 GrafPtr savedPort ;
1411
1412 GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
1413 GetPort(&savedPort);
1414 OpenDeskAcc(deskAccessoryName);
1415 SetPort(savedPort);
1416 #endif
1417 }
1418 else
1419 {
1420 wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() ) ;
1421 if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
1422 wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
1423 }
1424 HiliteMenu(0);
1425 }
1426
1427 /*
1428 long wxApp::MacTranslateKey(char key, int mods)
1429 {
1430 }
1431
1432 void wxApp::MacAdjustCursor()
1433 {
1434 }
1435
1436 */
1437 /*
1438 void
1439 wxApp::macAdjustCursor()
1440 {
1441 if (ev->what != kHighLevelEvent)
1442 {
1443 wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
1444 if (theMacWxFrame)
1445 {
1446 if (!theMacWxFrame->MacAdjustCursor(ev->where))
1447 ::SetCursor(&(qd.arrow));
1448 }
1449 }
1450 }
1451 */
wxWidgets (Impactor)