// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "app.h"
#endif
+#include "wx/defs.h"
+
+#include "wx/window.h"
#include "wx/frame.h"
+#include "wx/button.h"
#include "wx/app.h"
#include "wx/utils.h"
#include "wx/gdicmn.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/textctrl.h"
+#include "wx/menu.h"
+#include "wx/docview.h"
#if wxUSE_WX_RESOURCES
-#include "wx/resource.h"
+# include "wx/resource.h"
#endif
#include <string.h>
-extern char *wxBuffer;
-extern wxList wxPendingDelete;
-
-wxApp *wxTheApp = NULL;
+// mac
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
-BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
- EVT_IDLE(wxApp::OnIdle)
-END_EVENT_TABLE()
+#ifndef __DARWIN__
+ #if __option(profile)
+ #include <profiler.h>
+ #endif
#endif
-// platform layer
-
-typedef void * PLEventHandle ;
-
-int PLTestMinimalRequirements() ;
-void PLErrorMessage( int errorCode ) ;
-int PLStartupPhase1() ;
-int PLStartupPhase2() ;
-void PLCleanup() ;
-
-bool PLDoOneEvent() ;
-bool PLHandleOneEvent( PLEventHandle event ) ; // true if really event
-bool PLCallbackIdle() ;
-bool PLCallbackRepeat() ;
+#include "apprsrc.h"
-long wxApp::sm_lastMessageTime = 0;
+#include "wx/mac/uma.h"
+#include "wx/mac/macnotfy.h"
-bool wxApp::Initialize()
-{
- int error = 0 ;
-
- error = PLStartupPhase1() ;
- if ( !error )
- {
- error = PLTestMinimalRequirements() ;
- if ( !error )
- error = PLStartupPhase2() ;
- }
-
- if ( error )
- {
- PLErrorMessage( error ) ;
- return FALSE ;
- }
-
-#ifdef __WXMSW__
- wxBuffer = new char[1500];
+#ifdef __DARWIN__
+# include <CoreServices/CoreServices.h>
+# if defined(WXMAKINGDLL)
+# include <mach-o/dyld.h>
+# endif
#else
- wxBuffer = new char[BUFSIZ + 512];
+# include <Sound.h>
+# include <Threads.h>
+# include <ToolUtils.h>
+# include <DiskInit.h>
+# include <Devices.h>
#endif
-/* No longer used
-#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
-
- streambuf* sBuf = new wxDebugStreamBuf;
- ostream* oStr = new ostream(sBuf) ;
- wxDebugContext::SetStream(oStr, sBuf);
-#endif
-*/
-
- wxClassInfo::InitializeClasses();
+extern wxList wxPendingDelete;
+extern wxList *wxWinMacWindowList;
+extern wxList *wxWinMacControlList;
- wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
- wxTheColourDatabase->Initialize();
+// statics for implementation
- wxInitializeStockLists();
- wxInitializeStockObjects();
+static bool s_inYield = FALSE;
+static bool s_inOnIdle = FALSE;
-#if wxUSE_WX_RESOURCES
- wxInitializeResourceSystem();
+#if TARGET_CARBON
+static bool s_inReceiveEvent = FALSE ;
+static EventTime sleepTime = kEventDurationNoWait ;
+#else
+static long sleepTime = 0 ;
#endif
- wxBitmap::InitStandardHandlers();
-
- wxModule::RegisterModules();
- wxASSERT( wxModule::InitializeModules() == TRUE );
-
- return TRUE;
-}
-
-void wxApp::CleanUp()
-{
- wxModule::CleanUpModules();
+wxApp *wxTheApp = NULL;
-#if wxUSE_WX_RESOURCES
- wxCleanUpResourceSystem();
+#if !USE_SHARED_LIBRARY
+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
- wxDeleteStockObjects() ;
-
- // Destroy all GDI lists, etc.
-
- delete wxTheBrushList;
- wxTheBrushList = NULL;
- delete wxThePenList;
- wxThePenList = NULL;
-
- delete wxTheFontList;
- wxTheFontList = NULL;
-
- delete wxTheBitmapList;
- wxTheBitmapList = NULL;
+const short kMacMinHeap = (29 * 1024) ;
+// platform specific static variables
- delete wxTheColourDatabase;
- wxTheColourDatabase = NULL;
+const short kwxMacMenuBarResource = 1 ;
+const short kwxMacAppleMenuId = 1 ;
- wxBitmap::CleanUpHandlers();
+WXHRGN wxApp::s_macCursorRgn = NULL;
+wxWindow* wxApp::s_captureWindow = NULL ;
+int wxApp::s_lastMouseDown = 0 ;
+long wxApp::sm_lastMessageTime = 0;
+long wxApp::s_lastModifiers = 0 ;
- delete[] wxBuffer;
- wxBuffer = NULL;
- wxClassInfo::CleanUpClasses();
+bool wxApp::s_macDefaultEncodingIsPC = true ;
+bool wxApp::s_macSupportPCMenuShortcuts = true ;
+long wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
+long wxApp::s_macPreferencesMenuItemId = 0 ;
+long wxApp::s_macExitMenuItemId = wxID_EXIT ;
+wxString wxApp::s_macHelpMenuTitleName = "&Help" ;
- 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);
-#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);
+//----------------------------------------------------------------------
+// Core Apple Event Support
+//----------------------------------------------------------------------
- PLCleanup() ;
-}
+pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
+pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
+pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
+pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
-int wxEntry( int argc, char *argv[] )
+pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
- if (!wxApp::Initialize())
- return FALSE;
- if (!wxTheApp)
- {
- if (!wxApp::GetInitializerFunction())
- {
- 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;
- };
-
- wxTheApp->argc = argc;
- wxTheApp->argv = argv;
-
- // GUI-specific initialization, such as creating an app context.
- wxTheApp->OnInitGui();
-
- // 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();
-
- return retValue;
-};
-
-// Static member initialization
-wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
+ return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
+}
-wxApp::wxApp()
+pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
- 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;
+ return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
}
-bool wxApp::Initialized()
+pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
- return TRUE;
-// if (GetTopWindow())
-// return TRUE;
-// else
-// return FALSE;
+ return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
}
-int wxApp::MainLoop()
+pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
{
- m_keepGoing = TRUE;
-
- while (m_keepGoing)
- {
- PLDoOneEvent() ;
- }
-
- return 0;
+ return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
}
-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
- wxIdleEvent event;
- event.SetEventObject(this);
- ProcessEvent(event);
+// AEODoc Calls MacOpenFile on each of the files passed
- return event.MoreRequested();
+short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
+{
+ AEDescList docList;
+ AEKeyword keywd;
+ DescType returnedType;
+ Size actualSize;
+ long itemsInList;
+ FSSpec theSpec;
+ OSErr err;
+ short i;
+ err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
+ if (err != noErr)
+ return err;
+
+ err = AECountItems(&docList, &itemsInList);
+ if (err != noErr)
+ return err;
+
+ ProcessSerialNumber PSN ;
+ PSN.highLongOfPSN = 0 ;
+ PSN.lowLongOfPSN = kCurrentProcess ;
+ SetFrontProcess( &PSN ) ;
+
+ for (i = 1; i <= itemsInList; i++) {
+ AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
+ (Ptr) & theSpec, sizeof(theSpec), &actualSize);
+ wxString fName = wxMacFSSpec2MacFilename(&theSpec);
+ MacOpenFile(fName);
+ }
+ return noErr;
}
-void wxApp::ExitMainLoop()
+// AEPDoc Calls MacPrintFile on each of the files passed
+
+short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
{
- m_keepGoing = FALSE;
+ AEDescList docList;
+ AEKeyword keywd;
+ DescType returnedType;
+ Size actualSize;
+ long itemsInList;
+ FSSpec theSpec;
+ OSErr err;
+ short i;
+ err = AEGetParamDesc((AppleEvent *)event, keyDirectObject, typeAEList,&docList);
+ if (err != noErr)
+ return err;
+
+ err = AECountItems(&docList, &itemsInList);
+ if (err != noErr)
+ return err;
+
+ ProcessSerialNumber PSN ;
+ PSN.highLongOfPSN = 0 ;
+ PSN.lowLongOfPSN = kCurrentProcess ;
+ SetFrontProcess( &PSN ) ;
+
+ for (i = 1; i <= itemsInList; i++) {
+ AEGetNthPtr(&docList, i, typeFSS, &keywd, &returnedType,
+ (Ptr) & theSpec, sizeof(theSpec), &actualSize);
+ wxString fName = wxMacFSSpec2MacFilename(&theSpec);
+ MacPrintFile(fName);
+ }
+ return noErr;
}
-// Is a message/event pending?
-bool wxApp::Pending()
+// AEOApp calls MacNewFile
+
+short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
-/* TODO.
- */
- return FALSE;
+ MacNewFile() ;
+ return noErr ;
}
-// Dispatch a message.
-void wxApp::Dispatch()
+// AEQuit attempts to quite the application
+
+short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
{
-/* TODO.
+ /* wxWindow* win = GetTopWindow() ;
+ if ( win )
+ {
+ win->Close(TRUE ) ;
+ }
+ else
*/
+ {
+ ExitMainLoop() ;
+ }
+ return noErr ;
}
-void wxApp::OnIdle(wxIdleEvent& event)
-{
- static bool inOnIdle = FALSE;
-
- // Avoid recursion (via ProcessEvent default case)
- if (inOnIdle)
- return;
-
- inOnIdle = TRUE;
-
- // 'Garbage' collection of windows deleted with Close().
- DeletePendingObjects();
-
- // flush the logged messages if any
- wxLog *pLog = wxLog::GetActiveTarget();
- if ( pLog != NULL && pLog->HasPendingMessages() )
- pLog->Flush();
-
- // Send OnIdle events to all windows
- bool needMore = SendIdleEvents();
-
- if (needMore)
- event.RequestMore(TRUE);
+//----------------------------------------------------------------------
+// Support Routines linking the Mac...File Calls to the Document Manager
+//----------------------------------------------------------------------
- inOnIdle = FALSE;
+void wxApp::MacOpenFile(const wxString & fileName )
+{
+ wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+ if ( dm )
+ dm->CreateDocument(fileName , wxDOC_SILENT ) ;
}
-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
+void wxApp::MacPrintFile(const wxString & fileName )
{
- bool needMore = FALSE;
- wxNode* node = wxTopLevelWindows.First();
- while (node)
- {
- wxWindow* win = (wxWindow*) node->Data();
- if (SendIdleEvents(win))
- needMore = TRUE;
-
- node = node->Next();
- }
- return needMore;
+ wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+ if ( dm )
+ {
+ wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
+ if ( doc )
+ {
+ wxView* view = doc->GetFirstView() ;
+ if( view )
+ {
+ wxPrintout *printout = view->OnCreatePrintout();
+ if (printout)
+ {
+ wxPrinter printer;
+ printer.Print(view->GetFrame(), printout, TRUE);
+ delete printout;
+ }
+ }
+ if (doc->Close())
+ {
+ doc->DeleteAllViews();
+ dm->RemoveDocument(doc) ;
+ }
+ }
+ }
}
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
+void wxApp::MacNewFile()
{
- bool needMore = FALSE;
+}
- wxIdleEvent event;
- event.SetEventObject(win);
- win->ProcessEvent(event);
+//----------------------------------------------------------------------
+// Carbon Event Handler
+//----------------------------------------------------------------------
- if (event.MoreRequested())
- needMore = TRUE;
+#if TARGET_CARBON
- wxNode* node = win->GetChildren().First();
- while (node)
+ static const EventTypeSpec eventList[] =
{
- wxWindow* win = (wxWindow*) node->Data();
- if (SendIdleEvents(win))
- needMore = TRUE;
-
- node = node->Next();
- }
- return needMore ;
+ { kEventClassCommand, kEventProcessCommand } ,
+ { kEventClassCommand, kEventCommandUpdateStatus } ,
+
+ { kEventClassApplication , kEventAppActivated } ,
+ { kEventClassApplication , kEventAppDeactivated } ,
+ // handling the quit event is not recommended by apple
+ // rather using the quit apple event - which we do
+
+ { kEventClassAppleEvent , kEventAppleEvent } ,
+
+ { kEventClassMouse , kEventMouseDown } ,
+ } ;
+
+static pascal OSStatus MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+ UInt32 kind = GetEventKind( event ) ;
+
+ return result ;
}
-void wxApp::DeletePendingObjects()
+// due to the rather low-level event API of wxWindows, we cannot use RunApplicationEventLoop
+// but have to use ReceiveNextEvent dealing with events manually, therefore we also have
+// deal with clicks in the menu bar explicitely
+
+static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
- wxNode *node = wxPendingDelete.First();
- while (node)
- {
- wxObject *obj = (wxObject *)node->Data();
+ OSStatus result = eventNotHandledErr ;
- delete obj;
+ switch( GetEventKind(event) )
+ {
+ case kEventMouseDown :
+ {
+ Point point ;
+ WindowRef window ;
+
+ GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
+ sizeof( Point ), NULL, &point );
+ short windowPart = ::FindWindow(point, &window);
- if (wxPendingDelete.Member(obj))
- delete node;
+ if ( windowPart == inMenuBar )
+ {
+ MenuSelect( point ) ;
+ result = noErr ;
+ }
+ }
+ break ;
+ }
- // Deleting one object may have deleted other pending
- // objects, so start from beginning of list again.
- node = wxPendingDelete.First();
- }
+ return result ;
}
-wxLog* wxApp::CreateLogTarget()
+static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
- return new wxLogGui;
-}
+ OSStatus result = eventNotHandledErr ;
-wxWindow* wxApp::GetTopWindow() const
-{
- if (m_topWindow)
- return m_topWindow;
- else if (wxTopLevelWindows.Number() > 0)
- return (wxWindow*) wxTopLevelWindows.First()->Data();
- else
- return NULL;
-}
+ HICommand command ;
+
+ GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL,
+ sizeof( HICommand ), NULL, &command );
-void wxExit()
-{
- wxApp::CleanUp();
-/*
- * TODO: Exit in some platform-specific way. Not recommended that the app calls this:
- * only for emergencies.
- */
+ MenuCommand id = command.commandID ;
+ if ( id == kHICommandPreferences )
+ id = wxApp::s_macPreferencesMenuItemId ;
+
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ wxMenu* menu = NULL ;
+ wxMenuItem* item = NULL ;
+
+ if ( mbar )
+ item = mbar->FindItem( id , &menu ) ;
+
+ if ( item == NULL || menu == NULL || mbar == NULL )
+ return result ;
+
+ switch( GetEventKind( event ) )
+ {
+ case kEventProcessCommand :
+ {
+ if (item->IsCheckable())
+ {
+ item->Check( !item->IsChecked() ) ;
+ }
+
+ menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventCommandUpdateStatus:
+ // eventually trigger an updateui round
+ result = noErr ;
+ break ;
+ default :
+ break ;
+ }
+
+ return result ;
}
-// Yield to other processes
-bool wxYield()
+static pascal OSStatus ApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
- /*
- * TODO
- */
- return TRUE;
+ OSStatus result = eventNotHandledErr ;
+ switch ( GetEventKind( event ) )
+ {
+ case kEventAppActivated :
+ {
+ wxTheApp->MacResume( true ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventAppDeactivated :
+ {
+ wxTheApp->MacSuspend( true ) ;
+ result = noErr ;
+ }
+ break ;
+ default :
+ break ;
+ }
+ return result ;
}
-// -------------------------------------------------------------------
-// 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()
+pascal OSStatus wxAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
- return wxTheApp->ProcessIdle() ;
-}
+ OSStatus result = eventNotHandledErr ;
+ switch( GetEventClass( event ) )
+ {
+ case kEventClassCommand :
+ result = CommandEventHandler( handler , event , data ) ;
+ break ;
+ case kEventClassApplication :
+ result = ApplicationEventHandler( handler , event , data ) ;
+ break ;
+ case kEventClassMenu :
+ result = MenuEventHandler( handler , event , data ) ;
+ break ;
+ case kEventClassMouse :
+ result = MouseEventHandler( handler , event , data ) ;
+ break ;
+ case kEventClassAppleEvent :
+ {
+ EventRecord rec ;
+ wxMacConvertEventToRecord( event , &rec ) ;
+ result = AEProcessAppleEvent( &rec ) ;
+ }
+ break ;
+ default :
+ break ;
+ }
-bool PLCallbackRepeat()
-{
- // wxMacProcessSocketEvents() ;
- return false ;
+ return result ;
}
-// 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() ;
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler )
- return 0 ;
-}
+#endif
-// -------------------------------------------------------------------
-// PLStartupPhase2
-// -------------------------------------------------------------------
-// booting the system further until all subsystems are running
-//
-// parameters : none
-// return value : non zero for a implementation specific error code
+#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
+// we know it's there ;-)
+WXIMPORT char std::__throws_bad_alloc ;
+#endif
-int PLStartupPhase2()
+bool wxApp::Initialize()
{
- long total,contig;
+ int error = 0 ;
- ::MaxApplZone();
- for (long i = 1; i <= 4; i++)
- ::MoreMasters();
- PurgeSpace(&total, &contig);
- ::SetCursor( &qd.arrow ) ;
+ // Mac-specific
-#if 0
- InitAEHandlers();
- InitializeAECore() ;
- GUSISetup(GUSIwithInternetSockets);
+ UMAInitToolbox( 4 ) ;
+ SetEventMask( everyEvent ) ;
+ UMAShowWatchCursor() ;
+
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+ // open shared library resources from here since we don't have
+ // __wxinitialize in Mach-O shared libraries
+ wxStAppResource::OpenSharedLibraryResource(NULL);
#endif
- return 0 ;
-}
+#ifndef __DARWIN__
+ // test the minimal configuration necessary
-// -------------------------------------------------------------------
-// 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
+# if !TARGET_CARBON
+ long theSystem ;
+ long theMachine;
-void PLErrorMessage( int error )
-{
- short itemHit;
- Str255 message;
+ if (Gestalt(gestaltMachineType, &theMachine) != noErr)
+ {
+ error = kMacSTRWrongMachine;
+ }
+ else if (theMachine < gestaltMacPlus)
+ {
+ error = kMacSTRWrongMachine;
+ }
+ else if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
+ {
+ error = kMacSTROldSystem ;
+ }
+ else if ( theSystem < 0x0860 )
+ {
+ error = kMacSTROldSystem ;
+ }
+ else if ((long)GetApplLimit() - (long)ApplicationZone() < kMacMinHeap)
+ {
+ error = kMacSTRSmallSize;
+ }
+# endif
+ /*
+ else
+ {
+ if ( !UMAHasAppearance() )
+ {
+ error = kMacSTRNoPre8Yet ;
+ }
+ }
+ */
+#endif
- SetCursor(&qd.arrow);
- GetIndString(message, 128, error);
- ParamText(message, (ConstStr255Param)"\p", (ConstStr255Param)"\p", (ConstStr255Param)"\p");
- itemHit = Alert(129, nil);
-}
+ // if we encountered any problems so far, give the error code and exit immediately
+
+ if ( error )
+ {
+ wxStAppResource resload ;
+ short itemHit;
+ Str255 message;
+
+ GetIndString(message, 128, error);
+ UMAShowArrowCursor() ;
+ ParamText("\pFatal Error", message, (ConstStr255Param)"\p", (ConstStr255Param)"\p");
+ itemHit = Alert(128, nil);
+ return FALSE ;
+ }
-// -------------------------------------------------------------------
-// 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
+#ifndef __DARWIN__
+# if __option(profile)
+ ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
+# endif
+#endif
-void PLCleanup()
-{
- ::PrClose() ;
- if (gMacCursorRgn)
- ::DisposeRgn(gMacCursorRgn);
+#ifndef __DARWIN__
+ // now avoid exceptions thrown for new (bad_alloc)
+ // FIXME CS for some changes outside wxMac does not compile anymore
#if 0
- TerminateAE() ;
+ std::__throws_bad_alloc = 0 ;
#endif
-}
-// -------------------------------------------------------------------
-// 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
+#endif
-int PLTestMinimalRequirements()
-{
- long theSystem ;
- long theMachine;
- long theAppearance ;
+ s_macCursorRgn = ::NewRgn() ;
- if (Gestalt(gestaltMachineType, &theMachine) != noErr)
- {
- return(eWrongMachine);
- }
+ wxClassInfo::InitializeClasses();
- if (theMachine < gestaltMacPlus)
- {
- return(eWrongMachine);
- }
+#if wxUSE_RESOURCES
+// wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
+#endif
- if (Gestalt(gestaltSystemVersion, &theSystem) != noErr )
- {
- return( eOldSystem ) ;
- }
-
- if ( theSystem < 0x0700 )
- {
- return( eOldSystem ) ;
- }
+#if wxUSE_THREADS
+ wxPendingEventsLocker = new wxCriticalSection;
+#endif
- if ((long)GetApplLimit() - (long)ApplicationZone() < kMinHeap)
- {
- return(eSmallSize);
- }
+ wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+ wxTheColourDatabase->Initialize();
- if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
- {
- gMacHasAppearance = true ;
- RegisterAppearanceClient();
- if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
- {
- gMacAppearanceVersion = theAppearance ;
- }
- else
- {
- gMacAppearanceVersion = 0x0100 ;
- }
- }
-
- return 0 ;
-}
+#ifdef __WXDEBUG__
+#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();
-// -------------------------------------------------------------------
-// PLDoOneEvent
-// -------------------------------------------------------------------
-//
-// parameters : none
-// return value : returns true if a real event occured (no null or timeout event)
+ // this will flush the old messages if any
+ delete wxLog::SetActiveTarget(new wxLogStderr);
+#endif // wxUSE_LOG
+#endif
-bool PLDoOneEvent()
-{
- EventRecord event ;
+ wxWinMacWindowList = new wxList(wxKEY_INTEGER);
+ wxWinMacControlList = new wxList(wxKEY_INTEGER);
- long sleepTime = 60;
+ wxInitializeStockLists();
+ wxInitializeStockObjects();
- bool gotEvent = false ;
-
+#if wxUSE_WX_RESOURCES
+ wxInitializeResourceSystem();
+#endif
- if (WaitNextEvent(everyEvent, &event,sleepTime, gMacCursorRgn))
- {
- gotEvent = PLHandleOneEvent( &event );
- }
- else
- {
- PLCallbackIdle();
- }
-
- PLCallbackRepeat() ;
-
- return gotEvent ;
-}
+ wxBitmap::InitStandardHandlers();
-// -------------------------------------------------------------------
-// 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)
+ wxModule::RegisterModules();
+ if (!wxModule::InitializeModules()) {
+ return FALSE;
+ }
-bool PLHandleOneEvent( PLEventHandle event )
-{
- bool realEvent = true ;
+ wxMacCreateNotifierTable() ;
- EventRecord* ev = (EventRecord*) event ;
+ UMAShowArrowCursor() ;
- switch (ev->what)
- {
- case nullEvent:
- DoMacNullEvent( ev ) ;
- realEvent = false ;
- break ;
- case kHighLevelEvent:
- DoMacHighLevelEvent( ev ) ;
- break;
- case mouseDown:
- DoMacMouseDownEvent( ev ) ;
- wxTheApp->ExitMainLoop() ;
- break;
- case mouseUp:
- DoMacMouseUpEvent( ev ) ;
- break;
- case keyDown:
- DoMacKeyDownEvent( ev ) ;
- break;
- case autoKey:
- DoMacAutoKeyEvent( ev ) ;
- break;
- case keyUp:
- DoMacKeyUpEvent( ev ) ;
- break;
- case activateEvt:
- DoMacActivateEvent( ev ) ;
- break;
- case updateEvt:
- DoMacUpdateEvent( ev ) ;
- break;
- case diskEvt:
- DoMacDiskEvent( ev ) ;
- break;
- case osEvt:
- DoMacOSEvent( ev ) ;
- break;
- default:
- break;
- }
- return realEvent ;
+ return TRUE;
}
-// platform specific functions (non PLxxx functions)
-
-void DoMacNullEvent( EventRecord *ev )
+bool wxApp::OnInitGui()
{
+ if( !wxAppBase::OnInitGui() )
+ return false ;
+
+#if TARGET_CARBON
+ InstallStandardEventHandler( GetApplicationEventTarget() ) ;
+
+ InstallApplicationEventHandler(
+ GetwxAppEventHandlerUPP(),
+ GetEventTypeCount(eventList), eventList, wxTheApp, &((EventHandlerRef)wxTheApp->m_macEventHandler));
+#endif
+
+#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerUPP(AEHandleODoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerUPP(AEHandleOApp) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerUPP(AEHandlePDoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerUPP(AEHandleQuit) ,
+ 0 , FALSE ) ;
+#else
+ AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+ NewAEEventHandlerProc(AEHandleODoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+ NewAEEventHandlerProc(AEHandleOApp) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+ NewAEEventHandlerProc(AEHandlePDoc) ,
+ 0 , FALSE ) ;
+ AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+ NewAEEventHandlerProc(AEHandleQuit) ,
+ 0 , FALSE ) ;
+#endif
+
+ return TRUE ;
}
-void DoMacHighLevelEvent( EventRecord *ev )
+void wxApp::CleanUp()
{
+ wxToolTip::RemoveToolTips() ;
+#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
+ wxCleanUpResourceSystem();
+#endif
+
+ wxDeleteStockObjects() ;
+
+ // Destroy all GDI lists, etc.
+ wxDeleteStockLists();
+
+ delete wxTheColourDatabase;
+ wxTheColourDatabase = NULL;
+
+ wxBitmap::CleanUpHandlers();
+
+ wxMacDestroyNotifierTable() ;
+ if (wxWinMacWindowList) {
+ delete wxWinMacWindowList ;
+ }
+ if (wxWinMacControlList) {
+ delete wxWinMacControlList ;
+ }
+ 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 __DARWIN__
+# 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(TRUE) > 0)
+ {
+ wxLogDebug(wxT("There were memory leaks."));
+ wxDebugContext::Dump();
+ wxDebugContext::PrintStatistics();
+ }
+ // wxDebugContext::SetStream(NULL, NULL);
+#endif
+
+#if wxUSE_LOG
+ // do it as the very last thing because everything else can log messages
+ delete wxLog::SetActiveTarget(NULL);
+#endif // wxUSE_LOG
+
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+ // close shared library resources from here since we don't have
+ // __wxterminate in Mach-O shared libraries
+ wxStAppResource::CloseSharedLibraryResource();
+#endif
+
+ UMACleanupToolbox() ;
+ if (s_macCursorRgn) {
+ ::DisposeRgn((RgnHandle)s_macCursorRgn);
+ }
+
+ #if 0
+ TerminateAE() ;
+ #endif
}
-void DoMacMouseDownEvent( EventRecord *ev )
+//----------------------------------------------------------------------
+// wxEntry
+//----------------------------------------------------------------------
+
+// extern variable for shared library resource id
+// need to be able to find it with NSLookupAndBindSymbol
+short gSharedLibraryResource = kResFileNotOpened ;
+
+#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+CFBundleRef gSharedLibraryBundle = NULL;
+#endif /* WXMAKINGDLL && __DARWIN__ */
+
+wxStAppResource::wxStAppResource()
{
+ m_currentRefNum = CurResFile() ;
+ if ( gSharedLibraryResource != kResFileNotOpened )
+ {
+ UseResFile( gSharedLibraryResource ) ;
+ }
}
-void DoMacMouseUpEvent( EventRecord *ev )
+wxStAppResource::~wxStAppResource()
{
+ if ( m_currentRefNum != kResFileNotOpened )
+ {
+ UseResFile( m_currentRefNum ) ;
+ }
}
-void DoMacKeyDownEvent( EventRecord *ev )
+void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
{
+ gSharedLibraryResource = kResFileNotOpened;
+
+#ifdef WXMAKINGDLL
+ if ( initBlock != NULL ) {
+ const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
+ FSSpec *fileSpec = NULL;
+
+ if (theInitBlock->fragLocator.where == kDataForkCFragLocator) {
+ fileSpec = theInitBlock->fragLocator.u.onDisk.fileSpec;
+ }
+ else if (theInitBlock->fragLocator.where == kResourceCFragLocator) {
+ fileSpec = theInitBlock->fragLocator.u.inSegs.fileSpec;
+ }
+
+ if (fileSpec != NULL) {
+ gSharedLibraryResource = FSpOpenResFile(fileSpec, fsRdPerm);
+ }
+ }
+ else {
+#ifdef __DARWIN__
+ // Open the shared library resource file if it is not yet open
+ NSSymbol theSymbol;
+ NSModule theModule;
+ const char *theLibPath;
+
+ gSharedLibraryBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.wxwindows.wxWindows"));
+ if (gSharedLibraryBundle != NULL) {
+ // wxWindows has been bundled into a framework
+ // load the framework resources
+
+ gSharedLibraryResource = CFBundleOpenBundleResourceMap(gSharedLibraryBundle);
+ }
+ else {
+ // wxWindows is a simple dynamic shared library
+ // load the resources from the data fork of a separate resource file
+ char *theResPath;
+ char *theName;
+ char *theExt;
+ FSRef theResRef;
+ OSErr theErr = noErr;
+
+ // get the library path
+ theSymbol = NSLookupAndBindSymbol("_gSharedLibraryResource");
+ theModule = NSModuleForSymbol(theSymbol);
+ theLibPath = NSLibraryNameForModule(theModule);
+
+ wxLogDebug( wxT("wxMac library installation name is '%s'"),
+ theLibPath );
+
+ // allocate copy to replace .dylib.* extension with .rsrc
+ theResPath = strdup(theLibPath);
+ if (theResPath != NULL) {
+ theName = strrchr(theResPath, '/');
+ if (theName == NULL) {
+ // no directory elements in path
+ theName = theResPath;
+ }
+ // find ".dylib" shared library extension
+ theExt = strstr(theName, ".dylib");
+ // overwrite extension with ".rsrc"
+ strcpy(theExt, ".rsrc");
+
+ wxLogDebug( wxT("wxMac resources file name is '%s'"),
+ theResPath );
+
+ theErr = FSPathMakeRef((UInt8 *) theResPath, &theResRef, false);
+ if (theErr != noErr) {
+ // try in current directory (using name only)
+ theErr = FSPathMakeRef((UInt8 *) theName, &theResRef, false);
+ }
+
+ // open the resource file
+ if (theErr == noErr) {
+ theErr = FSOpenResourceFile( &theResRef, 0, NULL, fsRdPerm,
+ &gSharedLibraryResource);
+ }
+ if (theErr != noErr) {
+ wxLogDebug( wxT("unable to open wxMac resource file '%s'"),
+ theResPath );
+ }
+
+ // free duplicated resource file path
+ free(theResPath);
+ }
+ }
+#endif /* __DARWIN__ */
+ }
+#endif /* WXMAKINGDLL */
}
-void DoMacKeyUpEvent( EventRecord *ev )
+void wxStAppResource::CloseSharedLibraryResource()
{
+#ifdef WXMAKINGDLL
+ // Close the shared library resource file
+ if (gSharedLibraryResource != kResFileNotOpened) {
+#ifdef __DARWIN__
+ if (gSharedLibraryBundle != NULL) {
+ CFBundleCloseBundleResourceMap(gSharedLibraryBundle,
+ gSharedLibraryResource);
+ gSharedLibraryBundle = NULL;
+ }
+ else
+#endif /* __DARWIN__ */
+ {
+ CloseResFile(gSharedLibraryResource);
+ }
+ gSharedLibraryResource = kResFileNotOpened;
+ }
+#endif /* WXMAKINGDLL */
}
-void DoMacAutoKeyEvent( EventRecord *ev )
-{
+#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
+
+// for shared libraries we have to manually get the correct resource
+// ref num upon initializing and releasing when terminating, therefore
+// the __wxinitialize and __wxterminate must be used
+
+extern "C" {
+ void __sinit(void); /* (generated by linker) */
+ pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
+ pascal void __terminate(void);
}
-void DoMacActivateEvent( EventRecord *ev )
+pascal OSErr __wxinitialize(const CFragInitBlock *theInitBlock)
{
+ wxStAppResource::OpenSharedLibraryResource( theInitBlock ) ;
+ return __initialize( theInitBlock ) ;
}
-void DoMacUpdateEvent( EventRecord *ev )
+pascal void __wxterminate(void)
{
+ wxStAppResource::CloseSharedLibraryResource() ;
+ __terminate() ;
}
-void DoMacDiskEvent( EventRecord *ev )
+#endif /* WXMAKINGDLL && !__DARWIN__ */
+
+int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char *WXUNUSED(argv)[] )
{
+ return wxApp::Initialize();
}
-void DoMacOSEvent( EventRecord *ev )
+int WXDLLEXPORT wxEntryInitGui()
{
+ return wxTheApp->OnInitGui();
}
-
-
-/*
-
-void wxApp::doMacMouseDown(void)
+void WXDLLEXPORT wxEntryCleanup()
{
- WindowPtr window;
- short windowPart = ::FindWindow(m_event.where, &window);
- if ( windowPart != inMenuBar )
- {
- WindowPtr frontWindow = FrontWindow();
- if (WindowIsModal(frontWindow) && (window != frontWindow))
- SysBeep(1);
- else
- {
- switch (windowPart)
- {
- 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;
- }
-
- }
- }
- else
- {
- doMacInMenuBar(::MenuSelect(m_event.where));
- }
+ wxApp::CleanUp();
}
-void wxApp::doMacMouseUp(void)
+int wxEntry( int argc, char *argv[] , bool enterLoop )
{
- 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.
+#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
-
- 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
+ if (!wxEntryStart(argc, argv)) {
+ return 0;
+ }
+ // create the application object or ensure that one already exists
+ if (!wxTheApp)
+ {
+ // 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.") );
- 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))
- {
- macWxFrame = findMacWxFrame(frontFloatingPtr);
- }
- }
- }
+ wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
+ }
+
+ wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
+
+#ifdef __DARWIN__
+ // Mac OS X passes a process serial number command line argument when
+ // the application is launched from the Finder. This argument must be
+ // removed from the command line arguments before being handled by the
+ // application (otherwise applications would need to handle it)
+
+ if (argc > 1) {
+ if (strncmp(argv[1], "-psn_", 5) == 0) {
+ // assume the argument is always the only one and remove it
+ --argc;
+ }
+ }
+#else
+ argc = 0 ; // currently we don't support files as parameters
#endif
+ // we could try to get the open apple events here to adjust argc and argv better
+
+ wxTheApp->argc = argc;
+ wxTheApp->argv = argv;
+
+ // GUI-specific initialization, such as creating an app context.
+ wxEntryInitGui();
+
+ // Here frames insert themselves automatically
+ // into wxTopLevelWindows by getting created
+ // in OnInit().
+
+ int retValue = 0;
+
+ 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()
+
+ 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();
+
+ wxEntryCleanup();
+
+ return retValue;
}
-void wxApp::doMacKeyDown(void)
-{
- long menuResult = 0 ;
- short keycode ;
- short keychar ;
- keychar = short(m_event.message & charCodeMask);
- keycode = short(m_event.message & keyCodeMask) >> 8 ;
+#if TARGET_CARBON
- // Handle menu accelerators
- if ( gSFMacHasAppearance )
- {
- 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);
- }
- }
- }
- }
- else
- {
- if (GetMenuHandle( kwxMacAppleMenuId ) )
- {
-// menuResult = MDEF_MenuKey(m_event.message, m_event.modifiers , GetMenuHandle( kwxMacAppleMenuId ) );
- }
- else
- {
- if (m_event.modifiers & cmdKey)
- {
- menuResult = MenuKey( keychar ) ;
- }
- }
+bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
+{
+ bool converted = ConvertEventRefToEventRecord( event,rec) ;
+ OSStatus err = noErr ;
+ if ( !converted )
+ {
+ switch( GetEventClass( event ) )
+ {
+ case kEventClassKeyboard :
+ {
+ converted = true ;
+ switch( GetEventKind(event) )
+ {
+ case kEventRawKeyDown :
+ rec->what = keyDown ;
+ break ;
+ case kEventRawKeyRepeat :
+ rec->what = autoKey ;
+ break ;
+ case kEventRawKeyUp :
+ rec->what = keyUp ;
+ break ;
+ case kEventRawKeyModifiersChanged :
+ rec->what = nullEvent ;
+ break ;
+ default :
+ converted = false ;
+ break ;
+ }
+ if ( converted )
+ {
+ UInt32 keyCode ;
+ unsigned char charCode ;
+ UInt32 modifiers ;
+ GetMouse( &rec->where) ;
+
+ err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
+ err = GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
+ err = GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
+ rec->modifiers = modifiers ;
+ rec->message = (keyCode << 8 ) + charCode ;
+ }
+ }
+ break ;
+ case kEventClassTextInput :
+ {
+ switch( GetEventKind( event ) )
+ {
+ case kEventTextInputUnicodeForKeyEvent :
+ {
+ EventRef rawEvent ;
+ err = GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
+ converted = true ;
+ {
+ UInt32 keyCode ;
+ unsigned char charCode ;
+ UInt32 modifiers ;
+ GetMouse( &rec->where) ;
+ rec->what = keyDown ;
+ err = GetEventParameter(rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, 4, NULL, &modifiers);
+ err = GetEventParameter(rawEvent, kEventParamKeyCode, typeUInt32, NULL, 4, NULL, &keyCode);
+ err = GetEventParameter(rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode);
+ rec->modifiers = modifiers ;
+ rec->message = (keyCode << 8 ) + charCode ;
+ }
+ }
+ break ;
+ default :
+ break ;
+ }
+ }
+ break ;
+ }
+ }
- if ( HiWord( menuResult ) )
- {
- doMacInMenuBar( menuResult ) ;
- }
- 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);
- }
- }
- }
+ return converted ;
}
-void wxApp::doMacAutoKey(void)
+/*
+pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
- doMacKeyDown();
+ OSStatus result = eventNotHandledErr ;
+
+ EventRecord rec ;
+ switch ( GetEventClass( event ) )
+ {
+ case kEventClassKeyboard :
+ if ( wxMacConvertEventToRecord( event , &rec ) )
+ {
+ wxTheApp->MacHandleModifierEvents( &rec ) ;
+ wxTheApp->MacHandleOneEvent( &rec ) ;
+ result = noErr ;
+ }
+ break ;
+ case kEventClassTextInput :
+ if ( wxMacConvertEventToRecord( event , &rec ) )
+ {
+ wxTheApp->MacHandleModifierEvents( &rec ) ;
+ wxTheApp->MacHandleOneEvent( &rec ) ;
+ result = noErr ;
+ }
+ break ;
+ default :
+ break ;
+ }
+ return result ;
}
+*/
+#endif
+
+// Static member initialization
+wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
-void wxApp::doMacKeyUp(void)
+wxApp::wxApp()
{
+ m_topWindow = NULL;
+ wxTheApp = this;
+
+#if WXWIN_COMPATIBILITY_2_2
+ m_wantDebugOutput = TRUE;
+#endif
+
+ argc = 0;
+ argv = NULL;
+
+ m_printMode = wxPRINT_WINDOWS;
+ m_auto3D = TRUE;
}
-void wxApp::doMacActivateEvt(void)
+bool wxApp::Initialized()
{
- HighlightAndActivateWindow( (WindowPtr) m_event.message , m_event.modifiers & activeFlag ) ;
+ if (GetTopWindow())
+ return TRUE;
+ else
+ return FALSE;
}
-void wxApp::doMacUpdateEvt(void)
+int wxApp::MainLoop()
{
- WindowPtr theMacWindow = (WindowPtr)(m_event.message);
- ::BeginUpdate(theMacWindow);
-
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(theMacWindow);
- if (theMacWxFrame)
+ m_keepGoing = TRUE;
+
+ while (m_keepGoing)
{
-// 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") ;
- }
-
-// }
+ MacDoOneEvent() ;
}
- ::EndUpdate(theMacWindow);
+ return 0;
}
-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);
- }
-}
+// Returns TRUE if more time is needed.
+bool wxApp::ProcessIdle()
+{
+ wxIdleEvent event;
+ event.SetEventObject(this);
+ ProcessEvent(event);
-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;
- }
+ return event.MoreRequested();
}
-void wxApp::doMacHighLevelEvent(void)
+void wxApp::ExitMainLoop()
{
- ::AEProcessAppleEvent(&m_event); // System 7 or higher
+#if TARGET_CARBON
+ if (s_inReceiveEvent)
+ QuitApplicationEventLoop() ;
+ else
+ m_keepGoing = FALSE;
+#else
+ m_keepGoing = FALSE;
+#endif
}
-void wxApp::doMacResumeEvent(void)
+// Is a message/event pending?
+bool wxApp::Pending()
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- if (m_event.message & convertClipboardFlag)
- ::TEFromScrap();
+#if TARGET_CARBON
+ return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
+#else
+ EventRecord event ;
- wxActivateEvent event(wxEVT_ACTIVATE, TRUE);
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
+ return EventAvail( everyEvent , &event ) ;
+#endif
+}
- theMacWxFrame->ProcessEvent(event);
- }
+// Dispatch a message.
+void wxApp::Dispatch()
+{
+ MacDoOneEvent() ;
}
-void wxApp::doMacSuspendEvent(void)
+void wxApp::OnIdle(wxIdleEvent& event)
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- ::ZeroScrap();
- ::TEToScrap();
+ // Avoid recursion (via ProcessEvent default case)
+ if ( s_inOnIdle )
+ return;
- wxActivateEvent event(wxEVT_ACTIVATE, FALSE);
- event.m_timeStamp = m_event.when;
- event.SetEventObject(theMacWxFrame);
- theMacWxFrame->ProcessEvent(event);
- }
-}
+ s_inOnIdle = TRUE;
-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);
-}
+ // 'Garbage' collection of windows deleted with Close().
+ DeletePendingObjects();
-void wxApp::doMacInMenuBar(long menuResult)
-{
- int macMenuId = HiWord(menuResult);
- int macMenuItemNum = LoWord(menuResult); // counting from 1
+ // flush the logged messages if any
+ wxLog *pLog = wxLog::GetActiveTarget();
+ if ( pLog != NULL && pLog->HasPendingMessages() )
+ pLog->Flush();
- 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;
- }
- }
+ // Send OnIdle events to all windows
+ bool needMore = SendIdleEvents();
- 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);
- }
- ::HiliteMenu(0);
+ if (needMore)
+ event.RequestMore(TRUE);
+
+ // 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 wxApp::doMacInContent(WindowPtr window)
+void wxWakeUpIdle()
{
- WindowPtr frontWindow = FrontWindow();
- if (window != frontWindow )
- {
-// SFSelectWindow( window ) ;
- }
- else
- {
- ControlHandle control ;
- Point localwhere = m_event.where ;
- GrafPtr port ;
- SInt16 controlpart ;
-
- ::GetPort( &port ) ;
- ::SetPort( window ) ;
- ::GlobalToLocal( &localwhere ) ;
+ wxMacWakeUp() ;
+}
- ::SetPort( port ) ;
-
- if ( !gSFMacHasAppearance )
- {
- controlpart = FindControl( localwhere , window , &control ) ;
- }
- else
- {
- control = FindControlUnderMouse( localwhere , window , &controlpart ) ;
- }
+// Send idle event to all top-level windows
+bool wxApp::SendIdleEvents()
+{
+ bool needMore = FALSE;
+ wxNode* node = wxTopLevelWindows.First();
+ while (node)
+ {
+ wxWindow* win = (wxWindow*) node->Data();
+ if (SendIdleEvents(win))
+ needMore = TRUE;
+
+ node = node->Next();
+ }
+ return needMore;
+}
+
+// Send idle event to window and all subwindows
+bool wxApp::SendIdleEvents(wxWindow* win)
+{
+ bool needMore = FALSE;
+
+ wxIdleEvent event;
+ event.SetEventObject(win);
+ win->ProcessEvent(event);
+
+ if (event.MoreRequested())
+ needMore = TRUE;
+
+ wxNode* node = win->GetChildren().First();
+ while (node)
+ {
+ wxWindow* win = (wxWindow*) node->Data();
+ if (SendIdleEvents(win))
+ needMore = TRUE;
+
+ node = node->Next();
+ }
+ return needMore ;
+}
+
+void wxApp::DeletePendingObjects()
+{
+ wxNode *node = wxPendingDelete.First();
+ while (node)
+ {
+ wxObject *obj = (wxObject *)node->Data();
+
+ delete obj;
+
+ if (wxPendingDelete.Member(obj))
+ delete node;
+
+ // Deleting one object may have deleted other pending
+ // objects, so start from beginning of list again.
+ node = wxPendingDelete.First();
+ }
+}
+
+void wxExit()
+{
+ wxLogError(_("Fatal error: exiting"));
+
+ wxApp::CleanUp();
+ ::ExitToShell() ;
+}
+
+void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
+{
+ if (GetTopWindow())
+ GetTopWindow()->Close(TRUE);
+}
+
+// Default behaviour: close the application with prompts. The
+// user can veto the close, and therefore the end session.
+void wxApp::OnQueryEndSession(wxCloseEvent& event)
+{
+ if (GetTopWindow())
+ {
+ if (!GetTopWindow()->Close(!event.CanVeto()))
+ event.Veto(TRUE);
+ }
+}
+
+extern "C" void wxCYield() ;
+void wxCYield()
+{
+ wxYield() ;
+}
+
+// Yield to other processes
+
+bool wxApp::Yield(bool onlyIfNeeded)
+{
+ if (s_inYield)
+ {
+ if ( !onlyIfNeeded )
+ {
+ wxFAIL_MSG( wxT("wxYield called recursively" ) );
+ }
+
+ return FALSE;
+ }
+
+ s_inYield = TRUE;
+
+#if wxUSE_THREADS
+ YieldToAnyThread() ;
+#endif
+ // by definition yield should handle all non-processed events
+#if TARGET_CARBON
+ EventRef theEvent;
+
+ OSStatus status = noErr ;
+ do
+ {
+ s_inReceiveEvent = true ;
+ status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
+ s_inReceiveEvent = false ;
- if ( control && IsControlActive( control ) )
+ if ( status == eventLoopTimedOutErr )
{
- 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 )
- {
- if ( !gSFMacHasAppearance)
- {
- controlpart = TrackControl( control , localwhere , NULL ) ;
- }
- else
- {
- controlpart = HandleControlClick( control , localwhere , m_event.modifiers , (ControlActionUPP) -1 ) ;
- }
-
- if ( controlpart )
- {
- wxControl* wx = (wxControl*) GetControlReference( control ) ;
- if ( wx )
- wx->MacHandleControlClick( control , controlpart ) ;
- }
- }
+ // make sure next time the event loop will trigger idle events
+ sleepTime = kEventDurationNoWait ;
}
- else
+ else if ( status == eventLoopQuitErr )
{
- 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())
- {
- frontFrame->SetFocus();
- doMacContentClick(theMacWxFrame); // jonto - to deal with doc windows behind floaters ?
- ::newSelectWindow(window); // WCH : should I be calling some wxMethod?
- if (!IsFloating(MacWindow))
- {
- KeyMap keyMap;
- GetKeys(keyMap);
- if (!(keyMap[1] & 0x8000)) theMacWxFrame->ShowAsActive(true); // temporary measure...
- }
- } // jonto : not sure yet, but let's try this ...
- else ::SysBeep(3);
+ m_keepGoing = false ;
}
else
{
- doMacContentClick(theMacWxFrame);
+ MacHandleOneEvent( theEvent ) ;
+ ReleaseEvent(theEvent);
}
- }
+ } while( status == noErr ) ;
+#else
+ EventRecord event ;
+
+ // having a larger value here leads to large performance slowdowns
+ // so we cannot give background apps more processor time here
+ // we do so however having a large sleep value in the main event loop
+ long sleepTime = 0 ;
+
+ while ( !IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
+ {
+ MacHandleModifierEvents( &event ) ;
+ MacHandleOneEvent( &event );
+ if ( event.what != kHighLevelEvent )
+ SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v , event.where.h + 1 , event.where.v + 1 ) ;
+ }
+ MacHandleModifierEvents( &event ) ;
#endif
+
+ wxMacProcessNotifierAndPendingEvents() ;
+ s_inYield = FALSE;
+
+ return TRUE;
}
-void wxApp::doMacContentClick(wxWindow* frame)
+// platform specifics
+
+void wxApp::MacSuspend( bool convertClipboard )
{
- m_mouseWindow = frame;
+#if !TARGET_CARBON
+ // we have to deactive the top level windows manually
+
+ wxNode* node = wxTopLevelWindows.First();
+ while (node)
+ {
+ wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
+ win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
+
+ node = node->Next();
+ }
+
+ ::HideFloatingWindows() ;
+#endif
+ s_lastMouseDown = 0 ;
+
+ if( convertClipboard )
+ {
+ MacConvertPrivateToPublicScrap() ;
+ }
+}
+
+extern wxList wxModalDialogs;
+
+void wxApp::MacResume( bool convertClipboard )
+{
+ s_lastMouseDown = 0 ;
+ if( convertClipboard )
+ {
+ MacConvertPublicToPrivateScrap() ;
+ }
- 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 )
+#if !TARGET_CARBON
+ ::ShowFloatingWindows() ;
+ // raise modal dialogs in case a non modal window was selected to activate the app
+
+ wxNode* node = wxModalDialogs.First();
+ while (node)
+ {
+ wxDialog* dialog = (wxDialog *) node->Data();
+ dialog->Raise();
+
+ node = node->Next();
+ }
+#endif
+}
+
+void wxApp::MacConvertPrivateToPublicScrap()
+{
+}
+
+void wxApp::MacConvertPublicToPrivateScrap()
+{
+}
+
+void wxApp::MacDoOneEvent()
+{
+#if TARGET_CARBON
+ EventRef theEvent;
+
+ s_inReceiveEvent = true ;
+ OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
+ s_inReceiveEvent = false ;
+ if ( status == eventLoopTimedOutErr )
+ {
+ if ( wxTheApp->ProcessIdle() )
+ sleepTime = kEventDurationNoWait ;
+ else
+ sleepTime = kEventDurationForever ;
+ }
+ else if ( status == eventLoopQuitErr )
{
- event.m_rightDown = TRUE;
+ m_keepGoing = false ;
}
else
{
- event.m_leftDown = TRUE;
+ MacHandleOneEvent( theEvent ) ;
+ ReleaseEvent(theEvent);
}
-#if 0
- event.m_leftDown = !(m_event.modifiers & btnState);
- event.m_middleDown = FALSE;
- event.m_rightDown = FALSE;
+#else
+ EventRecord event ;
+
+ EventMask eventMask = everyEvent ;
+
+ if (WaitNextEvent(eventMask, &event, sleepTime, (RgnHandle) s_macCursorRgn))
+ {
+ MacHandleModifierEvents( &event ) ;
+ MacHandleOneEvent( &event );
+ }
+ else
+ {
+ MacHandleModifierEvents( &event ) ;
+ // idlers
+ WindowPtr window = ::FrontWindow() ;
+ if ( window )
+ ::IdleControls( window ) ;
+
+ if ( wxTheApp->ProcessIdle() )
+ sleepTime = 0 ;
+ else
+ sleepTime = GetCaretTime() / 2 ;
+ }
+ if ( event.what != kHighLevelEvent )
+ SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v , event.where.h + 1 , event.where.v + 1 ) ;
#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);
+ // repeaters
-// 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);
+ DeletePendingObjects() ;
+ wxMacProcessNotifierAndPendingEvents() ;
+}
+
+void wxApp::MacHandleOneEvent( WXEVENTREF evr )
+{
+#if TARGET_CARBON
+ EventTargetRef theTarget;
+ theTarget = GetEventDispatcherTarget();
+ m_macCurrentEvent = evr ;
+ SendEventToEventTarget ((EventRef) evr , theTarget);
+#else
+ EventRecord* ev = (EventRecord*) evr ;
+ m_macCurrentEvent = ev ;
+
+ wxApp::sm_lastMessageTime = ev->when ;
+
+ switch (ev->what)
+ {
+ case mouseDown:
+ MacHandleMouseDownEvent( ev ) ;
+ if ( ev->modifiers & controlKey )
+ s_lastMouseDown = 2;
+ else
+ s_lastMouseDown = 1;
+ break;
+ case mouseUp:
+ if ( s_lastMouseDown == 2 )
+ {
+ ev->modifiers |= controlKey ;
+ }
+ else
+ {
+ ev->modifiers &= ~controlKey ;
+ }
+ MacHandleMouseUpEvent( ev ) ;
+ s_lastMouseDown = 0;
+ break;
+ case activateEvt:
+ MacHandleActivateEvent( ev ) ;
+ break;
+ case updateEvt:
+ MacHandleUpdateEvent( ev ) ;
+ break;
+ case keyDown:
+ case autoKey:
+ MacHandleKeyDownEvent( ev ) ;
+ break;
+ case keyUp:
+ MacHandleKeyUpEvent( ev ) ;
+ break;
+ case diskEvt:
+ MacHandleDiskEvent( ev ) ;
+ break;
+ case osEvt:
+ MacHandleOSEvent( ev ) ;
+ break;
+ case kHighLevelEvent:
+ MacHandleHighLevelEvent( ev ) ;
+ break;
+ default:
+ break;
+ }
#endif
+ wxMacProcessNotifierAndPendingEvents() ;
}
-void wxApp::doMacInDrag(WindowPtr window)
+#if !TARGET_CARBON
+bool s_macIsInModalLoop = false ;
+
+void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
+ EventRecord* ev = (EventRecord*) evr ;
+ if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
+ {
+ 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_x = ev->where.h;
+ event.m_y = ev->where.v;
+ event.m_timeStamp = ev->when;
+ wxWindow* focus = wxWindow::FindFocus() ;
+ event.SetEventObject(focus);
+
+ if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
+ {
+ event.m_keyCode = WXK_CONTROL ;
+ event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
+ {
+ event.m_keyCode = WXK_SHIFT ;
+ event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
+ {
+ event.m_keyCode = WXK_ALT ;
+ event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+ focus->GetEventHandler()->ProcessEvent( event ) ;
+ }
+ s_lastModifiers = ev->modifiers ;
+ }
+}
+
+void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
+{
+ // we must avoid reentrancy problems when processing high level events eg printing
+ bool former = s_inYield ;
+ s_inYield = TRUE ;
+ EventRecord* ev = (EventRecord*) evr ;
+ ::AEProcessAppleEvent( ev ) ;
+ s_inYield = former ;
+}
+
+void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+ wxToolTip::RemoveToolTips() ;
+
+ WindowRef window;
+ WindowRef frontWindow = ::FrontNonFloatingWindow() ;
+ WindowAttributes frontWindowAttributes = NULL ;
+ if ( frontWindow )
+ ::GetWindowAttributes( frontWindow , &frontWindowAttributes ) ;
+
+ short windowPart = ::FindWindow(ev->where, &window);
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
+ if ( wxPendingDelete.Member(win) )
+ return ;
+
+ BitMap screenBits;
+ GetQDGlobalsScreenBits( &screenBits );
+
+ switch (windowPart)
+ {
+ case inMenuBar :
+ if ( s_macIsInModalLoop )
+ {
+ SysBeep ( 30 ) ;
+ }
+ else
+ {
+ UInt32 menuresult = MenuSelect(ev->where) ;
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
+ s_lastMouseDown = 0;
+ }
+ break ;
+ case inSysWindow :
+ SystemClick( ev , window ) ;
+ s_lastMouseDown = 0;
+ break ;
+ 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 } ;
+ SetPortWindowPort(window) ;
+ 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:
+ {
+ Rect newContentRect ;
+ Rect constraintRect ;
+ constraintRect.top = win->GetMinHeight() ;
+ if ( constraintRect.top == -1 )
+ constraintRect.top = 0 ;
+ constraintRect.left = win->GetMinWidth() ;
+ if ( constraintRect.left == -1 )
+ constraintRect.left = 0 ;
+ constraintRect.right = win->GetMaxWidth() ;
+ if ( constraintRect.right == -1 )
+ constraintRect.right = 32000 ;
+ constraintRect.bottom = win->GetMaxHeight() ;
+ if ( constraintRect.bottom == -1 )
+ constraintRect.bottom = 32000 ;
+
+ Boolean growResult = ResizeWindow( window , ev->where ,
+ &constraintRect , &newContentRect ) ;
+ if ( growResult )
+ {
+ win->SetSize( newContentRect.left , newContentRect.top ,
+ newContentRect.right - newContentRect.left ,
+ newContentRect.bottom - newContentRect.top, 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 ;
+ GrafPtr port ;
+ GetPort( &port ) ;
+ Point pt = { 0, 0 } ;
+ SetPortWindowPort(window) ;
+ LocalToGlobal( &pt ) ;
+ SetPort( port ) ;
+
+ GetWindowPortBounds(window, &tempRect ) ;
+ win->SetSize( pt.h , pt.v , 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 ;
+
+ case inContent :
+ {
+ GrafPtr port ;
+ GetPort( &port ) ;
+ SetPortWindowPort(window) ;
+ SetPort( port ) ;
+ }
+ if ( window != frontWindow && wxTheApp->s_captureWindow == NULL )
+ {
+ if ( s_macIsInModalLoop )
+ {
+ SysBeep ( 30 ) ;
+ }
+ else if ( UMAIsWindowFloating( window ) )
+ {
+ if ( win )
+ win->MacMouseDown( ev , windowPart ) ;
+ }
+ else
+ {
+ if ( win )
+ win->MacMouseDown( ev , windowPart ) ;
+ ::SelectWindow( window ) ;
+ }
+ }
+ else
+ {
+ if ( win )
+ win->MacMouseDown( ev , windowPart ) ;
+ }
+ break ;
+ default:
+ break;
+ }
+}
+
+void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+ WindowRef window;
+
+ short windowPart = inNoWindow ;
+ if ( wxTheApp->s_captureWindow )
{
- // 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
+ window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
+ windowPart = inContent ;
}
-
-#if 0
-// if (window != ::FrontWindow())
- if (window != findFrontNonFloatingWindow())
+ else
{
-// wxFrame* frontFrame = findMacWxFrame(::FrontWindow());
- wxFrame* frontFrame = findMacWxFrame(findFrontNonFloatingWindow());
- if (!frontFrame) wxFatalError("No wxFrame for frontWindow.");
- if (frontFrame->IsModal())
- {
- ::SysBeep(3);
- return;
- }
+ windowPart = ::FindWindow(ev->where, &window) ;
}
- wxFrame* theMacWxFrame = findMacWxFrame(window);
- if (theMacWxFrame)
+ switch (windowPart)
+ {
+ case inMenuBar :
+ break ;
+ case inSysWindow :
+ break ;
+ default:
+ {
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacMouseUp( ev , windowPart ) ;
+ }
+ break;
+ }
+}
+
+#endif
+
+long wxMacTranslateKey(unsigned char key, unsigned char code) ;
+long wxMacTranslateKey(unsigned char key, unsigned char code)
+{
+ long retval = key ;
+ switch (key)
+ {
+ case kHomeCharCode :
+ retval = WXK_HOME;
+ break;
+ case kEnterCharCode :
+ retval = WXK_RETURN;
+ break;
+ case kEndCharCode :
+ retval = WXK_END;
+ break;
+ case kHelpCharCode :
+ retval = WXK_HELP;
+ break;
+ case kBackspaceCharCode :
+ retval = WXK_BACK;
+ break;
+ case kTabCharCode :
+ retval = WXK_TAB;
+ break;
+ case kPageUpCharCode :
+ retval = WXK_PAGEUP;
+ break;
+ case kPageDownCharCode :
+ retval = WXK_PAGEDOWN;
+ break;
+ case kReturnCharCode :
+ retval = WXK_RETURN;
+ break;
+ case kFunctionKeyCharCode :
+ {
+ 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;
+ }
+ }
+ break ;
+ case kEscapeCharCode :
+ retval = WXK_ESCAPE ;
+ break ;
+ case kLeftArrowCharCode :
+ retval = WXK_LEFT ;
+ break ;
+ case kRightArrowCharCode :
+ retval = WXK_RIGHT ;
+ break ;
+ case kUpArrowCharCode :
+ retval = WXK_UP ;
+ break ;
+ case kDownArrowCharCode :
+ retval = WXK_DOWN ;
+ break ;
+ case kDeleteCharCode :
+ retval = WXK_DELETE ;
+ default:
+ break ;
+ } // end switch
+
+ return retval;
+}
+
+#if !TARGET_CARBON
+void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+ wxToolTip::RemoveToolTips() ;
+
+ UInt32 menuresult = UMAMenuEvent(ev) ;
+ if ( HiWord( menuresult ) )
+ {
+ if ( !s_macIsInModalLoop )
+ MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) ) ;
+ }
+ else
+ {
+ wxWindow* focus = wxWindow::FindFocus() ;
+
+ if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
+ {
+ // has not been handled -> perform default
+ wxControl* control = wxDynamicCast( focus , wxControl ) ;
+ if ( control && control->GetMacControl() != NULL )
+ {
+ short keycode ;
+ short keychar ;
+ keychar = short(ev->message & charCodeMask);
+ keycode = short(ev->message & keyCodeMask) >> 8 ;
+ ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
+ }
+ }
+ }
+}
+
+void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+ wxToolTip::RemoveToolTips() ;
+
+ UInt32 menuresult = UMAMenuEvent(ev) ;
+ if ( HiWord( menuresult ) )
+ {
+ }
+ else
+ {
+ MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
+ }
+}
+
+#endif
+
+bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
+{
+ if ( !focus )
+ return false ;
+
+ short keycode ;
+ short keychar ;
+ keychar = short(keymessage & charCodeMask);
+ keycode = short(keymessage & keyCodeMask) >> 8 ;
+
+ if ( modifiers & ( controlKey|shiftKey|optionKey ) )
+ {
+ // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
+ // and look at the character after
+ UInt32 state = 0;
+ UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
+ keychar = short(keyInfo & charCodeMask);
+ keycode = short(keyInfo & keyCodeMask) >> 8 ;
+ }
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
+ long realkeyval = keyval ;
+ if ( keyval == keychar )
{
- 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...
- }
+ // we are not on a special character combo -> pass the real os event-value to EVT_CHAR, but not to EVT_KEY (make upper first)
+ realkeyval = short(keymessage & charCodeMask) ;
+ keyval = wxToupper( keyval ) ;
}
+
+ wxKeyEvent event(wxEVT_KEY_DOWN);
+ bool handled = false ;
+ event.m_shiftDown = modifiers & shiftKey;
+ event.m_controlDown = modifiers & controlKey;
+ event.m_altDown = modifiers & optionKey;
+ event.m_metaDown = modifiers & cmdKey;
+ event.m_keyCode = keyval ;
+
+ event.m_x = wherex;
+ event.m_y = wherey;
+ event.m_timeStamp = when;
+ event.SetEventObject(focus);
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ if ( handled && event.GetSkipped() )
+ handled = false ;
+ if ( !handled )
+ {
+#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->IsTopLevel())
+ break;
+ ancestor = ancestor->GetParent();
+ }
+ }
+#endif // wxUSE_ACCEL
+ }
+ if (!handled)
+ {
+ event.Skip( FALSE ) ;
+ event.SetEventType( wxEVT_CHAR ) ;
+ // raw value again
+ event.m_keyCode = realkeyval ;
+
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ if ( handled && event.GetSkipped() )
+ handled = false ;
+ }
+ if ( !handled &&
+ (keyval == WXK_TAB) &&
+// CS: copied the change below from wxGTK
+// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
+// have this style, yet choose not to process this particular TAB in which
+// case TAB must still work as a navigational character
+#if 0
+ (!focus->HasFlag(wxTE_PROCESS_TAB)) &&
#endif
+ (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 );
+ if ( handled && new_event.GetSkipped() )
+ handled = false ;
+ }
+ // backdoor handler for default return and command escape
+ if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
+ {
+ // if window is not having a focus still testing for default enter or cancel
+ // TODO add the UMA version for ActiveNonFloatingWindow
+ wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
+ if ( focus )
+ {
+ if ( keyval == WXK_RETURN )
+ {
+ wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
+ wxButton);
+ if ( def && def->IsEnabled() )
+ {
+ wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
+ event.SetEventObject(def);
+ def->Command(event);
+ return true ;
+ }
+ }
+ /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
+ else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
+ {
+ wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
+ new_event.SetEventObject( focus );
+ handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ }
+ }
+ }
+ return handled ;
}
-void wxApp::doMacInGrow(WindowPtr window)
+bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
+ if ( !focus )
+ return false ;
+
+ short keycode ;
+ short keychar ;
+ keychar = short(keymessage & charCodeMask);
+ keycode = short(keymessage & keyCodeMask) >> 8 ;
+ if ( modifiers & ( controlKey|shiftKey|optionKey ) )
+ {
+ // control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
+ // and look at the character after
+ UInt32 state = 0;
+ UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
+ keychar = short(keyInfo & charCodeMask);
+ keycode = short(keyInfo & keyCodeMask) >> 8 ;
+ }
+ long keyval = wxMacTranslateKey(keychar, keycode) ;
+
+ if ( keyval == keychar )
{
- 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);
- }
+ keyval = wxToupper( keyval ) ;
}
+ bool handled = false ;
+
+ wxKeyEvent event(wxEVT_KEY_UP);
+ event.m_shiftDown = modifiers & shiftKey;
+ event.m_controlDown = modifiers & controlKey;
+ event.m_altDown = modifiers & optionKey;
+ event.m_metaDown = modifiers & cmdKey;
+ event.m_keyCode = keyval ;
+
+ event.m_x = wherex;
+ event.m_y = wherey;
+ event.m_timeStamp = when;
+ event.SetEventObject(focus);
+ handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+
+ return handled ;
}
-void wxApp::doMacInGoAway(WindowPtr window)
+#if !TARGET_CARBON
+void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
- {
- if (TrackGoAway(window, m_event.where))
- {
- // TODO: Stefan, I think you need to send a wxCloseEvent to the window
- // here. The OnCloseWindow handler will take care of delete the frame
- // if it wishes to (there should be a default wxFrame::OnCloseWindow
- // that destroys the frame).
- if (theMacWxFrame->OnClose()) {
-#if WXGARBAGE_COLLECTION_ON
- theMacWxFrame->Show(FALSE);
-#else
- delete theMacWxFrame;
-#endif
- }
- }
- }
+ EventRecord* ev = (EventRecord*) evr ;
+ WindowRef window = (WindowRef) ev->message ;
+ if ( window )
+ {
+ bool activate = (ev->modifiers & activeFlag ) ;
+ WindowClass wclass ;
+ ::GetWindowClass ( window , &wclass ) ;
+ if ( wclass == kFloatingWindowClass )
+ {
+ // if it is a floater we activate/deactivate the front non-floating window instead
+ window = ::FrontNonFloatingWindow() ;
+ }
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacActivate( ev->when , activate ) ;
+ }
}
-void wxApp::doMacInZoom(WindowPtr window, short windowPart)
+void wxApp::MacHandleUpdateEvent( WXEVENTREF evr )
{
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(window);
- if (theMacWxFrame)
- {
- if (TrackBox(window, m_event.where, windowPart))
- {
-#if 0
- theMacWxFrame->Maximize(windowPart == inZoomOut);
-#endif
- }
- }
+ EventRecord* ev = (EventRecord*) evr ;
+ WindowRef window = (WindowRef) ev->message ;
+ wxTopLevelWindowMac * win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ {
+ if ( !wxPendingDelete.Member(win) )
+ win->MacUpdate( ev->when ) ;
+ }
+ else
+ {
+ // 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 ) ;
+ }
}
-long wxApp::macTranslateKey(char key, int mods)
+void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
{
- static Handle transH = NULL;
- static unsigned long transState = 0;
- static Handle ScriptH = NULL;
- static short region_code = 1;
+ EventRecord* ev = (EventRecord*) evr ;
+ if ( HiWord( ev->message ) != noErr )
+ {
+ OSErr err ;
+ Point point ;
+ SetPt( &point , 100 , 100 ) ;
- 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);
- }
+ err = DIBadMount( point , ev->message ) ;
+ wxASSERT( err == noErr ) ;
}
-
- 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);
+}
+
+void wxApp::MacHandleOSEvent( WXEVENTREF evr )
+{
+ EventRecord* ev = (EventRecord*) evr ;
+ switch( ( ev->message & osEvtMessageMask ) >> 24 )
+ {
+ case suspendResumeMessage :
+ {
+ bool isResuming = ev->message & resumeFlag ;
+ bool convertClipboard = ev->message & convertClipboardFlag ;
+
+ bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
+ if ( isResuming )
+ {
+ 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 = ::FrontNonFloatingWindow() ;
+
+ MacResume( convertClipboard ) ;
+
+ newFrontWindow = ::FrontNonFloatingWindow() ;
+
+ if ( oldFrontWindow )
+ {
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
+ if ( win )
+ win->MacActivate( ev->when , false ) ;
+ }
+ if ( newFrontWindow )
+ {
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
+ if ( win )
+ win->MacActivate( ev->when , true ) ;
+ }
+ }
+ else
+ {
+ MacSuspend( convertClipboard ) ;
+ }
+ }
+ break ;
+ case mouseMovedMessage :
+ {
+ WindowRef window;
+
+ wxWindow* currentMouseWindow = NULL ;
+
+ if (s_captureWindow )
+ {
+ currentMouseWindow = s_captureWindow ;
+ }
+ else
+ {
+ wxWindow::MacGetWindowFromPoint( wxPoint( ev->where.h , ev->where.v ) ,
+ ¤tMouseWindow ) ;
+ }
+
+ if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
+ {
+ 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->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
+ eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
+
+ wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
+ }
+ if ( currentMouseWindow )
+ {
+ wxMouseEvent evententer(event);
+ evententer.SetEventType( wxEVT_ENTER_WINDOW );
+ currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
+ evententer.SetEventObject( currentMouseWindow ) ;
+ currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
+ }
+ wxWindow::s_lastMouseWindow = currentMouseWindow ;
+ }
+
+ short windowPart = inNoWindow ;
+
+ if ( s_captureWindow )
+ {
+ window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
+ windowPart = inContent ;
+ }
+ else
+ {
+ windowPart = ::FindWindow(ev->where, &window);
+ }
+
+ switch (windowPart)
+ {
+ case inContent :
+ {
+ wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
+ if ( win )
+ win->MacMouseMoved( ev , windowPart ) ;
+ else
+ {
+ if ( wxIsBusy() )
+ {
+ }
+ else
+ UMAShowArrowCursor();
+ }
+ }
+ break;
+ default :
+ {
+ if ( wxIsBusy() )
+ {
+ }
+ else
+ UMAShowArrowCursor();
+ }
+ break ;
+ }
+ }
+ break ;
+
+ }
+}
#endif
- }
- } // end switch
-
- return key;
+
+void wxApp::MacHandleMenuCommand( wxUint32 id )
+{
+ wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+ wxMenu* menu = NULL ;
+ wxMenuItem* item = NULL ;
+ if ( mbar )
+ {
+ item = mbar->FindItem( id , &menu ) ;
+ }
+ wxCHECK_RET( item != NULL && menu != NULL && mbar != NULL, wxT("error in menu item callback") );
+
+ if (item->IsCheckable())
+ {
+ item->Check( !item->IsChecked() ) ;
+ }
+
+ menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
}
-void
-wxApp::macAdjustCursor()
+#if !TARGET_CARBON
+void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
{
- if (m_event.what != kHighLevelEvent)
- {
- wxWindow* theMacWxFrame = wxFrame::MacFindFrameOrDialog(::FrontWindow());
- if (theMacWxFrame)
- {
- if (!theMacWxFrame->MacAdjustCursor(m_event.where))
- ::SetCursor(&(qd.arrow));
- }
- }
+ if (macMenuId == 0)
+ return; // no menu item selected
+
+ if (macMenuId == kwxMacAppleMenuId && macMenuItemNum > 1)
+ {
+ #if ! TARGET_CARBON
+ Str255 deskAccessoryName ;
+ GrafPtr savedPort ;
+
+ GetMenuItemText(GetMenuHandle(kwxMacAppleMenuId), macMenuItemNum, deskAccessoryName);
+ GetPort(&savedPort);
+ OpenDeskAcc(deskAccessoryName);
+ SetPort(savedPort);
+ #endif
+ }
+ else
+ {
+ MenuCommand id ;
+ GetMenuItemCommandID( GetMenuHandle(macMenuId) , macMenuItemNum , &id ) ;
+ MacHandleMenuCommand( id ) ;
+ }
+ HiliteMenu(0);
}
-*/
\ No newline at end of file
+#endif
\ No newline at end of file
projects / wxWidgets.git / blobdiff