bool installAEHandlers()
{
OSErr iErr = noErr;
g_lpfnAEProc = NewAEEventHandlerUPP(aplEventHdlr);
if (noErr != (iErr = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, g_lpfnAEProc, FOUR_CHAR_CODE('QUIT'), FALSE)))
{
DisposeAEEventHandlerUPP(g_lpfnAEProc);
fprintf(stderr, "installAEHandlers() - AEInstallEventHandler(kAEQuitApplication) failed, returning %lu!\n", (unsigned long) iErr);
return false;
}
if (noErr != (iErr = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, g_lpfnAEProc, FOUR_CHAR_CODE('OPEN'), FALSE)))
{
AERemoveEventHandler(kCoreEventClass, kAEQuitApplication, g_lpfnAEProc, FALSE);
DisposeAEEventHandlerUPP(g_lpfnAEProc);
fprintf(stderr, "installAEHandlers() - AEInstallEventHandler(kAEOpenDocuments) failed, returning %lu!\n", (unsigned long) iErr);
return false;
}
if (noErr != (iErr = AEInstallEventHandler(kCoreEventClass, kAEShowPreferences, g_lpfnAEProc, FOUR_CHAR_CODE('PREF'), FALSE)))
{
AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, g_lpfnAEProc, FALSE);
AERemoveEventHandler(kCoreEventClass, kAEQuitApplication, g_lpfnAEProc, FALSE);
DisposeAEEventHandlerUPP(g_lpfnAEProc);
fprintf(stderr, "installAEHandlers() - AEInstallEventHandler(kAEShowPreferences) failed, returning %lu!\n", (unsigned long) iErr);
return false;
}
return true;
}
void
setupEventHandler_mac(SRefCon handlerRef)
{
appleEventProcessorUPP = AEEventHandlerUPP(appleEventProcessor);
AEInstallEventHandler(kCoreEventClass, kAEReopenApplication, appleEventProcessorUPP, handlerRef, true);
macCallbackUrlHandlerUPP = AEEventHandlerUPP(macCallbackUrlHandler);
AEInstallEventHandler(kInternetEventClass, kAEGetURL, macCallbackUrlHandlerUPP, handlerRef, false);
}
static void Install(void)
{
short err=0;
err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, NewAEEventHandlerUPP(OpenApplicationStuff), 0, 0);
err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(OpenFinderDoc), 0, 0);
err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerUPP(DoNothing), 0, 0);
err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(SetUpQuitMessage), 0, 0);
err = AEInstallEventHandler('PLT ', 'cmdl', NewAEEventHandlerUPP(CmdLineMessage), 0, 0);
}
static void installhandlers (void) {
AEInstallEventHandler ('TEST', 'smsg', NewAEEventHandlerProc (setmessageverb), 0, false);
AEInstallEventHandler (kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc (handleopenapp), 0, false);
AEInstallEventHandler (kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerProc (handleopen), 0, false);
AEInstallEventHandler (kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerProc (handleprint), 0, false);
AEInstallEventHandler (kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc (handlequit), 0, false);
} /*installhandlers*/
void
unicorn::Application::init()
{
#ifdef Q_OS_MAC
addLibraryPath( applicationDirPath() + "/../plugins" );
#elif defined Q_OS_WIN
addLibraryPath( applicationDirPath() + "/plugins" );
#endif
#ifdef Q_WS_MAC
qt_mac_set_menubar_icons( false );
#endif
CoreApplication::init();
setupHotKeys();
#ifdef __APPLE__
setGetURLEventHandler();
AEEventHandlerUPP urlHandler = NewAEEventHandlerUPP( appleEventHandler );
AEInstallEventHandler( kInternetEventClass, kAEGetURL, urlHandler, 0, false );
setOpenApplicationEventHandler();
AEEventHandlerUPP openHandler = NewAEEventHandlerUPP( appleEventHandler );
AEInstallEventHandler( kCoreEventClass, kAEReopenApplication, openHandler, 0, false );
#endif
#ifdef Q_WS_MAC
#define CSS_PATH "/../Resources/"
#else
#define CSS_PATH "/"
#endif
refreshStyleSheet();
translate();
m_icm = new lastfm::InternetConnectionMonitor( this );
connect( m_icm, SIGNAL( up( QString ) ), this, SIGNAL( internetConnectionUp() ) );
connect( m_icm, SIGNAL( down( QString ) ), this, SIGNAL( internetConnectionDown() ) );
connect( &m_bus, SIGNAL( wizardRunningQuery( QString )), SLOT( onWizardRunningQuery( QString )));
connect( &m_bus, SIGNAL( sessionQuery( QString )), SLOT( onBusSessionQuery( QString )));
connect( &m_bus, SIGNAL( sessionChanged( const QMap<QString, QString>& )), SLOT( onBusSessionChanged( const QMap<QString, QString>& )));
connect( &m_bus, SIGNAL( lovedStateChanged(bool)), SIGNAL( busLovedStateChanged(bool)));
m_bus.board();
#ifdef __APPLE__
setQuitOnLastWindowClosed( false );
#endif
}
void
init_ae()
{
AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
NewAEEventHandlerProc(DoOpenApp), 0L, false);
AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
NewAEEventHandlerProc(DoOpenDocument), 0L, false);
AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
NewAEEventHandlerProc(DoQuitApp), 0L, false);
AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerProc(DoQuitApp), 0L, false);
}
/*
* If we got no arguments install the apple event handlers and our event loop.
*/
void LauncherSetup_md(int argc) {
OSErr err;
AEEventHandlerUPP openDocEventHandler;
AEEventHandlerUPP openAppEventHandler;
char **argv = NULL;
int no = 0;
// If we got more than one argument we were launched from the commandline,
// so don't install any handlers.
if (argc > 1)
return;
if (gInitialized)
return;
gInitialized = true;
// We need to handle open events for the functionality we're looking for.
openDocEventHandler = NewAEEventHandlerUPP((AEEventHandlerProcPtr)OpenDocEventHandler);
openAppEventHandler = NewAEEventHandlerUPP((AEEventHandlerProcPtr)OpenAppEventHandler);
err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, openDocEventHandler, 0, TRUE);
if(err) {
fprintf(stderr, "Error installing open event handler\n");
exit(-1);
}
err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, openAppEventHandler, 0, TRUE);
if(err) {
fprintf(stderr, "Error installing open app handler\n");
exit(-1);
}
// Enter the event loop and handle appleevents. If we were given files to open
// they will appear here.
RunApplicationEventLoop();
if (gRunAppManager) {
// Three arguments -- app name, no file, and null.
argv = (char**)malloc(sizeof(char*) * 3);
no = 0;
argv[no++] = GetWebStartAppName();
argv[no] = NULL;
// Call into our main app.
main(no, argv);
} else {
exit(0);
}
}
// --------------------------------------------------------------------------------------
static pascal OSErr openApplicationAEHandler(const AppleEvent *appleEvent, AppleEvent *reply,
long refcon)
{
#pragma unused (reply, refcon)
OSErr error;
DescType returnedType;
Size actualSize;
error = AEGetAttributePtr(appleEvent, keyMissedKeywordAttr, typeWildCard, &returnedType,
NULL, 0, &actualSize);
if (error == noErr)
error = errAEParamMissed;
else if (error == errAEDescNotFound)
{
EventTypeSpec applicationEvents[] = {
{kEventClassCommand, kEventCommandProcess}
};
/* For our program running in Carbon, a Quit Application Apple Event handler
is unnecessary because RunApplicationEventLoop installs one for us that
calls QuitApplicationEventLoop. However we will leave ours here in case
we ever need it to do something different so that we know where it
belongs. */
gQuitAppAEHandler = NewAEEventHandlerUPP(quitApplicationAEHandler);
error = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, gQuitAppAEHandler,
0, false);
if (error != noErr) // if we can't allow the user a mechanism to quit
{ // we'd better just quit right now
DisposeAEEventHandlerUPP(gOpenAppAEHandler);
DisposeAEEventHandlerUPP(gQuitAppAEHandler);
ExitToShell();
}
gViewsFontChangedAEHandler = NewAEEventHandlerUPP(viewsFontChangedAEHandler);
error = AEInstallEventHandler(kAppearanceEventClass, kAEViewsFontChanged,
gViewsFontChangedAEHandler, 0, false);
gAppEventHandler = NewEventHandlerUPP(appEventHandler);
InstallApplicationEventHandler(gAppEventHandler, GetEventTypeCount(applicationEvents),
applicationEvents, NULL, NULL);
Gestalt(gestaltSystemVersion, &gMacOSVersion); // get the version of Mac OS we're
// running on
InitIconDataBrowser();
error = noErr;
}
return error;
}
int
main( int argc, char *argv[] )
{
#ifdef Q_WS_MAC
// Do Mac specific startup to get media keys working.
// This must go before QApplication initialisation.
Tomahawk::macMain();
// used for url handler
AEEventHandlerUPP h = AEEventHandlerUPP( appleEventHandler );
AEInstallEventHandler( 'GURL', 'GURL', h, 0, false );
#endif
TomahawkApp a( argc, argv );
KDSingleApplicationGuard guard( &a, KDSingleApplicationGuard::AutoKillOtherInstances );
QObject::connect( &guard, SIGNAL( instanceStarted( KDSingleApplicationGuard::Instance ) ), &a, SLOT( instanceStarted( KDSingleApplicationGuard::Instance ) ) );
if ( guard.isPrimaryInstance() )
a.init();
QString locale = QLocale::system().name();
QTranslator translator;
translator.load( QString( ":/lang/tomahawk_" ) + locale );
a.installTranslator( &translator );
if ( argc > 1 )
{
QString arg = a.arguments()[ 1 ];
a.loadUrl( arg );
}
return a.exec();
}
// --------------------------------------------------------------------------------------
static void initialize(void)
{
OSStatus status;
IBNibRef nib;
OSErr error;
RegisterAppearanceClient();
status = CreateNibReference(CFSTR("ExamplePrefs"), &nib);
if (status != noErr)
ExitToShell();
status = SetMenuBarFromNib(nib, CFSTR("MenuBar"));
if (status != noErr)
ExitToShell();
DisposeNibReference(nib);
DrawMenuBar();
// do non time sensitive initialization after we get the application event loop going
gOpenAppAEHandler = NewAEEventHandlerUPP(openApplicationAEHandler);
error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gOpenAppAEHandler, 0,
false);
if (error != noErr)
ExitToShell();
/* If we supported them, we would install open documents and print documents
handlers here and we would do most of the same initialization stuff that we
do in the open application handler */
}
void setUp()
{
Handle menuBar;
OSErr anErr = noErr;
long aLong;
long response;
anErr = Gestalt(gestaltSystemVersion, &response);
// Carbon Porting guidelines say provide alternate menu bar/menu scheme for OS X
// This is just one way of doing this, which is pretty static
if (response >= 0x01000)
menuBar = GetNewMBar(MENU_BAR_IDX);
else
menuBar = GetNewMBar(MENU_BAR_ID);
if ( menuBar == nil || anErr != noErr )
ExitToShell();
SetMenuBar(menuBar);
DisposeHandle(menuBar);
DrawMenuBar();
// Install 'quit' event handler
if ((Gestalt(gestaltAppleEventsAttr, &aLong) == noErr)) {
anErr = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerUPP(AEQuitHandler), 0, false);
if (anErr != noErr)
ExitToShell();
}
}
// --------------------------------------------------------------------------------------
static void initialize(void)
{
MenuBarHandle menuBar;
OSErr error;
/* I doubt we actually need any extra master pointers but I left the call here
as a reminder for where it belongs if it is needed. */
MoreMasterPointers(64); // each call to MoreMasters allocates 64 master pointers
InitCursor();
RegisterAppearanceClient();
menuBar = GetNewMBar(rMenuBar); // draw the menu bar as soon as possible
if (menuBar == NULL)
ExitToShell();
SetMenuBar(menuBar);
DrawMenuBar();
// do non time sensitive initialization after we get the application event loop going
gOpenAppAEHandler = NewAEEventHandlerUPP(openApplicationAEHandler);
error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gOpenAppAEHandler, 0,
false);
if (error != noErr)
ExitToShell();
/* If we supported them, we would install open documents and print documents
handlers here and we would do most of the same initialization stuff that
we do in the open application handler. */
}
static PyObject *AE_AEInstallEventHandler(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSErr _err;
AEEventClass theAEEventClass;
AEEventID theAEEventID;
AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
PyObject *handler;
#ifndef AEInstallEventHandler
PyMac_PRECHECK(AEInstallEventHandler);
#endif
if (!PyArg_ParseTuple(_args, "O&O&O",
PyMac_GetOSType, &theAEEventClass,
PyMac_GetOSType, &theAEEventID,
&handler))
return NULL;
_err = AEInstallEventHandler(theAEEventClass,
theAEEventID,
handler__proc__, (long)handler,
0);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
Py_INCREF(handler); /* XXX leak, but needed */
return _res;
}
int main( int argc, char ** argv )
{
QApplication a( argc, argv );
a.setOrganizationName("sqlitebrowser");
a.setApplicationName("SQLite Database Browser");
// Set character encoding to UTF8
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
// Enable translation
QTranslator translator;
translator.load("qt_" + QLocale::system().name(), QLibraryInfo::location(QLibraryInfo::TranslationsPath));
a.installTranslator(&translator);
QTranslator apptranslator;
apptranslator.load("translations/tr_" + QLocale::system().name());
a.installTranslator(&apptranslator);
MainWindow w;
#if defined(Q_WS_MAC)
AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
NewAEEventHandlerUPP(odocHandler),reinterpret_cast<long>(&w),false);
#endif // Q_WS_MAC
w.show();
if (argc>1) {
//first and only argument we accept is the name of the database to open
w.fileOpen(QString(argv[1]));
}
a.connect( &a, SIGNAL( lastWindowClosed() ), &a, SLOT( quit() ) );
return a.exec();
}
// --------------------------------------------------------------------------------------
static void initialize(void)
{
MenuBarHandle menuBar;
OSErr error;
MoreMasters(); // I doubt we actually need any extra master pointers
InitGraf(&qd.thePort); // but I left the calls here as a reminder for where they
InitFonts(); // belong if they are needed
InitWindows();
InitMenus();
TEInit();
InitDialogs(NULL);
InitCursor();
RegisterAppearanceClient();
menuBar = GetNewMBar(rMenuBar); // draw the menu bar as soon as possible
if (menuBar == NULL)
ExitToShell();
SetMenuBar(menuBar);
DrawMenuBar();
// do non time sensitive initialization after we get the application event loop going
gOpenAppAEHandler = NewAEEventHandlerUPP(openApplicationAEHandler);
error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gOpenAppAEHandler, 0,
false);
if (error != noErr)
ExitToShell();
/* If we supported them, we would install open documents and print documents
handlers here and we would do most of the same initialization stuff that we
do in the open application handler. */
FlushEvents(everyEvent, 0);
}
bool os_initialize( adobe::application_t* theApp )
{
//
// On the Mac we need to install the application menus, respond
// to AppleEvents and set the resource path. We set the resource
// path first.
//
ProcessSerialNumber psn;
ADOBE_REQUIRE_STATUS( GetCurrentProcess( &psn ) );
FSRef location;
ADOBE_REQUIRE_STATUS( GetProcessBundleLocation( &psn, &location ) );
theApp->set_resource_directory( fsref_to_path( location ) / "Contents" / "Resources" );
//
// Now load our bundle, sign up for AppleEvents and show the menu.
//
CFBundleRef bundle = CFBundleGetMainBundle();
IBNibRef nibs = 0;
if( !bundle ) return false;
ADOBE_REQUIRE_STATUS( CreateNibReferenceWithCFBundle( bundle, kMainNibFileName, &nibs ) );
if( !nibs )
{
::CFRelease( bundle );
return false;
}
//
// Sign up to handle the "Open" AppleEvent.
//
static adobe::auto_resource<AEEventHandlerUPP> ae_handler( NewAEEventHandlerUPP( handle_open ) );
AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments, ae_handler.get(), 0, false );
//
// Install the menu, and it's event handler.
//
ADOBE_REQUIRE_STATUS( SetMenuBarFromNib( nibs, kMenuBarNibName ) );
static EventTypeSpec hi_event = { kEventClassCommand, kHICommandFromMenu };
static adobe::auto_resource<EventHandlerUPP> hi_handler( NewEventHandlerUPP( menu_command ) );
InstallApplicationEventHandler( hi_handler.get(), 1, &hi_event, theApp, 0 );
//
// Register this app as an Appearance Client
//
// Apple docs: "This function does nothing on Mac OS X. Do not call it."
//
// RegisterAppearanceClient();
return true;
}
int main( int argc, char** argv )
{
QCoreApplication::setApplicationName( moose::applicationName() );
QCoreApplication::setApplicationVersion( VERSION );
QCoreApplication::setOrganizationName( CoreSettings::organizationName() );
QCoreApplication::setOrganizationDomain( CoreSettings::organizationDomain() );
#ifdef NDEBUG
UniqueApplication uapp( moose::id() );
if (uapp.isAlreadyRunning())
return uapp.forward( argc, argv ) ? 0 : 1;
uapp.init1();
#endif
try
{
App app( argc, argv );
#ifdef NDEBUG
uapp.init2( &app );
app.connect( &uapp, SIGNAL(arguments( QStringList )), SLOT(parseArguments( QStringList )) );
#endif
#ifdef Q_WS_MAC
AEEventHandlerUPP h = NewAEEventHandlerUPP( appleEventHandler );
AEInstallEventHandler( 'GURL', 'GURL', h, 0, false );
//AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, h, 0, false ); //QCoreApplication handles this for us
AEInstallEventHandler( kCoreEventClass, kAEReopenApplication, h, 0, false );
#endif
Container container; gcon = &container;
container.show();
if (!app.arguments().contains( "--tray" ))
container.show();
app.parseArguments( app.arguments() );
return app.exec();
}
catch (unicorn::Application::StubbornUserException&)
{
// user wouldn't log in
return 0;
}
}
Boolean IACinstallhandler (AEEventClass eventclass, AEEventID id, ProcPtr handler) {
OSErr ec;
#if TARGET_API_MAC_CARBON == 1
ec = AEInstallEventHandler (eventclass, id, NewAEEventHandlerUPP ((AEEventHandlerProcPtr) handler), 0, false);
#else
ec = AEInstallEventHandler (eventclass, id, NewAEEventHandlerProc (handler), 0, false);
#endif
IACglobals.errorcode = ec;
return (ec == noErr);
} /*AEinstallhandler*/
void InitAppleEvents(void)
{
OSErr err;
oappUPP = NewAEEventHandlerUPP(AEoapp);
err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, oappUPP, 0L, false);
odocUPP = NewAEEventHandlerUPP(AEodoc);
err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, odocUPP, 0L, false);
pdocUPP = NewAEEventHandlerUPP(AEpdoc);
err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, pdocUPP, 0L, false);
quitUPP = NewAEEventHandlerUPP(AEquit);
err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, quitUPP, 0L, false);
rappUPP = NewAEEventHandlerUPP(AErapp);
err = AEInstallEventHandler(kCoreEventClass, kAEReopenApplication, rappUPP, 0L, false);
}
static void InstallAppleEventHandlers( void )
{
OSErr status;
status = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(HandleAppleEventOdoc), 0, false ); require_noerr( status, CantInstallAppleEventHandler );
// Note: Since RunApplicationEventLoop installs a Quit AE Handler, there is no need to do it here.
CantInstallAppleEventHandler:
return;
}
void Initialize() /* Initialize some managers */
{
OSErr err;
InitCursor();
err = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP((AEEventHandlerProcPtr)QuitAppleEventHandler), 0, false );
if (err != noErr)
ExitToShell();
}
/* ----------- private code */
static void initialize_application(
void)
{
Handle menubar;
StringHandle userName;
#ifndef OP_PLATFORM_MAC_CARBON_FLAG
MaxApplZone();
MoreMasters();
MoreMasters();
MoreMasters();
InitGraf(&qd.thePort);
InitFonts();
InitWindows();
InitMenus();
TEInit();
InitDialogs(NULL);
#else
MoreMasterPointers(192);
#endif // ! OP_PLATFORM_MAC_CARBON_FLAG
InitCursor();
FlushEvents(everyEvent, 0);
menubar= GetNewMBar(rMENU_BAR_ID);
op_assert(menubar);
SetMenuBar(menubar);
DisposeHandle(menubar);
AppendResMenu(GetMenuHandle(mApple), 'DRVR');
DrawMenuBar();
// Get the user name from the systemÉ
userName = GetString (-16096);
if (userName == NULL)
strcpy(gNameString, "OpenPlay Test");
else
{
doCopyP2CStr(*userName,gNameString);
ReleaseResource ((Handle) userName);
}
// ecf - we wanna enable enumeration by default...
check_menu_item(mSpecial, iActiveEnumeration, active_enumeration);
//install apple event handler for quitting
AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,NewAEEventHandlerUPP((AEEventHandlerProcPtr)do_quit_apple_event),0L,false);
return;
}
/* The 10.4 Entry point */
extern "C" OSErr SAInitialize(CFBundleRef b) {
OSErr err=0;
additionBundle=b;
SampleHandlerUPP = NewAEEventHandlerUPP(MyLocalSampleHandler);
for(int i=0;i<gEventDescriptionCount;i++){
err=AEInstallEventHandler( gEventDescriptionList[i].theAEEventClass, gEventDescriptionList[i].theAEEventID, SampleHandlerUPP, gEventDescriptionList[i].refCon, true);
if(err)
return err;
}
return err;
}
void InstallAEHandlers()
{
short err;
AEEventHandlerUPP eventFunc;
eventFunc = &AELoadCartRD;
err = AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,eventFunc,0,false);
if(err) SysBeep(10);
eventFunc = &AEQuitRD;
err = AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,eventFunc,0,false);
if(err) SysBeep(10);
eventFunc = &AEPrintRD;
err = AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,eventFunc,0,false);
if(err) SysBeep(10);
eventFunc = &AEOpenAppRD;
err = AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,eventFunc,0,false);
if(err) SysBeep(10);
}
/* Install event handlers for the Apple Events we care about */
static OSErr install_apple_event_handlers(void) {
OSErr err;
err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
NewAEEventHandlerUPP(OpenApplicationAE), 0, false);
require_noerr(err, CantInstallAppleEventHandler);
err = AEInstallEventHandler(kCoreEventClass, kAEReopenApplication,
NewAEEventHandlerUPP(ReopenApplicationAE), 0, false);
require_noerr(err, CantInstallAppleEventHandler);
err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
NewAEEventHandlerUPP(OpenDocumentsAE), 0, false);
require_noerr(err, CantInstallAppleEventHandler);
err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerUPP(QuitApplicationAE), 0, false);
require_noerr(err, CantInstallAppleEventHandler);
err = AEInstallEventHandler(kCoreEventClass, kAEShowPreferences,
NewAEEventHandlerUPP(ShowPreferencesAE), 0, false);
require_noerr(err, CantInstallAppleEventHandler);
/* some debugging code, for now */
if ( getenv("HOME")!=NULL ) {
char buffer[1024];
#ifdef __VMS
sprintf( buffer, "%s/_FontForge-LogFile.txt", getenv("HOME"));
#else
sprintf( buffer, "%s/.FontForge-LogFile.txt", getenv("HOME"));
#endif
logfile = fopen("/Users/gww/LogFile.txt","w");
}
if ( logfile==NULL )
logfile = stderr;
CantInstallAppleEventHandler:
return err;
}
bool Sys_CreateWindow(const char *title, unsigned int w, unsigned int h, bool fs) {
OSErr result;
ProcessSerialNumber psn;
windowRect.top = 100;
windowRect.left = 100;
windowRect.bottom = windowRect.top + h;
windowRect.right = windowRect.left + w;
g_Window.height = h;
g_Window.width = w;
g_Window.fs = fs;
result = CreateNewWindow(kDocumentWindowClass,
(kWindowStandardDocumentAttributes |
kWindowInWindowMenuAttribute |
kWindowStandardHandlerAttribute) &
~kWindowResizableAttribute,
&windowRect, &g_Window.window);
if (result != noErr)
return false;
SetWindowTitleWithCFString(
g_Window.window,
CFStringCreateWithCString(0, title, CFStringGetSystemEncoding())
);
result = GetCurrentProcess(&psn);
if (result == noErr) {
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
SetFrontProcess(&psn);
}
ShowWindow(g_Window.window);
SelectWindow(g_Window.window);
g_Window.glctx = createContext(g_Window.window);
if (!g_Window.glctx)
return false;
/*
static EventTypeSpec suspendResume[2] = {{kEventClassApplication, kEventAppActivated},
{kEventClassApplication, kEventAppDeactivated}};
InstallApplicationEventHandler(NewEventHandlerUPP(suspendResumeHandler), 2,
suspendResume, &g_Window.window, NULL);
*/
AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerUPP(quitEventHandler), 0, false);
return true;
}
bool wxApp::OnInitGui()
{
if ( !wxAppBase::OnInitGui() )
return false ;
InstallStandardEventHandler( GetApplicationEventTarget() ) ;
if (!sm_isEmbedded)
{
InstallApplicationEventHandler(
GetwxMacAppEventHandlerUPP(),
GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
}
if (!sm_isEmbedded)
{
sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
sODocHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
sOAppHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
sPDocHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
sRAppHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
sQuitHandler , 0 , FALSE ) ;
}
if ( !wxMacInitCocoa() )
return false;
return true ;
}
//---------------------------------------------------------------------------------------------
int main()
{
static const EventTypeSpec sApplicationEvents[] = {{ kEventClassCommand, kEventCommandProcess }};
OSErr err;
if (!SystemVersionRequired(0x1020))
{
DialogRef theAlert;
CreateStandardAlert(kAlertStopAlert, CFSTR("Need 10.2 or later!"), NULL, NULL, &theAlert);
RunStandardAlert(theAlert, NULL, NULL);
return 0;
}
ProcessSerialNumber psn = {0, kCurrentProcess};
err = GetProcessBundleLocation(&psn, &gApplicationBundleFSRef);
err = CreateNibReference(CFSTR("CarbonSketch"), &gOurNibRef );
require_noerr( err, CantGetNibRef );
err = SetMenuBarFromNib( gOurNibRef, CFSTR("MenuBar") );
require_noerr( err, SetMenuBarFromNib_FAILED );
AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, DoOpenApp, 0, false);
AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, DoOpenDocuments, 0, false);
// AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, DoPrintDocuments, 0, false);
InstallApplicationEventHandler( NewEventHandlerUPP(AppEventHandlerProc),
GetEventTypeCount(sApplicationEvents),
sApplicationEvents, 0, NULL );
RunApplicationEventLoop();
SetMenuBarFromNib_FAILED:
DisposeNibReference(gOurNibRef);
CantGetNibRef:
return err;
}
static void
gui_unique_mac_init (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (unique_gimp == NULL);
unique_gimp = gimp;
open_document_callback_proc = NewAEEventHandlerUPP(gui_unique_mac_open_documents);
AEInstallEventHandler (kCoreEventClass, kAEOpenDocuments,
open_document_callback_proc,
0L, TRUE);
}
/*****************************************************
*
* Install_AppleEventHandlers(void)
*
* Purpose: installs the AppleEvent handlers
*
* Inputs: none
*
* Returns: none
*/
static void Install_AppleEventHandlers(void)
{
OSErr status;
status = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, Handle_OpenApplication, 0, false);
require_noerr(status, CantInstallAppleEventHandlerOpenAppl);
status = AEInstallEventHandler(kCoreEventClass, kAEReopenApplication, Handle_ReopenApplication, 0, false);
require_noerr(status, CantInstallAppleEventHandlerReOpenAppl);
status = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, Handle_OpenDocuments, 0, false);
require_noerr(status, CantInstallAppleEventHandlerOpenDocs);
status = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, Handle_PrintDocuments, 0, false);
require_noerr(status, CantInstallAppleEventHandlerPrintDocs);
// Note: Since RunApplicationEventLoop installs a Quit AE Handler, there is no need to do it here.
CantInstallAppleEventHandlerOpenAppl:
CantInstallAppleEventHandlerReOpenAppl:
CantInstallAppleEventHandlerOpenDocs:
CantInstallAppleEventHandlerPrintDocs:
return;
} // Install_AppleEventHandlers