#pragma implementation "app.h"
#endif
+#include "wx/window.h"
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/utils.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/cursor.h"
+#include "wx/intl.h"
#include "wx/icon.h"
#include "wx/palette.h"
#include "wx/dc.h"
#include "wx/log.h"
#include "wx/module.h"
#include "wx/memory.h"
-
+#include "wx/tooltip.h"
+#include "wx/menu.h"
#if wxUSE_WX_RESOURCES
#include "wx/resource.h"
#endif
#include <string.h>
+// mac
+
+#ifndef __UNIX__
+ #if __option(profile)
+ #include <profiler.h>
+ #endif
+#endif
+
+#include "apprsrc.h"
+
+#include "wx/mac/uma.h"
+#include "wx/mac/macnotfy.h"
+
+#if wxUSE_SOCKETS
+ #ifdef __APPLE__
+ #include <OT/OpenTransport.h>
+ #else
+ #include <OpenTransport.h>
+ #include <OpenTptInternet.h>
+ #endif
+#endif
+
extern char *wxBuffer;
extern wxList wxPendingDelete;
+extern wxList *wxWinMacWindowList;
+extern wxList *wxWinMacControlList;
wxApp *wxTheApp = NULL;
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
+ EVT_END_SESSION(wxApp::OnEndSession)
+ EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
END_EVENT_TABLE()
#endif
-// platform layer
-typedef void * PLEventHandle ;
+const short kMacMinHeap = (29 * 1024) ;
+// platform specific static variables
+
+const short kwxMacMenuBarResource = 1 ;
+const short kwxMacAppleMenuId = 1 ;
+
+RgnHandle wxApp::s_macCursorRgn = NULL;
+wxWindow* wxApp::s_captureWindow = NULL ;
+int wxApp::s_lastMouseDown = 0 ;
+long wxApp::sm_lastMessageTime = 0;
+
+#ifdef __WXMAC__
+
+bool wxApp::s_macDefaultEncodingIsPC = true ;
+bool wxApp::s_macSupportPCMenuShortcuts = true ;
+long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
+wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
+
+pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
+{
+ wxApp* app = (wxApp*) refcon ;
+ return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
+}
+
+pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
+{
+ wxApp* app = (wxApp*) refcon ;
+ return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
+}
+
+pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
+{
+ wxApp* app = (wxApp*) refcon ;
+ return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
+}
+
+pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , unsigned long refcon )
+{
+ wxApp* app = (wxApp*) refcon ;
+ return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
+}
+
+OSErr wxApp::MacHandleAEODoc(const AppleEvent *event , AppleEvent *reply)
+{
+ ProcessSerialNumber PSN ;
+ PSN.highLongOfPSN = 0 ;
+ PSN.lowLongOfPSN = kCurrentProcess ;
+ SetFrontProcess( &PSN ) ;
+ return noErr ;
+}
+
+OSErr wxApp::MacHandleAEPDoc(const AppleEvent *event , AppleEvent *reply)
+{
+ return noErr ;
+}
+
+OSErr wxApp::MacHandleAEOApp(const AppleEvent *event , AppleEvent *reply)
+{
+ return noErr ;
+}
+
+OSErr wxApp::MacHandleAEQuit(const AppleEvent *event , AppleEvent *reply)
+{
+ wxWindow* win = GetTopWindow() ;
+ if ( win )
+ {
+ win->Close(TRUE ) ;
+ }
+ else
+ {
+ ExitMainLoop() ;
+ }
+ return noErr ;
+}
+
+char StringMac[] = "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+ "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+ "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
+ "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
+ "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
+ "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
+
+char StringANSI[] = "\x0a\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
+ "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
+ "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
+ "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
+ "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
+ "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
+
+void wxMacConvertFromPC( const char *from , char *to , int len )
+{
+ char *c ;
+ if ( from == to )
+ {
+ for( int i = 0 ; i < len ; ++ i )
+ {
+ c = strchr( StringANSI , *from ) ;
+ if ( c != NULL )
+ {
+ *to = StringMac[ c - StringANSI] ;
+ }
+ ++to ;
+ ++from ;
+ }
+ }
+ else
+ {
+ for( int i = 0 ; i < len ; ++ i )
+ {
+ c = strchr( StringANSI , *from ) ;
+ if ( c != NULL )
+ {
+ *to = StringMac[ c - StringANSI] ;
+ }
+ else
+ {
+ *to = *from ;
+ }
+ ++to ;
+ ++from ;
+ }
+ }
+}
+
+void wxMacConvertToPC( const char *from , char *to , int len )
+{
+ char *c ;
+ if ( from == to )
+ {
+ for( int i = 0 ; i < len ; ++ i )
+ {
+ c = strchr( StringMac , *from ) ;
+ if ( c != NULL )
+ {
+ *to = StringANSI[ c - StringMac] ;
+ }
+ ++to ;
+ ++from ;
+ }
+ }
+ else
+ {
+ for( int i = 0 ; i < len ; ++ i )
+ {
+ c = strchr( StringMac , *from ) ;
+ if ( c != NULL )
+ {
+ *to = StringANSI[ c - StringMac] ;
+ }
+ else
+ {
+ *to = *from ;
+ }
+ ++to ;
+ ++from ;
+ }
+ }
+}
+
+void wxMacConvertFromPC( char * p )
+{
+ char *ptr = p ;
+ int len = strlen ( p ) ;
+
+ wxMacConvertFromPC( ptr , ptr , len ) ;
+}
+
+void wxMacConvertFromPCForControls( char * p )
+{
+ char *ptr = p ;
+ int len = strlen ( p ) ;
+
+ wxMacConvertFromPC( ptr , ptr , len ) ;
+ for ( int i = 0 ; i < strlen ( ptr ) ; i++ )
+ {
+ if ( ptr[i] == '&' && ptr[i]+1 != ' ' )
+ {
+ memmove( &ptr[i] , &ptr[i+1] , strlen( &ptr[i+1] ) + 1) ;
+ }
+ }
+}
+
+void wxMacConvertFromPC( unsigned char *p )
+{
+ char *ptr = (char*) p + 1 ;
+ int len = p[0] ;
+
+ wxMacConvertFromPC( ptr , ptr , len ) ;
+}
+
+extern char *wxBuffer ;
+
+wxString wxMacMakeMacStringFromPC( const char * p )
+{
+ const char *ptr = p ;
+ int len = strlen ( p ) ;
+ char *buf = wxBuffer ;
+
+ if ( len >= BUFSIZ + 512 )
+ {
+ buf = new char [len+1] ;
+ }
+
+ wxMacConvertFromPC( ptr , buf , len ) ;
+ buf[len] = 0 ;
+ wxString result( buf ) ;
+ if ( buf != wxBuffer )
+ delete buf ;
+ return result ;
+}
+
+
+void wxMacConvertToPC( char * p )
+{
+ char *ptr = p ;
+ int len = strlen ( p ) ;
+
+ wxMacConvertToPC( ptr , ptr , len ) ;
+}
+
+void wxMacConvertToPC( unsigned char *p )
+{
+ char *ptr = (char*) p + 1 ;
+ int len = p[0] ;
+
+ wxMacConvertToPC( ptr , ptr , len ) ;
+}
+
+wxString wxMacMakePCStringFromMac( const char * p )
+{
+ const char *ptr = p ;
+ int len = strlen ( p ) ;
+ char *buf = wxBuffer ;
+
+ if ( len >= BUFSIZ + 512 )
+ {
+ buf = new char [len+1] ;
+ }
-int PLTestMinimalRequirements() ;
-void PLErrorMessage( int errorCode ) ;
-int PLStartupPhase1() ;
-int PLStartupPhase2() ;
-void PLCleanup() ;
+ wxMacConvertToPC( ptr , buf , len ) ;
+ buf[len] = 0 ;
-bool PLDoOneEvent() ;
-bool PLHandleOneEvent( PLEventHandle event ) ; // true if really event
-bool PLCallbackIdle() ;
-bool PLCallbackRepeat() ;
+ wxString result( buf ) ;
+ if ( buf != wxBuffer )
+ delete buf ;
+ return result ;
+}
-long wxApp::sm_lastMessageTime = 0;
+#endif
bool wxApp::Initialize()
{
int error = 0 ;
-
- error = PLStartupPhase1() ;
- if ( !error )
- {
- error = PLTestMinimalRequirements() ;
- if ( !error )
- error = PLStartupPhase2() ;
- }
-
+
+ // Mac-specific
+
+ UMAInitToolbox( 4 ) ;
+ UMAShowWatchCursor() ;
+
+#ifdef __UNIX__
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , AEHandleODoc ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , AEHandleOApp ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , AEHandlePDoc ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , AEHandleQuit ,
+ (long) wxTheApp , FALSE ) ;
+#else
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments , NewAEEventHandlerProc(AEHandleODoc) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication , NewAEEventHandlerProc(AEHandleOApp) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments , NewAEEventHandlerProc(AEHandlePDoc) ,
+ (long) wxTheApp , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication , NewAEEventHandlerProc(AEHandleQuit) ,
+ (long) wxTheApp , FALSE ) ;
+#endif
+
+
+#ifndef __UNIX__
+ // test the minimal configuration necessary
+
+ long theSystem ;
+ long theMachine;
+
+ if (Gestalt(gestaltMachineType, &theMachine) != noErr)
+ {
+ error = kMacSTRWrongMachine;
+ }
+ else if (theMachine < gestaltMacPlus)
+ {
+ error = kMacSTRWrongMachine;
+ }
+ else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
+ {
+ error = kMacSTROldSystem ;
+ }
+ else if ( theSystem < 0x0750 )
+ {
+ error = kMacSTROldSystem ;
+ }
+ #if !TARGET_CARBON
+ else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
+ {
+ error = kMacSTRSmallSize;
+ }
+ #endif
+ /*
+ else
+ {
+ if ( !UMAHasAppearance() )
+ {
+ error = kMacSTRNoPre8Yet ;
+ }
+ }
+ */
+#endif
+
+ // if we encountered any problems so far, give the error code and exit immediately
+
if ( error )
{
- PLErrorMessage( error ) ;
- return FALSE ;
- }
-
+ short itemHit;
+ Str255 message;
+
+ GetIndString(message, 128, error);
+ UMAShowArrowCursor() ;
+ ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
+ itemHit = Alert(128, nil);
+ return FALSE ;
+ }
+
+#ifndef __UNIX__
+ #if __option(profile)
+ ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
+ #endif
+#endif
+
+ // now avoid exceptions thrown for new (bad_alloc)
+
+#ifndef __UNIX__
+ std::__throws_bad_alloc = FALSE ;
+#endif
+
+ s_macCursorRgn = ::NewRgn() ;
+
#ifdef __WXMSW__
wxBuffer = new char[1500];
#else
wxBuffer = new char[BUFSIZ + 512];
#endif
-/* No longer used
-#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
+ wxClassInfo::InitializeClasses();
- streambuf* sBuf = new wxDebugStreamBuf;
- ostream* oStr = new ostream(sBuf) ;
- wxDebugContext::SetStream(oStr, sBuf);
+#if wxUSE_RESOURCES
+// wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
#endif
-*/
-
- wxClassInfo::InitializeClasses();
+#if wxUSE_THREADS
+ wxPendingEventsLocker = new wxCriticalSection;
+#endif
wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
wxTheColourDatabase->Initialize();
wxBitmap::InitStandardHandlers();
wxModule::RegisterModules();
- wxASSERT( wxModule::InitializeModules() == TRUE );
+ if (!wxModule::InitializeModules()) {
+ return FALSE;
+ }
+
+ wxWinMacWindowList = new wxList(wxKEY_INTEGER);
+ wxWinMacControlList = new wxList(wxKEY_INTEGER);
+ wxMacCreateNotifierTable() ;
+
+ UMAShowArrowCursor() ;
+
return TRUE;
}
void wxApp::CleanUp()
{
+#if wxUSE_LOG
+ // flush the logged messages if any and install a 'safer' log target: the
+ // default one (wxLogGui) can't be used after the resources are freed just
+ // below and the user suppliedo ne might be even more unsafe (using any
+ // wxWindows GUI function is unsafe starting from now)
+ wxLog::DontCreateOnDemand();
+
+ // this will flush the old messages if any
+ delete wxLog::SetActiveTarget(new wxLogStderr);
+#endif // wxUSE_LOG
+
+ // One last chance for pending objects to be cleaned up
+ wxTheApp->DeletePendingObjects();
+
wxModule::CleanUpModules();
#if wxUSE_WX_RESOURCES
wxDeleteStockObjects() ;
- // Destroy all GDI lists, etc.
-
- delete wxTheBrushList;
- wxTheBrushList = NULL;
-
- delete wxThePenList;
- wxThePenList = NULL;
-
- delete wxTheFontList;
- wxTheFontList = NULL;
-
- delete wxTheBitmapList;
- wxTheBitmapList = NULL;
+ // Destroy all GDI lists, etc.
+ wxDeleteStockLists();
delete wxTheColourDatabase;
wxTheColourDatabase = NULL;
delete[] wxBuffer;
wxBuffer = NULL;
+ wxMacDestroyNotifierTable() ;
+ if (wxWinMacWindowList)
+ delete wxWinMacWindowList ;
+
+ delete wxPendingEvents;
+#if wxUSE_THREADS
+ delete wxPendingEventsLocker;
+ // If we don't do the following, we get an apparent memory leak.
+ ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
+#endif
+
wxClassInfo::CleanUpClasses();
+#ifndef __UNIX__
+ #if __option(profile)
+ ProfilerDump( "\papp.prof" ) ;
+ ProfilerTerm() ;
+ #endif
+#endif
+
delete wxTheApp;
wxTheApp = NULL;
-
+
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
- // At this point we want to check if there are any memory
- // blocks that aren't part of the wxDebugContext itself,
- // as a special case. Then when dumping we need to ignore
- // wxDebugContext, too.
- if (wxDebugContext::CountObjectsLeft() > 0)
- {
- wxTrace("There were memory leaks.\n");
- wxDebugContext::Dump();
- wxDebugContext::PrintStatistics();
- }
-// wxDebugContext::SetStream(NULL, NULL);
+ // At this point we want to check if there are any memory
+ // blocks that aren't part of the wxDebugContext itself,
+ // as a special case. Then when dumping we need to ignore
+ // wxDebugContext, too.
+ if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
+ {
+ wxLogDebug(wxT("There were memory leaks."));
+ wxDebugContext::Dump();
+ wxDebugContext::PrintStatistics();
+ }
+ // wxDebugContext::SetStream(NULL, NULL);
#endif
-
- // do it as the very last thing because everything else can log messages
- wxLog::DontCreateOnDemand();
- // do it as the very last thing because everything else can log messages
- delete wxLog::SetActiveTarget(NULL);
- PLCleanup() ;
+#if wxUSE_LOG
+ // do it as the very last thing because everything else can log messages
+ delete wxLog::SetActiveTarget(NULL);
+#endif // wxUSE_LOG
+
+ UMACleanupToolbox() ;
+ if (s_macCursorRgn)
+ ::DisposeRgn(s_macCursorRgn);
+
+ #if 0
+ TerminateAE() ;
+ #endif
}
-int wxEntry( int argc, char *argv[] )
+int wxEntry( int argc, char *argv[] , bool enterLoop )
{
- if (!wxApp::Initialize())
- return FALSE;
- if (!wxTheApp)
- {
- if (!wxApp::GetInitializerFunction())
+#ifdef __MWERKS__
+#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
+ // This seems to be necessary since there are 'rogue'
+ // objects present at this point (perhaps global objects?)
+ // Setting a checkpoint will ignore them as far as the
+ // memory checking facility is concerned.
+ // Of course you may argue that memory allocated in globals should be
+ // checked, but this is a reasonable compromise.
+ wxDebugContext::SetCheckpoint();
+#endif
+#endif
+ if (!wxApp::Initialize()) {
+ return 0;
+ }
+ // create the application object or ensure that one already exists
+ if (!wxTheApp)
{
- printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
- return 0;
- };
-
- wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
- };
-
- if (!wxTheApp)
- {
- printf( "wxWindows error: wxTheApp == NULL\n" );
- return 0;
- };
+ // The app may have declared a global application object, but we recommend
+ // the IMPLEMENT_APP macro is used instead, which sets an initializer
+ // function for delayed, dynamic app object construction.
+ wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
+ wxT("No initializer - use IMPLEMENT_APP macro.") );
+
+ wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
+ }
+
+ wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
+
+#ifdef __WXMAC__
+ argc = 0 ; // currently we don't support files as parameters
+#endif
wxTheApp->argc = argc;
wxTheApp->argv = argv;
// GUI-specific initialization, such as creating an app context.
wxTheApp->OnInitGui();
+ // we could try to get the open apple events here to adjust argc and argv better
+
+
// Here frames insert themselves automatically
// into wxTopLevelWindows by getting created
// in OnInit().
-
- if (!wxTheApp->OnInit()) return 0;
int retValue = 0;
-
- if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
- if (wxTheApp->GetTopWindow())
- {
- delete wxTheApp->GetTopWindow();
- wxTheApp->SetTopWindow(NULL);
- }
-
- wxTheApp->DeletePendingObjects();
-
- wxTheApp->OnExit();
-
- wxApp::CleanUp();
+ if ( wxTheApp->OnInit() )
+ {
+ if ( enterLoop )
+ {
+ retValue = wxTheApp->OnRun();
+ }
+ else
+ // We want to initialize, but not run or exit immediately.
+ return 1;
+ }
+ //else: app initialization failed, so we skipped OnRun()
- return retValue;
-};
+ wxWindow *topWindow = wxTheApp->GetTopWindow();
+ if ( topWindow )
+ {
+ // Forcibly delete the window.
+ if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
+ topWindow->IsKindOf(CLASSINFO(wxDialog)) )
+ {
+ topWindow->Close(TRUE);
+ wxTheApp->DeletePendingObjects();
+ }
+ else
+ {
+ delete topWindow;
+ wxTheApp->SetTopWindow(NULL);
+ }
+ }
+
+ wxTheApp->OnExit();
+
+ wxApp::CleanUp();
+
+ return retValue;
+}
// Static member initialization
-wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
+wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
wxApp::wxApp()
{
m_topWindow = NULL;
wxTheApp = this;
- m_className = "";
+
m_wantDebugOutput = TRUE ;
- m_appName = "";
+
argc = 0;
argv = NULL;
-#ifdef __WXMSW__
+
m_printMode = wxPRINT_WINDOWS;
-#else
- m_printMode = wxPRINT_POSTSCRIPT;
-#endif
m_exitOnFrameDelete = TRUE;
m_auto3D = TRUE;
}
bool wxApp::Initialized()
{
+ if (GetTopWindow())
return TRUE;
-// if (GetTopWindow())
-// return TRUE;
-// else
-// return FALSE;
+ else
+ return FALSE;
}
int wxApp::MainLoop()
while (m_keepGoing)
{
- PLDoOneEvent() ;
+ MacDoOneEvent() ;
}
return 0;
// Is a message/event pending?
bool wxApp::Pending()
{
-/* TODO.
- */
- return FALSE;
+ EventRecord event ;
+
+ return EventAvail( everyEvent , &event ) ;
}
// Dispatch a message.
void wxApp::Dispatch()
{
-/* TODO.
- */
+ MacDoOneEvent() ;
}
void wxApp::OnIdle(wxIdleEvent& event)
{
- static bool inOnIdle = FALSE;
+ static bool s_inOnIdle = FALSE;
- // Avoid recursion (via ProcessEvent default case)
- if (inOnIdle)
- return;
+ // Avoid recursion (via ProcessEvent default case)
+ if ( s_inOnIdle )
+ return;
- inOnIdle = TRUE;
+
+ s_inOnIdle = TRUE;
// 'Garbage' collection of windows deleted with Close().
DeletePendingObjects();
if (needMore)
event.RequestMore(TRUE);
- inOnIdle = FALSE;
+ // If they are pending events, we must process them: pending events are
+ // either events to the threads other than main or events posted with
+ // wxPostEvent() functions
+ wxMacProcessNotifierAndPendingEvents();
+
+ s_inOnIdle = FALSE;
+}
+
+void wxWakeUpIdle()
+{
+ wxMacWakeUp() ;
}
// Send idle event to all top-level windows
while (node)
{
wxObject *obj = (wxObject *)node->Data();
-
+
delete obj;
if (wxPendingDelete.Member(obj))
}
}
-wxLog* wxApp::CreateLogTarget()
+wxIcon
+wxApp::GetStdIcon(int which) const
{
- return new wxLogGui;
-}
+ switch(which)
+ {
+ case wxICON_INFORMATION:
+ return wxIcon("wxICON_INFO");
-wxWindow* wxApp::GetTopWindow() const
-{
- if (m_topWindow)
- return m_topWindow;
- else if (wxTopLevelWindows.Number() > 0)
- return (wxWindow*) wxTopLevelWindows.First()->Data();
- else
- return NULL;
+ case wxICON_QUESTION:
+ return wxIcon("wxICON_QUESTION");
+
+ case wxICON_EXCLAMATION:
+ return wxIcon("wxICON_WARNING");
+
+ default:
+ wxFAIL_MSG(wxT("requested non existent standard icon"));
+ // still fall through
+
+ case wxICON_HAND:
+ return wxIcon("wxICON_ERROR");
+ }
}
void wxExit()
{
- wxApp::CleanUp();
-/*
- * TODO: Exit in some platform-specific way. Not recommended that the app calls this:
- * only for emergencies.
- */
+ wxLogError(_("Fatal error: exiting"));
+
+ wxApp::CleanUp();
+ ::ExitToShell() ;
}
-// Yield to other processes
-bool wxYield()
+void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
{
- /*
- * TODO
- */
- return TRUE;
+ if (GetTopWindow())
+ GetTopWindow()->Close(TRUE);
}
-// -------------------------------------------------------------------
-// Portability Layer PL
-// -------------------------------------------------------------------
-// this is the c-api part, the only part of this file that needs to be
-// adapted for supporting a new platform
-// there are two flavours of PL... functions, Callbacks and normal functions
-// Callbacks are called by other PLxxx functions and allow to trigger idle
-// processing etc. the callbacks don't have to be adapted for every platform
-// but only in case of changes to the underlying wx framework
-
-// callbacks
-
-bool PLCallbackIdle()
+// Default behaviour: close the application with prompts. The
+// user can veto the close, and therefore the end session.
+void wxApp::OnQueryEndSession(wxCloseEvent& event)
{
- return wxTheApp->ProcessIdle() ;
+ if (GetTopWindow())
+ {
+ if (!GetTopWindow()->Close(!event.CanVeto()))
+ event.Veto(TRUE);
+ }
}
-bool PLCallbackRepeat()
+extern "C" void wxCYield() ;
+void wxCYield()
{
- // wxMacProcessSocketEvents() ;
- return false ;
+ wxYield() ;
}
-// platform specific static variables
-
-bool gMacHasAppearance = false ;
-long gMacAppearanceVersion = 0 ;
-RgnHandle gMacCursorRgn = NULL ;
-
-#define kMinHeap (29 * 1024)
-#define kMinSpace (20 * 1024)
-#define eWrongMachine 1
-#define eSmallSize 2
-#define eNoMemory 3
-#define eOldSystem 4
-#define eGenericAbout 5
-
-// platform specific prototypes
-
-void DoMacNullEvent( EventRecord *ev ) ;
-void DoMacHighLevelEvent( EventRecord *ev ) ;
-void DoMacMouseDownEvent( EventRecord *ev ) ;
-void DoMacMouseUpEvent( EventRecord *ev ) ;
-void DoMacKeyDownEvent( EventRecord *ev ) ;
-void DoMacKeyUpEvent( EventRecord *ev ) ;
-void DoMacAutoKeyEvent( EventRecord *ev ) ;
-void DoMacActivateEvent( EventRecord *ev ) ;
-void DoMacUpdateEvent( EventRecord *ev ) ;
-void DoMacDiskEvent( EventRecord *ev ) ;
-void DoMacOSEvent( EventRecord *ev ) ;
-
-// platform specific functions
-
-// -------------------------------------------------------------------
-// PLStartupPhase1
-// -------------------------------------------------------------------
-// Initializes the system so that at least the requirements can be tested
-// and that error messages will shop up at all ;-)
-//
-// parameters : none
-// return value : non zero for a implementation specific error code
-
-int PLStartupPhase1()
-{
- ::InitGraf(&qd.thePort);
- ::InitFonts();
- ::InitWindows();
- ::InitMenus();
- ::TEInit();
- ::InitDialogs(0L);
- ::InitCursor();
- CursHandle aCursHandle = ::GetCursor(watchCursor); // Watch should be in system
- if (aCursHandle)
- ::SetCursor(*aCursHandle); // Change cursor to watch
- ::FlushEvents(everyEvent, 0);
-
- gMacCursorRgn = ::NewRgn() ;
-
- return 0 ;
-}
+// Yield to other processes
-// -------------------------------------------------------------------
-// PLStartupPhase2
-// -------------------------------------------------------------------
-// booting the system further until all subsystems are running
-//
-// parameters : none
-// return value : non zero for a implementation specific error code
+static bool gs_inYield = FALSE;
-int PLStartupPhase2()
+bool wxYield()
{
- long total,contig;
-
- ::MaxApplZone();
- for (long i = 1; i <= 4; i++)
- ::MoreMasters();
- PurgeSpace(&total, &contig);
- ::SetCursor( &qd.arrow ) ;
-
-#if 0
- InitAEHandlers();
- InitializeAECore() ;
- GUSISetup(GUSIwithInternetSockets);
+#ifdef __WXDEBUG__
+ if (gs_inYield)
+ wxFAIL_MSG( wxT("wxYield called recursively" ) );
#endif
- return 0 ;
-}
+ gs_inYield = TRUE;
+
+#if wxUSE_THREADS
+ YieldToAnyThread() ;
+#endif
+ EventRecord event ;
-// -------------------------------------------------------------------
-// PLErrorMessage
-// -------------------------------------------------------------------
-// notifies the user of a implementation specific error
-// is useful for messages before the wx System is up and running
-//
-// parameters : int error = error code (implementation specific)
-// return value : none
+ long sleepTime = 0 ; //::GetCaretTime();
-void PLErrorMessage( int error )
-{
- short itemHit;
- Str255 message;
+ while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, wxApp::s_macCursorRgn))
+ {
+ wxTheApp->MacHandleOneEvent( &event );
+ }
- SetCursor(&qd.arrow);
- GetIndString(message, 128, error);
- ParamText(message, (ConstStr255Param)"\p", (ConstStr255Param)"\p", (ConstStr255Param)"\p");
- itemHit = Alert(129, nil);
-}
+ wxMacProcessNotifierAndPendingEvents() ;
-// -------------------------------------------------------------------
-// PLCleanup
-// -------------------------------------------------------------------
-// notifies the user of a implementation specific error
-// is useful for messages before the wx System is up and running
-//
-// parameters : int error = error code (implementation specific)
-// return value : none
+ gs_inYield = FALSE;
+
+ return TRUE;
+}
-void PLCleanup()
+// Yield to incoming messages; but fail silently if recursion is detected.
+bool wxYieldIfNeeded()
{
- ::PrClose() ;
- if (gMacCursorRgn)
- ::DisposeRgn(gMacCursorRgn);
-#if 0
- TerminateAE() ;
-#endif
+ if (gs_inYield)
+ return FALSE;
+
+ return wxYield();
}
-// -------------------------------------------------------------------
-// PLTestMinimalRequirements
-// -------------------------------------------------------------------
-// test whether we are on the correct runnable system and read out any
-// useful informations from the system
-//
-// parameters : none
-// return value : non zero for a implementation specific error code
+// platform specifics
-int PLTestMinimalRequirements()
+void wxApp::MacSuspend( bool convertClipboard )
{
- long theSystem ;
- long theMachine;
- long theAppearance ;
-
- if (Gestalt(gestaltMachineType, &theMachine) != noErr)
- {
- return(eWrongMachine);
- }
-
- if (theMachine < gestaltMacPlus)
- {
- return(eWrongMachine);
- }
-
- if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
- {
- return( eOldSystem ) ;
- }
+ // we have to deactive the window manually
+
+ wxWindow* window = GetTopWindow() ;
+ if ( window )
+ window->MacActivate( MacGetCurrentEvent() , false ) ;
- if ( theSystem < 0x0700 )
- {
- return( eOldSystem ) ;
- }
-
- if ((long)GetApplLimit() - (long)ApplicationZone() < kMinHeap)
- {
- return(eSmallSize);
- }
-
- if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
- {
- gMacHasAppearance = true ;
- RegisterAppearanceClient();
- if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
+ s_lastMouseDown = 0 ;
+ if( convertClipboard )
{
- gMacAppearanceVersion = theAppearance ;
+ MacConvertPrivateToPublicScrap() ;
}
- else
+
+ UMAHideFloatingWindows() ;
+}
+
+void wxApp::MacResume( bool convertClipboard )
+{
+ s_lastMouseDown = 0 ;
+ if( convertClipboard )
{
- gMacAppearanceVersion = 0x0100 ;
+ MacConvertPublicToPrivateScrap() ;
}
- }
- return 0 ;
+ UMAShowFloatingWindows() ;
}
-// -------------------------------------------------------------------
-// PLDoOneEvent
-// -------------------------------------------------------------------
-//
-// parameters : none
-// return value : returns true if a real event occured (no null or timeout event)
+void wxApp::MacConvertPrivateToPublicScrap()
+{
+}
-bool PLDoOneEvent()
+void wxApp::MacConvertPublicToPrivateScrap()
{
- EventRecord event ;
+}
- long sleepTime = 60;
+void wxApp::MacDoOneEvent()
+{
+ EventRecord event ;
- bool gotEvent = false ;
-
+ long sleepTime = ::GetCaretTime();
- if (WaitNextEvent(everyEvent, &event,sleepTime, gMacCursorRgn))
+ if (WaitNextEvent(everyEvent, &event,sleepTime, s_macCursorRgn))
{
- gotEvent = PLHandleOneEvent( &event );
+ MacHandleOneEvent( &event );
}
else
{
- PLCallbackIdle();
+ // idlers
+ WindowPtr window = UMAFrontWindow() ;
+ if ( window )
+ UMAIdleControls( window ) ;
+
+ wxTheApp->ProcessIdle() ;
}
-
- PLCallbackRepeat() ;
-
- return gotEvent ;
-}
+ if ( event.what != kHighLevelEvent )
+ SetRectRgn( s_macCursorRgn , event.where.h - 1 , event.where.v - 1, event.where.h + 1 , event.where.v + 1 ) ;
-// -------------------------------------------------------------------
-// PLHandleOneEvent
-// -------------------------------------------------------------------
-//
-// parameters : event = event handle of the platform specific event to be handled
-// return value : returns true if a real event occured (no null or timeout event)
+ // repeaters
-bool PLHandleOneEvent( PLEventHandle event )
+ wxMacProcessNotifierAndPendingEvents() ;
+}
+
+void wxApp::MacHandleOneEvent( EventRecord *ev )
{
- bool realEvent = true ;
+ m_macCurrentEvent = ev ;
- EventRecord* ev = (EventRecord*) event ;
+ wxApp::sm_lastMessageTime = ev->when ;
switch (ev->what)
{
- case nullEvent:
- DoMacNullEvent( ev ) ;
- realEvent = false ;
- break ;
- case kHighLevelEvent:
- DoMacHighLevelEvent( ev ) ;
- break;
case mouseDown:
- DoMacMouseDownEvent( ev ) ;
- wxTheApp->ExitMainLoop() ;
+ MacHandleMouseDownEvent( ev ) ;
+ if ( ev->modifiers & controlKey )
+ s_lastMouseDown = 2;
+ else
+ s_lastMouseDown = 1;
break;
case mouseUp:
- DoMacMouseUpEvent( ev ) ;
+ if ( s_lastMouseDown == 2 )
+ {
+ ev->modifiers |= controlKey ;
+ }
+ else
+ {
+ ev->modifiers &= ~controlKey ;
+ }
+ MacHandleMouseUpEvent( ev ) ;
+ s_lastMouseDown = 0;
break;
- case keyDown:
- DoMacKeyDownEvent( ev ) ;
+ case activateEvt:
+ MacHandleActivateEvent( ev ) ;
+ break;
+ case updateEvt:
+ MacHandleUpdateEvent( ev ) ;
break;
+ case keyDown:
case autoKey:
- DoMacAutoKeyEvent( ev ) ;
+ MacHandleKeyDownEvent( ev ) ;
break;
case keyUp:
- DoMacKeyUpEvent( ev ) ;
- break;
- case activateEvt:
- DoMacActivateEvent( ev ) ;
- break;
- case updateEvt:
- DoMacUpdateEvent( ev ) ;
+ MacHandleKeyUpEvent( ev ) ;
break;
case diskEvt:
- DoMacDiskEvent( ev ) ;
+ MacHandleDiskEvent( ev ) ;
break;
case osEvt:
- DoMacOSEvent( ev ) ;
+ MacHandleOSEvent( ev ) ;
+ break;
+ case kHighLevelEvent:
+ MacHandleHighLevelEvent( ev ) ;
break;
default:
break;
}
- return realEvent ;
+ wxMacProcessNotifierAndPendingEvents() ;
}
-// platform specific functions (non PLxxx functions)
-
-void DoMacNullEvent( EventRecord *ev )
+void wxApp::MacHandleHighLevelEvent( EventRecord *ev )
{
+ ::AEProcessAppleEvent( ev ) ;
}
-void DoMacHighLevelEvent( EventRecord *ev )
-{
-}
+bool s_macIsInModalLoop = false ;
-void DoMacMouseDownEvent( EventRecord *ev )
+void wxApp::MacHandleMouseDownEvent( EventRecord *ev )
{
-}
+ wxToolTip::RemoveToolTips() ;
-void DoMacMouseUpEvent( EventRecord *ev )
-{
-}
+ WindowRef window;
+ WindowRef frontWindow = UMAFrontNonFloatingWindow() ;
+ WindowAttributes frontWindowAttributes = NULL ;
+ if ( frontWindow )
+ UMAGetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
-void DoMacKeyDownEvent( EventRecord *ev )
-{
-}
+ short windowPart = ::FindWindow(ev->where, &window);
+ wxWindow* win = wxFindWinFromMacWindow( window ) ;
-void DoMacKeyUpEvent( EventRecord *ev )
-{
-}
+ BitMap screenBits;
+ GetQDGlobalsScreenBits( &screenBits );
-void DoMacAutoKeyEvent( EventRecord *ev )
-{
-}
-
-void DoMacActivateEvent( EventRecord *ev )
-{
-}
+ switch (windowPart)
+ {
+ case inMenuBar :
+ if ( s_macIsInModalLoop )
+ {
+ SysBeep ( 30 ) ;
+ }
+ else
+ {
+ UInt32 menuresult = MenuSelect(ev->where) ;
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
+ s_lastMouseDown = 0;
+ }
+ break ;
+#if !TARGET_CARBON
+ case inSysWindow :
+ SystemClick( ev , window ) ;
+ s_lastMouseDown = 0;
+ break ;
+#endif
+ case inDrag :
+ if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
+ {
+ SysBeep ( 30 ) ;
+ }
+ else
+ {
+ DragWindow(window, ev->where, &screenBits.bounds);
+ if (win)
+ {
+ GrafPtr port ;
+ GetPort( &port ) ;
+ Point pt = { 0, 0 } ;
+ #if TARGET_CARBON
+ SetPort( GetWindowPort(window) ) ;
+ #else
+ SetPort( (window) ) ;
+ #endif
+ SetOrigin( 0 , 0 ) ;
+ LocalToGlobal( &pt ) ;
+ SetPort( port ) ;
+ win->SetSize( pt.h , pt.v , -1 ,
+ -1 , wxSIZE_USE_EXISTING);
+ }
+ s_lastMouseDown = 0;
+ }
+ break ;
+ case inGoAway:
+ if (TrackGoAway(window, ev->where))
+ {
+ if ( win )
+ win->Close() ;
+ }
+ s_lastMouseDown = 0;
+ break;
+ case inGrow:
+ {
+ int growResult = GrowWindow(window , ev->where, &screenBits.bounds);
+ if (growResult != 0)
+ {
+ int newWidth = LoWord(growResult);
+ int newHeight = HiWord(growResult);
+ int oldWidth, oldHeight;
+
+
+ if (win)
+ {
+ win->GetSize(&oldWidth, &oldHeight);
+ if (newWidth == 0)
+ newWidth = oldWidth;
+ if (newHeight == 0)
+ newHeight = oldHeight;
+ win->SetSize( -1, -1, newWidth, newHeight, wxSIZE_USE_EXISTING);
+ }
+ }
+ s_lastMouseDown = 0;
+ }
+ break;
+ case inZoomIn:
+ case inZoomOut:
+ if (TrackBox(window, ev->where, windowPart))
+ {
+ // TODO setup size event
+ ZoomWindow( window , windowPart , false ) ;
+ if (win)
+ {
+ Rect tempRect ;
+
+ GetWindowPortBounds(window, &tempRect ) ;
+ win->SetSize( -1, -1, tempRect.right-tempRect.left ,
+ tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
+ }
+ }
+ s_lastMouseDown = 0;
+ break;
+ case inCollapseBox :
+ // TODO setup size event
+ s_lastMouseDown = 0;
+ break ;
-void DoMacUpdateEvent( EventRecord *ev )
-{
-}
+ case inContent :
+ {
+ GrafPtr port ;
+ GetPort( &port ) ;
+ #if TARGET_CARBON
+ SetPort( GetWindowPort(window) ) ;
+ #else
+ SetPort( (window) ) ;
+ #endif
+ SetOrigin( 0 , 0 ) ;
+ SetPort( port ) ;
+ }
+ if ( window != frontWindow )
+ {
+ if ( s_macIsInModalLoop )
+ {
+ SysBeep ( 30 ) ;
+ }
+ else if ( UMAIsWindowFloating( window ) )
+ {
+ if ( win )
+ win->MacMouseDown( ev , windowPart ) ;
+ }
+ else
+ {
+ UMASelectWindow( window ) ;
+ }
+ }
+ else
+ {
+ if ( win )
+ win->MacMouseDown( ev , windowPart ) ;
+ }
+ break ;
-void DoMacDiskEvent( EventRecord *ev )
-{
+ default:
+ break;
+ }
}
-void DoMacOSEvent( EventRecord *ev )
+void wxApp::MacHandleMouseUpEvent( EventRecord *ev )
{
-}
-
-
+ WindowRef window;
-/*
+ short windowPart = ::FindWindow(ev->where, &window);
-void wxApp::doMacMouseDown(void)
-{
- WindowPtr window;
- short windowPart = ::FindWindow(m_event.where, &window);
- if ( windowPart != inMenuBar )
+ switch (windowPart)
{
- WindowPtr frontWindow = FrontWindow();
- if (WindowIsModal(frontWindow) && (window != frontWindow))
- SysBeep(1);
- else
- {
- switch (windowPart)
+ case inMenuBar :
+ break ;
+ case inSysWindow :
+ break ;
+ default:
{
- case inMenuBar:
- break;
- case inContent:
- doMacInContent(window); break;
- case inDrag:
- doMacInDrag(window); break;
- case inGrow:
- doMacInGrow(window); break;
- case inGoAway:
- doMacInGoAway(window); break;
- case inZoomIn:
- case inZoomOut:
- doMacInZoom(window, windowPart); break;
- default:
- break;
+ wxWindow* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacMouseUp( ev , windowPart ) ;
}
-
- }
- }
- else
- {
- doMacInMenuBar(::MenuSelect(m_event.where));
+ break;
}
}
-void wxApp::doMacMouseUp(void)
+long wxMacTranslateKey(unsigned char key, unsigned char code)
{
- if (m_mouseWindow)
- {
-#if 0
- int hitX = m_event.where.h; // screen window c.s.
- int hitY = m_event.where.v; // screen window c.s.
- m_mouseWindow->ScreenToClient(&hitX, &hitY); // mouseWindow client c.s.
- m_mouseWindow->ClientToLogical(&hitX, &hitY); // mouseWindow logical c.s.
-#endif
-
- wxMouseEvent event(wxEVT_LEFT_UP);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_leftDown = FALSE;
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(m_mouseWindow);
-
- m_mouseWindow->ProcessEvent(event);
- }
- else
- {
- //??? Can't we just throw away mouse up events without matching mouse down
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
-#if 0
- int hitX = cCurrentEvent.where.h; // screen window c.s.
- int hitY = cCurrentEvent.where.v; // screen window c.s.
- theMacWxFrame->ScreenToWindow(&hitX, &hitY);
-#endif
-
- wxMouseEvent event(wxEVT_LEFT_UP);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_leftDown = FALSE;
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(m_mouseWindow);
-
- theMacWxFrame->ProcessEvent(event);
- }
- }
-}
-
-void wxApp::doMacMouseMotion(void)
-{
- if (m_mouseWindow) {
- wxMouseEvent event(wxEVT_MOTION);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_leftDown = !(m_event.modifiers & btnState);
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(m_mouseWindow);
-
- m_mouseWindow->ProcessEvent(event);
- }
- else
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- wxMouseEvent event(wxEVT_MOTION);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_leftDown = !(m_event.modifiers & btnState);
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(m_mouseWindow);
-
- m_mouseWindow->ProcessEvent(event);
- }
- }
-
- //??? Need to work with floating windows... isn't there a toolbox call to find the
- // top window intersecting a point is screen coordinates??
-#if 0
- else // will only work for one floating window at the moment... ?
- {
- WindowPtr frontDocPtr = findFrontNonFloatingWindow();
- WindowPtr frontFloatingPtr = ::FrontWindow();
-
- int hitX = cCurrentEvent.where.h;
- int hitY = cCurrentEvent.where.v;
-
- wxFrame* macWxFrame = findMacWxFrame(frontDocPtr);
-
- if ((frontFloatingPtr != frontDocPtr) & (frontFloatingPtr != NULL))
- {
- RgnHandle frontFloatStrRgn = getStructureRegion(frontFloatingPtr);
- Rect frontFloatRect = (**frontFloatStrRgn).rgnBBox;
-
- if ((hitX >= frontFloatRect.left) &
- (hitX <= frontFloatRect.right) &
- (hitY >= frontFloatRect.top) &
- (hitY <= frontFloatRect.bottom))
+ long retval = key ;
+ switch (key)
+ {
+ case 0x01 :
+ retval = WXK_HOME;
+ break;
+ case 0x03 :
+ retval = WXK_RETURN;
+ break;
+ case 0x04 :
+ retval = WXK_END;
+ break;
+ case 0x05 :
+ retval = WXK_HELP;
+ break;
+ case 0x08 :
+ retval = WXK_BACK;
+ break;
+ case 0x09 :
+ retval = WXK_TAB;
+ break;
+ case 0x0b :
+ retval = WXK_PAGEUP;
+ break;
+ case 0x0c :
+ retval = WXK_PAGEDOWN;
+ break;
+ case 0x0d :
+ retval = WXK_RETURN;
+ break;
+ case 0x10 :
{
- macWxFrame = findMacWxFrame(frontFloatingPtr);
+ switch( code )
+ {
+ case 0x7a :
+ retval = WXK_F1 ;
+ break;
+ case 0x78 :
+ retval = WXK_F2 ;
+ break;
+ case 0x63 :
+ retval = WXK_F3 ;
+ break;
+ case 0x76 :
+ retval = WXK_F4 ;
+ break;
+ case 0x60 :
+ retval = WXK_F5 ;
+ break;
+ case 0x61 :
+ retval = WXK_F6 ;
+ break;
+ case 0x62:
+ retval = WXK_F7 ;
+ break;
+ case 0x64 :
+ retval = WXK_F8 ;
+ break;
+ case 0x65 :
+ retval = WXK_F9 ;
+ break;
+ case 0x6D :
+ retval = WXK_F10 ;
+ break;
+ case 0x67 :
+ retval = WXK_F11 ;
+ break;
+ case 0x6F :
+ retval = WXK_F12 ;
+ break;
+ case 0x69 :
+ retval = WXK_F13 ;
+ break;
+ case 0x6B :
+ retval = WXK_F14 ;
+ break;
+ case 0x71 :
+ retval = WXK_F15 ;
+ break;
+ }
}
- }
- }
-#endif
+ break ;
+ case 0x1b :
+ retval = WXK_ESCAPE ;
+ break ;
+ case 0x1c :
+ retval = WXK_LEFT ;
+ break ;
+ case 0x1d :
+ retval = WXK_RIGHT ;
+ break ;
+ case 0x1e :
+ retval = WXK_UP ;
+ break ;
+ case 0x1f :
+ retval = WXK_DOWN ;
+ break ;
+ case 0x7F :
+ retval = WXK_DELETE ;
+ default:
+ break ;
+ } // end switch
+
+ return retval;
}
-void wxApp::doMacKeyDown(void)
+void wxApp::MacHandleKeyDownEvent( EventRecord *ev )
{
- long menuResult = 0 ;
- short keycode ;
- short keychar ;
- keychar = short(m_event.message & charCodeMask);
- keycode = short(m_event.message & keyCodeMask) >> 8 ;
-
- // Handle menu accelerators
- if ( gSFMacHasAppearance )
+ wxToolTip::RemoveToolTips() ;
+
+ UInt32 menuresult = UMAMenuEvent(ev) ;
+ if ( HiWord( menuresult ) )
{
- menuResult = MenuEvent( &m_event ) ;
- if ( HiWord( menuResult ) )
- {
- doMacInMenuBar( menuResult ) ;
- }
- else
- {
- ControlHandle control ;
-
- GetKeyboardFocus( FrontNonFloatingWindow() , &control ) ;
- if ( control && keychar != 0x07 )
- HandleControlKey( control , keycode , keychar , m_event.modifiers ) ;
- else
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- wxKeyEvent event(wxEVT_CHAR);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_keyCode = macTranslateKey(keychar, m_event.modifiers & (shiftKey|optionKey));
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
-
- theMacWxFrame->ProcessEvent(event);
- }
- }
- }
+ if ( !s_macIsInModalLoop )
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
}
else
{
- if (GetMenuHandle( kwxMacAppleMenuId ) )
- {
-// menuResult = MDEF_MenuKey(m_event.message, m_event.modifiers , GetMenuHandle( kwxMacAppleMenuId ) );
- }
- else
+ short keycode ;
+ short keychar ;
+ keychar = short(ev->message & charCodeMask);
+ keycode = short(ev->message & keyCodeMask) >> 8 ;
+
+ wxWindow* focus = wxWindow::FindFocus() ;
+ if ( focus )
{
- if (m_event.modifiers & cmdKey)
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
+
+ wxKeyEvent event(wxEVT_KEY_DOWN);
+ event.m_shiftDown = ev->modifiers & shiftKey;
+ event.m_controlDown = ev->modifiers & controlKey;
+ event.m_altDown = ev->modifiers & optionKey;
+ event.m_metaDown = ev->modifiers & cmdKey;
+ event.m_keyCode = keyval;
+ event.m_x = ev->where.h;
+ event.m_y = ev->where.v;
+ event.m_timeStamp = ev->when;
+ event.SetEventObject(focus);
+ bool handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ if ( !handled )
{
- menuResult = MenuKey( keychar ) ;
+ #if wxUSE_ACCEL
+ if (!handled)
+ {
+ wxWindow *ancestor = focus;
+ /*
+ while (ancestor)
+ {
+ int command = ancestor->GetAcceleratorTable()->GetCommand( event );
+ if (command != -1)
+ {
+ wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
+ handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ break;
+ }
+ if (ancestor->m_isFrame)
+ break;
+ ancestor = ancestor->GetParent();
+ }
+ */
+ }
+ #endif // wxUSE_ACCEL
}
- }
-
- if ( HiWord( menuResult ) )
- {
- doMacInMenuBar( menuResult ) ;
- }
- else
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
+ if (!handled)
{
wxKeyEvent event(wxEVT_CHAR);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_keyCode = macTranslateKey(keychar, m_event.modifiers & (shiftKey|optionKey));
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
-
- theMacWxFrame->ProcessEvent(event);
+ event.m_shiftDown = ev->modifiers & shiftKey;
+ event.m_controlDown = ev->modifiers & controlKey;
+ event.m_altDown = ev->modifiers & optionKey;
+ event.m_metaDown = ev->modifiers & cmdKey;
+ event.m_keyCode = keyval;
+ event.m_x = ev->where.h;
+ event.m_y = ev->where.v;
+ event.m_timeStamp = ev->when;
+ event.SetEventObject(focus);
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
}
+ if ( !handled &&
+ (keyval == WXK_TAB) &&
+ (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
+ (focus->GetParent()) &&
+ (focus->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
+ {
+ wxNavigationKeyEvent new_event;
+ new_event.SetEventObject( focus );
+ new_event.SetDirection( !event.ShiftDown() );
+ /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
+ new_event.SetWindowChange( event.ControlDown() );
+ new_event.SetCurrentFocus( focus );
+ handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ }
+ /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
+ if ( (!handled) &&
+ (keyval == '.' && event.ControlDown() ) )
+ {
+ wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
+ new_event.SetEventObject( focus );
+ handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ }
}
}
}
-void wxApp::doMacAutoKey(void)
-{
- doMacKeyDown();
-}
-
-void wxApp::doMacKeyUp(void)
+void wxApp::MacHandleKeyUpEvent( EventRecord *ev )
{
+ // nothing to do
}
-void wxApp::doMacActivateEvt(void)
+void wxApp::MacHandleActivateEvent( EventRecord *ev )
{
- HighlightAndActivateWindow( (WindowPtr) m_event.message , m_event.modifiers & activeFlag ) ;
-}
-
-void wxApp::doMacUpdateEvt(void)
-{
- WindowPtr theMacWindow = (WindowPtr)(m_event.message);
- ::BeginUpdate(theMacWindow);
-
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(theMacWindow);
- if (theMacWxFrame)
+ WindowRef window = (WindowRef) ev->message ;
+ if ( window )
{
-// if (!::EmptyRgn(theMacWindow->visRgn)) // this doesn't work with windowshade
-// {
- if ( theMacWxFrame->MacSetupPort() )
- {
- // Erase update region
- // we must do this, because controls add their former rect to the inval
- // rgn and the background might not have been correct at that moment
- ::EraseRect(&theMacWindow->portRect);
-
- // Can't use UpdateControls since each control has it's own coordinate system
- // ::UpdateControls(theMacWindow, theMacWindow->visRgn);
-
- ::UpdateControls( theMacWindow , theMacWindow->visRgn ) ;
- #if 0
- // Draw the grow box
- if (cStyle & wxRESIZE_BORDER)
- MacDrawGrowIcon();
- #endif
-
- wxPaintEvent event;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
-
- theMacWxFrame->ProcessEvent(event);
- // ::SetThemeWindowBackground( theMacWindow , kThemeActiveDialogBackgroundBrush , false ) ;
- ::ClipRect( &theMacWindow->portRect ) ;
- ::SetOrigin( 0 , 0 );
- }
- else
- {
- wxASSERT_MSG( false , "unabled to setup window mac port") ;
- }
-
-// }
- }
-
- ::EndUpdate(theMacWindow);
-}
-
-void wxApp::doMacDiskEvt(void)
-{ // based on "Programming for System 7" by Gary Little and Tim Swihart
- if ((m_event.message >> 16) != noErr)
- {
- const int kDILeft = 0x0050; // top coord for disk init dialog
- const int kDITop = 0x0070; // left coord for disk init dialog
- Point mountPoint;
- mountPoint.h = kDILeft;
- mountPoint.v = kDITop;
- int myError = DIBadMount(mountPoint, m_event.message);
- }
-}
-
-void wxApp::doMacOsEvt(void)
-{ // based on "Programming for System 7" by Gary Little and Tim Swihart
- switch ((m_event.message >> 24) & 0x0ff)
- {
- case suspendResumeMessage:
- if (m_event.message & resumeFlag)
- doMacResumeEvent();
- else
- doMacSuspendEvent();
- break;
- case mouseMovedMessage:
- doMacMouseMovedMessage();
- break;
+ bool activate = (ev->modifiers & activeFlag ) ;
+ WindowClass wclass ;
+ UMAGetWindowClass ( window , &wclass ) ;
+ if ( wclass == kFloatingWindowClass )
+ {
+ // if it is a floater we activate/deactivate the front non-floating window instead
+ window = UMAFrontNonFloatingWindow() ;
+ }
+ wxWindow* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacActivate( ev , activate ) ;
}
}
-void wxApp::doMacHighLevelEvent(void)
-{
- ::AEProcessAppleEvent(&m_event); // System 7 or higher
-}
-
-void wxApp::doMacResumeEvent(void)
+void wxApp::MacHandleUpdateEvent( EventRecord *ev )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
+ WindowRef window = (WindowRef) ev->message ;
+ wxWindow * win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
{
- if (m_event.message & convertClipboardFlag)
- ::TEFromScrap();
-
- wxActivateEvent event(wxEVT_ACTIVATE, TRUE);
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
-
- theMacWxFrame->ProcessEvent(event);
+ win->MacUpdate( ev ) ;
}
-}
-
-void wxApp::doMacSuspendEvent(void)
-{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
+ else
{
- ::ZeroScrap();
- ::TEToScrap();
-
- wxActivateEvent event(wxEVT_ACTIVATE, FALSE);
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
-
- theMacWxFrame->ProcessEvent(event);
+ // since there is no way of telling this foreign window to update itself
+ // we have to invalidate the update region otherwise we keep getting the same
+ // event over and over again
+ BeginUpdate( window ) ;
+ EndUpdate( window ) ;
}
}
-void wxApp::doMacMouseMovedMessage(void)
-{ // based on "Programming for System 7" by Gary Little and Tim Swihart
- if (m_cursorRgn)
- ::DisposeRgn(m_cursorRgn);
- m_cursorRgn = ::NewRgn();
- ::SetRectRgn(m_cursorRgn, -32768, -32768, 32766, 32766);
-}
-
-void wxApp::doMacInMenuBar(long menuResult)
+void wxApp::MacHandleDiskEvent( EventRecord *ev )
{
- int macMenuId = HiWord(menuResult);
- int macMenuItemNum = LoWord(menuResult); // counting from 1
-
- if (macMenuId == 0) // no menu item selected;
- return;
- if (macMenuId == 128)
- {
- if (macMenuItemNum != 1)
- { // if not the "About" entry (or the separator)
- Str255 daName;
- ::GetMenuItemText(GetMenuHandle(128), macMenuItemNum, daName);
- (void)::OpenDeskAcc(daName);
- ::HiliteMenu(0);
- return;
- }
- }
+ if ( HiWord( ev->message ) != noErr )
+ {
+ #if !TARGET_CARBON
+ OSErr err ;
+ Point point ;
+ SetPt( &point , 100 , 100 ) ;
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- if ( theMacWxFrame->IsKindOf( CLASSINFO( wxDialog ) ) )
- (( wxDialog *) theMacWxFrame)->MacMenuSelect(m_event, macMenuId, macMenuItemNum);
- else if ( theMacWxFrame->IsKindOf( CLASSINFO( wxFrame ) ) )
- (( wxFrame *) theMacWxFrame)->MacMenuSelect(m_event, macMenuId, macMenuItemNum);
+ err = DIBadMount( point , ev->message ) ;
+ wxASSERT( err == noErr ) ;
+#endif
}
- ::HiliteMenu(0);
}
-void wxApp::doMacInContent(WindowPtr window)
+void wxApp::MacHandleOSEvent( EventRecord *ev )
{
- WindowPtr frontWindow = FrontWindow();
- if (window != frontWindow )
+ switch( ( ev->message & osEvtMessageMask ) >> 24 )
{
-// SFSelectWindow( window ) ;
- }
- else
- {
- ControlHandle control ;
- Point localwhere = m_event.where ;
- GrafPtr port ;
- SInt16 controlpart ;
-
- ::GetPort( &port ) ;
- ::SetPort( window ) ;
- ::GlobalToLocal( &localwhere ) ;
-
- ::SetPort( port ) ;
-
- if ( !gSFMacHasAppearance )
- {
- controlpart = FindControl( localwhere , window , &control ) ;
- }
- else
- {
- control = FindControlUnderMouse( localwhere , window , &controlpart ) ;
- }
-
- if ( control && IsControlActive( control ) )
- {
- wxControl* wxc = (wxControl*) GetControlReference( control ) ;
-
- if ( wxWindow::FindFocus() != wxc && wxc->AcceptsFocus() )
- {
- wxc->SetFocus() ;
- if ( wxWindow::FindFocus() != wxc )
- control = NULL ; // we were not able to change focus
- }
-
- if ( control )
+ case suspendResumeMessage :
{
- if ( !gSFMacHasAppearance)
+ bool isResuming = ev->message & resumeFlag ;
+ bool convertClipboard = ev->message & convertClipboardFlag ;
+ bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
+ if ( isResuming )
{
- controlpart = TrackControl( control , localwhere , NULL ) ;
+ WindowRef oldFrontWindow = NULL ;
+ WindowRef newFrontWindow = NULL ;
+
+ // in case we don't take care of activating ourselves, we have to synchronize
+ // our idea of the active window with the process manager's - which it already activated
+
+ if ( !doesActivate )
+ oldFrontWindow = UMAFrontNonFloatingWindow() ;
+
+ MacResume( convertClipboard ) ;
+
+ newFrontWindow = UMAFrontNonFloatingWindow() ;
+
+ if ( oldFrontWindow )
+ {
+ wxWindow* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
+ if ( win )
+ win->MacActivate( ev , false ) ;
+ }
+ if ( newFrontWindow )
+ {
+ wxWindow* win = wxFindWinFromMacWindow( newFrontWindow ) ;
+ if ( win )
+ win->MacActivate( ev , true ) ;
+ }
}
else
{
- controlpart = HandleControlClick( control , localwhere , m_event.modifiers , (ControlActionUPP) -1 ) ;
- }
-
- if ( controlpart )
- {
- wxControl* wx = (wxControl*) GetControlReference( control ) ;
- if ( wx )
- wx->MacHandleControlClick( control , controlpart ) ;
+ MacSuspend( convertClipboard ) ;
+
+ // in case this suspending did close an active window, another one might
+ // have surfaced -> lets deactivate that one
+
+ WindowRef newActiveWindow = UMAGetActiveNonFloatingWindow() ;
+ if ( newActiveWindow )
+ {
+ wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
+ if ( win )
+ win->MacActivate( ev , false ) ;
+ }
}
}
- }
- else
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
- {
- doMacContentClick((wxFrame*)theMacWxFrame); // todo : this cast is wrong
- }
- }
- }
-
-#if 0
- wxFrame* theMacWxFrame = findMacWxFrame(window);
- if (theMacWxFrame)
- {
- WindowPtr MacWindow = findFrontNonFloatingWindow();
- if (window != MacWindow)
- {
- wxFrame* frontFrame = findMacWxFrame(MacWindow);
- if (!frontFrame) wxFatalError("No wxFrame for frontnonfloatingWindow.");
- if (!frontFrame->IsModal())
+ break ;
+ case mouseMovedMessage :
{
- frontFrame->SetFocus();
- doMacContentClick(theMacWxFrame); // jonto - to deal with doc windows behind floaters ?
- ::newSelectWindow(window); // WCH : should I be calling some wxMethod?
- if (!IsFloating(MacWindow))
+ WindowRef window;
+
+ wxWindow* currentMouseWindow = NULL ;
+
+ wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
+ ¤tMouseWindow ) ;
+
+ if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
{
- KeyMap keyMap;
- GetKeys(keyMap);
- if (!(keyMap[1] & 0x8000)) theMacWxFrame->ShowAsActive(true); // temporary measure...
+ wxMouseEvent event ;
+
+ bool isDown = !(ev->modifiers & btnState) ; // 1 is for up
+ bool controlDown = ev->modifiers & controlKey ; // for simulating right mouse
+
+ event.m_leftDown = isDown && !controlDown;
+ event.m_middleDown = FALSE;
+ event.m_rightDown = isDown && controlDown;
+ event.m_shiftDown = ev->modifiers & shiftKey;
+ event.m_controlDown = ev->modifiers & controlKey;
+ event.m_altDown = ev->modifiers & optionKey;
+ event.m_metaDown = ev->modifiers & cmdKey;
+ event.m_x = ev->where.h;
+ event.m_y = ev->where.v;
+ event.m_timeStamp = ev->when;
+ event.SetEventObject(this);
+
+ if ( wxWindow::s_lastMouseWindow )
+ {
+ wxMouseEvent eventleave(event ) ;
+ eventleave.SetEventType( wxEVT_LEAVE_WINDOW ) ;
+ wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
+ }
+ if ( currentMouseWindow )
+ {
+ wxMouseEvent evententer(event ) ;
+ evententer.SetEventType( wxEVT_ENTER_WINDOW ) ;
+ currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
+ }
+ wxWindow::s_lastMouseWindow = currentMouseWindow ;
}
- } // jonto : not sure yet, but let's try this ...
- else ::SysBeep(3);
- }
- else
- {
- doMacContentClick(theMacWxFrame);
- }
- }
-#endif
-}
-
-void wxApp::doMacContentClick(wxWindow* frame)
-{
- m_mouseWindow = frame;
-
- wxMouseEvent event(wxEVT_LEFT_DOWN);
- event.m_shiftDown = m_event.modifiers & shiftKey;
- event.m_controlDown = m_event.modifiers & controlKey;
- event.m_altDown = m_event.modifiers & optionKey;
- event.m_metaDown = m_event.modifiers & cmdKey;
- event.m_leftDown = FALSE;
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
- if ( m_event.modifiers & controlKey )
- {
- event.m_rightDown = TRUE;
- }
- else
- {
- event.m_leftDown = TRUE;
- }
-#if 0
- event.m_leftDown = !(m_event.modifiers & btnState);
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
-#endif
- event.m_x = m_event.where.h;
- event.m_y = m_event.where.v;
- event.m_timeStamp = m_event.when;
- event.SetEventObject(m_mouseWindow);
-// m_mouseWindow->ProcessEvent(event);
- m_mouseWindow->MacDispatchMouseEvent(event);
-
-#if 0
- // RightButton is cmdKey click on the mac platform for one-button mouse
- Bool rightButton = cCurrentEvent.modifiers & cmdKey;
- // altKey is optionKey on the mac platform:
- Bool isAltKey = cCurrentEvent.modifiers & optionKey;
-
- WXTYPE mouseEventType = rightButton ? wxEVENT_TYPE_RIGHT_DOWN
- : wxEVENT_TYPE_LEFT_DOWN;
- wxMouseEvent theMouseEvent(mouseEventType);
- theMouseEvent.leftDown = !rightButton;
- theMouseEvent.middleDown = FALSE;
- theMouseEvent.rightDown = rightButton;
- theMouseEvent.shiftDown = cCurrentEvent.modifiers & shiftKey;
- theMouseEvent.controlDown = cCurrentEvent.modifiers & controlKey;
- theMouseEvent.altDown = isAltKey;
- theMouseEvent.metaDown = FALSE; // mflatt
- theMouseEvent.timeStamp = cCurrentEvent.when; // mflatt
-
- int hitX = cCurrentEvent.where.h; // screen window c.s.
- int hitY = cCurrentEvent.where.v; // screen window c.s.
-
- frame->ScreenToWindow(&hitX, &hitY);
-// frameParentArea->ScreenToArea(&hitX, &hitY); // tx coords ?
- theMouseEvent.x = hitX; // frame parent area c.s.
- theMouseEvent.y = hitY; // frame parent area c.s.
-
- frame->SeekMouseEventArea(theMouseEvent);
-#endif
-}
+ short windowPart = ::FindWindow(ev->where, &window);
-void wxApp::doMacInDrag(WindowPtr window)
-{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
- {
- // should be desktop, not screen
- Rect dragBoundsRect = qd.screenBits.bounds; // can't move to a different screen
-//xxx ::InsetRect(&dragBoundsRect, 4, ::GetMBarHeight() + 4); // This is not really necessary
- Rect oldPos = (**(((WindowPeek)window)->strucRgn)).rgnBBox;
- ::DragReferencedWindow(window, m_event.where, &dragBoundsRect); // jonto
- #if 0
- theMacWxFrame->m_x += (**(((WindowPeek)window)->strucRgn)).rgnBBox.left - oldPos.left;
- theMacWxFrame->m_y += (**(((WindowPeek)window)->strucRgn)).rgnBBox.top - oldPos.top;
- #endif
- Move( (**(((WindowPeek)window)->strucRgn)).rgnBBox.left , (**(((WindowPeek)window)->strucRgn)).rgnBBox.top ) ;
-#if 0
- theMacWxFrame->wxMacRecalcNewSize(); // Actually, recalc new position only
-#endif
- }
-
-#if 0
-// if (window != ::FrontWindow())
- if (window != findFrontNonFloatingWindow())
- {
-// wxFrame* frontFrame = findMacWxFrame(::FrontWindow());
- wxFrame* frontFrame = findMacWxFrame(findFrontNonFloatingWindow());
- if (!frontFrame) wxFatalError("No wxFrame for frontWindow.");
- if (frontFrame->IsModal())
- {
- ::SysBeep(3);
- return;
- }
- }
+ switch (windowPart)
+ {
+ // fixes for setting the cursor back from dominic mazzoni
+ case inMenuBar :
+ UMAShowArrowCursor();
+ break ;
+ case inSysWindow :
+ UMAShowArrowCursor();
+ break ;
+ default:
+ {
+ if ( s_lastMouseDown == 0 )
+ ev->modifiers |= btnState ;
+
+ wxWindow* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacMouseMoved( ev , windowPart ) ;
+ else
+ UMAShowArrowCursor();
+
+ }
+ break;
+ }
+ }
+ break ;
- wxFrame* theMacWxFrame = findMacWxFrame(window);
- if (theMacWxFrame)
- {
- Rect dragBoundsRect = qd.screenBits.bounds; // can't move to a different screen
- ::InsetRect(&dragBoundsRect, 4, ::GetMBarHeight() + 4); // This is not really necessary
- newDragWindow(window, cCurrentEvent.where, &dragBoundsRect); // jonto
- theMacWxFrame->wxMacRecalcNewSize(); // Actually, recalc new position only
- if (!IsFloating(window))
- {
- theMacWxFrame->ShowAsActive(true); // temporary measure...
- }
}
-#endif
}
-void wxApp::doMacInGrow(WindowPtr window)
+void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
+ if (macMenuId == 0)
+ return; // no menu item selected
+
+ if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
{
- Rect growSizeRect; // WCH: growSizeRect should be a member of wxFrame class
- growSizeRect.top = 1; // minimum window height
- growSizeRect.left = 1; // minimum window width
- growSizeRect.bottom = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
- growSizeRect.right = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
- long windSize = ::GrowWindow(window, m_event.where, &growSizeRect);
- if (windSize != 0)
- {
- int nWidth = LoWord(windSize);
- int nHeight = HiWord(windSize);
- int oWidth, oHeight;
- theMacWxFrame->GetSize(&oWidth, &oHeight);
- if (nWidth == 0) nWidth = oWidth;
- if (nHeight == 0) nHeight = oHeight;
- theMacWxFrame->SetSize( -1, -1, nWidth, nHeight, wxSIZE_USE_EXISTING);
- }
+ #if ! TARGET_CARBON
+ Str255 deskAccessoryName ;
+ GrafPtr savedPort ;
+
+ GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
+ GetPort(&savedPort);
+ OpenDeskAcc(deskAccessoryName);
+ SetPort(savedPort);
+ #endif
}
-}
-
-void wxApp::doMacInGoAway(WindowPtr window)
-{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
+ else
{
- if (TrackGoAway(window, m_event.where))
- {
- if (theMacWxFrame->OnClose()) {
-#if WXGARBAGE_COLLECTION_ON
- theMacWxFrame->Show(FALSE);
-#else
- delete theMacWxFrame;
-#endif
- }
- }
+ wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() ) ;
+ if ( frontwindow && wxMenuBar::MacGetInstalledMenuBar() )
+ wxMenuBar::MacGetInstalledMenuBar()->MacMenuSelect( frontwindow->GetEventHandler() , 0 , macMenuId , macMenuItemNum ) ;
}
+ HiliteMenu(0);
}
-void wxApp::doMacInZoom(WindowPtr window, short windowPart)
+/*
+long wxApp::MacTranslateKey(char key, int mods)
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
- {
- if (TrackBox(window, m_event.where, windowPart))
- {
-#if 0
- theMacWxFrame->Maximize(windowPart == inZoomOut);
-#endif
- }
- }
}
-long wxApp::macTranslateKey(char key, int mods)
+void wxApp::MacAdjustCursor()
{
- static Handle transH = NULL;
- static unsigned long transState = 0;
- static Handle ScriptH = NULL;
- static short region_code = 1;
-
- if (!ScriptH) { // tom: don't guess the regioncode!!!!
- struct ItlbRecord * r;
- ScriptH = GetResource('itlb',0);
- if (ScriptH) {
- HLock(ScriptH);
- r = (ItlbRecord*)*ScriptH;
- region_code = r->itlbKeys;
- HUnlock(ScriptH);
- }
- }
-
- switch (key) {
- case 0x7e:
- case 0x3e:
- key = WXK_UP;
- break;
- case 0x7d:
- case 0x3d:
- key = WXK_DOWN;
- break;
- case 0x7b:
- case 0x3b:
- key = WXK_LEFT;
- break;
- case 0x7c:
- case 0x3c:
- key = WXK_RIGHT;
- break;
- case 0x24:
- case 0x4c:
- key = WXK_RETURN;
- break;
- case 0x30:
- key = WXK_TAB;
- break;
- case 0x33:
- key = WXK_BACK;
- break;
- case 0x75:
- key = WXK_DELETE;
- break;
- case 0x73:
- key = WXK_HOME;
- break;
- case 0x77:
- key = WXK_END;
- break;
- case 0x74:
- key = WXK_PAGEUP;
- break;
- case 0x79:
- key = WXK_PAGEDOWN;
- break;
- default:
- if (!transH) {
- transH = GetIndResource('KCHR', 1);
- HNoPurge(transH);
- }
-#if 0 //Tom replaces
- if (transH) {
- // Only let shift & option modify the key:
- HLock(transH);
- key = KeyTranslate(*transH, (key & 0x7F) | mods, &transState) & charCodeMask;
- HUnlock(transH);
-#else
- if (0) { // tom fettig@dfki.uni-sb.de
- // why if(0):
- // code is not correct, see inside Macintosh: Text 1-87
- // and 'itlk'-resource!!
- // and it is not necessary, as the translated char is in
- // cCurrrentEvent.message!!
- // Only let shift & option modify the key:
- HLock(transH);
- key = KeyTranslate(*transH, (key & 0x7F) | mods, &transState) & charCodeMask;
- HUnlock(transH);
-#endif
- }
- } // end switch
-
- return key;
}
+*/
+/*
void
wxApp::macAdjustCursor()
{
- if (m_event.what != kHighLevelEvent)
+ if (ev->what != kHighLevelEvent)
{
wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
if (theMacWxFrame)
{
- if (!theMacWxFrame->MacAdjustCursor(m_event.where))
+ if (!theMacWxFrame->MacAdjustCursor(ev->where))
::SetCursor(&(qd.arrow));
}
}
}
-*/
\ No newline at end of file
+*/
projects / wxWidgets.git / blobdiff