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